appendinfo.h File Reference

#include "nodes/pathnodes.h"
#include "utils/relcache.h"

Include dependency graph for appendinfo.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
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, RelOptInfo *childrel, RelOptInfo *parentrel)
Relids	adjust_child_relids (Relids relids, int nappinfos, AppendRelInfo **appinfos)
Relids	adjust_child_relids_multilevel (PlannerInfo *root, Relids relids, RelOptInfo *childrel, RelOptInfo *parentrel)
List *	adjust_inherited_attnums (List *attnums, AppendRelInfo *context)
List *	adjust_inherited_attnums_multilevel (PlannerInfo *root, List *attnums, Index child_relid, Index top_parent_relid)
void	get_translated_update_targetlist (PlannerInfo *root, Index relid, List **processed_tlist, List **update_colnos)
AppendRelInfo **	find_appinfos_by_relids (PlannerInfo *root, Relids relids, int *nappinfos)
void	add_row_identity_var (PlannerInfo *root, Var *orig_var, Index rtindex, const char *rowid_name)
void	add_row_identity_columns (PlannerInfo *root, Index rtindex, RangeTblEntry *target_rte, Relation target_relation)
void	distribute_row_identity_vars (PlannerInfo *root)

Function Documentation

add_row_identity_columns()

void add_row_identity_columns	(	PlannerInfo *	root,
		Index	rtindex,
		RangeTblEntry *	target_rte,
		Relation	target_relation
	)

Definition at line 955 of file appendinfo.c.

{
    CmdType     commandType = root->parse->commandType;
    char        relkind = target_relation->rd_rel->relkind;
    Var        *var;
 
    Assert(commandType == CMD_UPDATE || commandType == CMD_DELETE || commandType == CMD_MERGE);
 
    if (relkind == RELKIND_RELATION ||
        relkind == RELKIND_MATVIEW ||
        relkind == RELKIND_PARTITIONED_TABLE)
    {
        /*
         * Emit CTID so that executor can find the row to merge, update or
         * delete.
         */
        var = makeVar(rtindex,
                      SelfItemPointerAttributeNumber,
                      TIDOID,
                      -1,
                      InvalidOid,
                      0);
        add_row_identity_var(root, var, rtindex, "ctid");
    }
    else if (relkind == RELKIND_FOREIGN_TABLE)
    {
        /*
         * Let the foreign table's FDW add whatever junk TLEs it wants.
         */
        FdwRoutine *fdwroutine;
 
        fdwroutine = GetFdwRoutineForRelation(target_relation, false);
 
        if (fdwroutine->AddForeignUpdateTargets != NULL)
            fdwroutine->AddForeignUpdateTargets(root, rtindex,
                                                target_rte, target_relation);
 
        /*
         * For UPDATE, we need to make the FDW fetch unchanged columns by
         * asking it to fetch a whole-row Var.  That's because the top-level
         * targetlist only contains entries for changed columns, but
         * ExecUpdate will need to build the complete new tuple.  (Actually,
         * we only really need this in UPDATEs that are not pushed to the
         * remote side, but it's hard to tell if that will be the case at the
         * point when this function is called.)
         *
         * We will also need the whole row if there are any row triggers, so
         * that the executor will have the "old" row to pass to the trigger.
         * Alas, this misses system columns.
         */
        if (commandType == CMD_UPDATE ||
            (target_relation->trigdesc &&
             (target_relation->trigdesc->trig_delete_after_row ||
              target_relation->trigdesc->trig_delete_before_row)))
        {
            var = makeVar(rtindex,
                          InvalidAttrNumber,
                          RECORDOID,
                          -1,
                          InvalidOid,
                          0);
            add_row_identity_var(root, var, rtindex, "wholerow");
        }
    }
}

References add_row_identity_var(), FdwRoutine::AddForeignUpdateTargets, Assert(), CMD_DELETE, CMD_MERGE, CMD_UPDATE, GetFdwRoutineForRelation(), InvalidAttrNumber, InvalidOid, makeVar(), RelationData::rd_rel, root, SelfItemPointerAttributeNumber, TriggerDesc::trig_delete_after_row, TriggerDesc::trig_delete_before_row, and RelationData::trigdesc.

