PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
pquery.h File Reference
#include "nodes/parsenodes.h"
#include "utils/portal.h"
Include dependency graph for pquery.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

PortalStrategy ChoosePortalStrategy (List *stmts)
 
ListFetchPortalTargetList (Portal portal)
 
ListFetchStatementTargetList (Node *stmt)
 
void PortalStart (Portal portal, ParamListInfo params, int eflags, Snapshot snapshot)
 
void PortalSetResultFormat (Portal portal, int nFormats, int16 *formats)
 
bool PortalRun (Portal portal, long count, bool isTopLevel, DestReceiver *dest, DestReceiver *altdest, QueryCompletion *qc)
 
uint64 PortalRunFetch (Portal portal, FetchDirection fdirection, long count, DestReceiver *dest)
 
bool PlannedStmtRequiresSnapshot (struct PlannedStmt *pstmt)
 
void EnsurePortalSnapshotExists (void)
 

Variables

PGDLLIMPORT Portal ActivePortal
 

Function Documentation

◆ ChoosePortalStrategy()

PortalStrategy ChoosePortalStrategy ( List stmts)

Definition at line 209 of file pquery.c.

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 {
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 {
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)
313
314 /* Else, it's the general case... */
315 return PORTAL_MULTI_QUERY;
316}
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define stmt
Definition: indent_codes.h:59
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
#define nodeTag(nodeptr)
Definition: nodes.h:133
@ CMD_UTILITY
Definition: nodes.h:270
@ CMD_SELECT
Definition: nodes.h:265
#define lfirst(lc)
Definition: pg_list.h:172
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
#define linitial(l)
Definition: pg_list.h:178
@ 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
Definition: nodes.h:129
bool hasModifyingCTE
Definition: plannodes.h:58
bool canSetTag
Definition: plannodes.h:60
bool hasReturning
Definition: plannodes.h:56
CmdType commandType
Definition: plannodes.h:52
Node * utilityStmt
Definition: plannodes.h:95
List * returningList
Definition: parsenodes.h:200
CmdType commandType
Definition: parsenodes.h:121
Node * utilityStmt
Definition: parsenodes.h:136
bool UtilityReturnsTuples(Node *parsetree)
Definition: utility.c:2028

References PlannedStmt::canSetTag, CMD_SELECT, CMD_UTILITY, Query::commandType, PlannedStmt::commandType, elog, ERROR, PlannedStmt::hasModifyingCTE, PlannedStmt::hasReturning, IsA, lfirst, linitial, list_length(), NIL, nodeTag, PORTAL_MULTI_QUERY, PORTAL_ONE_MOD_WITH, PORTAL_ONE_RETURNING, PORTAL_ONE_SELECT, PORTAL_UTIL_SELECT, Query::returningList, stmt, UtilityReturnsTuples(), Query::utilityStmt, and PlannedStmt::utilityStmt.

Referenced by PlanCacheComputeResultDesc(), and PortalStart().

◆ EnsurePortalSnapshotExists()

void EnsurePortalSnapshotExists ( void  )

Definition at line 1771 of file pquery.c.

1772{
1773 Portal portal;
1774
1775 /*
1776 * Nothing to do if a snapshot is set. (We take it on faith that the
1777 * outermost active snapshot belongs to some Portal; or if there is no
1778 * Portal, it's somebody else's responsibility to manage things.)
1779 */
1780 if (ActiveSnapshotSet())
1781 return;
1782
1783 /* Otherwise, we'd better have an active Portal */
1784 portal = ActivePortal;
1785 if (unlikely(portal == NULL))
1786 elog(ERROR, "cannot execute SQL without an outer snapshot or portal");
1787 Assert(portal->portalSnapshot == NULL);
1788
1789 /*
1790 * Create a new snapshot, make it active, and remember it in portal.
1791 * Because the portal now references the snapshot, we must tell snapmgr.c
1792 * that the snapshot belongs to the portal's transaction level, else we
1793 * risk portalSnapshot becoming a dangling pointer.
1794 */
1796 /* PushActiveSnapshotWithLevel might have copied the snapshot */
1798}
#define Assert(condition)
Definition: c.h:812
#define unlikely(x)
Definition: c.h:330
Portal ActivePortal
Definition: pquery.c:35
Snapshot GetTransactionSnapshot(void)
Definition: snapmgr.c:212
bool ActiveSnapshotSet(void)
Definition: snapmgr.c:740
void PushActiveSnapshotWithLevel(Snapshot snapshot, int snap_level)
Definition: snapmgr.c:624
Snapshot GetActiveSnapshot(void)
Definition: snapmgr.c:728
Snapshot portalSnapshot
Definition: portal.h:169
int createLevel
Definition: portal.h:133

