From c1d5189f52537d4632d0a4069a732e8666c123e1 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Fri, 16 Feb 2018 20:44:15 -0500 Subject: [PATCH v1 2/8] Rename TransactionChain functions We call this thing a "transaction block" everywhere except in a few functions, where it is mysteriously called a "transaction chain". In the SQL standard, a transaction chain is something different. So rename these functions to match the common terminology. --- src/backend/access/transam/xact.c | 28 ++++++++++++++-------------- src/backend/commands/cluster.c | 2 +- src/backend/commands/dbcommands.c | 2 +- src/backend/commands/discard.c | 2 +- src/backend/commands/portalcmds.c | 2 +- src/backend/commands/subscriptioncmds.c | 4 ++-- src/backend/commands/typecmds.c | 2 +- src/backend/commands/vacuum.c | 4 ++-- src/backend/replication/walsender.c | 6 +++--- src/backend/tcop/utility.c | 30 +++++++++++++++--------------- src/backend/utils/misc/guc.c | 10 +++++----- src/backend/utils/time/snapmgr.c | 2 +- src/bin/psql/common.c | 2 +- src/include/access/xact.h | 8 ++++---- 14 files changed, 52 insertions(+), 52 deletions(-) diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c index d7688879a3..e8a4412671 100644 --- a/src/backend/access/transam/xact.c +++ b/src/backend/access/transam/xact.c @@ -310,7 +310,7 @@ static void CallSubXactCallbacks(SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid); static void CleanupTransaction(void); -static void CheckTransactionChain(bool isTopLevel, bool throwError, +static void CheckTransactionBlock(bool isTopLevel, bool throwError, const char *stmtType); static void CommitTransaction(void); static TransactionId RecordTransactionAbort(bool isSubXact); @@ -3134,7 +3134,7 @@ AbortCurrentTransaction(void) } /* - * PreventTransactionChain + * PreventInTransactionBlock * * This routine is to be called by statements that must not run inside * a transaction block, typically because they have non-rollback-able @@ -3151,7 +3151,7 @@ AbortCurrentTransaction(void) * stmtType: statement type name, for error messages. */ void -PreventTransactionChain(bool isTopLevel, const char *stmtType) +PreventInTransactionBlock(bool isTopLevel, const char *stmtType) { /* * xact block already started? @@ -3190,8 +3190,8 @@ PreventTransactionChain(bool isTopLevel, const char *stmtType) } /* - * WarnNoTranactionChain - * RequireTransactionChain + * WarnNoTranactionBlock + * RequireTransactionBlock * * These two functions allow for warnings or errors if a command is executed * outside of a transaction block. This is useful for commands that have no @@ -3204,26 +3204,26 @@ PreventTransactionChain(bool isTopLevel, const char *stmtType) * If we appear to be running inside a user-defined function, we do not * issue anything, since the function could issue more commands that make * use of the current statement's results. Likewise subtransactions. - * Thus this is an inverse for PreventTransactionChain. + * Thus this is an inverse for PreventInTransactionBlock. * * isTopLevel: passed down from ProcessUtility to determine whether we are * inside a function. * stmtType: statement type name, for warning or error messages. */ void -WarnNoTransactionChain(bool isTopLevel, const char *stmtType) +WarnNoTransactionBlock(bool isTopLevel, const char *stmtType) { - CheckTransactionChain(isTopLevel, false, stmtType); + CheckTransactionBlock(isTopLevel, false, stmtType); } void -RequireTransactionChain(bool isTopLevel, const char *stmtType) +RequireTransactionBlock(bool isTopLevel, const char *stmtType) { - CheckTransactionChain(isTopLevel, true, stmtType); + CheckTransactionBlock(isTopLevel, true, stmtType); } static void -CheckTransactionChain(bool isTopLevel, bool throwError, const char *stmtType) +CheckTransactionBlock(bool isTopLevel, bool throwError, const char *stmtType) { /* * xact block already started? @@ -3252,7 +3252,7 @@ CheckTransactionChain(bool isTopLevel, bool throwError, const char *stmtType) } /* - * IsInTransactionChain + * IsInTransactionBlock * * This routine is for statements that need to behave differently inside * a transaction block than when running as single commands. ANALYZE is @@ -3262,10 +3262,10 @@ CheckTransactionChain(bool isTopLevel, bool throwError, const char *stmtType) * inside a function. */ bool -IsInTransactionChain(bool isTopLevel) +IsInTransactionBlock(bool isTopLevel) { /* - * Return true on same conditions that would make PreventTransactionChain + * Return true on same conditions that would make PreventInTransactionBlock * error out */ if (IsTransactionBlock()) diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c index 5d481dd50d..96a51bb760 100644 --- a/src/backend/commands/cluster.c +++ b/src/backend/commands/cluster.c @@ -202,7 +202,7 @@ cluster(ClusterStmt *stmt, bool isTopLevel) * We cannot run this form of CLUSTER inside a user transaction block; * we'd be holding locks way too long. */ - PreventTransactionChain(isTopLevel, "CLUSTER"); + PreventInTransactionBlock(isTopLevel, "CLUSTER"); /* * Create special memory context for cross-transaction storage. diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c index d1718f04ee..5342f217c0 100644 --- a/src/backend/commands/dbcommands.c +++ b/src/backend/commands/dbcommands.c @@ -1476,7 +1476,7 @@ AlterDatabase(ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel) dtablespace->defname), parser_errposition(pstate, dtablespace->location))); /* this case isn't allowed within a transaction block */ - PreventTransactionChain(isTopLevel, "ALTER DATABASE SET TABLESPACE"); + PreventInTransactionBlock(isTopLevel, "ALTER DATABASE SET TABLESPACE"); movedb(stmt->dbname, defGetString(dtablespace)); return InvalidOid; } diff --git a/src/backend/commands/discard.c b/src/backend/commands/discard.c index 353ec990af..01a999c2ac 100644 --- a/src/backend/commands/discard.c +++ b/src/backend/commands/discard.c @@ -63,7 +63,7 @@ DiscardAll(bool isTopLevel) * DISCARD ALL inside a transaction block would leave the transaction * still uncommitted. */ - PreventTransactionChain(isTopLevel, "DISCARD ALL"); + PreventInTransactionBlock(isTopLevel, "DISCARD ALL"); /* Closing portals might run user-defined code, so do that first. */ PortalHashTableDeleteAll(); diff --git a/src/backend/commands/portalcmds.c b/src/backend/commands/portalcmds.c index 6ecaea1443..73821502ba 100644 --- a/src/backend/commands/portalcmds.c +++ b/src/backend/commands/portalcmds.c @@ -63,7 +63,7 @@ PerformCursorOpen(DeclareCursorStmt *cstmt, ParamListInfo params, * user-visible effect). */ if (!(cstmt->options & CURSOR_OPT_HOLD)) - RequireTransactionChain(isTopLevel, "DECLARE CURSOR"); + RequireTransactionBlock(isTopLevel, "DECLARE CURSOR"); /* * Parse analysis was done already, but we still have to run the rule diff --git a/src/backend/commands/subscriptioncmds.c b/src/backend/commands/subscriptioncmds.c index 9de5969302..2694e1b2d7 100644 --- a/src/backend/commands/subscriptioncmds.c +++ b/src/backend/commands/subscriptioncmds.c @@ -339,7 +339,7 @@ CreateSubscription(CreateSubscriptionStmt *stmt, bool isTopLevel) * replication slot. */ if (create_slot) - PreventTransactionChain(isTopLevel, "CREATE SUBSCRIPTION ... WITH (create_slot = true)"); + PreventInTransactionBlock(isTopLevel, "CREATE SUBSCRIPTION ... WITH (create_slot = true)"); if (!superuser()) ereport(ERROR, @@ -897,7 +897,7 @@ DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel) * don't have the proper facilities for that. */ if (slotname) - PreventTransactionChain(isTopLevel, "DROP SUBSCRIPTION"); + PreventInTransactionBlock(isTopLevel, "DROP SUBSCRIPTION"); ObjectAddressSet(myself, SubscriptionRelationId, subid); diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c index 899a5c4cd4..d1409bf9f0 100644 --- a/src/backend/commands/typecmds.c +++ b/src/backend/commands/typecmds.c @@ -1321,7 +1321,7 @@ AlterEnum(AlterEnumStmt *stmt, bool isTopLevel) !(tup->t_data->t_infomask & HEAP_UPDATED)) /* safe to do inside transaction block */ ; else - PreventTransactionChain(isTopLevel, "ALTER TYPE ... ADD"); + PreventInTransactionBlock(isTopLevel, "ALTER TYPE ... ADD"); AddEnumLabel(enum_type_oid, stmt->newVal, stmt->newValNeighbor, stmt->newValIsAfter, diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index 7aca69a0ba..8e7b69a400 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -186,11 +186,11 @@ vacuum(int options, List *relations, VacuumParams *params, */ if (options & VACOPT_VACUUM) { - PreventTransactionChain(isTopLevel, stmttype); + PreventInTransactionBlock(isTopLevel, stmttype); in_outer_xact = false; } else - in_outer_xact = IsInTransactionChain(isTopLevel); + in_outer_xact = IsInTransactionBlock(isTopLevel); /* * Due to static variables vac_context, anl_context and vac_strategy, diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index d46374ddce..5f52e33207 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -1516,7 +1516,7 @@ exec_replication_command(const char *cmd_string) break; case T_BaseBackupCmd: - PreventTransactionChain(true, "BASE_BACKUP"); + PreventInTransactionBlock(true, "BASE_BACKUP"); SendBaseBackup((BaseBackupCmd *) cmd_node); break; @@ -1532,7 +1532,7 @@ exec_replication_command(const char *cmd_string) { StartReplicationCmd *cmd = (StartReplicationCmd *) cmd_node; - PreventTransactionChain(true, "START_REPLICATION"); + PreventInTransactionBlock(true, "START_REPLICATION"); if (cmd->kind == REPLICATION_KIND_PHYSICAL) StartReplication(cmd); @@ -1542,7 +1542,7 @@ exec_replication_command(const char *cmd_string) } case T_TimeLineHistoryCmd: - PreventTransactionChain(true, "TIMELINE_HISTORY"); + PreventInTransactionBlock(true, "TIMELINE_HISTORY"); SendTimeLineHistory((TimeLineHistoryCmd *) cmd_node); break; diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c index f78efdf359..65fc947fc6 100644 --- a/src/backend/tcop/utility.c +++ b/src/backend/tcop/utility.c @@ -453,13 +453,13 @@ standard_ProcessUtility(PlannedStmt *pstmt, break; case TRANS_STMT_COMMIT_PREPARED: - PreventTransactionChain(isTopLevel, "COMMIT PREPARED"); + PreventInTransactionBlock(isTopLevel, "COMMIT PREPARED"); PreventCommandDuringRecovery("COMMIT PREPARED"); FinishPreparedTransaction(stmt->gid, true); break; case TRANS_STMT_ROLLBACK_PREPARED: - PreventTransactionChain(isTopLevel, "ROLLBACK PREPARED"); + PreventInTransactionBlock(isTopLevel, "ROLLBACK PREPARED"); PreventCommandDuringRecovery("ROLLBACK PREPARED"); FinishPreparedTransaction(stmt->gid, false); break; @@ -473,7 +473,7 @@ standard_ProcessUtility(PlannedStmt *pstmt, ListCell *cell; char *name = NULL; - RequireTransactionChain(isTopLevel, "SAVEPOINT"); + RequireTransactionBlock(isTopLevel, "SAVEPOINT"); foreach(cell, stmt->options) { @@ -490,12 +490,12 @@ standard_ProcessUtility(PlannedStmt *pstmt, break; case TRANS_STMT_RELEASE: - RequireTransactionChain(isTopLevel, "RELEASE SAVEPOINT"); + RequireTransactionBlock(isTopLevel, "RELEASE SAVEPOINT"); ReleaseSavepoint(stmt->options); break; case TRANS_STMT_ROLLBACK_TO: - RequireTransactionChain(isTopLevel, "ROLLBACK TO SAVEPOINT"); + RequireTransactionBlock(isTopLevel, "ROLLBACK TO SAVEPOINT"); RollbackToSavepoint(stmt->options); /* @@ -536,13 +536,13 @@ standard_ProcessUtility(PlannedStmt *pstmt, case T_CreateTableSpaceStmt: /* no event triggers for global objects */ - PreventTransactionChain(isTopLevel, "CREATE TABLESPACE"); + PreventInTransactionBlock(isTopLevel, "CREATE TABLESPACE"); CreateTableSpace((CreateTableSpaceStmt *) parsetree); break; case T_DropTableSpaceStmt: /* no event triggers for global objects */ - PreventTransactionChain(isTopLevel, "DROP TABLESPACE"); + PreventInTransactionBlock(isTopLevel, "DROP TABLESPACE"); DropTableSpace((DropTableSpaceStmt *) parsetree); break; @@ -592,7 +592,7 @@ standard_ProcessUtility(PlannedStmt *pstmt, case T_CreatedbStmt: /* no event triggers for global objects */ - PreventTransactionChain(isTopLevel, "CREATE DATABASE"); + PreventInTransactionBlock(isTopLevel, "CREATE DATABASE"); createdb(pstate, (CreatedbStmt *) parsetree); break; @@ -611,7 +611,7 @@ standard_ProcessUtility(PlannedStmt *pstmt, DropdbStmt *stmt = (DropdbStmt *) parsetree; /* no event triggers for global objects */ - PreventTransactionChain(isTopLevel, "DROP DATABASE"); + PreventInTransactionBlock(isTopLevel, "DROP DATABASE"); dropdb(stmt->dbname, stmt->missing_ok); } break; @@ -689,7 +689,7 @@ standard_ProcessUtility(PlannedStmt *pstmt, break; case T_AlterSystemStmt: - PreventTransactionChain(isTopLevel, "ALTER SYSTEM"); + PreventInTransactionBlock(isTopLevel, "ALTER SYSTEM"); AlterSystemSetConfigFile((AlterSystemStmt *) parsetree); break; @@ -755,13 +755,13 @@ standard_ProcessUtility(PlannedStmt *pstmt, * Since the lock would just get dropped immediately, LOCK TABLE * outside a transaction block is presumed to be user error. */ - RequireTransactionChain(isTopLevel, "LOCK TABLE"); + RequireTransactionBlock(isTopLevel, "LOCK TABLE"); /* forbidden in parallel mode due to CommandIsReadOnly */ LockTableCommand((LockStmt *) parsetree); break; case T_ConstraintsSetStmt: - WarnNoTransactionChain(isTopLevel, "SET CONSTRAINTS"); + WarnNoTransactionBlock(isTopLevel, "SET CONSTRAINTS"); AfterTriggerSetState((ConstraintsSetStmt *) parsetree); break; @@ -807,7 +807,7 @@ standard_ProcessUtility(PlannedStmt *pstmt, * start-transaction-command calls would not have the * intended effect! */ - PreventTransactionChain(isTopLevel, + PreventInTransactionBlock(isTopLevel, (stmt->kind == REINDEX_OBJECT_SCHEMA) ? "REINDEX SCHEMA" : (stmt->kind == REINDEX_OBJECT_SYSTEM) ? "REINDEX SYSTEM" : "REINDEX DATABASE"); @@ -1306,7 +1306,7 @@ ProcessUtilitySlow(ParseState *pstate, List *inheritors = NIL; if (stmt->concurrent) - PreventTransactionChain(isTopLevel, + PreventInTransactionBlock(isTopLevel, "CREATE INDEX CONCURRENTLY"); /* @@ -1714,7 +1714,7 @@ ExecDropStmt(DropStmt *stmt, bool isTopLevel) { case OBJECT_INDEX: if (stmt->concurrent) - PreventTransactionChain(isTopLevel, + PreventInTransactionBlock(isTopLevel, "DROP INDEX CONCURRENTLY"); /* fall through */ diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c index 1db7845d5a..14dadf514e 100644 --- a/src/backend/utils/misc/guc.c +++ b/src/backend/utils/misc/guc.c @@ -7347,7 +7347,7 @@ ExecSetVariableStmt(VariableSetStmt *stmt, bool isTopLevel) case VAR_SET_VALUE: case VAR_SET_CURRENT: if (stmt->is_local) - WarnNoTransactionChain(isTopLevel, "SET LOCAL"); + WarnNoTransactionBlock(isTopLevel, "SET LOCAL"); (void) set_config_option(stmt->name, ExtractSetVariableArgs(stmt), (superuser() ? PGC_SUSET : PGC_USERSET), @@ -7367,7 +7367,7 @@ ExecSetVariableStmt(VariableSetStmt *stmt, bool isTopLevel) { ListCell *head; - WarnNoTransactionChain(isTopLevel, "SET TRANSACTION"); + WarnNoTransactionBlock(isTopLevel, "SET TRANSACTION"); foreach(head, stmt->args) { @@ -7418,7 +7418,7 @@ ExecSetVariableStmt(VariableSetStmt *stmt, bool isTopLevel) (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("SET LOCAL TRANSACTION SNAPSHOT is not implemented"))); - WarnNoTransactionChain(isTopLevel, "SET TRANSACTION"); + WarnNoTransactionBlock(isTopLevel, "SET TRANSACTION"); Assert(nodeTag(&con->val) == T_String); ImportSnapshot(strVal(&con->val)); } @@ -7428,11 +7428,11 @@ ExecSetVariableStmt(VariableSetStmt *stmt, bool isTopLevel) break; case VAR_SET_DEFAULT: if (stmt->is_local) - WarnNoTransactionChain(isTopLevel, "SET LOCAL"); + WarnNoTransactionBlock(isTopLevel, "SET LOCAL"); /* fall through */ case VAR_RESET: if (strcmp(stmt->name, "transaction_isolation") == 0) - WarnNoTransactionChain(isTopLevel, "RESET TRANSACTION"); + WarnNoTransactionBlock(isTopLevel, "RESET TRANSACTION"); (void) set_config_option(stmt->name, NULL, diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c index e58c69dbd7..4b45d3cccd 100644 --- a/src/backend/utils/time/snapmgr.c +++ b/src/backend/utils/time/snapmgr.c @@ -1171,7 +1171,7 @@ ExportSnapshot(Snapshot snapshot) char pathtmp[MAXPGPATH]; /* - * It's tempting to call RequireTransactionChain here, since it's not very + * It's tempting to call RequireTransactionBlock here, since it's not very * useful to export a snapshot that will disappear immediately afterwards. * However, we haven't got enough information to do that, since we don't * know if we're at top level or not. For example, we could be inside a diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c index 1c82180efb..2b1c4daced 100644 --- a/src/bin/psql/common.c +++ b/src/bin/psql/common.c @@ -2047,7 +2047,7 @@ command_no_begin(const char *query) /* * Commands not allowed within transactions. The statements checked for - * here should be exactly those that call PreventTransactionChain() in the + * here should be exactly those that call PreventInTransactionBlock() in the * backend. */ if (wordlen == 6 && pg_strncasecmp(query, "vacuum", 6) == 0) diff --git a/src/include/access/xact.h b/src/include/access/xact.h index 6445bbc46f..4a1307a4f0 100644 --- a/src/include/access/xact.h +++ b/src/include/access/xact.h @@ -369,10 +369,10 @@ extern bool IsTransactionBlock(void); extern bool IsTransactionOrTransactionBlock(void); extern char TransactionBlockStatusCode(void); extern void AbortOutOfAnyTransaction(void); -extern void PreventTransactionChain(bool isTopLevel, const char *stmtType); -extern void RequireTransactionChain(bool isTopLevel, const char *stmtType); -extern void WarnNoTransactionChain(bool isTopLevel, const char *stmtType); -extern bool IsInTransactionChain(bool isTopLevel); +extern void PreventInTransactionBlock(bool isTopLevel, const char *stmtType); +extern void RequireTransactionBlock(bool isTopLevel, const char *stmtType); +extern void WarnNoTransactionBlock(bool isTopLevel, const char *stmtType); +extern bool IsInTransactionBlock(bool isTopLevel); extern void RegisterXactCallback(XactCallback callback, void *arg); extern void UnregisterXactCallback(XactCallback callback, void *arg); extern void RegisterSubXactCallback(SubXactCallback callback, void *arg); -- 2.16.2