From d573e239f03506920938bf0be56c868d9c3416da Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Wed, 21 Dec 2011 09:16:55 -0500 Subject: [PATCH] Take fewer snapshots. When a PORTAL_ONE_SELECT query is executed, we can opportunistically reuse the parse/plan shot for the execution phase. This cuts down the number of snapshots per simple query from 2 to 1 for the simple protocol, and 3 to 2 for the extended protocol. Since we are only reusing a snapshot taken early in the processing of the same protocol message, the change shouldn't be user-visible, except that the remote possibility of the planning and execution snapshots being different is eliminated. Note that this change does not make it safe to assume that the parse/plan snapshot will certainly be reused; that will currently only happen if PortalStart() decides to use the PORTAL_ONE_SELECT strategy. It might be worth trying to provide some stronger guarantees here in the future, but for now we don't. Patch by me; review by Dimitri Fontaine. --- src/backend/commands/portalcmds.c | 2 +- src/backend/commands/prepare.c | 2 +- src/backend/executor/spi.c | 18 +++++++---------- src/backend/tcop/postgres.c | 32 ++++++++++++++++++++----------- src/backend/tcop/pquery.c | 15 ++++++++------- src/include/tcop/pquery.h | 2 +- 6 files changed, 39 insertions(+), 32 deletions(-) diff --git a/src/backend/commands/portalcmds.c b/src/backend/commands/portalcmds.c index 89086aa371..497657ee73 100644 --- a/src/backend/commands/portalcmds.c +++ b/src/backend/commands/portalcmds.c @@ -121,7 +121,7 @@ PerformCursorOpen(PlannedStmt *stmt, ParamListInfo params, /* * Start execution, inserting parameters if any. */ - PortalStart(portal, params, GetActiveSnapshot()); + PortalStart(portal, params, true); Assert(portal->strategy == PORTAL_ONE_SELECT); diff --git a/src/backend/commands/prepare.c b/src/backend/commands/prepare.c index a94921574f..dd0e837ebc 100644 --- a/src/backend/commands/prepare.c +++ b/src/backend/commands/prepare.c @@ -278,7 +278,7 @@ ExecuteQuery(ExecuteStmt *stmt, const char *queryString, /* * Run the portal to completion. */ - PortalStart(portal, paramLI, GetActiveSnapshot()); + PortalStart(portal, paramLI, true); (void) PortalRun(portal, FETCH_ALL, false, dest, dest, completionTag); diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c index 688279c716..7af3abf3f7 100644 --- a/src/backend/executor/spi.c +++ b/src/backend/executor/spi.c @@ -1126,7 +1126,6 @@ SPI_cursor_open_internal(const char *name, SPIPlanPtr plan, CachedPlan *cplan; List *stmt_list; char *query_string; - Snapshot snapshot; MemoryContext oldcontext; Portal portal; @@ -1269,15 +1268,6 @@ SPI_cursor_open_internal(const char *name, SPIPlanPtr plan, } } - /* Set up the snapshot to use. */ - if (read_only) - snapshot = GetActiveSnapshot(); - else - { - CommandCounterIncrement(); - snapshot = GetTransactionSnapshot(); - } - /* * If the plan has parameters, copy them into the portal. Note that this * must be done after revalidating the plan, because in dynamic parameter @@ -1293,7 +1283,13 @@ SPI_cursor_open_internal(const char *name, SPIPlanPtr plan, /* * Start portal execution. */ - PortalStart(portal, paramLI, snapshot); + if (read_only) + PortalStart(portal, paramLI, true); + else + { + CommandCounterIncrement(); + PortalStart(portal, paramLI, false); + } Assert(portal->strategy != PORTAL_MULTI_QUERY); diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index 5bb16e010c..f789a1e627 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -943,10 +943,6 @@ exec_simple_query(const char *query_string) plantree_list = pg_plan_queries(querytree_list, 0, NULL); - /* Done with the snapshot used for parsing/planning */ - if (snapshot_set) - PopActiveSnapshot(); - /* If we got a cancel signal in analysis or planning, quit */ CHECK_FOR_INTERRUPTS(); @@ -971,9 +967,19 @@ exec_simple_query(const char *query_string) NULL); /* - * Start the portal. No parameters here. + * Start the portal. + * + * If we took a snapshot for parsing/planning, the portal may be + * able to reuse it for the execution phase. Currently, this will only + * happen in PORTAL_ONE_SELECT mode. But even if PortalStart doesn't + * end up being able to do this, keeping the parse/plan snapshot around + * until after we start the portal doesn't cost much. */ - PortalStart(portal, NULL, InvalidSnapshot); + PortalStart(portal, NULL, snapshot_set); + + /* Done with the snapshot used for parsing/planning */ + if (snapshot_set) + PopActiveSnapshot(); /* * Select the appropriate output format: text unless we are doing a @@ -1696,14 +1702,18 @@ exec_bind_message(StringInfo input_message) cplan->stmt_list, cplan); - /* Done with the snapshot used for parameter I/O and parsing/planning */ - if (snapshot_set) - PopActiveSnapshot(); - /* * And we're ready to start portal execution. + * + * If we took a snapshot for parsing/planning, we'll try to reuse it + * for query execution (currently, reuse will only occur if + * PORTAL_ONE_SELECT mode is chosen). */ - PortalStart(portal, params, InvalidSnapshot); + PortalStart(portal, params, snapshot_set); + + /* Done with the snapshot used for parameter I/O and parsing/planning */ + if (snapshot_set) + PopActiveSnapshot(); /* * Apply the result format requests to the portal. diff --git a/src/backend/tcop/pquery.c b/src/backend/tcop/pquery.c index 466727b7b8..75c7dee3cb 100644 --- a/src/backend/tcop/pquery.c +++ b/src/backend/tcop/pquery.c @@ -446,16 +446,17 @@ FetchStatementTargetList(Node *stmt) * the query, they must be passed in here (caller is responsible for * giving them appropriate lifetime). * - * The caller can optionally pass a snapshot to be used; pass InvalidSnapshot - * for the normal behavior of setting a new snapshot. This parameter is - * presently ignored for non-PORTAL_ONE_SELECT portals (it's only intended - * to be used for cursors). + * The use_active_snapshot parameter is currently used only for + * PORTAL_ONE_SELECT portals. If it is true, the active snapshot will + * be used when starting up the executor; if false, a new snapshot will + * be taken. This is used both for cursors and to avoid taking an entirely + * new snapshot when it isn't necessary. * * On return, portal is ready to accept PortalRun() calls, and the result * tupdesc (if any) is known. */ void -PortalStart(Portal portal, ParamListInfo params, Snapshot snapshot) +PortalStart(Portal portal, ParamListInfo params, bool use_active_snapshot) { Portal saveActivePortal; ResourceOwner saveResourceOwner; @@ -497,8 +498,8 @@ PortalStart(Portal portal, ParamListInfo params, Snapshot snapshot) case PORTAL_ONE_SELECT: /* Must set snapshot before starting executor. */ - if (snapshot) - PushActiveSnapshot(snapshot); + if (use_active_snapshot) + PushActiveSnapshot(GetActiveSnapshot()); else PushActiveSnapshot(GetTransactionSnapshot()); diff --git a/src/include/tcop/pquery.h b/src/include/tcop/pquery.h index 2a5e871c92..ce37af3be1 100644 --- a/src/include/tcop/pquery.h +++ b/src/include/tcop/pquery.h @@ -28,7 +28,7 @@ extern List *FetchPortalTargetList(Portal portal); extern List *FetchStatementTargetList(Node *stmt); extern void PortalStart(Portal portal, ParamListInfo params, - Snapshot snapshot); + bool use_active_snapshot); extern void PortalSetResultFormat(Portal portal, int nFormats, int16 *formats); -- 2.40.0