PostgreSQL Source Code git master
pquery.c File Reference
#include "postgres.h"
#include <limits.h>
#include "access/xact.h"
#include "commands/prepare.h"
#include "executor/executor.h"
#include "executor/tstoreReceiver.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "tcop/pquery.h"
#include "tcop/utility.h"
#include "utils/memutils.h"
#include "utils/snapmgr.h"
Include dependency graph for pquery.c:

Go to the source code of this file.

Functions

static void ProcessQuery (PlannedStmt *plan, const char *sourceText, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
 
static void FillPortalStore (Portal portal, bool isTopLevel)
 
static uint64 RunFromStore (Portal portal, ScanDirection direction, uint64 count, DestReceiver *dest)
 
static uint64 PortalRunSelect (Portal portal, bool forward, long count, DestReceiver *dest)
 
static void PortalRunUtility (Portal portal, PlannedStmt *pstmt, bool isTopLevel, bool setHoldSnapshot, DestReceiver *dest, QueryCompletion *qc)
 
static void PortalRunMulti (Portal portal, bool isTopLevel, bool setHoldSnapshot, DestReceiver *dest, DestReceiver *altdest, QueryCompletion *qc)
 
static uint64 DoPortalRunFetch (Portal portal, FetchDirection fdirection, long count, DestReceiver *dest)
 
static void DoPortalRewind (Portal portal)
 
QueryDescCreateQueryDesc (PlannedStmt *plannedstmt, const char *sourceText, Snapshot snapshot, Snapshot crosscheck_snapshot, DestReceiver *dest, ParamListInfo params, QueryEnvironment *queryEnv, int instrument_options)
 
void FreeQueryDesc (QueryDesc *qdesc)
 
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 (PlannedStmt *pstmt)
 
void EnsurePortalSnapshotExists (void)
 

Variables

Portal ActivePortal = NULL
 

Function Documentation

◆ ChoosePortalStrategy()

PortalStrategy ChoosePortalStrategy ( List stmts)

Definition at line 210 of file pquery.c.

211{
212 int nSetTag;
213 ListCell *lc;
214
215 /*
216 * PORTAL_ONE_SELECT and PORTAL_UTIL_SELECT need only consider the
217 * single-statement case, since there are no rewrite rules that can add
218 * auxiliary queries to a SELECT or a utility command. PORTAL_ONE_MOD_WITH
219 * likewise allows only one top-level statement.
220 */
221 if (list_length(stmts) == 1)
222 {
223 Node *stmt = (Node *) linitial(stmts);
224
225 if (IsA(stmt, Query))
226 {
227 Query *query = (Query *) stmt;
228
229 if (query->canSetTag)
230 {
231 if (query->commandType == CMD_SELECT)
232 {
233 if (query->hasModifyingCTE)
234 return PORTAL_ONE_MOD_WITH;
235 else
236 return PORTAL_ONE_SELECT;
237 }
238 if (query->commandType == CMD_UTILITY)
239 {
241 return PORTAL_UTIL_SELECT;
242 /* it can't be ONE_RETURNING, so give up */
243 return PORTAL_MULTI_QUERY;
244 }
245 }
246 }
247 else if (IsA(stmt, PlannedStmt))
248 {
249 PlannedStmt *pstmt = (PlannedStmt *) stmt;
250
251 if (pstmt->canSetTag)
252 {
253 if (pstmt->commandType == CMD_SELECT)
254 {
255 if (pstmt->hasModifyingCTE)
256 return PORTAL_ONE_MOD_WITH;
257 else
258 return PORTAL_ONE_SELECT;
259 }
260 if (pstmt->commandType == CMD_UTILITY)
261 {
263 return PORTAL_UTIL_SELECT;
264 /* it can't be ONE_RETURNING, so give up */
265 return PORTAL_MULTI_QUERY;
266 }
267 }
268 }
269 else
270 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(stmt));
271 }
272
273 /*
274 * PORTAL_ONE_RETURNING has to allow auxiliary queries added by rewrite.
275 * Choose PORTAL_ONE_RETURNING if there is exactly one canSetTag query and
276 * it has a RETURNING list.
277 */
278 nSetTag = 0;
279 foreach(lc, stmts)
280 {
281 Node *stmt = (Node *) lfirst(lc);
282
283 if (IsA(stmt, Query))
284 {
285 Query *query = (Query *) stmt;
286
287 if (query->canSetTag)
288 {
289 if (++nSetTag > 1)
290 return PORTAL_MULTI_QUERY; /* no need to look further */
291 if (query->commandType == CMD_UTILITY ||
292 query->returningList == NIL)
293 return PORTAL_MULTI_QUERY; /* no need to look further */
294 }
295 }
296 else if (IsA(stmt, PlannedStmt))
297 {
298 PlannedStmt *pstmt = (PlannedStmt *) stmt;
299
300 if (pstmt->canSetTag)
301 {
302 if (++nSetTag > 1)
303 return PORTAL_MULTI_QUERY; /* no need to look further */
304 if (pstmt->commandType == CMD_UTILITY ||
305 !pstmt->hasReturning)
306 return PORTAL_MULTI_QUERY; /* no need to look further */
307 }
308 }
309 else
310 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(stmt));
311 }
312 if (nSetTag == 1)
314
315 /* Else, it's the general case... */
316 return PORTAL_MULTI_QUERY;
317}
#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:164
#define nodeTag(nodeptr)
Definition: nodes.h:139
@ CMD_UTILITY
Definition: nodes.h:276
@ CMD_SELECT
Definition: nodes.h:271
#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:135
bool hasModifyingCTE
Definition: plannodes.h:65
bool canSetTag
Definition: plannodes.h:68
bool hasReturning
Definition: plannodes.h:62
CmdType commandType
Definition: plannodes.h:53
Node * utilityStmt
Definition: plannodes.h:132
List * returningList
Definition: parsenodes.h:209
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().

◆ CreateQueryDesc()

QueryDesc * CreateQueryDesc ( PlannedStmt plannedstmt,
const char *  sourceText,
Snapshot  snapshot,
Snapshot  crosscheck_snapshot,
DestReceiver dest,
ParamListInfo  params,
QueryEnvironment queryEnv,
int  instrument_options 
)

Definition at line 68 of file pquery.c.

76{
77 QueryDesc *qd = (QueryDesc *) palloc(sizeof(QueryDesc));
78
79 qd->operation = plannedstmt->commandType; /* operation */
80 qd->plannedstmt = plannedstmt; /* plan */
81 qd->sourceText = sourceText; /* query text */
82 qd->snapshot = RegisterSnapshot(snapshot); /* snapshot */
83 /* RI check snapshot */
84 qd->crosscheck_snapshot = RegisterSnapshot(crosscheck_snapshot);
85 qd->dest = dest; /* output dest */
86 qd->params = params; /* parameter values passed into query */
87 qd->queryEnv = queryEnv;
88 qd->instrument_options = instrument_options; /* instrumentation wanted? */
89
90 /* null these fields until set by ExecutorStart */
91 qd->tupDesc = NULL;
92 qd->estate = NULL;
93 qd->planstate = NULL;
94 qd->totaltime = NULL;
95
96 /* not yet executed */
97 qd->already_executed = false;
98
99 return qd;
100}
void * palloc(Size size)
Definition: mcxt.c:1321
Snapshot RegisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:811
const char * sourceText
Definition: execdesc.h:38
ParamListInfo params
Definition: execdesc.h:42
DestReceiver * dest
Definition: execdesc.h:41
int instrument_options
Definition: execdesc.h:44
EState * estate
Definition: execdesc.h:48
CmdType operation
Definition: execdesc.h:36
Snapshot snapshot
Definition: execdesc.h:39
bool already_executed
Definition: execdesc.h:52
PlannedStmt * plannedstmt
Definition: execdesc.h:37
struct Instrumentation * totaltime
Definition: execdesc.h:55
QueryEnvironment * queryEnv
Definition: execdesc.h:43
TupleDesc tupDesc
Definition: execdesc.h:47
Snapshot crosscheck_snapshot
Definition: execdesc.h:40
PlanState * planstate
Definition: execdesc.h:49

