appendinfo.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/appendinfo.h"
#include "parser/parsetree.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for appendinfo.c:

Go to the source code of this file.

Data Structures
struct	adjust_appendrel_attrs_context

Functions
static void	make_inh_translation_list (Relation oldrelation, Relation newrelation, Index newvarno, AppendRelInfo *appinfo)
static Node *	adjust_appendrel_attrs_mutator (Node *node, adjust_appendrel_attrs_context *context)
static List *	adjust_inherited_tlist (List *tlist, AppendRelInfo *context)
AppendRelInfo *	make_append_rel_info (Relation parentrel, Relation childrel, Index parentRTindex, Index childRTindex)
Node *	adjust_appendrel_attrs (PlannerInfo *root, Node *node, int nappinfos, AppendRelInfo **appinfos)
Node *	adjust_appendrel_attrs_multilevel (PlannerInfo *root, Node *node, Relids child_relids, Relids top_parent_relids)
Relids	adjust_child_relids (Relids relids, int nappinfos, AppendRelInfo **appinfos)
Relids	adjust_child_relids_multilevel (PlannerInfo *root, Relids relids, Relids child_relids, Relids top_parent_relids)
AppendRelInfo **	find_appinfos_by_relids (PlannerInfo *root, Relids relids, int *nappinfos)

Function Documentation

adjust_appendrel_attrs()

Node* adjust_appendrel_attrs	(	PlannerInfo *	root,
		Node *	node,
		int	nappinfos,
		AppendRelInfo **	appinfos
	)

Definition at line 194 of file appendinfo.c.

References adjust_appendrel_attrs_mutator(), adjust_inherited_tlist(), adjust_appendrel_attrs_context::appinfos, Assert, AppendRelInfo::child_relid, CMD_UPDATE, Query::commandType, IsA, adjust_appendrel_attrs_context::nappinfos, AppendRelInfo::parent_relid, QTW_IGNORE_RC_SUBQUERIES, query_tree_mutator(), Query::resultRelation, adjust_appendrel_attrs_context::root, and Query::targetList.

Referenced by add_child_join_rel_equivalences(), add_child_rel_equivalences(), adjust_appendrel_attrs_multilevel(), apply_child_basequals(), apply_scanjoin_target_to_paths(), build_child_join_rel(), build_child_join_reltarget(), build_child_join_sjinfo(), create_partitionwise_grouping_paths(), inheritance_planner(), make_partitionedrel_pruneinfo(), set_append_rel_size(), and try_partitionwise_join().

{
    Node       *result;
    adjust_appendrel_attrs_context context;

    context.root = root;
    context.nappinfos = nappinfos;
    context.appinfos = appinfos;

    /* If there's nothing to adjust, don't call this function. */
    Assert(nappinfos >= 1 && appinfos != NULL);

    /*
     * Must be prepared to start with a Query or a bare expression tree.
     */
    if (node && IsA(node, Query))
    {
        Query      *newnode;
        int         cnt;

        newnode = query_tree_mutator((Query *) node,
                                     adjust_appendrel_attrs_mutator,
                                     (void *) &context,
                                     QTW_IGNORE_RC_SUBQUERIES);
        for (cnt = 0; cnt < nappinfos; cnt++)
        {
            AppendRelInfo *appinfo = appinfos[cnt];

            if (newnode->resultRelation == appinfo->parent_relid)
            {
                newnode->resultRelation = appinfo->child_relid;
                /* Fix tlist resnos too, if it's inherited UPDATE */
                if (newnode->commandType == CMD_UPDATE)
                    newnode->targetList =
                        adjust_inherited_tlist(newnode->targetList,
                                               appinfo);
                break;
            }
        }

        result = (Node *) newnode;
    }
    else
        result = adjust_appendrel_attrs_mutator(node, &context);

    return result;
}

adjust_appendrel_attrs_multilevel()

Node* adjust_appendrel_attrs_multilevel	(	PlannerInfo *	root,
		Node *	node,
		Relids	child_relids,
		Relids	top_parent_relids
	)

