PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
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

AppendRelInfomake_append_rel_info (Relation parentrel, Relation childrel, Index parentRTindex, Index childRTindex)
 
Nodeadjust_appendrel_attrs (PlannerInfo *root, Node *node, int nappinfos, AppendRelInfo **appinfos)
 
Nodeadjust_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)
 
Listadjust_inherited_attnums (List *attnums, AppendRelInfo *context)
 
Listadjust_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 887 of file appendinfo.c.

890{
891 CmdType commandType = root->parse->commandType;
892 char relkind = target_relation->rd_rel->relkind;
893 Var *var;
894
895 Assert(commandType == CMD_UPDATE || commandType == CMD_DELETE || commandType == CMD_MERGE);
896
897 if (relkind == RELKIND_RELATION ||
898 relkind == RELKIND_MATVIEW ||
899 relkind == RELKIND_PARTITIONED_TABLE)
900 {
901 /*
902 * Emit CTID so that executor can find the row to merge, update or
903 * delete.
904 */
905 var = makeVar(rtindex,
907 TIDOID,
908 -1,
910 0);
911 add_row_identity_var(root, var, rtindex, "ctid");
912 }
913 else if (relkind == RELKIND_FOREIGN_TABLE)
914 {
915 /*
916 * Let the foreign table's FDW add whatever junk TLEs it wants.
917 */
918 FdwRoutine *fdwroutine;
919
920 fdwroutine = GetFdwRoutineForRelation(target_relation, false);
921
922 if (fdwroutine->AddForeignUpdateTargets != NULL)
923 fdwroutine->AddForeignUpdateTargets(root, rtindex,
924 target_rte, target_relation);
925
926 /*
927 * For UPDATE, we need to make the FDW fetch unchanged columns by
928 * asking it to fetch a whole-row Var. That's because the top-level
929 * targetlist only contains entries for changed columns, but
930 * ExecUpdate will need to build the complete new tuple. (Actually,
931 * we only really need this in UPDATEs that are not pushed to the
932 * remote side, but it's hard to tell if that will be the case at the
933 * point when this function is called.)
934 *
935 * We will also need the whole row if there are any row triggers, so
936 * that the executor will have the "old" row to pass to the trigger.
937 * Alas, this misses system columns.
938 */
939 if (commandType == CMD_UPDATE ||
940 (target_relation->trigdesc &&
941 (target_relation->trigdesc->trig_delete_after_row ||
942 target_relation->trigdesc->trig_delete_before_row)))
943 {
944 var = makeVar(rtindex,
946 RECORDOID,
947 -1,
949 0);
950 add_row_identity_var(root, var, rtindex, "wholerow");
951 }
952 }
953}
void add_row_identity_var(PlannerInfo *root, Var *orig_var, Index rtindex, const char *rowid_name)
Definition: appendinfo.c:792
#define InvalidAttrNumber
Definition: attnum.h:23
#define Assert(condition)
Definition: c.h:812
FdwRoutine * GetFdwRoutineForRelation(Relation relation, bool makecopy)
Definition: foreign.c:442
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Definition: makefuncs.c:66
CmdType
Definition: nodes.h:263
@ CMD_MERGE
Definition: nodes.h:269
@ CMD_DELETE
Definition: nodes.h:268
@ CMD_UPDATE
Definition: nodes.h:266
#define InvalidOid
Definition: postgres_ext.h:36
tree ctl root
Definition: radixtree.h:1857
AddForeignUpdateTargets_function AddForeignUpdateTargets
Definition: fdwapi.h:229
TriggerDesc * trigdesc
Definition: rel.h:117
Form_pg_class rd_rel
Definition: rel.h:111
bool trig_delete_before_row
Definition: reltrigger.h:66
bool trig_delete_after_row
Definition: reltrigger.h:67
Definition: primnodes.h:248
#define SelfItemPointerAttributeNumber
Definition: sysattr.h:21

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 792 of file appendinfo.c.

