| blob | 676f771acd92a63c383138b84b6acbc5a9f861ae |
1 /*-------------------------------------------------------------------------
2 *
3 * execMain.c
4 * top level executor interface routines
5 *
6 * INTERFACE ROUTINES
7 * ExecutorStart()
8 * ExecutorRun()
9 * ExecutorEnd()
10 *
11 * The old ExecutorMain() has been replaced by ExecutorStart(),
12 * ExecutorRun() and ExecutorEnd()
13 *
14 * These three procedures are the external interfaces to the executor.
15 * In each case, the query descriptor is required as an argument.
16 *
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.
20 *
21 * ExecutorRun accepts direction and count arguments that specify whether
22 * the plan is to be executed forwards, backwards, and for how many tuples.
23 *
24 * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
25 * Portions Copyright (c) 1994, Regents of the University of California
26 *
27 *
28 * IDENTIFICATION
29 * $PostgreSQL$
30 *
31 *-------------------------------------------------------------------------
32 */
61 /* Hook for plugins to get control in ExecutorRun() */
65 {
66 Index rti;
73 /* decls for local routines only used within this module */
77 CmdType operation,
79 ScanDirection direction,
111 /* end of local decls */
114 /* ----------------------------------------------------------------
115 * ExecutorStart
116 *
117 * This routine must be called at the beginning of any execution of any
118 * query plan
119 *
120 * Takes a QueryDesc previously created by CreateQueryDesc (it's not real
121 * clear why we bother to separate the two functions, but...). The tupDesc
122 * field of the QueryDesc is filled in to describe the tuples that will be
123 * returned, and the internal fields (estate and planstate) are set up.
124 *
125 * eflags contains flag bits as described in executor.h.
126 *
127 * NB: the CurrentMemoryContext when this is called will become the parent
128 * of the per-query context used for this Executor invocation.
129 * ----------------------------------------------------------------
130 */
131 void
133 {
135 MemoryContext oldcontext;
137 /* sanity checks: queryDesc must not be started already */
141 /*
142 * If the transaction is read-only, we need to check if any writes are
143 * planned to non-temporary tables. EXPLAIN is considered read-only.
144 */
148 /*
149 * Build EState, switch into per-query memory context for startup.
150 */
156 /*
157 * Fill in parameters, if any, from queryDesc
158 */
165 /*
166 * If non-read-only query, set the command ID to mark output tuples with
167 */
169 {
171 /* SELECT INTO and SELECT FOR UPDATE/SHARE need to mark tuples */
187 }
189 /*
190 * Copy other important information into the EState
191 */
196 /*
197 * Initialize the plan state tree
198 */
202 }
204 /* ----------------------------------------------------------------
205 * ExecutorRun
206 *
207 * This is the main routine of the executor module. It accepts
208 * the query descriptor from the traffic cop and executes the
209 * query plan.
210 *
211 * ExecutorStart must have been called already.
212 *
213 * If direction is NoMovementScanDirection then nothing is done
214 * except to start up/shut down the destination. Otherwise,
215 * we retrieve up to 'count' tuples in the specified direction.
216 *
217 * Note: count = 0 is interpreted as no portal limit, i.e., run to
218 * completion.
219 *
220 * We provide a function hook variable that lets loadable plugins
221 * get control when ExecutorRun is called. Such a plugin would
222 * normally call standard_ExecutorRun().
223 *
224 * ----------------------------------------------------------------
225 */
226 TupleTableSlot *
229 {
234 else
237 }
239 TupleTableSlot *
242 {
244 CmdType operation;
248 MemoryContext oldcontext;
250 /* sanity checks */
257 /*
258 * Switch into per-query memory context
259 */
262 /*
263 * extract information from the query descriptor and the query feature.
264 */
268 /*
269 * startup tuple receiver, if we will be emitting tuples
270 */
280 /*
281 * run plan
282 */
285 else
288 operation,
289 count,
290 direction,
291 dest);
293 /*
294 * shutdown tuple receiver, if we started it
295 */
302 }
304 /* ----------------------------------------------------------------
305 * ExecutorEnd
306 *
307 * This routine must be called at the end of execution of any
308 * query plan
309 * ----------------------------------------------------------------
310 */
311 void
313 {
315 MemoryContext oldcontext;
317 /* sanity checks */
324 /*
325 * Switch into per-query memory context to run ExecEndPlan
326 */
331 /*
332 * Close the SELECT INTO relation if any
333 */
337 /* do away with our snapshots */
341 /*
342 * Must switch out of context before destroying it
343 */
346 /*
347 * Release EState and per-query memory context. This should release
348 * everything the executor has allocated.
349 */
352 /* Reset queryDesc fields that no longer point to anything */
356 }
358 /* ----------------------------------------------------------------
359 * ExecutorRewind
360 *
361 * This routine may be called on an open queryDesc to rewind it
362 * to the start.
363 * ----------------------------------------------------------------
364 */
365 void
367 {
369 MemoryContext oldcontext;
371 /* sanity checks */
378 /* It's probably not sensible to rescan updating queries */
381 /*
382 * Switch into per-query memory context
383 */
386 /*
387 * rescan plan
388 */
392 }
395 /*
396 * ExecCheckRTPerms
397 * Check access permissions for all relations listed in a range table.
398 */
399 static void
401 {
405 {
407 }
408 }
410 /*
411 * ExecCheckRTEPerms
412 * Check access permissions for a single RTE.
413 */
414 static void
416 {
417 AclMode requiredPerms;
418 Oid relOid;
419 Oid userid;
421 /*
422 * Only plain-relation RTEs need to be checked here. Function RTEs are
423 * checked by init_fcache when the function is prepared for execution.
424 * Join, subquery, and special RTEs need no checks.
425 */
429 /*
430 * No work if requiredPerms is empty.
431 */
438 /*
439 * userid to check as: current user unless we have a setuid indication.
440 *
441 * Note: GetUserId() is presently fast enough that there's no harm in
442 * calling it separately for each RTE. If that stops being true, we could
443 * call it once in ExecCheckRTPerms and pass the userid down from there.
444 * But for now, no need for the extra clutter.
445 */
448 /*
449 * We must have *all* the requiredPerms bits, so use aclmask not aclcheck.
450 */
455 }
457 /*
458 * Check that the query does not imply any writes to non-temp tables.
459 */
460 static void
462 {
465 /*
466 * CREATE TABLE AS or SELECT INTO?
467 *
468 * XXX should we allow this if the destination is temp?
469 */
473 /* Fail if write permissions are requested on any non-temp table */
475 {
488 }
492 fail:
496 }
499 /* ----------------------------------------------------------------
500 * InitPlan
501 *
502 * Initializes the query plan: open files, allocate storage
503 * and start up the rule manager
504 * ----------------------------------------------------------------
505 */
506 static void
508 {
515 TupleDesc tupType;
519 /*
520 * Do permissions checks
521 */
524 /*
525 * initialize the node's execution state
526 */
529 /*
530 * initialize result relation stuff
531 */
533 {
543 {
545 Oid resultRelationOid;
546 Relation resultRelation;
551 resultRelation,
552 resultRelationIndex,
553 operation,
555 resultRelInfo++;
556 }
559 /* Initialize to first or only result rel */
561 }
562 else
563 {
564 /*
565 * if no result relation, then set state appropriately
566 */
570 }
572 /*
573 * Detect whether we're doing SELECT INTO. If so, set the es_into_oids
574 * flag appropriately so that the plan tree will be initialized with the
575 * correct tuple descriptors. (Other SELECT INTO stuff comes later.)
576 */
579 {
582 }
584 /*
585 * Have to lock relations selected FOR UPDATE/FOR SHARE before we
586 * initialize the plan tree, else we'd be doing a lock upgrade. While we
587 * are at it, build the ExecRowMark list.
588 */
591 {
594 Relation relation;
603 /* We'll set up ctidAttno below */
606 }
608 /*
609 * Initialize the executor "tuple" table. We need slots for all the plan
610 * nodes, plus possibly output slots for the junkfilter(s). At this point
611 * we aren't sure if we need junkfilters, so just add slots for them
612 * unconditionally. Also, if it's not a SELECT, set up a slot for use for
613 * trigger output tuples. Also, one for RETURNING-list evaluation.
614 */
615 {
618 /* Slots for the main plan tree */
620 /* Add slots for subplans and initplans */
622 {
626 }
627 /* Add slots for junkfilter(s) */
630 else
642 }
644 /* mark EvalPlanQual not active */
651 /*
652 * Initialize private state information for each SubPlan. We must do this
653 * before running ExecInitNode on the main query tree, since
654 * ExecInitSubPlan expects to be able to find these entries.
655 */
659 {
664 /*
665 * A subplan will never need to do BACKWARD scan nor MARK/RESTORE. If
666 * it is a parameterless subplan (not initplan), we suggest that it be
667 * prepared to handle REWIND efficiently; otherwise there is no need.
668 */
676 subplanstate);
678 i++;
679 }
681 /*
682 * Initialize the private state information for all the nodes in the query
683 * tree. This opens files, allocates storage and leaves us ready to start
684 * processing tuples.
685 */
688 /*
689 * Get the tuple descriptor describing the type of tuples to return. (this
690 * is especially important if we are creating a relation with "SELECT
691 * INTO")
692 */
695 /*
696 * Initialize the junk filter if needed. SELECT and INSERT queries need a
697 * filter if there are any junk attrs in the tlist. INSERT and SELECT
698 * INTO also need a filter if the plan may return raw disk tuples (else
699 * heap_insert will be scribbling on the source relation!). UPDATE and
700 * DELETE always need a filter, since there's always a junk 'ctid'
701 * attribute present --- no need to look first.
702 */
703 {
708 {
712 {
716 {
719 }
720 }
732 }
735 {
736 /*
737 * If there are multiple result relations, each one needs its own
738 * junk filter. Note this is only possible for UPDATE/DELETE, so
739 * we can't be fooled by some needing a filter and some not.
740 */
742 {
747 /* Top plan had better be an Append here. */
756 {
764 /*
765 * Since it must be UPDATE/DELETE, there had better be a
766 * "ctid" junk attribute in the tlist ... but ctid could
767 * be at a different resno for each result relation. We
768 * look up the ctid resnos now and save them in the
769 * junkfilters.
770 */
775 resultRelInfo++;
776 }
778 /*
779 * Set active junkfilter too; at this point ExecInitAppend has
780 * already selected an active result relation...
781 */
785 /*
786 * We currently can't support rowmarks in this case, because
787 * the associated junk CTIDs might have different resnos in
788 * different subplans.
789 */
793 errmsg("SELECT FOR UPDATE/SHARE is not supported within a query with multiple result relations")));
794 }
795 else
796 {
797 /* Normal case with just one JunkFilter */
808 {
809 /* For SELECT, want to return the cleaned tuple type */
811 }
813 {
814 /* For UPDATE/DELETE, find the ctid junk attr now */
818 }
820 /* For SELECT FOR UPDATE/SHARE, find the ctid attrs now */
822 {
830 resname);
831 }
832 }
833 }
834 else
835 {
839 }
840 }
842 /*
843 * Initialize RETURNING projections if needed.
844 */
846 {
851 /*
852 * We set QueryDesc.tupDesc to be the RETURNING rowtype in this case.
853 * We assume all the sublists will generate the same output tupdesc.
854 */
858 /* Set up a slot for the output of the RETURNING projection(s) */
861 /* Need an econtext too */
864 /*
865 * Build a projection for each result rel. Note that any SubPlans in
866 * the RETURNING lists get attached to the topmost plan node.
867 */
871 {
879 resultRelInfo++;
880 }
881 }
886 /*
887 * If doing SELECT INTO, initialize the "into" relation. We must wait
888 * till now so we have the "clean" result tuple type to create the new
889 * table from.
890 *
891 * If EXPLAIN, skip creating the "into" relation.
892 */
895 }
897 /*
898 * Initialize ResultRelInfo data for one result relation
899 */
900 void
902 Relation resultRelationDesc,
903 Index resultRelationIndex,
904 CmdType operation,
906 {
907 /*
908 * Check valid relkind ... parser and/or planner should have noticed this
909 * already, but let's make sure.
910 */
912 {
914 /* OK */
940 }
942 /* OK, fill in the node */
950 /* make a copy so as not to depend on relcache info not changing... */
953 {
960 else
962 }
963 else
964 {
967 }
972 /*
973 * If there are indices on the result relation, open them and save
974 * descriptors in the result relation info, so that we can add new index
975 * entries for the tuples we add/update. We need not do this for a
976 * DELETE, however, since deletion doesn't affect indexes.
977 */
981 }
983 /*
984 * ExecGetTriggerResultRel
985 *
986 * Get a ResultRelInfo for a trigger target relation. Most of the time,
987 * triggers are fired on one of the result relations of the query, and so
988 * we can just return a member of the es_result_relations array. (Note: in
989 * self-join situations there might be multiple members with the same OID;
990 * if so it doesn't matter which one we pick.) However, it is sometimes
991 * necessary to fire triggers on other relations; this happens mainly when an
992 * RI update trigger queues additional triggers on other relations, which will
993 * be processed in the context of the outer query. For efficiency's sake,
994 * we want to have a ResultRelInfo for those triggers too; that can avoid
995 * repeated re-opening of the relation. (It also provides a way for EXPLAIN
996 * ANALYZE to report the runtimes of such triggers.) So we make additional
997 * ResultRelInfo's as needed, and save them in es_trig_target_relations.
998 */
999 ResultRelInfo *
1001 {
1005 Relation rel;
1006 MemoryContext oldcontext;
1008 /* First, search through the query result relations */
1012 {
1015 rInfo++;
1016 nr--;
1017 }
1018 /* Nope, but maybe we already made an extra ResultRelInfo for it */
1020 {
1024 }
1025 /* Nope, so we need a new one */
1027 /*
1028 * Open the target relation's relcache entry. We assume that an
1029 * appropriate lock is still held by the backend from whenever the trigger
1030 * event got queued, so we need take no new lock here.
1031 */
1034 /*
1035 * Make the new entry in the right context. Currently, we don't need any
1036 * index information in ResultRelInfos used only for triggers, so tell
1037 * InitResultRelInfo it's a DELETE.
1038 */
1042 rel,
1044 CMD_DELETE,
1051 }
1053 /*
1054 * ExecContextForcesOids
1055 *
1056 * This is pretty grotty: when doing INSERT, UPDATE, or SELECT INTO,
1057 * we need to ensure that result tuples have space for an OID iff they are
1058 * going to be stored into a relation that has OIDs. In other contexts
1059 * we are free to choose whether to leave space for OIDs in result tuples
1060 * (we generally don't want to, but we do if a physical-tlist optimization
1061 * is possible). This routine checks the plan context and returns TRUE if the
1062 * choice is forced, FALSE if the choice is not forced. In the TRUE case,
1063 * *hasoids is set to the required value.
1064 *
1065 * One reason this is ugly is that all plan nodes in the plan tree will emit
1066 * tuples with space for an OID, though we really only need the topmost node
1067 * to do so. However, node types like Sort don't project new tuples but just
1068 * return their inputs, and in those cases the requirement propagates down
1069 * to the input node. Eventually we might make this code smart enough to
1070 * recognize how far down the requirement really goes, but for now we just
1071 * make all plan nodes do the same thing if the top level forces the choice.
1072 *
1073 * We assume that estate->es_result_relation_info is already set up to
1074 * describe the target relation. Note that in an UPDATE that spans an
1075 * inheritance tree, some of the target relations may have OIDs and some not.
1076 * We have to make the decisions on a per-relation basis as we initialize
1077 * each of the child plans of the topmost Append plan.
1078 *
1079 * SELECT INTO is even uglier, because we don't have the INTO relation's
1080 * descriptor available when this code runs; we have to look aside at a
1081 * flag set by InitPlan().
1082 */
1083 bool
1085 {
1087 {
1090 }
1091 else
1092 {
1096 {
1100 {
1103 }
1104 }
1105 }
1108 }
1110 /* ----------------------------------------------------------------
1111 * ExecEndPlan
1112 *
1113 * Cleans up the query plan -- closes files and frees up storage
1114 *
1115 * NOTE: we are no longer very worried about freeing storage per se
1116 * in this code; FreeExecutorState should be guaranteed to release all
1117 * memory that needs to be released. What we are worried about doing
1118 * is closing relations and dropping buffer pins. Thus, for example,
1119 * tuple tables must be cleared or dropped to ensure pins are released.
1120 * ----------------------------------------------------------------
1121 */
1122 static void
1124 {
1129 /*
1130 * shut down any PlanQual processing we were doing
1131 */
1135 /*
1136 * shut down the node-type-specific query processing
1137 */
1140 /*
1141 * for subplans too
1142 */
1144 {
1148 }
1150 /*
1151 * destroy the executor "tuple" table.
1152 */
1156 /*
1157 * close the result relation(s) if any, but hold locks until xact commit.
1158 */
1161 {
1162 /* Close indices and then the relation itself */
1165 resultRelInfo++;
1166 }
1168 /*
1169 * likewise close any trigger target relations
1170 */
1172 {
1174 /* Close indices and then the relation itself */
1177 }
1179 /*
1180 * close any relations selected FOR UPDATE/FOR SHARE, again keeping locks
1181 */
1183 {
1187 }
1188 }
1190 /* ----------------------------------------------------------------
1191 * ExecutePlan
1192 *
1193 * processes the query plan to retrieve 'numberTuples' tuples in the
1194 * direction specified.
1195 *
1196 * Retrieves all tuples if numberTuples is 0
1197 *
1198 * result is either a slot containing the last tuple in the case
1199 * of a SELECT or NULL otherwise.
1200 *
1201 * Note: the ctid attribute is a 'junk' attribute that is removed before the
1202 * user can see it
1203 * ----------------------------------------------------------------
1204 */
1208 CmdType operation,
1210 ScanDirection direction,
1212 {
1217 ItemPointerData tuple_ctid;
1221 /*
1222 * initialize local variables
1223 */
1227 /*
1228 * Set the direction.
1229 */
1232 /*
1233 * Process BEFORE EACH STATEMENT triggers
1234 */
1236 {
1247 /* do nothing */
1249 }
1251 /*
1252 * Loop until we've processed the proper number of tuples from the plan.
1253 */
1256 {
1257 /* Reset the per-output-tuple exprcontext */
1260 /*
1261 * Execute the plan and obtain a tuple
1262 */
1263 lnext: ;
1265 {
1269 }
1270 else
1273 /*
1274 * if the tuple is null, then we assume there is nothing more to
1275 * process so we just return null...
1276 */
1278 {
1281 }
1284 /*
1285 * If we have a junk filter, then project a new tuple with the junk
1286 * removed.
1287 *
1288 * Store this new "clean" tuple in the junkfilter's resultSlot.
1289 * (Formerly, we stored it back over the "dirty" tuple, which is WRONG
1290 * because that tuple slot has the wrong descriptor.)
1291 *
1292 * But first, extract all the junk information we need.
1293 */
1295 {
1296 /*
1297 * Process any FOR UPDATE or FOR SHARE locking requested.
1298 */
1300 {
1303 lmark: ;
1305 {
1307 Datum datum;
1309 HeapTupleData tuple;
1310 Buffer buffer;
1311 ItemPointerData update_ctid;
1312 TransactionId update_xmax;
1314 LockTupleMode lockmode;
1315 HTSU_Result test;
1320 /* shouldn't ever get a null result... */
1328 else
1337 {
1339 /* treat it as deleted; do not process */
1352 {
1353 /* updated, so look at updated version */
1357 update_xmax);
1359 {
1363 }
1364 }
1366 /*
1367 * if tuple was deleted or PlanQual failed for
1368 * updated tuple - we must not return this tuple!
1369 */
1374 test);
1376 }
1377 }
1378 }
1380 /*
1381 * extract the 'ctid' junk attribute.
1382 */
1384 {
1385 Datum datum;
1390 /* shouldn't ever get a null result... */
1397 }
1399 /*
1400 * Create a new "clean" tuple with all junk attributes removed. We
1401 * don't need to do this for DELETE, however (there will in fact
1402 * be no non-junk attributes in a DELETE!)
1403 */
1406 }
1408 /*
1409 * now that we have a tuple, do the appropriate thing with it.. either
1410 * return it to the user, add it to a relation someplace, delete it
1411 * from a relation, or modify some of its attributes.
1412 */
1414 {
1440 }
1442 /*
1443 * check our tuple count.. if we've processed the proper number then
1444 * quit, else loop again and process more tuples. Zero numberTuples
1445 * means no limit.
1446 */
1447 current_tuple_count++;
1450 }
1452 /*
1453 * Process AFTER EACH STATEMENT triggers
1454 */
1456 {
1467 /* do nothing */
1469 }
1471 /*
1472 * here, result is either a slot containing a tuple in the case of a
1473 * SELECT or NULL otherwise.
1474 */
1476 }
1478 /* ----------------------------------------------------------------
1479 * ExecSelect
1480 *
1481 * SELECTs are easy.. we just pass the tuple to the appropriate
1482 * output function.
1483 * ----------------------------------------------------------------
1484 */
1485 static void
1489 {
1493 }
1495 /* ----------------------------------------------------------------
1496 * ExecInsert
1497 *
1498 * INSERTs are trickier.. we have to insert the tuple into
1499 * the base relation and insert appropriate tuples into the
1500 * index relations.
1501 * ----------------------------------------------------------------
1502 */
1503 static void
1505 ItemPointer tupleid,
1509 {
1510 HeapTuple tuple;
1512 Relation resultRelationDesc;
1513 Oid newId;
1515 /*
1516 * get the heap tuple out of the tuple table slot, making sure we have a
1517 * writable copy
1518 */
1521 /*
1522 * get information on the (current) result relation
1523 */
1527 /* BEFORE ROW INSERT Triggers */
1530 {
1531 HeapTuple newtuple;
1539 {
1540 /*
1541 * Put the modified tuple into a slot for convenience of routines
1542 * below. We assume the tuple was allocated in per-tuple memory
1543 * context, and therefore will go away by itself. The tuple table
1544 * slot should not try to clear it.
1545 */
1553 }
1554 }
1556 /*
1557 * Check the constraints of the tuple
1558 */
1562 /*
1563 * insert the tuple
1564 *
1565 * Note: heap_insert returns the tid (location) of the new tuple in the
1566 * t_self field.
1567 */
1577 /*
1578 * insert index entries for tuple
1579 */
1583 /* AFTER ROW INSERT Triggers */
1586 /* Process RETURNING if present */
1590 }
1592 /* ----------------------------------------------------------------
1593 * ExecDelete
1594 *
1595 * DELETE is like UPDATE, except that we delete the tuple and no
1596 * index modifications are needed
1597 * ----------------------------------------------------------------
1598 */
1599 static void
1604 {
1606 Relation resultRelationDesc;
1607 HTSU_Result result;
1608 ItemPointerData update_ctid;
1609 TransactionId update_xmax;
1611 /*
1612 * get information on the (current) result relation
1613 */
1617 /* BEFORE ROW DELETE Triggers */
1620 {
1627 }
1629 /*
1630 * delete the tuple
1631 *
1632 * Note: if es_crosscheck_snapshot isn't InvalidSnapshot, we check that
1633 * the row to be deleted is visible to that snapshot, and throw a can't-
1634 * serialize error if not. This is a special-case behavior needed for
1635 * referential integrity updates in serializable transactions.
1636 */
1637 ldelete:;
1644 {
1646 /* already deleted by self; nothing to do */
1658 {
1664 update_xmax);
1666 {
1669 }
1670 }
1671 /* tuple already deleted; nothing to do */
1677 }
1682 /*
1683 * Note: Normally one would think that we have to delete index tuples
1684 * associated with the heap tuple now...
1685 *
1686 * ... but in POSTGRES, we have no need to do this because VACUUM will
1687 * take care of it later. We can't delete index tuples immediately
1688 * anyway, since the tuple is still visible to other transactions.
1689 */
1691 /* AFTER ROW DELETE Triggers */
1694 /* Process RETURNING if present */
1696 {
1697 /*
1698 * We have to put the target tuple into a slot, which means first we
1699 * gotta fetch it. We can use the trigger tuple slot.
1700 */
1702 HeapTupleData deltuple;
1703 Buffer delbuffer;
1719 }
1720 }
1722 /* ----------------------------------------------------------------
1723 * ExecUpdate
1724 *
1725 * note: we can't run UPDATE queries with transactions
1726 * off because UPDATEs are actually INSERTs and our
1727 * scan will mistakenly loop forever, updating the tuple
1728 * it just inserted.. This should be fixed but until it
1729 * is, we don't want to get stuck in an infinite loop
1730 * which corrupts your database..
1731 * ----------------------------------------------------------------
1732 */
1733 static void
1735 ItemPointer tupleid,
1739 {
1740 HeapTuple tuple;
1742 Relation resultRelationDesc;
1743 HTSU_Result result;
1744 ItemPointerData update_ctid;
1745 TransactionId update_xmax;
1747 /*
1748 * abort the operation if not running transactions
1749 */
1753 /*
1754 * get the heap tuple out of the tuple table slot, making sure we have a
1755 * writable copy
1756 */
1759 /*
1760 * get information on the (current) result relation
1761 */
1765 /* BEFORE ROW UPDATE Triggers */
1768 {
1769 HeapTuple newtuple;
1778 {
1779 /*
1780 * Put the modified tuple into a slot for convenience of routines
1781 * below. We assume the tuple was allocated in per-tuple memory
1782 * context, and therefore will go away by itself. The tuple table
1783 * slot should not try to clear it.
1784 */
1792 }
1793 }
1795 /*
1796 * Check the constraints of the tuple
1797 *
1798 * If we generate a new candidate tuple after EvalPlanQual testing, we
1799 * must loop back here and recheck constraints. (We don't need to redo
1800 * triggers, however. If there are any BEFORE triggers then trigger.c
1801 * will have done heap_lock_tuple to lock the correct tuple, so there's no
1802 * need to do them again.)
1803 */
1804 lreplace:;
1808 /*
1809 * replace the heap tuple
1810 *
1811 * Note: if es_crosscheck_snapshot isn't InvalidSnapshot, we check that
1812 * the row to be updated is visible to that snapshot, and throw a can't-
1813 * serialize error if not. This is a special-case behavior needed for
1814 * referential integrity updates in serializable transactions.
1815 */
1822 {
1824 /* already deleted by self; nothing to do */
1836 {
1842 update_xmax);
1844 {
1849 }
1850 }
1851 /* tuple already deleted; nothing to do */
1857 }
1862 /*
1863 * Note: instead of having to update the old index tuples associated with
1864 * the heap tuple, all we do is form and insert new index tuples. This is
1865 * because UPDATEs are actually DELETEs and INSERTs, and index tuple
1866 * deletion is done later by VACUUM (see notes in ExecDelete). All we do
1867 * here is insert new index tuples. -cim 9/27/89
1868 */
1870 /*
1871 * insert index entries for tuple
1872 *
1873 * Note: heap_update returns the tid (location) of the new tuple in the
1874 * t_self field.
1875 *
1876 * If it's a HOT update, we mustn't insert new index entries.
1877 */
1881 /* AFTER ROW UPDATE Triggers */
1884 /* Process RETURNING if present */
1888 }
1890 /*
1891 * ExecRelCheck --- check that tuple meets constraints for result relation
1892 */
1896 {
1901 MemoryContext oldContext;
1905 /*
1906 * If first time through for this result relation, build expression
1907 * nodetrees for rel's constraint expressions. Keep them in the per-query
1908 * memory context so they'll survive throughout the query.
1909 */
1911 {
1916 {
1917 /* ExecQual wants implicit-AND form */
1921 }
1923 }
1925 /*
1926 * We will use the EState's per-tuple context for evaluating constraint
1927 * expressions (creating it if it's not already there).
1928 */
1931 /* Arrange for econtext's scan tuple to be the tuple under test */
1934 /* And evaluate the constraints */
1936 {
1939 /*
1940 * NOTE: SQL92 specifies that a NULL result from a constraint
1941 * expression is not to be treated as a failure. Therefore, tell
1942 * ExecQual to return TRUE for NULL.
1943 */
1946 }
1948 /* NULL result means no error */
1950 }
1952 void
1955 {
1962 {
1967 {
1974 }
1975 }
1978 {
1986 }
1987 }
1989 /*
1990 * ExecProcessReturning --- evaluate a RETURNING list and send to dest
1991 *
1992 * projectReturning: RETURNING projection info for current result rel
1993 * tupleSlot: slot holding tuple actually inserted/updated/deleted
1994 * planSlot: slot holding tuple returned by top plan node
1995 * dest: where to send the output
1996 */
1997 static void
2002 {
2006 /*
2007 * Reset per-tuple memory context to free any expression evaluation
2008 * storage allocated in the previous cycle.
2009 */
2012 /* Make tuple and any needed join variables available to ExecProject */
2016 /* Compute the RETURNING expressions */
2019 /* Send to dest */
2023 }
2025 /*
2026 * Check a modified tuple to see if we want to process its updated version
2027 * under READ COMMITTED rules.
2028 *
2029 * See backend/executor/README for some info about how this works.
2030 *
2031 * estate - executor state data
2032 * rti - rangetable index of table containing tuple
2033 * *tid - t_ctid from the outdated tuple (ie, next updated version)
2034 * priorXmax - t_xmax from the outdated tuple
2035 *
2036 * *tid is also an output parameter: it's modified to hold the TID of the
2037 * latest version of the tuple (note this may be changed even on failure)
2038 *
2039 * Returns a slot containing the new candidate update/delete tuple, or
2040 * NULL if we determine we shouldn't process the row.
2041 */
2042 TupleTableSlot *
2045 {
2048 Relation relation;
2049 HeapTupleData tuple;
2051 SnapshotData SnapshotDirty;
2056 /*
2057 * find relation containing target tuple
2058 */
2062 else
2063 {
2068 {
2070 {
2073 }
2074 }
2077 }
2079 /*
2080 * fetch tid tuple
2081 *
2082 * Loop here to deal with updated or busy tuples
2083 */
2087 {
2088 Buffer buffer;
2091 {
2092 /*
2093 * If xmin isn't what we're expecting, the slot must have been
2094 * recycled and reused for an unrelated tuple. This implies that
2095 * the latest version of the row was deleted, so we need do
2096 * nothing. (Should be safe to examine xmin without getting
2097 * buffer's content lock, since xmin never changes in an existing
2098 * tuple.)
2099 */
2101 priorXmax))
2102 {
2105 }
2107 /* otherwise xmin should not be dirty... */
2111 /*
2112 * If tuple is being updated by other transaction then we have to
2113 * wait for its commit/abort.
2114 */
2116 {
2120 }
2122 /*
2123 * If tuple was inserted by our own transaction, we have to check
2124 * cmin against es_output_cid: cmin >= current CID means our
2125 * command cannot see the tuple, so we should ignore it. Without
2126 * this we are open to the "Halloween problem" of indefinitely
2127 * re-updating the same tuple. (We need not check cmax because
2128 * HeapTupleSatisfiesDirty will consider a tuple deleted by our
2129 * transaction dead, regardless of cmax.) We just checked that
2130 * priorXmax == xmin, so we can test that variable instead of
2131 * doing HeapTupleHeaderGetXmin again.
2132 */
2135 {
2138 }
2140 /*
2141 * We got tuple - now copy it for use by recheck query.
2142 */
2146 }
2148 /*
2149 * If the referenced slot was actually empty, the latest version of
2150 * the row must have been deleted, so we need do nothing.
2151 */
2153 {
2156 }
2158 /*
2159 * As above, if xmin isn't what we're expecting, do nothing.
2160 */
2162 priorXmax))
2163 {
2166 }
2168 /*
2169 * If we get here, the tuple was found but failed SnapshotDirty.
2170 * Assuming the xmin is either a committed xact or our own xact (as it
2171 * certainly should be if we're trying to modify the tuple), this must
2172 * mean that the row was updated or deleted by either a committed xact
2173 * or our own xact. If it was deleted, we can ignore it; if it was
2174 * updated then chain up to the next version and repeat the whole
2175 * test.
2176 *
2177 * As above, it should be safe to examine xmax and t_ctid without the
2178 * buffer content lock, because they can't be changing.
2179 */
2181 {
2182 /* deleted, so forget about it */
2185 }
2187 /* updated, so look at the updated row */
2189 /* updated row should have xmin matching this xmax */
2192 /* loop back to fetch next in chain */
2193 }
2195 /*
2196 * For UPDATE/DELETE we have to return tid of actual row we're executing
2197 * PQ for.
2198 */
2201 /*
2202 * Need to run a recheck subquery. Find or create a PQ stack entry.
2203 */
2208 {
2209 /* Top PQ stack entry is idle, so re-use it */
2213 }
2215 /*
2216 * If this is request for another RTE - Ra, - then we have to check wasn't
2217 * PlanQual requested for Ra already and if so then Ra' row was updated
2218 * again and we have to re-start old execution for Ra and forget all what
2219 * we done after Ra was suspended. Cool? -:))
2220 */
2223 {
2224 do
2225 {
2228 /* stop execution */
2230 /* pop previous PlanQual from the stack */
2233 /* push current PQ to freePQ stack */
2238 }
2240 /*
2241 * If we are requested for another RTE then we have to suspend execution
2242 * of current PlanQual and start execution for new one.
2243 */
2245 {
2246 /* try to reuse plan used previously */
2250 {
2255 }
2256 else
2257 {
2258 /* recycle previously used PlanQual */
2261 }
2262 /* push current PQ to the stack */
2268 }
2272 /*
2273 * Ok - we're requested for the same RTE. Unfortunately we still have to
2274 * end and restart execution of the plan, because ExecReScan wouldn't
2275 * ensure that upper plan nodes would reset themselves. We could make
2276 * that work if insertion of the target tuple were integrated with the
2277 * Param mechanism somehow, so that the upper plan nodes know that their
2278 * children's outputs have changed.
2279 *
2280 * Note that the stack of free evalPlanQual nodes is quite useless at the
2281 * moment, since it only saves us from pallocing/releasing the
2282 * evalPlanQual nodes themselves. But it will be useful once we implement
2283 * ReScan instead of end/restart for re-using PlanQual nodes.
2284 */
2286 {
2287 /* stop execution */
2289 }
2291 /*
2292 * Initialize new recheck query.
2293 *
2294 * Note: if we were re-using PlanQual plans via ExecReScan, we'd need to
2295 * instead copy down changeable state from the top plan (including
2296 * es_result_relation_info, es_junkFilter) and reset locally changeable
2297 * state in the epq (including es_param_exec_vals, es_evTupleNull).
2298 */
2301 /*
2302 * free old RTE' tuple, if any, and store target tuple where relation's
2303 * scan node will see it
2304 */
2311 }
2315 {
2317 MemoryContext oldcontext;
2322 lpqnext:;
2327 /*
2328 * No more tuples for this PQ. Continue previous one.
2329 */
2331 {
2334 /* stop execution */
2336 /* pop old PQ from the stack */
2339 {
2340 /* this is the first (oldest) PQ - mark as free */
2343 /* and continue Query execution */
2345 }
2347 /* push current PQ to freePQ stack */
2352 }
2355 }
2357 static void
2359 {
2363 {
2366 }
2369 {
2372 /* stop execution */
2374 /* pop old PQ from the stack */
2377 {
2378 /* this is the first (oldest) PQ - mark as free */
2382 }
2384 /* push current PQ to freePQ stack */
2388 }
2389 }
2391 /*
2392 * Start execution of one level of PlanQual.
2393 *
2394 * This is a cut-down version of ExecutorStart(): we copy some state from
2395 * the top-level estate rather than initializing it fresh.
2396 */
2397 static void
2399 {
2402 MemoryContext oldcontext;
2411 /*
2412 * The epqstates share the top query's copy of unchanging state such as
2413 * the snapshot, rangetable, result-rel info, and external Param info.
2414 * They need their own copies of local state, including a tuple table,
2415 * es_param_exec_vals, etc.
2416 */
2426 /* es_trig_target_relations must NOT be copied */
2439 /*
2440 * Each epqstate must have its own es_evTupleNull state, but all the stack
2441 * entries share es_evTuple state. This allows sub-rechecks to inherit
2442 * the value being examined by an outer recheck.
2443 */
2446 /* first PQ stack entry */
2449 else
2450 /* later stack entries share the same storage */
2453 /*
2454 * Create sub-tuple-table; we needn't redo the CountSlots work though.
2455 */
2459 /*
2460 * Initialize private state information for each SubPlan. We must do this
2461 * before running ExecInitNode on the main query tree, since
2462 * ExecInitSubPlan expects to be able to find these entries.
2463 */
2466 {
2473 subplanstate);
2474 }
2476 /*
2477 * Initialize the private state information for all the nodes in the query
2478 * tree. This opens files, allocates storage and leaves us ready to start
2479 * processing tuples.
2480 */
2484 }
2486 /*
2487 * End execution of one level of PlanQual.
2488 *
2489 * This is a cut-down version of ExecutorEnd(); basically we want to do most
2490 * of the normal cleanup, but *not* close result relations (which we are
2491 * just sharing from the outer query). We do, however, have to close any
2492 * trigger target relations that got opened, since those are not shared.
2493 */
2494 static void
2496 {
2498 MemoryContext oldcontext;
2506 {
2510 }
2516 {
2519 }
2522 {
2525 /* Close indices and then the relation itself */
2528 }
2536 }
2538 /*
2539 * ExecGetActivePlanTree --- get the active PlanState tree from a QueryDesc
2540 *
2541 * Ordinarily this is just the one mentioned in the QueryDesc, but if we
2542 * are looking at a row returned by the EvalPlanQual machinery, we need
2543 * to look at the subsidiary state instead.
2544 */
2545 PlanState *
2547 {
2552 else
2554 }
2557 /*
2558 * Support for SELECT INTO (a/k/a CREATE TABLE AS)
2559 *
2560 * We implement SELECT INTO by diverting SELECT's normal output with
2561 * a specialized DestReceiver type.
2562 *
2563 * TODO: remove some of the INTO-specific cruft from EState, and keep
2564 * it in the DestReceiver instead.
2565 */
2568 {
2573 /*
2574 * OpenIntoRel --- actually create the SELECT INTO target relation
2575 *
2576 * This also replaces QueryDesc->dest with the special DestReceiver for
2577 * SELECT INTO. We assume that the correct result tuple type has already
2578 * been placed in queryDesc->tupDesc.
2579 */
2580 static void
2582 {
2585 Relation intoRelationDesc;
2587 Oid namespaceId;
2588 Oid tablespaceId;
2589 Datum reloptions;
2590 AclResult aclresult;
2591 Oid intoRelationId;
2592 TupleDesc tupdesc;
2597 /*
2598 * Check consistency of arguments
2599 */
2605 /*
2606 * Find namespace to create in, check its permissions
2607 */
2612 ACL_CREATE);
2617 /*
2618 * Select tablespace to use. If not specified, use default tablespace
2619 * (which may in turn default to database's default).
2620 */
2622 {
2629 }
2630 else
2631 {
2633 /* note InvalidOid is OK in this case */
2634 }
2636 /* Check permissions except when using the database's default space */
2638 {
2639 AclResult aclresult;
2642 ACL_CREATE);
2647 }
2649 /* Parse and validate any reloptions */
2656 /* Copy the tupdesc because heap_create_with_catalog modifies it */
2659 /* Now we can actually create the new relation */
2661 namespaceId,
2662 tablespaceId,
2663 InvalidOid,
2665 tupdesc,
2666 NIL,
2667 RELKIND_RELATION,
2672 reloptions,
2673 allowSystemTableMods);
2677 /*
2678 * Advance command counter so that the newly-created relation's catalog
2679 * tuples will be visible to heap_open.
2680 */
2683 /*
2684 * If necessary, create a TOAST table for the INTO relation. Note that
2685 * AlterTableCreateToastTable ends with CommandCounterIncrement(), so that
2686 * the TOAST table will be visible for insertion.
2687 */
2690 /*
2691 * And open the constructed table for writing.
2692 */
2695 /* use_wal off requires rd_targblock be initially invalid */
2698 /*
2699 * We can skip WAL-logging the insertions, unless PITR is in use.
2700 */
2704 /*
2705 * Now replace the query's DestReceiver with one for SELECT INTO
2706 */
2711 }
2713 /*
2714 * CloseIntoRel --- clean up SELECT INTO at ExecutorEnd time
2715 */
2716 static void
2718 {
2721 /* OpenIntoRel might never have gotten called */
2723 {
2724 /* If we skipped using WAL, must heap_sync before commit */
2728 /* close rel, but keep lock until commit */
2732 }
2733 }
2735 /*
2736 * CreateIntoRelDestReceiver -- create a suitable DestReceiver object
2737 *
2738 * Since CreateDestReceiver doesn't accept the parameters we'd need,
2739 * we just leave the private fields empty here. OpenIntoRel will
2740 * fill them in.
2741 */
2742 DestReceiver *
2744 {
2756 }
2758 /*
2759 * intorel_startup --- executor startup
2760 */
2761 static void
2763 {
2764 /* no-op */
2765 }
2767 /*
2768 * intorel_receive --- receive one tuple
2769 */
2770 static void
2772 {
2775 HeapTuple tuple;
2780 tuple,
2785 /* We know this is a newly created relation, so there are no indexes */
2790 }
2792 /*
2793 * intorel_shutdown --- executor end
2794 */
2795 static void
2797 {
2798 /* no-op */
2799 }
2801 /*
2802 * intorel_destroy --- release DestReceiver object
2803 */
2804 static void
2806 {
2808 }