Definition at line 497 of file appendinfo.c.

References adjust_appendrel_attrs(), adjust_appendrel_attrs_multilevel(), Assert, bms_add_member(), bms_equal(), bms_num_members(), find_appinfos_by_relids(), AppendRelInfo::parent_relid, and pfree().

Referenced by add_child_join_rel_equivalences(), add_child_rel_equivalences(), adjust_appendrel_attrs_multilevel(), generate_join_implied_equalities_broken(), and make_partitionedrel_pruneinfo().

{
    AppendRelInfo **appinfos;
    Bitmapset  *parent_relids = NULL;
    int         nappinfos;
    int         cnt;

    Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids));

    appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);

    /* Construct relids set for the immediate parent of given child. */
    for (cnt = 0; cnt < nappinfos; cnt++)
    {
        AppendRelInfo *appinfo = appinfos[cnt];

        parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
    }

    /* Recurse if immediate parent is not the top parent. */
    if (!bms_equal(parent_relids, top_parent_relids))
        node = adjust_appendrel_attrs_multilevel(root, node, parent_relids,
                                                 top_parent_relids);

    /* Now translate for this child */
    node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);

    pfree(appinfos);

    return node;
}

adjust_appendrel_attrs_mutator()

static Node * adjust_appendrel_attrs_mutator ( Node *  node, adjust_appendrel_attrs_context *  context  )

static

Definition at line 244 of file appendinfo.c.

References adjust_child_relids(), adjust_appendrel_attrs_context::appinfos, ConvertRowtypeExpr::arg, RowExpr::args, Assert, AppendRelInfo::child_relid, AppendRelInfo::child_reltype, RestrictInfo::clause, RestrictInfo::clause_relids, COERCE_IMPLICIT_CAST, Alias::colnames, RowExpr::colnames, ConvertRowtypeExpr::convertformat, copyObject, CurrentOfExpr::cvarno, elog, RangeTblEntry::eref, ERROR, RestrictInfo::eval_cost, expression_tree_mutator(), get_rel_name(), IsA, RestrictInfo::left_bucketsize, RestrictInfo::left_em, RestrictInfo::left_mcvfreq, RestrictInfo::left_relids, list_length(), list_nth(), ConvertRowtypeExpr::location, RowExpr::location, makeNode, adjust_appendrel_attrs_context::nappinfos, NIL, RestrictInfo::norm_selec, RestrictInfo::nullable_relids, OidIsValid, RestrictInfo::orclause, RestrictInfo::outer_relids, RestrictInfo::outer_selec, AppendRelInfo::parent_relid, AppendRelInfo::parent_reloid, AppendRelInfo::parent_reltype, PlannerInfo::parse, PlaceHolderVar::phlevelsup, PlaceHolderVar::phrels, RestrictInfo::required_relids, ConvertRowtypeExpr::resulttype, RestrictInfo::right_bucketsize, RestrictInfo::right_em, RestrictInfo::right_mcvfreq, RestrictInfo::right_relids, adjust_appendrel_attrs_context::root, RowExpr::row_format, RowExpr::row_typeid, rt_fetch, Query::rtable, RangeTblRef::rtindex, JoinExpr::rtindex, RestrictInfo::scansel_cache, QualCost::startup, AppendRelInfo::translated_vars, Var::varattno, Var::varlevelsup, Var::varno, Var::varnoold, and Var::vartype.

Referenced by adjust_appendrel_attrs().