References QueryDesc::already_executed, PlannedStmt::commandType, QueryDesc::crosscheck_snapshot, generate_unaccent_rules::dest, QueryDesc::dest, QueryDesc::estate, QueryDesc::instrument_options, QueryDesc::operation, palloc(), QueryDesc::params, QueryDesc::plannedstmt, QueryDesc::planstate, QueryDesc::queryEnv, RegisterSnapshot(), QueryDesc::snapshot, QueryDesc::sourceText, QueryDesc::totaltime, and QueryDesc::tupDesc.

Referenced by _SPI_execute_plan(), BeginCopyTo(), ExecCreateTableAs(), ExecParallelGetQueryDesc(), execute_sql_string(), ExplainOnePlan(), PortalStart(), postquel_start(), ProcessQuery(), and refresh_matview_datafill().

◆ DoPortalRewind()

static void DoPortalRewind ( Portal  portal)
static

Definition at line 1678 of file pquery.c.

1679{
1680 QueryDesc *queryDesc;
1681
1682 /*
1683 * No work is needed if we've not advanced nor attempted to advance the
1684 * cursor (and we don't want to throw a NO SCROLL error in this case).
1685 */
1686 if (portal->atStart && !portal->atEnd)
1687 return;
1688
1689 /* Otherwise, cursor must allow scrolling */
1690 if (portal->cursorOptions & CURSOR_OPT_NO_SCROLL)
1691 ereport(ERROR,
1692 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1693 errmsg("cursor can only scan forward"),
1694 errhint("Declare it with SCROLL option to enable backward scan.")));
1695
1696 /* Rewind holdStore, if we have one */
1697 if (portal->holdStore)
1698 {
1699 MemoryContext oldcontext;
1700
1701 oldcontext = MemoryContextSwitchTo(portal->holdContext);
1703 MemoryContextSwitchTo(oldcontext);
1704 }
1705
1706 /* Rewind executor, if active */
1707 queryDesc = portal->queryDesc;
1708 if (queryDesc)
1709 {
1710 PushActiveSnapshot(queryDesc->snapshot);
1711 ExecutorRewind(queryDesc);
1713 }
1714
1715 portal->atStart = true;
1716 portal->atEnd = false;
1717 portal->portalPos = 0;
1718}
int errhint(const char *fmt,...)
Definition: elog.c:1318
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ereport(elevel,...)
Definition: elog.h:149
void ExecutorRewind(QueryDesc *queryDesc)
Definition: execMain.c:537
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
#define CURSOR_OPT_NO_SCROLL
Definition: parsenodes.h:3377
void PushActiveSnapshot(Snapshot snapshot)
Definition: snapmgr.c:669
void PopActiveSnapshot(void)
Definition: snapmgr.c:762
uint64 portalPos
Definition: portal.h:200
QueryDesc * queryDesc
Definition: portal.h:156
bool atEnd
Definition: portal.h:199
bool atStart
Definition: portal.h:198
MemoryContext holdContext
Definition: portal.h:177
Tuplestorestate * holdStore
Definition: portal.h:176
int cursorOptions
Definition: portal.h:147
void tuplestore_rescan(Tuplestorestate *state)
Definition: tuplestore.c:1285

References PortalData::atEnd, PortalData::atStart, CURSOR_OPT_NO_SCROLL, PortalData::cursorOptions, ereport, errcode(), errhint(), errmsg(), ERROR, ExecutorRewind(), PortalData::holdContext, PortalData::holdStore, MemoryContextSwitchTo(), PopActiveSnapshot(), PortalData::portalPos, PushActiveSnapshot(), PortalData::queryDesc, QueryDesc::snapshot, and tuplestore_rescan().

Referenced by DoPortalRunFetch().

◆ DoPortalRunFetch()

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

Definition at line 1484 of file pquery.c.