794{
795 TargetEntry *tle;
796 Var *rowid_var;
797 RowIdentityVarInfo *ridinfo;
798 ListCell *lc;
799
800 /* For now, the argument must be just a Var of the given rtindex */
801 Assert(IsA(orig_var, Var));
802 Assert(orig_var->varno == rtindex);
803 Assert(orig_var->varlevelsup == 0);
804 Assert(orig_var->varnullingrels == NULL);
805
806 /*
807 * If we're doing non-inherited UPDATE/DELETE/MERGE, there's little need
808 * for ROWID_VAR shenanigans. Just shove the presented Var into the
809 * processed_tlist, and we're done.
810 */
811 if (rtindex == root->parse->resultRelation)
812 {
813 tle = makeTargetEntry((Expr *) orig_var,
814 list_length(root->processed_tlist) + 1,
815 pstrdup(rowid_name),
816 true);
817 root->processed_tlist = lappend(root->processed_tlist, tle);
818 return;
819 }
820
821 /*
822 * Otherwise, rtindex should reference a leaf target relation that's being
823 * added to the query during expand_inherited_rtentry().
824 */
825 Assert(bms_is_member(rtindex, root->leaf_result_relids));
826 Assert(root->append_rel_array[rtindex] != NULL);
827
828 /*
829 * We have to find a matching RowIdentityVarInfo, or make one if there is
830 * none. To allow using equal() to match the vars, change the varno to
831 * ROWID_VAR, leaving all else alone.
832 */
833 rowid_var = copyObject(orig_var);
834 /* This could eventually become ChangeVarNodes() */
835 rowid_var->varno = ROWID_VAR;
836
837 /* Look for an existing row-id column of the same name */
838 foreach(lc, root->row_identity_vars)
839 {
840 ridinfo = (RowIdentityVarInfo *) lfirst(lc);
841 if (strcmp(rowid_name, ridinfo->rowidname) != 0)
842 continue;
843 if (equal(rowid_var, ridinfo->rowidvar))
844 {
845 /* Found a match; we need only record that rtindex needs it too */
846 ridinfo->rowidrels = bms_add_member(ridinfo->rowidrels, rtindex);
847 return;
848 }
849 else
850 {
851 /* Ooops, can't handle this */
852 elog(ERROR, "conflicting uses of row-identity name \"%s\"",
853 rowid_name);
854 }
855 }
856
857 /* No request yet, so add a new RowIdentityVarInfo */
858 ridinfo = makeNode(RowIdentityVarInfo);
859 ridinfo->rowidvar = copyObject(rowid_var);
860 /* for the moment, estimate width using just the datatype info */
861 ridinfo->rowidwidth = get_typavgwidth(exprType((Node *) rowid_var),
862 exprTypmod((Node *) rowid_var));
863 ridinfo->rowidname = pstrdup(rowid_name);
864 ridinfo->rowidrels = bms_make_singleton(rtindex);
865
866 root->row_identity_vars = lappend(root->row_identity_vars, ridinfo);
867
868 /* Change rowid_var into a reference to this row_identity_vars entry */
869 rowid_var->varattno = list_length(root->row_identity_vars);
870
871 /* Push the ROWID_VAR reference variable into processed_tlist */
872 tle = makeTargetEntry((Expr *) rowid_var,
873 list_length(root->processed_tlist) + 1,
874 pstrdup(rowid_name),
875 true);
876 root->processed_tlist = lappend(root->processed_tlist, tle);
877}
Bitmapset * bms_make_singleton(int x)
Definition: bitmapset.c:216
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:510
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:815
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
bool equal(const void *a, const void *b)
Definition: equalfuncs.c:223
List * lappend(List *list, void *datum)
Definition: list.c:339
int32 get_typavgwidth(Oid typid, int32 typmod)
Definition: lsyscache.c:2578
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition: makefuncs.c:240
char * pstrdup(const char *in)
Definition: mcxt.c:1696
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:298
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
#define copyObject(obj)
Definition: nodes.h:224
#define makeNode(_type_)
Definition: nodes.h:155
#define lfirst(lc)
Definition: pg_list.h:172
static int list_length(const List *l)
Definition: pg_list.h:152
#define ROWID_VAR
Definition: primnodes.h:239
Definition: nodes.h:129
int varno
Definition: primnodes.h:255
Index varlevelsup
Definition: primnodes.h:280

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.