{
    AppendRelInfo **appinfos = context->appinfos;
    int         nappinfos = context->nappinfos;
    int         cnt;

    if (node == NULL)
        return NULL;
    if (IsA(node, Var))
    {
        Var        *var = (Var *) copyObject(node);
        AppendRelInfo *appinfo = NULL;

        for (cnt = 0; cnt < nappinfos; cnt++)
        {
            if (var->varno == appinfos[cnt]->parent_relid)
            {
                appinfo = appinfos[cnt];
                break;
            }
        }

        if (var->varlevelsup == 0 && appinfo)
        {
            var->varno = appinfo->child_relid;
            var->varnoold = appinfo->child_relid;
            if (var->varattno > 0)
            {
                Node       *newnode;

                if (var->varattno > list_length(appinfo->translated_vars))
                    elog(ERROR, "attribute %d of relation \"%s\" does not exist",
                         var->varattno, get_rel_name(appinfo->parent_reloid));
                newnode = copyObject(list_nth(appinfo->translated_vars,
                                              var->varattno - 1));
                if (newnode == NULL)
                    elog(ERROR, "attribute %d of relation \"%s\" does not exist",
                         var->varattno, get_rel_name(appinfo->parent_reloid));
                return newnode;
            }
            else if (var->varattno == 0)
            {
                /*
                 * Whole-row Var: if we are dealing with named rowtypes, we
                 * can use a whole-row Var for the child table plus a coercion
                 * step to convert the tuple layout to the parent's rowtype.
                 * Otherwise we have to generate a RowExpr.
                 */
                if (OidIsValid(appinfo->child_reltype))
                {
                    Assert(var->vartype == appinfo->parent_reltype);
                    if (appinfo->parent_reltype != appinfo->child_reltype)
                    {
                        ConvertRowtypeExpr *r = makeNode(ConvertRowtypeExpr);

                        r->arg = (Expr *) var;
                        r->resulttype = appinfo->parent_reltype;
                        r->convertformat = COERCE_IMPLICIT_CAST;
                        r->location = -1;
                        /* Make sure the Var node has the right type ID, too */
                        var->vartype = appinfo->child_reltype;
                        return (Node *) r;
                    }
                }
                else
                {
                    /*
                     * Build a RowExpr containing the translated variables.
                     *
                     * In practice var->vartype will always be RECORDOID here,
                     * so we need to come up with some suitable column names.
                     * We use the parent RTE's column names.
                     *
                     * Note: we can't get here for inheritance cases, so there
                     * is no need to worry that translated_vars might contain
                     * some dummy NULLs.
                     */
                    RowExpr    *rowexpr;
                    List       *fields;
                    RangeTblEntry *rte;

                    rte = rt_fetch(appinfo->parent_relid,
                                   context->root->parse->rtable);
                    fields = copyObject(appinfo->translated_vars);
                    rowexpr = makeNode(RowExpr);
                    rowexpr->args = fields;
                    rowexpr->row_typeid = var->vartype;
                    rowexpr->row_format = COERCE_IMPLICIT_CAST;
                    rowexpr->colnames = copyObject(rte->eref->colnames);
                    rowexpr->location = -1;

                    return (Node *) rowexpr;
                }
            }
            /* system attributes don't need any other translation */
        }
        return (Node *) var;
    }
    if (IsA(node, CurrentOfExpr))
    {
        CurrentOfExpr *cexpr = (CurrentOfExpr *) copyObject(node);

        for (cnt = 0; cnt < nappinfos; cnt++)
        {
            AppendRelInfo *appinfo = appinfos[cnt];

            if (cexpr->cvarno == appinfo->parent_relid)
            {
                cexpr->cvarno = appinfo->child_relid;
                break;
            }
        }
        return (Node *) cexpr;
    }
    if (IsA(node, RangeTblRef))
    {
        RangeTblRef *rtr = (RangeTblRef *) copyObject(node);

        for (cnt = 0; cnt < nappinfos; cnt++)
        {
            AppendRelInfo *appinfo = appinfos[cnt];

            if (rtr->rtindex == appinfo->parent_relid)
            {
                rtr->rtindex = appinfo->child_relid;
                break;
            }
        }
        return (Node *) rtr;
    }
    if (IsA(node, JoinExpr))
    {
        /* Copy the JoinExpr node with correct mutation of subnodes */
        JoinExpr   *j;
        AppendRelInfo *appinfo;

        j = (JoinExpr *) expression_tree_mutator(node,
                                                 adjust_appendrel_attrs_mutator,
                                                 (void *) context);
        /* now fix JoinExpr's rtindex (probably never happens) */
        for (cnt = 0; cnt < nappinfos; cnt++)
        {
            appinfo = appinfos[cnt];

            if (j->rtindex == appinfo->parent_relid)
            {
                j->rtindex = appinfo->child_relid;
                break;
            }
        }
        return (Node *) j;
    }
    if (IsA(node, PlaceHolderVar))
    {
        /* Copy the PlaceHolderVar node with correct mutation of subnodes */
        PlaceHolderVar *phv;

        phv = (PlaceHolderVar *) expression_tree_mutator(node,
                                                         adjust_appendrel_attrs_mutator,
                                                         (void *) context);
        /* now fix PlaceHolderVar's relid sets */
        if (phv->phlevelsup == 0)
            phv->phrels = adjust_child_relids(phv->phrels, context->nappinfos,
                                              context->appinfos);
        return (Node *) phv;
    }
    /* Shouldn't need to handle planner auxiliary nodes here */
    Assert(!IsA(node, SpecialJoinInfo));
    Assert(!IsA(node, AppendRelInfo));
    Assert(!IsA(node, PlaceHolderInfo));
    Assert(!IsA(node, MinMaxAggInfo));

    /*
     * We have to process RestrictInfo nodes specially.  (Note: although
     * set_append_rel_pathlist will hide RestrictInfos in the parent's
     * baserestrictinfo list from us, it doesn't hide those in joininfo.)
     */
    if (IsA(node, RestrictInfo))
    {
        RestrictInfo *oldinfo = (RestrictInfo *) node;
        RestrictInfo *newinfo = makeNode(RestrictInfo);

        /* Copy all flat-copiable fields */
        memcpy(newinfo, oldinfo, sizeof(RestrictInfo));

        /* Recursively fix the clause itself */
        newinfo->clause = (Expr *)
            adjust_appendrel_attrs_mutator((Node *) oldinfo->clause, context);

        /* and the modified version, if an OR clause */
        newinfo->orclause = (Expr *)
            adjust_appendrel_attrs_mutator((Node *) oldinfo->orclause, context);

        /* adjust relid sets too */
        newinfo->clause_relids = adjust_child_relids(oldinfo->clause_relids,
                                                     context->nappinfos,
                                                     context->appinfos);
        newinfo->required_relids = adjust_child_relids(oldinfo->required_relids,
                                                       context->nappinfos,
                                                       context->appinfos);
        newinfo->outer_relids = adjust_child_relids(oldinfo->outer_relids,
                                                    context->nappinfos,
                                                    context->appinfos);
        newinfo->nullable_relids = adjust_child_relids(oldinfo->nullable_relids,
                                                       context->nappinfos,
                                                       context->appinfos);
        newinfo->left_relids = adjust_child_relids(oldinfo->left_relids,
                                                   context->nappinfos,
                                                   context->appinfos);
        newinfo->right_relids = adjust_child_relids(oldinfo->right_relids,
                                                    context->nappinfos,
                                                    context->appinfos);

        /*
         * Reset cached derivative fields, since these might need to have
         * different values when considering the child relation.  Note we
         * don't reset left_ec/right_ec: each child variable is implicitly
         * equivalent to its parent, so still a member of the same EC if any.
         */
        newinfo->eval_cost.startup = -1;
        newinfo->norm_selec = -1;
        newinfo->outer_selec = -1;
        newinfo->left_em = NULL;
        newinfo->right_em = NULL;
        newinfo->scansel_cache = NIL;
        newinfo->left_bucketsize = -1;
        newinfo->right_bucketsize = -1;
        newinfo->left_mcvfreq = -1;
        newinfo->right_mcvfreq = -1;

        return (Node *) newinfo;
    }

    /*
     * NOTE: we do not need to recurse into sublinks, because they should
     * already have been converted to subplans before we see them.
     */
    Assert(!IsA(node, SubLink));
    Assert(!IsA(node, Query));

    return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
                                   (void *) context);
}