1488{
1489 bool forward;
1490
1491 Assert(portal->strategy == PORTAL_ONE_SELECT ||
1492 portal->strategy == PORTAL_ONE_RETURNING ||
1493 portal->strategy == PORTAL_ONE_MOD_WITH ||
1494 portal->strategy == PORTAL_UTIL_SELECT);
1495
1496 /*
1497 * Note: we disallow backwards fetch (including re-fetch of current row)
1498 * for NO SCROLL cursors, but we interpret that very loosely: you can use
1499 * any of the FetchDirection options, so long as the end result is to move
1500 * forwards by at least one row. Currently it's sufficient to check for
1501 * NO SCROLL in DoPortalRewind() and in the forward == false path in
1502 * PortalRunSelect(); but someday we might prefer to account for that
1503 * restriction explicitly here.
1504 */
1505 switch (fdirection)
1506 {
1507 case FETCH_FORWARD:
1508 if (count < 0)
1509 {
1510 fdirection = FETCH_BACKWARD;
1511 count = -count;
1512 }
1513 /* fall out of switch to share code with FETCH_BACKWARD */
1514 break;
1515 case FETCH_BACKWARD:
1516 if (count < 0)
1517 {
1518 fdirection = FETCH_FORWARD;
1519 count = -count;
1520 }
1521 /* fall out of switch to share code with FETCH_FORWARD */
1522 break;
1523 case FETCH_ABSOLUTE:
1524 if (count > 0)
1525 {
1526 /*
1527 * Definition: Rewind to start, advance count-1 rows, return
1528 * next row (if any).
1529 *
1530 * In practice, if the goal is less than halfway back to the
1531 * start, it's better to scan from where we are.
1532 *
1533 * Also, if current portalPos is outside the range of "long",
1534 * do it the hard way to avoid possible overflow of the count
1535 * argument to PortalRunSelect. We must exclude exactly
1536 * LONG_MAX, as well, lest the count look like FETCH_ALL.
1537 *
1538 * In any case, we arrange to fetch the target row going
1539 * forwards.
1540 */
1541 if ((uint64) (count - 1) <= portal->portalPos / 2 ||
1542 portal->portalPos >= (uint64) LONG_MAX)
1543 {
1544 DoPortalRewind(portal);
1545 if (count > 1)
1546 PortalRunSelect(portal, true, count - 1,
1548 }
1549 else
1550 {
1551 long pos = (long) portal->portalPos;
1552
1553 if (portal->atEnd)
1554 pos++; /* need one extra fetch if off end */
1555 if (count <= pos)
1556 PortalRunSelect(portal, false, pos - count + 1,
1558 else if (count > pos + 1)
1559 PortalRunSelect(portal, true, count - pos - 1,
1561 }
1562 return PortalRunSelect(portal, true, 1L, dest);
1563 }
1564 else if (count < 0)
1565 {
1566 /*
1567 * Definition: Advance to end, back up abs(count)-1 rows,
1568 * return prior row (if any). We could optimize this if we
1569 * knew in advance where the end was, but typically we won't.
1570 * (Is it worth considering case where count > half of size of
1571 * query? We could rewind once we know the size ...)
1572 */
1573 PortalRunSelect(portal, true, FETCH_ALL, None_Receiver);
1574 if (count < -1)
1575 PortalRunSelect(portal, false, -count - 1, None_Receiver);
1576 return PortalRunSelect(portal, false, 1L, dest);
1577 }
1578 else
1579 {
1580 /* count == 0 */
1581 /* Rewind to start, return zero rows */
1582 DoPortalRewind(portal);
1583 return PortalRunSelect(portal, true, 0L, dest);
1584 }
1585 break;
1586 case FETCH_RELATIVE:
1587 if (count > 0)
1588 {
1589 /*
1590 * Definition: advance count-1 rows, return next row (if any).
1591 */
1592 if (count > 1)
1593 PortalRunSelect(portal, true, count - 1, None_Receiver);
1594 return PortalRunSelect(portal, true, 1L, dest);
1595 }
1596 else if (count < 0)
1597 {
1598 /*
1599 * Definition: back up abs(count)-1 rows, return prior row (if
1600 * any).
1601 */
1602 if (count < -1)
1603 PortalRunSelect(portal, false, -count - 1, None_Receiver);
1604 return PortalRunSelect(portal, false, 1L, dest);
1605 }
1606 else
1607 {
1608 /* count == 0 */
1609 /* Same as FETCH FORWARD 0, so fall out of switch */
1610 fdirection = FETCH_FORWARD;
1611 }
1612 break;
1613 default:
1614 elog(ERROR, "bogus direction");
1615 break;
1616 }
1617
1618 /*
1619 * Get here with fdirection == FETCH_FORWARD or FETCH_BACKWARD, and count
1620 * >= 0.
1621 */
1622 forward = (fdirection == FETCH_FORWARD);
1623
1624 /*
1625 * Zero count means to re-fetch the current row, if any (per SQL)
1626 */
1627 if (count == 0)
1628 {
1629 bool on_row;
1630
1631 /* Are we sitting on a row? */
1632 on_row = (!portal->atStart && !portal->atEnd);
1633
1634 if (dest->mydest == DestNone)
1635 {
1636 /* MOVE 0 returns 0/1 based on if FETCH 0 would return a row */
1637 return on_row ? 1 : 0;
1638 }
1639 else
1640 {
1641 /*
1642 * If we are sitting on a row, back up one so we can re-fetch it.
1643 * If we are not sitting on a row, we still have to start up and
1644 * shut down the executor so that the destination is initialized
1645 * and shut down correctly; so keep going. To PortalRunSelect,
1646 * count == 0 means we will retrieve no row.
1647 */
1648 if (on_row)
1649 {
1650 PortalRunSelect(portal, false, 1L, None_Receiver);
1651 /* Set up to fetch one row forward */
1652 count = 1;
1653 forward = true;
1654 }
1655 }
1656 }
1657
1658 /*
1659 * Optimize MOVE BACKWARD ALL into a Rewind.
1660 */
1661 if (!forward && count == FETCH_ALL && dest->mydest == DestNone)
1662 {
1663 uint64 result = portal->portalPos;
1664
1665 if (result > 0 && !portal->atEnd)
1666 result--;
1667 DoPortalRewind(portal);
1668 return result;
1669 }
1670
1671 return PortalRunSelect(portal, forward, count, dest);
1672}
uint64_t uint64
Definition: c.h:503
DestReceiver * None_Receiver
Definition: dest.c:96
@ DestNone
Definition: dest.h:87
Assert(PointerIsAligned(start, uint64))
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81
#define FETCH_ALL
Definition: parsenodes.h:3420
@ FETCH_RELATIVE
Definition: parsenodes.h:3417
@ FETCH_ABSOLUTE
Definition: parsenodes.h:3416
@ FETCH_FORWARD
Definition: parsenodes.h:3413
@ FETCH_BACKWARD
Definition: parsenodes.h:3414
static uint64 PortalRunSelect(Portal portal, bool forward, long count, DestReceiver *dest)
Definition: pquery.c:864
static void DoPortalRewind(Portal portal)
Definition: pquery.c:1678
PortalStrategy strategy
Definition: portal.h:146

References Assert(), PortalData::atEnd, PortalData::atStart, generate_unaccent_rules::dest, DestNone, DoPortalRewind(), elog, ERROR, FETCH_ABSOLUTE, FETCH_ALL, FETCH_BACKWARD, FETCH_FORWARD, FETCH_RELATIVE, if(), None_Receiver, PORTAL_ONE_MOD_WITH, PORTAL_ONE_RETURNING, PORTAL_ONE_SELECT, PORTAL_UTIL_SELECT, PortalData::portalPos, PortalRunSelect(), and PortalData::strategy.

Referenced by PortalRunFetch().

◆ EnsurePortalSnapshotExists()

void EnsurePortalSnapshotExists ( void  )

Definition at line 1772 of file pquery.c.

1773{
1774 Portal portal;
1775
1776 /*
1777 * Nothing to do if a snapshot is set. (We take it on faith that the
1778 * outermost active snapshot belongs to some Portal; or if there is no
1779 * Portal, it's somebody else's responsibility to manage things.)
1780 */
1781 if (ActiveSnapshotSet())
1782 return;
1783
1784 /* Otherwise, we'd better have an active Portal */
1785 portal = ActivePortal;
1786 if (unlikely(portal == NULL))
1787 elog(ERROR, "cannot execute SQL without an outer snapshot or portal");
1788 Assert(portal->portalSnapshot == NULL);
1789
1790 /*
1791 * Create a new snapshot, make it active, and remember it in portal.
1792 * Because the portal now references the snapshot, we must tell snapmgr.c
1793 * that the snapshot belongs to the portal's transaction level, else we
1794 * risk portalSnapshot becoming a dangling pointer.
1795 */
1797 /* PushActiveSnapshotWithLevel might have copied the snapshot */
1799}
#define unlikely(x)
Definition: c.h:347
Portal ActivePortal
Definition: pquery.c:36
Snapshot GetTransactionSnapshot(void)
Definition: snapmgr.c:271
bool ActiveSnapshotSet(void)
Definition: snapmgr.c:799
void PushActiveSnapshotWithLevel(Snapshot snapshot, int snap_level)
Definition: snapmgr.c:683
Snapshot GetActiveSnapshot(void)
Definition: snapmgr.c:787
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 327 of file pquery.c.

328{
329 /* no point in looking if we determined it doesn't return tuples */
330 if (portal->strategy == PORTAL_MULTI_QUERY)
331 return NIL;
332 /* get the primary statement and find out what it returns */
334}
PlannedStmt * PortalGetPrimaryStmt(Portal portal)
Definition: portalmem.c:151
List * FetchStatementTargetList(Node *stmt)
Definition: pquery.c:349

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 349 of file pquery.c.

350{
351 if (stmt == NULL)
352 return NIL;
353 if (IsA(stmt, Query))
354 {
355 Query *query = (Query *) stmt;
356
357 if (query->commandType == CMD_UTILITY)
358 {
359 /* transfer attention to utility statement */
360 stmt = query->utilityStmt;
361 }
362 else
363 {
364 if (query->commandType == CMD_SELECT)
365 return query->targetList;
366 if (query->returningList)
367 return query->returningList;
368 return NIL;
369 }
370 }
371 if (IsA(stmt, PlannedStmt))
372 {
373 PlannedStmt *pstmt = (PlannedStmt *) stmt;
374
375 if (pstmt->commandType == CMD_UTILITY)
376 {
377 /* transfer attention to utility statement */
378 stmt = pstmt->utilityStmt;
379 }
380 else
381 {
382 if (pstmt->commandType == CMD_SELECT)
383 return pstmt->planTree->targetlist;
384 if (pstmt->hasReturning)
385 return pstmt->planTree->targetlist;
386 return NIL;
387 }
388 }
389 if (IsA(stmt, FetchStmt))
390 {
391 FetchStmt *fstmt = (FetchStmt *) stmt;
392 Portal subportal;
393
394 Assert(!fstmt->ismove);
395 subportal = GetPortalByName(fstmt->portalname);
396 Assert(PortalIsValid(subportal));
397 return FetchPortalTargetList(subportal);
398 }
399 if (IsA(stmt, ExecuteStmt))
400 {
401 ExecuteStmt *estmt = (ExecuteStmt *) stmt;
402 PreparedStatement *entry;
403
404 entry = FetchPreparedStatement(estmt->name, true);
406 }
407 return NIL;
408}
PreparedStatement * FetchPreparedStatement(const char *stmt_name, bool throwError)
Definition: prepare.c:434
List * FetchPreparedStatementTargetList(PreparedStatement *stmt)
Definition: prepare.c:489
#define PortalIsValid(p)
Definition: portal.h:211
Portal GetPortalByName(const char *name)
Definition: portalmem.c:130
List * FetchPortalTargetList(Portal portal)
Definition: pquery.c:327
char * name
Definition: parsenodes.h:4143
bool ismove
Definition: parsenodes.h:3428
char * portalname
Definition: parsenodes.h:3427
List * targetlist
Definition: plannodes.h:202
struct Plan * planTree
Definition: plannodes.h:83
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().

◆ FillPortalStore()

static void FillPortalStore ( Portal  portal,
bool  isTopLevel 
)
static

Definition at line 995 of file pquery.c.

996{
997 DestReceiver *treceiver;
999
1001 PortalCreateHoldStore(portal);
1004 portal->holdStore,
1005 portal->holdContext,
1006 false,
1007 NULL,
1008 NULL);
1009
1010 switch (portal->strategy)
1011 {
1014
1015 /*
1016 * Run the portal to completion just as for the default
1017 * PORTAL_MULTI_QUERY case, but send the primary query's output to
1018 * the tuplestore. Auxiliary query outputs are discarded. Set the
1019 * portal's holdSnapshot to the snapshot used (or a copy of it).
1020 */
1021 PortalRunMulti(portal, isTopLevel, true,
1022 treceiver, None_Receiver, &qc);
1023 break;
1024
1025 case PORTAL_UTIL_SELECT:
1027 isTopLevel, true, treceiver, &qc);
1028 break;
1029
1030 default:
1031 elog(ERROR, "unsupported portal strategy: %d",
1032 (int) portal->strategy);
1033 break;
1034 }
1035
1036 /* Override portal completion data with actual command results */
1037 if (qc.commandTag != CMDTAG_UNKNOWN)
1038 CopyQueryCompletion(&portal->qc, &qc);
1039
1040 treceiver->rDestroy(treceiver);
1041}
void InitializeQueryCompletion(QueryCompletion *qc)
Definition: cmdtag.c:40
static void CopyQueryCompletion(QueryCompletion *dst, const QueryCompletion *src)
Definition: cmdtag.h:45
DestReceiver * CreateDestReceiver(CommandDest dest)
Definition: dest.c:113
@ DestTuplestore
Definition: dest.h:93
#define linitial_node(type, l)
Definition: pg_list.h:181
void PortalCreateHoldStore(Portal portal)
Definition: portalmem.c:331
static void PortalRunMulti(Portal portal, bool isTopLevel, bool setHoldSnapshot, DestReceiver *dest, DestReceiver *altdest, QueryCompletion *qc)
Definition: pquery.c:1185
static void PortalRunUtility(Portal portal, PlannedStmt *pstmt, bool isTopLevel, bool setHoldSnapshot, DestReceiver *dest, QueryCompletion *qc)
Definition: pquery.c:1122
List * stmts
Definition: portal.h:139
QueryCompletion qc
Definition: portal.h:138
CommandTag commandTag
Definition: cmdtag.h:31
void(* rDestroy)(DestReceiver *self)
Definition: dest.h:126
void SetTuplestoreDestReceiverParams(DestReceiver *self, Tuplestorestate *tStore, MemoryContext tContext, bool detoast, TupleDesc target_tupdesc, const char *map_failure_msg)

References QueryCompletion::commandTag, CopyQueryCompletion(), CreateDestReceiver(), DestTuplestore, elog, ERROR, PortalData::holdContext, PortalData::holdStore, InitializeQueryCompletion(), linitial_node, None_Receiver, PORTAL_ONE_MOD_WITH, PORTAL_ONE_RETURNING, PORTAL_UTIL_SELECT, PortalCreateHoldStore(), PortalRunMulti(), PortalRunUtility(), PortalData::qc, _DestReceiver::rDestroy, SetTuplestoreDestReceiverParams(), PortalData::stmts, and PortalData::strategy.

Referenced by PortalRun(), and PortalRunFetch().

◆ FreeQueryDesc()

void FreeQueryDesc ( QueryDesc qdesc)

Definition at line 106 of file pquery.c.

107{
108 /* Can't be a live query */
109 Assert(qdesc->estate == NULL);
110
111 /* forget our snapshots */
114
115 /* Only the QueryDesc itself need be freed */
116 pfree(qdesc);
117}
void pfree(void *pointer)
Definition: mcxt.c:1528
void UnregisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:853

References Assert(), QueryDesc::crosscheck_snapshot, QueryDesc::estate, pfree(), QueryDesc::snapshot, and UnregisterSnapshot().

Referenced by _SPI_execute_plan(), EndCopyTo(), ExecCreateTableAs(), execute_sql_string(), ExplainOnePlan(), ParallelQueryMain(), PersistHoldablePortal(), PortalCleanup(), postquel_end(), ProcessQuery(), and refresh_matview_datafill().

◆ PlannedStmtRequiresSnapshot()

bool PlannedStmtRequiresSnapshot ( PlannedStmt pstmt)

Definition at line 1724 of file pquery.c.

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

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 685 of file pquery.c.

688{
689 bool result;
690 uint64 nprocessed;
691 ResourceOwner saveTopTransactionResourceOwner;
692 MemoryContext saveTopTransactionContext;
693 Portal saveActivePortal;
694 ResourceOwner saveResourceOwner;
695 MemoryContext savePortalContext;
696 MemoryContext saveMemoryContext;
697
698 Assert(PortalIsValid(portal));
699
700 TRACE_POSTGRESQL_QUERY_EXECUTE_START();
701
702 /* Initialize empty completion data */
703 if (qc)
705
707 {
708 elog(DEBUG3, "PortalRun");
709 /* PORTAL_MULTI_QUERY logs its own stats per query */
710 ResetUsage();
711 }
712
713 /*
714 * Check for improper portal use, and mark portal active.
715 */
716 MarkPortalActive(portal);
717
718 /*
719 * Set up global portal context pointers.
720 *
721 * We have to play a special game here to support utility commands like
722 * VACUUM and CLUSTER, which internally start and commit transactions.
723 * When we are called to execute such a command, CurrentResourceOwner will
724 * be pointing to the TopTransactionResourceOwner --- which will be
725 * destroyed and replaced in the course of the internal commit and
726 * restart. So we need to be prepared to restore it as pointing to the
727 * exit-time TopTransactionResourceOwner. (Ain't that ugly? This idea of
728 * internally starting whole new transactions is not good.)
729 * CurrentMemoryContext has a similar problem, but the other pointers we
730 * save here will be NULL or pointing to longer-lived objects.
731 */
732 saveTopTransactionResourceOwner = TopTransactionResourceOwner;
733 saveTopTransactionContext = TopTransactionContext;
734 saveActivePortal = ActivePortal;
735 saveResourceOwner = CurrentResourceOwner;
736 savePortalContext = PortalContext;
737 saveMemoryContext = CurrentMemoryContext;
738 PG_TRY();
739 {
740 ActivePortal = portal;
741 if (portal->resowner)
744
746
747 switch (portal->strategy)
748 {
753
754 /*
755 * If we have not yet run the command, do so, storing its
756 * results in the portal's tuplestore. But we don't do that
757 * for the PORTAL_ONE_SELECT case.
758 */
759 if (portal->strategy != PORTAL_ONE_SELECT && !portal->holdStore)
760 FillPortalStore(portal, isTopLevel);
761
762 /*
763 * Now fetch desired portion of results.
764 */
765 nprocessed = PortalRunSelect(portal, true, count, dest);
766
767 /*
768 * If the portal result contains a command tag and the caller
769 * gave us a pointer to store it, copy it and update the
770 * rowcount.
771 */
772 if (qc && portal->qc.commandTag != CMDTAG_UNKNOWN)
773 {
774 CopyQueryCompletion(qc, &portal->qc);
775 qc->nprocessed = nprocessed;
776 }
777
778 /* Mark portal not active */
779 portal->status = PORTAL_READY;
780
781 /*
782 * Since it's a forward fetch, say DONE iff atEnd is now true.
783 */
784 result = portal->atEnd;
785 break;
786
788 PortalRunMulti(portal, isTopLevel, false,
789 dest, altdest, qc);
790
791 /* Prevent portal's commands from being re-executed */
792 MarkPortalDone(portal);
793
794 /* Always complete at end of RunMulti */
795 result = true;
796 break;
797
798 default:
799 elog(ERROR, "unrecognized portal strategy: %d",
800 (int) portal->strategy);
801 result = false; /* keep compiler quiet */
802 break;
803 }
804 }
805 PG_CATCH();
806 {
807 /* Uncaught error while executing portal: mark it dead */
808 MarkPortalFailed(portal);
809
810 /* Restore global vars and propagate error */
811 if (saveMemoryContext == saveTopTransactionContext)
813 else
814 MemoryContextSwitchTo(saveMemoryContext);
815 ActivePortal = saveActivePortal;
816 if (saveResourceOwner == saveTopTransactionResourceOwner)
818 else
819 CurrentResourceOwner = saveResourceOwner;
820 PortalContext = savePortalContext;
821
822 PG_RE_THROW();
823 }
824 PG_END_TRY();
825
826 if (saveMemoryContext == saveTopTransactionContext)
828 else
829 MemoryContextSwitchTo(saveMemoryContext);
830 ActivePortal = saveActivePortal;
831 if (saveResourceOwner == saveTopTransactionResourceOwner)
833 else
834 CurrentResourceOwner = saveResourceOwner;
835 PortalContext = savePortalContext;
836
838 ShowUsage("EXECUTOR STATISTICS");
839
840 TRACE_POSTGRESQL_QUERY_EXECUTE_DONE();
841
842 return result;
843}
#define PG_RE_THROW()
Definition: elog.h:404
#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:521
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:5059
void ResetUsage(void)
Definition: postgres.c:5052
static void FillPortalStore(Portal portal, bool isTopLevel)
Definition: pquery.c:995
ResourceOwner TopTransactionResourceOwner
Definition: resowner.c:175
ResourceOwner CurrentResourceOwner
Definition: resowner.c:173
ResourceOwner resowner
Definition: portal.h:121
MemoryContext portalContext
Definition: portal.h:120
PortalStatus status
Definition: portal.h:150
uint64 nprocessed
Definition: cmdtag.h:32

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 1386 of file pquery.c.

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

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().

◆ PortalRunMulti()

static void PortalRunMulti ( Portal  portal,
bool  isTopLevel,
bool  setHoldSnapshot,
DestReceiver dest,
DestReceiver altdest,
QueryCompletion qc 
)
static

Definition at line 1185 of file pquery.c.

1189{
1190 bool active_snapshot_set = false;
1191 ListCell *stmtlist_item;
1192
1193 /*
1194 * If the destination is DestRemoteExecute, change to DestNone. The
1195 * reason is that the client won't be expecting any tuples, and indeed has
1196 * no way to know what they are, since there is no provision for Describe
1197 * to send a RowDescription message when this portal execution strategy is
1198 * in effect. This presently will only affect SELECT commands added to
1199 * non-SELECT queries by rewrite rules: such commands will be executed,
1200 * but the results will be discarded unless you use "simple Query"
1201 * protocol.
1202 */
1203 if (dest->mydest == DestRemoteExecute)
1205 if (altdest->mydest == DestRemoteExecute)
1206 altdest = None_Receiver;
1207
1208 /*
1209 * Loop to handle the individual queries generated from a single parsetree
1210 * by analysis and rewrite.
1211 */
1212 foreach(stmtlist_item, portal->stmts)
1213 {
1214 PlannedStmt *pstmt = lfirst_node(PlannedStmt, stmtlist_item);
1215
1216 /*
1217 * If we got a cancel signal in prior command, quit
1218 */
1220
1221 if (pstmt->utilityStmt == NULL)
1222 {
1223 /*
1224 * process a plannable query.
1225 */
1226 TRACE_POSTGRESQL_QUERY_EXECUTE_START();
1227
1229 ResetUsage();
1230
1231 /*
1232 * Must always have a snapshot for plannable queries. First time
1233 * through, take a new snapshot; for subsequent queries in the
1234 * same portal, just update the snapshot's copy of the command
1235 * counter.
1236 */
1237 if (!active_snapshot_set)
1238 {
1239 Snapshot snapshot = GetTransactionSnapshot();
1240
1241 /* If told to, register the snapshot and save in portal */
1242 if (setHoldSnapshot)
1243 {
1244 snapshot = RegisterSnapshot(snapshot);
1245 portal->holdSnapshot = snapshot;
1246 }
1247
1248 /*
1249 * We can't have the holdSnapshot also be the active one,
1250 * because UpdateActiveSnapshotCommandId would complain. So
1251 * force an extra snapshot copy. Plain PushActiveSnapshot
1252 * would have copied the transaction snapshot anyway, so this
1253 * only adds a copy step when setHoldSnapshot is true. (It's
1254 * okay for the command ID of the active snapshot to diverge
1255 * from what holdSnapshot has.)
1256 */
1257 PushCopiedSnapshot(snapshot);
1258
1259 /*
1260 * As for PORTAL_ONE_SELECT portals, it does not seem
1261 * necessary to maintain portal->portalSnapshot here.
1262 */
1263
1264 active_snapshot_set = true;
1265 }
1266 else
1268
1269 if (pstmt->canSetTag)
1270 {
1271 /* statement can set tag string */
1272 ProcessQuery(pstmt,
1273 portal->sourceText,
1274 portal->portalParams,
1275 portal->queryEnv,
1276 dest, qc);
1277 }
1278 else
1279 {
1280 /* stmt added by rewrite cannot set tag */
1281 ProcessQuery(pstmt,
1282 portal->sourceText,
1283 portal->portalParams,
1284 portal->queryEnv,
1285 altdest, NULL);
1286 }
1287
1289 ShowUsage("EXECUTOR STATISTICS");
1290
1291 TRACE_POSTGRESQL_QUERY_EXECUTE_DONE();
1292 }
1293 else
1294 {
1295 /*
1296 * process utility functions (create, destroy, etc..)
1297 *
1298 * We must not set a snapshot here for utility commands (if one is
1299 * needed, PortalRunUtility will do it). If a utility command is
1300 * alone in a portal then everything's fine. The only case where
1301 * a utility command can be part of a longer list is that rules
1302 * are allowed to include NotifyStmt. NotifyStmt doesn't care
1303 * whether it has a snapshot or not, so we just leave the current
1304 * snapshot alone if we have one.
1305 */
1306 if (pstmt->canSetTag)
1307 {
1308 Assert(!active_snapshot_set);
1309 /* statement can set tag string */
1310 PortalRunUtility(portal, pstmt, isTopLevel, false,
1311 dest, qc);
1312 }
1313 else
1314 {
1315 Assert(IsA(pstmt->utilityStmt, NotifyStmt));
1316 /* stmt added by rewrite cannot set tag */
1317 PortalRunUtility(portal, pstmt, isTopLevel, false,
1318 altdest, NULL);
1319 }
1320 }
1321
1322 /*
1323 * Clear subsidiary contexts to recover temporary memory.
1324 */
1326
1328
1329 /*
1330 * Avoid crashing if portal->stmts has been reset. This can only
1331 * occur if a CALL or DO utility statement executed an internal
1332 * COMMIT/ROLLBACK (cf PortalReleaseCachedPlan). The CALL or DO must
1333 * have been the only statement in the portal, so there's nothing left
1334 * for us to do; but we don't want to dereference a now-dangling list
1335 * pointer.
1336 */
1337 if (portal->stmts == NIL)
1338 break;
1339
1340 /*
1341 * Increment command counter between queries, but not after the last
1342 * one.
1343 */
1344 if (lnext(portal->stmts, stmtlist_item) != NULL)
1346 }
1347
1348 /* Pop the snapshot if we pushed one. */
1349 if (active_snapshot_set)
1351
1352 /*
1353 * If a query completion data was supplied, use it. Otherwise use the
1354 * portal's query completion data.
1355 *
1356 * Exception: Clients expect INSERT/UPDATE/DELETE tags to have counts, so
1357 * fake them with zeros. This can happen with DO INSTEAD rules if there
1358 * is no replacement query of the same type as the original. We print "0
1359 * 0" here because technically there is no query of the matching tag type,
1360 * and printing a non-zero count for a different query type seems wrong,
1361 * e.g. an INSERT that does an UPDATE instead should not print "0 1" if
1362 * one row was updated. See QueryRewrite(), step 3, for details.
1363 */
1364 if (qc && qc->commandTag == CMDTAG_UNKNOWN)
1365 {
1366 if (portal->qc.commandTag != CMDTAG_UNKNOWN)
1367 CopyQueryCompletion(qc, &portal->qc);
1368 /* If the caller supplied a qc, we should have set it by now. */
1369 Assert(qc->commandTag != CMDTAG_UNKNOWN);
1370 }
1371}
@ DestRemoteExecute
Definition: dest.h:90
void MemoryContextDeleteChildren(MemoryContext context)
Definition: mcxt.c:539
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
#define lfirst_node(type, lc)
Definition: pg_list.h:176
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343
static void ProcessQuery(PlannedStmt *plan, const char *sourceText, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition: pquery.c:137
void UpdateActiveSnapshotCommandId(void)
Definition: snapmgr.c:731
void PushCopiedSnapshot(Snapshot snapshot)
Definition: snapmgr.c:719
const char * sourceText
Definition: portal.h:136
QueryEnvironment * queryEnv
Definition: portal.h:143
ParamListInfo portalParams
Definition: portal.h:142
Snapshot holdSnapshot
Definition: portal.h:187
CommandDest mydest
Definition: dest.h:128
void CommandCounterIncrement(void)
Definition: xact.c:1100

References Assert(), PlannedStmt::canSetTag, CHECK_FOR_INTERRUPTS, CommandCounterIncrement(), QueryCompletion::commandTag, CopyQueryCompletion(), CurrentMemoryContext, generate_unaccent_rules::dest, DestRemoteExecute, GetTransactionSnapshot(), PortalData::holdSnapshot, IsA, lfirst_node, lnext(), log_executor_stats, MemoryContextDeleteChildren(), _DestReceiver::mydest, NIL, None_Receiver, PopActiveSnapshot(), PortalData::portalContext, PortalData::portalParams, PortalRunUtility(), ProcessQuery(), PushCopiedSnapshot(), PortalData::qc, PortalData::queryEnv, RegisterSnapshot(), ResetUsage(), ShowUsage(), PortalData::sourceText, PortalData::stmts, UpdateActiveSnapshotCommandId(), and PlannedStmt::utilityStmt.

Referenced by FillPortalStore(), and PortalRun().

◆ PortalRunSelect()

static uint64 PortalRunSelect ( Portal  portal,
bool  forward,
long  count,
DestReceiver dest 
)
static

Definition at line 864 of file pquery.c.

868{
869 QueryDesc *queryDesc;
870 ScanDirection direction;
871 uint64 nprocessed;
872
873 /*
874 * NB: queryDesc will be NULL if we are fetching from a held cursor or a
875 * completed utility query; can't use it in that path.
876 */
877 queryDesc = portal->queryDesc;
878
879 /* Caller messed up if we have neither a ready query nor held data. */
880 Assert(queryDesc || portal->holdStore);
881
882 /*
883 * Force the queryDesc destination to the right thing. This supports
884 * MOVE, for example, which will pass in dest = DestNone. This is okay to
885 * change as long as we do it on every fetch. (The Executor must not
886 * assume that dest never changes.)
887 */
888 if (queryDesc)
889 queryDesc->dest = dest;
890
891 /*
892 * Determine which direction to go in, and check to see if we're already
893 * at the end of the available tuples in that direction. If so, set the
894 * direction to NoMovement to avoid trying to fetch any tuples. (This
895 * check exists because not all plan node types are robust about being
896 * called again if they've already returned NULL once.) Then call the
897 * executor (we must not skip this, because the destination needs to see a
898 * setup and shutdown even if no tuples are available). Finally, update
899 * the portal position state depending on the number of tuples that were
900 * retrieved.
901 */
902 if (forward)
903 {
904 if (portal->atEnd || count <= 0)
905 {
906 direction = NoMovementScanDirection;
907 count = 0; /* don't pass negative count to executor */
908 }
909 else
910 direction = ForwardScanDirection;
911
912 /* In the executor, zero count processes all rows */
913 if (count == FETCH_ALL)
914 count = 0;
915
916 if (portal->holdStore)
917 nprocessed = RunFromStore(portal, direction, (uint64) count, dest);
918 else
919 {
920 PushActiveSnapshot(queryDesc->snapshot);
921 ExecutorRun(queryDesc, direction, (uint64) count);
922 nprocessed = queryDesc->estate->es_processed;
924 }
925
926 if (!ScanDirectionIsNoMovement(direction))
927 {
928 if (nprocessed > 0)
929 portal->atStart = false; /* OK to go backward now */
930 if (count == 0 || nprocessed < (uint64) count)
931 portal->atEnd = true; /* we retrieved 'em all */
932 portal->portalPos += nprocessed;
933 }
934 }
935 else
936 {
939 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
940 errmsg("cursor can only scan forward"),
941 errhint("Declare it with SCROLL option to enable backward scan.")));
942
943 if (portal->atStart || count <= 0)
944 {
945 direction = NoMovementScanDirection;
946 count = 0; /* don't pass negative count to executor */
947 }
948 else
949 direction = BackwardScanDirection;
950
951 /* In the executor, zero count processes all rows */
952 if (count == FETCH_ALL)
953 count = 0;
954
955 if (portal->holdStore)
956 nprocessed = RunFromStore(portal, direction, (uint64) count, dest);
957 else
958 {
959 PushActiveSnapshot(queryDesc->snapshot);
960 ExecutorRun(queryDesc, direction, (uint64) count);
961 nprocessed = queryDesc->estate->es_processed;
963 }
964
965 if (!ScanDirectionIsNoMovement(direction))
966 {
967 if (nprocessed > 0 && portal->atEnd)
968 {
969 portal->atEnd = false; /* OK to go forward now */
970 portal->portalPos++; /* adjust for endpoint case */
971 }
972 if (count == 0 || nprocessed < (uint64) count)
973 {
974 portal->atStart = true; /* we retrieved 'em all */
975 portal->portalPos = 0;
976 }
977 else
978 {
979 portal->portalPos -= nprocessed;
980 }
981 }
982 }
983
984 return nprocessed;
985}
void ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count)
Definition: execMain.c:298
static uint64 RunFromStore(Portal portal, ScanDirection direction, uint64 count, DestReceiver *dest)
Definition: pquery.c:1056
#define ScanDirectionIsNoMovement(direction)
Definition: sdir.h:57
ScanDirection
Definition: sdir.h:25
@ NoMovementScanDirection
Definition: sdir.h:27
@ BackwardScanDirection
Definition: sdir.h:26
@ ForwardScanDirection
Definition: sdir.h:28
uint64 es_processed
Definition: execnodes.h:710

