Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * pquery.c
4 : * POSTGRES process query command code
5 : *
6 : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : *
10 : * IDENTIFICATION
11 : * src/backend/tcop/pquery.c
12 : *
13 : *-------------------------------------------------------------------------
14 : */
15 :
16 : #include "postgres.h"
17 :
18 : #include <limits.h>
19 :
20 : #include "access/xact.h"
21 : #include "commands/prepare.h"
22 : #include "executor/executor.h"
23 : #include "executor/tstoreReceiver.h"
24 : #include "miscadmin.h"
25 : #include "pg_trace.h"
26 : #include "tcop/pquery.h"
27 : #include "tcop/utility.h"
28 : #include "utils/memutils.h"
29 : #include "utils/snapmgr.h"
30 :
31 :
32 : /*
33 : * ActivePortal is the currently executing Portal (the most closely nested,
34 : * if there are several).
35 : */
36 : Portal ActivePortal = NULL;
37 :
38 :
39 : static void ProcessQuery(PlannedStmt *plan,
40 : const char *sourceText,
41 : ParamListInfo params,
42 : QueryEnvironment *queryEnv,
43 : DestReceiver *dest,
44 : QueryCompletion *qc);
45 : static void FillPortalStore(Portal portal, bool isTopLevel);
46 : static uint64 RunFromStore(Portal portal, ScanDirection direction, uint64 count,
47 : DestReceiver *dest);
48 : static uint64 PortalRunSelect(Portal portal, bool forward, long count,
49 : DestReceiver *dest);
50 : static void PortalRunUtility(Portal portal, PlannedStmt *pstmt,
51 : bool isTopLevel, bool setHoldSnapshot,
52 : DestReceiver *dest, QueryCompletion *qc);
53 : static void PortalRunMulti(Portal portal,
54 : bool isTopLevel, bool setHoldSnapshot,
55 : DestReceiver *dest, DestReceiver *altdest,
56 : QueryCompletion *qc);
57 : static uint64 DoPortalRunFetch(Portal portal,
58 : FetchDirection fdirection,
59 : long count,
60 : DestReceiver *dest);
61 : static void DoPortalRewind(Portal portal);
62 :
63 :
64 : /*
65 : * CreateQueryDesc
66 : */
67 : QueryDesc *
68 587030 : CreateQueryDesc(PlannedStmt *plannedstmt,
69 : const char *sourceText,
70 : Snapshot snapshot,
71 : Snapshot crosscheck_snapshot,
72 : DestReceiver *dest,
73 : ParamListInfo params,
74 : QueryEnvironment *queryEnv,
75 : int instrument_options)
76 : {
77 587030 : QueryDesc *qd = (QueryDesc *) palloc(sizeof(QueryDesc));
78 :
79 587030 : qd->operation = plannedstmt->commandType; /* operation */
80 587030 : qd->plannedstmt = plannedstmt; /* plan */
81 587030 : qd->sourceText = sourceText; /* query text */
82 587030 : qd->snapshot = RegisterSnapshot(snapshot); /* snapshot */
83 : /* RI check snapshot */
84 587030 : qd->crosscheck_snapshot = RegisterSnapshot(crosscheck_snapshot);
85 587030 : qd->dest = dest; /* output dest */
86 587030 : qd->params = params; /* parameter values passed into query */
87 587030 : qd->queryEnv = queryEnv;
88 587030 : qd->instrument_options = instrument_options; /* instrumentation wanted? */
89 :
90 : /* null these fields until set by ExecutorStart */
91 587030 : qd->tupDesc = NULL;
92 587030 : qd->estate = NULL;
93 587030 : qd->planstate = NULL;
94 587030 : qd->totaltime = NULL;
95 :
96 : /* not yet executed */
97 587030 : qd->already_executed = false;
98 :
99 587030 : return qd;
100 : }
101 :
102 : /*
103 : * FreeQueryDesc
104 : */
105 : void
106 558194 : FreeQueryDesc(QueryDesc *qdesc)
107 : {
108 : /* Can't be a live query */
109 : Assert(qdesc->estate == NULL);
110 :
111 : /* forget our snapshots */
112 558194 : UnregisterSnapshot(qdesc->snapshot);
113 558194 : UnregisterSnapshot(qdesc->crosscheck_snapshot);
114 :
115 : /* Only the QueryDesc itself need be freed */
116 558194 : pfree(qdesc);
117 558194 : }
118 :
119 :
120 : /*
121 : * ProcessQuery
122 : * Execute a single plannable query within a PORTAL_MULTI_QUERY,
123 : * PORTAL_ONE_RETURNING, or PORTAL_ONE_MOD_WITH portal
124 : *
125 : * plan: the plan tree for the query
126 : * sourceText: the source text of the query
127 : * params: any parameters needed
128 : * dest: where to send results
129 : * qc: where to store the command completion status data.
130 : *
131 : * qc may be NULL if caller doesn't want a status string.
132 : *
133 : * Must be called in a memory context that will be reset or deleted on
134 : * error; otherwise the executor's memory usage will be leaked.
135 : */
136 : static void
137 87888 : ProcessQuery(PlannedStmt *plan,
138 : const char *sourceText,
139 : ParamListInfo params,
140 : QueryEnvironment *queryEnv,
141 : DestReceiver *dest,
142 : QueryCompletion *qc)
143 : {
144 : QueryDesc *queryDesc;
145 :
146 : /*
147 : * Create the QueryDesc object
148 : */
149 87888 : queryDesc = CreateQueryDesc(plan, sourceText,
150 : GetActiveSnapshot(), InvalidSnapshot,
151 : dest, params, queryEnv, 0);
152 :
153 : /*
154 : * Call ExecutorStart to prepare the plan for execution
155 : */
156 87888 : ExecutorStart(queryDesc, 0);
157 :
158 : /*
159 : * Run the plan to completion.
160 : */
161 86610 : ExecutorRun(queryDesc, ForwardScanDirection, 0);
162 :
163 : /*
164 : * Build command completion status data, if caller wants one.
165 : */
166 83418 : if (qc)
167 : {
168 82794 : switch (queryDesc->operation)
169 : {
170 116 : case CMD_SELECT:
171 116 : SetQueryCompletion(qc, CMDTAG_SELECT, queryDesc->estate->es_processed);
172 116 : break;
173 67170 : case CMD_INSERT:
174 67170 : SetQueryCompletion(qc, CMDTAG_INSERT, queryDesc->estate->es_processed);
175 67170 : break;
176 10976 : case CMD_UPDATE:
177 10976 : SetQueryCompletion(qc, CMDTAG_UPDATE, queryDesc->estate->es_processed);
178 10976 : break;
179 3464 : case CMD_DELETE:
180 3464 : SetQueryCompletion(qc, CMDTAG_DELETE, queryDesc->estate->es_processed);
181 3464 : break;
182 1068 : case CMD_MERGE:
183 1068 : SetQueryCompletion(qc, CMDTAG_MERGE, queryDesc->estate->es_processed);
184 1068 : break;
185 0 : default:
186 0 : SetQueryCompletion(qc, CMDTAG_UNKNOWN, queryDesc->estate->es_processed);
187 0 : break;
188 : }
189 : }
190 :
191 : /*
192 : * Now, we close down all the scans and free allocated resources.
193 : */
194 83418 : ExecutorFinish(queryDesc);
195 82340 : ExecutorEnd(queryDesc);
196 :
197 82340 : FreeQueryDesc(queryDesc);
198 82340 : }
199 :
200 : /*
201 : * ChoosePortalStrategy
202 : * Select portal execution strategy given the intended statement list.
203 : *
204 : * The list elements can be Querys or PlannedStmts.
205 : * That's more general than portals need, but plancache.c uses this too.
206 : *
207 : * See the comments in portal.h.
208 : */
209 : PortalStrategy
210 848364 : ChoosePortalStrategy(List *stmts)
211 : {
212 : int nSetTag;
213 : ListCell *lc;
214 :
215 : /*
216 : * PORTAL_ONE_SELECT and PORTAL_UTIL_SELECT need only consider the
217 : * single-statement case, since there are no rewrite rules that can add
218 : * auxiliary queries to a SELECT or a utility command. PORTAL_ONE_MOD_WITH
219 : * likewise allows only one top-level statement.
220 : */
221 848364 : if (list_length(stmts) == 1)
222 : {
223 848028 : Node *stmt = (Node *) linitial(stmts);
224 :
225 848028 : if (IsA(stmt, Query))
226 : {
227 83770 : Query *query = (Query *) stmt;
228 :
229 83770 : if (query->canSetTag)
230 : {
231 83770 : if (query->commandType == CMD_SELECT)
232 : {
233 55620 : if (query->hasModifyingCTE)
234 0 : return PORTAL_ONE_MOD_WITH;
235 : else
236 55620 : return PORTAL_ONE_SELECT;
237 : }
238 28150 : if (query->commandType == CMD_UTILITY)
239 : {
240 20034 : if (UtilityReturnsTuples(query->utilityStmt))
241 10050 : return PORTAL_UTIL_SELECT;
242 : /* it can't be ONE_RETURNING, so give up */
243 9984 : return PORTAL_MULTI_QUERY;
244 : }
245 : }
246 : }
247 764258 : else if (IsA(stmt, PlannedStmt))
248 : {
249 764258 : PlannedStmt *pstmt = (PlannedStmt *) stmt;
250 :
251 764258 : if (pstmt->canSetTag)
252 : {
253 764222 : if (pstmt->commandType == CMD_SELECT)
254 : {
255 298066 : if (pstmt->hasModifyingCTE)
256 128 : return PORTAL_ONE_MOD_WITH;
257 : else
258 297938 : return PORTAL_ONE_SELECT;
259 : }
260 466156 : if (pstmt->commandType == CMD_UTILITY)
261 : {
262 379344 : if (UtilityReturnsTuples(pstmt->utilityStmt))
263 49780 : return PORTAL_UTIL_SELECT;
264 : /* it can't be ONE_RETURNING, so give up */
265 329564 : return PORTAL_MULTI_QUERY;
266 : }
267 : }
268 : }
269 : else
270 0 : elog(ERROR, "unrecognized node type: %d", (int) nodeTag(stmt));
271 : }
272 :
273 : /*
274 : * PORTAL_ONE_RETURNING has to allow auxiliary queries added by rewrite.
275 : * Choose PORTAL_ONE_RETURNING if there is exactly one canSetTag query and
276 : * it has a RETURNING list.
277 : */
278 95300 : nSetTag = 0;
279 99254 : foreach(lc, stmts)
280 : {
281 95468 : Node *stmt = (Node *) lfirst(lc);
282 :
283 95468 : if (IsA(stmt, Query))
284 : {
285 8128 : Query *query = (Query *) stmt;
286 :
287 8128 : if (query->canSetTag)
288 : {
289 8122 : if (++nSetTag > 1)
290 91514 : return PORTAL_MULTI_QUERY; /* no need to look further */
291 8122 : if (query->commandType == CMD_UTILITY ||
292 8122 : query->returningList == NIL)
293 7820 : return PORTAL_MULTI_QUERY; /* no need to look further */
294 : }
295 : }
296 87340 : else if (IsA(stmt, PlannedStmt))
297 : {
298 87340 : PlannedStmt *pstmt = (PlannedStmt *) stmt;
299 :
300 87340 : if (pstmt->canSetTag)
301 : {
302 87130 : if (++nSetTag > 1)
303 0 : return PORTAL_MULTI_QUERY; /* no need to look further */
304 87130 : if (pstmt->commandType == CMD_UTILITY ||
305 87130 : !pstmt->hasReturning)
306 83694 : return PORTAL_MULTI_QUERY; /* no need to look further */
307 : }
308 : }
309 : else
310 0 : elog(ERROR, "unrecognized node type: %d", (int) nodeTag(stmt));
311 : }
312 3786 : if (nSetTag == 1)
313 3738 : return PORTAL_ONE_RETURNING;
314 :
315 : /* Else, it's the general case... */
316 48 : return PORTAL_MULTI_QUERY;
317 : }
318 :
319 : /*
320 : * FetchPortalTargetList
321 : * Given a portal that returns tuples, extract the query targetlist.
322 : * Returns NIL if the portal doesn't have a determinable targetlist.
323 : *
324 : * Note: do not modify the result.
325 : */
326 : List *
327 319604 : FetchPortalTargetList(Portal portal)
328 : {
329 : /* no point in looking if we determined it doesn't return tuples */
330 319604 : if (portal->strategy == PORTAL_MULTI_QUERY)
331 30 : return NIL;
332 : /* get the primary statement and find out what it returns */
333 319574 : return FetchStatementTargetList((Node *) PortalGetPrimaryStmt(portal));
334 : }
335 :
336 : /*
337 : * FetchStatementTargetList
338 : * Given a statement that returns tuples, extract the query targetlist.
339 : * Returns NIL if the statement doesn't have a determinable targetlist.
340 : *
341 : * This can be applied to a Query or a PlannedStmt.
342 : * That's more general than portals need, but plancache.c uses this too.
343 : *
344 : * Note: do not modify the result.
345 : *
346 : * XXX be careful to keep this in sync with UtilityReturnsTuples.
347 : */
348 : List *
349 339052 : FetchStatementTargetList(Node *stmt)
350 : {
351 339052 : if (stmt == NULL)
352 0 : return NIL;
353 339052 : if (IsA(stmt, Query))
354 : {
355 19478 : Query *query = (Query *) stmt;
356 :
357 19478 : if (query->commandType == CMD_UTILITY)
358 : {
359 : /* transfer attention to utility statement */
360 12 : stmt = query->utilityStmt;
361 : }
362 : else
363 : {
364 19466 : if (query->commandType == CMD_SELECT)
365 19454 : return query->targetList;
366 12 : if (query->returningList)
367 12 : return query->returningList;
368 0 : return NIL;
369 : }
370 : }
371 319586 : if (IsA(stmt, PlannedStmt))
372 : {
373 319574 : PlannedStmt *pstmt = (PlannedStmt *) stmt;
374 :
375 319574 : if (pstmt->commandType == CMD_UTILITY)
376 : {
377 : /* transfer attention to utility statement */
378 41430 : stmt = pstmt->utilityStmt;
379 : }
380 : else
381 : {
382 278144 : if (pstmt->commandType == CMD_SELECT)
383 274858 : return pstmt->planTree->targetlist;
384 3286 : if (pstmt->hasReturning)
385 3286 : return pstmt->planTree->targetlist;
386 0 : return NIL;
387 : }
388 : }
389 41442 : if (IsA(stmt, FetchStmt))
390 : {
391 5644 : FetchStmt *fstmt = (FetchStmt *) stmt;
392 : Portal subportal;
393 :
394 : Assert(!fstmt->ismove);
395 5644 : subportal = GetPortalByName(fstmt->portalname);
396 : Assert(PortalIsValid(subportal));
397 5644 : return FetchPortalTargetList(subportal);
398 : }
399 35798 : if (IsA(stmt, ExecuteStmt))
400 : {
401 19350 : ExecuteStmt *estmt = (ExecuteStmt *) stmt;
402 : PreparedStatement *entry;
403 :
404 19350 : entry = FetchPreparedStatement(estmt->name, true);
405 19350 : return FetchPreparedStatementTargetList(entry);
406 : }
407 16448 : return NIL;
408 : }
409 :
410 : /*
411 : * PortalStart
412 : * Prepare a portal for execution.
413 : *
414 : * Caller must already have created the portal, done PortalDefineQuery(),
415 : * and adjusted portal options if needed.
416 : *
417 : * If parameters are needed by the query, they must be passed in "params"
418 : * (caller is responsible for giving them appropriate lifetime).
419 : *
420 : * The caller can also provide an initial set of "eflags" to be passed to
421 : * ExecutorStart (but note these can be modified internally, and they are
422 : * currently only honored for PORTAL_ONE_SELECT portals). Most callers
423 : * should simply pass zero.
424 : *
425 : * The caller can optionally pass a snapshot to be used; pass InvalidSnapshot
426 : * for the normal behavior of setting a new snapshot. This parameter is
427 : * presently ignored for non-PORTAL_ONE_SELECT portals (it's only intended
428 : * to be used for cursors).
429 : *
430 : * On return, portal is ready to accept PortalRun() calls, and the result
431 : * tupdesc (if any) is known.
432 : */
433 : void
434 764582 : PortalStart(Portal portal, ParamListInfo params,
435 : int eflags, Snapshot snapshot)
436 : {
437 : Portal saveActivePortal;
438 : ResourceOwner saveResourceOwner;
439 : MemoryContext savePortalContext;
440 : MemoryContext oldContext;
441 : QueryDesc *queryDesc;
442 : int myeflags;
443 :
444 : Assert(PortalIsValid(portal));
445 : Assert(portal->status == PORTAL_DEFINED);
446 :
447 : /*
448 : * Set up global portal context pointers.
449 : */
450 764582 : saveActivePortal = ActivePortal;
451 764582 : saveResourceOwner = CurrentResourceOwner;
452 764582 : savePortalContext = PortalContext;
453 764582 : PG_TRY();
454 : {
455 764582 : ActivePortal = portal;
456 764582 : if (portal->resowner)
457 764582 : CurrentResourceOwner = portal->resowner;
458 764582 : PortalContext = portal->portalContext;
459 :
460 764582 : oldContext = MemoryContextSwitchTo(PortalContext);
461 :
462 : /* Must remember portal param list, if any */
463 764582 : portal->portalParams = params;
464 :
465 : /*
466 : * Determine the portal execution strategy
467 : */
468 764582 : portal->strategy = ChoosePortalStrategy(portal->stmts);
469 :
470 : /*
471 : * Fire her up according to the strategy
472 : */
473 764582 : switch (portal->strategy)
474 : {
475 297938 : case PORTAL_ONE_SELECT:
476 :
477 : /* Must set snapshot before starting executor. */
478 297938 : if (snapshot)
479 27996 : PushActiveSnapshot(snapshot);
480 : else
481 269942 : PushActiveSnapshot(GetTransactionSnapshot());
482 :
483 : /*
484 : * We could remember the snapshot in portal->portalSnapshot,
485 : * but presently there seems no need to, as this code path
486 : * cannot be used for non-atomic execution. Hence there can't
487 : * be any commit/abort that might destroy the snapshot. Since
488 : * we don't do that, there's also no need to force a
489 : * non-default nesting level for the snapshot.
490 : */
491 :
492 : /*
493 : * Create QueryDesc in portal's context; for the moment, set
494 : * the destination to DestNone.
495 : */
496 297938 : queryDesc = CreateQueryDesc(linitial_node(PlannedStmt, portal->stmts),
497 : portal->sourceText,
498 : GetActiveSnapshot(),
499 : InvalidSnapshot,
500 : None_Receiver,
501 : params,
502 : portal->queryEnv,
503 : 0);
504 :
505 : /*
506 : * If it's a scrollable cursor, executor needs to support
507 : * REWIND and backwards scan, as well as whatever the caller
508 : * might've asked for.
509 : */
510 297938 : if (portal->cursorOptions & CURSOR_OPT_SCROLL)
511 3946 : myeflags = eflags | EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD;
512 : else
513 293992 : myeflags = eflags;
514 :
515 : /*
516 : * Call ExecutorStart to prepare the plan for execution
517 : */
518 297938 : ExecutorStart(queryDesc, myeflags);
519 :
520 : /*
521 : * This tells PortalCleanup to shut down the executor
522 : */
523 297284 : portal->queryDesc = queryDesc;
524 :
525 : /*
526 : * Remember tuple descriptor (computed by ExecutorStart)
527 : */
528 297284 : portal->tupDesc = queryDesc->tupDesc;
529 :
530 : /*
531 : * Reset cursor position data to "start of query"
532 : */
533 297284 : portal->atStart = true;
534 297284 : portal->atEnd = false; /* allow fetches */
535 297284 : portal->portalPos = 0;
536 :
537 297284 : PopActiveSnapshot();
538 297284 : break;
539 :
540 3564 : case PORTAL_ONE_RETURNING:
541 : case PORTAL_ONE_MOD_WITH:
542 :
543 : /*
544 : * We don't start the executor until we are told to run the
545 : * portal. We do need to set up the result tupdesc.
546 : */
547 : {
548 : PlannedStmt *pstmt;
549 :
550 3564 : pstmt = PortalGetPrimaryStmt(portal);
551 3564 : portal->tupDesc =
552 3564 : ExecCleanTypeFromTL(pstmt->planTree->targetlist);
553 : }
554 :
555 : /*
556 : * Reset cursor position data to "start of query"
557 : */
558 3564 : portal->atStart = true;
559 3564 : portal->atEnd = false; /* allow fetches */
560 3564 : portal->portalPos = 0;
561 3564 : break;
562 :
563 49780 : case PORTAL_UTIL_SELECT:
564 :
565 : /*
566 : * We don't set snapshot here, because PortalRunUtility will
567 : * take care of it if needed.
568 : */
569 : {
570 49780 : PlannedStmt *pstmt = PortalGetPrimaryStmt(portal);
571 :
572 : Assert(pstmt->commandType == CMD_UTILITY);
573 49780 : portal->tupDesc = UtilityTupleDescriptor(pstmt->utilityStmt);
574 : }
575 :
576 : /*
577 : * Reset cursor position data to "start of query"
578 : */
579 49752 : portal->atStart = true;
580 49752 : portal->atEnd = false; /* allow fetches */
581 49752 : portal->portalPos = 0;
582 49752 : break;
583 :
584 413300 : case PORTAL_MULTI_QUERY:
585 : /* Need do nothing now */
586 413300 : portal->tupDesc = NULL;
587 413300 : break;
588 : }
589 : }
590 682 : PG_CATCH();
591 : {
592 : /* Uncaught error while executing portal: mark it dead */
593 682 : MarkPortalFailed(portal);
594 :
595 : /* Restore global vars and propagate error */
596 682 : ActivePortal = saveActivePortal;
597 682 : CurrentResourceOwner = saveResourceOwner;
598 682 : PortalContext = savePortalContext;
599 :
600 682 : PG_RE_THROW();
601 : }
602 763900 : PG_END_TRY();
603 :
604 763900 : MemoryContextSwitchTo(oldContext);
605 :
606 763900 : ActivePortal = saveActivePortal;
607 763900 : CurrentResourceOwner = saveResourceOwner;
608 763900 : PortalContext = savePortalContext;
609 :
610 763900 : portal->status = PORTAL_READY;
611 763900 : }
612 :
613 : /*
614 : * PortalSetResultFormat
615 : * Select the format codes for a portal's output.
616 : *
617 : * This must be run after PortalStart for a portal that will be read by
618 : * a DestRemote or DestRemoteExecute destination. It is not presently needed
619 : * for other destination types.
620 : *
621 : * formats[] is the client format request, as per Bind message conventions.
622 : */
623 : void
624 727688 : PortalSetResultFormat(Portal portal, int nFormats, int16 *formats)
625 : {
626 : int natts;
627 : int i;
628 :
629 : /* Do nothing if portal won't return tuples */
630 727688 : if (portal->tupDesc == NULL)
631 413180 : return;
632 314508 : natts = portal->tupDesc->natts;
633 314508 : portal->formats = (int16 *)
634 314508 : MemoryContextAlloc(portal->portalContext,
635 : natts * sizeof(int16));
636 314508 : if (nFormats > 1)
637 : {
638 : /* format specified for each column */
639 0 : if (nFormats != natts)
640 0 : ereport(ERROR,
641 : (errcode(ERRCODE_PROTOCOL_VIOLATION),
642 : errmsg("bind message has %d result formats but query has %d columns",
643 : nFormats, natts)));
644 0 : memcpy(portal->formats, formats, natts * sizeof(int16));
645 : }
646 314508 : else if (nFormats > 0)
647 : {
648 : /* single format specified, use for all columns */
649 314508 : int16 format1 = formats[0];
650 :
651 1377088 : for (i = 0; i < natts; i++)
652 1062580 : portal->formats[i] = format1;
653 : }
654 : else
655 : {
656 : /* use default format for all columns */
657 0 : for (i = 0; i < natts; i++)
658 0 : portal->formats[i] = 0;
659 : }
660 : }
661 :
662 : /*
663 : * PortalRun
664 : * Run a portal's query or queries.
665 : *
666 : * count <= 0 is interpreted as a no-op: the destination gets started up
667 : * and shut down, but nothing else happens. Also, count == FETCH_ALL is
668 : * interpreted as "all rows". Note that count is ignored in multi-query
669 : * situations, where we always run the portal to completion.
670 : *
671 : * isTopLevel: true if query is being executed at backend "top level"
672 : * (that is, directly from a client command message)
673 : *
674 : * dest: where to send output of primary (canSetTag) query
675 : *
676 : * altdest: where to send output of non-primary queries
677 : *
678 : * qc: where to store command completion status data.
679 : * May be NULL if caller doesn't want status data.
680 : *
681 : * Returns true if the portal's execution is complete, false if it was
682 : * suspended due to exhaustion of the count parameter.
683 : */
684 : bool
685 747206 : PortalRun(Portal portal, long count, bool isTopLevel,
686 : DestReceiver *dest, DestReceiver *altdest,
687 : QueryCompletion *qc)
688 : {
689 : bool result;
690 : uint64 nprocessed;
691 : ResourceOwner saveTopTransactionResourceOwner;
692 : MemoryContext saveTopTransactionContext;
693 : Portal saveActivePortal;
694 : ResourceOwner saveResourceOwner;
695 : MemoryContext savePortalContext;
696 : MemoryContext saveMemoryContext;
697 :
698 : Assert(PortalIsValid(portal));
699 :
700 : TRACE_POSTGRESQL_QUERY_EXECUTE_START();
701 :
702 : /* Initialize empty completion data */
703 747206 : if (qc)
704 747206 : InitializeQueryCompletion(qc);
705 :
706 747206 : if (log_executor_stats && portal->strategy != PORTAL_MULTI_QUERY)
707 : {
708 0 : elog(DEBUG3, "PortalRun");
709 : /* PORTAL_MULTI_QUERY logs its own stats per query */
710 0 : ResetUsage();
711 : }
712 :
713 : /*
714 : * Check for improper portal use, and mark portal active.
715 : */
716 747206 : MarkPortalActive(portal);
717 :
718 : /*
719 : * Set up global portal context pointers.
720 : *
721 : * We have to play a special game here to support utility commands like
722 : * VACUUM and CLUSTER, which internally start and commit transactions.
723 : * When we are called to execute such a command, CurrentResourceOwner will
724 : * be pointing to the TopTransactionResourceOwner --- which will be
725 : * destroyed and replaced in the course of the internal commit and
726 : * restart. So we need to be prepared to restore it as pointing to the
727 : * exit-time TopTransactionResourceOwner. (Ain't that ugly? This idea of
728 : * internally starting whole new transactions is not good.)
729 : * CurrentMemoryContext has a similar problem, but the other pointers we
730 : * save here will be NULL or pointing to longer-lived objects.
731 : */
732 747206 : saveTopTransactionResourceOwner = TopTransactionResourceOwner;
733 747206 : saveTopTransactionContext = TopTransactionContext;
734 747206 : saveActivePortal = ActivePortal;
735 747206 : saveResourceOwner = CurrentResourceOwner;
736 747206 : savePortalContext = PortalContext;
737 747206 : saveMemoryContext = CurrentMemoryContext;
738 747206 : PG_TRY();
739 : {
740 747206 : ActivePortal = portal;
741 747206 : if (portal->resowner)
742 747206 : CurrentResourceOwner = portal->resowner;
743 747206 : PortalContext = portal->portalContext;
744 :
745 747206 : MemoryContextSwitchTo(PortalContext);
746 :
747 747206 : switch (portal->strategy)
748 : {
749 333906 : case PORTAL_ONE_SELECT:
750 : case PORTAL_ONE_RETURNING:
751 : case PORTAL_ONE_MOD_WITH:
752 : case PORTAL_UTIL_SELECT:
753 :
754 : /*
755 : * If we have not yet run the command, do so, storing its
756 : * results in the portal's tuplestore. But we don't do that
757 : * for the PORTAL_ONE_SELECT case.
758 : */
759 333906 : if (portal->strategy != PORTAL_ONE_SELECT && !portal->holdStore)
760 45238 : FillPortalStore(portal, isTopLevel);
761 :
762 : /*
763 : * Now fetch desired portion of results.
764 : */
765 333508 : nprocessed = PortalRunSelect(portal, true, count, dest);
766 :
767 : /*
768 : * If the portal result contains a command tag and the caller
769 : * gave us a pointer to store it, copy it and update the
770 : * rowcount.
771 : */
772 326318 : if (qc && portal->qc.commandTag != CMDTAG_UNKNOWN)
773 : {
774 326318 : CopyQueryCompletion(qc, &portal->qc);
775 326318 : qc->nprocessed = nprocessed;
776 : }
777 :
778 : /* Mark portal not active */
779 326318 : portal->status = PORTAL_READY;
780 :
781 : /*
782 : * Since it's a forward fetch, say DONE iff atEnd is now true.
783 : */
784 326318 : result = portal->atEnd;
785 326318 : break;
786 :
787 413300 : case PORTAL_MULTI_QUERY:
788 413300 : PortalRunMulti(portal, isTopLevel, false,
789 : dest, altdest, qc);
790 :
791 : /* Prevent portal's commands from being re-executed */
792 392636 : MarkPortalDone(portal);
793 :
794 : /* Always complete at end of RunMulti */
795 392636 : result = true;
796 392636 : break;
797 :
798 0 : default:
799 0 : elog(ERROR, "unrecognized portal strategy: %d",
800 : (int) portal->strategy);
801 : result = false; /* keep compiler quiet */
802 : break;
803 : }
804 : }
805 28244 : PG_CATCH();
806 : {
807 : /* Uncaught error while executing portal: mark it dead */
808 28244 : MarkPortalFailed(portal);
809 :
810 : /* Restore global vars and propagate error */
811 28244 : if (saveMemoryContext == saveTopTransactionContext)
812 27874 : MemoryContextSwitchTo(TopTransactionContext);
813 : else
814 370 : MemoryContextSwitchTo(saveMemoryContext);
815 28244 : ActivePortal = saveActivePortal;
816 28244 : if (saveResourceOwner == saveTopTransactionResourceOwner)
817 27972 : CurrentResourceOwner = TopTransactionResourceOwner;
818 : else
819 272 : CurrentResourceOwner = saveResourceOwner;
820 28244 : PortalContext = savePortalContext;
821 :
822 28244 : PG_RE_THROW();
823 : }
824 718954 : PG_END_TRY();
825 :
826 718954 : if (saveMemoryContext == saveTopTransactionContext)
827 671674 : MemoryContextSwitchTo(TopTransactionContext);
828 : else
829 47280 : MemoryContextSwitchTo(saveMemoryContext);
830 718954 : ActivePortal = saveActivePortal;
831 718954 : if (saveResourceOwner == saveTopTransactionResourceOwner)
832 693304 : CurrentResourceOwner = TopTransactionResourceOwner;
833 : else
834 25650 : CurrentResourceOwner = saveResourceOwner;
835 718954 : PortalContext = savePortalContext;
836 :
837 718954 : if (log_executor_stats && portal->strategy != PORTAL_MULTI_QUERY)
838 0 : ShowUsage("EXECUTOR STATISTICS");
839 :
840 : TRACE_POSTGRESQL_QUERY_EXECUTE_DONE();
841 :
842 718954 : return result;
843 : }
844 :
845 : /*
846 : * PortalRunSelect
847 : * Execute a portal's query in PORTAL_ONE_SELECT mode, and also
848 : * when fetching from a completed holdStore in PORTAL_ONE_RETURNING,
849 : * PORTAL_ONE_MOD_WITH, and PORTAL_UTIL_SELECT cases.
850 : *
851 : * This handles simple N-rows-forward-or-backward cases. For more complex
852 : * nonsequential access to a portal, see PortalRunFetch.
853 : *
854 : * count <= 0 is interpreted as a no-op: the destination gets started up
855 : * and shut down, but nothing else happens. Also, count == FETCH_ALL is
856 : * interpreted as "all rows". (cf FetchStmt.howMany)
857 : *
858 : * Caller must already have validated the Portal and done appropriate
859 : * setup (cf. PortalRun).
860 : *
861 : * Returns number of rows processed (suitable for use in result tag)
862 : */
863 : static uint64
864 385410 : PortalRunSelect(Portal portal,
865 : bool forward,
866 : long count,
867 : DestReceiver *dest)
868 : {
869 : QueryDesc *queryDesc;
870 : ScanDirection direction;
871 : uint64 nprocessed;
872 :
873 : /*
874 : * NB: queryDesc will be NULL if we are fetching from a held cursor or a
875 : * completed utility query; can't use it in that path.
876 : */
877 385410 : queryDesc = portal->queryDesc;
878 :
879 : /* Caller messed up if we have neither a ready query nor held data. */
880 : Assert(queryDesc || portal->holdStore);
881 :
882 : /*
883 : * Force the queryDesc destination to the right thing. This supports
884 : * MOVE, for example, which will pass in dest = DestNone. This is okay to
885 : * change as long as we do it on every fetch. (The Executor must not
886 : * assume that dest never changes.)
887 : */
888 385410 : if (queryDesc)
889 308514 : queryDesc->dest = dest;
890 :
891 : /*
892 : * Determine which direction to go in, and check to see if we're already
893 : * at the end of the available tuples in that direction. If so, set the
894 : * direction to NoMovement to avoid trying to fetch any tuples. (This
895 : * check exists because not all plan node types are robust about being
896 : * called again if they've already returned NULL once.) Then call the
897 : * executor (we must not skip this, because the destination needs to see a
898 : * setup and shutdown even if no tuples are available). Finally, update
899 : * the portal position state depending on the number of tuples that were
900 : * retrieved.
901 : */
902 385410 : if (forward)
903 : {
904 384806 : if (portal->atEnd || count <= 0)
905 : {
906 3686 : direction = NoMovementScanDirection;
907 3686 : count = 0; /* don't pass negative count to executor */
908 : }
909 : else
910 381120 : direction = ForwardScanDirection;
911 :
912 : /* In the executor, zero count processes all rows */
913 384806 : if (count == FETCH_ALL)
914 333832 : count = 0;
915 :
916 384806 : if (portal->holdStore)
917 76878 : nprocessed = RunFromStore(portal, direction, (uint64) count, dest);
918 : else
919 : {
920 307928 : PushActiveSnapshot(queryDesc->snapshot);
921 307928 : ExecutorRun(queryDesc, direction, (uint64) count);
922 300710 : nprocessed = queryDesc->estate->es_processed;
923 300710 : PopActiveSnapshot();
924 : }
925 :
926 377588 : if (!ScanDirectionIsNoMovement(direction))
927 : {
928 373902 : if (nprocessed > 0)
929 314504 : portal->atStart = false; /* OK to go backward now */
930 373902 : if (count == 0 || nprocessed < (uint64) count)
931 340714 : portal->atEnd = true; /* we retrieved 'em all */
932 373902 : portal->portalPos += nprocessed;
933 : }
934 : }
935 : else
936 : {
937 604 : if (portal->cursorOptions & CURSOR_OPT_NO_SCROLL)
938 24 : ereport(ERROR,
939 : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
940 : errmsg("cursor can only scan forward"),
941 : errhint("Declare it with SCROLL option to enable backward scan.")));
942 :
943 580 : if (portal->atStart || count <= 0)
944 : {
945 72 : direction = NoMovementScanDirection;
946 72 : count = 0; /* don't pass negative count to executor */
947 : }
948 : else
949 508 : direction = BackwardScanDirection;
950 :
951 : /* In the executor, zero count processes all rows */
952 580 : if (count == FETCH_ALL)
953 60 : count = 0;
954 :
955 580 : if (portal->holdStore)
956 12 : nprocessed = RunFromStore(portal, direction, (uint64) count, dest);
957 : else
958 : {
959 568 : PushActiveSnapshot(queryDesc->snapshot);
960 568 : ExecutorRun(queryDesc, direction, (uint64) count);
961 568 : nprocessed = queryDesc->estate->es_processed;
962 568 : PopActiveSnapshot();
963 : }
964 :
965 580 : if (!ScanDirectionIsNoMovement(direction))
966 : {
967 508 : if (nprocessed > 0 && portal->atEnd)
968 : {
969 154 : portal->atEnd = false; /* OK to go forward now */
970 154 : portal->portalPos++; /* adjust for endpoint case */
971 : }
972 508 : if (count == 0 || nprocessed < (uint64) count)
973 : {
974 186 : portal->atStart = true; /* we retrieved 'em all */
975 186 : portal->portalPos = 0;
976 : }
977 : else
978 : {
979 322 : portal->portalPos -= nprocessed;
980 : }
981 : }
982 : }
983 :
984 378168 : return nprocessed;
985 : }
986 :
987 : /*
988 : * FillPortalStore
989 : * Run the query and load result tuples into the portal's tuple store.
990 : *
991 : * This is used for PORTAL_ONE_RETURNING, PORTAL_ONE_MOD_WITH, and
992 : * PORTAL_UTIL_SELECT cases only.
993 : */
994 : static void
995 53316 : FillPortalStore(Portal portal, bool isTopLevel)
996 : {
997 : DestReceiver *treceiver;
998 : QueryCompletion qc;
999 :
1000 53316 : InitializeQueryCompletion(&qc);
1001 53316 : PortalCreateHoldStore(portal);
1002 53316 : treceiver = CreateDestReceiver(DestTuplestore);
1003 53316 : SetTuplestoreDestReceiverParams(treceiver,
1004 : portal->holdStore,
1005 : portal->holdContext,
1006 : false,
1007 : NULL,
1008 : NULL);
1009 :
1010 53316 : switch (portal->strategy)
1011 : {
1012 3564 : case PORTAL_ONE_RETURNING:
1013 : case PORTAL_ONE_MOD_WITH:
1014 :
1015 : /*
1016 : * Run the portal to completion just as for the default
1017 : * PORTAL_MULTI_QUERY case, but send the primary query's output to
1018 : * the tuplestore. Auxiliary query outputs are discarded. Set the
1019 : * portal's holdSnapshot to the snapshot used (or a copy of it).
1020 : */
1021 3564 : PortalRunMulti(portal, isTopLevel, true,
1022 : treceiver, None_Receiver, &qc);
1023 3412 : break;
1024 :
1025 49752 : case PORTAL_UTIL_SELECT:
1026 49752 : PortalRunUtility(portal, linitial_node(PlannedStmt, portal->stmts),
1027 : isTopLevel, true, treceiver, &qc);
1028 49500 : break;
1029 :
1030 0 : default:
1031 0 : elog(ERROR, "unsupported portal strategy: %d",
1032 : (int) portal->strategy);
1033 : break;
1034 : }
1035 :
1036 : /* Override portal completion data with actual command results */
1037 52912 : if (qc.commandTag != CMDTAG_UNKNOWN)
1038 28400 : CopyQueryCompletion(&portal->qc, &qc);
1039 :
1040 52912 : treceiver->rDestroy(treceiver);
1041 52912 : }
1042 :
1043 : /*
1044 : * RunFromStore
1045 : * Fetch tuples from the portal's tuple store.
1046 : *
1047 : * Calling conventions are similar to ExecutorRun, except that we
1048 : * do not depend on having a queryDesc or estate. Therefore we return the
1049 : * number of tuples processed as the result, not in estate->es_processed.
1050 : *
1051 : * One difference from ExecutorRun is that the destination receiver functions
1052 : * are run in the caller's memory context (since we have no estate). Watch
1053 : * out for memory leaks.
1054 : */
1055 : static uint64
1056 76890 : RunFromStore(Portal portal, ScanDirection direction, uint64 count,
1057 : DestReceiver *dest)
1058 : {
1059 76890 : uint64 current_tuple_count = 0;
1060 : TupleTableSlot *slot;
1061 :
1062 76890 : slot = MakeSingleTupleTableSlot(portal->tupDesc, &TTSOpsMinimalTuple);
1063 :
1064 76890 : dest->rStartup(dest, CMD_SELECT, portal->tupDesc);
1065 :
1066 76890 : if (ScanDirectionIsNoMovement(direction))
1067 : {
1068 : /* do nothing except start/stop the destination */
1069 : }
1070 : else
1071 : {
1072 74328 : bool forward = ScanDirectionIsForward(direction);
1073 :
1074 : for (;;)
1075 422964 : {
1076 : MemoryContext oldcontext;
1077 : bool ok;
1078 :
1079 497292 : oldcontext = MemoryContextSwitchTo(portal->holdContext);
1080 :
1081 497292 : ok = tuplestore_gettupleslot(portal->holdStore, forward, false,
1082 : slot);
1083 :
1084 497292 : MemoryContextSwitchTo(oldcontext);
1085 :
1086 497292 : if (!ok)
1087 52966 : break;
1088 :
1089 : /*
1090 : * If we are not able to send the tuple, we assume the destination
1091 : * has closed and no more tuples can be sent. If that's the case,
1092 : * end the loop.
1093 : */
1094 444326 : if (!dest->receiveSlot(slot, dest))
1095 0 : break;
1096 :
1097 444326 : ExecClearTuple(slot);
1098 :
1099 : /*
1100 : * check our tuple count.. if we've processed the proper number
1101 : * then quit, else loop again and process more tuples. Zero count
1102 : * means no limit.
1103 : */
1104 444326 : current_tuple_count++;
1105 444326 : if (count && count == current_tuple_count)
1106 21362 : break;
1107 : }
1108 : }
1109 :
1110 76890 : dest->rShutdown(dest);
1111 :
1112 76890 : ExecDropSingleTupleTableSlot(slot);
1113 :
1114 76890 : return current_tuple_count;
1115 : }
1116 :
1117 : /*
1118 : * PortalRunUtility
1119 : * Execute a utility statement inside a portal.
1120 : */
1121 : static void
1122 379316 : PortalRunUtility(Portal portal, PlannedStmt *pstmt,
1123 : bool isTopLevel, bool setHoldSnapshot,
1124 : DestReceiver *dest, QueryCompletion *qc)
1125 : {
1126 : /*
1127 : * Set snapshot if utility stmt needs one.
1128 : */
1129 379316 : if (PlannedStmtRequiresSnapshot(pstmt))
1130 : {
1131 303792 : Snapshot snapshot = GetTransactionSnapshot();
1132 :
1133 : /* If told to, register the snapshot we're using and save in portal */
1134 303792 : if (setHoldSnapshot)
1135 : {
1136 43214 : snapshot = RegisterSnapshot(snapshot);
1137 43214 : portal->holdSnapshot = snapshot;
1138 : }
1139 :
1140 : /*
1141 : * In any case, make the snapshot active and remember it in portal.
1142 : * Because the portal now references the snapshot, we must tell
1143 : * snapmgr.c that the snapshot belongs to the portal's transaction
1144 : * level, else we risk portalSnapshot becoming a dangling pointer.
1145 : */
1146 303792 : PushActiveSnapshotWithLevel(snapshot, portal->createLevel);
1147 : /* PushActiveSnapshotWithLevel might have copied the snapshot */
1148 303792 : portal->portalSnapshot = GetActiveSnapshot();
1149 : }
1150 : else
1151 75524 : portal->portalSnapshot = NULL;
1152 :
1153 379316 : ProcessUtility(pstmt,
1154 : portal->sourceText,
1155 379316 : (portal->cplan != NULL), /* protect tree if in plancache */
1156 379316 : isTopLevel ? PROCESS_UTILITY_TOPLEVEL : PROCESS_UTILITY_QUERY,
1157 : portal->portalParams,
1158 : portal->queryEnv,
1159 : dest,
1160 : qc);
1161 :
1162 : /* Some utility statements may change context on us */
1163 363796 : MemoryContextSwitchTo(portal->portalContext);
1164 :
1165 : /*
1166 : * Some utility commands (e.g., VACUUM) pop the ActiveSnapshot stack from
1167 : * under us, so don't complain if it's now empty. Otherwise, our snapshot
1168 : * should be the top one; pop it. Note that this could be a different
1169 : * snapshot from the one we made above; see EnsurePortalSnapshotExists.
1170 : */
1171 363796 : if (portal->portalSnapshot != NULL && ActiveSnapshotSet())
1172 : {
1173 : Assert(portal->portalSnapshot == GetActiveSnapshot());
1174 278186 : PopActiveSnapshot();
1175 : }
1176 363796 : portal->portalSnapshot = NULL;
1177 363796 : }
1178 :
1179 : /*
1180 : * PortalRunMulti
1181 : * Execute a portal's queries in the general case (multi queries
1182 : * or non-SELECT-like queries)
1183 : */
1184 : static void
1185 416864 : PortalRunMulti(Portal portal,
1186 : bool isTopLevel, bool setHoldSnapshot,
1187 : DestReceiver *dest, DestReceiver *altdest,
1188 : QueryCompletion *qc)
1189 : {
1190 416864 : bool active_snapshot_set = false;
1191 : ListCell *stmtlist_item;
1192 :
1193 : /*
1194 : * If the destination is DestRemoteExecute, change to DestNone. The
1195 : * reason is that the client won't be expecting any tuples, and indeed has
1196 : * no way to know what they are, since there is no provision for Describe
1197 : * to send a RowDescription message when this portal execution strategy is
1198 : * in effect. This presently will only affect SELECT commands added to
1199 : * non-SELECT queries by rewrite rules: such commands will be executed,
1200 : * but the results will be discarded unless you use "simple Query"
1201 : * protocol.
1202 : */
1203 416864 : if (dest->mydest == DestRemoteExecute)
1204 12466 : dest = None_Receiver;
1205 416864 : if (altdest->mydest == DestRemoteExecute)
1206 12466 : altdest = None_Receiver;
1207 :
1208 : /*
1209 : * Loop to handle the individual queries generated from a single parsetree
1210 : * by analysis and rewrite.
1211 : */
1212 813500 : foreach(stmtlist_item, portal->stmts)
1213 : {
1214 417452 : PlannedStmt *pstmt = lfirst_node(PlannedStmt, stmtlist_item);
1215 :
1216 : /*
1217 : * If we got a cancel signal in prior command, quit
1218 : */
1219 417452 : CHECK_FOR_INTERRUPTS();
1220 :
1221 417452 : if (pstmt->utilityStmt == NULL)
1222 : {
1223 : /*
1224 : * process a plannable query.
1225 : */
1226 : TRACE_POSTGRESQL_QUERY_EXECUTE_START();
1227 :
1228 87888 : if (log_executor_stats)
1229 0 : ResetUsage();
1230 :
1231 : /*
1232 : * Must always have a snapshot for plannable queries. First time
1233 : * through, take a new snapshot; for subsequent queries in the
1234 : * same portal, just update the snapshot's copy of the command
1235 : * counter.
1236 : */
1237 87888 : if (!active_snapshot_set)
1238 : {
1239 87300 : Snapshot snapshot = GetTransactionSnapshot();
1240 :
1241 : /* If told to, register the snapshot and save in portal */
1242 87300 : if (setHoldSnapshot)
1243 : {
1244 3564 : snapshot = RegisterSnapshot(snapshot);
1245 3564 : portal->holdSnapshot = snapshot;
1246 : }
1247 :
1248 : /*
1249 : * We can't have the holdSnapshot also be the active one,
1250 : * because UpdateActiveSnapshotCommandId would complain. So
1251 : * force an extra snapshot copy. Plain PushActiveSnapshot
1252 : * would have copied the transaction snapshot anyway, so this
1253 : * only adds a copy step when setHoldSnapshot is true. (It's
1254 : * okay for the command ID of the active snapshot to diverge
1255 : * from what holdSnapshot has.)
1256 : */
1257 87300 : PushCopiedSnapshot(snapshot);
1258 :
1259 : /*
1260 : * As for PORTAL_ONE_SELECT portals, it does not seem
1261 : * necessary to maintain portal->portalSnapshot here.
1262 : */
1263 :
1264 87300 : active_snapshot_set = true;
1265 : }
1266 : else
1267 588 : UpdateActiveSnapshotCommandId();
1268 :
1269 87888 : if (pstmt->canSetTag)
1270 : {
1271 : /* statement can set tag string */
1272 87258 : ProcessQuery(pstmt,
1273 : portal->sourceText,
1274 : portal->portalParams,
1275 : portal->queryEnv,
1276 : dest, qc);
1277 : }
1278 : else
1279 : {
1280 : /* stmt added by rewrite cannot set tag */
1281 630 : ProcessQuery(pstmt,
1282 : portal->sourceText,
1283 : portal->portalParams,
1284 : portal->queryEnv,
1285 : altdest, NULL);
1286 : }
1287 :
1288 82340 : if (log_executor_stats)
1289 0 : ShowUsage("EXECUTOR STATISTICS");
1290 :
1291 : TRACE_POSTGRESQL_QUERY_EXECUTE_DONE();
1292 : }
1293 : else
1294 : {
1295 : /*
1296 : * process utility functions (create, destroy, etc..)
1297 : *
1298 : * We must not set a snapshot here for utility commands (if one is
1299 : * needed, PortalRunUtility will do it). If a utility command is
1300 : * alone in a portal then everything's fine. The only case where
1301 : * a utility command can be part of a longer list is that rules
1302 : * are allowed to include NotifyStmt. NotifyStmt doesn't care
1303 : * whether it has a snapshot or not, so we just leave the current
1304 : * snapshot alone if we have one.
1305 : */
1306 329564 : if (pstmt->canSetTag)
1307 : {
1308 : Assert(!active_snapshot_set);
1309 : /* statement can set tag string */
1310 329564 : PortalRunUtility(portal, pstmt, isTopLevel, false,
1311 : dest, qc);
1312 : }
1313 : else
1314 : {
1315 : Assert(IsA(pstmt->utilityStmt, NotifyStmt));
1316 : /* stmt added by rewrite cannot set tag */
1317 0 : PortalRunUtility(portal, pstmt, isTopLevel, false,
1318 : altdest, NULL);
1319 : }
1320 : }
1321 :
1322 : /*
1323 : * Clear subsidiary contexts to recover temporary memory.
1324 : */
1325 : Assert(portal->portalContext == CurrentMemoryContext);
1326 :
1327 396636 : MemoryContextDeleteChildren(portal->portalContext);
1328 :
1329 : /*
1330 : * Avoid crashing if portal->stmts has been reset. This can only
1331 : * occur if a CALL or DO utility statement executed an internal
1332 : * COMMIT/ROLLBACK (cf PortalReleaseCachedPlan). The CALL or DO must
1333 : * have been the only statement in the portal, so there's nothing left
1334 : * for us to do; but we don't want to dereference a now-dangling list
1335 : * pointer.
1336 : */
1337 396636 : if (portal->stmts == NIL)
1338 0 : break;
1339 :
1340 : /*
1341 : * Increment command counter between queries, but not after the last
1342 : * one.
1343 : */
1344 396636 : if (lnext(portal->stmts, stmtlist_item) != NULL)
1345 588 : CommandCounterIncrement();
1346 : }
1347 :
1348 : /* Pop the snapshot if we pushed one. */
1349 396048 : if (active_snapshot_set)
1350 81752 : PopActiveSnapshot();
1351 :
1352 : /*
1353 : * If a query completion data was supplied, use it. Otherwise use the
1354 : * portal's query completion data.
1355 : *
1356 : * Exception: Clients expect INSERT/UPDATE/DELETE tags to have counts, so
1357 : * fake them with zeros. This can happen with DO INSTEAD rules if there
1358 : * is no replacement query of the same type as the original. We print "0
1359 : * 0" here because technically there is no query of the matching tag type,
1360 : * and printing a non-zero count for a different query type seems wrong,
1361 : * e.g. an INSERT that does an UPDATE instead should not print "0 1" if
1362 : * one row was updated. See QueryRewrite(), step 3, for details.
1363 : */
1364 396048 : if (qc && qc->commandTag == CMDTAG_UNKNOWN)
1365 : {
1366 296326 : if (portal->qc.commandTag != CMDTAG_UNKNOWN)
1367 296326 : CopyQueryCompletion(qc, &portal->qc);
1368 : /* If the caller supplied a qc, we should have set it by now. */
1369 : Assert(qc->commandTag != CMDTAG_UNKNOWN);
1370 : }
1371 396048 : }
1372 :
1373 : /*
1374 : * PortalRunFetch
1375 : * Variant form of PortalRun that supports SQL FETCH directions.
1376 : *
1377 : * Note: we presently assume that no callers of this want isTopLevel = true.
1378 : *
1379 : * count <= 0 is interpreted as a no-op: the destination gets started up
1380 : * and shut down, but nothing else happens. Also, count == FETCH_ALL is
1381 : * interpreted as "all rows". (cf FetchStmt.howMany)
1382 : *
1383 : * Returns number of rows processed (suitable for use in result tag)
1384 : */
1385 : uint64
1386 51830 : PortalRunFetch(Portal portal,
1387 : FetchDirection fdirection,
1388 : long count,
1389 : DestReceiver *dest)
1390 : {
1391 : uint64 result;
1392 : Portal saveActivePortal;
1393 : ResourceOwner saveResourceOwner;
1394 : MemoryContext savePortalContext;
1395 : MemoryContext oldContext;
1396 :
1397 : Assert(PortalIsValid(portal));
1398 :
1399 : /*
1400 : * Check for improper portal use, and mark portal active.
1401 : */
1402 51830 : MarkPortalActive(portal);
1403 :
1404 : /*
1405 : * Set up global portal context pointers.
1406 : */
1407 51812 : saveActivePortal = ActivePortal;
1408 51812 : saveResourceOwner = CurrentResourceOwner;
1409 51812 : savePortalContext = PortalContext;
1410 51812 : PG_TRY();
1411 : {
1412 51812 : ActivePortal = portal;
1413 51812 : if (portal->resowner)
1414 51620 : CurrentResourceOwner = portal->resowner;
1415 51812 : PortalContext = portal->portalContext;
1416 :
1417 51812 : oldContext = MemoryContextSwitchTo(PortalContext);
1418 :
1419 51812 : switch (portal->strategy)
1420 : {
1421 19942 : case PORTAL_ONE_SELECT:
1422 19942 : result = DoPortalRunFetch(portal, fdirection, count, dest);
1423 19884 : break;
1424 :
1425 31870 : case PORTAL_ONE_RETURNING:
1426 : case PORTAL_ONE_MOD_WITH:
1427 : case PORTAL_UTIL_SELECT:
1428 :
1429 : /*
1430 : * If we have not yet run the command, do so, storing its
1431 : * results in the portal's tuplestore.
1432 : */
1433 31870 : if (!portal->holdStore)
1434 8078 : FillPortalStore(portal, false /* isTopLevel */ );
1435 :
1436 : /*
1437 : * Now fetch desired portion of results.
1438 : */
1439 31864 : result = DoPortalRunFetch(portal, fdirection, count, dest);
1440 31864 : break;
1441 :
1442 0 : default:
1443 0 : elog(ERROR, "unsupported portal strategy");
1444 : result = 0; /* keep compiler quiet */
1445 : break;
1446 : }
1447 : }
1448 64 : PG_CATCH();
1449 : {
1450 : /* Uncaught error while executing portal: mark it dead */
1451 64 : MarkPortalFailed(portal);
1452 :
1453 : /* Restore global vars and propagate error */
1454 64 : ActivePortal = saveActivePortal;
1455 64 : CurrentResourceOwner = saveResourceOwner;
1456 64 : PortalContext = savePortalContext;
1457 :
1458 64 : PG_RE_THROW();
1459 : }
1460 51748 : PG_END_TRY();
1461 :
1462 51748 : MemoryContextSwitchTo(oldContext);
1463 :
1464 : /* Mark portal not active */
1465 51748 : portal->status = PORTAL_READY;
1466 :
1467 51748 : ActivePortal = saveActivePortal;
1468 51748 : CurrentResourceOwner = saveResourceOwner;
1469 51748 : PortalContext = savePortalContext;
1470 :
1471 51748 : return result;
1472 : }
1473 :
1474 : /*
1475 : * DoPortalRunFetch
1476 : * Guts of PortalRunFetch --- the portal context is already set up
1477 : *
1478 : * Here, count < 0 typically reverses the direction. Also, count == FETCH_ALL
1479 : * is interpreted as "all rows". (cf FetchStmt.howMany)
1480 : *
1481 : * Returns number of rows processed (suitable for use in result tag)
1482 : */
1483 : static uint64
1484 51806 : DoPortalRunFetch(Portal portal,
1485 : FetchDirection fdirection,
1486 : long count,
1487 : DestReceiver *dest)
1488 : {
1489 : bool forward;
1490 :
1491 : Assert(portal->strategy == PORTAL_ONE_SELECT ||
1492 : portal->strategy == PORTAL_ONE_RETURNING ||
1493 : portal->strategy == PORTAL_ONE_MOD_WITH ||
1494 : portal->strategy == PORTAL_UTIL_SELECT);
1495 :
1496 : /*
1497 : * Note: we disallow backwards fetch (including re-fetch of current row)
1498 : * for NO SCROLL cursors, but we interpret that very loosely: you can use
1499 : * any of the FetchDirection options, so long as the end result is to move
1500 : * forwards by at least one row. Currently it's sufficient to check for
1501 : * NO SCROLL in DoPortalRewind() and in the forward == false path in
1502 : * PortalRunSelect(); but someday we might prefer to account for that
1503 : * restriction explicitly here.
1504 : */
1505 51806 : switch (fdirection)
1506 : {
1507 51066 : case FETCH_FORWARD:
1508 51066 : if (count < 0)
1509 : {
1510 0 : fdirection = FETCH_BACKWARD;
1511 0 : count = -count;
1512 : }
1513 : /* fall out of switch to share code with FETCH_BACKWARD */
1514 51066 : break;
1515 496 : case FETCH_BACKWARD:
1516 496 : if (count < 0)
1517 : {
1518 0 : fdirection = FETCH_FORWARD;
1519 0 : count = -count;
1520 : }
1521 : /* fall out of switch to share code with FETCH_FORWARD */
1522 496 : break;
1523 160 : case FETCH_ABSOLUTE:
1524 160 : if (count > 0)
1525 : {
1526 : /*
1527 : * Definition: Rewind to start, advance count-1 rows, return
1528 : * next row (if any).
1529 : *
1530 : * In practice, if the goal is less than halfway back to the
1531 : * start, it's better to scan from where we are.
1532 : *
1533 : * Also, if current portalPos is outside the range of "long",
1534 : * do it the hard way to avoid possible overflow of the count
1535 : * argument to PortalRunSelect. We must exclude exactly
1536 : * LONG_MAX, as well, lest the count look like FETCH_ALL.
1537 : *
1538 : * In any case, we arrange to fetch the target row going
1539 : * forwards.
1540 : */
1541 90 : if ((uint64) (count - 1) <= portal->portalPos / 2 ||
1542 36 : portal->portalPos >= (uint64) LONG_MAX)
1543 : {
1544 54 : DoPortalRewind(portal);
1545 48 : if (count > 1)
1546 0 : PortalRunSelect(portal, true, count - 1,
1547 : None_Receiver);
1548 : }
1549 : else
1550 : {
1551 36 : long pos = (long) portal->portalPos;
1552 :
1553 36 : if (portal->atEnd)
1554 0 : pos++; /* need one extra fetch if off end */
1555 36 : if (count <= pos)
1556 12 : PortalRunSelect(portal, false, pos - count + 1,
1557 : None_Receiver);
1558 24 : else if (count > pos + 1)
1559 12 : PortalRunSelect(portal, true, count - pos - 1,
1560 : None_Receiver);
1561 : }
1562 78 : return PortalRunSelect(portal, true, 1L, dest);
1563 : }
1564 70 : else if (count < 0)
1565 : {
1566 : /*
1567 : * Definition: Advance to end, back up abs(count)-1 rows,
1568 : * return prior row (if any). We could optimize this if we
1569 : * knew in advance where the end was, but typically we won't.
1570 : * (Is it worth considering case where count > half of size of
1571 : * query? We could rewind once we know the size ...)
1572 : */
1573 54 : PortalRunSelect(portal, true, FETCH_ALL, None_Receiver);
1574 54 : if (count < -1)
1575 0 : PortalRunSelect(portal, false, -count - 1, None_Receiver);
1576 54 : return PortalRunSelect(portal, false, 1L, dest);
1577 : }
1578 : else
1579 : {
1580 : /* count == 0 */
1581 : /* Rewind to start, return zero rows */
1582 16 : DoPortalRewind(portal);
1583 16 : return PortalRunSelect(portal, true, 0L, dest);
1584 : }
1585 : break;
1586 84 : case FETCH_RELATIVE:
1587 84 : if (count > 0)
1588 : {
1589 : /*
1590 : * Definition: advance count-1 rows, return next row (if any).
1591 : */
1592 36 : if (count > 1)
1593 24 : PortalRunSelect(portal, true, count - 1, None_Receiver);
1594 36 : return PortalRunSelect(portal, true, 1L, dest);
1595 : }
1596 48 : else if (count < 0)
1597 : {
1598 : /*
1599 : * Definition: back up abs(count)-1 rows, return prior row (if
1600 : * any).
1601 : */
1602 30 : if (count < -1)
1603 18 : PortalRunSelect(portal, false, -count - 1, None_Receiver);
1604 30 : return PortalRunSelect(portal, false, 1L, dest);
1605 : }
1606 : else
1607 : {
1608 : /* count == 0 */
1609 : /* Same as FETCH FORWARD 0, so fall out of switch */
1610 18 : fdirection = FETCH_FORWARD;
1611 : }
1612 18 : break;
1613 0 : default:
1614 0 : elog(ERROR, "bogus direction");
1615 : break;
1616 : }
1617 :
1618 : /*
1619 : * Get here with fdirection == FETCH_FORWARD or FETCH_BACKWARD, and count
1620 : * >= 0.
1621 : */
1622 51580 : forward = (fdirection == FETCH_FORWARD);
1623 :
1624 : /*
1625 : * Zero count means to re-fetch the current row, if any (per SQL)
1626 : */
1627 51580 : if (count == 0)
1628 : {
1629 : bool on_row;
1630 :
1631 : /* Are we sitting on a row? */
1632 18 : on_row = (!portal->atStart && !portal->atEnd);
1633 :
1634 18 : if (dest->mydest == DestNone)
1635 : {
1636 : /* MOVE 0 returns 0/1 based on if FETCH 0 would return a row */
1637 0 : return on_row ? 1 : 0;
1638 : }
1639 : else
1640 : {
1641 : /*
1642 : * If we are sitting on a row, back up one so we can re-fetch it.
1643 : * If we are not sitting on a row, we still have to start up and
1644 : * shut down the executor so that the destination is initialized
1645 : * and shut down correctly; so keep going. To PortalRunSelect,
1646 : * count == 0 means we will retrieve no row.
1647 : */
1648 18 : if (on_row)
1649 : {
1650 18 : PortalRunSelect(portal, false, 1L, None_Receiver);
1651 : /* Set up to fetch one row forward */
1652 12 : count = 1;
1653 12 : forward = true;
1654 : }
1655 : }
1656 : }
1657 :
1658 : /*
1659 : * Optimize MOVE BACKWARD ALL into a Rewind.
1660 : */
1661 51574 : if (!forward && count == FETCH_ALL && dest->mydest == DestNone)
1662 : {
1663 24 : uint64 result = portal->portalPos;
1664 :
1665 24 : if (result > 0 && !portal->atEnd)
1666 0 : result--;
1667 24 : DoPortalRewind(portal);
1668 24 : return result;
1669 : }
1670 :
1671 51550 : return PortalRunSelect(portal, forward, count, dest);
1672 : }
1673 :
1674 : /*
1675 : * DoPortalRewind - rewind a Portal to starting point
1676 : */
1677 : static void
1678 94 : DoPortalRewind(Portal portal)
1679 : {
1680 : QueryDesc *queryDesc;
1681 :
1682 : /*
1683 : * No work is needed if we've not advanced nor attempted to advance the
1684 : * cursor (and we don't want to throw a NO SCROLL error in this case).
1685 : */
1686 94 : if (portal->atStart && !portal->atEnd)
1687 18 : return;
1688 :
1689 : /* Otherwise, cursor must allow scrolling */
1690 76 : if (portal->cursorOptions & CURSOR_OPT_NO_SCROLL)
1691 6 : ereport(ERROR,
1692 : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1693 : errmsg("cursor can only scan forward"),
1694 : errhint("Declare it with SCROLL option to enable backward scan.")));
1695 :
1696 : /* Rewind holdStore, if we have one */
1697 70 : if (portal->holdStore)
1698 : {
1699 : MemoryContext oldcontext;
1700 :
1701 6 : oldcontext = MemoryContextSwitchTo(portal->holdContext);
1702 6 : tuplestore_rescan(portal->holdStore);
1703 6 : MemoryContextSwitchTo(oldcontext);
1704 : }
1705 :
1706 : /* Rewind executor, if active */
1707 70 : queryDesc = portal->queryDesc;
1708 70 : if (queryDesc)
1709 : {
1710 64 : PushActiveSnapshot(queryDesc->snapshot);
1711 64 : ExecutorRewind(queryDesc);
1712 64 : PopActiveSnapshot();
1713 : }
1714 :
1715 70 : portal->atStart = true;
1716 70 : portal->atEnd = false;
1717 70 : portal->portalPos = 0;
1718 : }
1719 :
1720 : /*
1721 : * PlannedStmtRequiresSnapshot - what it says on the tin
1722 : */
1723 : bool
1724 492318 : PlannedStmtRequiresSnapshot(PlannedStmt *pstmt)
1725 : {
1726 492318 : Node *utilityStmt = pstmt->utilityStmt;
1727 :
1728 : /* If it's not a utility statement, it definitely needs a snapshot */
1729 492318 : if (utilityStmt == NULL)
1730 85564 : return true;
1731 :
1732 : /*
1733 : * Most utility statements need a snapshot, and the default presumption
1734 : * about new ones should be that they do too. Hence, enumerate those that
1735 : * do not need one.
1736 : *
1737 : * Transaction control, LOCK, and SET must *not* set a snapshot, since
1738 : * they need to be executable at the start of a transaction-snapshot-mode
1739 : * transaction without freezing a snapshot. By extension we allow SHOW
1740 : * not to set a snapshot. The other stmts listed are just efficiency
1741 : * hacks. Beware of listing anything that can modify the database --- if,
1742 : * say, it has to update an index with expressions that invoke
1743 : * user-defined functions, then it had better have a snapshot.
1744 : */
1745 406754 : if (IsA(utilityStmt, TransactionStmt) ||
1746 368550 : IsA(utilityStmt, LockStmt) ||
1747 366032 : IsA(utilityStmt, VariableSetStmt) ||
1748 327640 : IsA(utilityStmt, VariableShowStmt) ||
1749 326802 : IsA(utilityStmt, ConstraintsSetStmt) ||
1750 : /* efficiency hacks from here down */
1751 326700 : IsA(utilityStmt, FetchStmt) ||
1752 319164 : IsA(utilityStmt, ListenStmt) ||
1753 319090 : IsA(utilityStmt, NotifyStmt) ||
1754 319002 : IsA(utilityStmt, UnlistenStmt) ||
1755 318964 : IsA(utilityStmt, CheckPointStmt))
1756 88656 : return false;
1757 :
1758 318098 : return true;
1759 : }
1760 :
1761 : /*
1762 : * EnsurePortalSnapshotExists - recreate Portal-level snapshot, if needed
1763 : *
1764 : * Generally, we will have an active snapshot whenever we are executing
1765 : * inside a Portal, unless the Portal's query is one of the utility
1766 : * statements exempted from that rule (see PlannedStmtRequiresSnapshot).
1767 : * However, procedures and DO blocks can commit or abort the transaction,
1768 : * and thereby destroy all snapshots. This function can be called to
1769 : * re-establish the Portal-level snapshot when none exists.
1770 : */
1771 : void
1772 417734 : EnsurePortalSnapshotExists(void)
1773 : {
1774 : Portal portal;
1775 :
1776 : /*
1777 : * Nothing to do if a snapshot is set. (We take it on faith that the
1778 : * outermost active snapshot belongs to some Portal; or if there is no
1779 : * Portal, it's somebody else's responsibility to manage things.)
1780 : */
1781 417734 : if (ActiveSnapshotSet())
1782 413278 : return;
1783 :
1784 : /* Otherwise, we'd better have an active Portal */
1785 4456 : portal = ActivePortal;
1786 4456 : if (unlikely(portal == NULL))
1787 0 : elog(ERROR, "cannot execute SQL without an outer snapshot or portal");
1788 : Assert(portal->portalSnapshot == NULL);
1789 :
1790 : /*
1791 : * Create a new snapshot, make it active, and remember it in portal.
1792 : * Because the portal now references the snapshot, we must tell snapmgr.c
1793 : * that the snapshot belongs to the portal's transaction level, else we
1794 : * risk portalSnapshot becoming a dangling pointer.
1795 : */
1796 4456 : PushActiveSnapshotWithLevel(GetTransactionSnapshot(), portal->createLevel);
1797 : /* PushActiveSnapshotWithLevel might have copied the snapshot */
1798 4456 : portal->portalSnapshot = GetActiveSnapshot();
1799 : }
|