adjust_child_relids()

Relids adjust_child_relids	(	Relids	relids,
		int	nappinfos,
		AppendRelInfo **	appinfos
	)

Definition at line 536 of file appendinfo.c.

References bms_add_member(), bms_copy(), bms_del_member(), bms_is_member(), AppendRelInfo::child_relid, and AppendRelInfo::parent_relid.

Referenced by adjust_appendrel_attrs_mutator(), adjust_child_relids_multilevel(), and build_child_join_sjinfo().

{
    Bitmapset  *result = NULL;
    int         cnt;

    for (cnt = 0; cnt < nappinfos; cnt++)
    {
        AppendRelInfo *appinfo = appinfos[cnt];

        /* Remove parent, add child */
        if (bms_is_member(appinfo->parent_relid, relids))
        {
            /* Make a copy if we are changing the set. */
            if (!result)
                result = bms_copy(relids);

            result = bms_del_member(result, appinfo->parent_relid);
            result = bms_add_member(result, appinfo->child_relid);
        }
    }

    /* If we made any changes, return the modified copy. */
    if (result)
        return result;

    /* Otherwise, return the original set without modification. */
    return relids;
}

adjust_child_relids_multilevel()

Relids adjust_child_relids_multilevel	(	PlannerInfo *	root,
		Relids	relids,
		Relids	child_relids,
		Relids	top_parent_relids
	)