Referenced by distribute_row_identity_vars(), expand_single_inheritance_child(), and preprocess_targetlist().

add_row_identity_var()

void add_row_identity_var	(	PlannerInfo *	root,
		Var *	orig_var,
		Index	rtindex,
		const char *	rowid_name
	)

Definition at line 860 of file appendinfo.c.

{
    TargetEntry *tle;
    Var        *rowid_var;
    RowIdentityVarInfo *ridinfo;
    ListCell   *lc;
 
    /* For now, the argument must be just a Var of the given rtindex */
    Assert(IsA(orig_var, Var));
    Assert(orig_var->varno == rtindex);
    Assert(orig_var->varlevelsup == 0);
    Assert(orig_var->varnullingrels == NULL);
 
    /*
     * If we're doing non-inherited UPDATE/DELETE/MERGE, there's little need
     * for ROWID_VAR shenanigans.  Just shove the presented Var into the
     * processed_tlist, and we're done.
     */
    if (rtindex == root->parse->resultRelation)
    {
        tle = makeTargetEntry((Expr *) orig_var,
                              list_length(root->processed_tlist) + 1,
                              pstrdup(rowid_name),
                              true);
        root->processed_tlist = lappend(root->processed_tlist, tle);
        return;
    }
 
    /*
     * Otherwise, rtindex should reference a leaf target relation that's being
     * added to the query during expand_inherited_rtentry().
     */
    Assert(bms_is_member(rtindex, root->leaf_result_relids));
    Assert(root->append_rel_array[rtindex] != NULL);
 
    /*
     * We have to find a matching RowIdentityVarInfo, or make one if there is
     * none.  To allow using equal() to match the vars, change the varno to
     * ROWID_VAR, leaving all else alone.
     */
    rowid_var = copyObject(orig_var);
    /* This could eventually become ChangeVarNodes() */
    rowid_var->varno = ROWID_VAR;
 
    /* Look for an existing row-id column of the same name */
    foreach(lc, root->row_identity_vars)
    {
        ridinfo = (RowIdentityVarInfo *) lfirst(lc);
        if (strcmp(rowid_name, ridinfo->rowidname) != 0)
            continue;
        if (equal(rowid_var, ridinfo->rowidvar))
        {
            /* Found a match; we need only record that rtindex needs it too */
            ridinfo->rowidrels = bms_add_member(ridinfo->rowidrels, rtindex);
            return;
        }
        else
        {
            /* Ooops, can't handle this */
            elog(ERROR, "conflicting uses of row-identity name \"%s\"",
                 rowid_name);
        }
    }
 
    /* No request yet, so add a new RowIdentityVarInfo */
    ridinfo = makeNode(RowIdentityVarInfo);
    ridinfo->rowidvar = copyObject(rowid_var);
    /* for the moment, estimate width using just the datatype info */
    ridinfo->rowidwidth = get_typavgwidth(exprType((Node *) rowid_var),
                                          exprTypmod((Node *) rowid_var));
    ridinfo->rowidname = pstrdup(rowid_name);
    ridinfo->rowidrels = bms_make_singleton(rtindex);
 
    root->row_identity_vars = lappend(root->row_identity_vars, ridinfo);
 
    /* Change rowid_var into a reference to this row_identity_vars entry */
    rowid_var->varattno = list_length(root->row_identity_vars);
 
    /* Push the ROWID_VAR reference variable into processed_tlist */
    tle = makeTargetEntry((Expr *) rowid_var,
                          list_length(root->processed_tlist) + 1,
                          pstrdup(rowid_name),
                          true);
    root->processed_tlist = lappend(root->processed_tlist, tle);
}

References Assert(), bms_add_member(), bms_is_member(), bms_make_singleton(), copyObject, elog, equal(), ERROR, exprType(), exprTypmod(), get_typavgwidth(), IsA, lappend(), lfirst, list_length(), makeNode, makeTargetEntry(), pstrdup(), root, ROWID_VAR, RowIdentityVarInfo::rowidname, RowIdentityVarInfo::rowidrels, RowIdentityVarInfo::rowidvar, RowIdentityVarInfo::rowidwidth, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by add_row_identity_columns(), expand_single_inheritance_child(), and postgresAddForeignUpdateTargets().