References Assert(), PortalData::atEnd, PortalData::atStart, BackwardScanDirection, CURSOR_OPT_NO_SCROLL, PortalData::cursorOptions, generate_unaccent_rules::dest, QueryDesc::dest, ereport, errcode(), errhint(), errmsg(), ERROR, EState::es_processed, QueryDesc::estate, ExecutorRun(), FETCH_ALL, ForwardScanDirection, PortalData::holdStore, NoMovementScanDirection, PopActiveSnapshot(), PortalData::portalPos, PushActiveSnapshot(), PortalData::queryDesc, RunFromStore(), ScanDirectionIsNoMovement, and QueryDesc::snapshot.

Referenced by DoPortalRunFetch(), and PortalRun().

◆ PortalRunUtility()

static void PortalRunUtility ( Portal  portal,
PlannedStmt pstmt,
bool  isTopLevel,
bool  setHoldSnapshot,
DestReceiver dest,
QueryCompletion qc 
)
static

Definition at line 1122 of file pquery.c.

1125{
1126 /*
1127 * Set snapshot if utility stmt needs one.
1128 */
1129 if (PlannedStmtRequiresSnapshot(pstmt))
1130 {
1131 Snapshot snapshot = GetTransactionSnapshot();
1132
1133 /* If told to, register the snapshot we're using and save in portal */
1134 if (setHoldSnapshot)
1135 {
1136 snapshot = RegisterSnapshot(snapshot);
1137 portal->holdSnapshot = snapshot;
1138 }
1139
1140 /*
1141 * In any case, make the snapshot active and remember it in portal.
1142 * Because the portal now references the snapshot, we must tell
1143 * snapmgr.c that the snapshot belongs to the portal's transaction
1144 * level, else we risk portalSnapshot becoming a dangling pointer.
1145 */
1146 PushActiveSnapshotWithLevel(snapshot, portal->createLevel);
1147 /* PushActiveSnapshotWithLevel might have copied the snapshot */
1149 }
1150 else
1151 portal->portalSnapshot = NULL;
1152
1153 ProcessUtility(pstmt,
1154 portal->sourceText,
1155 (portal->cplan != NULL), /* protect tree if in plancache */
1157 portal->portalParams,
1158 portal->queryEnv,
1159 dest,
1160 qc);
1161
1162 /* Some utility statements may change context on us */
1164
1165 /*
1166 * Some utility commands (e.g., VACUUM) pop the ActiveSnapshot stack from
1167 * under us, so don't complain if it's now empty. Otherwise, our snapshot
1168 * should be the top one; pop it. Note that this could be a different
1169 * snapshot from the one we made above; see EnsurePortalSnapshotExists.
1170 */
1171 if (portal->portalSnapshot != NULL && ActiveSnapshotSet())
1172 {
1175 }
1176 portal->portalSnapshot = NULL;
1177}
bool PlannedStmtRequiresSnapshot(PlannedStmt *pstmt)
Definition: pquery.c:1724
CachedPlan * cplan
Definition: portal.h:140
void ProcessUtility(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition: utility.c:499
@ PROCESS_UTILITY_TOPLEVEL
Definition: utility.h:22
@ PROCESS_UTILITY_QUERY
Definition: utility.h:23

References ActiveSnapshotSet(), Assert(), PortalData::cplan, PortalData::createLevel, generate_unaccent_rules::dest, GetActiveSnapshot(), GetTransactionSnapshot(), PortalData::holdSnapshot, MemoryContextSwitchTo(), PlannedStmtRequiresSnapshot(), PopActiveSnapshot(), PortalData::portalContext, PortalData::portalParams, PortalData::portalSnapshot, PROCESS_UTILITY_QUERY, PROCESS_UTILITY_TOPLEVEL, ProcessUtility(), PushActiveSnapshotWithLevel(), PortalData::queryEnv, RegisterSnapshot(), and PortalData::sourceText.

Referenced by FillPortalStore(), and PortalRunMulti().

◆ PortalSetResultFormat()

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

Definition at line 624 of file pquery.c.

625{
626 int natts;
627 int i;
628
629 /* Do nothing if portal won't return tuples */
630 if (portal->tupDesc == NULL)
631 return;
632 natts = portal->tupDesc->natts;
633 portal->formats = (int16 *)
635 natts * sizeof(int16));
636 if (nFormats > 1)
637 {
638 /* format specified for each column */
639 if (nFormats != natts)
641 (errcode(ERRCODE_PROTOCOL_VIOLATION),
642 errmsg("bind message has %d result formats but query has %d columns",
643 nFormats, natts)));
644 memcpy(portal->formats, formats, natts * sizeof(int16));
645 }
646 else if (nFormats > 0)
647 {
648 /* single format specified, use for all columns */
649 int16 format1 = formats[0];
650
651 for (i = 0; i < natts; i++)
652 portal->formats[i] = format1;
653 }
654 else
655 {
656 /* use default format for all columns */
657 for (i = 0; i < natts; i++)
658 portal->formats[i] = 0;
659 }
660}
int16_t int16
Definition: c.h:497
int i
Definition: isn.c:77
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1185
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 434 of file pquery.c.