202{
204
205 context.root = root;
206 context.nappinfos = nappinfos;
207 context.appinfos = appinfos;
208
209 /* If there's nothing to adjust, don't call this function. */
210 Assert(nappinfos >= 1 && appinfos != NULL);
211
212 /* Should never be translating a Query tree. */
213 Assert(node == NULL || !IsA(node, Query));
214
215 return adjust_appendrel_attrs_mutator(node, &context);
216}
static Node * adjust_appendrel_attrs_mutator(Node *node, adjust_appendrel_attrs_context *context)
Definition: appendinfo.c:219
AppendRelInfo ** appinfos
Definition: appendinfo.c:35

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 524 of file appendinfo.c.

527{
528 AppendRelInfo **appinfos;
529 int nappinfos;
530
531 /* Recurse if immediate parent is not the top parent. */
532 if (childrel->parent != parentrel)
533 {
534 if (childrel->parent)
536 childrel->parent,
537 parentrel);
538 else
539 elog(ERROR, "childrel is not a child of parentrel");
540 }
541
542 /* Now translate for this child. */
543 appinfos = find_appinfos_by_relids(root, childrel->relids, &nappinfos);
544
545 node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
546
547 pfree(appinfos);
548
549 return node;
550}
AppendRelInfo ** find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
Definition: appendinfo.c:736
Node * adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, AppendRelInfo **appinfos)
Definition: appendinfo.c:200
Node * adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, RelOptInfo *childrel, RelOptInfo *parentrel)
Definition: appendinfo.c:524
void pfree(void *pointer)
Definition: mcxt.c:1521
Relids relids
Definition: pathnodes.h:871

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(), 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 557 of file appendinfo.c.

558{
559 Bitmapset *result = NULL;
560 int cnt;
561
562 for (cnt = 0; cnt < nappinfos; cnt++)
563 {
564 AppendRelInfo *appinfo = appinfos[cnt];
565
566 /* Remove parent, add child */
567 if (bms_is_member(appinfo->parent_relid, relids))
568 {
569 /* Make a copy if we are changing the set. */
570 if (!result)
571 result = bms_copy(relids);
572
573 result = bms_del_member(result, appinfo->parent_relid);
574 result = bms_add_member(result, appinfo->child_relid);
575 }
576 }
577
578 /* If we made any changes, return the modified copy. */
579 if (result)
580 return result;
581
582 /* Otherwise, return the original set without modification. */
583 return relids;
584}
Bitmapset * bms_del_member(Bitmapset *a, int x)
Definition: bitmapset.c:868
Bitmapset * bms_copy(const Bitmapset *a)
Definition: bitmapset.c:122
Index child_relid
Definition: pathnodes.h:2981
Index parent_relid
Definition: pathnodes.h:2980

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 591 of file appendinfo.c.

594{
595 AppendRelInfo **appinfos;
596 int nappinfos;
597
598 /*
599 * If the given relids set doesn't contain any of the parent relids, it
600 * will remain unchanged.
601 */
602 if (!bms_overlap(relids, parentrel->relids))
603 return relids;
604
605 /* Recurse if immediate parent is not the top parent. */
606 if (childrel->parent != parentrel)
607 {
608 if (childrel->parent)
609 relids = adjust_child_relids_multilevel(root, relids,
610 childrel->parent,
611 parentrel);
612 else
613 elog(ERROR, "childrel is not a child of parentrel");
614 }
615
616 /* Now translate for this child. */
617 appinfos = find_appinfos_by_relids(root, childrel->relids, &nappinfos);
618
619 relids = adjust_child_relids(relids, nappinfos, appinfos);
620
621 pfree(appinfos);
622
623 return relids;
624}
Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, RelOptInfo *childrel, RelOptInfo *parentrel)
Definition: appendinfo.c:591
Relids adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
Definition: appendinfo.c:557
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:582

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 631 of file appendinfo.c.