Definition at line 571 of file appendinfo.c.

References adjust_child_relids(), adjust_child_relids_multilevel(), bms_add_member(), bms_equal(), bms_free(), bms_overlap(), find_appinfos_by_relids(), AppendRelInfo::parent_relid, and pfree().

Referenced by add_child_join_rel_equivalences(), adjust_child_relids_multilevel(), and reparameterize_path_by_child().

{
    AppendRelInfo **appinfos;
    int         nappinfos;
    Relids      parent_relids = NULL;
    Relids      result;
    Relids      tmp_result = NULL;
    int         cnt;

    /*
     * If the given relids set doesn't contain any of the top parent relids,
     * it will remain unchanged.
     */
    if (!bms_overlap(relids, top_parent_relids))
        return relids;

    appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos);

    /* Construct relids set for the immediate parent of the given child. */
    for (cnt = 0; cnt < nappinfos; cnt++)
    {
        AppendRelInfo *appinfo = appinfos[cnt];

        parent_relids = bms_add_member(parent_relids, appinfo->parent_relid);
    }

    /* Recurse if immediate parent is not the top parent. */
    if (!bms_equal(parent_relids, top_parent_relids))
    {
        tmp_result = adjust_child_relids_multilevel(root, relids,
                                                    parent_relids,
                                                    top_parent_relids);
        relids = tmp_result;
    }

    result = adjust_child_relids(relids, nappinfos, appinfos);

    /* Free memory consumed by any intermediate result. */
    if (tmp_result)
        bms_free(tmp_result);
    bms_free(parent_relids);
    pfree(appinfos);

    return result;
}

adjust_inherited_tlist()

static List * adjust_inherited_tlist ( List *  tlist, AppendRelInfo *  context  )

static

Definition at line 635 of file appendinfo.c.

References Assert, elog, ERROR, get_rel_name(), IsA, lappend(), lfirst, list_length(), list_nth(), NIL, OidIsValid, AppendRelInfo::parent_reloid, TargetEntry::resjunk, TargetEntry::resno, AppendRelInfo::translated_vars, and Var::varattno.

Referenced by adjust_appendrel_attrs().