436{
437 Portal saveActivePortal;
438 ResourceOwner saveResourceOwner;
439 MemoryContext savePortalContext;
440 MemoryContext oldContext;
441 QueryDesc *queryDesc;
442 int myeflags;
443
444 Assert(PortalIsValid(portal));
445 Assert(portal->status == PORTAL_DEFINED);
446
447 /*
448 * Set up global portal context pointers.
449 */
450 saveActivePortal = ActivePortal;
451 saveResourceOwner = CurrentResourceOwner;
452 savePortalContext = PortalContext;
453 PG_TRY();
454 {
455 ActivePortal = portal;
456 if (portal->resowner)
459
461
462 /* Must remember portal param list, if any */
463 portal->portalParams = params;
464
465 /*
466 * Determine the portal execution strategy
467 */
468 portal->strategy = ChoosePortalStrategy(portal->stmts);
469
470 /*
471 * Fire her up according to the strategy
472 */
473 switch (portal->strategy)
474 {
476
477 /* Must set snapshot before starting executor. */
478 if (snapshot)
479 PushActiveSnapshot(snapshot);
480 else
482
483 /*
484 * We could remember the snapshot in portal->portalSnapshot,
485 * but presently there seems no need to, as this code path
486 * cannot be used for non-atomic execution. Hence there can't
487 * be any commit/abort that might destroy the snapshot. Since
488 * we don't do that, there's also no need to force a
489 * non-default nesting level for the snapshot.
490 */
491
492 /*
493 * Create QueryDesc in portal's context; for the moment, set
494 * the destination to DestNone.
495 */
496 queryDesc = CreateQueryDesc(linitial_node(PlannedStmt, portal->stmts),
497 portal->sourceText,
501 params,
502 portal->queryEnv,
503 0);
504
505 /*
506 * If it's a scrollable cursor, executor needs to support
507 * REWIND and backwards scan, as well as whatever the caller
508 * might've asked for.
509 */
510 if (portal->cursorOptions & CURSOR_OPT_SCROLL)
511 myeflags = eflags | EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD;
512 else
513 myeflags = eflags;
514
515 /*
516 * Call ExecutorStart to prepare the plan for execution
517 */
518 ExecutorStart(queryDesc, myeflags);
519
520 /*
521 * This tells PortalCleanup to shut down the executor
522 */
523 portal->queryDesc = queryDesc;
524
525 /*
526 * Remember tuple descriptor (computed by ExecutorStart)
527 */
528 portal->tupDesc = queryDesc->tupDesc;
529
530 /*
531 * Reset cursor position data to "start of query"
532 */
533 portal->atStart = true;
534 portal->atEnd = false; /* allow fetches */
535 portal->portalPos = 0;
536
538 break;
539
542
543 /*
544 * We don't start the executor until we are told to run the
545 * portal. We do need to set up the result tupdesc.
546 */
547 {
548 PlannedStmt *pstmt;
549
550 pstmt = PortalGetPrimaryStmt(portal);
551 portal->tupDesc =
553 }
554
555 /*
556 * Reset cursor position data to "start of query"
557 */
558 portal->atStart = true;
559 portal->atEnd = false; /* allow fetches */
560 portal->portalPos = 0;
561 break;
562
564
565 /*
566 * We don't set snapshot here, because PortalRunUtility will
567 * take care of it if needed.
568 */
569 {
570 PlannedStmt *pstmt = PortalGetPrimaryStmt(portal);
571
572 Assert(pstmt->commandType == CMD_UTILITY);
574 }
575
576 /*
577 * Reset cursor position data to "start of query"
578 */
579 portal->atStart = true;
580 portal->atEnd = false; /* allow fetches */
581 portal->portalPos = 0;
582 break;
583
585 /* Need do nothing now */
586 portal->tupDesc = NULL;
587 break;
588 }
589 }
590 PG_CATCH();
591 {
592 /* Uncaught error while executing portal: mark it dead */
593 MarkPortalFailed(portal);
594
595 /* Restore global vars and propagate error */
596 ActivePortal = saveActivePortal;
597 CurrentResourceOwner = saveResourceOwner;
598 PortalContext = savePortalContext;
599
600 PG_RE_THROW();
601 }
602 PG_END_TRY();
603
604 MemoryContextSwitchTo(oldContext);
605
606 ActivePortal = saveActivePortal;
607 CurrentResourceOwner = saveResourceOwner;
608 PortalContext = savePortalContext;
609
610 portal->status = PORTAL_READY;
611}
void ExecutorStart(QueryDesc *queryDesc, int eflags)
Definition: execMain.c:123
TupleDesc ExecCleanTypeFromTL(List *targetList)
Definition: execTuples.c:2139
#define EXEC_FLAG_BACKWARD
Definition: executor.h:68
#define EXEC_FLAG_REWIND
Definition: executor.h:67
#define CURSOR_OPT_SCROLL
Definition: parsenodes.h:3376
@ 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:68
PortalStrategy ChoosePortalStrategy(List *stmts)
Definition: pquery.c:210
#define InvalidSnapshot
Definition: snapshot.h:119
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().