632{
633 List *result = NIL;
634 ListCell *lc;
635
636 /* This should only happen for an inheritance case, not UNION ALL */
638
639 /* Look up each attribute in the AppendRelInfo's translated_vars list */
640 foreach(lc, attnums)
641 {
642 AttrNumber parentattno = lfirst_int(lc);
643 Var *childvar;
644
645 /* Look up the translation of this column: it must be a Var */
646 if (parentattno <= 0 ||
647 parentattno > list_length(context->translated_vars))
648 elog(ERROR, "attribute %d of relation \"%s\" does not exist",
649 parentattno, get_rel_name(context->parent_reloid));
650 childvar = (Var *) list_nth(context->translated_vars, parentattno - 1);
651 if (childvar == NULL || !IsA(childvar, Var))
652 elog(ERROR, "attribute %d of relation \"%s\" does not exist",
653 parentattno, get_rel_name(context->parent_reloid));
654
655 result = lappend_int(result, childvar->varattno);
656 }
657 return result;
658}
int16 AttrNumber
Definition: attnum.h:21
#define OidIsValid(objectId)
Definition: c.h:729
List * lappend_int(List *list, int datum)
Definition: list.c:357
char * get_rel_name(Oid relid)
Definition: lsyscache.c:1928
#define NIL
Definition: pg_list.h:68
#define lfirst_int(lc)
Definition: pg_list.h:173
static void * list_nth(const List *list, int n)
Definition: pg_list.h:299
List * translated_vars
Definition: pathnodes.h:3008
Definition: pg_list.h:54
AttrNumber varattno
Definition: primnodes.h:260

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 665 of file appendinfo.c.

667{
668 AppendRelInfo *appinfo = root->append_rel_array[child_relid];
669
670 if (!appinfo)
671 elog(ERROR, "child rel %d not found in append_rel_array", child_relid);
672
673 /* Recurse if immediate parent is not the top parent. */
674 if (appinfo->parent_relid != top_parent_relid)
675 attnums = adjust_inherited_attnums_multilevel(root, attnums,
676 appinfo->parent_relid,
677 top_parent_relid);
678
679 /* Now translate for this child */
680 return adjust_inherited_attnums(attnums, appinfo);
681}
List * adjust_inherited_attnums_multilevel(PlannerInfo *root, List *attnums, Index child_relid, Index top_parent_relid)
Definition: appendinfo.c:665
List * adjust_inherited_attnums(List *attnums, AppendRelInfo *context)
Definition: appendinfo.c:631

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 968 of file appendinfo.c.

969{
970 Query *parse = root->parse;
971 int result_relation = parse->resultRelation;
972 RangeTblEntry *target_rte;
973 RelOptInfo *target_rel;
974 ListCell *lc;
975
976 /*
977 * There's nothing to do if this isn't an inherited UPDATE/DELETE/MERGE.
978 */
979 if (parse->commandType != CMD_UPDATE && parse->commandType != CMD_DELETE &&
980 parse->commandType != CMD_MERGE)
981 {
982 Assert(root->row_identity_vars == NIL);
983 return;
984 }
985 target_rte = rt_fetch(result_relation, parse->rtable);
986 if (!target_rte->inh)
987 {
988 Assert(root->row_identity_vars == NIL);
989 return;
990 }
991
992 /*
993 * Ordinarily, we expect that leaf result relation(s) will have added some
994 * ROWID_VAR Vars to the query. However, it's possible that constraint
995 * exclusion suppressed every leaf relation. The executor will get upset
996 * if the plan has no row identity columns at all, even though it will
997 * certainly process no rows. Handle this edge case by re-opening the top
998 * result relation and adding the row identity columns it would have used,
999 * as preprocess_targetlist() would have done if it weren't marked "inh".
1000 * Then re-run build_base_rel_tlists() to ensure that the added columns
1001 * get propagated to the relation's reltarget. (This is a bit ugly, but
1002 * it seems better to confine the ugliness and extra cycles to this
1003 * unusual corner case.)
1004 */
1005 if (root->row_identity_vars == NIL)
1006 {
1007 Relation target_relation;
1008
1009 target_relation = table_open(target_rte->relid, NoLock);
1010 add_row_identity_columns(root, result_relation,
1011 target_rte, target_relation);
1012 table_close(target_relation, NoLock);
1013 build_base_rel_tlists(root, root->processed_tlist);
1014 /* There are no ROWID_VAR Vars in this case, so we're done. */
1015 return;
1016 }
1017
1018 /*
1019 * Dig through the processed_tlist to find the ROWID_VAR reference Vars,
1020 * and forcibly copy them into the reltarget list of the topmost target
1021 * relation. That's sufficient because they'll be copied to the
1022 * individual leaf target rels (with appropriate translation) later,
1023 * during appendrel expansion --- see set_append_rel_size().
1024 */
1025 target_rel = find_base_rel(root, result_relation);
1026
1027 foreach(lc, root->processed_tlist)
1028 {
1029 TargetEntry *tle = lfirst(lc);
1030 Var *var = (Var *) tle->expr;
1031
1032 if (var && IsA(var, Var) && var->varno == ROWID_VAR)
1033 {
1034 target_rel->reltarget->exprs =
1035 lappend(target_rel->reltarget->exprs, copyObject(var));
1036 /* reltarget cost and width will be computed later */
1037 }
1038 }
1039}
void add_row_identity_columns(PlannerInfo *root, Index rtindex, RangeTblEntry *target_rte, Relation target_relation)
Definition: appendinfo.c:887
void build_base_rel_tlists(PlannerInfo *root, List *final_tlist)
Definition: initsplan.c:235
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:76
#define NoLock
Definition: lockdefs.h:34
#define rt_fetch(rangetable_index, rangetable)
Definition: parsetree.h:31
static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)
Definition: regcomp.c:717
RelOptInfo * find_base_rel(PlannerInfo *root, int relid)
Definition: relnode.c:414
List * exprs
Definition: pathnodes.h:1544
struct PathTarget * reltarget
Definition: pathnodes.h:893
Expr * expr
Definition: primnodes.h:2190
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40

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(), RangeTblEntry::relid, 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 736 of file appendinfo.c.

