2020-04-07 01:08:14 +02:00
|
|
|
-- xid and xid8
|
|
|
|
-- values in range, in octal, decimal, hex
|
|
|
|
select '010'::xid,
|
|
|
|
'42'::xid,
|
|
|
|
'0xffffffff'::xid,
|
|
|
|
'-1'::xid,
|
|
|
|
'010'::xid8,
|
|
|
|
'42'::xid8,
|
|
|
|
'0xffffffffffffffff'::xid8,
|
|
|
|
'-1'::xid8;
|
|
|
|
xid | xid | xid | xid | xid8 | xid8 | xid8 | xid8
|
|
|
|
-----+-----+------------+------------+------+------+----------------------+----------------------
|
|
|
|
8 | 42 | 4294967295 | 4294967295 | 8 | 42 | 18446744073709551615 | 18446744073709551615
|
|
|
|
(1 row)
|
|
|
|
|
Detect bad input for types xid, xid8, and cid.
Historically these input functions just called strtoul or strtoull
and returned the result, with no error detection whatever. Upgrade
them to reject garbage input and out-of-range values, similarly to
our other numeric input routines.
To share the code for this with type oid, adjust the existing
"oidin_subr" to be agnostic about the SQL name of the type it is
handling, and move it to numutils.c; then clone it for 64-bit types.
Because the xid types previously accepted hex and octal input by
reason of calling strtoul[l] with third argument zero, I made the
common subroutine do that too, with the consequence that type oid
now also accepts hex and octal input. In view of 6fcda9aba, that
seems like a good thing.
While at it, simplify the existing over-complicated handling of
syntax errors from strtoul: we only need one ereturn not three.
Discussion: https://postgr.es/m/3526121.1672000729@sss.pgh.pa.us
2022-12-27 17:40:01 +01:00
|
|
|
-- garbage values
|
2020-04-07 01:08:14 +02:00
|
|
|
select ''::xid;
|
Detect bad input for types xid, xid8, and cid.
Historically these input functions just called strtoul or strtoull
and returned the result, with no error detection whatever. Upgrade
them to reject garbage input and out-of-range values, similarly to
our other numeric input routines.
To share the code for this with type oid, adjust the existing
"oidin_subr" to be agnostic about the SQL name of the type it is
handling, and move it to numutils.c; then clone it for 64-bit types.
Because the xid types previously accepted hex and octal input by
reason of calling strtoul[l] with third argument zero, I made the
common subroutine do that too, with the consequence that type oid
now also accepts hex and octal input. In view of 6fcda9aba, that
seems like a good thing.
While at it, simplify the existing over-complicated handling of
syntax errors from strtoul: we only need one ereturn not three.
Discussion: https://postgr.es/m/3526121.1672000729@sss.pgh.pa.us
2022-12-27 17:40:01 +01:00
|
|
|
ERROR: invalid input syntax for type xid: ""
|
|
|
|
LINE 1: select ''::xid;
|
|
|
|
^
|
|
|
|
select 'asdf'::xid;
|
|
|
|
ERROR: invalid input syntax for type xid: "asdf"
|
|
|
|
LINE 1: select 'asdf'::xid;
|
|
|
|
^
|
|
|
|
select ''::xid8;
|
|
|
|
ERROR: invalid input syntax for type xid8: ""
|
|
|
|
LINE 1: select ''::xid8;
|
|
|
|
^
|
|
|
|
select 'asdf'::xid8;
|
|
|
|
ERROR: invalid input syntax for type xid8: "asdf"
|
|
|
|
LINE 1: select 'asdf'::xid8;
|
|
|
|
^
|
|
|
|
-- Also try it with non-error-throwing API
|
|
|
|
SELECT pg_input_is_valid('42', 'xid');
|
|
|
|
pg_input_is_valid
|
|
|
|
-------------------
|
|
|
|
t
|
2020-04-07 01:08:14 +02:00
|
|
|
(1 row)
|
|
|
|
|
Detect bad input for types xid, xid8, and cid.
Historically these input functions just called strtoul or strtoull
and returned the result, with no error detection whatever. Upgrade
them to reject garbage input and out-of-range values, similarly to
our other numeric input routines.
To share the code for this with type oid, adjust the existing
"oidin_subr" to be agnostic about the SQL name of the type it is
handling, and move it to numutils.c; then clone it for 64-bit types.
Because the xid types previously accepted hex and octal input by
reason of calling strtoul[l] with third argument zero, I made the
common subroutine do that too, with the consequence that type oid
now also accepts hex and octal input. In view of 6fcda9aba, that
seems like a good thing.
While at it, simplify the existing over-complicated handling of
syntax errors from strtoul: we only need one ereturn not three.
Discussion: https://postgr.es/m/3526121.1672000729@sss.pgh.pa.us
2022-12-27 17:40:01 +01:00
|
|
|
SELECT pg_input_is_valid('asdf', 'xid');
|
|
|
|
pg_input_is_valid
|
|
|
|
-------------------
|
|
|
|
f
|
2020-04-07 01:08:14 +02:00
|
|
|
(1 row)
|
|
|
|
|
2023-02-28 00:04:13 +01:00
|
|
|
SELECT * FROM pg_input_error_info('0xffffffffff', 'xid');
|
|
|
|
message | detail | hint | sql_error_code
|
|
|
|
---------------------------------------------------+--------+------+----------------
|
|
|
|
value "0xffffffffff" is out of range for type xid | | | 22003
|
2020-04-07 01:08:14 +02:00
|
|
|
(1 row)
|
|
|
|
|
Detect bad input for types xid, xid8, and cid.
Historically these input functions just called strtoul or strtoull
and returned the result, with no error detection whatever. Upgrade
them to reject garbage input and out-of-range values, similarly to
our other numeric input routines.
To share the code for this with type oid, adjust the existing
"oidin_subr" to be agnostic about the SQL name of the type it is
handling, and move it to numutils.c; then clone it for 64-bit types.
Because the xid types previously accepted hex and octal input by
reason of calling strtoul[l] with third argument zero, I made the
common subroutine do that too, with the consequence that type oid
now also accepts hex and octal input. In view of 6fcda9aba, that
seems like a good thing.
While at it, simplify the existing over-complicated handling of
syntax errors from strtoul: we only need one ereturn not three.
Discussion: https://postgr.es/m/3526121.1672000729@sss.pgh.pa.us
2022-12-27 17:40:01 +01:00
|
|
|
SELECT pg_input_is_valid('42', 'xid8');
|
|
|
|
pg_input_is_valid
|
|
|
|
-------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT pg_input_is_valid('asdf', 'xid8');
|
|
|
|
pg_input_is_valid
|
|
|
|
-------------------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
2023-02-28 00:04:13 +01:00
|
|
|
SELECT * FROM pg_input_error_info('0xffffffffffffffffffff', 'xid8');
|
|
|
|
message | detail | hint | sql_error_code
|
|
|
|
--------------------------------------------------------------+--------+------+----------------
|
|
|
|
value "0xffffffffffffffffffff" is out of range for type xid8 | | | 22003
|
2020-04-07 01:08:14 +02:00
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- equality
|
|
|
|
select '1'::xid = '1'::xid;
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select '1'::xid != '1'::xid;
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select '1'::xid8 = '1'::xid8;
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select '1'::xid8 != '1'::xid8;
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- conversion
|
|
|
|
select '1'::xid = '1'::xid8::xid;
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select '1'::xid != '1'::xid8::xid;
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- we don't want relational operators for xid, due to use of modular arithmetic
|
|
|
|
select '1'::xid < '2'::xid;
|
|
|
|
ERROR: operator does not exist: xid < xid
|
|
|
|
LINE 1: select '1'::xid < '2'::xid;
|
|
|
|
^
|
|
|
|
HINT: No operator matches the given name and argument types. You might need to add explicit type casts.
|
|
|
|
select '1'::xid <= '2'::xid;
|
|
|
|
ERROR: operator does not exist: xid <= xid
|
|
|
|
LINE 1: select '1'::xid <= '2'::xid;
|
|
|
|
^
|
|
|
|
HINT: No operator matches the given name and argument types. You might need to add explicit type casts.
|
|
|
|
select '1'::xid > '2'::xid;
|
|
|
|
ERROR: operator does not exist: xid > xid
|
|
|
|
LINE 1: select '1'::xid > '2'::xid;
|
|
|
|
^
|
|
|
|
HINT: No operator matches the given name and argument types. You might need to add explicit type casts.
|
|
|
|
select '1'::xid >= '2'::xid;
|
|
|
|
ERROR: operator does not exist: xid >= xid
|
|
|
|
LINE 1: select '1'::xid >= '2'::xid;
|
|
|
|
^
|
|
|
|
HINT: No operator matches the given name and argument types. You might need to add explicit type casts.
|
|
|
|
-- we want them for xid8 though
|
|
|
|
select '1'::xid8 < '2'::xid8, '2'::xid8 < '2'::xid8, '2'::xid8 < '1'::xid8;
|
|
|
|
?column? | ?column? | ?column?
|
|
|
|
----------+----------+----------
|
|
|
|
t | f | f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select '1'::xid8 <= '2'::xid8, '2'::xid8 <= '2'::xid8, '2'::xid8 <= '1'::xid8;
|
|
|
|
?column? | ?column? | ?column?
|
|
|
|
----------+----------+----------
|
|
|
|
t | t | f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select '1'::xid8 > '2'::xid8, '2'::xid8 > '2'::xid8, '2'::xid8 > '1'::xid8;
|
|
|
|
?column? | ?column? | ?column?
|
|
|
|
----------+----------+----------
|
|
|
|
f | f | t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select '1'::xid8 >= '2'::xid8, '2'::xid8 >= '2'::xid8, '2'::xid8 >= '1'::xid8;
|
|
|
|
?column? | ?column? | ?column?
|
|
|
|
----------+----------+----------
|
|
|
|
f | t | t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- we also have a 3way compare for btrees
|
|
|
|
select xid8cmp('1', '2'), xid8cmp('2', '2'), xid8cmp('2', '1');
|
|
|
|
xid8cmp | xid8cmp | xid8cmp
|
|
|
|
---------+---------+---------
|
|
|
|
-1 | 0 | 1
|
|
|
|
(1 row)
|
|
|
|
|
2022-02-10 04:33:41 +01:00
|
|
|
-- min() and max() for xid8
|
2020-04-07 01:08:14 +02:00
|
|
|
create table xid8_t1 (x xid8);
|
2022-02-10 04:33:41 +01:00
|
|
|
insert into xid8_t1 values ('0'), ('010'), ('42'), ('0xffffffffffffffff'), ('-1');
|
|
|
|
select min(x), max(x) from xid8_t1;
|
|
|
|
min | max
|
|
|
|
-----+----------------------
|
|
|
|
0 | 18446744073709551615
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- xid8 has btree and hash opclasses
|
2020-04-07 01:08:14 +02:00
|
|
|
create index on xid8_t1 using btree(x);
|
|
|
|
create index on xid8_t1 using hash(x);
|
|
|
|
drop table xid8_t1;
|
2020-04-07 01:33:56 +02:00
|
|
|
-- pg_snapshot data type and related functions
|
|
|
|
-- Note: another set of tests similar to this exists in txid.sql, for a limited
|
|
|
|
-- time (the relevant functions share C code)
|
|
|
|
-- i/o
|
|
|
|
select '12:13:'::pg_snapshot;
|
|
|
|
pg_snapshot
|
|
|
|
-------------
|
|
|
|
12:13:
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select '12:18:14,16'::pg_snapshot;
|
|
|
|
pg_snapshot
|
|
|
|
-------------
|
|
|
|
12:18:14,16
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select '12:16:14,14'::pg_snapshot;
|
|
|
|
pg_snapshot
|
|
|
|
-------------
|
|
|
|
12:16:14
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- errors
|
|
|
|
select '31:12:'::pg_snapshot;
|
|
|
|
ERROR: invalid input syntax for type pg_snapshot: "31:12:"
|
|
|
|
LINE 1: select '31:12:'::pg_snapshot;
|
|
|
|
^
|
|
|
|
select '0:1:'::pg_snapshot;
|
|
|
|
ERROR: invalid input syntax for type pg_snapshot: "0:1:"
|
|
|
|
LINE 1: select '0:1:'::pg_snapshot;
|
|
|
|
^
|
|
|
|
select '12:13:0'::pg_snapshot;
|
|
|
|
ERROR: invalid input syntax for type pg_snapshot: "12:13:0"
|
|
|
|
LINE 1: select '12:13:0'::pg_snapshot;
|
|
|
|
^
|
|
|
|
select '12:16:14,13'::pg_snapshot;
|
|
|
|
ERROR: invalid input syntax for type pg_snapshot: "12:16:14,13"
|
|
|
|
LINE 1: select '12:16:14,13'::pg_snapshot;
|
|
|
|
^
|
Convert a few more datatype input functions to report errors softly.
Convert assorted internal-ish datatypes, namely aclitemin,
int2vectorin, oidin, oidvectorin, pg_lsn_in, pg_snapshot_in,
and tidin to the new style.
(Some others you might expect to find in this group, such as
cidin and xidin, need no changes because they never throw
errors at all. That seems a little cheesy ... but it is not in
the charter of this patch series to add new error conditions.)
Amul Sul, minor mods by me
Discussion: https://postgr.es/m/CAAJ_b97KeDWUdpTKGOaFYPv0OicjOu6EW+QYWj-Ywrgj_aEy1g@mail.gmail.com
2022-12-14 23:50:24 +01:00
|
|
|
-- also try it with non-error-throwing API
|
|
|
|
select pg_input_is_valid('12:13:', 'pg_snapshot');
|
|
|
|
pg_input_is_valid
|
|
|
|
-------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select pg_input_is_valid('31:12:', 'pg_snapshot');
|
|
|
|
pg_input_is_valid
|
|
|
|
-------------------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
2023-02-28 00:04:13 +01:00
|
|
|
select * from pg_input_error_info('31:12:', 'pg_snapshot');
|
|
|
|
message | detail | hint | sql_error_code
|
|
|
|
-----------------------------------------------------+--------+------+----------------
|
|
|
|
invalid input syntax for type pg_snapshot: "31:12:" | | | 22P02
|
Convert a few more datatype input functions to report errors softly.
Convert assorted internal-ish datatypes, namely aclitemin,
int2vectorin, oidin, oidvectorin, pg_lsn_in, pg_snapshot_in,
and tidin to the new style.
(Some others you might expect to find in this group, such as
cidin and xidin, need no changes because they never throw
errors at all. That seems a little cheesy ... but it is not in
the charter of this patch series to add new error conditions.)
Amul Sul, minor mods by me
Discussion: https://postgr.es/m/CAAJ_b97KeDWUdpTKGOaFYPv0OicjOu6EW+QYWj-Ywrgj_aEy1g@mail.gmail.com
2022-12-14 23:50:24 +01:00
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select pg_input_is_valid('12:16:14,13', 'pg_snapshot');
|
|
|
|
pg_input_is_valid
|
|
|
|
-------------------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
2023-02-28 00:04:13 +01:00
|
|
|
select * from pg_input_error_info('12:16:14,13', 'pg_snapshot');
|
|
|
|
message | detail | hint | sql_error_code
|
|
|
|
----------------------------------------------------------+--------+------+----------------
|
|
|
|
invalid input syntax for type pg_snapshot: "12:16:14,13" | | | 22P02
|
Convert a few more datatype input functions to report errors softly.
Convert assorted internal-ish datatypes, namely aclitemin,
int2vectorin, oidin, oidvectorin, pg_lsn_in, pg_snapshot_in,
and tidin to the new style.
(Some others you might expect to find in this group, such as
cidin and xidin, need no changes because they never throw
errors at all. That seems a little cheesy ... but it is not in
the charter of this patch series to add new error conditions.)
Amul Sul, minor mods by me
Discussion: https://postgr.es/m/CAAJ_b97KeDWUdpTKGOaFYPv0OicjOu6EW+QYWj-Ywrgj_aEy1g@mail.gmail.com
2022-12-14 23:50:24 +01:00
|
|
|
(1 row)
|
|
|
|
|
2020-04-07 01:33:56 +02:00
|
|
|
create temp table snapshot_test (
|
|
|
|
nr integer,
|
|
|
|
snap pg_snapshot
|
|
|
|
);
|
|
|
|
insert into snapshot_test values (1, '12:13:');
|
|
|
|
insert into snapshot_test values (2, '12:20:13,15,18');
|
|
|
|
insert into snapshot_test values (3, '100001:100009:100005,100007,100008');
|
|
|
|
insert into snapshot_test values (4, '100:150:101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131');
|
|
|
|
select snap from snapshot_test order by nr;
|
|
|
|
snap
|
|
|
|
-------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
12:13:
|
|
|
|
12:20:13,15,18
|
|
|
|
100001:100009:100005,100007,100008
|
|
|
|
100:150:101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131
|
|
|
|
(4 rows)
|
|
|
|
|
|
|
|
select pg_snapshot_xmin(snap),
|
|
|
|
pg_snapshot_xmax(snap),
|
|
|
|
pg_snapshot_xip(snap)
|
|
|
|
from snapshot_test order by nr;
|
|
|
|
pg_snapshot_xmin | pg_snapshot_xmax | pg_snapshot_xip
|
|
|
|
------------------+------------------+-----------------
|
|
|
|
12 | 20 | 13
|
|
|
|
12 | 20 | 15
|
|
|
|
12 | 20 | 18
|
|
|
|
100001 | 100009 | 100005
|
|
|
|
100001 | 100009 | 100007
|
|
|
|
100001 | 100009 | 100008
|
|
|
|
100 | 150 | 101
|
|
|
|
100 | 150 | 102
|
|
|
|
100 | 150 | 103
|
|
|
|
100 | 150 | 104
|
|
|
|
100 | 150 | 105
|
|
|
|
100 | 150 | 106
|
|
|
|
100 | 150 | 107
|
|
|
|
100 | 150 | 108
|
|
|
|
100 | 150 | 109
|
|
|
|
100 | 150 | 110
|
|
|
|
100 | 150 | 111
|
|
|
|
100 | 150 | 112
|
|
|
|
100 | 150 | 113
|
|
|
|
100 | 150 | 114
|
|
|
|
100 | 150 | 115
|
|
|
|
100 | 150 | 116
|
|
|
|
100 | 150 | 117
|
|
|
|
100 | 150 | 118
|
|
|
|
100 | 150 | 119
|
|
|
|
100 | 150 | 120
|
|
|
|
100 | 150 | 121
|
|
|
|
100 | 150 | 122
|
|
|
|
100 | 150 | 123
|
|
|
|
100 | 150 | 124
|
|
|
|
100 | 150 | 125
|
|
|
|
100 | 150 | 126
|
|
|
|
100 | 150 | 127
|
|
|
|
100 | 150 | 128
|
|
|
|
100 | 150 | 129
|
|
|
|
100 | 150 | 130
|
|
|
|
100 | 150 | 131
|
|
|
|
(37 rows)
|
|
|
|
|
|
|
|
select id, pg_visible_in_snapshot(id::text::xid8, snap)
|
|
|
|
from snapshot_test, generate_series(11, 21) id
|
|
|
|
where nr = 2;
|
|
|
|
id | pg_visible_in_snapshot
|
|
|
|
----+------------------------
|
|
|
|
11 | t
|
|
|
|
12 | t
|
|
|
|
13 | f
|
|
|
|
14 | t
|
|
|
|
15 | f
|
|
|
|
16 | t
|
|
|
|
17 | t
|
|
|
|
18 | f
|
|
|
|
19 | t
|
|
|
|
20 | f
|
|
|
|
21 | f
|
|
|
|
(11 rows)
|
|
|
|
|
|
|
|
-- test bsearch
|
|
|
|
select id, pg_visible_in_snapshot(id::text::xid8, snap)
|
|
|
|
from snapshot_test, generate_series(90, 160) id
|
|
|
|
where nr = 4;
|
|
|
|
id | pg_visible_in_snapshot
|
|
|
|
-----+------------------------
|
|
|
|
90 | t
|
|
|
|
91 | t
|
|
|
|
92 | t
|
|
|
|
93 | t
|
|
|
|
94 | t
|
|
|
|
95 | t
|
|
|
|
96 | t
|
|
|
|
97 | t
|
|
|
|
98 | t
|
|
|
|
99 | t
|
|
|
|
100 | t
|
|
|
|
101 | f
|
|
|
|
102 | f
|
|
|
|
103 | f
|
|
|
|
104 | f
|
|
|
|
105 | f
|
|
|
|
106 | f
|
|
|
|
107 | f
|
|
|
|
108 | f
|
|
|
|
109 | f
|
|
|
|
110 | f
|
|
|
|
111 | f
|
|
|
|
112 | f
|
|
|
|
113 | f
|
|
|
|
114 | f
|
|
|
|
115 | f
|
|
|
|
116 | f
|
|
|
|
117 | f
|
|
|
|
118 | f
|
|
|
|
119 | f
|
|
|
|
120 | f
|
|
|
|
121 | f
|
|
|
|
122 | f
|
|
|
|
123 | f
|
|
|
|
124 | f
|
|
|
|
125 | f
|
|
|
|
126 | f
|
|
|
|
127 | f
|
|
|
|
128 | f
|
|
|
|
129 | f
|
|
|
|
130 | f
|
|
|
|
131 | f
|
|
|
|
132 | t
|
|
|
|
133 | t
|
|
|
|
134 | t
|
|
|
|
135 | t
|
|
|
|
136 | t
|
|
|
|
137 | t
|
|
|
|
138 | t
|
|
|
|
139 | t
|
|
|
|
140 | t
|
|
|
|
141 | t
|
|
|
|
142 | t
|
|
|
|
143 | t
|
|
|
|
144 | t
|
|
|
|
145 | t
|
|
|
|
146 | t
|
|
|
|
147 | t
|
|
|
|
148 | t
|
|
|
|
149 | t
|
|
|
|
150 | f
|
|
|
|
151 | f
|
|
|
|
152 | f
|
|
|
|
153 | f
|
|
|
|
154 | f
|
|
|
|
155 | f
|
|
|
|
156 | f
|
|
|
|
157 | f
|
|
|
|
158 | f
|
|
|
|
159 | f
|
|
|
|
160 | f
|
|
|
|
(71 rows)
|
|
|
|
|
|
|
|
-- test current values also
|
|
|
|
select pg_current_xact_id() >= pg_snapshot_xmin(pg_current_snapshot());
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- we can't assume current is always less than xmax, however
|
|
|
|
select pg_visible_in_snapshot(pg_current_xact_id(), pg_current_snapshot());
|
|
|
|
pg_visible_in_snapshot
|
|
|
|
------------------------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- test 64bitness
|
|
|
|
select pg_snapshot '1000100010001000:1000100010001100:1000100010001012,1000100010001013';
|
|
|
|
pg_snapshot
|
|
|
|
---------------------------------------------------------------------
|
|
|
|
1000100010001000:1000100010001100:1000100010001012,1000100010001013
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select pg_visible_in_snapshot('1000100010001012', '1000100010001000:1000100010001100:1000100010001012,1000100010001013');
|
|
|
|
pg_visible_in_snapshot
|
|
|
|
------------------------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select pg_visible_in_snapshot('1000100010001015', '1000100010001000:1000100010001100:1000100010001012,1000100010001013');
|
|
|
|
pg_visible_in_snapshot
|
|
|
|
------------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- test 64bit overflow
|
|
|
|
SELECT pg_snapshot '1:9223372036854775807:3';
|
|
|
|
pg_snapshot
|
|
|
|
-------------------------
|
|
|
|
1:9223372036854775807:3
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT pg_snapshot '1:9223372036854775808:3';
|
|
|
|
ERROR: invalid input syntax for type pg_snapshot: "1:9223372036854775808:3"
|
|
|
|
LINE 1: SELECT pg_snapshot '1:9223372036854775808:3';
|
|
|
|
^
|
|
|
|
-- test pg_current_xact_id_if_assigned
|
|
|
|
BEGIN;
|
|
|
|
SELECT pg_current_xact_id_if_assigned() IS NULL;
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT pg_current_xact_id() \gset
|
|
|
|
SELECT pg_current_xact_id_if_assigned() IS NOT DISTINCT FROM xid8 :'pg_current_xact_id';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
COMMIT;
|
|
|
|
-- test xid status functions
|
|
|
|
BEGIN;
|
|
|
|
SELECT pg_current_xact_id() AS committed \gset
|
|
|
|
COMMIT;
|
|
|
|
BEGIN;
|
|
|
|
SELECT pg_current_xact_id() AS rolledback \gset
|
|
|
|
ROLLBACK;
|
|
|
|
BEGIN;
|
|
|
|
SELECT pg_current_xact_id() AS inprogress \gset
|
|
|
|
SELECT pg_xact_status(:committed::text::xid8) AS committed;
|
|
|
|
committed
|
|
|
|
-----------
|
|
|
|
committed
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT pg_xact_status(:rolledback::text::xid8) AS rolledback;
|
|
|
|
rolledback
|
|
|
|
------------
|
|
|
|
aborted
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT pg_xact_status(:inprogress::text::xid8) AS inprogress;
|
|
|
|
inprogress
|
|
|
|
-------------
|
|
|
|
in progress
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT pg_xact_status('1'::xid8); -- BootstrapTransactionId is always committed
|
|
|
|
pg_xact_status
|
|
|
|
----------------
|
|
|
|
committed
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT pg_xact_status('2'::xid8); -- FrozenTransactionId is always committed
|
|
|
|
pg_xact_status
|
|
|
|
----------------
|
|
|
|
committed
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT pg_xact_status('3'::xid8); -- in regress testing FirstNormalTransactionId will always be behind oldestXmin
|
|
|
|
pg_xact_status
|
|
|
|
----------------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
COMMIT;
|
|
|
|
BEGIN;
|
|
|
|
CREATE FUNCTION test_future_xid_status(xid8)
|
|
|
|
RETURNS void
|
|
|
|
LANGUAGE plpgsql
|
|
|
|
AS
|
|
|
|
$$
|
|
|
|
BEGIN
|
|
|
|
PERFORM pg_xact_status($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_status((:inprogress + 10000)::text::xid8);
|
|
|
|
NOTICE: Got expected error for xid in the future
|
|
|
|
test_future_xid_status
|
|
|
|
------------------------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
ROLLBACK;
|