References ActivePortal, ActiveSnapshotSet(), Assert, PortalData::createLevel, elog, ERROR, GetActiveSnapshot(), GetTransactionSnapshot(), PortalData::portalSnapshot, PushActiveSnapshotWithLevel(), and unlikely.

Referenced by _SPI_execute_plan(), exec_eval_simple_expr(), and ExecuteCallStmt().

◆ FetchPortalTargetList()

List * FetchPortalTargetList ( Portal  portal)

Definition at line 326 of file pquery.c.

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}
PlannedStmt * PortalGetPrimaryStmt(Portal portal)
Definition: portalmem.c:151
List * FetchStatementTargetList(Node *stmt)
Definition: pquery.c:348
PortalStrategy strategy
Definition: portal.h:146

References FetchStatementTargetList(), NIL, PORTAL_MULTI_QUERY, PortalGetPrimaryStmt(), and PortalData::strategy.

Referenced by exec_describe_portal_message(), FetchStatementTargetList(), and printtup_startup().

◆ FetchStatementTargetList()

List * FetchStatementTargetList ( Node stmt)

Definition at line 348 of file pquery.c.

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);
405 }
406 return NIL;
407}
PreparedStatement * FetchPreparedStatement(const char *stmt_name, bool throwError)
Definition: prepare.c:431
List * FetchPreparedStatementTargetList(PreparedStatement *stmt)
Definition: prepare.c:486
#define PortalIsValid(p)
Definition: portal.h:211
Portal GetPortalByName(const char *name)
Definition: portalmem.c:130
List * FetchPortalTargetList(Portal portal)
Definition: pquery.c:326
char * name
Definition: parsenodes.h:4075
bool ismove
Definition: parsenodes.h:3360
char * portalname
Definition: parsenodes.h:3359
List * targetlist
Definition: plannodes.h:153
struct Plan * planTree
Definition: plannodes.h:70
List * targetList
Definition: parsenodes.h:193

References Assert, CMD_SELECT, CMD_UTILITY, Query::commandType, PlannedStmt::commandType, FetchPortalTargetList(), FetchPreparedStatement(), FetchPreparedStatementTargetList(), GetPortalByName(), PlannedStmt::hasReturning, IsA, FetchStmt::ismove, ExecuteStmt::name, NIL, PlannedStmt::planTree, PortalIsValid, FetchStmt::portalname, Query::returningList, stmt, Query::targetList, Plan::targetlist, Query::utilityStmt, and PlannedStmt::utilityStmt.

Referenced by CachedPlanGetTargetList(), and FetchPortalTargetList().

◆ PlannedStmtRequiresSnapshot()

bool PlannedStmtRequiresSnapshot ( struct PlannedStmt pstmt)

Definition at line 1723 of file pquery.c.