737{
738 AppendRelInfo **appinfos;
739 int cnt = 0;
740 int i;
741
742 /* Allocate an array that's certainly big enough */
743 appinfos = (AppendRelInfo **)
744 palloc(sizeof(AppendRelInfo *) * bms_num_members(relids));
745
746 i = -1;
747 while ((i = bms_next_member(relids, i)) >= 0)
748 {
749 AppendRelInfo *appinfo = root->append_rel_array[i];
750
751 if (!appinfo)
752 {
753 /* Probably i is an OJ index, but let's check */
754 if (find_base_rel_ignore_join(root, i) == NULL)
755 continue;
756 /* It's a base rel, but we lack an append_rel_array entry */
757 elog(ERROR, "child rel %d not found in append_rel_array", i);
758 }
759
760 appinfos[cnt++] = appinfo;
761 }
762 *nappinfos = cnt;
763 return appinfos;
764}
int bms_next_member(const Bitmapset *a, int prevbit)
Definition: bitmapset.c:1306
int bms_num_members(const Bitmapset *a)
Definition: bitmapset.c:751
int i
Definition: isn.c:72
void * palloc(Size size)
Definition: mcxt.c:1317
RelOptInfo * find_base_rel_ignore_join(PlannerInfo *root, int relid)
Definition: relnode.c:454

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 693 of file appendinfo.c.

695{
696 /* This is pretty meaningless for commands other than UPDATE. */
697 Assert(root->parse->commandType == CMD_UPDATE);
698 if (relid == root->parse->resultRelation)
699 {
700 /*
701 * Non-inheritance case, so it's easy. The caller might be expecting
702 * a tree it can scribble on, though, so copy.
703 */
704 *processed_tlist = copyObject(root->processed_tlist);
705 if (update_colnos)
706 *update_colnos = copyObject(root->update_colnos);
707 }
708 else
709 {
710 Assert(bms_is_member(relid, root->all_result_relids));
711 *processed_tlist = (List *)
713 (Node *) root->processed_tlist,
714 find_base_rel(root, relid),
715 find_base_rel(root, root->parse->resultRelation));
716 if (update_colnos)
717 *update_colnos =
719 relid,
720 root->parse->resultRelation);
721 }
722}

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.

53{
55
56 appinfo->parent_relid = parentRTindex;
57 appinfo->child_relid = childRTindex;
58 appinfo->parent_reltype = parentrel->rd_rel->reltype;
59 appinfo->child_reltype = childrel->rd_rel->reltype;
60 make_inh_translation_list(parentrel, childrel, childRTindex, appinfo);
61 appinfo->parent_reloid = RelationGetRelid(parentrel);
62
63 return appinfo;
64}
static void make_inh_translation_list(Relation oldrelation, Relation newrelation, Index newvarno, AppendRelInfo *appinfo)
Definition: appendinfo.c:80
#define RelationGetRelid(relation)
Definition: rel.h:505
Oid parent_reltype
Definition: pathnodes.h:2989

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