{
    bool        changed_it = false;
    ListCell   *tl;
    List       *new_tlist;
    bool        more;
    int         attrno;

    /* This should only happen for an inheritance case, not UNION ALL */
    Assert(OidIsValid(context->parent_reloid));

    /* Scan tlist and update resnos to match attnums of child rel */
    foreach(tl, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(tl);
        Var        *childvar;

        if (tle->resjunk)
            continue;           /* ignore junk items */

        /* Look up the translation of this column: it must be a Var */
        if (tle->resno <= 0 ||
            tle->resno > list_length(context->translated_vars))
            elog(ERROR, "attribute %d of relation \"%s\" does not exist",
                 tle->resno, get_rel_name(context->parent_reloid));
        childvar = (Var *) list_nth(context->translated_vars, tle->resno - 1);
        if (childvar == NULL || !IsA(childvar, Var))
            elog(ERROR, "attribute %d of relation \"%s\" does not exist",
                 tle->resno, get_rel_name(context->parent_reloid));

        if (tle->resno != childvar->varattno)
        {
            tle->resno = childvar->varattno;
            changed_it = true;
        }
    }

    /*
     * If we changed anything, re-sort the tlist by resno, and make sure
     * resjunk entries have resnos above the last real resno.  The sort
     * algorithm is a bit stupid, but for such a seldom-taken path, small is
     * probably better than fast.
     */
    if (!changed_it)
        return tlist;

    new_tlist = NIL;
    more = true;
    for (attrno = 1; more; attrno++)
    {
        more = false;
        foreach(tl, tlist)
        {
            TargetEntry *tle = (TargetEntry *) lfirst(tl);

            if (tle->resjunk)
                continue;       /* ignore junk items */

            if (tle->resno == attrno)
                new_tlist = lappend(new_tlist, tle);
            else if (tle->resno > attrno)
                more = true;
        }
    }

    foreach(tl, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(tl);

        if (!tle->resjunk)
            continue;           /* here, ignore non-junk items */

        tle->resno = attrno;
        new_tlist = lappend(new_tlist, tle);
        attrno++;
    }

    return new_tlist;
}

find_appinfos_by_relids()

AppendRelInfo** find_appinfos_by_relids	(	PlannerInfo *	root,
		Relids	relids,
		int *	nappinfos
	)

Definition at line 723 of file appendinfo.c.

References PlannerInfo::append_rel_array, bms_next_member(), bms_num_members(), elog, ERROR, i, and palloc().

Referenced by adjust_appendrel_attrs_multilevel(), adjust_child_relids_multilevel(), apply_scanjoin_target_to_paths(), build_child_join_rel(), build_child_join_sjinfo(), create_partitionwise_grouping_paths(), make_partitionedrel_pruneinfo(), and try_partitionwise_join().

{
    AppendRelInfo **appinfos;
    int         cnt = 0;
    int         i;

    *nappinfos = bms_num_members(relids);
    appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos);

    i = -1;
    while ((i = bms_next_member(relids, i)) >= 0)
    {
        AppendRelInfo *appinfo = root->append_rel_array[i];

        if (!appinfo)
            elog(ERROR, "child rel %d not found in append_rel_array", i);

        appinfos[cnt++] = appinfo;
    }
    return appinfos;
}

make_append_rel_info()

AppendRelInfo* make_append_rel_info	(	Relation	parentrel,
		Relation	childrel,
		Index	parentRTindex,
		Index	childRTindex
	)

Definition at line 49 of file appendinfo.c.

References AppendRelInfo::child_relid, AppendRelInfo::child_reltype, make_inh_translation_list(), makeNode, AppendRelInfo::parent_relid, AppendRelInfo::parent_reloid, AppendRelInfo::parent_reltype, RelationData::rd_rel, and RelationGetRelid.

Referenced by expand_single_inheritance_child().

{
    AppendRelInfo *appinfo = makeNode(AppendRelInfo);

    appinfo->parent_relid = parentRTindex;
    appinfo->child_relid = childRTindex;
    appinfo->parent_reltype = parentrel->rd_rel->reltype;
    appinfo->child_reltype = childrel->rd_rel->reltype;
    make_inh_translation_list(parentrel, childrel, childRTindex, appinfo);
    appinfo->parent_reloid = RelationGetRelid(parentrel);

    return appinfo;
}