1724{
1725 Node *utilityStmt = pstmt->utilityStmt;
1726
1727 /* If it's not a utility statement, it definitely needs a snapshot */
1728 if (utilityStmt == NULL)
1729 return true;
1730
1731 /*
1732 * Most utility statements need a snapshot, and the default presumption
1733 * about new ones should be that they do too. Hence, enumerate those that
1734 * do not need one.
1735 *
1736 * Transaction control, LOCK, and SET must *not* set a snapshot, since
1737 * they need to be executable at the start of a transaction-snapshot-mode
1738 * transaction without freezing a snapshot. By extension we allow SHOW
1739 * not to set a snapshot. The other stmts listed are just efficiency
1740 * hacks. Beware of listing anything that can modify the database --- if,
1741 * say, it has to update an index with expressions that invoke
1742 * user-defined functions, then it had better have a snapshot.
1743 */
1744 if (IsA(utilityStmt, TransactionStmt) ||
1745 IsA(utilityStmt, LockStmt) ||
1746 IsA(utilityStmt, VariableSetStmt) ||
1747 IsA(utilityStmt, VariableShowStmt) ||
1748 IsA(utilityStmt, ConstraintsSetStmt) ||
1749 /* efficiency hacks from here down */
1750 IsA(utilityStmt, FetchStmt) ||
1751 IsA(utilityStmt, ListenStmt) ||
1752 IsA(utilityStmt, NotifyStmt) ||
1753 IsA(utilityStmt, UnlistenStmt) ||
1754 IsA(utilityStmt, CheckPointStmt))
1755 return false;
1756
1757 return true;
1758}

References IsA, and PlannedStmt::utilityStmt.

Referenced by _SPI_execute_plan(), and PortalRunUtility().

◆ PortalRun()

bool PortalRun ( Portal  portal,
long  count,
bool  isTopLevel,
DestReceiver dest,
DestReceiver altdest,
QueryCompletion qc 
)