adjust_appendrel_attrs()

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

Definition at line 200 of file appendinfo.c.

{
    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);
 
    /* Should never be translating a Query tree. */
    Assert(node == NULL || !IsA(node, Query));
 
    return adjust_appendrel_attrs_mutator(node, &context);
}

References adjust_appendrel_attrs_mutator(), adjust_appendrel_attrs_context::appinfos, Assert(), IsA, adjust_appendrel_attrs_context::nappinfos, adjust_appendrel_attrs_context::root, and root.

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(), make_partitionedrel_pruneinfo(), set_append_rel_size(), and try_partitionwise_join().

adjust_appendrel_attrs_multilevel()

Node * adjust_appendrel_attrs_multilevel	(	PlannerInfo *	root,
		Node *	node,
		RelOptInfo *	childrel,
		RelOptInfo *	parentrel
	)

Definition at line 592 of file appendinfo.c.

{
    AppendRelInfo **appinfos;
    int         nappinfos;
 
    /* Recurse if immediate parent is not the top parent. */
    if (childrel->parent != parentrel)
    {
        if (childrel->parent)
            node = adjust_appendrel_attrs_multilevel(root, node,
                                                     childrel->parent,
                                                     parentrel);
        else
            elog(ERROR, "childrel is not a child of parentrel");
    }
 
    /* Now translate for this child. */
    appinfos = find_appinfos_by_relids(root, childrel->relids, &nappinfos);
 
    node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
 
    pfree(appinfos);
 
    return node;
}

References adjust_appendrel_attrs(), adjust_appendrel_attrs_multilevel(), elog, ERROR, find_appinfos_by_relids(), pfree(), RelOptInfo::relids, and root.

Referenced by add_child_join_rel_equivalences(), add_child_rel_equivalences(), adjust_appendrel_attrs_multilevel(), create_rel_agg_info(), create_unique_paths(), generate_join_implied_equalities_broken(), get_translated_update_targetlist(), grouping_planner(), and make_partitionedrel_pruneinfo().

adjust_child_relids()

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

Definition at line 625 of file appendinfo.c.

{
    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;
}

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(), build_child_join_rel(), build_child_join_sjinfo(), and try_partitionwise_join().

adjust_child_relids_multilevel()

Relids adjust_child_relids_multilevel	(	PlannerInfo *	root,
		Relids	relids,
		RelOptInfo *	childrel,
		RelOptInfo *	parentrel
	)

Definition at line 659 of file appendinfo.c.

{
    AppendRelInfo **appinfos;
    int         nappinfos;
 
    /*
     * If the given relids set doesn't contain any of the parent relids, it
     * will remain unchanged.
     */
    if (!bms_overlap(relids, parentrel->relids))
        return relids;
 
    /* Recurse if immediate parent is not the top parent. */
    if (childrel->parent != parentrel)
    {
        if (childrel->parent)
            relids = adjust_child_relids_multilevel(root, relids,
                                                    childrel->parent,
                                                    parentrel);
        else
            elog(ERROR, "childrel is not a child of parentrel");
    }
 
    /* Now translate for this child. */
    appinfos = find_appinfos_by_relids(root, childrel->relids, &nappinfos);
 
    relids = adjust_child_relids(relids, nappinfos, appinfos);
 
    pfree(appinfos);
 
    return relids;
}

References adjust_child_relids(), adjust_child_relids_multilevel(), bms_overlap(), elog, ERROR, find_appinfos_by_relids(), pfree(), RelOptInfo::relids, and root.

Referenced by adjust_child_relids_multilevel(), and reparameterize_path_by_child().

adjust_inherited_attnums()

List * adjust_inherited_attnums	(	List *	attnums,
		AppendRelInfo *	context
	)

Definition at line 699 of file appendinfo.c.

