database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-07 00:36:50 +03:00
Code Activity

Transaction chaining

Browse Source 
Add command variants COMMIT AND CHAIN and ROLLBACK AND CHAIN, which
start new transactions with the same transaction characteristics as the
just finished one, per SQL standard.

Support for transaction chaining in PL/pgSQL is also added.  This
functionality is especially useful when running COMMIT in a loop in
PL/pgSQL.

Reviewed-by: Fabien COELHO <coelho@cri.ensmp.fr>
Discussion: https://www.postgresql.org/message-id/flat/28536681-324b-10dc-ade8-ab46f7645a5a@2ndquadrant.com
This commit is contained in:
Peter Eisentraut
2019-03-24 10:33:14 +01:00
parent b2db277057
commit 280a408b48
26 changed files with 601 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
src/backend/access/transam/xact.c
View File

@ -190,6 +190,7 @@ typedef struct TransactionStateData
bool startedInRecovery; /* did we start in recovery? */
bool didLogXid; /* has xid been included in WAL record? */
int parallelModeLevel; /* Enter/ExitParallelMode counter */
bool chain; /* start a new block after this one */
struct TransactionStateData *parent; /* back link to parent */
} TransactionStateData;
@ -2775,6 +2776,36 @@ StartTransactionCommand(void)
MemoryContextSwitchTo(CurTransactionContext);
}
/*
* Simple system for saving and restoring transaction characteristics
* (isolation level, read only, deferrable). We need this for transaction
* chaining, so that we can set the characteristics of the new transaction to
* be the same as the previous one. (We need something like this because the
* GUC system resets the characteristics at transaction end, so for example
* just skipping the reset in StartTransaction() won't work.)
*/
static int save_XactIsoLevel;
static bool save_XactReadOnly;
static bool save_XactDeferrable;
void
SaveTransactionCharacteristics(void)
{
save_XactIsoLevel = XactIsoLevel;
save_XactReadOnly = XactReadOnly;
save_XactDeferrable = XactDeferrable;
}
void
RestoreTransactionCharacteristics(void)
{
XactIsoLevel = save_XactIsoLevel;
XactReadOnly = save_XactReadOnly;
XactDeferrable = save_XactDeferrable;
}
/*
* CommitTransactionCommand
*/
@ -2783,6 +2814,9 @@ CommitTransactionCommand(void)
{
TransactionState s = CurrentTransactionState;
if (s->chain)
SaveTransactionCharacteristics();
switch (s->blockState)
{
/*
@ -2834,6 +2868,13 @@ CommitTransactionCommand(void)
case TBLOCK_END:
CommitTransaction();
s->blockState = TBLOCK_DEFAULT;
if (s->chain)
{
StartTransaction();
s->blockState = TBLOCK_INPROGRESS;
s->chain = false;
RestoreTransactionCharacteristics();
}
break;
/*
@ -2853,6 +2894,13 @@ CommitTransactionCommand(void)
case TBLOCK_ABORT_END:
CleanupTransaction();
s->blockState = TBLOCK_DEFAULT;
if (s->chain)
{
StartTransaction();
s->blockState = TBLOCK_INPROGRESS;
s->chain = false;
RestoreTransactionCharacteristics();
}
break;
/*
@ -2864,6 +2912,13 @@ CommitTransactionCommand(void)
AbortTransaction();
CleanupTransaction();
s->blockState = TBLOCK_DEFAULT;
if (s->chain)
{
StartTransaction();
s->blockState = TBLOCK_INPROGRESS;
s->chain = false;
RestoreTransactionCharacteristics();
}
break;
/*
@ -3521,7 +3576,7 @@ PrepareTransactionBlock(const char *gid)
bool result;
/* Set up to commit the current transaction */
result = EndTransactionBlock();
result = EndTransactionBlock(false);
/* If successful, change outer tblock state to PREPARE */
if (result)
@ -3567,7 +3622,7 @@ PrepareTransactionBlock(const char *gid)
* resource owner, etc while executing inside a Portal.
*/
bool
EndTransactionBlock(void)
EndTransactionBlock(bool chain)
{
TransactionState s = CurrentTransactionState;
bool result = false;
@ -3693,6 +3748,13 @@ EndTransactionBlock(void)
break;
}
Assert(s->blockState == TBLOCK_STARTED ||
s->blockState == TBLOCK_END ||
s->blockState == TBLOCK_ABORT_END ||
s->blockState == TBLOCK_ABORT_PENDING);
s->chain = chain;
return result;
}
@ -3703,7 +3765,7 @@ EndTransactionBlock(void)
* As above, we don't actually do anything here except change blockState.
*/
void
UserAbortTransactionBlock(void)
UserAbortTransactionBlock(bool chain)
{
TransactionState s = CurrentTransactionState;
@ -3801,6 +3863,11 @@ UserAbortTransactionBlock(void)
BlockStateAsString(s->blockState));
break;
}
Assert(s->blockState == TBLOCK_ABORT_END ||
s->blockState == TBLOCK_ABORT_PENDING);
s->chain = chain;
}
/*

2
src/backend/catalog/sql_features.txt
View File

@ -443,7 +443,7 @@ T213 INSTEAD OF triggers YES
T231 Sensitive cursors YES
T241 START TRANSACTION statement YES
T251 SET TRANSACTION statement: LOCAL option NO
T261 Chained transactions NO
T261 Chained transactions YES
T271 Savepoints YES
T272 Enhanced savepoint management NO
T281 SELECT privilege with column granularity YES

50
src/backend/executor/spi.c
View File

@ -217,8 +217,8 @@ SPI_start_transaction(void)
MemoryContextSwitchTo(oldcontext);
}
void
SPI_commit(void)
static void
_SPI_commit(bool chain)
{
MemoryContext oldcontext = CurrentMemoryContext;
@ -250,14 +250,36 @@ SPI_commit(void)
while (ActiveSnapshotSet())
PopActiveSnapshot();
if (chain)
SaveTransactionCharacteristics();
CommitTransactionCommand();
if (chain)
{
StartTransactionCommand();
RestoreTransactionCharacteristics();
}
MemoryContextSwitchTo(oldcontext);
_SPI_current->internal_xact = false;
}
void
SPI_rollback(void)
SPI_commit(void)
{
_SPI_commit(false);
}
void
SPI_commit_and_chain(void)
{
_SPI_commit(true);
}
static void
_SPI_rollback(bool chain)
{
MemoryContext oldcontext = CurrentMemoryContext;
@ -274,12 +296,34 @@ SPI_rollback(void)
_SPI_current->internal_xact = true;
if (chain)
SaveTransactionCharacteristics();
AbortCurrentTransaction();
if (chain)
{
StartTransactionCommand();
RestoreTransactionCharacteristics();
}
MemoryContextSwitchTo(oldcontext);
_SPI_current->internal_xact = false;
}
void
SPI_rollback(void)
{
_SPI_rollback(false);
}
void
SPI_rollback_and_chain(void)
{
_SPI_rollback(true);
}
/*
* Clean up SPI state. Called on transaction end (of non-SPI-internal
* transactions) and when returning to the main loop on error.

1
src/backend/nodes/copyfuncs.c
View File

@ -3666,6 +3666,7 @@ _copyTransactionStmt(const TransactionStmt *from)
COPY_NODE_FIELD(options);
COPY_STRING_FIELD(savepoint_name);
COPY_STRING_FIELD(gid);
COPY_SCALAR_FIELD(chain);
return newnode;
}

1
src/backend/nodes/equalfuncs.c
View File

@ -1510,6 +1510,7 @@ _equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b)
COMPARE_NODE_FIELD(options);
COMPARE_STRING_FIELD(savepoint_name);
COMPARE_STRING_FIELD(gid);
COMPARE_SCALAR_FIELD(chain);
return true;
}

19
src/backend/parser/gram.y
View File

@ -312,6 +312,7 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
%type <boolean> opt_or_replace
opt_grant_grant_option opt_grant_admin_option
opt_nowait opt_if_exists opt_with_data
opt_transaction_chain
%type <ival> opt_nowait_or_skip
%type <list> OptRoleList AlterOptRoleList
@ -9792,11 +9793,12 @@ UnlistenStmt:
*****************************************************************************/
TransactionStmt:
ABORT_P opt_transaction
ABORT_P opt_transaction opt_transaction_chain
{
TransactionStmt *n = makeNode(TransactionStmt);
n->kind = TRANS_STMT_ROLLBACK;
n->options = NIL;
n->chain = $3;
$$ = (Node *)n;
}
| BEGIN_P opt_transaction transaction_mode_list_or_empty
@ -9813,25 +9815,28 @@ TransactionStmt:
n->options = $3;
$$ = (Node *)n;
}
| COMMIT opt_transaction
| COMMIT opt_transaction opt_transaction_chain
{
TransactionStmt *n = makeNode(TransactionStmt);
n->kind = TRANS_STMT_COMMIT;
n->options = NIL;
n->chain = $3;
$$ = (Node *)n;
}
| END_P opt_transaction
| END_P opt_transaction opt_transaction_chain
{
TransactionStmt *n = makeNode(TransactionStmt);
n->kind = TRANS_STMT_COMMIT;
n->options = NIL;
n->chain = $3;
$$ = (Node *)n;
}
| ROLLBACK opt_transaction
| ROLLBACK opt_transaction opt_transaction_chain
{
TransactionStmt *n = makeNode(TransactionStmt);
n->kind = TRANS_STMT_ROLLBACK;
n->options = NIL;
n->chain = $3;
$$ = (Node *)n;
}
| SAVEPOINT ColId
@ -9931,6 +9936,12 @@ transaction_mode_list_or_empty:
{ $$ = NIL; }
;
opt_transaction_chain:
AND CHAIN { $$ = true; }
| AND NO CHAIN { $$ = false; }
| /* EMPTY */ { $$ = false; }
;
/*****************************************************************************
*

4
src/backend/tcop/utility.c
View File

@ -440,7 +440,7 @@ standard_ProcessUtility(PlannedStmt *pstmt,
break;
case TRANS_STMT_COMMIT:
if (!EndTransactionBlock())
if (!EndTransactionBlock(stmt->chain))
{
/* report unsuccessful commit in completionTag */
if (completionTag)
@ -471,7 +471,7 @@ standard_ProcessUtility(PlannedStmt *pstmt,
break;
case TRANS_STMT_ROLLBACK:
UserAbortTransactionBlock();
UserAbortTransactionBlock(stmt->chain);
break;
case TRANS_STMT_SAVEPOINT:

8
src/bin/psql/tab-complete.c
View File

@ -2091,16 +2091,18 @@ psql_completion(const char *text, int start, int end)
COMPLETE_WITH("WORK", "TRANSACTION", "ISOLATION LEVEL", "READ", "DEFERRABLE", "NOT DEFERRABLE");
/* END, ABORT */
else if (Matches("END|ABORT"))
COMPLETE_WITH("WORK", "TRANSACTION");
COMPLETE_WITH("AND", "WORK", "TRANSACTION");
/* COMMIT */
else if (Matches("COMMIT"))
COMPLETE_WITH("WORK", "TRANSACTION", "PREPARED");
COMPLETE_WITH("AND", "WORK", "TRANSACTION", "PREPARED");
/* RELEASE SAVEPOINT */
else if (Matches("RELEASE"))
COMPLETE_WITH("SAVEPOINT");
/* ROLLBACK */
else if (Matches("ROLLBACK"))
COMPLETE_WITH("WORK", "TRANSACTION", "TO SAVEPOINT", "PREPARED");
COMPLETE_WITH("AND", "WORK", "TRANSACTION", "TO SAVEPOINT", "PREPARED");
else if (Matches("ABORT|END|COMMIT|ROLLBACK", "AND"))
COMPLETE_WITH("CHAIN");
/* CALL */
else if (Matches("CALL"))
COMPLETE_WITH_VERSIONED_SCHEMA_QUERY(Query_for_list_of_procedures, NULL);

6
src/include/access/xact.h
View File

@ -368,12 +368,14 @@ extern bool TransactionIdIsCurrentTransactionId(TransactionId xid);
extern void CommandCounterIncrement(void);
extern void ForceSyncCommit(void);
extern void StartTransactionCommand(void);
extern void SaveTransactionCharacteristics(void);
extern void RestoreTransactionCharacteristics(void);
extern void CommitTransactionCommand(void);
extern void AbortCurrentTransaction(void);
extern void BeginTransactionBlock(void);
extern bool EndTransactionBlock(void);
extern bool EndTransactionBlock(bool chain);
extern bool PrepareTransactionBlock(const char *gid);
extern void UserAbortTransactionBlock(void);
extern void UserAbortTransactionBlock(bool chain);
extern void BeginImplicitTransactionBlock(void);
extern void EndImplicitTransactionBlock(void);
extern void ReleaseSavepoint(const char *name);

2
src/include/executor/spi.h
View File

@ -160,7 +160,9 @@ extern int SPI_register_trigger_data(TriggerData *tdata);
extern void SPI_start_transaction(void);
extern void SPI_commit(void);
extern void SPI_commit_and_chain(void);
extern void SPI_rollback(void);
extern void SPI_rollback_and_chain(void);
extern void SPICleanup(void);
extern void AtEOXact_SPI(bool isCommit);

1
src/include/nodes/parsenodes.h
View File

@ -2998,6 +2998,7 @@ typedef struct TransactionStmt
List *options; /* for BEGIN/START commands */
char *savepoint_name; /* for savepoint commands */
char *gid; /* for two-phase-commit related commands */
bool chain; /* AND CHAIN option */
} TransactionStmt;
/* ----------------------

28
src/pl/plpgsql/src/expected/plpgsql_transaction.out
View File

@ -523,6 +523,34 @@ BEGIN
END;
$$;
CALL transaction_test11();
-- transaction chain
TRUNCATE test1;
DO LANGUAGE plpgsql $$
BEGIN
ROLLBACK;
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
FOR i IN 0..3 LOOP
RAISE INFO 'transaction_isolation = %', current_setting('transaction_isolation');
INSERT INTO test1 (a) VALUES (i);
IF i % 2 = 0 THEN
COMMIT AND CHAIN;
ELSE
ROLLBACK AND CHAIN;
END IF;
END LOOP;
END
$$;
INFO: transaction_isolation = repeatable read
INFO: transaction_isolation = repeatable read
INFO: transaction_isolation = repeatable read
INFO: transaction_isolation = repeatable read
SELECT * FROM test1;
a | b
---+---
0 |
2 |
(2 rows)
DROP TABLE test1;
DROP TABLE test2;
DROP TABLE test3;

18
src/pl/plpgsql/src/pl_exec.c
View File

@ -4773,8 +4773,13 @@ exec_stmt_commit(PLpgSQL_execstate *estate, PLpgSQL_stmt_commit *stmt)
{
HoldPinnedPortals();
SPI_commit();
SPI_start_transaction();
if (stmt->chain)
SPI_commit_and_chain();
else
{
SPI_commit();
SPI_start_transaction();
}
estate->simple_eval_estate = NULL;
plpgsql_create_econtext(estate);
@ -4792,8 +4797,13 @@ exec_stmt_rollback(PLpgSQL_execstate *estate, PLpgSQL_stmt_rollback *stmt)
{
HoldPinnedPortals();
SPI_rollback();
SPI_start_transaction();
if (stmt->chain)
SPI_rollback_and_chain();
else
{
SPI_rollback();
SPI_start_transaction();
}
estate->simple_eval_estate = NULL;
plpgsql_create_econtext(estate);

10
src/pl/plpgsql/src/pl_funcs.c
View File

@ -1318,14 +1318,20 @@ static void
dump_commit(PLpgSQL_stmt_commit *stmt)
{
dump_ind();
printf("COMMIT\n");
if (stmt->chain)
printf("COMMIT AND CHAIN\n");
else
printf("COMMIT\n");
}
static void
dump_rollback(PLpgSQL_stmt_rollback *stmt)
{
dump_ind();
printf("ROLLBACK\n");
if (stmt->chain)
printf("ROLLBACK AND CHAIN\n");
else
printf("ROLLBACK\n");
}
static void

18
src/pl/plpgsql/src/pl_gram.y
View File

@ -219,6 +219,8 @@ static void check_raise_parameters(PLpgSQL_stmt_raise *stmt);
%type <ival> opt_scrollable
%type <fetch> opt_fetch_direction
%type <ival> opt_transaction_chain
%type <keyword> unreserved_keyword
@ -252,6 +254,7 @@ static void check_raise_parameters(PLpgSQL_stmt_raise *stmt);
%token <keyword> K_ABSOLUTE
%token <keyword> K_ALIAS
%token <keyword> K_ALL
%token <keyword> K_AND
%token <keyword> K_ARRAY
%token <keyword> K_ASSERT
%token <keyword> K_BACKWARD
@ -259,6 +262,7 @@ static void check_raise_parameters(PLpgSQL_stmt_raise *stmt);
%token <keyword> K_BY
%token <keyword> K_CALL
%token <keyword> K_CASE
%token <keyword> K_CHAIN
%token <keyword> K_CLOSE
%token <keyword> K_COLLATE
%token <keyword> K_COLUMN
@ -2199,7 +2203,7 @@ stmt_null : K_NULL ';'
}
;
stmt_commit : K_COMMIT ';'
stmt_commit : K_COMMIT opt_transaction_chain ';'
{
PLpgSQL_stmt_commit *new;
@ -2207,12 +2211,13 @@ stmt_commit : K_COMMIT ';'
new->cmd_type = PLPGSQL_STMT_COMMIT;
new->lineno = plpgsql_location_to_lineno(@1);
new->stmtid = ++plpgsql_curr_compile->nstatements;
new->chain = $2;
$$ = (PLpgSQL_stmt *)new;
}
;
stmt_rollback : K_ROLLBACK ';'
stmt_rollback : K_ROLLBACK opt_transaction_chain ';'
{
PLpgSQL_stmt_rollback *new;
@ -2220,11 +2225,18 @@ stmt_rollback : K_ROLLBACK ';'
new->cmd_type = PLPGSQL_STMT_ROLLBACK;
new->lineno = plpgsql_location_to_lineno(@1);
new->stmtid = ++plpgsql_curr_compile->nstatements;
new->chain = $2;
$$ = (PLpgSQL_stmt *)new;
}
;
opt_transaction_chain:
K_AND K_CHAIN { $$ = true; }
| K_AND K_NO K_CHAIN { $$ = false; }
| /* EMPTY */ { $$ = false; }
;
stmt_set : K_SET
{
PLpgSQL_stmt_set *new;
@ -2482,10 +2494,12 @@ any_identifier : T_WORD
unreserved_keyword :
K_ABSOLUTE
| K_ALIAS
| K_AND
| K_ARRAY
| K_ASSERT
| K_BACKWARD
| K_CALL
| K_CHAIN
| K_CLOSE
| K_COLLATE
| K_COLUMN

2
src/pl/plpgsql/src/pl_unreserved_kwlist.h
View File

@ -29,10 +29,12 @@
/* name, value */
PG_KEYWORD("absolute", K_ABSOLUTE)
PG_KEYWORD("alias", K_ALIAS)
PG_KEYWORD("and", K_AND)
PG_KEYWORD("array", K_ARRAY)
PG_KEYWORD("assert", K_ASSERT)
PG_KEYWORD("backward", K_BACKWARD)
PG_KEYWORD("call", K_CALL)
PG_KEYWORD("chain", K_CHAIN)
PG_KEYWORD("close", K_CLOSE)
PG_KEYWORD("collate", K_COLLATE)
PG_KEYWORD("column", K_COLUMN)

2
src/pl/plpgsql/src/plpgsql.h
View File

@ -545,6 +545,7 @@ typedef struct PLpgSQL_stmt_commit
PLpgSQL_stmt_type cmd_type;
int lineno;
unsigned int stmtid;
bool chain;
} PLpgSQL_stmt_commit;
/*
@ -555,6 +556,7 @@ typedef struct PLpgSQL_stmt_rollback
PLpgSQL_stmt_type cmd_type;
int lineno;
unsigned int stmtid;
bool chain;
} PLpgSQL_stmt_rollback;
/*

23
src/pl/plpgsql/src/sql/plpgsql_transaction.sql
View File

@ -445,6 +445,29 @@ $$;
CALL transaction_test11();
-- transaction chain
TRUNCATE test1;
DO LANGUAGE plpgsql $$
BEGIN
ROLLBACK;
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
FOR i IN 0..3 LOOP
RAISE INFO 'transaction_isolation = %', current_setting('transaction_isolation');
INSERT INTO test1 (a) VALUES (i);
IF i % 2 = 0 THEN
COMMIT AND CHAIN;
ELSE
ROLLBACK AND CHAIN;
END IF;
END LOOP;
END
$$;
SELECT * FROM test1;
DROP TABLE test1;
DROP TABLE test2;
DROP TABLE test3;

191
src/test/regress/expected/transactions.out
View File

@ -659,6 +659,197 @@ ERROR: portal "ctt" cannot be run
COMMIT;
DROP FUNCTION create_temp_tab();
DROP FUNCTION invert(x float8);
-- Tests for AND CHAIN
CREATE TABLE abc (a int);
-- set nondefault value so we have something to override below
SET default_transaction_read_only = on;
START TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ WRITE, DEFERRABLE;
SHOW transaction_isolation;
transaction_isolation
-----------------------
repeatable read
(1 row)
SHOW transaction_read_only;
transaction_read_only
-----------------------
off
(1 row)
SHOW transaction_deferrable;
transaction_deferrable
------------------------
on
(1 row)
INSERT INTO abc VALUES (1);
INSERT INTO abc VALUES (2);
COMMIT AND CHAIN; -- TBLOCK_END
SHOW transaction_isolation;
transaction_isolation
-----------------------
repeatable read
(1 row)
SHOW transaction_read_only;
transaction_read_only
-----------------------
off
(1 row)
SHOW transaction_deferrable;
transaction_deferrable
------------------------
on
(1 row)
INSERT INTO abc VALUES ('error');
ERROR: invalid input syntax for type integer: "error"
LINE 1: INSERT INTO abc VALUES ('error');
^
INSERT INTO abc VALUES (3); -- check it's really aborted
ERROR: current transaction is aborted, commands ignored until end of transaction block
COMMIT AND CHAIN; -- TBLOCK_ABORT_END
SHOW transaction_isolation;
transaction_isolation
-----------------------
repeatable read
(1 row)
SHOW transaction_read_only;
transaction_read_only
-----------------------
off
(1 row)
SHOW transaction_deferrable;
transaction_deferrable
------------------------
on
(1 row)
INSERT INTO abc VALUES (4);
COMMIT;
START TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ WRITE, DEFERRABLE;
SHOW transaction_isolation;
transaction_isolation
-----------------------
repeatable read
(1 row)
SHOW transaction_read_only;
transaction_read_only
-----------------------
off
(1 row)
SHOW transaction_deferrable;
transaction_deferrable
------------------------
on
(1 row)
SAVEPOINT x;
INSERT INTO abc VALUES ('error');
ERROR: invalid input syntax for type integer: "error"
LINE 1: INSERT INTO abc VALUES ('error');
^
COMMIT AND CHAIN; -- TBLOCK_ABORT_PENDING
SHOW transaction_isolation;
transaction_isolation
-----------------------
repeatable read
(1 row)
SHOW transaction_read_only;
transaction_read_only
-----------------------
off
(1 row)
SHOW transaction_deferrable;
transaction_deferrable
------------------------
on
(1 row)
INSERT INTO abc VALUES (5);
COMMIT;
-- different mix of options just for fun
START TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ WRITE, NOT DEFERRABLE;
SHOW transaction_isolation;
transaction_isolation
-----------------------
serializable
(1 row)
SHOW transaction_read_only;
transaction_read_only
-----------------------
off
(1 row)
SHOW transaction_deferrable;
transaction_deferrable
------------------------
off
(1 row)
INSERT INTO abc VALUES (6);
ROLLBACK AND CHAIN; -- TBLOCK_ABORT_PENDING
SHOW transaction_isolation;
transaction_isolation
-----------------------
serializable
(1 row)
SHOW transaction_read_only;
transaction_read_only
-----------------------
off
(1 row)
SHOW transaction_deferrable;
transaction_deferrable
------------------------
off
(1 row)
INSERT INTO abc VALUES ('error');
ERROR: invalid input syntax for type integer: "error"
LINE 1: INSERT INTO abc VALUES ('error');
^
ROLLBACK AND CHAIN; -- TBLOCK_ABORT_END
SHOW transaction_isolation;
transaction_isolation
-----------------------
serializable
(1 row)
SHOW transaction_read_only;
transaction_read_only
-----------------------
off
(1 row)
SHOW transaction_deferrable;
transaction_deferrable
------------------------
off
(1 row)
ROLLBACK;
SELECT * FROM abc ORDER BY 1;
a
---
1
2
4
5
(4 rows)
RESET default_transaction_read_only;
DROP TABLE abc;
-- Test assorted behaviors around the implicit transaction block created
-- when multiple SQL commands are sent in a single Query message. These
-- tests rely on the fact that psql will not break SQL commands apart at a

63
src/test/regress/sql/transactions.sql
View File

@ -419,6 +419,69 @@ DROP FUNCTION create_temp_tab();
DROP FUNCTION invert(x float8);
-- Tests for AND CHAIN
CREATE TABLE abc (a int);
-- set nondefault value so we have something to override below
SET default_transaction_read_only = on;
START TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ WRITE, DEFERRABLE;
SHOW transaction_isolation;
SHOW transaction_read_only;
SHOW transaction_deferrable;
INSERT INTO abc VALUES (1);
INSERT INTO abc VALUES (2);
COMMIT AND CHAIN; -- TBLOCK_END
SHOW transaction_isolation;
SHOW transaction_read_only;
SHOW transaction_deferrable;
INSERT INTO abc VALUES ('error');
INSERT INTO abc VALUES (3); -- check it's really aborted
COMMIT AND CHAIN; -- TBLOCK_ABORT_END
SHOW transaction_isolation;
SHOW transaction_read_only;
SHOW transaction_deferrable;
INSERT INTO abc VALUES (4);
COMMIT;
START TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ WRITE, DEFERRABLE;
SHOW transaction_isolation;
SHOW transaction_read_only;
SHOW transaction_deferrable;
SAVEPOINT x;
INSERT INTO abc VALUES ('error');
COMMIT AND CHAIN; -- TBLOCK_ABORT_PENDING
SHOW transaction_isolation;
SHOW transaction_read_only;
SHOW transaction_deferrable;
INSERT INTO abc VALUES (5);
COMMIT;
-- different mix of options just for fun
START TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ WRITE, NOT DEFERRABLE;
SHOW transaction_isolation;
SHOW transaction_read_only;
SHOW transaction_deferrable;
INSERT INTO abc VALUES (6);
ROLLBACK AND CHAIN; -- TBLOCK_ABORT_PENDING
SHOW transaction_isolation;
SHOW transaction_read_only;
SHOW transaction_deferrable;
INSERT INTO abc VALUES ('error');
ROLLBACK AND CHAIN; -- TBLOCK_ABORT_END
SHOW transaction_isolation;
SHOW transaction_read_only;
SHOW transaction_deferrable;
ROLLBACK;
SELECT * FROM abc ORDER BY 1;
RESET default_transaction_read_only;
DROP TABLE abc;
-- Test assorted behaviors around the implicit transaction block created
-- when multiple SQL commands are sent in a single Query message. These
-- tests rely on the fact that psql will not break SQL commands apart at a