Definition at line 684 of file pquery.c.

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 /*
718 * Set up global portal context pointers.
719 *
720 * We have to play a special game here to support utility commands like
721 * VACUUM and CLUSTER, which internally start and commit transactions.
722 * When we are called to execute such a command, CurrentResourceOwner will
723 * be pointing to the TopTransactionResourceOwner --- which will be
724 * destroyed and replaced in the course of the internal commit and
725 * restart. So we need to be prepared to restore it as pointing to the
726 * exit-time TopTransactionResourceOwner. (Ain't that ugly? This idea of
727 * internally starting whole new transactions is not good.)
728 * CurrentMemoryContext has a similar problem, but the other pointers we
729 * save here will be NULL or pointing to longer-lived objects.
730 */
731 saveTopTransactionResourceOwner = TopTransactionResourceOwner;
732 saveTopTransactionContext = TopTransactionContext;
733 saveActivePortal = ActivePortal;
734 saveResourceOwner = CurrentResourceOwner;
735 savePortalContext = PortalContext;
736 saveMemoryContext = CurrentMemoryContext;
737 PG_TRY();
738 {
739 ActivePortal = portal;
740 if (portal->resowner)
743
745
746 switch (portal->strategy)
747 {
752
753 /*
754 * If we have not yet run the command, do so, storing its
755 * results in the portal's tuplestore. But we don't do that
756 * for the PORTAL_ONE_SELECT case.
757 */
758 if (portal->strategy != PORTAL_ONE_SELECT && !portal->holdStore)
759 FillPortalStore(portal, isTopLevel);
760
761 /*
762 * Now fetch desired portion of results.
763 */
764 nprocessed = PortalRunSelect(portal, true, count, dest);
765
766 /*
767 * If the portal result contains a command tag and the caller
768 * gave us a pointer to store it, copy it and update the
769 * rowcount.
770 */
771 if (qc && portal->qc.commandTag != CMDTAG_UNKNOWN)
772 {
773 CopyQueryCompletion(qc, &portal->qc);
774 qc->nprocessed = nprocessed;
775 }
776
777 /* Mark portal not active */
778 portal->status = PORTAL_READY;
779
780 /*
781 * Since it's a forward fetch, say DONE iff atEnd is now true.
782 */
783 result = portal->atEnd;
784 break;
785
787 PortalRunMulti(portal, isTopLevel, false,
788 dest, altdest, qc);
789
790 /* Prevent portal's commands from being re-executed */
791 MarkPortalDone(portal);
792
793 /* Always complete at end of RunMulti */
794 result = true;
795 break;
796
797 default:
798 elog(ERROR, "unrecognized portal strategy: %d",
799 (int) portal->strategy);
800 result = false; /* keep compiler quiet */
801 break;
802 }
803 }
804 PG_CATCH();
805 {
806 /* Uncaught error while executing portal: mark it dead */
807 MarkPortalFailed(portal);
808
809 /* Restore global vars and propagate error */
810 if (saveMemoryContext == saveTopTransactionContext)
812 else
813 MemoryContextSwitchTo(saveMemoryContext);
814 ActivePortal = saveActivePortal;
815 if (saveResourceOwner == saveTopTransactionResourceOwner)
817 else
818 CurrentResourceOwner = saveResourceOwner;
819 PortalContext = savePortalContext;
820
821 PG_RE_THROW();
822 }
823 PG_END_TRY();
824
825 if (saveMemoryContext == saveTopTransactionContext)
827 else
828 MemoryContextSwitchTo(saveMemoryContext);
829 ActivePortal = saveActivePortal;
830 if (saveResourceOwner == saveTopTransactionResourceOwner)
832 else
833 CurrentResourceOwner = saveResourceOwner;
834 PortalContext = savePortalContext;
835
837 ShowUsage("EXECUTOR STATISTICS");
838
839 TRACE_POSTGRESQL_QUERY_EXECUTE_DONE();
840
841 return result;
842}
uint64_t uint64
Definition: c.h:486
void InitializeQueryCompletion(QueryCompletion *qc)
Definition: cmdtag.c:40
static void CopyQueryCompletion(QueryCompletion *dst, const QueryCompletion *src)
Definition: cmdtag.h:45
#define PG_RE_THROW()
Definition: elog.h:412
#define DEBUG3
Definition: elog.h:28
#define PG_TRY(...)
Definition: elog.h:371
#define PG_END_TRY(...)
Definition: elog.h:396
#define PG_CATCH(...)
Definition: elog.h:381
bool log_executor_stats
Definition: guc_tables.c:504
MemoryContext TopTransactionContext
Definition: mcxt.c:154
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
MemoryContext PortalContext
Definition: mcxt.c:158
@ PORTAL_READY
Definition: portal.h:107
void MarkPortalDone(Portal portal)
Definition: portalmem.c:414
void MarkPortalFailed(Portal portal)
Definition: portalmem.c:442
void MarkPortalActive(Portal portal)
Definition: portalmem.c:395
void ShowUsage(const char *title)
Definition: postgres.c:4984
void ResetUsage(void)
Definition: postgres.c:4977
static void PortalRunMulti(Portal portal, bool isTopLevel, bool setHoldSnapshot, DestReceiver *dest, DestReceiver *altdest, QueryCompletion *qc)
Definition: pquery.c:1184
static void FillPortalStore(Portal portal, bool isTopLevel)
Definition: pquery.c:994
static uint64 PortalRunSelect(Portal portal, bool forward, long count, DestReceiver *dest)
Definition: pquery.c:863
MemoryContextSwitchTo(old_ctx)
ResourceOwner TopTransactionResourceOwner
Definition: resowner.c:167
ResourceOwner CurrentResourceOwner
Definition: resowner.c:165
bool atEnd
Definition: portal.h:199
ResourceOwner resowner
Definition: portal.h:121
QueryCompletion qc
Definition: portal.h:138
MemoryContext portalContext
Definition: portal.h:120
Tuplestorestate * holdStore
Definition: portal.h:176
PortalStatus status
Definition: portal.h:150
uint64 nprocessed
Definition: cmdtag.h:32
CommandTag commandTag
Definition: cmdtag.h:31

References ActivePortal, Assert, PortalData::atEnd, QueryCompletion::commandTag, CopyQueryCompletion(), CurrentMemoryContext, CurrentResourceOwner, DEBUG3, generate_unaccent_rules::dest, elog, ERROR, FillPortalStore(), PortalData::holdStore, InitializeQueryCompletion(), log_executor_stats, MarkPortalActive(), MarkPortalDone(), MarkPortalFailed(), MemoryContextSwitchTo(), QueryCompletion::nprocessed, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PORTAL_MULTI_QUERY, PORTAL_ONE_MOD_WITH, PORTAL_ONE_RETURNING, PORTAL_ONE_SELECT, PORTAL_READY, PORTAL_UTIL_SELECT, PortalContext, PortalData::portalContext, PortalIsValid, PortalRunMulti(), PortalRunSelect(), PortalData::qc, ResetUsage(), PortalData::resowner, ShowUsage(), PortalData::status, PortalData::strategy, TopTransactionContext, and TopTransactionResourceOwner.