{
    List       *result = NIL;
    ListCell   *lc;
 
    /* This should only happen for an inheritance case, not UNION ALL */
    Assert(OidIsValid(context->parent_reloid));
 
    /* Look up each attribute in the AppendRelInfo's translated_vars list */
    foreach(lc, attnums)
    {
        AttrNumber  parentattno = lfirst_int(lc);
        Var        *childvar;
 
        /* Look up the translation of this column: it must be a Var */
        if (parentattno <= 0 ||
            parentattno > list_length(context->translated_vars))
            elog(ERROR, "attribute %d of relation \"%s\" does not exist",
                 parentattno, get_rel_name(context->parent_reloid));
        childvar = (Var *) list_nth(context->translated_vars, parentattno - 1);
        if (childvar == NULL || !IsA(childvar, Var))
            elog(ERROR, "attribute %d of relation \"%s\" does not exist",
                 parentattno, get_rel_name(context->parent_reloid));
 
        result = lappend_int(result, childvar->varattno);
    }
    return result;
}

References Assert(), elog, ERROR, get_rel_name(), IsA, lappend_int(), lfirst_int, list_length(), list_nth(), NIL, OidIsValid, AppendRelInfo::parent_reloid, AppendRelInfo::translated_vars, and Var::varattno.

Referenced by adjust_inherited_attnums_multilevel().

adjust_inherited_attnums_multilevel()

List * adjust_inherited_attnums_multilevel	(	PlannerInfo *	root,
		List *	attnums,
		Index	child_relid,
		Index	top_parent_relid
	)

Definition at line 733 of file appendinfo.c.

{
    AppendRelInfo *appinfo = root->append_rel_array[child_relid];
 
    if (!appinfo)
        elog(ERROR, "child rel %d not found in append_rel_array", child_relid);
 
    /* Recurse if immediate parent is not the top parent. */
    if (appinfo->parent_relid != top_parent_relid)
        attnums = adjust_inherited_attnums_multilevel(root, attnums,
                                                      appinfo->parent_relid,
                                                      top_parent_relid);
 
    /* Now translate for this child */
    return adjust_inherited_attnums(attnums, appinfo);
}

References adjust_inherited_attnums(), adjust_inherited_attnums_multilevel(), elog, ERROR, AppendRelInfo::parent_relid, and root.

Referenced by adjust_inherited_attnums_multilevel(), get_translated_update_targetlist(), and grouping_planner().

distribute_row_identity_vars()

void distribute_row_identity_vars

(

PlannerInfo *

root

)

Definition at line 1036 of file appendinfo.c.

{
    Query      *parse = root->parse;
    int         result_relation = parse->resultRelation;
    RangeTblEntry *target_rte;
    RelOptInfo *target_rel;
    ListCell   *lc;
 
    /*
     * There's nothing to do if this isn't an inherited UPDATE/DELETE/MERGE.
     */
    if (parse->commandType != CMD_UPDATE && parse->commandType != CMD_DELETE &&
        parse->commandType != CMD_MERGE)
    {
        Assert(root->row_identity_vars == NIL);
        return;
    }
    target_rte = rt_fetch(result_relation, parse->rtable);
    if (!target_rte->inh)
    {
        Assert(root->row_identity_vars == NIL);
        return;
    }
 
    /*
     * Ordinarily, we expect that leaf result relation(s) will have added some
     * ROWID_VAR Vars to the query.  However, it's possible that constraint
     * exclusion suppressed every leaf relation.  The executor will get upset
     * if the plan has no row identity columns at all, even though it will
     * certainly process no rows.  Handle this edge case by re-opening the top
     * result relation and adding the row identity columns it would have used,
     * as preprocess_targetlist() would have done if it weren't marked "inh".
     * Then re-run build_base_rel_tlists() to ensure that the added columns
     * get propagated to the relation's reltarget.  (This is a bit ugly, but
     * it seems better to confine the ugliness and extra cycles to this
     * unusual corner case.)
     */
    if (root->row_identity_vars == NIL)
    {
        Relation    target_relation;
 
        target_relation = table_open(target_rte->relid, NoLock);
        add_row_identity_columns(root, result_relation,
                                 target_rte, target_relation);
        table_close(target_relation, NoLock);
        build_base_rel_tlists(root, root->processed_tlist);
        /* There are no ROWID_VAR Vars in this case, so we're done. */
        return;
    }
 
    /*
     * Dig through the processed_tlist to find the ROWID_VAR reference Vars,
     * and forcibly copy them into the reltarget list of the topmost target
     * relation.  That's sufficient because they'll be copied to the
     * individual leaf target rels (with appropriate translation) later,
     * during appendrel expansion --- see set_append_rel_size().
     */
    target_rel = find_base_rel(root, result_relation);
 
    foreach(lc, root->processed_tlist)
    {
        TargetEntry *tle = lfirst(lc);
        Var        *var = (Var *) tle->expr;
 
        if (var && IsA(var, Var) && var->varno == ROWID_VAR)
        {
            target_rel->reltarget->exprs =
                lappend(target_rel->reltarget->exprs, copyObject(var));
            /* reltarget cost and width will be computed later */
        }
    }
}

