docs: def modify_postquery_parts(self, postquery_parts):
          """Make the comparison recipe a subquery that is left joined to the
          base recipe using dimensions that are shared between the recipes.
  
          Hoist the metric from the comparison recipe up to the base query
          while adding the suffix.
  
          """
          if not self.compare_recipe:
              return postquery_parts
  
          for compare_recipe, compare_suffix in zip(
              self.compare_recipe, self.suffix
          ):
              comparison_subq = compare_recipe.subquery()
  
              # For all metrics in the comparison recipe
              # Use the metric in the base recipe and
              # Add the metric columns to the base recipe
  
              # Comparison metrics hoisted into the base recipe need an
              # aggregation function.The default is func.avg but
              # metrics can override this by provoding a
              # metric.meta.summary_aggregation callable parameter
              for m in compare_recipe.metric_ids:
                  met = compare_recipe._cauldron[m]
                  id = met.id
                  met.id = id + compare_suffix
                  summary_aggregation = met.meta.get(
                      'summary_aggregation', func.avg
                  )
                  self.recipe._cauldron.use(met)
                  for suffix in met.make_column_suffixes():
                      col = getattr(comparison_subq.c, id + suffix, None)
                      if col is not None:
                          postquery_parts['query'] = \
                              postquery_parts['query'].add_columns(
                                  summary_aggregation(col).label(
                                      met.id + suffix))
                      else:
                          raise BadRecipe(
                              '{} could not be found in .compare() '
                              'recipe subquery'.format(id + suffix)
                          )
  
              join_conditions = []
              for dim in compare_recipe.dimension_ids:
                  if dim not in self.recipe.dimension_ids:
                      raise BadRecipe(
                          '{} dimension in comparison recipe must exist '
                          'in base recipe'
                      )
                  base_dim = self.recipe._cauldron[dim]
                  compare_dim = compare_recipe._cauldron[dim]
                  base_col = base_dim.columns[0]
                  compare_col = getattr(
                      comparison_subq.c, compare_dim.id_prop, None
                  )
                  if compare_col is None:
                      raise BadRecipe(
                          'Can\'t find join property for {} dimension in \
                          compare recipe'.format(compare_dim.id_prop)
                      )
                  join_conditions.append(base_col == compare_col)
  
              join_clause = text('1=1')
              if join_conditions:
                  join_clause = and_(*join_conditions)
  
              postquery_parts['query'] = postquery_parts['query'] \
                  .outerjoin(comparison_subq, join_clause)
  
          return postquery_parts