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