PostgreSQL Source Code git master
Functions
nodeSubplan.h File Reference
#include "nodes/execnodes.h"
Include dependency graph for nodeSubplan.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

SubPlanState *  ExecInitSubPlan (SubPlan *subplan, PlanState *parent)
 
Datum  ExecSubPlan (SubPlanState *node, ExprContext *econtext, bool *isNull)
 
void  ExecReScanSetParamPlan (SubPlanState *node, PlanState *parent)
 
void  ExecSetParamPlan (SubPlanState *node, ExprContext *econtext)
 
void  ExecSetParamPlanMulti (const Bitmapset *params, ExprContext *econtext)
 

Function Documentation

◆ ExecInitSubPlan()

SubPlanState * ExecInitSubPlan ( SubPlan *  subplan,
PlanState *  parent 
)

Definition at line 807 of file nodeSubplan.c.

808{
810 EState *estate = parent->state;
811
812 sstate->subplan = subplan;
813
814 /* Link the SubPlanState to already-initialized subplan */
815 sstate->planstate = (PlanState *) list_nth(estate->es_subplanstates,
816 subplan->plan_id - 1);
817
818 /*
819 * This check can fail if the planner mistakenly puts a parallel-unsafe
820 * subplan into a parallelized subquery; see ExecSerializePlan.
821 */
822 if (sstate->planstate == NULL)
823 elog(ERROR, "subplan \"%s\" was not initialized",
824 subplan->plan_name);
825
826 /* Link to parent's state, too */
827 sstate->parent = parent;
828
829 /* Initialize subexpressions */
830 sstate->testexpr = ExecInitExpr((Expr *) subplan->testexpr, parent);
831
832 /*
833 * initialize my state
834 */
835 sstate->curTuple = NULL;
836 sstate->curArray = PointerGetDatum(NULL);
837 sstate->projLeft = NULL;
838 sstate->projRight = NULL;
839 sstate->hashtable = NULL;
840 sstate->hashnulls = NULL;
841 sstate->hashtablecxt = NULL;
842 sstate->innerecontext = NULL;
843 sstate->keyColIdx = NULL;
844 sstate->tab_eq_funcoids = NULL;
845 sstate->tab_hash_funcs = NULL;
846 sstate->tab_collations = NULL;
847 sstate->cur_eq_funcs = NULL;
848
849 /*
850 * If this is an initplan, it has output parameters that the parent plan
851 * will use, so mark those parameters as needing evaluation. We don't
852 * actually run the subplan until we first need one of its outputs.
853 *
854 * A CTE subplan's output parameter is never to be evaluated in the normal
855 * way, so skip this in that case.
856 *
857 * Note that we don't set parent->chgParam here: the parent plan hasn't
858 * been run yet, so no need to force it to re-run.
859 */
860 if (subplan->setParam != NIL && subplan->parParam == NIL &&
861 subplan->subLinkType != CTE_SUBLINK)
862 {
863 ListCell *lst;
864
865 foreach(lst, subplan->setParam)
866 {
867 int paramid = lfirst_int(lst);
868 ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
869
870 prm->execPlan = sstate;
871 }
872 }
873
874 /*
875 * If we are going to hash the subquery output, initialize relevant stuff.
876 * (We don't create the hashtable until needed, though.)
877 */
878 if (subplan->useHashTable)
879 {
880 int ncols,
881 i;
882 TupleDesc tupDescLeft;
883 TupleDesc tupDescRight;
884 Oid *cross_eq_funcoids;
885 TupleTableSlot *slot;
886 FmgrInfo *lhs_hash_funcs;
887 List *oplist,
888 *lefttlist,
889 *righttlist;
890 ListCell *l;
891
892 /* We need a memory context to hold the hash table(s) */
893 sstate->hashtablecxt =
895 "Subplan HashTable Context",
897 /* and a short-lived exprcontext for function evaluation */
898 sstate->innerecontext = CreateExprContext(estate);
899
900 /*
901 * We use ExecProject to evaluate the lefthand and righthand
902 * expression lists and form tuples. (You might think that we could
903 * use the sub-select's output tuples directly, but that is not the
904 * case if we had to insert any run-time coercions of the sub-select's
905 * output datatypes; anyway this avoids storing any resjunk columns
906 * that might be in the sub-select's output.) Run through the
907 * combining expressions to build tlists for the lefthand and
908 * righthand sides.
909 *
910 * We also extract the combining operators themselves to initialize
911 * the equality and hashing functions for the hash tables.
912 */
913 if (IsA(subplan->testexpr, OpExpr))
914 {
915 /* single combining operator */
916 oplist = list_make1(subplan->testexpr);
917 }
918 else if (is_andclause(subplan->testexpr))
919 {
920 /* multiple combining operators */
921 oplist = castNode(BoolExpr, subplan->testexpr)->args;
922 }
923 else
924 {
925 /* shouldn't see anything else in a hashable subplan */
926 elog(ERROR, "unrecognized testexpr type: %d",
927 (int) nodeTag(subplan->testexpr));
928 oplist = NIL; /* keep compiler quiet */
929 }
930 ncols = list_length(oplist);
931
932 lefttlist = righttlist = NIL;
933 sstate->numCols = ncols;
934 sstate->keyColIdx = (AttrNumber *) palloc(ncols * sizeof(AttrNumber));
935 sstate->tab_eq_funcoids = (Oid *) palloc(ncols * sizeof(Oid));
936 sstate->tab_collations = (Oid *) palloc(ncols * sizeof(Oid));
937 sstate->tab_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
938 lhs_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
939 sstate->cur_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
940 /* we'll need the cross-type equality fns below, but not in sstate */
941 cross_eq_funcoids = (Oid *) palloc(ncols * sizeof(Oid));
942
943 i = 1;
944 foreach(l, oplist)
945 {
946 OpExpr *opexpr = lfirst_node(OpExpr, l);
947 Expr *expr;
948 TargetEntry *tle;
949 Oid rhs_eq_oper;
950 Oid left_hashfn;
951 Oid right_hashfn;
952
953 Assert(list_length(opexpr->args) == 2);
954
955 /* Process lefthand argument */
956 expr = (Expr *) linitial(opexpr->args);
957 tle = makeTargetEntry(expr,
958 i,
959 NULL,
960 false);
961 lefttlist = lappend(lefttlist, tle);
962
963 /* Process righthand argument */
964 expr = (Expr *) lsecond(opexpr->args);
965 tle = makeTargetEntry(expr,
966 i,
967 NULL,
968 false);
969 righttlist = lappend(righttlist, tle);
970
971 /* Lookup the equality function (potentially cross-type) */
972 cross_eq_funcoids[i - 1] = opexpr->opfuncid;
973 fmgr_info(opexpr->opfuncid, &sstate->cur_eq_funcs[i - 1]);
974 fmgr_info_set_expr((Node *) opexpr, &sstate->cur_eq_funcs[i - 1]);
975
976 /* Look up the equality function for the RHS type */
978 NULL, &rhs_eq_oper))
979 elog(ERROR, "could not find compatible hash operator for operator %u",
980 opexpr->opno);
981 sstate->tab_eq_funcoids[i - 1] = get_opcode(rhs_eq_oper);
982
983 /* Lookup the associated hash functions */
984 if (!get_op_hash_functions(opexpr->opno,
985 &left_hashfn, &right_hashfn))
986 elog(ERROR, "could not find hash function for hash operator %u",
987 opexpr->opno);
988 fmgr_info(left_hashfn, &lhs_hash_funcs[i - 1]);
989 fmgr_info(right_hashfn, &sstate->tab_hash_funcs[i - 1]);
990
991 /* Set collation */
992 sstate->tab_collations[i - 1] = opexpr->inputcollid;
993
994 /* keyColIdx is just column numbers 1..n */
995 sstate->keyColIdx[i - 1] = i;
996
997 i++;
998 }
999
1000 /*
1001 * Construct tupdescs, slots and projection nodes for left and right
1002 * sides. The lefthand expressions will be evaluated in the parent
1003 * plan node's exprcontext, which we don't have access to here.
1004 * Fortunately we can just pass NULL for now and fill it in later
1005 * (hack alert!). The righthand expressions will be evaluated in our
1006 * own innerecontext.
1007 */
1008 tupDescLeft = ExecTypeFromTL(lefttlist);
1009 slot = ExecInitExtraTupleSlot(estate, tupDescLeft, &TTSOpsVirtual);
1010 sstate->projLeft = ExecBuildProjectionInfo(lefttlist,
1011 NULL,
1012 slot,
1013 parent,
1014 NULL);
1015
1016 sstate->descRight = tupDescRight = ExecTypeFromTL(righttlist);
1017 slot = ExecInitExtraTupleSlot(estate, tupDescRight, &TTSOpsVirtual);
1018 sstate->projRight = ExecBuildProjectionInfo(righttlist,
1019 sstate->innerecontext,
1020 slot,
1021 sstate->planstate,
1022 NULL);
1023
1024 /* Build the ExprState for generating hash values */
1025 sstate->lhs_hash_expr = ExecBuildHash32FromAttrs(tupDescLeft,
1027 lhs_hash_funcs,
1028 sstate->tab_collations,
1029 sstate->numCols,
1030 sstate->keyColIdx,
1031 parent,
1032 0);
1033
1034 /*
1035 * Create comparator for lookups of rows in the table (potentially
1036 * cross-type comparisons).
1037 */
1038 sstate->cur_eq_comp = ExecBuildGroupingEqual(tupDescLeft, tupDescRight,
1040 ncols,
1041 sstate->keyColIdx,
1042 cross_eq_funcoids,
1043 sstate->tab_collations,
1044 parent);
1045 }
1046
1047 return sstate;
1048}
int16 AttrNumber
Definition: attnum.h:21
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
ExprState * ExecBuildHash32FromAttrs(TupleDesc desc, const TupleTableSlotOps *ops, FmgrInfo *hashfunctions, Oid *collations, int numCols, AttrNumber *keyColIdx, PlanState *parent, uint32 init_value)
Definition: execExpr.c:4141
ExprState * ExecInitExpr(Expr *node, PlanState *parent)
Definition: execExpr.c:143
ProjectionInfo * ExecBuildProjectionInfo(List *targetList, ExprContext *econtext, TupleTableSlot *slot, PlanState *parent, TupleDesc inputDesc)
Definition: execExpr.c:370
ExprState * ExecBuildGroupingEqual(TupleDesc ldesc, TupleDesc rdesc, const TupleTableSlotOps *lops, const TupleTableSlotOps *rops, int numCols, const AttrNumber *keyColIdx, const Oid *eqfunctions, const Oid *collations, PlanState *parent)
Definition: execExpr.c:4465
const TupleTableSlotOps TTSOpsVirtual
Definition: execTuples.c:84
TupleTableSlot * ExecInitExtraTupleSlot(EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:2020
const TupleTableSlotOps TTSOpsMinimalTuple
Definition: execTuples.c:86
TupleDesc ExecTypeFromTL(List *targetList)
Definition: execTuples.c:2127
ExprContext * CreateExprContext(EState *estate)
Definition: execUtils.c:307
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition: fmgr.c:128
#define fmgr_info_set_expr(expr, finfo)
Definition: fmgr.h:135
Assert(PointerIsAligned(start, uint64))
i
int i
Definition: isn.c:77
List * lappend(List *list, void *datum)
Definition: list.c:339
bool get_compatible_hash_operators(Oid opno, Oid *lhs_opno, Oid *rhs_opno)
Definition: lsyscache.c:482
RegProcedure get_opcode(Oid opno)
Definition: lsyscache.c:1452
bool get_op_hash_functions(Oid opno, RegProcedure *lhs_procno, RegProcedure *rhs_procno)
Definition: lsyscache.c:582
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition: makefuncs.c:289
void * palloc(Size size)
Definition: mcxt.c:1365
MemoryContext CurrentMemoryContext
Definition: mcxt.c:160
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
static bool is_andclause(const void *clause)
Definition: nodeFuncs.h:107
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
#define nodeTag(nodeptr)
Definition: nodes.h:139
#define makeNode(_type_)
Definition: nodes.h:161
#define castNode(_type_, nodeptr)
Definition: nodes.h:182
#define lfirst_node(type, lc)
Definition: pg_list.h:176
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
#define lfirst_int(lc)
Definition: pg_list.h:173
#define list_make1(x1)
Definition: pg_list.h:212
static void * list_nth(const List *list, int n)
Definition: pg_list.h:299
#define linitial(l)
Definition: pg_list.h:178
#define lsecond(l)
Definition: pg_list.h:183
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:332
unsigned int Oid
Definition: postgres_ext.h:32
@ CTE_SUBLINK
Definition: primnodes.h:1036
Definition: execnodes.h:655
ParamExecData * es_param_exec_vals
Definition: execnodes.h:705
List * es_subplanstates
Definition: execnodes.h:725
Definition: primnodes.h:189
Definition: fmgr.h:57
Definition: pg_list.h:54
Definition: nodes.h:135
Definition: primnodes.h:846
Oid opno
Definition: primnodes.h:850
List * args
Definition: primnodes.h:868
void * execPlan
Definition: params.h:147
EState * state
Definition: execnodes.h:1161
TupleHashTable hashtable
Definition: execnodes.h:1016
ExprState * lhs_hash_expr
Definition: execnodes.h:1029
PlanState * parent
Definition: execnodes.h:1008
ExprState * cur_eq_comp
Definition: execnodes.h:1031
MemoryContext hashtablecxt
Definition: execnodes.h:1020
Oid * tab_eq_funcoids
Definition: execnodes.h:1025
ExprContext * innerecontext
Definition: execnodes.h:1021
FmgrInfo * tab_hash_funcs
Definition: execnodes.h:1028
FmgrInfo * cur_eq_funcs
Definition: execnodes.h:1030
PlanState * planstate
Definition: execnodes.h:1007
HeapTuple curTuple
Definition: execnodes.h:1010
AttrNumber * keyColIdx
Definition: execnodes.h:1024
int numCols
Definition: execnodes.h:1022
TupleDesc descRight
Definition: execnodes.h:1013
SubPlan * subplan
Definition: execnodes.h:1006
ProjectionInfo * projLeft
Definition: execnodes.h:1014
ProjectionInfo * projRight
Definition: execnodes.h:1015
ExprState * testexpr
Definition: execnodes.h:1009
Oid * tab_collations
Definition: execnodes.h:1027
TupleHashTable hashnulls
Definition: execnodes.h:1017
Datum curArray
Definition: execnodes.h:1011
int plan_id
Definition: primnodes.h:1102
char * plan_name
Definition: primnodes.h:1104
bool useHashTable
Definition: primnodes.h:1111
Node * testexpr
Definition: primnodes.h:1099
List * parParam
Definition: primnodes.h:1122
List * setParam
Definition: primnodes.h:1120
SubLinkType subLinkType
Definition: primnodes.h:1097
Definition: pg_list.h:46

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, OpExpr::args, Assert(), castNode, CreateExprContext(), CTE_SUBLINK, SubPlanState::cur_eq_comp, SubPlanState::cur_eq_funcs, SubPlanState::curArray, CurrentMemoryContext, SubPlanState::curTuple, SubPlanState::descRight, elog, ERROR, EState::es_param_exec_vals, EState::es_subplanstates, ExecBuildGroupingEqual(), ExecBuildHash32FromAttrs(), ExecBuildProjectionInfo(), ExecInitExpr(), ExecInitExtraTupleSlot(), ParamExecData::execPlan, ExecTypeFromTL(), fmgr_info(), fmgr_info_set_expr, get_compatible_hash_operators(), get_op_hash_functions(), get_opcode(), SubPlanState::hashnulls, SubPlanState::hashtable, SubPlanState::hashtablecxt, i, SubPlanState::innerecontext, is_andclause(), IsA, SubPlanState::keyColIdx, lappend(), lfirst_int, lfirst_node, SubPlanState::lhs_hash_expr, linitial, list_length(), list_make1, list_nth(), lsecond, makeNode, makeTargetEntry(), NIL, nodeTag, SubPlanState::numCols, OpExpr::opno, palloc(), SubPlanState::parent, SubPlan::parParam, SubPlan::plan_id, SubPlan::plan_name, SubPlanState::planstate, PointerGetDatum(), SubPlanState::projLeft, SubPlanState::projRight, SubPlan::setParam, PlanState::state, SubPlan::subLinkType, SubPlanState::subplan, SubPlanState::tab_collations, SubPlanState::tab_eq_funcoids, SubPlanState::tab_hash_funcs, SubPlanState::testexpr, SubPlan::testexpr, TTSOpsMinimalTuple, TTSOpsVirtual, and SubPlan::useHashTable.

Referenced by ExecInitNode(), and ExecInitSubPlanExpr().

◆ ExecReScanSetParamPlan()

void ExecReScanSetParamPlan ( SubPlanState *  node,
PlanState *  parent 
)

Definition at line 1274 of file nodeSubplan.c.

1275{
1276 PlanState *planstate = node->planstate;
1277 SubPlan *subplan = node->subplan;
1278 EState *estate = parent->state;
1279 ListCell *l;
1280
1281 /* sanity checks */
1282 if (subplan->parParam != NIL)
1283 elog(ERROR, "direct correlated subquery unsupported as initplan");
1284 if (subplan->setParam == NIL)
1285 elog(ERROR, "setParam list of initplan is empty");
1286 if (bms_is_empty(planstate->plan->extParam))
1287 elog(ERROR, "extParam set of initplan is empty");
1288
1289 /*
1290 * Don't actually re-scan: it'll happen inside ExecSetParamPlan if needed.
1291 */
1292
1293 /*
1294 * Mark this subplan's output parameters as needing recalculation.
1295 *
1296 * CTE subplans are never executed via parameter recalculation; instead
1297 * they get run when called by nodeCtescan.c. So don't mark the output
1298 * parameter of a CTE subplan as dirty, but do set the chgParam bit for it
1299 * so that dependent plan nodes will get told to rescan.
1300 */
1301 foreach(l, subplan->setParam)
1302 {
1303 int paramid = lfirst_int(l);
1304 ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
1305
1306 if (subplan->subLinkType != CTE_SUBLINK)
1307 prm->execPlan = node;
1308
1309 parent->chgParam = bms_add_member(parent->chgParam, paramid);
1310 }
1311}
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:815
#define bms_is_empty(a)
Definition: bitmapset.h:118
Plan * plan
Definition: execnodes.h:1159
Bitmapset * chgParam
Definition: execnodes.h:1191
Bitmapset * extParam
Definition: plannodes.h:240

References bms_add_member(), bms_is_empty, PlanState::chgParam, CTE_SUBLINK, elog, ERROR, EState::es_param_exec_vals, ParamExecData::execPlan, Plan::extParam, lfirst_int, NIL, SubPlan::parParam, PlanState::plan, SubPlanState::planstate, SubPlan::setParam, PlanState::state, SubPlan::subLinkType, and SubPlanState::subplan.

Referenced by ExecReScan().

◆ ExecSetParamPlan()

void ExecSetParamPlan ( SubPlanState *  node,
ExprContext *  econtext 
)

Definition at line 1075 of file nodeSubplan.c.

1076{
1077 SubPlan *subplan = node->subplan;
1078 PlanState *planstate = node->planstate;
1079 SubLinkType subLinkType = subplan->subLinkType;
1080 EState *estate = planstate->state;
1081 ScanDirection dir = estate->es_direction;
1082 MemoryContext oldcontext;
1083 TupleTableSlot *slot;
1084 ListCell *l;
1085 bool found = false;
1086 ArrayBuildStateAny *astate = NULL;
1087
1088 if (subLinkType == ANY_SUBLINK ||
1089 subLinkType == ALL_SUBLINK)
1090 elog(ERROR, "ANY/ALL subselect unsupported as initplan");
1091 if (subLinkType == CTE_SUBLINK)
1092 elog(ERROR, "CTE subplans should not be executed via ExecSetParamPlan");
1093 if (subplan->parParam || subplan->args)
1094 elog(ERROR, "correlated subplans should not be executed via ExecSetParamPlan");
1095
1096 /*
1097 * Enforce forward scan direction regardless of caller. It's hard but not
1098 * impossible to get here in backward scan, so make it work anyway.
1099 */
1101
1102 /* Initialize ArrayBuildStateAny in caller's context, if needed */
1103 if (subLinkType == ARRAY_SUBLINK)
1104 astate = initArrayResultAny(subplan->firstColType,
1105 CurrentMemoryContext, true);
1106
1107 /*
1108 * Must switch to per-query memory context.
1109 */
1110 oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
1111
1112 /*
1113 * Run the plan. (If it needs to be rescanned, the first ExecProcNode
1114 * call will take care of that.)
1115 */
1116 for (slot = ExecProcNode(planstate);
1117 !TupIsNull(slot);
1118 slot = ExecProcNode(planstate))
1119 {
1120 TupleDesc tdesc = slot->tts_tupleDescriptor;
1121 int i = 1;
1122
1123 if (subLinkType == EXISTS_SUBLINK)
1124 {
1125 /* There can be only one setParam... */
1126 int paramid = linitial_int(subplan->setParam);
1127 ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1128
1129 prm->execPlan = NULL;
1130 prm->value = BoolGetDatum(true);
1131 prm->isnull = false;
1132 found = true;
1133 break;
1134 }
1135
1136 if (subLinkType == ARRAY_SUBLINK)
1137 {
1138 Datum dvalue;
1139 bool disnull;
1140
1141 found = true;
1142 /* stash away current value */
1143 Assert(subplan->firstColType == TupleDescAttr(tdesc, 0)->atttypid);
1144 dvalue = slot_getattr(slot, 1, &disnull);
1145 astate = accumArrayResultAny(astate, dvalue, disnull,
1146 subplan->firstColType, oldcontext);
1147 /* keep scanning subplan to collect all values */
1148 continue;
1149 }
1150
1151 if (found &&
1152 (subLinkType == EXPR_SUBLINK ||
1153 subLinkType == MULTIEXPR_SUBLINK ||
1154 subLinkType == ROWCOMPARE_SUBLINK))
1155 ereport(ERROR,
1156 (errcode(ERRCODE_CARDINALITY_VIOLATION),
1157 errmsg("more than one row returned by a subquery used as an expression")));
1158
1159 found = true;
1160
1161 /*
1162 * We need to copy the subplan's tuple into our own context, in case
1163 * any of the params are pass-by-ref type --- the pointers stored in
1164 * the param structs will point at this copied tuple! node->curTuple
1165 * keeps track of the copied tuple for eventual freeing.
1166 */
1167 if (node->curTuple)
1168 heap_freetuple(node->curTuple);
1169 node->curTuple = ExecCopySlotHeapTuple(slot);
1170
1171 /*
1172 * Now set all the setParam params from the columns of the tuple
1173 */
1174 foreach(l, subplan->setParam)
1175 {
1176 int paramid = lfirst_int(l);
1177 ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1178
1179 prm->execPlan = NULL;
1180 prm->value = heap_getattr(node->curTuple, i, tdesc,
1181 &(prm->isnull));
1182 i++;
1183 }
1184 }
1185
1186 if (subLinkType == ARRAY_SUBLINK)
1187 {
1188 /* There can be only one setParam... */
1189 int paramid = linitial_int(subplan->setParam);
1190 ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1191
1192 /*
1193 * We build the result array in query context so it won't disappear;
1194 * to avoid leaking memory across repeated calls, we have to remember
1195 * the latest value, much as for curTuple above.
1196 */
1197 if (node->curArray != PointerGetDatum(NULL))
1199 node->curArray = makeArrayResultAny(astate,
1200 econtext->ecxt_per_query_memory,
1201 true);
1202 prm->execPlan = NULL;
1203 prm->value = node->curArray;
1204 prm->isnull = false;
1205 }
1206 else if (!found)
1207 {
1208 if (subLinkType == EXISTS_SUBLINK)
1209 {
1210 /* There can be only one setParam... */
1211 int paramid = linitial_int(subplan->setParam);
1212 ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1213
1214 prm->execPlan = NULL;
1215 prm->value = BoolGetDatum(false);
1216 prm->isnull = false;
1217 }
1218 else
1219 {
1220 /* For other sublink types, set all the output params to NULL */
1221 foreach(l, subplan->setParam)
1222 {
1223 int paramid = lfirst_int(l);
1224 ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1225
1226 prm->execPlan = NULL;
1227 prm->value = (Datum) 0;
1228 prm->isnull = true;
1229 }
1230 }
1231 }
1232
1233 MemoryContextSwitchTo(oldcontext);
1234
1235 /* restore scan direction */
1236 estate->es_direction = dir;
1237}
ArrayBuildStateAny * initArrayResultAny(Oid input_type, MemoryContext rcontext, bool subcontext)
Definition: arrayfuncs.c:5783
ArrayBuildStateAny * accumArrayResultAny(ArrayBuildStateAny *astate, Datum dvalue, bool disnull, Oid input_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5830
Datum makeArrayResultAny(ArrayBuildStateAny *astate, MemoryContext rcontext, bool release)
Definition: arrayfuncs.c:5858
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ereport(elevel,...)
Definition: elog.h:150
static TupleTableSlot * ExecProcNode(PlanState *node)
Definition: executor.h:311
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1435
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: htup_details.h:904
void pfree(void *pointer)
Definition: mcxt.c:1594
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
#define linitial_int(l)
Definition: pg_list.h:179
static Datum BoolGetDatum(bool X)
Definition: postgres.h:112
uint64_t Datum
Definition: postgres.h:70
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:322
SubLinkType
Definition: primnodes.h:1028
@ ARRAY_SUBLINK
Definition: primnodes.h:1035
@ ANY_SUBLINK
Definition: primnodes.h:1031
@ MULTIEXPR_SUBLINK
Definition: primnodes.h:1034
@ EXPR_SUBLINK
Definition: primnodes.h:1033
@ ROWCOMPARE_SUBLINK
Definition: primnodes.h:1032
@ ALL_SUBLINK
Definition: primnodes.h:1030
@ EXISTS_SUBLINK
Definition: primnodes.h:1029
ScanDirection
Definition: sdir.h:25
@ ForwardScanDirection
Definition: sdir.h:28
ScanDirection es_direction
Definition: execnodes.h:659
ParamExecData * ecxt_param_exec_vals
Definition: execnodes.h:284
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:280
bool isnull
Definition: params.h:149
Datum value
Definition: params.h:148
List * args
Definition: primnodes.h:1123
Oid firstColType
Definition: primnodes.h:1106
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:122
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:160
static HeapTuple ExecCopySlotHeapTuple(TupleTableSlot *slot)
Definition: tuptable.h:484
static Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:398
#define TupIsNull(slot)
Definition: tuptable.h:309

References accumArrayResultAny(), ALL_SUBLINK, ANY_SUBLINK, SubPlan::args, ARRAY_SUBLINK, Assert(), BoolGetDatum(), CTE_SUBLINK, SubPlanState::curArray, CurrentMemoryContext, SubPlanState::curTuple, DatumGetPointer(), ExprContext::ecxt_param_exec_vals, ExprContext::ecxt_per_query_memory, elog, ereport, errcode(), errmsg(), ERROR, EState::es_direction, ExecCopySlotHeapTuple(), ParamExecData::execPlan, ExecProcNode(), EXISTS_SUBLINK, EXPR_SUBLINK, SubPlan::firstColType, ForwardScanDirection, heap_freetuple(), heap_getattr(), i, initArrayResultAny(), ParamExecData::isnull, lfirst_int, linitial_int, makeArrayResultAny(), MemoryContextSwitchTo(), MULTIEXPR_SUBLINK, SubPlan::parParam, pfree(), SubPlanState::planstate, PointerGetDatum(), ROWCOMPARE_SUBLINK, SubPlan::setParam, slot_getattr(), PlanState::state, SubPlan::subLinkType, SubPlanState::subplan, TupleTableSlot::tts_tupleDescriptor, TupIsNull, TupleDescAttr(), and ParamExecData::value.

Referenced by ExecEvalParamExec(), and ExecSetParamPlanMulti().

◆ ExecSetParamPlanMulti()

void ExecSetParamPlanMulti ( const Bitmapset *  params,
ExprContext *  econtext 
)

Definition at line 1251 of file nodeSubplan.c.

1252{
1253 int paramid;
1254
1255 paramid = -1;
1256 while ((paramid = bms_next_member(params, paramid)) >= 0)
1257 {
1258 ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1259
1260 if (prm->execPlan != NULL)
1261 {
1262 /* Parameter not evaluated yet, so go do it */
1263 ExecSetParamPlan(prm->execPlan, econtext);
1264 /* ExecSetParamPlan should have processed this param... */
1265 Assert(prm->execPlan == NULL);
1266 }
1267 }
1268}
int bms_next_member(const Bitmapset *a, int prevbit)
Definition: bitmapset.c:1306
void ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
Definition: nodeSubplan.c:1075

References Assert(), bms_next_member(), ExprContext::ecxt_param_exec_vals, ParamExecData::execPlan, and ExecSetParamPlan().

Referenced by EvalPlanQualBegin(), EvalPlanQualStart(), ExecInitParallelPlan(), and ExecParallelReinitialize().

◆ ExecSubPlan()

Datum ExecSubPlan ( SubPlanState *  node,
ExprContext *  econtext,
bool *  isNull 
)

Definition at line 62 of file nodeSubplan.c.

65{
66 SubPlan *subplan = node->subplan;
67 EState *estate = node->planstate->state;
68 ScanDirection dir = estate->es_direction;
69 Datum retval;
70
72
73 /* Set non-null as default */
74 *isNull = false;
75
76 /* Sanity checks */
77 if (subplan->subLinkType == CTE_SUBLINK)
78 elog(ERROR, "CTE subplans should not be executed via ExecSubPlan");
79 if (subplan->setParam != NIL && subplan->subLinkType != MULTIEXPR_SUBLINK)
80 elog(ERROR, "cannot set parent params from subquery");
81
82 /* Force forward-scan mode for evaluation */
84
85 /* Select appropriate evaluation strategy */
86 if (subplan->useHashTable)
87 retval = ExecHashSubPlan(node, econtext, isNull);
88 else
89 retval = ExecScanSubPlan(node, econtext, isNull);
90
91 /* restore scan direction */
92 estate->es_direction = dir;
93
94 return retval;
95}
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
static Datum ExecHashSubPlan(SubPlanState *node, ExprContext *econtext, bool *isNull)
Definition: nodeSubplan.c:101
static Datum ExecScanSubPlan(SubPlanState *node, ExprContext *econtext, bool *isNull)
Definition: nodeSubplan.c:204

References CHECK_FOR_INTERRUPTS, CTE_SUBLINK, elog, ERROR, EState::es_direction, ExecHashSubPlan(), ExecScanSubPlan(), ForwardScanDirection, MULTIEXPR_SUBLINK, NIL, SubPlanState::planstate, SubPlan::setParam, PlanState::state, SubPlan::subLinkType, SubPlanState::subplan, and SubPlan::useHashTable.

Referenced by ExecEvalSubPlan().

AltStyle によって変換されたページ (->オリジナル) /