From e8af137358b1d89fb334ad1d715c3f81c15ba5cf Mon Sep 17 00:00:00 2001 From: Craig Ringer Date: Tue, 16 Aug 2016 16:54:00 +0800 Subject: [PATCH] Add txid_recent(bigint) => xid Provide a function to get the 32-bit xid from a bigint extended xid-with-epoch as returned by txid_current() etc, for use in functions that expect an xid argument. --- doc/src/sgml/func.sgml | 17 +++++++-- src/backend/utils/adt/txid.c | 56 ++++++++++++++++++++++++++++++ src/include/catalog/pg_proc.h | 2 ++ src/test/regress/expected/txid.out | 70 ++++++++++++++++++++++++++++++++++++++ src/test/regress/sql/txid.sql | 40 ++++++++++++++++++++++ 5 files changed, 182 insertions(+), 3 deletions(-) diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml index 02b25f9..4ae621f 100644 --- a/doc/src/sgml/func.sgml +++ b/doc/src/sgml/func.sgml @@ -16956,6 +16956,11 @@ SELECT collation for ('foo' COLLATE "de_DE"); boolean is transaction ID visible in snapshot? (do not use with subtransaction ids) + + txid_recent(bigint) + xid + return the 32-bit xid for a 64-bit transaction ID if it isn't wrapped around, otherwise return null + @@ -16964,9 +16969,15 @@ SELECT collation for ('foo' COLLATE "de_DE"); The internal transaction ID type (xid) is 32 bits wide and wraps around every 4 billion transactions. However, these functions export a 64-bit format that is extended with an epoch counter - so it will not wrap around during the life of an installation. - The data type used by these functions, txid_snapshot, - stores information about transaction ID + so it will not wrap around during the life of an installation. For that + reason you cannot cast a bigint transaction ID directly to xid + and must use txid_recent(bigint) instead of casting + to xid. + + + + The data type used by the xid snapshot functions, + txid_snapshot, stores information about transaction ID visibility at a particular moment in time. Its components are described in . diff --git a/src/backend/utils/adt/txid.c b/src/backend/utils/adt/txid.c index 4fa3cdb..9fdf9c7 100644 --- a/src/backend/utils/adt/txid.c +++ b/src/backend/utils/adt/txid.c @@ -117,6 +117,50 @@ convert_xid(TransactionId xid, const TxidEpoch *state) } /* + * Helper to get a TransactionId from a 64-bit txid with wraparound detection. + * ERRORs if the txid is in the future. Returns permanent XIDs unchanged. + * Otherwise returns the 32-bit xid and sets the wraparound param to true + * if wraparound is detected, false otherwise. + */ +static TransactionId +get_xid_in_recent_past(txid xid_with_epoch, bool *wraparound) +{ + uint32 xid_epoch = (uint32)(xid_with_epoch >>32); + TransactionId xid = (TransactionId)(xid_with_epoch); + TxidEpoch now_epoch; + + load_xid_epoch(&now_epoch); + + *wraparound = false; + + if (!TransactionIdIsNormal(xid)) + { + /* must be a permanent XID, ignore the epoch and return unchanged */ + return xid; + } + else if (xid_epoch > now_epoch.epoch + || (xid_epoch == now_epoch.epoch && xid > now_epoch.last_xid)) + { + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("transaction ID "UINT64_FORMAT" is in the future", + xid_with_epoch))); + } + else if (xid_epoch + 1 < now_epoch.epoch + || (xid_epoch + 1 == now_epoch.epoch && xid < now_epoch.last_xid)) + { + /* xid too far in the past */ + *wraparound = true; + } + else + { + Assert(TransactionIdPrecedes(xid, now_epoch.last_xid)); + } + + return xid; +} + +/* * txid comparator for qsort/bsearch */ static int @@ -640,3 +684,15 @@ txid_snapshot_xip(PG_FUNCTION_ARGS) SRF_RETURN_DONE(fctx); } } + +Datum +txid_recent(PG_FUNCTION_ARGS) +{ + bool wraparound; + TransactionId xid = get_xid_in_recent_past(PG_GETARG_INT64(0), &wraparound); + + if (wraparound) + PG_RETURN_NULL(); + else + return TransactionIdGetDatum(xid); +} diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h index 270dd21..dffe3b8 100644 --- a/src/include/catalog/pg_proc.h +++ b/src/include/catalog/pg_proc.h @@ -4903,6 +4903,8 @@ DATA(insert OID = 2947 ( txid_snapshot_xip PGNSP PGUID 12 1 50 0 0 f f f f t DESCR("get set of in-progress txids in snapshot"); DATA(insert OID = 2948 ( txid_visible_in_snapshot PGNSP PGUID 12 1 0 0 0 f f f f t f i s 2 0 16 "20 2970" _null_ _null_ _null_ _null_ _null_ txid_visible_in_snapshot _null_ _null_ _null_ )); DESCR("is txid visible in snapshot?"); +DATA(insert OID = 3344 ( txid_recent PGNSP PGUID 12 1 0 0 0 f f f f t f v s 1 0 28 "20" _null_ _null_ _null_ _null_ _null_ txid_recent _null_ _null_ _null_ )); +DESCR("get the xid from a bigint transaction id if not wrapped around"); /* record comparison using normal comparison rules */ DATA(insert OID = 2981 ( record_eq PGNSP PGUID 12 1 0 0 0 f f f f t f i s 2 0 16 "2249 2249" _null_ _null_ _null_ _null_ _null_ record_eq _null_ _null_ _null_ )); diff --git a/src/test/regress/expected/txid.out b/src/test/regress/expected/txid.out index ddd217e..ca8edb7 100644 --- a/src/test/regress/expected/txid.out +++ b/src/test/regress/expected/txid.out @@ -238,3 +238,73 @@ SELECT txid_snapshot '1:9223372036854775808:3'; ERROR: invalid input syntax for type txid_snapshot: "1:9223372036854775808:3" LINE 1: SELECT txid_snapshot '1:9223372036854775808:3'; ^ +-- test xid status functions +BEGIN; +SELECT txid_current() AS committed \gset +COMMIT; +BEGIN; +SELECT txid_current() AS rolledback \gset +ROLLBACK; +BEGIN; +SELECT txid_current() AS inprogress \gset +-- We can reasonably assume we haven't hit the first xid +-- wraparound here, so: +SELECT txid_recent(:committed) = :'committed'::xid; + ?column? +---------- + t +(1 row) + +SELECT txid_recent(:rolledback) = :'rolledback'::xid; + ?column? +---------- + t +(1 row) + +SELECT txid_recent(:inprogress) = :'inprogress'::xid; + ?column? +---------- + t +(1 row) + +SELECT txid_recent(0) = '0'::xid; -- InvalidTransactionId + ?column? +---------- + t +(1 row) + +SELECT txid_recent(1) = '1'::xid; -- BootstrapTransactionId + ?column? +---------- + t +(1 row) + +SELECT txid_recent(2) = '2'::xid; -- FrozenTransactionId + ?column? +---------- + t +(1 row) + +COMMIT; +BEGIN; +CREATE FUNCTION test_future_xid(bigint) +RETURNS void +LANGUAGE plpgsql +AS +$$ +BEGIN + PERFORM txid_recent($1); + RAISE EXCEPTION 'didn''t ERROR at xid in the future as expected'; +EXCEPTION + WHEN invalid_parameter_value THEN + RAISE NOTICE 'Got expected error for xid in the future'; +END; +$$; +SELECT test_future_xid(:inprogress + 100); +NOTICE: Got expected error for xid in the future + test_future_xid +----------------- + +(1 row) + +ROLLBACK; diff --git a/src/test/regress/sql/txid.sql b/src/test/regress/sql/txid.sql index b6650b9..4c1d548 100644 --- a/src/test/regress/sql/txid.sql +++ b/src/test/regress/sql/txid.sql @@ -52,3 +52,43 @@ select txid_visible_in_snapshot('1000100010001015', '1000100010001000:1000100010 -- test 64bit overflow SELECT txid_snapshot '1:9223372036854775807:3'; SELECT txid_snapshot '1:9223372036854775808:3'; + +-- test xid status functions +BEGIN; +SELECT txid_current() AS committed \gset +COMMIT; + +BEGIN; +SELECT txid_current() AS rolledback \gset +ROLLBACK; + +BEGIN; +SELECT txid_current() AS inprogress \gset + +-- We can reasonably assume we haven't hit the first xid +-- wraparound here, so: +SELECT txid_recent(:committed) = :'committed'::xid; +SELECT txid_recent(:rolledback) = :'rolledback'::xid; +SELECT txid_recent(:inprogress) = :'inprogress'::xid; +SELECT txid_recent(0) = '0'::xid; -- InvalidTransactionId +SELECT txid_recent(1) = '1'::xid; -- BootstrapTransactionId +SELECT txid_recent(2) = '2'::xid; -- FrozenTransactionId + +COMMIT; + +BEGIN; +CREATE FUNCTION test_future_xid(bigint) +RETURNS void +LANGUAGE plpgsql +AS +$$ +BEGIN + PERFORM txid_recent($1); + RAISE EXCEPTION 'didn''t ERROR at xid in the future as expected'; +EXCEPTION + WHEN invalid_parameter_value THEN + RAISE NOTICE 'Got expected error for xid in the future'; +END; +$$; +SELECT test_future_xid(:inprogress + 100); +ROLLBACK; -- 2.5.5