◆ ProcessQuery()

static void ProcessQuery ( PlannedStmt plan,
const char *  sourceText,
ParamListInfo  params,
QueryEnvironment queryEnv,
DestReceiver dest,
QueryCompletion qc 
)
static

Definition at line 137 of file pquery.c.

143{
144 QueryDesc *queryDesc;
145
146 /*
147 * Create the QueryDesc object
148 */
149 queryDesc = CreateQueryDesc(plan, sourceText,
151 dest, params, queryEnv, 0);
152
153 /*
154 * Call ExecutorStart to prepare the plan for execution
155 */
156 ExecutorStart(queryDesc, 0);
157
158 /*
159 * Run the plan to completion.
160 */
161 ExecutorRun(queryDesc, ForwardScanDirection, 0);
162
163 /*
164 * Build command completion status data, if caller wants one.
165 */
166 if (qc)
167 {
168 switch (queryDesc->operation)
169 {
170 case CMD_SELECT:
171 SetQueryCompletion(qc, CMDTAG_SELECT, queryDesc->estate->es_processed);
172 break;
173 case CMD_INSERT:
174 SetQueryCompletion(qc, CMDTAG_INSERT, queryDesc->estate->es_processed);
175 break;
176 case CMD_UPDATE:
177 SetQueryCompletion(qc, CMDTAG_UPDATE, queryDesc->estate->es_processed);
178 break;
179 case CMD_DELETE:
180 SetQueryCompletion(qc, CMDTAG_DELETE, queryDesc->estate->es_processed);
181 break;
182 case CMD_MERGE:
183 SetQueryCompletion(qc, CMDTAG_MERGE, queryDesc->estate->es_processed);
184 break;
185 default:
186 SetQueryCompletion(qc, CMDTAG_UNKNOWN, queryDesc->estate->es_processed);
187 break;
188 }
189 }
190
191 /*
192 * Now, we close down all the scans and free allocated resources.
193 */
194 ExecutorFinish(queryDesc);
195 ExecutorEnd(queryDesc);
196
197 FreeQueryDesc(queryDesc);
198}
static void SetQueryCompletion(QueryCompletion *qc, CommandTag commandTag, uint64 nprocessed)
Definition: cmdtag.h:37
void ExecutorEnd(QueryDesc *queryDesc)
Definition: execMain.c:467
void ExecutorFinish(QueryDesc *queryDesc)
Definition: execMain.c:407
@ CMD_MERGE
Definition: nodes.h:275
@ CMD_INSERT
Definition: nodes.h:273
@ CMD_DELETE
Definition: nodes.h:274
@ CMD_UPDATE
Definition: nodes.h:272
#define plan(x)
Definition: pg_regress.c:161
void FreeQueryDesc(QueryDesc *qdesc)
Definition: pquery.c:106

References CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, CreateQueryDesc(), generate_unaccent_rules::dest, EState::es_processed, QueryDesc::estate, ExecutorEnd(), ExecutorFinish(), ExecutorRun(), ExecutorStart(), ForwardScanDirection, FreeQueryDesc(), GetActiveSnapshot(), InvalidSnapshot, QueryDesc::operation, plan, and SetQueryCompletion().

Referenced by PortalRunMulti().

◆ RunFromStore()

static uint64 RunFromStore ( Portal  portal,
ScanDirection  direction,
uint64  count,
DestReceiver dest 
)
static

Definition at line 1056 of file pquery.c.

1058{
1059 uint64 current_tuple_count = 0;
1060 TupleTableSlot *slot;
1061
1063
1064 dest->rStartup(dest, CMD_SELECT, portal->tupDesc);
1065
1066 if (ScanDirectionIsNoMovement(direction))
1067 {
1068 /* do nothing except start/stop the destination */
1069 }
1070 else
1071 {
1072 bool forward = ScanDirectionIsForward(direction);
1073
1074 for (;;)
1075 {
1076 MemoryContext oldcontext;
1077 bool ok;
1078
1079 oldcontext = MemoryContextSwitchTo(portal->holdContext);
1080
1081 ok = tuplestore_gettupleslot(portal->holdStore, forward, false,
1082 slot);
1083
1084 MemoryContextSwitchTo(oldcontext);
1085
1086 if (!ok)
1087 break;
1088
1089 /*
1090 * If we are not able to send the tuple, we assume the destination
1091 * has closed and no more tuples can be sent. If that's the case,
1092 * end the loop.
1093 */
1094 if (!dest->receiveSlot(slot, dest))
1095 break;
1096
1097 ExecClearTuple(slot);
1098
1099 /*
1100 * check our tuple count.. if we've processed the proper number
1101 * then quit, else loop again and process more tuples. Zero count
1102 * means no limit.
1103 */
1104 current_tuple_count++;
1105 if (count && count == current_tuple_count)
1106 break;
1107 }
1108 }
1109
1110 dest->rShutdown(dest);
1111
1113
1114 return current_tuple_count;
1115}
TupleTableSlot * MakeSingleTupleTableSlot(TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1427
void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
Definition: execTuples.c:1443
const TupleTableSlotOps TTSOpsMinimalTuple
Definition: execTuples.c:86
#define ScanDirectionIsForward(direction)
Definition: sdir.h:64
bool tuplestore_gettupleslot(Tuplestorestate *state, bool forward, bool copy, TupleTableSlot *slot)
Definition: tuplestore.c:1130
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:458

References CMD_SELECT, generate_unaccent_rules::dest, ExecClearTuple(), ExecDropSingleTupleTableSlot(), PortalData::holdContext, PortalData::holdStore, MakeSingleTupleTableSlot(), MemoryContextSwitchTo(), ScanDirectionIsForward, ScanDirectionIsNoMovement, TTSOpsMinimalTuple, PortalData::tupDesc, and tuplestore_gettupleslot().

Referenced by PortalRunSelect().

Variable Documentation

◆ ActivePortal