Referenced by exec_execute_message(), exec_simple_query(), and ExecuteQuery().

◆ PortalRunFetch()

uint64 PortalRunFetch ( Portal  portal,
FetchDirection  fdirection,
long  count,
DestReceiver dest 
)

Definition at line 1385 of file pquery.c.

1389{
1390 uint64 result;
1391 Portal saveActivePortal;
1392 ResourceOwner saveResourceOwner;
1393 MemoryContext savePortalContext;
1394 MemoryContext oldContext;
1395
1396 Assert(PortalIsValid(portal));
1397
1398 /*
1399 * Check for improper portal use, and mark portal active.
1400 */
1401 MarkPortalActive(portal);
1402
1403 /*
1404 * Set up global portal context pointers.
1405 */
1406 saveActivePortal = ActivePortal;
1407 saveResourceOwner = CurrentResourceOwner;
1408 savePortalContext = PortalContext;
1409 PG_TRY();
1410 {
1411 ActivePortal = portal;
1412 if (portal->resowner)
1414 PortalContext = portal->portalContext;
1415
1417
1418 switch (portal->strategy)
1419 {
1420 case PORTAL_ONE_SELECT:
1421 result = DoPortalRunFetch(portal, fdirection, count, dest);
1422 break;
1423
1426 case PORTAL_UTIL_SELECT:
1427
1428 /*
1429 * If we have not yet run the command, do so, storing its
1430 * results in the portal's tuplestore.
1431 */
1432 if (!portal->holdStore)
1433 FillPortalStore(portal, false /* isTopLevel */ );
1434
1435 /*
1436 * Now fetch desired portion of results.
1437 */
1438 result = DoPortalRunFetch(portal, fdirection, count, dest);
1439 break;
1440
1441 default:
1442 elog(ERROR, "unsupported portal strategy");
1443 result = 0; /* keep compiler quiet */
1444 break;
1445 }
1446 }
1447 PG_CATCH();
1448 {
1449 /* Uncaught error while executing portal: mark it dead */
1450 MarkPortalFailed(portal);
1451
1452 /* Restore global vars and propagate error */
1453 ActivePortal = saveActivePortal;
1454 CurrentResourceOwner = saveResourceOwner;
1455 PortalContext = savePortalContext;
1456
1457 PG_RE_THROW();
1458 }
1459 PG_END_TRY();
1460
1461 MemoryContextSwitchTo(oldContext);
1462
1463 /* Mark portal not active */
1464 portal->status = PORTAL_READY;
1465
1466 ActivePortal = saveActivePortal;
1467 CurrentResourceOwner = saveResourceOwner;
1468 PortalContext = savePortalContext;
1469
1470 return result;
1471}
static uint64 DoPortalRunFetch(Portal portal, FetchDirection fdirection, long count, DestReceiver *dest)
Definition: pquery.c:1483

References ActivePortal, Assert, CurrentResourceOwner, generate_unaccent_rules::dest, DoPortalRunFetch(), elog, ERROR, FillPortalStore(), PortalData::holdStore, MarkPortalActive(), MarkPortalFailed(), MemoryContextSwitchTo(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PORTAL_ONE_MOD_WITH, PORTAL_ONE_RETURNING, PORTAL_ONE_SELECT, PORTAL_READY, PORTAL_UTIL_SELECT, PortalContext, PortalData::portalContext, PortalIsValid, PortalData::resowner, PortalData::status, and PortalData::strategy.

Referenced by _SPI_cursor_operation(), and PerformPortalFetch().

◆ PortalSetResultFormat()

void PortalSetResultFormat ( Portal  portal,
int  nFormats,
int16 formats 
)

Definition at line 623 of file pquery.c.

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)
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}
int16_t int16
Definition: c.h:480
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ereport(elevel,...)
Definition: elog.h:149
int i
Definition: isn.c:72
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1181
int16 * formats
Definition: portal.h:161
TupleDesc tupDesc
Definition: portal.h:159

