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.blend_recipes:
              return postquery_parts
  
          for blend_recipe, blend_type, blend_criteria in \
              zip(self.blend_recipes,
                  self.blend_types,
                  self.blend_criteria):
              join_base, join_blend = blend_criteria
  
              blend_subq = blend_recipe.subquery()
  
              # For all metrics in the blend recipe
              # Use the metric in the base recipe and
              # Add the metric columns to the base recipe
              for m in blend_recipe.metric_ids:
                  met = blend_recipe._cauldron[m]
                  self.recipe._cauldron.use(met)
                  for suffix in met.make_column_suffixes():
                      col = getattr(blend_subq.c, met.id, None)
                      if col is not None:
                          postquery_parts['query'] = postquery_parts[
                              'query'
                          ].add_columns(col.label(met.id + suffix))
                      else:
                          raise BadRecipe(
                              '{} could not be found in .blend() '
                              'recipe subquery'.format(id + suffix)
                          )
  
              # For all dimensions in the blend recipe
              # Use the dimension in the base recipe and
              # Add the dimension columns and group_by to the base recipe
              # Ignore the join_blend dimension
              for d in blend_recipe.dimension_ids:
                  if d == join_blend:
                      continue
                  dim = blend_recipe._cauldron[d]
                  self.recipe._cauldron.use(dim)
                  for suffix in dim.make_column_suffixes():
                      col = getattr(blend_subq.c, dim.id, None)
                      if col is not None:
                          postquery_parts['query'] = postquery_parts[
                              'query'
                          ].add_columns(col.label(dim.id + suffix))
                          postquery_parts['query'] = postquery_parts[
                              'query'
                          ].group_by(col)
                      else:
                          raise BadRecipe(
                              '{} could not be found in .blend() '
                              'recipe subquery'.format(id + suffix)
                          )
  
              base_dim = self.recipe._cauldron[join_base]
              blend_dim = blend_recipe._cauldron[join_blend]
  
              base_col = base_dim.columns[0]
              blend_col = getattr(blend_subq.c, blend_dim.id_prop, None)
              if blend_col is None:
                  raise BadRecipe(
                      'Can\'t find join property for {} dimension in \
                          blend recipe'.format(blend_dim.id_prop)
                  )
  
              if blend_type == 'outer':
                  postquery_parts['query'] = postquery_parts['query'] \
                      .outerjoin(blend_subq, base_col == blend_col)
              else:
                  postquery_parts['query'] = postquery_parts['query'] \
                      .join(blend_subq, base_col == blend_col)
  
          return postquery_parts