1 /*-------------------------------------------------------------------------
4 * top level executor interface routines
11 * The old ExecutorMain() has been replaced by ExecutorStart(),
12 * ExecutorRun() and ExecutorEnd()
14 * These three procedures are the external interfaces to the executor.
15 * In each case, the query descriptor is required as an argument.
17 * ExecutorStart() must be called at the beginning of execution of any
18 * query plan and ExecutorEnd() should always be called at the end of
19 * execution of a plan.
21 * ExecutorRun accepts direction and count arguments that specify whether
22 * the plan is to be executed forwards, backwards, and for how many tuples.
24 * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
25 * Portions Copyright (c) 1994, Regents of the University of California
29 * $PostgreSQL: pgsql/src/backend/executor/execMain.c,v 1.304 2008/03/26 21:10:38 alvherre Exp $
31 *-------------------------------------------------------------------------
35 #include "access/heapam.h"
36 #include "access/reloptions.h"
37 #include "access/transam.h"
38 #include "access/xact.h"
39 #include "catalog/heap.h"
40 #include "catalog/namespace.h"
41 #include "catalog/toasting.h"
42 #include "commands/tablespace.h"
43 #include "commands/trigger.h"
44 #include "executor/execdebug.h"
45 #include "executor/instrument.h"
46 #include "executor/nodeSubplan.h"
47 #include "miscadmin.h"
48 #include "optimizer/clauses.h"
49 #include "parser/parse_clause.h"
50 #include "parser/parsetree.h"
51 #include "storage/smgr.h"
52 #include "utils/acl.h"
53 #include "utils/lsyscache.h"
54 #include "utils/memutils.h"
55 #include "utils/tqual.h"
58 typedef struct evalPlanQual
63 struct evalPlanQual *next; /* stack of active PlanQual plans */
64 struct evalPlanQual *free; /* list of free PlanQual plans */
67 /* decls for local routines only used within this module */
68 static void InitPlan(QueryDesc *queryDesc, int eflags);
69 static void initResultRelInfo(ResultRelInfo *resultRelInfo,
70 Relation resultRelationDesc,
71 Index resultRelationIndex,
74 static void ExecEndPlan(PlanState *planstate, EState *estate);
75 static TupleTableSlot *ExecutePlan(EState *estate, PlanState *planstate,
78 ScanDirection direction,
80 static void ExecSelect(TupleTableSlot *slot,
81 DestReceiver *dest, EState *estate);
82 static void ExecInsert(TupleTableSlot *slot, ItemPointer tupleid,
83 TupleTableSlot *planSlot,
84 DestReceiver *dest, EState *estate);
85 static void ExecDelete(ItemPointer tupleid,
86 TupleTableSlot *planSlot,
87 DestReceiver *dest, EState *estate);
88 static void ExecUpdate(TupleTableSlot *slot, ItemPointer tupleid,
89 TupleTableSlot *planSlot,
90 DestReceiver *dest, EState *estate);
91 static void ExecProcessReturning(ProjectionInfo *projectReturning,
92 TupleTableSlot *tupleSlot,
93 TupleTableSlot *planSlot,
95 static TupleTableSlot *EvalPlanQualNext(EState *estate);
96 static void EndEvalPlanQual(EState *estate);
97 static void ExecCheckRTPerms(List *rangeTable);
98 static void ExecCheckRTEPerms(RangeTblEntry *rte);
99 static void ExecCheckXactReadOnly(PlannedStmt *plannedstmt);
100 static void EvalPlanQualStart(evalPlanQual *epq, EState *estate,
101 evalPlanQual *priorepq);
102 static void EvalPlanQualStop(evalPlanQual *epq);
103 static void OpenIntoRel(QueryDesc *queryDesc);
104 static void CloseIntoRel(QueryDesc *queryDesc);
105 static void intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo);
106 static void intorel_receive(TupleTableSlot *slot, DestReceiver *self);
107 static void intorel_shutdown(DestReceiver *self);
108 static void intorel_destroy(DestReceiver *self);
110 /* end of local decls */
113 /* ----------------------------------------------------------------
116 * This routine must be called at the beginning of any execution of any
119 * Takes a QueryDesc previously created by CreateQueryDesc (it's not real
120 * clear why we bother to separate the two functions, but...). The tupDesc
121 * field of the QueryDesc is filled in to describe the tuples that will be
122 * returned, and the internal fields (estate and planstate) are set up.
124 * eflags contains flag bits as described in executor.h.
126 * NB: the CurrentMemoryContext when this is called will become the parent
127 * of the per-query context used for this Executor invocation.
128 * ----------------------------------------------------------------
131 ExecutorStart(QueryDesc *queryDesc, int eflags)
134 MemoryContext oldcontext;
136 /* sanity checks: queryDesc must not be started already */
137 Assert(queryDesc != NULL);
138 Assert(queryDesc->estate == NULL);
141 * If the transaction is read-only, we need to check if any writes are
142 * planned to non-temporary tables. EXPLAIN is considered read-only.
144 if (XactReadOnly && !(eflags & EXEC_FLAG_EXPLAIN_ONLY))
145 ExecCheckXactReadOnly(queryDesc->plannedstmt);
148 * Build EState, switch into per-query memory context for startup.
150 estate = CreateExecutorState();
151 queryDesc->estate = estate;
153 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
156 * Fill in parameters, if any, from queryDesc
158 estate->es_param_list_info = queryDesc->params;
160 if (queryDesc->plannedstmt->nParamExec > 0)
161 estate->es_param_exec_vals = (ParamExecData *)
162 palloc0(queryDesc->plannedstmt->nParamExec * sizeof(ParamExecData));
165 * If non-read-only query, set the command ID to mark output tuples with
167 switch (queryDesc->operation)
170 /* SELECT INTO and SELECT FOR UPDATE/SHARE need to mark tuples */
171 if (queryDesc->plannedstmt->intoClause != NULL ||
172 queryDesc->plannedstmt->rowMarks != NIL)
173 estate->es_output_cid = GetCurrentCommandId(true);
179 estate->es_output_cid = GetCurrentCommandId(true);
183 elog(ERROR, "unrecognized operation code: %d",
184 (int) queryDesc->operation);
189 * Copy other important information into the EState
191 estate->es_snapshot = queryDesc->snapshot;
192 estate->es_crosscheck_snapshot = queryDesc->crosscheck_snapshot;
193 estate->es_instrument = queryDesc->doInstrument;
196 * Initialize the plan state tree
198 InitPlan(queryDesc, eflags);
200 MemoryContextSwitchTo(oldcontext);
203 /* ----------------------------------------------------------------
206 * This is the main routine of the executor module. It accepts
207 * the query descriptor from the traffic cop and executes the
210 * ExecutorStart must have been called already.
212 * If direction is NoMovementScanDirection then nothing is done
213 * except to start up/shut down the destination. Otherwise,
214 * we retrieve up to 'count' tuples in the specified direction.
216 * Note: count = 0 is interpreted as no portal limit, i.e., run to
219 * ----------------------------------------------------------------
222 ExecutorRun(QueryDesc *queryDesc,
223 ScanDirection direction, long count)
229 TupleTableSlot *result;
230 MemoryContext oldcontext;
233 Assert(queryDesc != NULL);
235 estate = queryDesc->estate;
237 Assert(estate != NULL);
240 * Switch into per-query memory context
242 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
245 * extract information from the query descriptor and the query feature.
247 operation = queryDesc->operation;
248 dest = queryDesc->dest;
251 * startup tuple receiver, if we will be emitting tuples
253 estate->es_processed = 0;
254 estate->es_lastoid = InvalidOid;
256 sendTuples = (operation == CMD_SELECT ||
257 queryDesc->plannedstmt->returningLists);
260 (*dest->rStartup) (dest, operation, queryDesc->tupDesc);
265 if (ScanDirectionIsNoMovement(direction))
268 result = ExecutePlan(estate,
269 queryDesc->planstate,
276 * shutdown tuple receiver, if we started it
279 (*dest->rShutdown) (dest);
281 MemoryContextSwitchTo(oldcontext);
286 /* ----------------------------------------------------------------
289 * This routine must be called at the end of execution of any
291 * ----------------------------------------------------------------
294 ExecutorEnd(QueryDesc *queryDesc)
297 MemoryContext oldcontext;
300 Assert(queryDesc != NULL);
302 estate = queryDesc->estate;
304 Assert(estate != NULL);
307 * Switch into per-query memory context to run ExecEndPlan
309 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
311 ExecEndPlan(queryDesc->planstate, estate);
314 * Close the SELECT INTO relation if any
316 if (estate->es_select_into)
317 CloseIntoRel(queryDesc);
320 * Must switch out of context before destroying it
322 MemoryContextSwitchTo(oldcontext);
325 * Release EState and per-query memory context. This should release
326 * everything the executor has allocated.
328 FreeExecutorState(estate);
330 /* Reset queryDesc fields that no longer point to anything */
331 queryDesc->tupDesc = NULL;
332 queryDesc->estate = NULL;
333 queryDesc->planstate = NULL;
336 /* ----------------------------------------------------------------
339 * This routine may be called on an open queryDesc to rewind it
341 * ----------------------------------------------------------------
344 ExecutorRewind(QueryDesc *queryDesc)
347 MemoryContext oldcontext;
350 Assert(queryDesc != NULL);
352 estate = queryDesc->estate;
354 Assert(estate != NULL);
356 /* It's probably not sensible to rescan updating queries */
357 Assert(queryDesc->operation == CMD_SELECT);
360 * Switch into per-query memory context
362 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
367 ExecReScan(queryDesc->planstate, NULL);
369 MemoryContextSwitchTo(oldcontext);
375 * Check access permissions for all relations listed in a range table.
378 ExecCheckRTPerms(List *rangeTable)
382 foreach(l, rangeTable)
384 ExecCheckRTEPerms((RangeTblEntry *) lfirst(l));
390 * Check access permissions for a single RTE.
393 ExecCheckRTEPerms(RangeTblEntry *rte)
395 AclMode requiredPerms;
400 * Only plain-relation RTEs need to be checked here. Function RTEs are
401 * checked by init_fcache when the function is prepared for execution.
402 * Join, subquery, and special RTEs need no checks.
404 if (rte->rtekind != RTE_RELATION)
408 * No work if requiredPerms is empty.
410 requiredPerms = rte->requiredPerms;
411 if (requiredPerms == 0)
417 * userid to check as: current user unless we have a setuid indication.
419 * Note: GetUserId() is presently fast enough that there's no harm in
420 * calling it separately for each RTE. If that stops being true, we could
421 * call it once in ExecCheckRTPerms and pass the userid down from there.
422 * But for now, no need for the extra clutter.
424 userid = rte->checkAsUser ? rte->checkAsUser : GetUserId();
427 * We must have *all* the requiredPerms bits, so use aclmask not aclcheck.
429 if (pg_class_aclmask(relOid, userid, requiredPerms, ACLMASK_ALL)
431 aclcheck_error(ACLCHECK_NO_PRIV, ACL_KIND_CLASS,
432 get_rel_name(relOid));
436 * Check that the query does not imply any writes to non-temp tables.
439 ExecCheckXactReadOnly(PlannedStmt *plannedstmt)
444 * CREATE TABLE AS or SELECT INTO?
446 * XXX should we allow this if the destination is temp?
448 if (plannedstmt->intoClause != NULL)
451 /* Fail if write permissions are requested on any non-temp table */
452 foreach(l, plannedstmt->rtable)
454 RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
456 if (rte->rtekind != RTE_RELATION)
459 if ((rte->requiredPerms & (~ACL_SELECT)) == 0)
462 if (isTempNamespace(get_rel_namespace(rte->relid)))
472 (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
473 errmsg("transaction is read-only")));
477 /* ----------------------------------------------------------------
480 * Initializes the query plan: open files, allocate storage
481 * and start up the rule manager
482 * ----------------------------------------------------------------
485 InitPlan(QueryDesc *queryDesc, int eflags)
487 CmdType operation = queryDesc->operation;
488 PlannedStmt *plannedstmt = queryDesc->plannedstmt;
489 Plan *plan = plannedstmt->planTree;
490 List *rangeTable = plannedstmt->rtable;
491 EState *estate = queryDesc->estate;
492 PlanState *planstate;
498 * Do permissions checks
500 ExecCheckRTPerms(rangeTable);
503 * initialize the node's execution state
505 estate->es_range_table = rangeTable;
508 * initialize result relation stuff
510 if (plannedstmt->resultRelations)
512 List *resultRelations = plannedstmt->resultRelations;
513 int numResultRelations = list_length(resultRelations);
514 ResultRelInfo *resultRelInfos;
515 ResultRelInfo *resultRelInfo;
517 resultRelInfos = (ResultRelInfo *)
518 palloc(numResultRelations * sizeof(ResultRelInfo));
519 resultRelInfo = resultRelInfos;
520 foreach(l, resultRelations)
522 Index resultRelationIndex = lfirst_int(l);
523 Oid resultRelationOid;
524 Relation resultRelation;
526 resultRelationOid = getrelid(resultRelationIndex, rangeTable);
527 resultRelation = heap_open(resultRelationOid, RowExclusiveLock);
528 initResultRelInfo(resultRelInfo,
532 estate->es_instrument);
535 estate->es_result_relations = resultRelInfos;
536 estate->es_num_result_relations = numResultRelations;
537 /* Initialize to first or only result rel */
538 estate->es_result_relation_info = resultRelInfos;
543 * if no result relation, then set state appropriately
545 estate->es_result_relations = NULL;
546 estate->es_num_result_relations = 0;
547 estate->es_result_relation_info = NULL;
551 * Detect whether we're doing SELECT INTO. If so, set the es_into_oids
552 * flag appropriately so that the plan tree will be initialized with the
553 * correct tuple descriptors. (Other SELECT INTO stuff comes later.)
555 estate->es_select_into = false;
556 if (operation == CMD_SELECT && plannedstmt->intoClause != NULL)
558 estate->es_select_into = true;
559 estate->es_into_oids = interpretOidsOption(plannedstmt->intoClause->options);
563 * Have to lock relations selected FOR UPDATE/FOR SHARE before we
564 * initialize the plan tree, else we'd be doing a lock upgrade. While we
565 * are at it, build the ExecRowMark list.
567 estate->es_rowMarks = NIL;
568 foreach(l, plannedstmt->rowMarks)
570 RowMarkClause *rc = (RowMarkClause *) lfirst(l);
571 Oid relid = getrelid(rc->rti, rangeTable);
575 relation = heap_open(relid, RowShareLock);
576 erm = (ExecRowMark *) palloc(sizeof(ExecRowMark));
577 erm->relation = relation;
579 erm->forUpdate = rc->forUpdate;
580 erm->noWait = rc->noWait;
581 /* We'll set up ctidAttno below */
582 erm->ctidAttNo = InvalidAttrNumber;
583 estate->es_rowMarks = lappend(estate->es_rowMarks, erm);
587 * Initialize the executor "tuple" table. We need slots for all the plan
588 * nodes, plus possibly output slots for the junkfilter(s). At this point
589 * we aren't sure if we need junkfilters, so just add slots for them
590 * unconditionally. Also, if it's not a SELECT, set up a slot for use for
591 * trigger output tuples. Also, one for RETURNING-list evaluation.
596 /* Slots for the main plan tree */
597 nSlots = ExecCountSlotsNode(plan);
598 /* Add slots for subplans and initplans */
599 foreach(l, plannedstmt->subplans)
601 Plan *subplan = (Plan *) lfirst(l);
603 nSlots += ExecCountSlotsNode(subplan);
605 /* Add slots for junkfilter(s) */
606 if (plannedstmt->resultRelations != NIL)
607 nSlots += list_length(plannedstmt->resultRelations);
610 if (operation != CMD_SELECT)
611 nSlots++; /* for es_trig_tuple_slot */
612 if (plannedstmt->returningLists)
613 nSlots++; /* for RETURNING projection */
615 estate->es_tupleTable = ExecCreateTupleTable(nSlots);
617 if (operation != CMD_SELECT)
618 estate->es_trig_tuple_slot =
619 ExecAllocTableSlot(estate->es_tupleTable);
622 /* mark EvalPlanQual not active */
623 estate->es_plannedstmt = plannedstmt;
624 estate->es_evalPlanQual = NULL;
625 estate->es_evTupleNull = NULL;
626 estate->es_evTuple = NULL;
627 estate->es_useEvalPlan = false;
630 * Initialize private state information for each SubPlan. We must do this
631 * before running ExecInitNode on the main query tree, since
632 * ExecInitSubPlan expects to be able to find these entries.
634 Assert(estate->es_subplanstates == NIL);
635 i = 1; /* subplan indices count from 1 */
636 foreach(l, plannedstmt->subplans)
638 Plan *subplan = (Plan *) lfirst(l);
639 PlanState *subplanstate;
643 * A subplan will never need to do BACKWARD scan nor MARK/RESTORE. If
644 * it is a parameterless subplan (not initplan), we suggest that it be
645 * prepared to handle REWIND efficiently; otherwise there is no need.
647 sp_eflags = eflags & EXEC_FLAG_EXPLAIN_ONLY;
648 if (bms_is_member(i, plannedstmt->rewindPlanIDs))
649 sp_eflags |= EXEC_FLAG_REWIND;
651 subplanstate = ExecInitNode(subplan, estate, sp_eflags);
653 estate->es_subplanstates = lappend(estate->es_subplanstates,
660 * Initialize the private state information for all the nodes in the query
661 * tree. This opens files, allocates storage and leaves us ready to start
664 planstate = ExecInitNode(plan, estate, eflags);
667 * Get the tuple descriptor describing the type of tuples to return. (this
668 * is especially important if we are creating a relation with "SELECT
671 tupType = ExecGetResultType(planstate);
674 * Initialize the junk filter if needed. SELECT and INSERT queries need a
675 * filter if there are any junk attrs in the tlist. INSERT and SELECT
676 * INTO also need a filter if the plan may return raw disk tuples (else
677 * heap_insert will be scribbling on the source relation!). UPDATE and
678 * DELETE always need a filter, since there's always a junk 'ctid'
679 * attribute present --- no need to look first.
682 bool junk_filter_needed = false;
689 foreach(tlist, plan->targetlist)
691 TargetEntry *tle = (TargetEntry *) lfirst(tlist);
695 junk_filter_needed = true;
699 if (!junk_filter_needed &&
700 (operation == CMD_INSERT || estate->es_select_into) &&
701 ExecMayReturnRawTuples(planstate))
702 junk_filter_needed = true;
706 junk_filter_needed = true;
712 if (junk_filter_needed)
715 * If there are multiple result relations, each one needs its own
716 * junk filter. Note this is only possible for UPDATE/DELETE, so
717 * we can't be fooled by some needing a filter and some not.
719 if (list_length(plannedstmt->resultRelations) > 1)
721 PlanState **appendplans;
723 ResultRelInfo *resultRelInfo;
725 /* Top plan had better be an Append here. */
726 Assert(IsA(plan, Append));
727 Assert(((Append *) plan)->isTarget);
728 Assert(IsA(planstate, AppendState));
729 appendplans = ((AppendState *) planstate)->appendplans;
730 as_nplans = ((AppendState *) planstate)->as_nplans;
731 Assert(as_nplans == estate->es_num_result_relations);
732 resultRelInfo = estate->es_result_relations;
733 for (i = 0; i < as_nplans; i++)
735 PlanState *subplan = appendplans[i];
738 j = ExecInitJunkFilter(subplan->plan->targetlist,
739 resultRelInfo->ri_RelationDesc->rd_att->tdhasoid,
740 ExecAllocTableSlot(estate->es_tupleTable));
743 * Since it must be UPDATE/DELETE, there had better be a
744 * "ctid" junk attribute in the tlist ... but ctid could
745 * be at a different resno for each result relation. We
746 * look up the ctid resnos now and save them in the
749 j->jf_junkAttNo = ExecFindJunkAttribute(j, "ctid");
750 if (!AttributeNumberIsValid(j->jf_junkAttNo))
751 elog(ERROR, "could not find junk ctid column");
752 resultRelInfo->ri_junkFilter = j;
757 * Set active junkfilter too; at this point ExecInitAppend has
758 * already selected an active result relation...
760 estate->es_junkFilter =
761 estate->es_result_relation_info->ri_junkFilter;
765 /* Normal case with just one JunkFilter */
768 j = ExecInitJunkFilter(planstate->plan->targetlist,
770 ExecAllocTableSlot(estate->es_tupleTable));
771 estate->es_junkFilter = j;
772 if (estate->es_result_relation_info)
773 estate->es_result_relation_info->ri_junkFilter = j;
775 if (operation == CMD_SELECT)
777 /* For SELECT, want to return the cleaned tuple type */
778 tupType = j->jf_cleanTupType;
779 /* For SELECT FOR UPDATE/SHARE, find the ctid attrs now */
780 foreach(l, estate->es_rowMarks)
782 ExecRowMark *erm = (ExecRowMark *) lfirst(l);
785 snprintf(resname, sizeof(resname), "ctid%u", erm->rti);
786 erm->ctidAttNo = ExecFindJunkAttribute(j, resname);
787 if (!AttributeNumberIsValid(erm->ctidAttNo))
788 elog(ERROR, "could not find junk \"%s\" column",
792 else if (operation == CMD_UPDATE || operation == CMD_DELETE)
794 /* For UPDATE/DELETE, find the ctid junk attr now */
795 j->jf_junkAttNo = ExecFindJunkAttribute(j, "ctid");
796 if (!AttributeNumberIsValid(j->jf_junkAttNo))
797 elog(ERROR, "could not find junk ctid column");
802 estate->es_junkFilter = NULL;
806 * Initialize RETURNING projections if needed.
808 if (plannedstmt->returningLists)
810 TupleTableSlot *slot;
811 ExprContext *econtext;
812 ResultRelInfo *resultRelInfo;
815 * We set QueryDesc.tupDesc to be the RETURNING rowtype in this case.
816 * We assume all the sublists will generate the same output tupdesc.
818 tupType = ExecTypeFromTL((List *) linitial(plannedstmt->returningLists),
821 /* Set up a slot for the output of the RETURNING projection(s) */
822 slot = ExecAllocTableSlot(estate->es_tupleTable);
823 ExecSetSlotDescriptor(slot, tupType);
824 /* Need an econtext too */
825 econtext = CreateExprContext(estate);
828 * Build a projection for each result rel. Note that any SubPlans in
829 * the RETURNING lists get attached to the topmost plan node.
831 Assert(list_length(plannedstmt->returningLists) == estate->es_num_result_relations);
832 resultRelInfo = estate->es_result_relations;
833 foreach(l, plannedstmt->returningLists)
835 List *rlist = (List *) lfirst(l);
838 rliststate = (List *) ExecInitExpr((Expr *) rlist, planstate);
839 resultRelInfo->ri_projectReturning =
840 ExecBuildProjectionInfo(rliststate, econtext, slot,
841 resultRelInfo->ri_RelationDesc->rd_att);
846 queryDesc->tupDesc = tupType;
847 queryDesc->planstate = planstate;
850 * If doing SELECT INTO, initialize the "into" relation. We must wait
851 * till now so we have the "clean" result tuple type to create the new
854 * If EXPLAIN, skip creating the "into" relation.
856 if (estate->es_select_into && !(eflags & EXEC_FLAG_EXPLAIN_ONLY))
857 OpenIntoRel(queryDesc);
861 * Initialize ResultRelInfo data for one result relation
864 initResultRelInfo(ResultRelInfo *resultRelInfo,
865 Relation resultRelationDesc,
866 Index resultRelationIndex,
871 * Check valid relkind ... parser and/or planner should have noticed this
872 * already, but let's make sure.
874 switch (resultRelationDesc->rd_rel->relkind)
876 case RELKIND_RELATION:
879 case RELKIND_SEQUENCE:
881 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
882 errmsg("cannot change sequence \"%s\"",
883 RelationGetRelationName(resultRelationDesc))));
885 case RELKIND_TOASTVALUE:
887 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
888 errmsg("cannot change TOAST relation \"%s\"",
889 RelationGetRelationName(resultRelationDesc))));
893 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
894 errmsg("cannot change view \"%s\"",
895 RelationGetRelationName(resultRelationDesc))));
899 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
900 errmsg("cannot change relation \"%s\"",
901 RelationGetRelationName(resultRelationDesc))));
905 /* OK, fill in the node */
906 MemSet(resultRelInfo, 0, sizeof(ResultRelInfo));
907 resultRelInfo->type = T_ResultRelInfo;
908 resultRelInfo->ri_RangeTableIndex = resultRelationIndex;
909 resultRelInfo->ri_RelationDesc = resultRelationDesc;
910 resultRelInfo->ri_NumIndices = 0;
911 resultRelInfo->ri_IndexRelationDescs = NULL;
912 resultRelInfo->ri_IndexRelationInfo = NULL;
913 /* make a copy so as not to depend on relcache info not changing... */
914 resultRelInfo->ri_TrigDesc = CopyTriggerDesc(resultRelationDesc->trigdesc);
915 if (resultRelInfo->ri_TrigDesc)
917 int n = resultRelInfo->ri_TrigDesc->numtriggers;
919 resultRelInfo->ri_TrigFunctions = (FmgrInfo *)
920 palloc0(n * sizeof(FmgrInfo));
922 resultRelInfo->ri_TrigInstrument = InstrAlloc(n);
924 resultRelInfo->ri_TrigInstrument = NULL;
928 resultRelInfo->ri_TrigFunctions = NULL;
929 resultRelInfo->ri_TrigInstrument = NULL;
931 resultRelInfo->ri_ConstraintExprs = NULL;
932 resultRelInfo->ri_junkFilter = NULL;
933 resultRelInfo->ri_projectReturning = NULL;
936 * If there are indices on the result relation, open them and save
937 * descriptors in the result relation info, so that we can add new index
938 * entries for the tuples we add/update. We need not do this for a
939 * DELETE, however, since deletion doesn't affect indexes.
941 if (resultRelationDesc->rd_rel->relhasindex &&
942 operation != CMD_DELETE)
943 ExecOpenIndices(resultRelInfo);
947 * ExecGetTriggerResultRel
949 * Get a ResultRelInfo for a trigger target relation. Most of the time,
950 * triggers are fired on one of the result relations of the query, and so
951 * we can just return a member of the es_result_relations array. (Note: in
952 * self-join situations there might be multiple members with the same OID;
953 * if so it doesn't matter which one we pick.) However, it is sometimes
954 * necessary to fire triggers on other relations; this happens mainly when an
955 * RI update trigger queues additional triggers on other relations, which will
956 * be processed in the context of the outer query. For efficiency's sake,
957 * we want to have a ResultRelInfo for those triggers too; that can avoid
958 * repeated re-opening of the relation. (It also provides a way for EXPLAIN
959 * ANALYZE to report the runtimes of such triggers.) So we make additional
960 * ResultRelInfo's as needed, and save them in es_trig_target_relations.
963 ExecGetTriggerResultRel(EState *estate, Oid relid)
965 ResultRelInfo *rInfo;
969 MemoryContext oldcontext;
971 /* First, search through the query result relations */
972 rInfo = estate->es_result_relations;
973 nr = estate->es_num_result_relations;
976 if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
981 /* Nope, but maybe we already made an extra ResultRelInfo for it */
982 foreach(l, estate->es_trig_target_relations)
984 rInfo = (ResultRelInfo *) lfirst(l);
985 if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
988 /* Nope, so we need a new one */
991 * Open the target relation's relcache entry. We assume that an
992 * appropriate lock is still held by the backend from whenever the trigger
993 * event got queued, so we need take no new lock here.
995 rel = heap_open(relid, NoLock);
998 * Make the new entry in the right context. Currently, we don't need any
999 * index information in ResultRelInfos used only for triggers, so tell
1000 * initResultRelInfo it's a DELETE.
1002 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1003 rInfo = makeNode(ResultRelInfo);
1004 initResultRelInfo(rInfo,
1006 0, /* dummy rangetable index */
1008 estate->es_instrument);
1009 estate->es_trig_target_relations =
1010 lappend(estate->es_trig_target_relations, rInfo);
1011 MemoryContextSwitchTo(oldcontext);
1017 * ExecContextForcesOids
1019 * This is pretty grotty: when doing INSERT, UPDATE, or SELECT INTO,
1020 * we need to ensure that result tuples have space for an OID iff they are
1021 * going to be stored into a relation that has OIDs. In other contexts
1022 * we are free to choose whether to leave space for OIDs in result tuples
1023 * (we generally don't want to, but we do if a physical-tlist optimization
1024 * is possible). This routine checks the plan context and returns TRUE if the
1025 * choice is forced, FALSE if the choice is not forced. In the TRUE case,
1026 * *hasoids is set to the required value.
1028 * One reason this is ugly is that all plan nodes in the plan tree will emit
1029 * tuples with space for an OID, though we really only need the topmost node
1030 * to do so. However, node types like Sort don't project new tuples but just
1031 * return their inputs, and in those cases the requirement propagates down
1032 * to the input node. Eventually we might make this code smart enough to
1033 * recognize how far down the requirement really goes, but for now we just
1034 * make all plan nodes do the same thing if the top level forces the choice.
1036 * We assume that estate->es_result_relation_info is already set up to
1037 * describe the target relation. Note that in an UPDATE that spans an
1038 * inheritance tree, some of the target relations may have OIDs and some not.
1039 * We have to make the decisions on a per-relation basis as we initialize
1040 * each of the child plans of the topmost Append plan.
1042 * SELECT INTO is even uglier, because we don't have the INTO relation's
1043 * descriptor available when this code runs; we have to look aside at a
1044 * flag set by InitPlan().
1047 ExecContextForcesOids(PlanState *planstate, bool *hasoids)
1049 if (planstate->state->es_select_into)
1051 *hasoids = planstate->state->es_into_oids;
1056 ResultRelInfo *ri = planstate->state->es_result_relation_info;
1060 Relation rel = ri->ri_RelationDesc;
1064 *hasoids = rel->rd_rel->relhasoids;
1073 /* ----------------------------------------------------------------
1076 * Cleans up the query plan -- closes files and frees up storage
1078 * NOTE: we are no longer very worried about freeing storage per se
1079 * in this code; FreeExecutorState should be guaranteed to release all
1080 * memory that needs to be released. What we are worried about doing
1081 * is closing relations and dropping buffer pins. Thus, for example,
1082 * tuple tables must be cleared or dropped to ensure pins are released.
1083 * ----------------------------------------------------------------
1086 ExecEndPlan(PlanState *planstate, EState *estate)
1088 ResultRelInfo *resultRelInfo;
1093 * shut down any PlanQual processing we were doing
1095 if (estate->es_evalPlanQual != NULL)
1096 EndEvalPlanQual(estate);
1099 * shut down the node-type-specific query processing
1101 ExecEndNode(planstate);
1106 foreach(l, estate->es_subplanstates)
1108 PlanState *subplanstate = (PlanState *) lfirst(l);
1110 ExecEndNode(subplanstate);
1114 * destroy the executor "tuple" table.
1116 ExecDropTupleTable(estate->es_tupleTable, true);
1117 estate->es_tupleTable = NULL;
1120 * close the result relation(s) if any, but hold locks until xact commit.
1122 resultRelInfo = estate->es_result_relations;
1123 for (i = estate->es_num_result_relations; i > 0; i--)
1125 /* Close indices and then the relation itself */
1126 ExecCloseIndices(resultRelInfo);
1127 heap_close(resultRelInfo->ri_RelationDesc, NoLock);
1132 * likewise close any trigger target relations
1134 foreach(l, estate->es_trig_target_relations)
1136 resultRelInfo = (ResultRelInfo *) lfirst(l);
1137 /* Close indices and then the relation itself */
1138 ExecCloseIndices(resultRelInfo);
1139 heap_close(resultRelInfo->ri_RelationDesc, NoLock);
1143 * close any relations selected FOR UPDATE/FOR SHARE, again keeping locks
1145 foreach(l, estate->es_rowMarks)
1147 ExecRowMark *erm = lfirst(l);
1149 heap_close(erm->relation, NoLock);
1153 /* ----------------------------------------------------------------
1156 * processes the query plan to retrieve 'numberTuples' tuples in the
1157 * direction specified.
1159 * Retrieves all tuples if numberTuples is 0
1161 * result is either a slot containing the last tuple in the case
1162 * of a SELECT or NULL otherwise.
1164 * Note: the ctid attribute is a 'junk' attribute that is removed before the
1166 * ----------------------------------------------------------------
1168 static TupleTableSlot *
1169 ExecutePlan(EState *estate,
1170 PlanState *planstate,
1173 ScanDirection direction,
1176 JunkFilter *junkfilter;
1177 TupleTableSlot *planSlot;
1178 TupleTableSlot *slot;
1179 ItemPointer tupleid = NULL;
1180 ItemPointerData tuple_ctid;
1181 long current_tuple_count;
1182 TupleTableSlot *result;
1185 * initialize local variables
1187 current_tuple_count = 0;
1191 * Set the direction.
1193 estate->es_direction = direction;
1196 * Process BEFORE EACH STATEMENT triggers
1201 ExecBSUpdateTriggers(estate, estate->es_result_relation_info);
1204 ExecBSDeleteTriggers(estate, estate->es_result_relation_info);
1207 ExecBSInsertTriggers(estate, estate->es_result_relation_info);
1215 * Loop until we've processed the proper number of tuples from the plan.
1220 /* Reset the per-output-tuple exprcontext */
1221 ResetPerTupleExprContext(estate);
1224 * Execute the plan and obtain a tuple
1227 if (estate->es_useEvalPlan)
1229 planSlot = EvalPlanQualNext(estate);
1230 if (TupIsNull(planSlot))
1231 planSlot = ExecProcNode(planstate);
1234 planSlot = ExecProcNode(planstate);
1237 * if the tuple is null, then we assume there is nothing more to
1238 * process so we just return null...
1240 if (TupIsNull(planSlot))
1248 * if we have a junk filter, then project a new tuple with the junk
1251 * Store this new "clean" tuple in the junkfilter's resultSlot.
1252 * (Formerly, we stored it back over the "dirty" tuple, which is WRONG
1253 * because that tuple slot has the wrong descriptor.)
1255 * Also, extract all the junk information we need.
1257 if ((junkfilter = estate->es_junkFilter) != NULL)
1263 * extract the 'ctid' junk attribute.
1265 if (operation == CMD_UPDATE || operation == CMD_DELETE)
1267 datum = ExecGetJunkAttribute(slot, junkfilter->jf_junkAttNo,
1269 /* shouldn't ever get a null result... */
1271 elog(ERROR, "ctid is NULL");
1273 tupleid = (ItemPointer) DatumGetPointer(datum);
1274 tuple_ctid = *tupleid; /* make sure we don't free the ctid!! */
1275 tupleid = &tuple_ctid;
1279 * Process any FOR UPDATE or FOR SHARE locking requested.
1281 else if (estate->es_rowMarks != NIL)
1286 foreach(l, estate->es_rowMarks)
1288 ExecRowMark *erm = lfirst(l);
1289 HeapTupleData tuple;
1291 ItemPointerData update_ctid;
1292 TransactionId update_xmax;
1293 TupleTableSlot *newSlot;
1294 LockTupleMode lockmode;
1297 datum = ExecGetJunkAttribute(slot,
1300 /* shouldn't ever get a null result... */
1302 elog(ERROR, "ctid is NULL");
1304 tuple.t_self = *((ItemPointer) DatumGetPointer(datum));
1307 lockmode = LockTupleExclusive;
1309 lockmode = LockTupleShared;
1311 test = heap_lock_tuple(erm->relation, &tuple, &buffer,
1312 &update_ctid, &update_xmax,
1313 estate->es_output_cid,
1314 lockmode, erm->noWait);
1315 ReleaseBuffer(buffer);
1318 case HeapTupleSelfUpdated:
1319 /* treat it as deleted; do not process */
1322 case HeapTupleMayBeUpdated:
1325 case HeapTupleUpdated:
1326 if (IsXactIsoLevelSerializable)
1328 (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
1329 errmsg("could not serialize access due to concurrent update")));
1330 if (!ItemPointerEquals(&update_ctid,
1333 /* updated, so look at updated version */
1334 newSlot = EvalPlanQual(estate,
1338 if (!TupIsNull(newSlot))
1340 slot = planSlot = newSlot;
1341 estate->es_useEvalPlan = true;
1347 * if tuple was deleted or PlanQual failed for
1348 * updated tuple - we must not return this tuple!
1353 elog(ERROR, "unrecognized heap_lock_tuple status: %u",
1361 * Create a new "clean" tuple with all junk attributes removed. We
1362 * don't need to do this for DELETE, however (there will in fact
1363 * be no non-junk attributes in a DELETE!)
1365 if (operation != CMD_DELETE)
1366 slot = ExecFilterJunk(junkfilter, slot);
1370 * now that we have a tuple, do the appropriate thing with it.. either
1371 * return it to the user, add it to a relation someplace, delete it
1372 * from a relation, or modify some of its attributes.
1377 ExecSelect(slot, dest, estate);
1382 ExecInsert(slot, tupleid, planSlot, dest, estate);
1387 ExecDelete(tupleid, planSlot, dest, estate);
1392 ExecUpdate(slot, tupleid, planSlot, dest, estate);
1397 elog(ERROR, "unrecognized operation code: %d",
1404 * check our tuple count.. if we've processed the proper number then
1405 * quit, else loop again and process more tuples. Zero numberTuples
1408 current_tuple_count++;
1409 if (numberTuples && numberTuples == current_tuple_count)
1414 * Process AFTER EACH STATEMENT triggers
1419 ExecASUpdateTriggers(estate, estate->es_result_relation_info);
1422 ExecASDeleteTriggers(estate, estate->es_result_relation_info);
1425 ExecASInsertTriggers(estate, estate->es_result_relation_info);
1433 * here, result is either a slot containing a tuple in the case of a
1434 * SELECT or NULL otherwise.
1439 /* ----------------------------------------------------------------
1442 * SELECTs are easy.. we just pass the tuple to the appropriate
1444 * ----------------------------------------------------------------
1447 ExecSelect(TupleTableSlot *slot,
1451 (*dest->receiveSlot) (slot, dest);
1453 (estate->es_processed)++;
1456 /* ----------------------------------------------------------------
1459 * INSERTs are trickier.. we have to insert the tuple into
1460 * the base relation and insert appropriate tuples into the
1462 * ----------------------------------------------------------------
1465 ExecInsert(TupleTableSlot *slot,
1466 ItemPointer tupleid,
1467 TupleTableSlot *planSlot,
1472 ResultRelInfo *resultRelInfo;
1473 Relation resultRelationDesc;
1477 * get the heap tuple out of the tuple table slot, making sure we have a
1480 tuple = ExecMaterializeSlot(slot);
1483 * get information on the (current) result relation
1485 resultRelInfo = estate->es_result_relation_info;
1486 resultRelationDesc = resultRelInfo->ri_RelationDesc;
1488 /* BEFORE ROW INSERT Triggers */
1489 if (resultRelInfo->ri_TrigDesc &&
1490 resultRelInfo->ri_TrigDesc->n_before_row[TRIGGER_EVENT_INSERT] > 0)
1494 newtuple = ExecBRInsertTriggers(estate, resultRelInfo, tuple);
1496 if (newtuple == NULL) /* "do nothing" */
1499 if (newtuple != tuple) /* modified by Trigger(s) */
1502 * Put the modified tuple into a slot for convenience of routines
1503 * below. We assume the tuple was allocated in per-tuple memory
1504 * context, and therefore will go away by itself. The tuple table
1505 * slot should not try to clear it.
1507 TupleTableSlot *newslot = estate->es_trig_tuple_slot;
1509 if (newslot->tts_tupleDescriptor != slot->tts_tupleDescriptor)
1510 ExecSetSlotDescriptor(newslot, slot->tts_tupleDescriptor);
1511 ExecStoreTuple(newtuple, newslot, InvalidBuffer, false);
1518 * Check the constraints of the tuple
1520 if (resultRelationDesc->rd_att->constr)
1521 ExecConstraints(resultRelInfo, slot, estate);
1526 * Note: heap_insert returns the tid (location) of the new tuple in the
1529 newId = heap_insert(resultRelationDesc, tuple,
1530 estate->es_output_cid,
1534 (estate->es_processed)++;
1535 estate->es_lastoid = newId;
1536 setLastTid(&(tuple->t_self));
1539 * insert index entries for tuple
1541 if (resultRelInfo->ri_NumIndices > 0)
1542 ExecInsertIndexTuples(slot, &(tuple->t_self), estate, false);
1544 /* AFTER ROW INSERT Triggers */
1545 ExecARInsertTriggers(estate, resultRelInfo, tuple);
1547 /* Process RETURNING if present */
1548 if (resultRelInfo->ri_projectReturning)
1549 ExecProcessReturning(resultRelInfo->ri_projectReturning,
1550 slot, planSlot, dest);
1553 /* ----------------------------------------------------------------
1556 * DELETE is like UPDATE, except that we delete the tuple and no
1557 * index modifications are needed
1558 * ----------------------------------------------------------------
1561 ExecDelete(ItemPointer tupleid,
1562 TupleTableSlot *planSlot,
1566 ResultRelInfo *resultRelInfo;
1567 Relation resultRelationDesc;
1569 ItemPointerData update_ctid;
1570 TransactionId update_xmax;
1573 * get information on the (current) result relation
1575 resultRelInfo = estate->es_result_relation_info;
1576 resultRelationDesc = resultRelInfo->ri_RelationDesc;
1578 /* BEFORE ROW DELETE Triggers */
1579 if (resultRelInfo->ri_TrigDesc &&
1580 resultRelInfo->ri_TrigDesc->n_before_row[TRIGGER_EVENT_DELETE] > 0)
1584 dodelete = ExecBRDeleteTriggers(estate, resultRelInfo, tupleid);
1586 if (!dodelete) /* "do nothing" */
1593 * Note: if es_crosscheck_snapshot isn't InvalidSnapshot, we check that
1594 * the row to be deleted is visible to that snapshot, and throw a can't-
1595 * serialize error if not. This is a special-case behavior needed for
1596 * referential integrity updates in serializable transactions.
1599 result = heap_delete(resultRelationDesc, tupleid,
1600 &update_ctid, &update_xmax,
1601 estate->es_output_cid,
1602 estate->es_crosscheck_snapshot,
1603 true /* wait for commit */ );
1606 case HeapTupleSelfUpdated:
1607 /* already deleted by self; nothing to do */
1610 case HeapTupleMayBeUpdated:
1613 case HeapTupleUpdated:
1614 if (IsXactIsoLevelSerializable)
1616 (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
1617 errmsg("could not serialize access due to concurrent update")));
1618 else if (!ItemPointerEquals(tupleid, &update_ctid))
1620 TupleTableSlot *epqslot;
1622 epqslot = EvalPlanQual(estate,
1623 resultRelInfo->ri_RangeTableIndex,
1626 if (!TupIsNull(epqslot))
1628 *tupleid = update_ctid;
1632 /* tuple already deleted; nothing to do */
1636 elog(ERROR, "unrecognized heap_delete status: %u", result);
1641 (estate->es_processed)++;
1644 * Note: Normally one would think that we have to delete index tuples
1645 * associated with the heap tuple now...
1647 * ... but in POSTGRES, we have no need to do this because VACUUM will
1648 * take care of it later. We can't delete index tuples immediately
1649 * anyway, since the tuple is still visible to other transactions.
1652 /* AFTER ROW DELETE Triggers */
1653 ExecARDeleteTriggers(estate, resultRelInfo, tupleid);
1655 /* Process RETURNING if present */
1656 if (resultRelInfo->ri_projectReturning)
1659 * We have to put the target tuple into a slot, which means first we
1660 * gotta fetch it. We can use the trigger tuple slot.
1662 TupleTableSlot *slot = estate->es_trig_tuple_slot;
1663 HeapTupleData deltuple;
1666 deltuple.t_self = *tupleid;
1667 if (!heap_fetch(resultRelationDesc, SnapshotAny,
1668 &deltuple, &delbuffer, false, NULL))
1669 elog(ERROR, "failed to fetch deleted tuple for DELETE RETURNING");
1671 if (slot->tts_tupleDescriptor != RelationGetDescr(resultRelationDesc))
1672 ExecSetSlotDescriptor(slot, RelationGetDescr(resultRelationDesc));
1673 ExecStoreTuple(&deltuple, slot, InvalidBuffer, false);
1675 ExecProcessReturning(resultRelInfo->ri_projectReturning,
1676 slot, planSlot, dest);
1678 ExecClearTuple(slot);
1679 ReleaseBuffer(delbuffer);
1683 /* ----------------------------------------------------------------
1686 * note: we can't run UPDATE queries with transactions
1687 * off because UPDATEs are actually INSERTs and our
1688 * scan will mistakenly loop forever, updating the tuple
1689 * it just inserted.. This should be fixed but until it
1690 * is, we don't want to get stuck in an infinite loop
1691 * which corrupts your database..
1692 * ----------------------------------------------------------------
1695 ExecUpdate(TupleTableSlot *slot,
1696 ItemPointer tupleid,
1697 TupleTableSlot *planSlot,
1702 ResultRelInfo *resultRelInfo;
1703 Relation resultRelationDesc;
1705 ItemPointerData update_ctid;
1706 TransactionId update_xmax;
1709 * abort the operation if not running transactions
1711 if (IsBootstrapProcessingMode())
1712 elog(ERROR, "cannot UPDATE during bootstrap");
1715 * get the heap tuple out of the tuple table slot, making sure we have a
1718 tuple = ExecMaterializeSlot(slot);
1721 * get information on the (current) result relation
1723 resultRelInfo = estate->es_result_relation_info;
1724 resultRelationDesc = resultRelInfo->ri_RelationDesc;
1726 /* BEFORE ROW UPDATE Triggers */
1727 if (resultRelInfo->ri_TrigDesc &&
1728 resultRelInfo->ri_TrigDesc->n_before_row[TRIGGER_EVENT_UPDATE] > 0)
1732 newtuple = ExecBRUpdateTriggers(estate, resultRelInfo,
1735 if (newtuple == NULL) /* "do nothing" */
1738 if (newtuple != tuple) /* modified by Trigger(s) */
1741 * Put the modified tuple into a slot for convenience of routines
1742 * below. We assume the tuple was allocated in per-tuple memory
1743 * context, and therefore will go away by itself. The tuple table
1744 * slot should not try to clear it.
1746 TupleTableSlot *newslot = estate->es_trig_tuple_slot;
1748 if (newslot->tts_tupleDescriptor != slot->tts_tupleDescriptor)
1749 ExecSetSlotDescriptor(newslot, slot->tts_tupleDescriptor);
1750 ExecStoreTuple(newtuple, newslot, InvalidBuffer, false);
1757 * Check the constraints of the tuple
1759 * If we generate a new candidate tuple after EvalPlanQual testing, we
1760 * must loop back here and recheck constraints. (We don't need to redo
1761 * triggers, however. If there are any BEFORE triggers then trigger.c
1762 * will have done heap_lock_tuple to lock the correct tuple, so there's no
1763 * need to do them again.)
1766 if (resultRelationDesc->rd_att->constr)
1767 ExecConstraints(resultRelInfo, slot, estate);
1770 * replace the heap tuple
1772 * Note: if es_crosscheck_snapshot isn't InvalidSnapshot, we check that
1773 * the row to be updated is visible to that snapshot, and throw a can't-
1774 * serialize error if not. This is a special-case behavior needed for
1775 * referential integrity updates in serializable transactions.
1777 result = heap_update(resultRelationDesc, tupleid, tuple,
1778 &update_ctid, &update_xmax,
1779 estate->es_output_cid,
1780 estate->es_crosscheck_snapshot,
1781 true /* wait for commit */ );
1784 case HeapTupleSelfUpdated:
1785 /* already deleted by self; nothing to do */
1788 case HeapTupleMayBeUpdated:
1791 case HeapTupleUpdated:
1792 if (IsXactIsoLevelSerializable)
1794 (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
1795 errmsg("could not serialize access due to concurrent update")));
1796 else if (!ItemPointerEquals(tupleid, &update_ctid))
1798 TupleTableSlot *epqslot;
1800 epqslot = EvalPlanQual(estate,
1801 resultRelInfo->ri_RangeTableIndex,
1804 if (!TupIsNull(epqslot))
1806 *tupleid = update_ctid;
1807 slot = ExecFilterJunk(estate->es_junkFilter, epqslot);
1808 tuple = ExecMaterializeSlot(slot);
1812 /* tuple already deleted; nothing to do */
1816 elog(ERROR, "unrecognized heap_update status: %u", result);
1821 (estate->es_processed)++;
1824 * Note: instead of having to update the old index tuples associated with
1825 * the heap tuple, all we do is form and insert new index tuples. This is
1826 * because UPDATEs are actually DELETEs and INSERTs, and index tuple
1827 * deletion is done later by VACUUM (see notes in ExecDelete). All we do
1828 * here is insert new index tuples. -cim 9/27/89
1832 * insert index entries for tuple
1834 * Note: heap_update returns the tid (location) of the new tuple in the
1837 * If it's a HOT update, we mustn't insert new index entries.
1839 if (resultRelInfo->ri_NumIndices > 0 && !HeapTupleIsHeapOnly(tuple))
1840 ExecInsertIndexTuples(slot, &(tuple->t_self), estate, false);
1842 /* AFTER ROW UPDATE Triggers */
1843 ExecARUpdateTriggers(estate, resultRelInfo, tupleid, tuple);
1845 /* Process RETURNING if present */
1846 if (resultRelInfo->ri_projectReturning)
1847 ExecProcessReturning(resultRelInfo->ri_projectReturning,
1848 slot, planSlot, dest);
1852 * ExecRelCheck --- check that tuple meets constraints for result relation
1855 ExecRelCheck(ResultRelInfo *resultRelInfo,
1856 TupleTableSlot *slot, EState *estate)
1858 Relation rel = resultRelInfo->ri_RelationDesc;
1859 int ncheck = rel->rd_att->constr->num_check;
1860 ConstrCheck *check = rel->rd_att->constr->check;
1861 ExprContext *econtext;
1862 MemoryContext oldContext;
1867 * If first time through for this result relation, build expression
1868 * nodetrees for rel's constraint expressions. Keep them in the per-query
1869 * memory context so they'll survive throughout the query.
1871 if (resultRelInfo->ri_ConstraintExprs == NULL)
1873 oldContext = MemoryContextSwitchTo(estate->es_query_cxt);
1874 resultRelInfo->ri_ConstraintExprs =
1875 (List **) palloc(ncheck * sizeof(List *));
1876 for (i = 0; i < ncheck; i++)
1878 /* ExecQual wants implicit-AND form */
1879 qual = make_ands_implicit(stringToNode(check[i].ccbin));
1880 resultRelInfo->ri_ConstraintExprs[i] = (List *)
1881 ExecPrepareExpr((Expr *) qual, estate);
1883 MemoryContextSwitchTo(oldContext);
1887 * We will use the EState's per-tuple context for evaluating constraint
1888 * expressions (creating it if it's not already there).
1890 econtext = GetPerTupleExprContext(estate);
1892 /* Arrange for econtext's scan tuple to be the tuple under test */
1893 econtext->ecxt_scantuple = slot;
1895 /* And evaluate the constraints */
1896 for (i = 0; i < ncheck; i++)
1898 qual = resultRelInfo->ri_ConstraintExprs[i];
1901 * NOTE: SQL92 specifies that a NULL result from a constraint
1902 * expression is not to be treated as a failure. Therefore, tell
1903 * ExecQual to return TRUE for NULL.
1905 if (!ExecQual(qual, econtext, true))
1906 return check[i].ccname;
1909 /* NULL result means no error */
1914 ExecConstraints(ResultRelInfo *resultRelInfo,
1915 TupleTableSlot *slot, EState *estate)
1917 Relation rel = resultRelInfo->ri_RelationDesc;
1918 TupleConstr *constr = rel->rd_att->constr;
1922 if (constr->has_not_null)
1924 int natts = rel->rd_att->natts;
1927 for (attrChk = 1; attrChk <= natts; attrChk++)
1929 if (rel->rd_att->attrs[attrChk - 1]->attnotnull &&
1930 slot_attisnull(slot, attrChk))
1932 (errcode(ERRCODE_NOT_NULL_VIOLATION),
1933 errmsg("null value in column \"%s\" violates not-null constraint",
1934 NameStr(rel->rd_att->attrs[attrChk - 1]->attname))));
1938 if (constr->num_check > 0)
1942 if ((failed = ExecRelCheck(resultRelInfo, slot, estate)) != NULL)
1944 (errcode(ERRCODE_CHECK_VIOLATION),
1945 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
1946 RelationGetRelationName(rel), failed)));
1951 * ExecProcessReturning --- evaluate a RETURNING list and send to dest
1953 * projectReturning: RETURNING projection info for current result rel
1954 * tupleSlot: slot holding tuple actually inserted/updated/deleted
1955 * planSlot: slot holding tuple returned by top plan node
1956 * dest: where to send the output
1959 ExecProcessReturning(ProjectionInfo *projectReturning,
1960 TupleTableSlot *tupleSlot,
1961 TupleTableSlot *planSlot,
1964 ExprContext *econtext = projectReturning->pi_exprContext;
1965 TupleTableSlot *retSlot;
1968 * Reset per-tuple memory context to free any expression evaluation
1969 * storage allocated in the previous cycle.
1971 ResetExprContext(econtext);
1973 /* Make tuple and any needed join variables available to ExecProject */
1974 econtext->ecxt_scantuple = tupleSlot;
1975 econtext->ecxt_outertuple = planSlot;
1977 /* Compute the RETURNING expressions */
1978 retSlot = ExecProject(projectReturning, NULL);
1981 (*dest->receiveSlot) (retSlot, dest);
1983 ExecClearTuple(retSlot);
1987 * Check a modified tuple to see if we want to process its updated version
1988 * under READ COMMITTED rules.
1990 * See backend/executor/README for some info about how this works.
1992 * estate - executor state data
1993 * rti - rangetable index of table containing tuple
1994 * *tid - t_ctid from the outdated tuple (ie, next updated version)
1995 * priorXmax - t_xmax from the outdated tuple
1997 * *tid is also an output parameter: it's modified to hold the TID of the
1998 * latest version of the tuple (note this may be changed even on failure)
2000 * Returns a slot containing the new candidate update/delete tuple, or
2001 * NULL if we determine we shouldn't process the row.
2004 EvalPlanQual(EState *estate, Index rti,
2005 ItemPointer tid, TransactionId priorXmax)
2010 HeapTupleData tuple;
2011 HeapTuple copyTuple = NULL;
2012 SnapshotData SnapshotDirty;
2018 * find relation containing target tuple
2020 if (estate->es_result_relation_info != NULL &&
2021 estate->es_result_relation_info->ri_RangeTableIndex == rti)
2022 relation = estate->es_result_relation_info->ri_RelationDesc;
2028 foreach(l, estate->es_rowMarks)
2030 if (((ExecRowMark *) lfirst(l))->rti == rti)
2032 relation = ((ExecRowMark *) lfirst(l))->relation;
2036 if (relation == NULL)
2037 elog(ERROR, "could not find RowMark for RT index %u", rti);
2043 * Loop here to deal with updated or busy tuples
2045 InitDirtySnapshot(SnapshotDirty);
2046 tuple.t_self = *tid;
2051 if (heap_fetch(relation, &SnapshotDirty, &tuple, &buffer, true, NULL))
2054 * If xmin isn't what we're expecting, the slot must have been
2055 * recycled and reused for an unrelated tuple. This implies that
2056 * the latest version of the row was deleted, so we need do
2057 * nothing. (Should be safe to examine xmin without getting
2058 * buffer's content lock, since xmin never changes in an existing
2061 if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple.t_data),
2064 ReleaseBuffer(buffer);
2068 /* otherwise xmin should not be dirty... */
2069 if (TransactionIdIsValid(SnapshotDirty.xmin))
2070 elog(ERROR, "t_xmin is uncommitted in tuple to be updated");
2073 * If tuple is being updated by other transaction then we have to
2074 * wait for its commit/abort.
2076 if (TransactionIdIsValid(SnapshotDirty.xmax))
2078 ReleaseBuffer(buffer);
2079 XactLockTableWait(SnapshotDirty.xmax);
2080 continue; /* loop back to repeat heap_fetch */
2084 * If tuple was inserted by our own transaction, we have to check
2085 * cmin against es_output_cid: cmin >= current CID means our
2086 * command cannot see the tuple, so we should ignore it. Without
2087 * this we are open to the "Halloween problem" of indefinitely
2088 * re-updating the same tuple. (We need not check cmax because
2089 * HeapTupleSatisfiesDirty will consider a tuple deleted by our
2090 * transaction dead, regardless of cmax.) We just checked that
2091 * priorXmax == xmin, so we can test that variable instead of
2092 * doing HeapTupleHeaderGetXmin again.
2094 if (TransactionIdIsCurrentTransactionId(priorXmax) &&
2095 HeapTupleHeaderGetCmin(tuple.t_data) >= estate->es_output_cid)
2097 ReleaseBuffer(buffer);
2102 * We got tuple - now copy it for use by recheck query.
2104 copyTuple = heap_copytuple(&tuple);
2105 ReleaseBuffer(buffer);
2110 * If the referenced slot was actually empty, the latest version of
2111 * the row must have been deleted, so we need do nothing.
2113 if (tuple.t_data == NULL)
2115 ReleaseBuffer(buffer);
2120 * As above, if xmin isn't what we're expecting, do nothing.
2122 if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple.t_data),
2125 ReleaseBuffer(buffer);
2130 * If we get here, the tuple was found but failed SnapshotDirty.
2131 * Assuming the xmin is either a committed xact or our own xact (as it
2132 * certainly should be if we're trying to modify the tuple), this must
2133 * mean that the row was updated or deleted by either a committed xact
2134 * or our own xact. If it was deleted, we can ignore it; if it was
2135 * updated then chain up to the next version and repeat the whole
2138 * As above, it should be safe to examine xmax and t_ctid without the
2139 * buffer content lock, because they can't be changing.
2141 if (ItemPointerEquals(&tuple.t_self, &tuple.t_data->t_ctid))
2143 /* deleted, so forget about it */
2144 ReleaseBuffer(buffer);
2148 /* updated, so look at the updated row */
2149 tuple.t_self = tuple.t_data->t_ctid;
2150 /* updated row should have xmin matching this xmax */
2151 priorXmax = HeapTupleHeaderGetXmax(tuple.t_data);
2152 ReleaseBuffer(buffer);
2153 /* loop back to fetch next in chain */
2157 * For UPDATE/DELETE we have to return tid of actual row we're executing
2160 *tid = tuple.t_self;
2163 * Need to run a recheck subquery. Find or create a PQ stack entry.
2165 epq = estate->es_evalPlanQual;
2168 if (epq != NULL && epq->rti == 0)
2170 /* Top PQ stack entry is idle, so re-use it */
2171 Assert(!(estate->es_useEvalPlan) && epq->next == NULL);
2177 * If this is request for another RTE - Ra, - then we have to check wasn't
2178 * PlanQual requested for Ra already and if so then Ra' row was updated
2179 * again and we have to re-start old execution for Ra and forget all what
2180 * we done after Ra was suspended. Cool? -:))
2182 if (epq != NULL && epq->rti != rti &&
2183 epq->estate->es_evTuple[rti - 1] != NULL)
2187 evalPlanQual *oldepq;
2189 /* stop execution */
2190 EvalPlanQualStop(epq);
2191 /* pop previous PlanQual from the stack */
2193 Assert(oldepq && oldepq->rti != 0);
2194 /* push current PQ to freePQ stack */
2197 estate->es_evalPlanQual = epq;
2198 } while (epq->rti != rti);
2202 * If we are requested for another RTE then we have to suspend execution
2203 * of current PlanQual and start execution for new one.
2205 if (epq == NULL || epq->rti != rti)
2207 /* try to reuse plan used previously */
2208 evalPlanQual *newepq = (epq != NULL) ? epq->free : NULL;
2210 if (newepq == NULL) /* first call or freePQ stack is empty */
2212 newepq = (evalPlanQual *) palloc0(sizeof(evalPlanQual));
2213 newepq->free = NULL;
2214 newepq->estate = NULL;
2215 newepq->planstate = NULL;
2219 /* recycle previously used PlanQual */
2220 Assert(newepq->estate == NULL);
2223 /* push current PQ to the stack */
2226 estate->es_evalPlanQual = epq;
2231 Assert(epq->rti == rti);
2234 * Ok - we're requested for the same RTE. Unfortunately we still have to
2235 * end and restart execution of the plan, because ExecReScan wouldn't
2236 * ensure that upper plan nodes would reset themselves. We could make
2237 * that work if insertion of the target tuple were integrated with the
2238 * Param mechanism somehow, so that the upper plan nodes know that their
2239 * children's outputs have changed.
2241 * Note that the stack of free evalPlanQual nodes is quite useless at the
2242 * moment, since it only saves us from pallocing/releasing the
2243 * evalPlanQual nodes themselves. But it will be useful once we implement
2244 * ReScan instead of end/restart for re-using PlanQual nodes.
2248 /* stop execution */
2249 EvalPlanQualStop(epq);
2253 * Initialize new recheck query.
2255 * Note: if we were re-using PlanQual plans via ExecReScan, we'd need to
2256 * instead copy down changeable state from the top plan (including
2257 * es_result_relation_info, es_junkFilter) and reset locally changeable
2258 * state in the epq (including es_param_exec_vals, es_evTupleNull).
2260 EvalPlanQualStart(epq, estate, epq->next);
2263 * free old RTE' tuple, if any, and store target tuple where relation's
2264 * scan node will see it
2266 epqstate = epq->estate;
2267 if (epqstate->es_evTuple[rti - 1] != NULL)
2268 heap_freetuple(epqstate->es_evTuple[rti - 1]);
2269 epqstate->es_evTuple[rti - 1] = copyTuple;
2271 return EvalPlanQualNext(estate);
2274 static TupleTableSlot *
2275 EvalPlanQualNext(EState *estate)
2277 evalPlanQual *epq = estate->es_evalPlanQual;
2278 MemoryContext oldcontext;
2279 TupleTableSlot *slot;
2281 Assert(epq->rti != 0);
2284 oldcontext = MemoryContextSwitchTo(epq->estate->es_query_cxt);
2285 slot = ExecProcNode(epq->planstate);
2286 MemoryContextSwitchTo(oldcontext);
2289 * No more tuples for this PQ. Continue previous one.
2291 if (TupIsNull(slot))
2293 evalPlanQual *oldepq;
2295 /* stop execution */
2296 EvalPlanQualStop(epq);
2297 /* pop old PQ from the stack */
2301 /* this is the first (oldest) PQ - mark as free */
2303 estate->es_useEvalPlan = false;
2304 /* and continue Query execution */
2307 Assert(oldepq->rti != 0);
2308 /* push current PQ to freePQ stack */
2311 estate->es_evalPlanQual = epq;
2319 EndEvalPlanQual(EState *estate)
2321 evalPlanQual *epq = estate->es_evalPlanQual;
2323 if (epq->rti == 0) /* plans already shutdowned */
2325 Assert(epq->next == NULL);
2331 evalPlanQual *oldepq;
2333 /* stop execution */
2334 EvalPlanQualStop(epq);
2335 /* pop old PQ from the stack */
2339 /* this is the first (oldest) PQ - mark as free */
2341 estate->es_useEvalPlan = false;
2344 Assert(oldepq->rti != 0);
2345 /* push current PQ to freePQ stack */
2348 estate->es_evalPlanQual = epq;
2353 * Start execution of one level of PlanQual.
2355 * This is a cut-down version of ExecutorStart(): we copy some state from
2356 * the top-level estate rather than initializing it fresh.
2359 EvalPlanQualStart(evalPlanQual *epq, EState *estate, evalPlanQual *priorepq)
2363 MemoryContext oldcontext;
2366 rtsize = list_length(estate->es_range_table);
2368 epq->estate = epqstate = CreateExecutorState();
2370 oldcontext = MemoryContextSwitchTo(epqstate->es_query_cxt);
2373 * The epqstates share the top query's copy of unchanging state such as
2374 * the snapshot, rangetable, result-rel info, and external Param info.
2375 * They need their own copies of local state, including a tuple table,
2376 * es_param_exec_vals, etc.
2378 epqstate->es_direction = ForwardScanDirection;
2379 epqstate->es_snapshot = estate->es_snapshot;
2380 epqstate->es_crosscheck_snapshot = estate->es_crosscheck_snapshot;
2381 epqstate->es_range_table = estate->es_range_table;
2382 epqstate->es_output_cid = estate->es_output_cid;
2383 epqstate->es_result_relations = estate->es_result_relations;
2384 epqstate->es_num_result_relations = estate->es_num_result_relations;
2385 epqstate->es_result_relation_info = estate->es_result_relation_info;
2386 epqstate->es_junkFilter = estate->es_junkFilter;
2387 /* es_trig_target_relations must NOT be copied */
2388 epqstate->es_into_relation_descriptor = estate->es_into_relation_descriptor;
2389 epqstate->es_into_relation_use_wal = estate->es_into_relation_use_wal;
2390 epqstate->es_param_list_info = estate->es_param_list_info;
2391 if (estate->es_plannedstmt->nParamExec > 0)
2392 epqstate->es_param_exec_vals = (ParamExecData *)
2393 palloc0(estate->es_plannedstmt->nParamExec * sizeof(ParamExecData));
2394 epqstate->es_rowMarks = estate->es_rowMarks;
2395 epqstate->es_instrument = estate->es_instrument;
2396 epqstate->es_select_into = estate->es_select_into;
2397 epqstate->es_into_oids = estate->es_into_oids;
2398 epqstate->es_plannedstmt = estate->es_plannedstmt;
2401 * Each epqstate must have its own es_evTupleNull state, but all the stack
2402 * entries share es_evTuple state. This allows sub-rechecks to inherit
2403 * the value being examined by an outer recheck.
2405 epqstate->es_evTupleNull = (bool *) palloc0(rtsize * sizeof(bool));
2406 if (priorepq == NULL)
2407 /* first PQ stack entry */
2408 epqstate->es_evTuple = (HeapTuple *)
2409 palloc0(rtsize * sizeof(HeapTuple));
2411 /* later stack entries share the same storage */
2412 epqstate->es_evTuple = priorepq->estate->es_evTuple;
2415 * Create sub-tuple-table; we needn't redo the CountSlots work though.
2417 epqstate->es_tupleTable =
2418 ExecCreateTupleTable(estate->es_tupleTable->size);
2421 * Initialize private state information for each SubPlan. We must do this
2422 * before running ExecInitNode on the main query tree, since
2423 * ExecInitSubPlan expects to be able to find these entries.
2425 Assert(epqstate->es_subplanstates == NIL);
2426 foreach(l, estate->es_plannedstmt->subplans)
2428 Plan *subplan = (Plan *) lfirst(l);
2429 PlanState *subplanstate;
2431 subplanstate = ExecInitNode(subplan, epqstate, 0);
2433 epqstate->es_subplanstates = lappend(epqstate->es_subplanstates,
2438 * Initialize the private state information for all the nodes in the query
2439 * tree. This opens files, allocates storage and leaves us ready to start
2440 * processing tuples.
2442 epq->planstate = ExecInitNode(estate->es_plannedstmt->planTree, epqstate, 0);
2444 MemoryContextSwitchTo(oldcontext);
2448 * End execution of one level of PlanQual.
2450 * This is a cut-down version of ExecutorEnd(); basically we want to do most
2451 * of the normal cleanup, but *not* close result relations (which we are
2452 * just sharing from the outer query). We do, however, have to close any
2453 * trigger target relations that got opened, since those are not shared.
2456 EvalPlanQualStop(evalPlanQual *epq)
2458 EState *epqstate = epq->estate;
2459 MemoryContext oldcontext;
2462 oldcontext = MemoryContextSwitchTo(epqstate->es_query_cxt);
2464 ExecEndNode(epq->planstate);
2466 foreach(l, epqstate->es_subplanstates)
2468 PlanState *subplanstate = (PlanState *) lfirst(l);
2470 ExecEndNode(subplanstate);
2473 ExecDropTupleTable(epqstate->es_tupleTable, true);
2474 epqstate->es_tupleTable = NULL;
2476 if (epqstate->es_evTuple[epq->rti - 1] != NULL)
2478 heap_freetuple(epqstate->es_evTuple[epq->rti - 1]);
2479 epqstate->es_evTuple[epq->rti - 1] = NULL;
2482 foreach(l, epqstate->es_trig_target_relations)
2484 ResultRelInfo *resultRelInfo = (ResultRelInfo *) lfirst(l);
2486 /* Close indices and then the relation itself */
2487 ExecCloseIndices(resultRelInfo);
2488 heap_close(resultRelInfo->ri_RelationDesc, NoLock);
2491 MemoryContextSwitchTo(oldcontext);
2493 FreeExecutorState(epqstate);
2496 epq->planstate = NULL;
2500 * ExecGetActivePlanTree --- get the active PlanState tree from a QueryDesc
2502 * Ordinarily this is just the one mentioned in the QueryDesc, but if we
2503 * are looking at a row returned by the EvalPlanQual machinery, we need
2504 * to look at the subsidiary state instead.
2507 ExecGetActivePlanTree(QueryDesc *queryDesc)
2509 EState *estate = queryDesc->estate;
2511 if (estate && estate->es_useEvalPlan && estate->es_evalPlanQual != NULL)
2512 return estate->es_evalPlanQual->planstate;
2514 return queryDesc->planstate;
2519 * Support for SELECT INTO (a/k/a CREATE TABLE AS)
2521 * We implement SELECT INTO by diverting SELECT's normal output with
2522 * a specialized DestReceiver type.
2524 * TODO: remove some of the INTO-specific cruft from EState, and keep
2525 * it in the DestReceiver instead.
2530 DestReceiver pub; /* publicly-known function pointers */
2531 EState *estate; /* EState we are working with */
2535 * OpenIntoRel --- actually create the SELECT INTO target relation
2537 * This also replaces QueryDesc->dest with the special DestReceiver for
2538 * SELECT INTO. We assume that the correct result tuple type has already
2539 * been placed in queryDesc->tupDesc.
2542 OpenIntoRel(QueryDesc *queryDesc)
2544 IntoClause *into = queryDesc->plannedstmt->intoClause;
2545 EState *estate = queryDesc->estate;
2546 Relation intoRelationDesc;
2551 AclResult aclresult;
2554 DR_intorel *myState;
2559 * Check consistency of arguments
2561 if (into->onCommit != ONCOMMIT_NOOP && !into->rel->istemp)
2563 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
2564 errmsg("ON COMMIT can only be used on temporary tables")));
2567 * Find namespace to create in, check its permissions
2569 intoName = into->rel->relname;
2570 namespaceId = RangeVarGetCreationNamespace(into->rel);
2572 aclresult = pg_namespace_aclcheck(namespaceId, GetUserId(),
2574 if (aclresult != ACLCHECK_OK)
2575 aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
2576 get_namespace_name(namespaceId));
2579 * Select tablespace to use. If not specified, use default tablespace
2580 * (which may in turn default to database's default).
2582 if (into->tableSpaceName)
2584 tablespaceId = get_tablespace_oid(into->tableSpaceName);
2585 if (!OidIsValid(tablespaceId))
2587 (errcode(ERRCODE_UNDEFINED_OBJECT),
2588 errmsg("tablespace \"%s\" does not exist",
2589 into->tableSpaceName)));
2593 tablespaceId = GetDefaultTablespace(into->rel->istemp);
2594 /* note InvalidOid is OK in this case */
2597 /* Check permissions except when using the database's default space */
2598 if (OidIsValid(tablespaceId) && tablespaceId != MyDatabaseTableSpace)
2600 AclResult aclresult;
2602 aclresult = pg_tablespace_aclcheck(tablespaceId, GetUserId(),
2605 if (aclresult != ACLCHECK_OK)
2606 aclcheck_error(aclresult, ACL_KIND_TABLESPACE,
2607 get_tablespace_name(tablespaceId));
2610 /* Parse and validate any reloptions */
2611 reloptions = transformRelOptions((Datum) 0,
2615 (void) heap_reloptions(RELKIND_RELATION, reloptions, true);
2617 /* have to copy the actual tupdesc to get rid of any constraints */
2618 tupdesc = CreateTupleDescCopy(queryDesc->tupDesc);
2620 /* Now we can actually create the new relation */
2621 intoRelationId = heap_create_with_catalog(intoName,
2633 allowSystemTableMods);
2635 FreeTupleDesc(tupdesc);
2638 * Advance command counter so that the newly-created relation's catalog
2639 * tuples will be visible to heap_open.
2641 CommandCounterIncrement();
2644 * If necessary, create a TOAST table for the INTO relation. Note that
2645 * AlterTableCreateToastTable ends with CommandCounterIncrement(), so that
2646 * the TOAST table will be visible for insertion.
2648 AlterTableCreateToastTable(intoRelationId);
2651 * And open the constructed table for writing.
2653 intoRelationDesc = heap_open(intoRelationId, AccessExclusiveLock);
2655 /* use_wal off requires rd_targblock be initially invalid */
2656 Assert(intoRelationDesc->rd_targblock == InvalidBlockNumber);
2659 * We can skip WAL-logging the insertions, unless PITR is in use.
2661 estate->es_into_relation_use_wal = XLogArchivingActive();
2662 estate->es_into_relation_descriptor = intoRelationDesc;
2665 * Now replace the query's DestReceiver with one for SELECT INTO
2667 queryDesc->dest = CreateDestReceiver(DestIntoRel, NULL);
2668 myState = (DR_intorel *) queryDesc->dest;
2669 Assert(myState->pub.mydest == DestIntoRel);
2670 myState->estate = estate;
2674 * CloseIntoRel --- clean up SELECT INTO at ExecutorEnd time
2677 CloseIntoRel(QueryDesc *queryDesc)
2679 EState *estate = queryDesc->estate;
2681 /* OpenIntoRel might never have gotten called */
2682 if (estate->es_into_relation_descriptor)
2684 /* If we skipped using WAL, must heap_sync before commit */
2685 if (!estate->es_into_relation_use_wal)
2686 heap_sync(estate->es_into_relation_descriptor);
2688 /* close rel, but keep lock until commit */
2689 heap_close(estate->es_into_relation_descriptor, NoLock);
2691 estate->es_into_relation_descriptor = NULL;
2696 * CreateIntoRelDestReceiver -- create a suitable DestReceiver object
2698 * Since CreateDestReceiver doesn't accept the parameters we'd need,
2699 * we just leave the private fields empty here. OpenIntoRel will
2703 CreateIntoRelDestReceiver(void)
2705 DR_intorel *self = (DR_intorel *) palloc(sizeof(DR_intorel));
2707 self->pub.receiveSlot = intorel_receive;
2708 self->pub.rStartup = intorel_startup;
2709 self->pub.rShutdown = intorel_shutdown;
2710 self->pub.rDestroy = intorel_destroy;
2711 self->pub.mydest = DestIntoRel;
2713 self->estate = NULL;
2715 return (DestReceiver *) self;
2719 * intorel_startup --- executor startup
2722 intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
2728 * intorel_receive --- receive one tuple
2731 intorel_receive(TupleTableSlot *slot, DestReceiver *self)
2733 DR_intorel *myState = (DR_intorel *) self;
2734 EState *estate = myState->estate;
2737 tuple = ExecCopySlotTuple(slot);
2739 heap_insert(estate->es_into_relation_descriptor,
2741 estate->es_output_cid,
2742 estate->es_into_relation_use_wal,
2743 false); /* never any point in using FSM */
2745 /* We know this is a newly created relation, so there are no indexes */
2747 heap_freetuple(tuple);
2753 * intorel_shutdown --- executor end
2756 intorel_shutdown(DestReceiver *self)
2762 * intorel_destroy --- release DestReceiver object
2765 intorel_destroy(DestReceiver *self)