Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * execMain.c
4 : * top level executor interface routines
5 : *
6 : * INTERFACE ROUTINES
7 : * ExecutorStart()
8 : * ExecutorRun()
9 : * ExecutorFinish()
10 : * ExecutorEnd()
11 : *
12 : * These four procedures are the external interface to the executor.
13 : * In each case, the query descriptor is required as an argument.
14 : *
15 : * ExecutorStart must be called at the beginning of execution of any
16 : * query plan and ExecutorEnd must always be called at the end of
17 : * execution of a plan (unless it is aborted due to error).
18 : *
19 : * ExecutorRun accepts direction and count arguments that specify whether
20 : * the plan is to be executed forwards, backwards, and for how many tuples.
21 : * In some cases ExecutorRun may be called multiple times to process all
22 : * the tuples for a plan. It is also acceptable to stop short of executing
23 : * the whole plan (but only if it is a SELECT).
24 : *
25 : * ExecutorFinish must be called after the final ExecutorRun call and
26 : * before ExecutorEnd. This can be omitted only in case of EXPLAIN,
27 : * which should also omit ExecutorRun.
28 : *
29 : * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
30 : * Portions Copyright (c) 1994, Regents of the University of California
31 : *
32 : *
33 : * IDENTIFICATION
34 : * src/backend/executor/execMain.c
35 : *
36 : *-------------------------------------------------------------------------
37 : */
38 : #include "postgres.h"
39 :
40 : #include "access/heapam.h"
41 : #include "access/htup_details.h"
42 : #include "access/sysattr.h"
43 : #include "access/tableam.h"
44 : #include "access/transam.h"
45 : #include "access/xact.h"
46 : #include "catalog/namespace.h"
47 : #include "catalog/partition.h"
48 : #include "catalog/pg_publication.h"
49 : #include "commands/matview.h"
50 : #include "commands/trigger.h"
51 : #include "executor/execdebug.h"
52 : #include "executor/nodeSubplan.h"
53 : #include "foreign/fdwapi.h"
54 : #include "jit/jit.h"
55 : #include "mb/pg_wchar.h"
56 : #include "miscadmin.h"
57 : #include "parser/parse_relation.h"
58 : #include "parser/parsetree.h"
59 : #include "storage/bufmgr.h"
60 : #include "storage/lmgr.h"
61 : #include "tcop/utility.h"
62 : #include "utils/acl.h"
63 : #include "utils/backend_status.h"
64 : #include "utils/lsyscache.h"
65 : #include "utils/memutils.h"
66 : #include "utils/partcache.h"
67 : #include "utils/rls.h"
68 : #include "utils/ruleutils.h"
69 : #include "utils/snapmgr.h"
70 :
71 :
72 : /* Hooks for plugins to get control in ExecutorStart/Run/Finish/End */
73 : ExecutorStart_hook_type ExecutorStart_hook = NULL;
74 : ExecutorRun_hook_type ExecutorRun_hook = NULL;
75 : ExecutorFinish_hook_type ExecutorFinish_hook = NULL;
76 : ExecutorEnd_hook_type ExecutorEnd_hook = NULL;
77 :
78 : /* Hook for plugin to get control in ExecCheckPermissions() */
79 : ExecutorCheckPerms_hook_type ExecutorCheckPerms_hook = NULL;
80 :
81 : /* decls for local routines only used within this module */
82 : static void InitPlan(QueryDesc *queryDesc, int eflags);
83 : static void CheckValidRowMarkRel(Relation rel, RowMarkType markType);
84 : static void ExecPostprocessPlan(EState *estate);
85 : static void ExecEndPlan(PlanState *planstate, EState *estate);
86 : static void ExecutePlan(EState *estate, PlanState *planstate,
87 : bool use_parallel_mode,
88 : CmdType operation,
89 : bool sendTuples,
90 : uint64 numberTuples,
91 : ScanDirection direction,
92 : DestReceiver *dest,
93 : bool execute_once);
94 : static bool ExecCheckOneRelPerms(RTEPermissionInfo *perminfo);
95 : static bool ExecCheckPermissionsModified(Oid relOid, Oid userid,
96 : Bitmapset *modifiedCols,
97 : AclMode requiredPerms);
98 : static void ExecCheckXactReadOnly(PlannedStmt *plannedstmt);
99 : static char *ExecBuildSlotValueDescription(Oid reloid,
100 : TupleTableSlot *slot,
101 : TupleDesc tupdesc,
102 : Bitmapset *modifiedCols,
103 : int maxfieldlen);
104 : static void EvalPlanQualStart(EPQState *epqstate, Plan *planTree);
105 :
106 : /* end of local decls */
107 :
108 :
109 : /* ----------------------------------------------------------------
110 : * ExecutorStart
111 : *
112 : * This routine must be called at the beginning of any execution of any
113 : * query plan
114 : *
115 : * Takes a QueryDesc previously created by CreateQueryDesc (which is separate
116 : * only because some places use QueryDescs for utility commands). The tupDesc
117 : * field of the QueryDesc is filled in to describe the tuples that will be
118 : * returned, and the internal fields (estate and planstate) are set up.
119 : *
120 : * eflags contains flag bits as described in executor.h.
121 : *
122 : * NB: the CurrentMemoryContext when this is called will become the parent
123 : * of the per-query context used for this Executor invocation.
124 : *
125 : * We provide a function hook variable that lets loadable plugins
126 : * get control when ExecutorStart is called. Such a plugin would
127 : * normally call standard_ExecutorStart().
128 : *
129 : * ----------------------------------------------------------------
130 : */
131 : void
132 569120 : ExecutorStart(QueryDesc *queryDesc, int eflags)
133 : {
134 : /*
135 : * In some cases (e.g. an EXECUTE statement) a query execution will skip
136 : * parse analysis, which means that the query_id won't be reported. Note
137 : * that it's harmless to report the query_id multiple times, as the call
138 : * will be ignored if the top level query_id has already been reported.
139 : */
140 569120 : pgstat_report_query_id(queryDesc->plannedstmt->queryId, false);
141 :
142 569120 : if (ExecutorStart_hook)
143 88826 : (*ExecutorStart_hook) (queryDesc, eflags);
144 : else
145 480294 : standard_ExecutorStart(queryDesc, eflags);
146 567466 : }
147 :
148 : void
149 569120 : standard_ExecutorStart(QueryDesc *queryDesc, int eflags)
150 : {
151 : EState *estate;
152 : MemoryContext oldcontext;
153 :
154 : /* sanity checks: queryDesc must not be started already */
155 : Assert(queryDesc != NULL);
156 : Assert(queryDesc->estate == NULL);
157 :
158 : /*
159 : * If the transaction is read-only, we need to check if any writes are
160 : * planned to non-temporary tables. EXPLAIN is considered read-only.
161 : *
162 : * Don't allow writes in parallel mode. Supporting UPDATE and DELETE
163 : * would require (a) storing the combo CID hash in shared memory, rather
164 : * than synchronizing it just once at the start of parallelism, and (b) an
165 : * alternative to heap_update()'s reliance on xmax for mutual exclusion.
166 : * INSERT may have no such troubles, but we forbid it to simplify the
167 : * checks.
168 : *
169 : * We have lower-level defenses in CommandCounterIncrement and elsewhere
170 : * against performing unsafe operations in parallel mode, but this gives a
171 : * more user-friendly error message.
172 : */
173 569120 : if ((XactReadOnly || IsInParallelMode()) &&
174 127608 : !(eflags & EXEC_FLAG_EXPLAIN_ONLY))
175 127608 : ExecCheckXactReadOnly(queryDesc->plannedstmt);
176 :
177 : /*
178 : * Build EState, switch into per-query memory context for startup.
179 : */
180 569104 : estate = CreateExecutorState();
181 569104 : queryDesc->estate = estate;
182 :
183 569104 : oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
184 :
185 : /*
186 : * Fill in external parameters, if any, from queryDesc; and allocate
187 : * workspace for internal parameters
188 : */
189 569104 : estate->es_param_list_info = queryDesc->params;
190 :
191 569104 : if (queryDesc->plannedstmt->paramExecTypes != NIL)
192 : {
193 : int nParamExec;
194 :
195 159978 : nParamExec = list_length(queryDesc->plannedstmt->paramExecTypes);
196 159978 : estate->es_param_exec_vals = (ParamExecData *)
197 159978 : palloc0(nParamExec * sizeof(ParamExecData));
198 : }
199 :
200 : /* We now require all callers to provide sourceText */
201 : Assert(queryDesc->sourceText != NULL);
202 569104 : estate->es_sourceText = queryDesc->sourceText;
203 :
204 : /*
205 : * Fill in the query environment, if any, from queryDesc.
206 : */
207 569104 : estate->es_queryEnv = queryDesc->queryEnv;
208 :
209 : /*
210 : * If non-read-only query, set the command ID to mark output tuples with
211 : */
212 569104 : switch (queryDesc->operation)
213 : {
214 465704 : case CMD_SELECT:
215 :
216 : /*
217 : * SELECT FOR [KEY] UPDATE/SHARE and modifying CTEs need to mark
218 : * tuples
219 : */
220 465704 : if (queryDesc->plannedstmt->rowMarks != NIL ||
221 458628 : queryDesc->plannedstmt->hasModifyingCTE)
222 7204 : estate->es_output_cid = GetCurrentCommandId(true);
223 :
224 : /*
225 : * A SELECT without modifying CTEs can't possibly queue triggers,
226 : * so force skip-triggers mode. This is just a marginal efficiency
227 : * hack, since AfterTriggerBeginQuery/AfterTriggerEndQuery aren't
228 : * all that expensive, but we might as well do it.
229 : */
230 465704 : if (!queryDesc->plannedstmt->hasModifyingCTE)
231 465576 : eflags |= EXEC_FLAG_SKIP_TRIGGERS;
232 465704 : break;
233 :
234 103400 : case CMD_INSERT:
235 : case CMD_DELETE:
236 : case CMD_UPDATE:
237 : case CMD_MERGE:
238 103400 : estate->es_output_cid = GetCurrentCommandId(true);
239 103400 : break;
240 :
241 0 : default:
242 0 : elog(ERROR, "unrecognized operation code: %d",
243 : (int) queryDesc->operation);
244 : break;
245 : }
246 :
247 : /*
248 : * Copy other important information into the EState
249 : */
250 569104 : estate->es_snapshot = RegisterSnapshot(queryDesc->snapshot);
251 569104 : estate->es_crosscheck_snapshot = RegisterSnapshot(queryDesc->crosscheck_snapshot);
252 569104 : estate->es_top_eflags = eflags;
253 569104 : estate->es_instrument = queryDesc->instrument_options;
254 569104 : estate->es_jit_flags = queryDesc->plannedstmt->jitFlags;
255 :
256 : /*
257 : * Set up an AFTER-trigger statement context, unless told not to, or
258 : * unless it's EXPLAIN-only mode (when ExecutorFinish won't be called).
259 : */
260 569104 : if (!(eflags & (EXEC_FLAG_SKIP_TRIGGERS | EXEC_FLAG_EXPLAIN_ONLY)))
261 102154 : AfterTriggerBeginQuery();
262 :
263 : /*
264 : * Initialize the plan state tree
265 : */
266 569104 : InitPlan(queryDesc, eflags);
267 :
268 567466 : MemoryContextSwitchTo(oldcontext);
269 567466 : }
270 :
271 : /* ----------------------------------------------------------------
272 : * ExecutorRun
273 : *
274 : * This is the main routine of the executor module. It accepts
275 : * the query descriptor from the traffic cop and executes the
276 : * query plan.
277 : *
278 : * ExecutorStart must have been called already.
279 : *
280 : * If direction is NoMovementScanDirection then nothing is done
281 : * except to start up/shut down the destination. Otherwise,
282 : * we retrieve up to 'count' tuples in the specified direction.
283 : *
284 : * Note: count = 0 is interpreted as no portal limit, i.e., run to
285 : * completion. Also note that the count limit is only applied to
286 : * retrieved tuples, not for instance to those inserted/updated/deleted
287 : * by a ModifyTable plan node.
288 : *
289 : * There is no return value, but output tuples (if any) are sent to
290 : * the destination receiver specified in the QueryDesc; and the number
291 : * of tuples processed at the top level can be found in
292 : * estate->es_processed. The total number of tuples processed in all
293 : * the ExecutorRun calls can be found in estate->es_total_processed.
294 : *
295 : * We provide a function hook variable that lets loadable plugins
296 : * get control when ExecutorRun is called. Such a plugin would
297 : * normally call standard_ExecutorRun().
298 : *
299 : * ----------------------------------------------------------------
300 : */
301 : void
302 562352 : ExecutorRun(QueryDesc *queryDesc,
303 : ScanDirection direction, uint64 count,
304 : bool execute_once)
305 : {
306 562352 : if (ExecutorRun_hook)
307 86576 : (*ExecutorRun_hook) (queryDesc, direction, count, execute_once);
308 : else
309 475776 : standard_ExecutorRun(queryDesc, direction, count, execute_once);
310 540562 : }
311 :
312 : void
313 562352 : standard_ExecutorRun(QueryDesc *queryDesc,
314 : ScanDirection direction, uint64 count, bool execute_once)
315 : {
316 : EState *estate;
317 : CmdType operation;
318 : DestReceiver *dest;
319 : bool sendTuples;
320 : MemoryContext oldcontext;
321 :
322 : /* sanity checks */
323 : Assert(queryDesc != NULL);
324 :
325 562352 : estate = queryDesc->estate;
326 :
327 : Assert(estate != NULL);
328 : Assert(!(estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY));
329 :
330 : /*
331 : * Switch into per-query memory context
332 : */
333 562352 : oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
334 :
335 : /* Allow instrumentation of Executor overall runtime */
336 562352 : if (queryDesc->totaltime)
337 54188 : InstrStartNode(queryDesc->totaltime);
338 :
339 : /*
340 : * extract information from the query descriptor and the query feature.
341 : */
342 562352 : operation = queryDesc->operation;
343 562352 : dest = queryDesc->dest;
344 :
345 : /*
346 : * startup tuple receiver, if we will be emitting tuples
347 : */
348 562352 : estate->es_processed = 0;
349 :
350 664048 : sendTuples = (operation == CMD_SELECT ||
351 101696 : queryDesc->plannedstmt->hasReturning);
352 :
353 562352 : if (sendTuples)
354 464302 : dest->rStartup(dest, operation, queryDesc->tupDesc);
355 :
356 : /*
357 : * run plan
358 : */
359 562314 : if (!ScanDirectionIsNoMovement(direction))
360 : {
361 561102 : if (execute_once && queryDesc->already_executed)
362 0 : elog(ERROR, "can't re-execute query flagged for single execution");
363 561102 : queryDesc->already_executed = true;
364 :
365 561102 : ExecutePlan(estate,
366 : queryDesc->planstate,
367 561102 : queryDesc->plannedstmt->parallelModeNeeded,
368 : operation,
369 : sendTuples,
370 : count,
371 : direction,
372 : dest,
373 : execute_once);
374 : }
375 :
376 : /*
377 : * Update es_total_processed to keep track of the number of tuples
378 : * processed across multiple ExecutorRun() calls.
379 : */
380 540562 : estate->es_total_processed += estate->es_processed;
381 :
382 : /*
383 : * shutdown tuple receiver, if we started it
384 : */
385 540562 : if (sendTuples)
386 445176 : dest->rShutdown(dest);
387 :
388 540562 : if (queryDesc->totaltime)
389 52254 : InstrStopNode(queryDesc->totaltime, estate->es_processed);
390 :
391 540562 : MemoryContextSwitchTo(oldcontext);
392 540562 : }
393 :
394 : /* ----------------------------------------------------------------
395 : * ExecutorFinish
396 : *
397 : * This routine must be called after the last ExecutorRun call.
398 : * It performs cleanup such as firing AFTER triggers. It is
399 : * separate from ExecutorEnd because EXPLAIN ANALYZE needs to
400 : * include these actions in the total runtime.
401 : *
402 : * We provide a function hook variable that lets loadable plugins
403 : * get control when ExecutorFinish is called. Such a plugin would
404 : * normally call standard_ExecutorFinish().
405 : *
406 : * ----------------------------------------------------------------
407 : */
408 : void
409 527910 : ExecutorFinish(QueryDesc *queryDesc)
410 : {
411 527910 : if (ExecutorFinish_hook)
412 77058 : (*ExecutorFinish_hook) (queryDesc);
413 : else
414 450852 : standard_ExecutorFinish(queryDesc);
415 527040 : }
416 :
417 : void
418 527910 : standard_ExecutorFinish(QueryDesc *queryDesc)
419 : {
420 : EState *estate;
421 : MemoryContext oldcontext;
422 :
423 : /* sanity checks */
424 : Assert(queryDesc != NULL);
425 :
426 527910 : estate = queryDesc->estate;
427 :
428 : Assert(estate != NULL);
429 : Assert(!(estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY));
430 :
431 : /* This should be run once and only once per Executor instance */
432 : Assert(!estate->es_finished);
433 :
434 : /* Switch into per-query memory context */
435 527910 : oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
436 :
437 : /* Allow instrumentation of Executor overall runtime */
438 527910 : if (queryDesc->totaltime)
439 52254 : InstrStartNode(queryDesc->totaltime);
440 :
441 : /* Run ModifyTable nodes to completion */
442 527910 : ExecPostprocessPlan(estate);
443 :
444 : /* Execute queued AFTER triggers, unless told not to */
445 527910 : if (!(estate->es_top_eflags & EXEC_FLAG_SKIP_TRIGGERS))
446 98438 : AfterTriggerEndQuery(estate);
447 :
448 527040 : if (queryDesc->totaltime)
449 52006 : InstrStopNode(queryDesc->totaltime, 0);
450 :
451 527040 : MemoryContextSwitchTo(oldcontext);
452 :
453 527040 : estate->es_finished = true;
454 527040 : }
455 :
456 : /* ----------------------------------------------------------------
457 : * ExecutorEnd
458 : *
459 : * This routine must be called at the end of execution of any
460 : * query plan
461 : *
462 : * We provide a function hook variable that lets loadable plugins
463 : * get control when ExecutorEnd is called. Such a plugin would
464 : * normally call standard_ExecutorEnd().
465 : *
466 : * ----------------------------------------------------------------
467 : */
468 : void
469 544428 : ExecutorEnd(QueryDesc *queryDesc)
470 : {
471 544428 : if (ExecutorEnd_hook)
472 81708 : (*ExecutorEnd_hook) (queryDesc);
473 : else
474 462720 : standard_ExecutorEnd(queryDesc);
475 544428 : }
476 :
477 : void
478 544428 : standard_ExecutorEnd(QueryDesc *queryDesc)
479 : {
480 : EState *estate;
481 : MemoryContext oldcontext;
482 :
483 : /* sanity checks */
484 : Assert(queryDesc != NULL);
485 :
486 544428 : estate = queryDesc->estate;
487 :
488 : Assert(estate != NULL);
489 :
490 : /*
491 : * Check that ExecutorFinish was called, unless in EXPLAIN-only mode. This
492 : * Assert is needed because ExecutorFinish is new as of 9.1, and callers
493 : * might forget to call it.
494 : */
495 : Assert(estate->es_finished ||
496 : (estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY));
497 :
498 : /*
499 : * Switch into per-query memory context to run ExecEndPlan
500 : */
501 544428 : oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
502 :
503 544428 : ExecEndPlan(queryDesc->planstate, estate);
504 :
505 : /* do away with our snapshots */
506 544428 : UnregisterSnapshot(estate->es_snapshot);
507 544428 : UnregisterSnapshot(estate->es_crosscheck_snapshot);
508 :
509 : /*
510 : * Must switch out of context before destroying it
511 : */
512 544428 : MemoryContextSwitchTo(oldcontext);
513 :
514 : /*
515 : * Release EState and per-query memory context. This should release
516 : * everything the executor has allocated.
517 : */
518 544428 : FreeExecutorState(estate);
519 :
520 : /* Reset queryDesc fields that no longer point to anything */
521 544428 : queryDesc->tupDesc = NULL;
522 544428 : queryDesc->estate = NULL;
523 544428 : queryDesc->planstate = NULL;
524 544428 : queryDesc->totaltime = NULL;
525 544428 : }
526 :
527 : /* ----------------------------------------------------------------
528 : * ExecutorRewind
529 : *
530 : * This routine may be called on an open queryDesc to rewind it
531 : * to the start.
532 : * ----------------------------------------------------------------
533 : */
534 : void
535 140 : ExecutorRewind(QueryDesc *queryDesc)
536 : {
537 : EState *estate;
538 : MemoryContext oldcontext;
539 :
540 : /* sanity checks */
541 : Assert(queryDesc != NULL);
542 :
543 140 : estate = queryDesc->estate;
544 :
545 : Assert(estate != NULL);
546 :
547 : /* It's probably not sensible to rescan updating queries */
548 : Assert(queryDesc->operation == CMD_SELECT);
549 :
550 : /*
551 : * Switch into per-query memory context
552 : */
553 140 : oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
554 :
555 : /*
556 : * rescan plan
557 : */
558 140 : ExecReScan(queryDesc->planstate);
559 :
560 140 : MemoryContextSwitchTo(oldcontext);
561 140 : }
562 :
563 :
564 : /*
565 : * ExecCheckPermissions
566 : * Check access permissions of relations mentioned in a query
567 : *
568 : * Returns true if permissions are adequate. Otherwise, throws an appropriate
569 : * error if ereport_on_violation is true, or simply returns false otherwise.
570 : *
571 : * Note that this does NOT address row-level security policies (aka: RLS). If
572 : * rows will be returned to the user as a result of this permission check
573 : * passing, then RLS also needs to be consulted (and check_enable_rls()).
574 : *
575 : * See rewrite/rowsecurity.c.
576 : *
577 : * NB: rangeTable is no longer used by us, but kept around for the hooks that
578 : * might still want to look at the RTEs.
579 : */
580 : bool
581 578482 : ExecCheckPermissions(List *rangeTable, List *rteperminfos,
582 : bool ereport_on_violation)
583 : {
584 : ListCell *l;
585 578482 : bool result = true;
586 :
587 : #ifdef USE_ASSERT_CHECKING
588 : Bitmapset *indexset = NULL;
589 :
590 : /* Check that rteperminfos is consistent with rangeTable */
591 : foreach(l, rangeTable)
592 : {
593 : RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
594 :
595 : if (rte->perminfoindex != 0)
596 : {
597 : /* Sanity checks */
598 :
599 : /*
600 : * Only relation RTEs and subquery RTEs that were once relation
601 : * RTEs (views) have their perminfoindex set.
602 : */
603 : Assert(rte->rtekind == RTE_RELATION ||
604 : (rte->rtekind == RTE_SUBQUERY &&
605 : rte->relkind == RELKIND_VIEW));
606 :
607 : (void) getRTEPermissionInfo(rteperminfos, rte);
608 : /* Many-to-one mapping not allowed */
609 : Assert(!bms_is_member(rte->perminfoindex, indexset));
610 : indexset = bms_add_member(indexset, rte->perminfoindex);
611 : }
612 : }
613 :
614 : /* All rteperminfos are referenced */
615 : Assert(bms_num_members(indexset) == list_length(rteperminfos));
616 : #endif
617 :
618 1040024 : foreach(l, rteperminfos)
619 : {
620 462886 : RTEPermissionInfo *perminfo = lfirst_node(RTEPermissionInfo, l);
621 :
622 : Assert(OidIsValid(perminfo->relid));
623 462886 : result = ExecCheckOneRelPerms(perminfo);
624 462886 : if (!result)
625 : {
626 1344 : if (ereport_on_violation)
627 1332 : aclcheck_error(ACLCHECK_NO_PRIV,
628 1332 : get_relkind_objtype(get_rel_relkind(perminfo->relid)),
629 1332 : get_rel_name(perminfo->relid));
630 12 : return false;
631 : }
632 : }
633 :
634 577138 : if (ExecutorCheckPerms_hook)
635 12 : result = (*ExecutorCheckPerms_hook) (rangeTable, rteperminfos,
636 : ereport_on_violation);
637 577138 : return result;
638 : }
639 :
640 : /*
641 : * ExecCheckOneRelPerms
642 : * Check access permissions for a single relation.
643 : */
644 : static bool
645 462886 : ExecCheckOneRelPerms(RTEPermissionInfo *perminfo)
646 : {
647 : AclMode requiredPerms;
648 : AclMode relPerms;
649 : AclMode remainingPerms;
650 : Oid userid;
651 462886 : Oid relOid = perminfo->relid;
652 :
653 462886 : requiredPerms = perminfo->requiredPerms;
654 : Assert(requiredPerms != 0);
655 :
656 : /*
657 : * userid to check as: current user unless we have a setuid indication.
658 : *
659 : * Note: GetUserId() is presently fast enough that there's no harm in
660 : * calling it separately for each relation. If that stops being true, we
661 : * could call it once in ExecCheckPermissions and pass the userid down
662 : * from there. But for now, no need for the extra clutter.
663 : */
664 925772 : userid = OidIsValid(perminfo->checkAsUser) ?
665 462886 : perminfo->checkAsUser : GetUserId();
666 :
667 : /*
668 : * We must have *all* the requiredPerms bits, but some of the bits can be
669 : * satisfied from column-level rather than relation-level permissions.
670 : * First, remove any bits that are satisfied by relation permissions.
671 : */
672 462886 : relPerms = pg_class_aclmask(relOid, userid, requiredPerms, ACLMASK_ALL);
673 462886 : remainingPerms = requiredPerms & ~relPerms;
674 462886 : if (remainingPerms != 0)
675 : {
676 2078 : int col = -1;
677 :
678 : /*
679 : * If we lack any permissions that exist only as relation permissions,
680 : * we can fail straight away.
681 : */
682 2078 : if (remainingPerms & ~(ACL_SELECT | ACL_INSERT | ACL_UPDATE))
683 120 : return false;
684 :
685 : /*
686 : * Check to see if we have the needed privileges at column level.
687 : *
688 : * Note: failures just report a table-level error; it would be nicer
689 : * to report a column-level error if we have some but not all of the
690 : * column privileges.
691 : */
692 1958 : if (remainingPerms & ACL_SELECT)
693 : {
694 : /*
695 : * When the query doesn't explicitly reference any columns (for
696 : * example, SELECT COUNT(*) FROM table), allow the query if we
697 : * have SELECT on any column of the rel, as per SQL spec.
698 : */
699 1302 : if (bms_is_empty(perminfo->selectedCols))
700 : {
701 48 : if (pg_attribute_aclcheck_all(relOid, userid, ACL_SELECT,
702 : ACLMASK_ANY) != ACLCHECK_OK)
703 6 : return false;
704 : }
705 :
706 2174 : while ((col = bms_next_member(perminfo->selectedCols, col)) >= 0)
707 : {
708 : /* bit #s are offset by FirstLowInvalidHeapAttributeNumber */
709 1680 : AttrNumber attno = col + FirstLowInvalidHeapAttributeNumber;
710 :
711 1680 : if (attno == InvalidAttrNumber)
712 : {
713 : /* Whole-row reference, must have priv on all cols */
714 54 : if (pg_attribute_aclcheck_all(relOid, userid, ACL_SELECT,
715 : ACLMASK_ALL) != ACLCHECK_OK)
716 30 : return false;
717 : }
718 : else
719 : {
720 1626 : if (pg_attribute_aclcheck(relOid, attno, userid,
721 : ACL_SELECT) != ACLCHECK_OK)
722 772 : return false;
723 : }
724 : }
725 : }
726 :
727 : /*
728 : * Basically the same for the mod columns, for both INSERT and UPDATE
729 : * privilege as specified by remainingPerms.
730 : */
731 1150 : if (remainingPerms & ACL_INSERT &&
732 296 : !ExecCheckPermissionsModified(relOid,
733 : userid,
734 : perminfo->insertedCols,
735 : ACL_INSERT))
736 164 : return false;
737 :
738 986 : if (remainingPerms & ACL_UPDATE &&
739 576 : !ExecCheckPermissionsModified(relOid,
740 : userid,
741 : perminfo->updatedCols,
742 : ACL_UPDATE))
743 252 : return false;
744 : }
745 461542 : return true;
746 : }
747 :
748 : /*
749 : * ExecCheckPermissionsModified
750 : * Check INSERT or UPDATE access permissions for a single relation (these
751 : * are processed uniformly).
752 : */
753 : static bool
754 872 : ExecCheckPermissionsModified(Oid relOid, Oid userid, Bitmapset *modifiedCols,
755 : AclMode requiredPerms)
756 : {
757 872 : int col = -1;
758 :
759 : /*
760 : * When the query doesn't explicitly update any columns, allow the query
761 : * if we have permission on any column of the rel. This is to handle
762 : * SELECT FOR UPDATE as well as possible corner cases in UPDATE.
763 : */
764 872 : if (bms_is_empty(modifiedCols))
765 : {
766 48 : if (pg_attribute_aclcheck_all(relOid, userid, requiredPerms,
767 : ACLMASK_ANY) != ACLCHECK_OK)
768 48 : return false;
769 : }
770 :
771 1394 : while ((col = bms_next_member(modifiedCols, col)) >= 0)
772 : {
773 : /* bit #s are offset by FirstLowInvalidHeapAttributeNumber */
774 938 : AttrNumber attno = col + FirstLowInvalidHeapAttributeNumber;
775 :
776 938 : if (attno == InvalidAttrNumber)
777 : {
778 : /* whole-row reference can't happen here */
779 0 : elog(ERROR, "whole-row update is not implemented");
780 : }
781 : else
782 : {
783 938 : if (pg_attribute_aclcheck(relOid, attno, userid,
784 : requiredPerms) != ACLCHECK_OK)
785 368 : return false;
786 : }
787 : }
788 456 : return true;
789 : }
790 :
791 : /*
792 : * Check that the query does not imply any writes to non-temp tables;
793 : * unless we're in parallel mode, in which case don't even allow writes
794 : * to temp tables.
795 : *
796 : * Note: in a Hot Standby this would need to reject writes to temp
797 : * tables just as we do in parallel mode; but an HS standby can't have created
798 : * any temp tables in the first place, so no need to check that.
799 : */
800 : static void
801 127608 : ExecCheckXactReadOnly(PlannedStmt *plannedstmt)
802 : {
803 : ListCell *l;
804 :
805 : /*
806 : * Fail if write permissions are requested in parallel mode for table
807 : * (temp or non-temp), otherwise fail for any non-temp table.
808 : */
809 207044 : foreach(l, plannedstmt->permInfos)
810 : {
811 79452 : RTEPermissionInfo *perminfo = lfirst_node(RTEPermissionInfo, l);
812 :
813 79452 : if ((perminfo->requiredPerms & (~ACL_SELECT)) == 0)
814 79424 : continue;
815 :
816 28 : if (isTempNamespace(get_rel_namespace(perminfo->relid)))
817 12 : continue;
818 :
819 16 : PreventCommandIfReadOnly(CreateCommandName((Node *) plannedstmt));
820 : }
821 :
822 127592 : if (plannedstmt->commandType != CMD_SELECT || plannedstmt->hasModifyingCTE)
823 12 : PreventCommandIfParallelMode(CreateCommandName((Node *) plannedstmt));
824 127592 : }
825 :
826 :
827 : /* ----------------------------------------------------------------
828 : * InitPlan
829 : *
830 : * Initializes the query plan: open files, allocate storage
831 : * and start up the rule manager
832 : * ----------------------------------------------------------------
833 : */
834 : static void
835 569104 : InitPlan(QueryDesc *queryDesc, int eflags)
836 : {
837 569104 : CmdType operation = queryDesc->operation;
838 569104 : PlannedStmt *plannedstmt = queryDesc->plannedstmt;
839 569104 : Plan *plan = plannedstmt->planTree;
840 569104 : List *rangeTable = plannedstmt->rtable;
841 569104 : EState *estate = queryDesc->estate;
842 : PlanState *planstate;
843 : TupleDesc tupType;
844 : ListCell *l;
845 : int i;
846 :
847 : /*
848 : * Do permissions checks
849 : */
850 569104 : ExecCheckPermissions(rangeTable, plannedstmt->permInfos, true);
851 :
852 : /*
853 : * initialize the node's execution state
854 : */
855 567856 : ExecInitRangeTable(estate, rangeTable, plannedstmt->permInfos);
856 :
857 567856 : estate->es_plannedstmt = plannedstmt;
858 :
859 : /*
860 : * Next, build the ExecRowMark array from the PlanRowMark(s), if any.
861 : */
862 567856 : if (plannedstmt->rowMarks)
863 : {
864 8622 : estate->es_rowmarks = (ExecRowMark **)
865 8622 : palloc0(estate->es_range_table_size * sizeof(ExecRowMark *));
866 19642 : foreach(l, plannedstmt->rowMarks)
867 : {
868 11026 : PlanRowMark *rc = (PlanRowMark *) lfirst(l);
869 : Oid relid;
870 : Relation relation;
871 : ExecRowMark *erm;
872 :
873 : /* ignore "parent" rowmarks; they are irrelevant at runtime */
874 11026 : if (rc->isParent)
875 1550 : continue;
876 :
877 : /* get relation's OID (will produce InvalidOid if subquery) */
878 9476 : relid = exec_rt_fetch(rc->rti, estate)->relid;
879 :
880 : /* open relation, if we need to access it for this mark type */
881 9476 : switch (rc->markType)
882 : {
883 9000 : case ROW_MARK_EXCLUSIVE:
884 : case ROW_MARK_NOKEYEXCLUSIVE:
885 : case ROW_MARK_SHARE:
886 : case ROW_MARK_KEYSHARE:
887 : case ROW_MARK_REFERENCE:
888 9000 : relation = ExecGetRangeTableRelation(estate, rc->rti);
889 9000 : break;
890 476 : case ROW_MARK_COPY:
891 : /* no physical table access is required */
892 476 : relation = NULL;
893 476 : break;
894 0 : default:
895 0 : elog(ERROR, "unrecognized markType: %d", rc->markType);
896 : relation = NULL; /* keep compiler quiet */
897 : break;
898 : }
899 :
900 : /* Check that relation is a legal target for marking */
901 9476 : if (relation)
902 9000 : CheckValidRowMarkRel(relation, rc->markType);
903 :
904 9470 : erm = (ExecRowMark *) palloc(sizeof(ExecRowMark));
905 9470 : erm->relation = relation;
906 9470 : erm->relid = relid;
907 9470 : erm->rti = rc->rti;
908 9470 : erm->prti = rc->prti;
909 9470 : erm->rowmarkId = rc->rowmarkId;
910 9470 : erm->markType = rc->markType;
911 9470 : erm->strength = rc->strength;
912 9470 : erm->waitPolicy = rc->waitPolicy;
913 9470 : erm->ermActive = false;
914 9470 : ItemPointerSetInvalid(&(erm->curCtid));
915 9470 : erm->ermExtra = NULL;
916 :
917 : Assert(erm->rti > 0 && erm->rti <= estate->es_range_table_size &&
918 : estate->es_rowmarks[erm->rti - 1] == NULL);
919 :
920 9470 : estate->es_rowmarks[erm->rti - 1] = erm;
921 : }
922 : }
923 :
924 : /*
925 : * Initialize the executor's tuple table to empty.
926 : */
927 567850 : estate->es_tupleTable = NIL;
928 :
929 : /* signal that this EState is not used for EPQ */
930 567850 : estate->es_epq_active = NULL;
931 :
932 : /*
933 : * Initialize private state information for each SubPlan. We must do this
934 : * before running ExecInitNode on the main query tree, since
935 : * ExecInitSubPlan expects to be able to find these entries.
936 : */
937 : Assert(estate->es_subplanstates == NIL);
938 567850 : i = 1; /* subplan indices count from 1 */
939 602688 : foreach(l, plannedstmt->subplans)
940 : {
941 34838 : Plan *subplan = (Plan *) lfirst(l);
942 : PlanState *subplanstate;
943 : int sp_eflags;
944 :
945 : /*
946 : * A subplan will never need to do BACKWARD scan nor MARK/RESTORE. If
947 : * it is a parameterless subplan (not initplan), we suggest that it be
948 : * prepared to handle REWIND efficiently; otherwise there is no need.
949 : */
950 34838 : sp_eflags = eflags
951 : & ~(EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK);
952 34838 : if (bms_is_member(i, plannedstmt->rewindPlanIDs))
953 42 : sp_eflags |= EXEC_FLAG_REWIND;
954 :
955 34838 : subplanstate = ExecInitNode(subplan, estate, sp_eflags);
956 :
957 34838 : estate->es_subplanstates = lappend(estate->es_subplanstates,
958 : subplanstate);
959 :
960 34838 : i++;
961 : }
962 :
963 : /*
964 : * Initialize the private state information for all the nodes in the query
965 : * tree. This opens files, allocates storage and leaves us ready to start
966 : * processing tuples.
967 : */
968 567850 : planstate = ExecInitNode(plan, estate, eflags);
969 :
970 : /*
971 : * Get the tuple descriptor describing the type of tuples to return.
972 : */
973 567466 : tupType = ExecGetResultType(planstate);
974 :
975 : /*
976 : * Initialize the junk filter if needed. SELECT queries need a filter if
977 : * there are any junk attrs in the top-level tlist.
978 : */
979 567466 : if (operation == CMD_SELECT)
980 : {
981 465008 : bool junk_filter_needed = false;
982 : ListCell *tlist;
983 :
984 1521516 : foreach(tlist, plan->targetlist)
985 : {
986 1077598 : TargetEntry *tle = (TargetEntry *) lfirst(tlist);
987 :
988 1077598 : if (tle->resjunk)
989 : {
990 21090 : junk_filter_needed = true;
991 21090 : break;
992 : }
993 : }
994 :
995 465008 : if (junk_filter_needed)
996 : {
997 : JunkFilter *j;
998 : TupleTableSlot *slot;
999 :
1000 21090 : slot = ExecInitExtraTupleSlot(estate, NULL, &TTSOpsVirtual);
1001 21090 : j = ExecInitJunkFilter(planstate->plan->targetlist,
1002 : slot);
1003 21090 : estate->es_junkFilter = j;
1004 :
1005 : /* Want to return the cleaned tuple type */
1006 21090 : tupType = j->jf_cleanTupType;
1007 : }
1008 : }
1009 :
1010 567466 : queryDesc->tupDesc = tupType;
1011 567466 : queryDesc->planstate = planstate;
1012 567466 : }
1013 :
1014 : /*
1015 : * Check that a proposed result relation is a legal target for the operation
1016 : *
1017 : * Generally the parser and/or planner should have noticed any such mistake
1018 : * already, but let's make sure.
1019 : *
1020 : * Note: when changing this function, you probably also need to look at
1021 : * CheckValidRowMarkRel.
1022 : */
1023 : void
1024 114674 : CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation)
1025 : {
1026 114674 : Relation resultRel = resultRelInfo->ri_RelationDesc;
1027 114674 : TriggerDesc *trigDesc = resultRel->trigdesc;
1028 : FdwRoutine *fdwroutine;
1029 :
1030 114674 : switch (resultRel->rd_rel->relkind)
1031 : {
1032 113578 : case RELKIND_RELATION:
1033 : case RELKIND_PARTITIONED_TABLE:
1034 113578 : CheckCmdReplicaIdentity(resultRel, operation);
1035 113320 : break;
1036 0 : case RELKIND_SEQUENCE:
1037 0 : ereport(ERROR,
1038 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1039 : errmsg("cannot change sequence \"%s\"",
1040 : RelationGetRelationName(resultRel))));
1041 : break;
1042 0 : case RELKIND_TOASTVALUE:
1043 0 : ereport(ERROR,
1044 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1045 : errmsg("cannot change TOAST relation \"%s\"",
1046 : RelationGetRelationName(resultRel))));
1047 : break;
1048 324 : case RELKIND_VIEW:
1049 :
1050 : /*
1051 : * Okay only if there's a suitable INSTEAD OF trigger. Messages
1052 : * here should match rewriteHandler.c's rewriteTargetView and
1053 : * RewriteQuery, except that we omit errdetail because we haven't
1054 : * got the information handy (and given that we really shouldn't
1055 : * get here anyway, it's not worth great exertion to get).
1056 : */
1057 : switch (operation)
1058 : {
1059 132 : case CMD_INSERT:
1060 132 : if (!trigDesc || !trigDesc->trig_insert_instead_row)
1061 0 : ereport(ERROR,
1062 : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1063 : errmsg("cannot insert into view \"%s\"",
1064 : RelationGetRelationName(resultRel)),
1065 : errhint("To enable inserting into the view, provide an INSTEAD OF INSERT trigger or an unconditional ON INSERT DO INSTEAD rule.")));
1066 132 : break;
1067 138 : case CMD_UPDATE:
1068 138 : if (!trigDesc || !trigDesc->trig_update_instead_row)
1069 0 : ereport(ERROR,
1070 : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1071 : errmsg("cannot update view \"%s\"",
1072 : RelationGetRelationName(resultRel)),
1073 : errhint("To enable updating the view, provide an INSTEAD OF UPDATE trigger or an unconditional ON UPDATE DO INSTEAD rule.")));
1074 138 : break;
1075 54 : case CMD_DELETE:
1076 54 : if (!trigDesc || !trigDesc->trig_delete_instead_row)
1077 0 : ereport(ERROR,
1078 : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1079 : errmsg("cannot delete from view \"%s\"",
1080 : RelationGetRelationName(resultRel)),
1081 : errhint("To enable deleting from the view, provide an INSTEAD OF DELETE trigger or an unconditional ON DELETE DO INSTEAD rule.")));
1082 54 : break;
1083 0 : default:
1084 0 : elog(ERROR, "unrecognized CmdType: %d", (int) operation);
1085 : break;
1086 : }
1087 324 : break;
1088 120 : case RELKIND_MATVIEW:
1089 120 : if (!MatViewIncrementalMaintenanceIsEnabled())
1090 0 : ereport(ERROR,
1091 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1092 : errmsg("cannot change materialized view \"%s\"",
1093 : RelationGetRelationName(resultRel))));
1094 120 : break;
1095 652 : case RELKIND_FOREIGN_TABLE:
1096 : /* Okay only if the FDW supports it */
1097 652 : fdwroutine = resultRelInfo->ri_FdwRoutine;
1098 : switch (operation)
1099 : {
1100 304 : case CMD_INSERT:
1101 304 : if (fdwroutine->ExecForeignInsert == NULL)
1102 10 : ereport(ERROR,
1103 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1104 : errmsg("cannot insert into foreign table \"%s\"",
1105 : RelationGetRelationName(resultRel))));
1106 294 : if (fdwroutine->IsForeignRelUpdatable != NULL &&
1107 294 : (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
1108 0 : ereport(ERROR,
1109 : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1110 : errmsg("foreign table \"%s\" does not allow inserts",
1111 : RelationGetRelationName(resultRel))));
1112 294 : break;
1113 194 : case CMD_UPDATE:
1114 194 : if (fdwroutine->ExecForeignUpdate == NULL)
1115 4 : ereport(ERROR,
1116 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1117 : errmsg("cannot update foreign table \"%s\"",
1118 : RelationGetRelationName(resultRel))));
1119 190 : if (fdwroutine->IsForeignRelUpdatable != NULL &&
1120 190 : (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_UPDATE)) == 0)
1121 0 : ereport(ERROR,
1122 : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1123 : errmsg("foreign table \"%s\" does not allow updates",
1124 : RelationGetRelationName(resultRel))));
1125 190 : break;
1126 154 : case CMD_DELETE:
1127 154 : if (fdwroutine->ExecForeignDelete == NULL)
1128 4 : ereport(ERROR,
1129 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1130 : errmsg("cannot delete from foreign table \"%s\"",
1131 : RelationGetRelationName(resultRel))));
1132 150 : if (fdwroutine->IsForeignRelUpdatable != NULL &&
1133 150 : (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_DELETE)) == 0)
1134 0 : ereport(ERROR,
1135 : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1136 : errmsg("foreign table \"%s\" does not allow deletes",
1137 : RelationGetRelationName(resultRel))));
1138 150 : break;
1139 0 : default:
1140 0 : elog(ERROR, "unrecognized CmdType: %d", (int) operation);
1141 : break;
1142 : }
1143 634 : break;
1144 0 : default:
1145 0 : ereport(ERROR,
1146 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1147 : errmsg("cannot change relation \"%s\"",
1148 : RelationGetRelationName(resultRel))));
1149 : break;
1150 : }
1151 114398 : }
1152 :
1153 : /*
1154 : * Check that a proposed rowmark target relation is a legal target
1155 : *
1156 : * In most cases parser and/or planner should have noticed this already, but
1157 : * they don't cover all cases.
1158 : */
1159 : static void
1160 9000 : CheckValidRowMarkRel(Relation rel, RowMarkType markType)
1161 : {
1162 : FdwRoutine *fdwroutine;
1163 :
1164 9000 : switch (rel->rd_rel->relkind)
1165 : {
1166 8988 : case RELKIND_RELATION:
1167 : case RELKIND_PARTITIONED_TABLE:
1168 : /* OK */
1169 8988 : break;
1170 0 : case RELKIND_SEQUENCE:
1171 : /* Must disallow this because we don't vacuum sequences */
1172 0 : ereport(ERROR,
1173 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1174 : errmsg("cannot lock rows in sequence \"%s\"",
1175 : RelationGetRelationName(rel))));
1176 : break;
1177 0 : case RELKIND_TOASTVALUE:
1178 : /* We could allow this, but there seems no good reason to */
1179 0 : ereport(ERROR,
1180 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1181 : errmsg("cannot lock rows in TOAST relation \"%s\"",
1182 : RelationGetRelationName(rel))));
1183 : break;
1184 0 : case RELKIND_VIEW:
1185 : /* Should not get here; planner should have expanded the view */
1186 0 : ereport(ERROR,
1187 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1188 : errmsg("cannot lock rows in view \"%s\"",
1189 : RelationGetRelationName(rel))));
1190 : break;
1191 12 : case RELKIND_MATVIEW:
1192 : /* Allow referencing a matview, but not actual locking clauses */
1193 12 : if (markType != ROW_MARK_REFERENCE)
1194 6 : ereport(ERROR,
1195 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1196 : errmsg("cannot lock rows in materialized view \"%s\"",
1197 : RelationGetRelationName(rel))));
1198 6 : break;
1199 0 : case RELKIND_FOREIGN_TABLE:
1200 : /* Okay only if the FDW supports it */
1201 0 : fdwroutine = GetFdwRoutineForRelation(rel, false);
1202 0 : if (fdwroutine->RefetchForeignRow == NULL)
1203 0 : ereport(ERROR,
1204 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1205 : errmsg("cannot lock rows in foreign table \"%s\"",
1206 : RelationGetRelationName(rel))));
1207 0 : break;
1208 0 : default:
1209 0 : ereport(ERROR,
1210 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1211 : errmsg("cannot lock rows in relation \"%s\"",
1212 : RelationGetRelationName(rel))));
1213 : break;
1214 : }
1215 8994 : }
1216 :
1217 : /*
1218 : * Initialize ResultRelInfo data for one result relation
1219 : *
1220 : * Caution: before Postgres 9.1, this function included the relkind checking
1221 : * that's now in CheckValidResultRel, and it also did ExecOpenIndices if
1222 : * appropriate. Be sure callers cover those needs.
1223 : */
1224 : void
1225 418392 : InitResultRelInfo(ResultRelInfo *resultRelInfo,
1226 : Relation resultRelationDesc,
1227 : Index resultRelationIndex,
1228 : ResultRelInfo *partition_root_rri,
1229 : int instrument_options)
1230 : {
1231 19246032 : MemSet(resultRelInfo, 0, sizeof(ResultRelInfo));
1232 418392 : resultRelInfo->type = T_ResultRelInfo;
1233 418392 : resultRelInfo->ri_RangeTableIndex = resultRelationIndex;
1234 418392 : resultRelInfo->ri_RelationDesc = resultRelationDesc;
1235 418392 : resultRelInfo->ri_NumIndices = 0;
1236 418392 : resultRelInfo->ri_IndexRelationDescs = NULL;
1237 418392 : resultRelInfo->ri_IndexRelationInfo = NULL;
1238 : /* make a copy so as not to depend on relcache info not changing... */
1239 418392 : resultRelInfo->ri_TrigDesc = CopyTriggerDesc(resultRelationDesc->trigdesc);
1240 418392 : if (resultRelInfo->ri_TrigDesc)
1241 : {
1242 15530 : int n = resultRelInfo->ri_TrigDesc->numtriggers;
1243 :
1244 15530 : resultRelInfo->ri_TrigFunctions = (FmgrInfo *)
1245 15530 : palloc0(n * sizeof(FmgrInfo));
1246 15530 : resultRelInfo->ri_TrigWhenExprs = (ExprState **)
1247 15530 : palloc0(n * sizeof(ExprState *));
1248 15530 : if (instrument_options)
1249 0 : resultRelInfo->ri_TrigInstrument = InstrAlloc(n, instrument_options, false);
1250 : }
1251 : else
1252 : {
1253 402862 : resultRelInfo->ri_TrigFunctions = NULL;
1254 402862 : resultRelInfo->ri_TrigWhenExprs = NULL;
1255 402862 : resultRelInfo->ri_TrigInstrument = NULL;
1256 : }
1257 418392 : if (resultRelationDesc->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
1258 674 : resultRelInfo->ri_FdwRoutine = GetFdwRoutineForRelation(resultRelationDesc, true);
1259 : else
1260 417718 : resultRelInfo->ri_FdwRoutine = NULL;
1261 :
1262 : /* The following fields are set later if needed */
1263 418392 : resultRelInfo->ri_RowIdAttNo = 0;
1264 418392 : resultRelInfo->ri_extraUpdatedCols = NULL;
1265 418392 : resultRelInfo->ri_projectNew = NULL;
1266 418392 : resultRelInfo->ri_newTupleSlot = NULL;
1267 418392 : resultRelInfo->ri_oldTupleSlot = NULL;
1268 418392 : resultRelInfo->ri_projectNewInfoValid = false;
1269 418392 : resultRelInfo->ri_FdwState = NULL;
1270 418392 : resultRelInfo->ri_usesFdwDirectModify = false;
1271 418392 : resultRelInfo->ri_ConstraintExprs = NULL;
1272 418392 : resultRelInfo->ri_GeneratedExprsI = NULL;
1273 418392 : resultRelInfo->ri_GeneratedExprsU = NULL;
1274 418392 : resultRelInfo->ri_projectReturning = NULL;
1275 418392 : resultRelInfo->ri_onConflictArbiterIndexes = NIL;
1276 418392 : resultRelInfo->ri_onConflict = NULL;
1277 418392 : resultRelInfo->ri_ReturningSlot = NULL;
1278 418392 : resultRelInfo->ri_TrigOldSlot = NULL;
1279 418392 : resultRelInfo->ri_TrigNewSlot = NULL;
1280 418392 : resultRelInfo->ri_matchedMergeAction = NIL;
1281 418392 : resultRelInfo->ri_notMatchedMergeAction = NIL;
1282 :
1283 : /*
1284 : * Only ExecInitPartitionInfo() and ExecInitPartitionDispatchInfo() pass
1285 : * non-NULL partition_root_rri. For child relations that are part of the
1286 : * initial query rather than being dynamically added by tuple routing,
1287 : * this field is filled in ExecInitModifyTable().
1288 : */
1289 418392 : resultRelInfo->ri_RootResultRelInfo = partition_root_rri;
1290 : /* Set by ExecGetRootToChildMap */
1291 418392 : resultRelInfo->ri_RootToChildMap = NULL;
1292 418392 : resultRelInfo->ri_RootToChildMapValid = false;
1293 : /* Set by ExecInitRoutingInfo */
1294 418392 : resultRelInfo->ri_PartitionTupleSlot = NULL;
1295 418392 : resultRelInfo->ri_ChildToRootMap = NULL;
1296 418392 : resultRelInfo->ri_ChildToRootMapValid = false;
1297 418392 : resultRelInfo->ri_CopyMultiInsertBuffer = NULL;
1298 418392 : }
1299 :
1300 : /*
1301 : * ExecGetTriggerResultRel
1302 : * Get a ResultRelInfo for a trigger target relation.
1303 : *
1304 : * Most of the time, triggers are fired on one of the result relations of the
1305 : * query, and so we can just return a member of the es_result_relations array,
1306 : * or the es_tuple_routing_result_relations list (if any). (Note: in self-join
1307 : * situations there might be multiple members with the same OID; if so it
1308 : * doesn't matter which one we pick.)
1309 : *
1310 : * However, it is sometimes necessary to fire triggers on other relations;
1311 : * this happens mainly when an RI update trigger queues additional triggers
1312 : * on other relations, which will be processed in the context of the outer
1313 : * query. For efficiency's sake, we want to have a ResultRelInfo for those
1314 : * triggers too; that can avoid repeated re-opening of the relation. (It
1315 : * also provides a way for EXPLAIN ANALYZE to report the runtimes of such
1316 : * triggers.) So we make additional ResultRelInfo's as needed, and save them
1317 : * in es_trig_target_relations.
1318 : */
1319 : ResultRelInfo *
1320 7402 : ExecGetTriggerResultRel(EState *estate, Oid relid,
1321 : ResultRelInfo *rootRelInfo)
1322 : {
1323 : ResultRelInfo *rInfo;
1324 : ListCell *l;
1325 : Relation rel;
1326 : MemoryContext oldcontext;
1327 :
1328 : /* Search through the query result relations */
1329 9398 : foreach(l, estate->es_opened_result_relations)
1330 : {
1331 8142 : rInfo = lfirst(l);
1332 8142 : if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
1333 6146 : return rInfo;
1334 : }
1335 :
1336 : /*
1337 : * Search through the result relations that were created during tuple
1338 : * routing, if any.
1339 : */
1340 1458 : foreach(l, estate->es_tuple_routing_result_relations)
1341 : {
1342 766 : rInfo = (ResultRelInfo *) lfirst(l);
1343 766 : if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
1344 564 : return rInfo;
1345 : }
1346 :
1347 : /* Nope, but maybe we already made an extra ResultRelInfo for it */
1348 1034 : foreach(l, estate->es_trig_target_relations)
1349 : {
1350 372 : rInfo = (ResultRelInfo *) lfirst(l);
1351 372 : if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
1352 30 : return rInfo;
1353 : }
1354 : /* Nope, so we need a new one */
1355 :
1356 : /*
1357 : * Open the target relation's relcache entry. We assume that an
1358 : * appropriate lock is still held by the backend from whenever the trigger
1359 : * event got queued, so we need take no new lock here. Also, we need not
1360 : * recheck the relkind, so no need for CheckValidResultRel.
1361 : */
1362 662 : rel = table_open(relid, NoLock);
1363 :
1364 : /*
1365 : * Make the new entry in the right context.
1366 : */
1367 662 : oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1368 662 : rInfo = makeNode(ResultRelInfo);
1369 662 : InitResultRelInfo(rInfo,
1370 : rel,
1371 : 0, /* dummy rangetable index */
1372 : rootRelInfo,
1373 : estate->es_instrument);
1374 662 : estate->es_trig_target_relations =
1375 662 : lappend(estate->es_trig_target_relations, rInfo);
1376 662 : MemoryContextSwitchTo(oldcontext);
1377 :
1378 : /*
1379 : * Currently, we don't need any index information in ResultRelInfos used
1380 : * only for triggers, so no need to call ExecOpenIndices.
1381 : */
1382 :
1383 662 : return rInfo;
1384 : }
1385 :
1386 : /*
1387 : * Return the ancestor relations of a given leaf partition result relation
1388 : * up to and including the query's root target relation.
1389 : *
1390 : * These work much like the ones opened by ExecGetTriggerResultRel, except
1391 : * that we need to keep them in a separate list.
1392 : *
1393 : * These are closed by ExecCloseResultRelations.
1394 : */
1395 : List *
1396 252 : ExecGetAncestorResultRels(EState *estate, ResultRelInfo *resultRelInfo)
1397 : {
1398 252 : ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
1399 252 : Relation partRel = resultRelInfo->ri_RelationDesc;
1400 : Oid rootRelOid;
1401 :
1402 252 : if (!partRel->rd_rel->relispartition)
1403 0 : elog(ERROR, "cannot find ancestors of a non-partition result relation");
1404 : Assert(rootRelInfo != NULL);
1405 252 : rootRelOid = RelationGetRelid(rootRelInfo->ri_RelationDesc);
1406 252 : if (resultRelInfo->ri_ancestorResultRels == NIL)
1407 : {
1408 : ListCell *lc;
1409 210 : List *oids = get_partition_ancestors(RelationGetRelid(partRel));
1410 210 : List *ancResultRels = NIL;
1411 :
1412 276 : foreach(lc, oids)
1413 : {
1414 276 : Oid ancOid = lfirst_oid(lc);
1415 : Relation ancRel;
1416 : ResultRelInfo *rInfo;
1417 :
1418 : /*
1419 : * Ignore the root ancestor here, and use ri_RootResultRelInfo
1420 : * (below) for it instead. Also, we stop climbing up the
1421 : * hierarchy when we find the table that was mentioned in the
1422 : * query.
1423 : */
1424 276 : if (ancOid == rootRelOid)
1425 210 : break;
1426 :
1427 : /*
1428 : * All ancestors up to the root target relation must have been
1429 : * locked by the planner or AcquireExecutorLocks().
1430 : */
1431 66 : ancRel = table_open(ancOid, NoLock);
1432 66 : rInfo = makeNode(ResultRelInfo);
1433 :
1434 : /* dummy rangetable index */
1435 66 : InitResultRelInfo(rInfo, ancRel, 0, NULL,
1436 : estate->es_instrument);
1437 66 : ancResultRels = lappend(ancResultRels, rInfo);
1438 : }
1439 210 : ancResultRels = lappend(ancResultRels, rootRelInfo);
1440 210 : resultRelInfo->ri_ancestorResultRels = ancResultRels;
1441 : }
1442 :
1443 : /* We must have found some ancestor */
1444 : Assert(resultRelInfo->ri_ancestorResultRels != NIL);
1445 :
1446 252 : return resultRelInfo->ri_ancestorResultRels;
1447 : }
1448 :
1449 : /* ----------------------------------------------------------------
1450 : * ExecPostprocessPlan
1451 : *
1452 : * Give plan nodes a final chance to execute before shutdown
1453 : * ----------------------------------------------------------------
1454 : */
1455 : static void
1456 527910 : ExecPostprocessPlan(EState *estate)
1457 : {
1458 : ListCell *lc;
1459 :
1460 : /*
1461 : * Make sure nodes run forward.
1462 : */
1463 527910 : estate->es_direction = ForwardScanDirection;
1464 :
1465 : /*
1466 : * Run any secondary ModifyTable nodes to completion, in case the main
1467 : * query did not fetch all rows from them. (We do this to ensure that
1468 : * such nodes have predictable results.)
1469 : */
1470 528730 : foreach(lc, estate->es_auxmodifytables)
1471 : {
1472 820 : PlanState *ps = (PlanState *) lfirst(lc);
1473 :
1474 : for (;;)
1475 138 : {
1476 : TupleTableSlot *slot;
1477 :
1478 : /* Reset the per-output-tuple exprcontext each time */
1479 958 : ResetPerTupleExprContext(estate);
1480 :
1481 958 : slot = ExecProcNode(ps);
1482 :
1483 958 : if (TupIsNull(slot))
1484 : break;
1485 : }
1486 : }
1487 527910 : }
1488 :
1489 : /* ----------------------------------------------------------------
1490 : * ExecEndPlan
1491 : *
1492 : * Cleans up the query plan -- closes files and frees up storage
1493 : *
1494 : * NOTE: we are no longer very worried about freeing storage per se
1495 : * in this code; FreeExecutorState should be guaranteed to release all
1496 : * memory that needs to be released. What we are worried about doing
1497 : * is closing relations and dropping buffer pins. Thus, for example,
1498 : * tuple tables must be cleared or dropped to ensure pins are released.
1499 : * ----------------------------------------------------------------
1500 : */
1501 : static void
1502 544428 : ExecEndPlan(PlanState *planstate, EState *estate)
1503 : {
1504 : ListCell *l;
1505 :
1506 : /*
1507 : * shut down the node-type-specific query processing
1508 : */
1509 544428 : ExecEndNode(planstate);
1510 :
1511 : /*
1512 : * for subplans too
1513 : */
1514 578726 : foreach(l, estate->es_subplanstates)
1515 : {
1516 34298 : PlanState *subplanstate = (PlanState *) lfirst(l);
1517 :
1518 34298 : ExecEndNode(subplanstate);
1519 : }
1520 :
1521 : /*
1522 : * destroy the executor's tuple table. Actually we only care about
1523 : * releasing buffer pins and tupdesc refcounts; there's no need to pfree
1524 : * the TupleTableSlots, since the containing memory context is about to go
1525 : * away anyway.
1526 : */
1527 544428 : ExecResetTupleTable(estate->es_tupleTable, false);
1528 :
1529 : /*
1530 : * Close any Relations that have been opened for range table entries or
1531 : * result relations.
1532 : */
1533 544428 : ExecCloseResultRelations(estate);
1534 544428 : ExecCloseRangeTableRelations(estate);
1535 544428 : }
1536 :
1537 : /*
1538 : * Close any relations that have been opened for ResultRelInfos.
1539 : */
1540 : void
1541 546116 : ExecCloseResultRelations(EState *estate)
1542 : {
1543 : ListCell *l;
1544 :
1545 : /*
1546 : * close indexes of result relation(s) if any. (Rels themselves are
1547 : * closed in ExecCloseRangeTableRelations())
1548 : *
1549 : * In addition, close the stub RTs that may be in each resultrel's
1550 : * ri_ancestorResultRels.
1551 : */
1552 650334 : foreach(l, estate->es_opened_result_relations)
1553 : {
1554 104218 : ResultRelInfo *resultRelInfo = lfirst(l);
1555 : ListCell *lc;
1556 :
1557 104218 : ExecCloseIndices(resultRelInfo);
1558 104446 : foreach(lc, resultRelInfo->ri_ancestorResultRels)
1559 : {
1560 228 : ResultRelInfo *rInfo = lfirst(lc);
1561 :
1562 : /*
1563 : * Ancestors with RTI > 0 (should only be the root ancestor) are
1564 : * closed by ExecCloseRangeTableRelations.
1565 : */
1566 228 : if (rInfo->ri_RangeTableIndex > 0)
1567 180 : continue;
1568 :
1569 48 : table_close(rInfo->ri_RelationDesc, NoLock);
1570 : }
1571 : }
1572 :
1573 : /* Close any relations that have been opened by ExecGetTriggerResultRel(). */
1574 546602 : foreach(l, estate->es_trig_target_relations)
1575 : {
1576 486 : ResultRelInfo *resultRelInfo = (ResultRelInfo *) lfirst(l);
1577 :
1578 : /*
1579 : * Assert this is a "dummy" ResultRelInfo, see above. Otherwise we
1580 : * might be issuing a duplicate close against a Relation opened by
1581 : * ExecGetRangeTableRelation.
1582 : */
1583 : Assert(resultRelInfo->ri_RangeTableIndex == 0);
1584 :
1585 : /*
1586 : * Since ExecGetTriggerResultRel doesn't call ExecOpenIndices for
1587 : * these rels, we needn't call ExecCloseIndices either.
1588 : */
1589 : Assert(resultRelInfo->ri_NumIndices == 0);
1590 :
1591 486 : table_close(resultRelInfo->ri_RelationDesc, NoLock);
1592 : }
1593 546116 : }
1594 :
1595 : /*
1596 : * Close all relations opened by ExecGetRangeTableRelation().
1597 : *
1598 : * We do not release any locks we might hold on those rels.
1599 : */
1600 : void
1601 545740 : ExecCloseRangeTableRelations(EState *estate)
1602 : {
1603 : int i;
1604 :
1605 1508770 : for (i = 0; i < estate->es_range_table_size; i++)
1606 : {
1607 963030 : if (estate->es_relations[i])
1608 433304 : table_close(estate->es_relations[i], NoLock);
1609 : }
1610 545740 : }
1611 :
1612 : /* ----------------------------------------------------------------
1613 : * ExecutePlan
1614 : *
1615 : * Processes the query plan until we have retrieved 'numberTuples' tuples,
1616 : * moving in the specified direction.
1617 : *
1618 : * Runs to completion if numberTuples is 0
1619 : *
1620 : * Note: the ctid attribute is a 'junk' attribute that is removed before the
1621 : * user can see it
1622 : * ----------------------------------------------------------------
1623 : */
1624 : static void
1625 561102 : ExecutePlan(EState *estate,
1626 : PlanState *planstate,
1627 : bool use_parallel_mode,
1628 : CmdType operation,
1629 : bool sendTuples,
1630 : uint64 numberTuples,
1631 : ScanDirection direction,
1632 : DestReceiver *dest,
1633 : bool execute_once)
1634 : {
1635 : TupleTableSlot *slot;
1636 : uint64 current_tuple_count;
1637 :
1638 : /*
1639 : * initialize local variables
1640 : */
1641 561102 : current_tuple_count = 0;
1642 :
1643 : /*
1644 : * Set the direction.
1645 : */
1646 561102 : estate->es_direction = direction;
1647 :
1648 : /*
1649 : * If the plan might potentially be executed multiple times, we must force
1650 : * it to run without parallelism, because we might exit early.
1651 : */
1652 561102 : if (!execute_once)
1653 21026 : use_parallel_mode = false;
1654 :
1655 561102 : estate->es_use_parallel_mode = use_parallel_mode;
1656 561102 : if (use_parallel_mode)
1657 626 : EnterParallelMode();
1658 :
1659 : /*
1660 : * Loop until we've processed the proper number of tuples from the plan.
1661 : */
1662 : for (;;)
1663 : {
1664 : /* Reset the per-output-tuple exprcontext */
1665 11306790 : ResetPerTupleExprContext(estate);
1666 :
1667 : /*
1668 : * Execute the plan and obtain a tuple
1669 : */
1670 11306790 : slot = ExecProcNode(planstate);
1671 :
1672 : /*
1673 : * if the tuple is null, then we assume there is nothing more to
1674 : * process so we just end the loop...
1675 : */
1676 11285038 : if (TupIsNull(slot))
1677 : break;
1678 :
1679 : /*
1680 : * If we have a junk filter, then project a new tuple with the junk
1681 : * removed.
1682 : *
1683 : * Store this new "clean" tuple in the junkfilter's resultSlot.
1684 : * (Formerly, we stored it back over the "dirty" tuple, which is WRONG
1685 : * because that tuple slot has the wrong descriptor.)
1686 : */
1687 10876530 : if (estate->es_junkFilter != NULL)
1688 234114 : slot = ExecFilterJunk(estate->es_junkFilter, slot);
1689 :
1690 : /*
1691 : * If we are supposed to send the tuple somewhere, do so. (In
1692 : * practice, this is probably always the case at this point.)
1693 : */
1694 10876530 : if (sendTuples)
1695 : {
1696 : /*
1697 : * If we are not able to send the tuple, we assume the destination
1698 : * has closed and no more tuples can be sent. If that's the case,
1699 : * end the loop.
1700 : */
1701 10876530 : if (!dest->receiveSlot(slot, dest))
1702 0 : break;
1703 : }
1704 :
1705 : /*
1706 : * Count tuples processed, if this is a SELECT. (For other operation
1707 : * types, the ModifyTable plan node must count the appropriate
1708 : * events.)
1709 : */
1710 10876530 : if (operation == CMD_SELECT)
1711 10870830 : (estate->es_processed)++;
1712 :
1713 : /*
1714 : * check our tuple count.. if we've processed the proper number then
1715 : * quit, else loop again and process more tuples. Zero numberTuples
1716 : * means no limit.
1717 : */
1718 10876530 : current_tuple_count++;
1719 10876530 : if (numberTuples && numberTuples == current_tuple_count)
1720 130842 : break;
1721 : }
1722 :
1723 : /*
1724 : * If we know we won't need to back up, we can release resources at this
1725 : * point.
1726 : */
1727 539350 : if (!(estate->es_top_eflags & EXEC_FLAG_BACKWARD))
1728 533816 : ExecShutdownNode(planstate);
1729 :
1730 539350 : if (use_parallel_mode)
1731 620 : ExitParallelMode();
1732 539350 : }
1733 :
1734 :
1735 : /*
1736 : * ExecRelCheck --- check that tuple meets constraints for result relation
1737 : *
1738 : * Returns NULL if OK, else name of failed check constraint
1739 : */
1740 : static const char *
1741 2638 : ExecRelCheck(ResultRelInfo *resultRelInfo,
1742 : TupleTableSlot *slot, EState *estate)
1743 : {
1744 2638 : Relation rel = resultRelInfo->ri_RelationDesc;
1745 2638 : int ncheck = rel->rd_att->constr->num_check;
1746 2638 : ConstrCheck *check = rel->rd_att->constr->check;
1747 : ExprContext *econtext;
1748 : MemoryContext oldContext;
1749 : int i;
1750 :
1751 : /*
1752 : * CheckConstraintFetch let this pass with only a warning, but now we
1753 : * should fail rather than possibly failing to enforce an important
1754 : * constraint.
1755 : */
1756 2638 : if (ncheck != rel->rd_rel->relchecks)
1757 0 : elog(ERROR, "%d pg_constraint record(s) missing for relation \"%s\"",
1758 : rel->rd_rel->relchecks - ncheck, RelationGetRelationName(rel));
1759 :
1760 : /*
1761 : * If first time through for this result relation, build expression
1762 : * nodetrees for rel's constraint expressions. Keep them in the per-query
1763 : * memory context so they'll survive throughout the query.
1764 : */
1765 2638 : if (resultRelInfo->ri_ConstraintExprs == NULL)
1766 : {
1767 1186 : oldContext = MemoryContextSwitchTo(estate->es_query_cxt);
1768 1186 : resultRelInfo->ri_ConstraintExprs =
1769 1186 : (ExprState **) palloc(ncheck * sizeof(ExprState *));
1770 2740 : for (i = 0; i < ncheck; i++)
1771 : {
1772 : Expr *checkconstr;
1773 :
1774 1560 : checkconstr = stringToNode(check[i].ccbin);
1775 1554 : resultRelInfo->ri_ConstraintExprs[i] =
1776 1560 : ExecPrepareExpr(checkconstr, estate);
1777 : }
1778 1180 : MemoryContextSwitchTo(oldContext);
1779 : }
1780 :
1781 : /*
1782 : * We will use the EState's per-tuple context for evaluating constraint
1783 : * expressions (creating it if it's not already there).
1784 : */
1785 2632 : econtext = GetPerTupleExprContext(estate);
1786 :
1787 : /* Arrange for econtext's scan tuple to be the tuple under test */
1788 2632 : econtext->ecxt_scantuple = slot;
1789 :
1790 : /* And evaluate the constraints */
1791 5808 : for (i = 0; i < ncheck; i++)
1792 : {
1793 3570 : ExprState *checkconstr = resultRelInfo->ri_ConstraintExprs[i];
1794 :
1795 : /*
1796 : * NOTE: SQL specifies that a NULL result from a constraint expression
1797 : * is not to be treated as a failure. Therefore, use ExecCheck not
1798 : * ExecQual.
1799 : */
1800 3570 : if (!ExecCheck(checkconstr, econtext))
1801 394 : return check[i].ccname;
1802 : }
1803 :
1804 : /* NULL result means no error */
1805 2238 : return NULL;
1806 : }
1807 :
1808 : /*
1809 : * ExecPartitionCheck --- check that tuple meets the partition constraint.
1810 : *
1811 : * Returns true if it meets the partition constraint. If the constraint
1812 : * fails and we're asked to emit an error, do so and don't return; otherwise
1813 : * return false.
1814 : */
1815 : bool
1816 14780 : ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
1817 : EState *estate, bool emitError)
1818 : {
1819 : ExprContext *econtext;
1820 : bool success;
1821 :
1822 : /*
1823 : * If first time through, build expression state tree for the partition
1824 : * check expression. (In the corner case where the partition check
1825 : * expression is empty, ie there's a default partition and nothing else,
1826 : * we'll be fooled into executing this code each time through. But it's
1827 : * pretty darn cheap in that case, so we don't worry about it.)
1828 : */
1829 14780 : if (resultRelInfo->ri_PartitionCheckExpr == NULL)
1830 : {
1831 : /*
1832 : * Ensure that the qual tree and prepared expression are in the
1833 : * query-lifespan context.
1834 : */
1835 5158 : MemoryContext oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
1836 5158 : List *qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc);
1837 :
1838 5158 : resultRelInfo->ri_PartitionCheckExpr = ExecPrepareCheck(qual, estate);
1839 5158 : MemoryContextSwitchTo(oldcxt);
1840 : }
1841 :
1842 : /*
1843 : * We will use the EState's per-tuple context for evaluating constraint
1844 : * expressions (creating it if it's not already there).
1845 : */
1846 14780 : econtext = GetPerTupleExprContext(estate);
1847 :
1848 : /* Arrange for econtext's scan tuple to be the tuple under test */
1849 14780 : econtext->ecxt_scantuple = slot;
1850 :
1851 : /*
1852 : * As in case of the catalogued constraints, we treat a NULL result as
1853 : * success here, not a failure.
1854 : */
1855 14780 : success = ExecCheck(resultRelInfo->ri_PartitionCheckExpr, econtext);
1856 :
1857 : /* if asked to emit error, don't actually return on failure */
1858 14780 : if (!success && emitError)
1859 202 : ExecPartitionCheckEmitError(resultRelInfo, slot, estate);
1860 :
1861 14578 : return success;
1862 : }
1863 :
1864 : /*
1865 : * ExecPartitionCheckEmitError - Form and emit an error message after a failed
1866 : * partition constraint check.
1867 : */
1868 : void
1869 244 : ExecPartitionCheckEmitError(ResultRelInfo *resultRelInfo,
1870 : TupleTableSlot *slot,
1871 : EState *estate)
1872 : {
1873 : Oid root_relid;
1874 : TupleDesc tupdesc;
1875 : char *val_desc;
1876 : Bitmapset *modifiedCols;
1877 :
1878 : /*
1879 : * If the tuple has been routed, it's been converted to the partition's
1880 : * rowtype, which might differ from the root table's. We must convert it
1881 : * back to the root table's rowtype so that val_desc in the error message
1882 : * matches the input tuple.
1883 : */
1884 244 : if (resultRelInfo->ri_RootResultRelInfo)
1885 : {
1886 20 : ResultRelInfo *rootrel = resultRelInfo->ri_RootResultRelInfo;
1887 : TupleDesc old_tupdesc;
1888 : AttrMap *map;
1889 :
1890 20 : root_relid = RelationGetRelid(rootrel->ri_RelationDesc);
1891 20 : tupdesc = RelationGetDescr(rootrel->ri_RelationDesc);
1892 :
1893 20 : old_tupdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
1894 : /* a reverse map */
1895 20 : map = build_attrmap_by_name_if_req(old_tupdesc, tupdesc, false);
1896 :
1897 : /*
1898 : * Partition-specific slot's tupdesc can't be changed, so allocate a
1899 : * new one.
1900 : */
1901 20 : if (map != NULL)
1902 8 : slot = execute_attr_map_slot(map, slot,
1903 : MakeTupleTableSlot(tupdesc, &TTSOpsVirtual));
1904 20 : modifiedCols = bms_union(ExecGetInsertedCols(rootrel, estate),
1905 20 : ExecGetUpdatedCols(rootrel, estate));
1906 : }
1907 : else
1908 : {
1909 224 : root_relid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
1910 224 : tupdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
1911 224 : modifiedCols = bms_union(ExecGetInsertedCols(resultRelInfo, estate),
1912 224 : ExecGetUpdatedCols(resultRelInfo, estate));
1913 : }
1914 :
1915 244 : val_desc = ExecBuildSlotValueDescription(root_relid,
1916 : slot,
1917 : tupdesc,
1918 : modifiedCols,
1919 : 64);
1920 244 : ereport(ERROR,
1921 : (errcode(ERRCODE_CHECK_VIOLATION),
1922 : errmsg("new row for relation \"%s\" violates partition constraint",
1923 : RelationGetRelationName(resultRelInfo->ri_RelationDesc)),
1924 : val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
1925 : errtable(resultRelInfo->ri_RelationDesc)));
1926 : }
1927 :
1928 : /*
1929 : * ExecConstraints - check constraints of the tuple in 'slot'
1930 : *
1931 : * This checks the traditional NOT NULL and check constraints.
1932 : *
1933 : * The partition constraint is *NOT* checked.
1934 : *
1935 : * Note: 'slot' contains the tuple to check the constraints of, which may
1936 : * have been converted from the original input tuple after tuple routing.
1937 : * 'resultRelInfo' is the final result relation, after tuple routing.
1938 : */
1939 : void
1940 3859364 : ExecConstraints(ResultRelInfo *resultRelInfo,
1941 : TupleTableSlot *slot, EState *estate)
1942 : {
1943 3859364 : Relation rel = resultRelInfo->ri_RelationDesc;
1944 3859364 : TupleDesc tupdesc = RelationGetDescr(rel);
1945 3859364 : TupleConstr *constr = tupdesc->constr;
1946 : Bitmapset *modifiedCols;
1947 :
1948 : Assert(constr); /* we should not be called otherwise */
1949 :
1950 3859364 : if (constr->has_not_null)
1951 : {
1952 3853806 : int natts = tupdesc->natts;
1953 : int attrChk;
1954 :
1955 14179622 : for (attrChk = 1; attrChk <= natts; attrChk++)
1956 : {
1957 10326052 : Form_pg_attribute att = TupleDescAttr(tupdesc, attrChk - 1);
1958 :
1959 10326052 : if (att->attnotnull && slot_attisnull(slot, attrChk))
1960 : {
1961 : char *val_desc;
1962 236 : Relation orig_rel = rel;
1963 236 : TupleDesc orig_tupdesc = RelationGetDescr(rel);
1964 :
1965 : /*
1966 : * If the tuple has been routed, it's been converted to the
1967 : * partition's rowtype, which might differ from the root
1968 : * table's. We must convert it back to the root table's
1969 : * rowtype so that val_desc shown error message matches the
1970 : * input tuple.
1971 : */
1972 236 : if (resultRelInfo->ri_RootResultRelInfo)
1973 : {
1974 54 : ResultRelInfo *rootrel = resultRelInfo->ri_RootResultRelInfo;
1975 : AttrMap *map;
1976 :
1977 54 : tupdesc = RelationGetDescr(rootrel->ri_RelationDesc);
1978 : /* a reverse map */
1979 54 : map = build_attrmap_by_name_if_req(orig_tupdesc,
1980 : tupdesc,
1981 : false);
1982 :
1983 : /*
1984 : * Partition-specific slot's tupdesc can't be changed, so
1985 : * allocate a new one.
1986 : */
1987 54 : if (map != NULL)
1988 42 : slot = execute_attr_map_slot(map, slot,
1989 : MakeTupleTableSlot(tupdesc, &TTSOpsVirtual));
1990 54 : modifiedCols = bms_union(ExecGetInsertedCols(rootrel, estate),
1991 54 : ExecGetUpdatedCols(rootrel, estate));
1992 54 : rel = rootrel->ri_RelationDesc;
1993 : }
1994 : else
1995 182 : modifiedCols = bms_union(ExecGetInsertedCols(resultRelInfo, estate),
1996 182 : ExecGetUpdatedCols(resultRelInfo, estate));
1997 236 : val_desc = ExecBuildSlotValueDescription(RelationGetRelid(rel),
1998 : slot,
1999 : tupdesc,
2000 : modifiedCols,
2001 : 64);
2002 :
2003 236 : ereport(ERROR,
2004 : (errcode(ERRCODE_NOT_NULL_VIOLATION),
2005 : errmsg("null value in column \"%s\" of relation \"%s\" violates not-null constraint",
2006 : NameStr(att->attname),
2007 : RelationGetRelationName(orig_rel)),
2008 : val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
2009 : errtablecol(orig_rel, attrChk)));
2010 : }
2011 : }
2012 : }
2013 :
2014 3859128 : if (rel->rd_rel->relchecks > 0)
2015 : {
2016 : const char *failed;
2017 :
2018 2638 : if ((failed = ExecRelCheck(resultRelInfo, slot, estate)) != NULL)
2019 : {
2020 : char *val_desc;
2021 394 : Relation orig_rel = rel;
2022 :
2023 : /* See the comment above. */
2024 394 : if (resultRelInfo->ri_RootResultRelInfo)
2025 : {
2026 90 : ResultRelInfo *rootrel = resultRelInfo->ri_RootResultRelInfo;
2027 90 : TupleDesc old_tupdesc = RelationGetDescr(rel);
2028 : AttrMap *map;
2029 :
2030 90 : tupdesc = RelationGetDescr(rootrel->ri_RelationDesc);
2031 : /* a reverse map */
2032 90 : map = build_attrmap_by_name_if_req(old_tupdesc,
2033 : tupdesc,
2034 : false);
2035 :
2036 : /*
2037 : * Partition-specific slot's tupdesc can't be changed, so
2038 : * allocate a new one.
2039 : */
2040 90 : if (map != NULL)
2041 60 : slot = execute_attr_map_slot(map, slot,
2042 : MakeTupleTableSlot(tupdesc, &TTSOpsVirtual));
2043 90 : modifiedCols = bms_union(ExecGetInsertedCols(rootrel, estate),
2044 90 : ExecGetUpdatedCols(rootrel, estate));
2045 90 : rel = rootrel->ri_RelationDesc;
2046 : }
2047 : else
2048 304 : modifiedCols = bms_union(ExecGetInsertedCols(resultRelInfo, estate),
2049 304 : ExecGetUpdatedCols(resultRelInfo, estate));
2050 394 : val_desc = ExecBuildSlotValueDescription(RelationGetRelid(rel),
2051 : slot,
2052 : tupdesc,
2053 : modifiedCols,
2054 : 64);
2055 394 : ereport(ERROR,
2056 : (errcode(ERRCODE_CHECK_VIOLATION),
2057 : errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
2058 : RelationGetRelationName(orig_rel), failed),
2059 : val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
2060 : errtableconstraint(orig_rel, failed)));
2061 : }
2062 : }
2063 3858728 : }
2064 :
2065 : /*
2066 : * ExecWithCheckOptions -- check that tuple satisfies any WITH CHECK OPTIONs
2067 : * of the specified kind.
2068 : *
2069 : * Note that this needs to be called multiple times to ensure that all kinds of
2070 : * WITH CHECK OPTIONs are handled (both those from views which have the WITH
2071 : * CHECK OPTION set and from row-level security policies). See ExecInsert()
2072 : * and ExecUpdate().
2073 : */
2074 : void
2075 1880 : ExecWithCheckOptions(WCOKind kind, ResultRelInfo *resultRelInfo,
2076 : TupleTableSlot *slot, EState *estate)
2077 : {
2078 1880 : Relation rel = resultRelInfo->ri_RelationDesc;
2079 1880 : TupleDesc tupdesc = RelationGetDescr(rel);
2080 : ExprContext *econtext;
2081 : ListCell *l1,
2082 : *l2;
2083 :
2084 : /*
2085 : * We will use the EState's per-tuple context for evaluating constraint
2086 : * expressions (creating it if it's not already there).
2087 : */
2088 1880 : econtext = GetPerTupleExprContext(estate);
2089 :
2090 : /* Arrange for econtext's scan tuple to be the tuple under test */
2091 1880 : econtext->ecxt_scantuple = slot;
2092 :
2093 : /* Check each of the constraints */
2094 4450 : forboth(l1, resultRelInfo->ri_WithCheckOptions,
2095 : l2, resultRelInfo->ri_WithCheckOptionExprs)
2096 : {
2097 3038 : WithCheckOption *wco = (WithCheckOption *) lfirst(l1);
2098 3038 : ExprState *wcoExpr = (ExprState *) lfirst(l2);
2099 :
2100 : /*
2101 : * Skip any WCOs which are not the kind we are looking for at this
2102 : * time.
2103 : */
2104 3038 : if (wco->kind != kind)
2105 1684 : continue;
2106 :
2107 : /*
2108 : * WITH CHECK OPTION checks are intended to ensure that the new tuple
2109 : * is visible (in the case of a view) or that it passes the
2110 : * 'with-check' policy (in the case of row security). If the qual
2111 : * evaluates to NULL or FALSE, then the new tuple won't be included in
2112 : * the view or doesn't pass the 'with-check' policy for the table.
2113 : */
2114 1354 : if (!ExecQual(wcoExpr, econtext))
2115 : {
2116 : char *val_desc;
2117 : Bitmapset *modifiedCols;
2118 :
2119 468 : switch (wco->kind)
2120 : {
2121 : /*
2122 : * For WITH CHECK OPTIONs coming from views, we might be
2123 : * able to provide the details on the row, depending on
2124 : * the permissions on the relation (that is, if the user
2125 : * could view it directly anyway). For RLS violations, we
2126 : * don't include the data since we don't know if the user
2127 : * should be able to view the tuple as that depends on the
2128 : * USING policy.
2129 : */
2130 198 : case WCO_VIEW_CHECK:
2131 : /* See the comment in ExecConstraints(). */
2132 198 : if (resultRelInfo->ri_RootResultRelInfo)
2133 : {
2134 36 : ResultRelInfo *rootrel = resultRelInfo->ri_RootResultRelInfo;
2135 36 : TupleDesc old_tupdesc = RelationGetDescr(rel);
2136 : AttrMap *map;
2137 :
2138 36 : tupdesc = RelationGetDescr(rootrel->ri_RelationDesc);
2139 : /* a reverse map */
2140 36 : map = build_attrmap_by_name_if_req(old_tupdesc,
2141 : tupdesc,
2142 : false);
2143 :
2144 : /*
2145 : * Partition-specific slot's tupdesc can't be changed,
2146 : * so allocate a new one.
2147 : */
2148 36 : if (map != NULL)
2149 18 : slot = execute_attr_map_slot(map, slot,
2150 : MakeTupleTableSlot(tupdesc, &TTSOpsVirtual));
2151 :
2152 36 : modifiedCols = bms_union(ExecGetInsertedCols(rootrel, estate),
2153 36 : ExecGetUpdatedCols(rootrel, estate));
2154 36 : rel = rootrel->ri_RelationDesc;
2155 : }
2156 : else
2157 162 : modifiedCols = bms_union(ExecGetInsertedCols(resultRelInfo, estate),
2158 162 : ExecGetUpdatedCols(resultRelInfo, estate));
2159 198 : val_desc = ExecBuildSlotValueDescription(RelationGetRelid(rel),
2160 : slot,
2161 : tupdesc,
2162 : modifiedCols,
2163 : 64);
2164 :
2165 198 : ereport(ERROR,
2166 : (errcode(ERRCODE_WITH_CHECK_OPTION_VIOLATION),
2167 : errmsg("new row violates check option for view \"%s\"",
2168 : wco->relname),
2169 : val_desc ? errdetail("Failing row contains %s.",
2170 : val_desc) : 0));
2171 : break;
2172 222 : case WCO_RLS_INSERT_CHECK:
2173 : case WCO_RLS_UPDATE_CHECK:
2174 222 : if (wco->polname != NULL)
2175 48 : ereport(ERROR,
2176 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2177 : errmsg("new row violates row-level security policy \"%s\" for table \"%s\"",
2178 : wco->polname, wco->relname)));
2179 : else
2180 174 : ereport(ERROR,
2181 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2182 : errmsg("new row violates row-level security policy for table \"%s\"",
2183 : wco->relname)));
2184 : break;
2185 24 : case WCO_RLS_MERGE_UPDATE_CHECK:
2186 : case WCO_RLS_MERGE_DELETE_CHECK:
2187 24 : if (wco->polname != NULL)
2188 0 : ereport(ERROR,
2189 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2190 : errmsg("target row violates row-level security policy \"%s\" (USING expression) for table \"%s\"",
2191 : wco->polname, wco->relname)));
2192 : else
2193 24 : ereport(ERROR,
2194 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2195 : errmsg("target row violates row-level security policy (USING expression) for table \"%s\"",
2196 : wco->relname)));
2197 : break;
2198 24 : case WCO_RLS_CONFLICT_CHECK:
2199 24 : if (wco->polname != NULL)
2200 0 : ereport(ERROR,
2201 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2202 : errmsg("new row violates row-level security policy \"%s\" (USING expression) for table \"%s\"",
2203 : wco->polname, wco->relname)));
2204 : else
2205 24 : ereport(ERROR,
2206 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2207 : errmsg("new row violates row-level security policy (USING expression) for table \"%s\"",
2208 : wco->relname)));
2209 : break;
2210 0 : default:
2211 0 : elog(ERROR, "unrecognized WCO kind: %u", wco->kind);
2212 : break;
2213 : }
2214 886 : }
2215 : }
2216 1412 : }
2217 :
2218 : /*
2219 : * ExecBuildSlotValueDescription -- construct a string representing a tuple
2220 : *
2221 : * This is intentionally very similar to BuildIndexValueDescription, but
2222 : * unlike that function, we truncate long field values (to at most maxfieldlen
2223 : * bytes). That seems necessary here since heap field values could be very
2224 : * long, whereas index entries typically aren't so wide.
2225 : *
2226 : * Also, unlike the case with index entries, we need to be prepared to ignore
2227 : * dropped columns. We used to use the slot's tuple descriptor to decode the
2228 : * data, but the slot's descriptor doesn't identify dropped columns, so we
2229 : * now need to be passed the relation's descriptor.
2230 : *
2231 : * Note that, like BuildIndexValueDescription, if the user does not have
2232 : * permission to view any of the columns involved, a NULL is returned. Unlike
2233 : * BuildIndexValueDescription, if the user has access to view a subset of the
2234 : * column involved, that subset will be returned with a key identifying which
2235 : * columns they are.
2236 : */
2237 : static char *
2238 1072 : ExecBuildSlotValueDescription(Oid reloid,
2239 : TupleTableSlot *slot,
2240 : TupleDesc tupdesc,
2241 : Bitmapset *modifiedCols,
2242 : int maxfieldlen)
2243 : {
2244 : StringInfoData buf;
2245 : StringInfoData collist;
2246 1072 : bool write_comma = false;
2247 1072 : bool write_comma_collist = false;
2248 : int i;
2249 : AclResult aclresult;
2250 1072 : bool table_perm = false;
2251 1072 : bool any_perm = false;
2252 :
2253 : /*
2254 : * Check if RLS is enabled and should be active for the relation; if so,
2255 : * then don't return anything. Otherwise, go through normal permission
2256 : * checks.
2257 : */
2258 1072 : if (check_enable_rls(reloid, InvalidOid, true) == RLS_ENABLED)
2259 0 : return NULL;
2260 :
2261 1072 : initStringInfo(&buf);
2262 :
2263 1072 : appendStringInfoChar(&buf, '(');
2264 :
2265 : /*
2266 : * Check if the user has permissions to see the row. Table-level SELECT
2267 : * allows access to all columns. If the user does not have table-level
2268 : * SELECT then we check each column and include those the user has SELECT
2269 : * rights on. Additionally, we always include columns the user provided
2270 : * data for.
2271 : */
2272 1072 : aclresult = pg_class_aclcheck(reloid, GetUserId(), ACL_SELECT);
2273 1072 : if (aclresult != ACLCHECK_OK)
2274 : {
2275 : /* Set up the buffer for the column list */
2276 60 : initStringInfo(&collist);
2277 60 : appendStringInfoChar(&collist, '(');
2278 : }
2279 : else
2280 1012 : table_perm = any_perm = true;
2281 :
2282 : /* Make sure the tuple is fully deconstructed */
2283 1072 : slot_getallattrs(slot);
2284 :
2285 3924 : for (i = 0; i < tupdesc->natts; i++)
2286 : {
2287 2852 : bool column_perm = false;
2288 : char *val;
2289 : int vallen;
2290 2852 : Form_pg_attribute att = TupleDescAttr(tupdesc, i);
2291 :
2292 : /* ignore dropped columns */
2293 2852 : if (att->attisdropped)
2294 38 : continue;
2295 :
2296 2814 : if (!table_perm)
2297 : {
2298 : /*
2299 : * No table-level SELECT, so need to make sure they either have
2300 : * SELECT rights on the column or that they have provided the data
2301 : * for the column. If not, omit this column from the error
2302 : * message.
2303 : */
2304 234 : aclresult = pg_attribute_aclcheck(reloid, att->attnum,
2305 : GetUserId(), ACL_SELECT);
2306 234 : if (bms_is_member(att->attnum - FirstLowInvalidHeapAttributeNumber,
2307 138 : modifiedCols) || aclresult == ACLCHECK_OK)
2308 : {
2309 144 : column_perm = any_perm = true;
2310 :
2311 144 : if (write_comma_collist)
2312 84 : appendStringInfoString(&collist, ", ");
2313 : else
2314 60 : write_comma_collist = true;
2315 :
2316 144 : appendStringInfoString(&collist, NameStr(att->attname));
2317 : }
2318 : }
2319 :
2320 2814 : if (table_perm || column_perm)
2321 : {
2322 2724 : if (slot->tts_isnull[i])
2323 496 : val = "null";
2324 : else
2325 : {
2326 : Oid foutoid;
2327 : bool typisvarlena;
2328 :
2329 2228 : getTypeOutputInfo(att->atttypid,
2330 : &foutoid, &typisvarlena);
2331 2228 : val = OidOutputFunctionCall(foutoid, slot->tts_values[i]);
2332 : }
2333 :
2334 2724 : if (write_comma)
2335 1652 : appendStringInfoString(&buf, ", ");
2336 : else
2337 1072 : write_comma = true;
2338 :
2339 : /* truncate if needed */
2340 2724 : vallen = strlen(val);
2341 2724 : if (vallen <= maxfieldlen)
2342 2724 : appendBinaryStringInfo(&buf, val, vallen);
2343 : else
2344 : {
2345 0 : vallen = pg_mbcliplen(val, vallen, maxfieldlen);
2346 0 : appendBinaryStringInfo(&buf, val, vallen);
2347 0 : appendStringInfoString(&buf, "...");
2348 : }
2349 : }
2350 : }
2351 :
2352 : /* If we end up with zero columns being returned, then return NULL. */
2353 1072 : if (!any_perm)
2354 0 : return NULL;
2355 :
2356 1072 : appendStringInfoChar(&buf, ')');
2357 :
2358 1072 : if (!table_perm)
2359 : {
2360 60 : appendStringInfoString(&collist, ") = ");
2361 60 : appendBinaryStringInfo(&collist, buf.data, buf.len);
2362 :
2363 60 : return collist.data;
2364 : }
2365 :
2366 1012 : return buf.data;
2367 : }
2368 :
2369 :
2370 : /*
2371 : * ExecUpdateLockMode -- find the appropriate UPDATE tuple lock mode for a
2372 : * given ResultRelInfo
2373 : */
2374 : LockTupleMode
2375 7810 : ExecUpdateLockMode(EState *estate, ResultRelInfo *relinfo)
2376 : {
2377 : Bitmapset *keyCols;
2378 : Bitmapset *updatedCols;
2379 :
2380 : /*
2381 : * Compute lock mode to use. If columns that are part of the key have not
2382 : * been modified, then we can use a weaker lock, allowing for better
2383 : * concurrency.
2384 : */
2385 7810 : updatedCols = ExecGetAllUpdatedCols(relinfo, estate);
2386 7810 : keyCols = RelationGetIndexAttrBitmap(relinfo->ri_RelationDesc,
2387 : INDEX_ATTR_BITMAP_KEY);
2388 :
2389 7810 : if (bms_overlap(keyCols, updatedCols))
2390 250 : return LockTupleExclusive;
2391 :
2392 7560 : return LockTupleNoKeyExclusive;
2393 : }
2394 :
2395 : /*
2396 : * ExecFindRowMark -- find the ExecRowMark struct for given rangetable index
2397 : *
2398 : * If no such struct, either return NULL or throw error depending on missing_ok
2399 : */
2400 : ExecRowMark *
2401 9450 : ExecFindRowMark(EState *estate, Index rti, bool missing_ok)
2402 : {
2403 9450 : if (rti > 0 && rti <= estate->es_range_table_size &&
2404 9450 : estate->es_rowmarks != NULL)
2405 : {
2406 9450 : ExecRowMark *erm = estate->es_rowmarks[rti - 1];
2407 :
2408 9450 : if (erm)
2409 9450 : return erm;
2410 : }
2411 0 : if (!missing_ok)
2412 0 : elog(ERROR, "failed to find ExecRowMark for rangetable index %u", rti);
2413 0 : return NULL;
2414 : }
2415 :
2416 : /*
2417 : * ExecBuildAuxRowMark -- create an ExecAuxRowMark struct
2418 : *
2419 : * Inputs are the underlying ExecRowMark struct and the targetlist of the
2420 : * input plan node (not planstate node!). We need the latter to find out
2421 : * the column numbers of the resjunk columns.
2422 : */
2423 : ExecAuxRowMark *
2424 9450 : ExecBuildAuxRowMark(ExecRowMark *erm, List *targetlist)
2425 : {
2426 9450 : ExecAuxRowMark *aerm = (ExecAuxRowMark *) palloc0(sizeof(ExecAuxRowMark));
2427 : char resname[32];
2428 :
2429 9450 : aerm->rowmark = erm;
2430 :
2431 : /* Look up the resjunk columns associated with this rowmark */
2432 9450 : if (erm->markType != ROW_MARK_COPY)
2433 : {
2434 : /* need ctid for all methods other than COPY */
2435 9014 : snprintf(resname, sizeof(resname), "ctid%u", erm->rowmarkId);
2436 9014 : aerm->ctidAttNo = ExecFindJunkAttributeInTlist(targetlist,
2437 : resname);
2438 9014 : if (!AttributeNumberIsValid(aerm->ctidAttNo))
2439 0 : elog(ERROR, "could not find junk %s column", resname);
2440 : }
2441 : else
2442 : {
2443 : /* need wholerow if COPY */
2444 436 : snprintf(resname, sizeof(resname), "wholerow%u", erm->rowmarkId);
2445 436 : aerm->wholeAttNo = ExecFindJunkAttributeInTlist(targetlist,
2446 : resname);
2447 436 : if (!AttributeNumberIsValid(aerm->wholeAttNo))
2448 0 : elog(ERROR, "could not find junk %s column", resname);
2449 : }
2450 :
2451 : /* if child rel, need tableoid */
2452 9450 : if (erm->rti != erm->prti)
2453 : {
2454 1540 : snprintf(resname, sizeof(resname), "tableoid%u", erm->rowmarkId);
2455 1540 : aerm->toidAttNo = ExecFindJunkAttributeInTlist(targetlist,
2456 : resname);
2457 1540 : if (!AttributeNumberIsValid(aerm->toidAttNo))
2458 0 : elog(ERROR, "could not find junk %s column", resname);
2459 : }
2460 :
2461 9450 : return aerm;
2462 : }
2463 :
2464 :
2465 : /*
2466 : * EvalPlanQual logic --- recheck modified tuple(s) to see if we want to
2467 : * process the updated version under READ COMMITTED rules.
2468 : *
2469 : * See backend/executor/README for some info about how this works.
2470 : */
2471 :
2472 :
2473 : /*
2474 : * Check the updated version of a tuple to see if we want to process it under
2475 : * READ COMMITTED rules.
2476 : *
2477 : * epqstate - state for EvalPlanQual rechecking
2478 : * relation - table containing tuple
2479 : * rti - rangetable index of table containing tuple
2480 : * inputslot - tuple for processing - this can be the slot from
2481 : * EvalPlanQualSlot() for this rel, for increased efficiency.
2482 : *
2483 : * This tests whether the tuple in inputslot still matches the relevant
2484 : * quals. For that result to be useful, typically the input tuple has to be
2485 : * last row version (otherwise the result isn't particularly useful) and
2486 : * locked (otherwise the result might be out of date). That's typically
2487 : * achieved by using table_tuple_lock() with the
2488 : * TUPLE_LOCK_FLAG_FIND_LAST_VERSION flag.
2489 : *
2490 : * Returns a slot containing the new candidate update/delete tuple, or
2491 : * NULL if we determine we shouldn't process the row.
2492 : */
2493 : TupleTableSlot *
2494 254 : EvalPlanQual(EPQState *epqstate, Relation relation,
2495 : Index rti, TupleTableSlot *inputslot)
2496 : {
2497 : TupleTableSlot *slot;
2498 : TupleTableSlot *testslot;
2499 :
2500 : Assert(rti > 0);
2501 :
2502 : /*
2503 : * Need to run a recheck subquery. Initialize or reinitialize EPQ state.
2504 : */
2505 254 : EvalPlanQualBegin(epqstate);
2506 :
2507 : /*
2508 : * Callers will often use the EvalPlanQualSlot to store the tuple to avoid
2509 : * an unnecessary copy.
2510 : */
2511 254 : testslot = EvalPlanQualSlot(epqstate, relation, rti);
2512 254 : if (testslot != inputslot)
2513 12 : ExecCopySlot(testslot, inputslot);
2514 :
2515 : /*
2516 : * Mark that an EPQ tuple is available for this relation. (If there is
2517 : * more than one result relation, the others remain marked as having no
2518 : * tuple available.)
2519 : */
2520 254 : epqstate->relsubs_done[rti - 1] = false;
2521 254 : epqstate->relsubs_blocked[rti - 1] = false;
2522 :
2523 : /*
2524 : * Run the EPQ query. We assume it will return at most one tuple.
2525 : */
2526 254 : slot = EvalPlanQualNext(epqstate);
2527 :
2528 : /*
2529 : * If we got a tuple, force the slot to materialize the tuple so that it
2530 : * is not dependent on any local state in the EPQ query (in particular,
2531 : * it's highly likely that the slot contains references to any pass-by-ref
2532 : * datums that may be present in copyTuple). As with the next step, this
2533 : * is to guard against early re-use of the EPQ query.
2534 : */
2535 254 : if (!TupIsNull(slot))
2536 188 : ExecMaterializeSlot(slot);
2537 :
2538 : /*
2539 : * Clear out the test tuple, and mark that no tuple is available here.
2540 : * This is needed in case the EPQ state is re-used to test a tuple for a
2541 : * different target relation.
2542 : */
2543 254 : ExecClearTuple(testslot);
2544 254 : epqstate->relsubs_blocked[rti - 1] = true;
2545 :
2546 254 : return slot;
2547 : }
2548 :
2549 : /*
2550 : * EvalPlanQualInit -- initialize during creation of a plan state node
2551 : * that might need to invoke EPQ processing.
2552 : *
2553 : * If the caller intends to use EvalPlanQual(), resultRelations should be
2554 : * a list of RT indexes of potential target relations for EvalPlanQual(),
2555 : * and we will arrange that the other listed relations don't return any
2556 : * tuple during an EvalPlanQual() call. Otherwise resultRelations
2557 : * should be NIL.
2558 : *
2559 : * Note: subplan/auxrowmarks can be NULL/NIL if they will be set later
2560 : * with EvalPlanQualSetPlan.
2561 : */
2562 : void
2563 254464 : EvalPlanQualInit(EPQState *epqstate, EState *parentestate,
2564 : Plan *subplan, List *auxrowmarks,
2565 : int epqParam, List *resultRelations)
2566 : {
2567 254464 : Index rtsize = parentestate->es_range_table_size;
2568 :
2569 : /* initialize data not changing over EPQState's lifetime */
2570 254464 : epqstate->parentestate = parentestate;
2571 254464 : epqstate->epqParam = epqParam;
2572 254464 : epqstate->resultRelations = resultRelations;
2573 :
2574 : /*
2575 : * Allocate space to reference a slot for each potential rti - do so now
2576 : * rather than in EvalPlanQualBegin(), as done for other dynamically
2577 : * allocated resources, so EvalPlanQualSlot() can be used to hold tuples
2578 : * that *may* need EPQ later, without forcing the overhead of
2579 : * EvalPlanQualBegin().
2580 : */
2581 254464 : epqstate->tuple_table = NIL;
2582 254464 : epqstate->relsubs_slot = (TupleTableSlot **)
2583 254464 : palloc0(rtsize * sizeof(TupleTableSlot *));
2584 :
2585 : /* ... and remember data that EvalPlanQualBegin will need */
2586 254464 : epqstate->plan = subplan;
2587 254464 : epqstate->arowMarks = auxrowmarks;
2588 :
2589 : /* ... and mark the EPQ state inactive */
2590 254464 : epqstate->origslot = NULL;
2591 254464 : epqstate->recheckestate = NULL;
2592 254464 : epqstate->recheckplanstate = NULL;
2593 254464 : epqstate->relsubs_rowmark = NULL;
2594 254464 : epqstate->relsubs_done = NULL;
2595 254464 : epqstate->relsubs_blocked = NULL;
2596 254464 : }
2597 :
2598 : /*
2599 : * EvalPlanQualSetPlan -- set or change subplan of an EPQState.
2600 : *
2601 : * We used to need this so that ModifyTable could deal with multiple subplans.
2602 : * It could now be refactored out of existence.
2603 : */
2604 : void
2605 102734 : EvalPlanQualSetPlan(EPQState *epqstate, Plan *subplan, List *auxrowmarks)
2606 : {
2607 : /* If we have a live EPQ query, shut it down */
2608 102734 : EvalPlanQualEnd(epqstate);
2609 : /* And set/change the plan pointer */
2610 102734 : epqstate->plan = subplan;
2611 : /* The rowmarks depend on the plan, too */
2612 102734 : epqstate->arowMarks = auxrowmarks;
2613 102734 : }
2614 :
2615 : /*
2616 : * Return, and create if necessary, a slot for an EPQ test tuple.
2617 : *
2618 : * Note this only requires EvalPlanQualInit() to have been called,
2619 : * EvalPlanQualBegin() is not necessary.
2620 : */
2621 : TupleTableSlot *
2622 12454 : EvalPlanQualSlot(EPQState *epqstate,
2623 : Relation relation, Index rti)
2624 : {
2625 : TupleTableSlot **slot;
2626 :
2627 : Assert(relation);
2628 : Assert(rti > 0 && rti <= epqstate->parentestate->es_range_table_size);
2629 12454 : slot = &epqstate->relsubs_slot[rti - 1];
2630 :
2631 12454 : if (*slot == NULL)
2632 : {
2633 : MemoryContext oldcontext;
2634 :
2635 5306 : oldcontext = MemoryContextSwitchTo(epqstate->parentestate->es_query_cxt);
2636 5306 : *slot = table_slot_create(relation, &epqstate->tuple_table);
2637 5306 : MemoryContextSwitchTo(oldcontext);
2638 : }
2639 :
2640 12454 : return *slot;
2641 : }
2642 :
2643 : /*
2644 : * Fetch the current row value for a non-locked relation, identified by rti,
2645 : * that needs to be scanned by an EvalPlanQual operation. origslot must have
2646 : * been set to contain the current result row (top-level row) that we need to
2647 : * recheck. Returns true if a substitution tuple was found, false if not.
2648 : */
2649 : bool
2650 32 : EvalPlanQualFetchRowMark(EPQState *epqstate, Index rti, TupleTableSlot *slot)
2651 : {
2652 32 : ExecAuxRowMark *earm = epqstate->relsubs_rowmark[rti - 1];
2653 32 : ExecRowMark *erm = earm->rowmark;
2654 : Datum datum;
2655 : bool isNull;
2656 :
2657 : Assert(earm != NULL);
2658 : Assert(epqstate->origslot != NULL);
2659 :
2660 32 : if (RowMarkRequiresRowShareLock(erm->markType))
2661 0 : elog(ERROR, "EvalPlanQual doesn't support locking rowmarks");
2662 :
2663 : /* if child rel, must check whether it produced this row */
2664 32 : if (erm->rti != erm->prti)
2665 : {
2666 : Oid tableoid;
2667 :
2668 0 : datum = ExecGetJunkAttribute(epqstate->origslot,
2669 0 : earm->toidAttNo,
2670 : &isNull);
2671 : /* non-locked rels could be on the inside of outer joins */
2672 0 : if (isNull)
2673 0 : return false;
2674 :
2675 0 : tableoid = DatumGetObjectId(datum);
2676 :
2677 : Assert(OidIsValid(erm->relid));
2678 0 : if (tableoid != erm->relid)
2679 : {
2680 : /* this child is inactive right now */
2681 0 : return false;
2682 : }
2683 : }
2684 :
2685 32 : if (erm->markType == ROW_MARK_REFERENCE)
2686 : {
2687 : Assert(erm->relation != NULL);
2688 :
2689 : /* fetch the tuple's ctid */
2690 26 : datum = ExecGetJunkAttribute(epqstate->origslot,
2691 26 : earm->ctidAttNo,
2692 : &isNull);
2693 : /* non-locked rels could be on the inside of outer joins */
2694 26 : if (isNull)
2695 0 : return false;
2696 :
2697 : /* fetch requests on foreign tables must be passed to their FDW */
2698 26 : if (erm->relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
2699 : {
2700 : FdwRoutine *fdwroutine;
2701 0 : bool updated = false;
2702 :
2703 0 : fdwroutine = GetFdwRoutineForRelation(erm->relation, false);
2704 : /* this should have been checked already, but let's be safe */
2705 0 : if (fdwroutine->RefetchForeignRow == NULL)
2706 0 : ereport(ERROR,
2707 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2708 : errmsg("cannot lock rows in foreign table \"%s\"",
2709 : RelationGetRelationName(erm->relation))));
2710 :
2711 0 : fdwroutine->RefetchForeignRow(epqstate->recheckestate,
2712 : erm,
2713 : datum,
2714 : slot,
2715 : &updated);
2716 0 : if (TupIsNull(slot))
2717 0 : elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
2718 :
2719 : /*
2720 : * Ideally we'd insist on updated == false here, but that assumes
2721 : * that FDWs can track that exactly, which they might not be able
2722 : * to. So just ignore the flag.
2723 : */
2724 0 : return true;
2725 : }
2726 : else
2727 : {
2728 : /* ordinary table, fetch the tuple */
2729 26 : if (!table_tuple_fetch_row_version(erm->relation,
2730 26 : (ItemPointer) DatumGetPointer(datum),
2731 : SnapshotAny, slot))
2732 0 : elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
2733 26 : return true;
2734 : }
2735 : }
2736 : else
2737 : {
2738 : Assert(erm->markType == ROW_MARK_COPY);
2739 :
2740 : /* fetch the whole-row Var for the relation */
2741 6 : datum = ExecGetJunkAttribute(epqstate->origslot,
2742 6 : earm->wholeAttNo,
2743 : &isNull);
2744 : /* non-locked rels could be on the inside of outer joins */
2745 6 : if (isNull)
2746 0 : return false;
2747 :
2748 6 : ExecStoreHeapTupleDatum(datum, slot);
2749 6 : return true;
2750 : }
2751 : }
2752 :
2753 : /*
2754 : * Fetch the next row (if any) from EvalPlanQual testing
2755 : *
2756 : * (In practice, there should never be more than one row...)
2757 : */
2758 : TupleTableSlot *
2759 308 : EvalPlanQualNext(EPQState *epqstate)
2760 : {
2761 : MemoryContext oldcontext;
2762 : TupleTableSlot *slot;
2763 :
2764 308 : oldcontext = MemoryContextSwitchTo(epqstate->recheckestate->es_query_cxt);
2765 308 : slot = ExecProcNode(epqstate->recheckplanstate);
2766 308 : MemoryContextSwitchTo(oldcontext);
2767 :
2768 308 : return slot;
2769 : }
2770 :
2771 : /*
2772 : * Initialize or reset an EvalPlanQual state tree
2773 : */
2774 : void
2775 362 : EvalPlanQualBegin(EPQState *epqstate)
2776 : {
2777 362 : EState *parentestate = epqstate->parentestate;
2778 362 : EState *recheckestate = epqstate->recheckestate;
2779 :
2780 362 : if (recheckestate == NULL)
2781 : {
2782 : /* First time through, so create a child EState */
2783 220 : EvalPlanQualStart(epqstate, epqstate->plan);
2784 : }
2785 : else
2786 : {
2787 : /*
2788 : * We already have a suitable child EPQ tree, so just reset it.
2789 : */
2790 142 : Index rtsize = parentestate->es_range_table_size;
2791 142 : PlanState *rcplanstate = epqstate->recheckplanstate;
2792 :
2793 : /*
2794 : * Reset the relsubs_done[] flags to equal relsubs_blocked[], so that
2795 : * the EPQ run will never attempt to fetch tuples from blocked target
2796 : * relations.
2797 : */
2798 142 : memcpy(epqstate->relsubs_done, epqstate->relsubs_blocked,
2799 : rtsize * sizeof(bool));
2800 :
2801 : /* Recopy current values of parent parameters */
2802 142 : if (parentestate->es_plannedstmt->paramExecTypes != NIL)
2803 : {
2804 : int i;
2805 :
2806 : /*
2807 : * Force evaluation of any InitPlan outputs that could be needed
2808 : * by the subplan, just in case they got reset since
2809 : * EvalPlanQualStart (see comments therein).
2810 : */
2811 142 : ExecSetParamPlanMulti(rcplanstate->plan->extParam,
2812 142 : GetPerTupleExprContext(parentestate));
2813 :
2814 142 : i = list_length(parentestate->es_plannedstmt->paramExecTypes);
2815 :
2816 302 : while (--i >= 0)
2817 : {
2818 : /* copy value if any, but not execPlan link */
2819 160 : recheckestate->es_param_exec_vals[i].value =
2820 160 : parentestate->es_param_exec_vals[i].value;
2821 160 : recheckestate->es_param_exec_vals[i].isnull =
2822 160 : parentestate->es_param_exec_vals[i].isnull;
2823 : }
2824 : }
2825 :
2826 : /*
2827 : * Mark child plan tree as needing rescan at all scan nodes. The
2828 : * first ExecProcNode will take care of actually doing the rescan.
2829 : */
2830 142 : rcplanstate->chgParam = bms_add_member(rcplanstate->chgParam,
2831 : epqstate->epqParam);
2832 : }
2833 362 : }
2834 :
2835 : /*
2836 : * Start execution of an EvalPlanQual plan tree.
2837 : *
2838 : * This is a cut-down version of ExecutorStart(): we copy some state from
2839 : * the top-level estate rather than initializing it fresh.
2840 : */
2841 : static void
2842 220 : EvalPlanQualStart(EPQState *epqstate, Plan *planTree)
2843 : {
2844 220 : EState *parentestate = epqstate->parentestate;
2845 220 : Index rtsize = parentestate->es_range_table_size;
2846 : EState *rcestate;
2847 : MemoryContext oldcontext;
2848 : ListCell *l;
2849 :
2850 220 : epqstate->recheckestate = rcestate = CreateExecutorState();
2851 :
2852 220 : oldcontext = MemoryContextSwitchTo(rcestate->es_query_cxt);
2853 :
2854 : /* signal that this is an EState for executing EPQ */
2855 220 : rcestate->es_epq_active = epqstate;
2856 :
2857 : /*
2858 : * Child EPQ EStates share the parent's copy of unchanging state such as
2859 : * the snapshot, rangetable, and external Param info. They need their own
2860 : * copies of local state, including a tuple table, es_param_exec_vals,
2861 : * result-rel info, etc.
2862 : */
2863 220 : rcestate->es_direction = ForwardScanDirection;
2864 220 : rcestate->es_snapshot = parentestate->es_snapshot;
2865 220 : rcestate->es_crosscheck_snapshot = parentestate->es_crosscheck_snapshot;
2866 220 : rcestate->es_range_table = parentestate->es_range_table;
2867 220 : rcestate->es_range_table_size = parentestate->es_range_table_size;
2868 220 : rcestate->es_relations = parentestate->es_relations;
2869 220 : rcestate->es_rowmarks = parentestate->es_rowmarks;
2870 220 : rcestate->es_rteperminfos = parentestate->es_rteperminfos;
2871 220 : rcestate->es_plannedstmt = parentestate->es_plannedstmt;
2872 220 : rcestate->es_junkFilter = parentestate->es_junkFilter;
2873 220 : rcestate->es_output_cid = parentestate->es_output_cid;
2874 220 : rcestate->es_queryEnv = parentestate->es_queryEnv;
2875 :
2876 : /*
2877 : * ResultRelInfos needed by subplans are initialized from scratch when the
2878 : * subplans themselves are initialized.
2879 : */
2880 220 : rcestate->es_result_relations = NULL;
2881 : /* es_trig_target_relations must NOT be copied */
2882 220 : rcestate->es_top_eflags = parentestate->es_top_eflags;
2883 220 : rcestate->es_instrument = parentestate->es_instrument;
2884 : /* es_auxmodifytables must NOT be copied */
2885 :
2886 : /*
2887 : * The external param list is simply shared from parent. The internal
2888 : * param workspace has to be local state, but we copy the initial values
2889 : * from the parent, so as to have access to any param values that were
2890 : * already set from other parts of the parent's plan tree.
2891 : */
2892 220 : rcestate->es_param_list_info = parentestate->es_param_list_info;
2893 220 : if (parentestate->es_plannedstmt->paramExecTypes != NIL)
2894 : {
2895 : int i;
2896 :
2897 : /*
2898 : * Force evaluation of any InitPlan outputs that could be needed by
2899 : * the subplan. (With more complexity, maybe we could postpone this
2900 : * till the subplan actually demands them, but it doesn't seem worth
2901 : * the trouble; this is a corner case already, since usually the
2902 : * InitPlans would have been evaluated before reaching EvalPlanQual.)
2903 : *
2904 : * This will not touch output params of InitPlans that occur somewhere
2905 : * within the subplan tree, only those that are attached to the
2906 : * ModifyTable node or above it and are referenced within the subplan.
2907 : * That's OK though, because the planner would only attach such
2908 : * InitPlans to a lower-level SubqueryScan node, and EPQ execution
2909 : * will not descend into a SubqueryScan.
2910 : *
2911 : * The EState's per-output-tuple econtext is sufficiently short-lived
2912 : * for this, since it should get reset before there is any chance of
2913 : * doing EvalPlanQual again.
2914 : */
2915 220 : ExecSetParamPlanMulti(planTree->extParam,
2916 220 : GetPerTupleExprContext(parentestate));
2917 :
2918 : /* now make the internal param workspace ... */
2919 220 : i = list_length(parentestate->es_plannedstmt->paramExecTypes);
2920 220 : rcestate->es_param_exec_vals = (ParamExecData *)
2921 220 : palloc0(i * sizeof(ParamExecData));
2922 : /* ... and copy down all values, whether really needed or not */
2923 538 : while (--i >= 0)
2924 : {
2925 : /* copy value if any, but not execPlan link */
2926 318 : rcestate->es_param_exec_vals[i].value =
2927 318 : parentestate->es_param_exec_vals[i].value;
2928 318 : rcestate->es_param_exec_vals[i].isnull =
2929 318 : parentestate->es_param_exec_vals[i].isnull;
2930 : }
2931 : }
2932 :
2933 : /*
2934 : * Initialize private state information for each SubPlan. We must do this
2935 : * before running ExecInitNode on the main query tree, since
2936 : * ExecInitSubPlan expects to be able to find these entries. Some of the
2937 : * SubPlans might not be used in the part of the plan tree we intend to
2938 : * run, but since it's not easy to tell which, we just initialize them
2939 : * all.
2940 : */
2941 : Assert(rcestate->es_subplanstates == NIL);
2942 276 : foreach(l, parentestate->es_plannedstmt->subplans)
2943 : {
2944 56 : Plan *subplan = (Plan *) lfirst(l);
2945 : PlanState *subplanstate;
2946 :
2947 56 : subplanstate = ExecInitNode(subplan, rcestate, 0);
2948 56 : rcestate->es_subplanstates = lappend(rcestate->es_subplanstates,
2949 : subplanstate);
2950 : }
2951 :
2952 : /*
2953 : * Build an RTI indexed array of rowmarks, so that
2954 : * EvalPlanQualFetchRowMark() can efficiently access the to be fetched
2955 : * rowmark.
2956 : */
2957 220 : epqstate->relsubs_rowmark = (ExecAuxRowMark **)
2958 220 : palloc0(rtsize * sizeof(ExecAuxRowMark *));
2959 242 : foreach(l, epqstate->arowMarks)
2960 : {
2961 22 : ExecAuxRowMark *earm = (ExecAuxRowMark *) lfirst(l);
2962 :
2963 22 : epqstate->relsubs_rowmark[earm->rowmark->rti - 1] = earm;
2964 : }
2965 :
2966 : /*
2967 : * Initialize per-relation EPQ tuple states. Result relations, if any,
2968 : * get marked as blocked; others as not-fetched.
2969 : */
2970 220 : epqstate->relsubs_done = palloc_array(bool, rtsize);
2971 220 : epqstate->relsubs_blocked = palloc0_array(bool, rtsize);
2972 :
2973 430 : foreach(l, epqstate->resultRelations)
2974 : {
2975 210 : int rtindex = lfirst_int(l);
2976 :
2977 : Assert(rtindex > 0 && rtindex <= rtsize);
2978 210 : epqstate->relsubs_blocked[rtindex - 1] = true;
2979 : }
2980 :
2981 220 : memcpy(epqstate->relsubs_done, epqstate->relsubs_blocked,
2982 : rtsize * sizeof(bool));
2983 :
2984 : /*
2985 : * Initialize the private state information for all the nodes in the part
2986 : * of the plan tree we need to run. This opens files, allocates storage
2987 : * and leaves us ready to start processing tuples.
2988 : */
2989 220 : epqstate->recheckplanstate = ExecInitNode(planTree, rcestate, 0);
2990 :
2991 220 : MemoryContextSwitchTo(oldcontext);
2992 220 : }
2993 :
2994 : /*
2995 : * EvalPlanQualEnd -- shut down at termination of parent plan state node,
2996 : * or if we are done with the current EPQ child.
2997 : *
2998 : * This is a cut-down version of ExecutorEnd(); basically we want to do most
2999 : * of the normal cleanup, but *not* close result relations (which we are
3000 : * just sharing from the outer query). We do, however, have to close any
3001 : * result and trigger target relations that got opened, since those are not
3002 : * shared. (There probably shouldn't be any of the latter, but just in
3003 : * case...)
3004 : */
3005 : void
3006 355600 : EvalPlanQualEnd(EPQState *epqstate)
3007 : {
3008 355600 : EState *estate = epqstate->recheckestate;
3009 : Index rtsize;
3010 : MemoryContext oldcontext;
3011 : ListCell *l;
3012 :
3013 355600 : rtsize = epqstate->parentestate->es_range_table_size;
3014 :
3015 : /*
3016 : * We may have a tuple table, even if EPQ wasn't started, because we allow
3017 : * use of EvalPlanQualSlot() without calling EvalPlanQualBegin().
3018 : */
3019 355600 : if (epqstate->tuple_table != NIL)
3020 : {
3021 5124 : memset(epqstate->relsubs_slot, 0,
3022 : rtsize * sizeof(TupleTableSlot *));
3023 5124 : ExecResetTupleTable(epqstate->tuple_table, true);
3024 5124 : epqstate->tuple_table = NIL;
3025 : }
3026 :
3027 : /* EPQ wasn't started, nothing further to do */
3028 355600 : if (estate == NULL)
3029 355390 : return;
3030 :
3031 210 : oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
3032 :
3033 210 : ExecEndNode(epqstate->recheckplanstate);
3034 :
3035 260 : foreach(l, estate->es_subplanstates)
3036 : {
3037 50 : PlanState *subplanstate = (PlanState *) lfirst(l);
3038 :
3039 50 : ExecEndNode(subplanstate);
3040 : }
3041 :
3042 : /* throw away the per-estate tuple table, some node may have used it */
3043 210 : ExecResetTupleTable(estate->es_tupleTable, false);
3044 :
3045 : /* Close any result and trigger target relations attached to this EState */
3046 210 : ExecCloseResultRelations(estate);
3047 :
3048 210 : MemoryContextSwitchTo(oldcontext);
3049 :
3050 210 : FreeExecutorState(estate);
3051 :
3052 : /* Mark EPQState idle */
3053 210 : epqstate->origslot = NULL;
3054 210 : epqstate->recheckestate = NULL;
3055 210 : epqstate->recheckplanstate = NULL;
3056 210 : epqstate->relsubs_rowmark = NULL;
3057 210 : epqstate->relsubs_done = NULL;
3058 210 : epqstate->relsubs_blocked = NULL;
3059 : }
|
