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