References ereport, errcode(), errmsg(), ERROR, PortalData::formats, i, MemoryContextAlloc(), TupleDescData::natts, PortalData::portalContext, and PortalData::tupDesc.

Referenced by exec_bind_message(), and exec_simple_query().

◆ PortalStart()

void PortalStart ( Portal  portal,
ParamListInfo  params,
int  eflags,
Snapshot  snapshot 
)

Definition at line 433 of file pquery.c.

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)
458
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 {
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
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
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);
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
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}
DestReceiver * None_Receiver
Definition: dest.c:96
void ExecutorStart(QueryDesc *queryDesc, int eflags)
Definition: execMain.c:119
TupleDesc ExecCleanTypeFromTL(List *targetList)
Definition: execTuples.c:2137
#define EXEC_FLAG_BACKWARD
Definition: executor.h:68
#define EXEC_FLAG_REWIND
Definition: executor.h:67
#define CURSOR_OPT_SCROLL
Definition: parsenodes.h:3308
#define linitial_node(type, l)
Definition: pg_list.h:181
@ PORTAL_DEFINED
Definition: portal.h:106
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
PortalStrategy ChoosePortalStrategy(List *stmts)
Definition: pquery.c:209
void PushActiveSnapshot(Snapshot snapshot)
Definition: snapmgr.c:610
void PopActiveSnapshot(void)
Definition: snapmgr.c:703
#define InvalidSnapshot
Definition: snapshot.h:119
uint64 portalPos
Definition: portal.h:200
QueryDesc * queryDesc
Definition: portal.h:156
const char * sourceText
Definition: portal.h:136
bool atStart
Definition: portal.h:198
List * stmts
Definition: portal.h:139
QueryEnvironment * queryEnv
Definition: portal.h:143
ParamListInfo portalParams
Definition: portal.h:142
int cursorOptions
Definition: portal.h:147
TupleDesc tupDesc
Definition: execdesc.h:47
TupleDesc UtilityTupleDescriptor(Node *parsetree)
Definition: utility.c:2084

References ActivePortal, Assert, PortalData::atEnd, PortalData::atStart, ChoosePortalStrategy(), CMD_UTILITY, PlannedStmt::commandType, CreateQueryDesc(), CurrentResourceOwner, CURSOR_OPT_SCROLL, PortalData::cursorOptions, EXEC_FLAG_BACKWARD, EXEC_FLAG_REWIND, ExecCleanTypeFromTL(), ExecutorStart(), GetActiveSnapshot(), GetTransactionSnapshot(), InvalidSnapshot, linitial_node, MarkPortalFailed(), MemoryContextSwitchTo(), None_Receiver, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PlannedStmt::planTree, PopActiveSnapshot(), PORTAL_DEFINED, PORTAL_MULTI_QUERY, PORTAL_ONE_MOD_WITH, PORTAL_ONE_RETURNING, PORTAL_ONE_SELECT, PORTAL_READY, PORTAL_UTIL_SELECT, PortalContext, PortalData::portalContext, PortalGetPrimaryStmt(), PortalIsValid, PortalData::portalParams, PortalData::portalPos, PushActiveSnapshot(), PortalData::queryDesc, PortalData::queryEnv, PortalData::resowner, PortalData::sourceText, PortalData::status, PortalData::stmts, PortalData::strategy, Plan::targetlist, QueryDesc::tupDesc, PortalData::tupDesc, PlannedStmt::utilityStmt, and UtilityTupleDescriptor().

Referenced by exec_bind_message(), exec_simple_query(), ExecuteQuery(), PerformCursorOpen(), and SPI_cursor_open_internal().

Variable Documentation

◆ ActivePortal