References add_row_identity_columns(), Assert(), build_base_rel_tlists(), CMD_DELETE, CMD_MERGE, CMD_UPDATE, copyObject, TargetEntry::expr, PathTarget::exprs, find_base_rel(), if(), RangeTblEntry::inh, IsA, lappend(), lfirst, NIL, NoLock, parse(), RelOptInfo::reltarget, root, ROWID_VAR, rt_fetch, table_close(), table_open(), and Var::varno.

Referenced by query_planner().

find_appinfos_by_relids()

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

Definition at line 804 of file appendinfo.c.

{
    AppendRelInfo **appinfos;
    int         cnt = 0;
    int         i;
 
    /* Allocate an array that's certainly big enough */
    appinfos = (AppendRelInfo **)
        palloc(sizeof(AppendRelInfo *) * bms_num_members(relids));
 
    i = -1;
    while ((i = bms_next_member(relids, i)) >= 0)
    {
        AppendRelInfo *appinfo = root->append_rel_array[i];
 
        if (!appinfo)
        {
            /* Probably i is an OJ index, but let's check */
            if (find_base_rel_ignore_join(root, i) == NULL)
                continue;
            /* It's a base rel, but we lack an append_rel_array entry */
            elog(ERROR, "child rel %d not found in append_rel_array", i);
        }
 
        appinfos[cnt++] = appinfo;
    }
    *nappinfos = cnt;
    return appinfos;
}

References bms_next_member(), bms_num_members(), elog, ERROR, find_base_rel_ignore_join(), i, palloc(), and root.

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

get_translated_update_targetlist()

void get_translated_update_targetlist	(	PlannerInfo *	root,
		Index	relid,
		List **	processed_tlist,
		List **	update_colnos
	)

Definition at line 761 of file appendinfo.c.

{
    /* This is pretty meaningless for commands other than UPDATE. */
    Assert(root->parse->commandType == CMD_UPDATE);
    if (relid == root->parse->resultRelation)
    {
        /*
         * Non-inheritance case, so it's easy.  The caller might be expecting
         * a tree it can scribble on, though, so copy.
         */
        *processed_tlist = copyObject(root->processed_tlist);
        if (update_colnos)
            *update_colnos = copyObject(root->update_colnos);
    }
    else
    {
        Assert(bms_is_member(relid, root->all_result_relids));
        *processed_tlist = (List *)
            adjust_appendrel_attrs_multilevel(root,
                                              (Node *) root->processed_tlist,
                                              find_base_rel(root, relid),
                                              find_base_rel(root, root->parse->resultRelation));
        if (update_colnos)
            *update_colnos =
                adjust_inherited_attnums_multilevel(root, root->update_colnos,
                                                    relid,
                                                    root->parse->resultRelation);
    }
}

References adjust_appendrel_attrs_multilevel(), adjust_inherited_attnums_multilevel(), Assert(), bms_is_member(), CMD_UPDATE, copyObject, find_base_rel(), and root.

Referenced by postgresPlanDirectModify().

make_append_rel_info()

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

Definition at line 51 of file appendinfo.c.

{
    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;
}

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().