* Copyright (c) 2002-2006, PostgreSQL Global Development Group
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/prepare.c,v 1.60 2006/08/12 02:52:04 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/prepare.c,v 1.61 2006/08/14 22:57:15 tgl Exp $
*
*-------------------------------------------------------------------------
*/
return ExecCleanTypeFromTL(query->targetList, false);
case PORTAL_ONE_RETURNING:
- query = (Query *) linitial(stmt->query_list);
+ query = PortalListGetPrimaryQuery(stmt->query_list);
return ExecCleanTypeFromTL(query->returningList, false);
case PORTAL_UTIL_SELECT:
if (strategy == PORTAL_ONE_SELECT)
return ((Query *) linitial(stmt->query_list))->targetList;
if (strategy == PORTAL_ONE_RETURNING)
- return ((Query *) linitial(stmt->query_list))->returningList;
+ return (PortalListGetPrimaryQuery(stmt->query_list))->returningList;
if (strategy == PORTAL_UTIL_SELECT)
{
Node *utilityStmt;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/executor/spi.c,v 1.156 2006/08/14 13:40:18 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/executor/spi.c,v 1.157 2006/08/14 22:57:15 tgl Exp $
*
*-------------------------------------------------------------------------
*/
bool read_only)
{
_SPI_plan *spiplan = (_SPI_plan *) plan;
- List *qtlist = spiplan->qtlist;
- List *ptlist = spiplan->ptlist;
- Query *queryTree;
- Plan *planTree;
+ List *qtlist;
+ List *ptlist;
ParamListInfo paramLI;
Snapshot snapshot;
MemoryContext oldcontext;
Portal portal;
int k;
- /* Ensure that the plan contains only one query */
- if (list_length(ptlist) != 1 || list_length(qtlist) != 1)
- ereport(ERROR,
- (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
- errmsg("cannot open multi-query plan as cursor")));
- queryTree = (Query *) linitial((List *) linitial(qtlist));
- planTree = (Plan *) linitial(ptlist);
-
- /* Must be a query that returns tuples */
- if (!QueryReturnsTuples(queryTree))
+ /*
+ * Check that the plan is something the Portal code will special-case
+ * as returning one tupleset.
+ */
+ if (!SPI_is_cursor_plan(spiplan))
+ {
+ /* try to give a good error message */
+ Query *queryTree;
+
+ if (list_length(spiplan->qtlist) != 1)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
+ errmsg("cannot open multi-query plan as cursor")));
+ queryTree = PortalListGetPrimaryQuery((List *) linitial(spiplan->qtlist));
+ if (queryTree == NULL)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
+ errmsg("cannot open empty query as cursor")));
ereport(ERROR,
(errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
/* translator: %s is name of a SQL command, eg INSERT */
errmsg("cannot open %s query as cursor",
CreateQueryTag(queryTree))));
+ }
+
+ Assert(list_length(spiplan->qtlist) == 1);
+ qtlist = (List *) linitial(spiplan->qtlist);
+ ptlist = spiplan->ptlist;
+ if (list_length(qtlist) != list_length(ptlist))
+ elog(ERROR, "corrupted SPI plan lists");
/* Reset SPI result (note we deliberately don't touch lastoid) */
SPI_processed = 0;
portal = CreatePortal(name, false, false);
}
- /* Switch to portal's memory and copy the parsetree and plan to there */
+ /* Switch to portal's memory and copy the parsetrees and plans to there */
oldcontext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));
- queryTree = copyObject(queryTree);
- planTree = copyObject(planTree);
+ qtlist = copyObject(qtlist);
+ ptlist = copyObject(ptlist);
/* If the plan has parameters, set them up */
if (spiplan->nargs > 0)
PortalDefineQuery(portal,
NULL, /* no statement name */
spiplan->query,
- CreateQueryTag(queryTree),
- list_make1(queryTree),
- list_make1(planTree),
+ CreateQueryTag(PortalListGetPrimaryQuery(qtlist)),
+ qtlist,
+ ptlist,
PortalGetHeapMemory(portal));
MemoryContextSwitchTo(oldcontext);
* Set up options for portal.
*/
portal->cursorOptions &= ~(CURSOR_OPT_SCROLL | CURSOR_OPT_NO_SCROLL);
- if (planTree == NULL || ExecSupportsBackwardScan(planTree))
+ if (list_length(ptlist) == 1 &&
+ ExecSupportsBackwardScan((Plan *) linitial(ptlist)))
portal->cursorOptions |= CURSOR_OPT_SCROLL;
else
portal->cursorOptions |= CURSOR_OPT_NO_SCROLL;
*/
PortalStart(portal, paramLI, snapshot);
- /*
- * If this test fails then we're out of sync with pquery.c about
- * which queries can return tuples...
- */
- if (portal->strategy == PORTAL_MULTI_QUERY)
- ereport(ERROR,
- (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
- /* translator: %s is name of a SQL command, eg INSERT */
- errmsg("cannot open %s query as cursor",
- CreateQueryTag(queryTree))));
+ Assert(portal->strategy != PORTAL_MULTI_QUERY);
/* Return the created portal */
return portal;
SPI_is_cursor_plan(void *plan)
{
_SPI_plan *spiplan = (_SPI_plan *) plan;
- List *qtlist;
if (spiplan == NULL)
{
return false;
}
- qtlist = spiplan->qtlist;
- if (list_length(spiplan->ptlist) == 1 && list_length(qtlist) == 1)
- {
- Query *queryTree = (Query *) linitial((List *) linitial(qtlist));
+ if (list_length(spiplan->qtlist) != 1)
+ return false; /* not exactly 1 pre-rewrite command */
- if (QueryReturnsTuples(queryTree))
+ switch (ChoosePortalStrategy((List *) linitial(spiplan->qtlist)))
+ {
+ case PORTAL_ONE_SELECT:
+ case PORTAL_ONE_RETURNING:
+ case PORTAL_UTIL_SELECT:
+ /* OK */
return true;
+
+ case PORTAL_MULTI_QUERY:
+ /* will not return tuples */
+ break;
}
return false;
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/tcop/pquery.c,v 1.106 2006/08/12 02:52:05 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/tcop/pquery.c,v 1.107 2006/08/14 22:57:15 tgl Exp $
*
*-------------------------------------------------------------------------
*/
PortalStrategy
ChoosePortalStrategy(List *parseTrees)
{
- PortalStrategy strategy;
-
- strategy = PORTAL_MULTI_QUERY; /* default assumption */
+ int nSetTag;
+ ListCell *lc;
+ /*
+ * PORTAL_ONE_SELECT and PORTAL_UTIL_SELECT need only consider the
+ * single-Query-struct case, since there are no rewrite rules that
+ * can add auxiliary queries to a SELECT or a utility command.
+ */
if (list_length(parseTrees) == 1)
{
Query *query = (Query *) linitial(parseTrees);
+ Assert(IsA(query, Query));
if (query->canSetTag)
{
if (query->commandType == CMD_SELECT &&
query->into == NULL)
- strategy = PORTAL_ONE_SELECT;
- else if (query->returningList != NIL)
- strategy = PORTAL_ONE_RETURNING;
- else if (query->commandType == CMD_UTILITY &&
- query->utilityStmt != NULL)
+ return PORTAL_ONE_SELECT;
+ if (query->commandType == CMD_UTILITY &&
+ query->utilityStmt != NULL)
{
if (UtilityReturnsTuples(query->utilityStmt))
- strategy = PORTAL_UTIL_SELECT;
+ return PORTAL_UTIL_SELECT;
+ /* it can't be ONE_RETURNING, so give up */
+ return PORTAL_MULTI_QUERY;
}
}
}
- return strategy;
+
+ /*
+ * PORTAL_ONE_RETURNING has to allow auxiliary queries added by rewrite.
+ * Choose PORTAL_ONE_RETURNING if there is exactly one canSetTag query
+ * and it has a RETURNING list.
+ */
+ nSetTag = 0;
+ foreach(lc, parseTrees)
+ {
+ Query *query = (Query *) lfirst(lc);
+
+ Assert(IsA(query, Query));
+ if (query->canSetTag)
+ {
+ if (++nSetTag > 1)
+ return PORTAL_MULTI_QUERY; /* no need to look further */
+ if (query->returningList == NIL)
+ return PORTAL_MULTI_QUERY; /* no need to look further */
+ }
+ }
+ if (nSetTag == 1)
+ return PORTAL_ONE_RETURNING;
+
+ /* Else, it's the general case... */
+ return PORTAL_MULTI_QUERY;
}
/*
if (portal->strategy == PORTAL_ONE_SELECT)
return ((Query *) linitial(portal->parseTrees))->targetList;
if (portal->strategy == PORTAL_ONE_RETURNING)
- return ((Query *) linitial(portal->parseTrees))->returningList;
+ return (PortalGetPrimaryQuery(portal))->returningList;
if (portal->strategy == PORTAL_UTIL_SELECT)
{
Node *utilityStmt;
* the portal. We do need to set up the result tupdesc.
*/
portal->tupDesc =
- ExecCleanTypeFromTL(((Query *) linitial(portal->parseTrees))->returningList, false);
+ ExecCleanTypeFromTL((PortalGetPrimaryQuery(portal))->returningList, false);
/*
* Reset cursor position data to "start of query"
{
case PORTAL_ONE_RETURNING:
/*
- * We run the query just as if it were in a MULTI portal,
- * but send the output to the tuplestore.
+ * Run the portal to completion just as for the default MULTI_QUERY
+ * case, but send the primary query's output to the tuplestore.
+ * Auxiliary query outputs are discarded.
*/
- PortalRunMulti(portal, treceiver, treceiver, completionTag);
+ PortalRunMulti(portal, treceiver, None_Receiver, completionTag);
/* Override default completion tag with actual command result */
portal->commandTag = pstrdup(completionTag);
break;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/mmgr/portalmem.c,v 1.91 2006/08/08 01:23:15 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/mmgr/portalmem.c,v 1.92 2006/08/14 22:57:15 tgl Exp $
*
*-------------------------------------------------------------------------
*/
return portal;
}
+/*
+ * PortalListGetPrimaryQuery
+ * Get the "primary" Query within a portal, ie, the one marked canSetTag.
+ *
+ * Returns NULL if no such Query. If multiple Query structs within the
+ * portal are marked canSetTag, returns the first one. Neither of these
+ * cases should occur in present usages of this function.
+ *
+ * Note: the reason this is just handed a List is so that prepared statements
+ * can share the code. For use with a portal, use PortalGetPrimaryQuery
+ * rather than calling this directly.
+ */
+Query *
+PortalListGetPrimaryQuery(List *parseTrees)
+{
+ ListCell *lc;
+
+ foreach(lc, parseTrees)
+ {
+ Query *query = (Query *) lfirst(lc);
+
+ Assert(IsA(query, Query));
+ if (query->canSetTag)
+ return query;
+ }
+ return NULL;
+}
+
/*
* CreatePortal
* Returns a new portal given a name.
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/utils/portal.h,v 1.65 2006/08/12 02:52:06 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/utils/portal.h,v 1.66 2006/08/14 22:57:15 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* tuplestore for access after transaction completion).
*
* PORTAL_ONE_RETURNING: the portal contains a single INSERT/UPDATE/DELETE
- * query with a RETURNING clause. On first execution, we run the statement
- * and dump its results into the portal tuplestore; the results are then
- * returned to the client as demanded. (We can't support suspension of
- * the query partway through, because the AFTER TRIGGER code can't cope.)
+ * query with a RETURNING clause (plus possibly auxiliary queries added by
+ * rule rewriting). On first execution, we run the portal to completion
+ * and dump the primary query's results into the portal tuplestore; the
+ * results are then returned to the client as demanded. (We can't support
+ * suspension of the query partway through, because the AFTER TRIGGER code
+ * can't cope, and also because we don't want to risk failing to execute
+ * all the auxiliary queries.)
*
* PORTAL_UTIL_SELECT: the portal contains a utility statement that returns
* a SELECT-like result (for example, EXPLAIN or SHOW). On first execution,
*/
#define PortalGetQueryDesc(portal) ((portal)->queryDesc)
#define PortalGetHeapMemory(portal) ((portal)->heap)
+#define PortalGetPrimaryQuery(portal) PortalListGetPrimaryQuery((portal)->parseTrees)
/* Prototypes for functions in utils/mmgr/portalmem.c */
List *parseTrees,
List *planTrees,
MemoryContext queryContext);
+extern Query *PortalListGetPrimaryQuery(List *parseTrees);
extern void PortalCreateHoldStore(Portal portal);
#endif /* PORTAL_H */
projects / postgresql.git / commitdiff