make_inh_translation_list()

static void make_inh_translation_list ( Relation  oldrelation, Relation  newrelation, Index  newvarno, AppendRelInfo *  appinfo  )

static

Definition at line 78 of file appendinfo.c.

References Assert, attcollation, attname, attnum, atttypid, elog, ERROR, GETSTRUCT, HeapTupleIsValid, lappend(), makeVar(), NameStr, TupleDescData::natts, NIL, AppendRelInfo::num_child_cols, palloc0(), AppendRelInfo::parent_colnos, RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), SearchSysCacheAttName(), AppendRelInfo::translated_vars, and TupleDescAttr.

Referenced by make_append_rel_info().

{
    List       *vars = NIL;
    AttrNumber *pcolnos;
    TupleDesc   old_tupdesc = RelationGetDescr(oldrelation);
    TupleDesc   new_tupdesc = RelationGetDescr(newrelation);
    Oid         new_relid = RelationGetRelid(newrelation);
    int         oldnatts = old_tupdesc->natts;
    int         newnatts = new_tupdesc->natts;
    int         old_attno;
    int         new_attno = 0;

    /* Initialize reverse-translation array with all entries zero */
    appinfo->num_child_cols = newnatts;
    appinfo->parent_colnos = pcolnos =
        (AttrNumber *) palloc0(newnatts * sizeof(AttrNumber));

    for (old_attno = 0; old_attno < oldnatts; old_attno++)
    {
        Form_pg_attribute att;
        char       *attname;
        Oid         atttypid;
        int32       atttypmod;
        Oid         attcollation;

        att = TupleDescAttr(old_tupdesc, old_attno);
        if (att->attisdropped)
        {
            /* Just put NULL into this list entry */
            vars = lappend(vars, NULL);
            continue;
        }
        attname = NameStr(att->attname);
        atttypid = att->atttypid;
        atttypmod = att->atttypmod;
        attcollation = att->attcollation;

        /*
         * When we are generating the "translation list" for the parent table
         * of an inheritance set, no need to search for matches.
         */
        if (oldrelation == newrelation)
        {
            vars = lappend(vars, makeVar(newvarno,
                                         (AttrNumber) (old_attno + 1),
                                         atttypid,
                                         atttypmod,
                                         attcollation,
                                         0));
            pcolnos[old_attno] = old_attno + 1;
            continue;
        }

        /*
         * Otherwise we have to search for the matching column by name.
         * There's no guarantee it'll have the same column position, because
         * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
         * However, in simple cases, the relative order of columns is mostly
         * the same in both relations, so try the column of newrelation that
         * follows immediately after the one that we just found, and if that
         * fails, let syscache handle it.
         */
        if (new_attno >= newnatts ||
            (att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
            strcmp(attname, NameStr(att->attname)) != 0)
        {
            HeapTuple   newtup;

            newtup = SearchSysCacheAttName(new_relid, attname);
            if (!HeapTupleIsValid(newtup))
                elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
                     attname, RelationGetRelationName(newrelation));
            new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
            Assert(new_attno >= 0 && new_attno < newnatts);
            ReleaseSysCache(newtup);

            att = TupleDescAttr(new_tupdesc, new_attno);
        }

        /* Found it, check type and collation match */
        if (atttypid != att->atttypid || atttypmod != att->atttypmod)
            elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
                 attname, RelationGetRelationName(newrelation));
        if (attcollation != att->attcollation)
            elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
                 attname, RelationGetRelationName(newrelation));

        vars = lappend(vars, makeVar(newvarno,
                                     (AttrNumber) (new_attno + 1),
                                     atttypid,
                                     atttypmod,
                                     attcollation,
                                     0));
        pcolnos[new_attno] = old_attno + 1;
        new_attno++;
    }

    appinfo->translated_vars = vars;
}