Hi Michael, > v5-0001 includes the following output: > > --- a/src/test/regress/expected/opr_sanity.out > +++ b/src/test/regress/expected/opr_sanity.out > @@ -126,9 +126,12 @@ WHERE p1.oid < p2.oid AND > p1.proretset != p2.proretset OR > p1.provolatile != p2.provolatile OR > p1.pronargs != p2.pronargs); > - oid | proname | oid | proname > ------+---------+-----+--------- > -(0 rows) > + oid | proname | oid | proname > +------+----------+------+--------- > + 2405 | int2send | 8577 | bytea > + 2407 | int4send | 8578 | bytea > + 2409 | int8send | 8579 | bytea > +(3 rows) > > This should not happen, as you are using multiple times the same > function.
Thanks. Here is the corrected patch. Besides fixing opr_sanity test I corrected error messages: -ERROR: bytea size 3 out of valid range, 0..2 +ERROR: bytea out of valid range, ''..'\xFFFF' ... and also included tests for min/max integer values. I discarded the 0002 patch that implemented get_bytes() / set_bytes(). This part doesn't seem to get much support, so let's focus on casting. -- Best regards, Aleksander Alekseev
From 4b25ab46f10c8d284b2b2f8f3a7998a7b00c12d0 Mon Sep 17 00:00:00 2001 From: Aleksander Alekseev <aleksander@timescale.com> Date: Mon, 26 Aug 2024 12:09:59 +0300 Subject: [PATCH v6] Allow casting between bytea and integer types. For instance: SELECT '\x12345678'::bytea::integer; SELECT 0x12345678::bytea; This works with int2's, int4's and int8's. Aleksander Alekseev, reviewed by Peter Eisentraut, Michael Paquier Discussion: https://postgr.es/m/CAJ7c6TPtOp6%2BkFX5QX3fH1SVr7v65uHr-7yEJ%3DGMGQi5uhGtcA%40mail.gmail.com BUMP CATVERSION --- src/backend/utils/adt/int.c | 68 +++++++++++++ src/include/catalog/pg_cast.dat | 14 +++ src/include/catalog/pg_proc.dat | 18 ++++ src/test/regress/expected/opr_sanity.out | 6 ++ src/test/regress/expected/strings.out | 120 +++++++++++++++++++++++ src/test/regress/sql/strings.sql | 34 +++++++ 6 files changed, 260 insertions(+) diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c index b5781989a64..a240f647a48 100644 --- a/src/backend/utils/adt/int.c +++ b/src/backend/utils/adt/int.c @@ -336,6 +336,74 @@ int4send(PG_FUNCTION_ARGS) * =================== */ +/* Common code for bytea_int2, bytea_int4 and bytea_int8 */ +static int64 +bytea_integer(bytea* v, int max_size, const char* max_value) +{ + int len = VARSIZE_ANY_EXHDR(v); + int offset = 0; + int64 result = 0; + + if (len > max_size) + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("bytea out of valid range, ''..'\\x%s'", + max_value))); + while (len--) + { + result = result << 8; + result |= ((unsigned char *) VARDATA_ANY(v))[offset]; + offset++; + } + + return result; +} + +/* Cast bytea -> int2 */ +Datum +bytea_int2(PG_FUNCTION_ARGS) +{ + bytea *v = PG_GETARG_BYTEA_PP(0); + PG_RETURN_INT16((int16)bytea_integer(v, sizeof(int16), "FFFF")); +} + +/* Cast bytea -> int4 */ +Datum +bytea_int4(PG_FUNCTION_ARGS) +{ + bytea *v = PG_GETARG_BYTEA_PP(0); + PG_RETURN_INT32((int32)bytea_integer(v, sizeof(int32), "FFFFFFFF")); +} + +/* Cast bytea -> int8 */ +Datum +bytea_int8(PG_FUNCTION_ARGS) +{ + bytea *v = PG_GETARG_BYTEA_PP(0); + PG_RETURN_INT64(bytea_integer(v, sizeof(int64), "FFFFFFFFFFFFFFFF")); +} + +/* Cast int2 -> bytea; currently just a wrapper for int2send() */ +Datum +int2_bytea(PG_FUNCTION_ARGS) +{ + return int2send(fcinfo); +} + +/* Cast int4 -> bytea; currently just a wrapper for int4send() */ +Datum +int4_bytea(PG_FUNCTION_ARGS) +{ + return int4send(fcinfo); +} + +/* Cast int8 -> bytea; currently just a wrapper for int8send() */ +Datum +int8_bytea(PG_FUNCTION_ARGS) +{ + return int8send(fcinfo); +} + Datum i2toi4(PG_FUNCTION_ARGS) { diff --git a/src/include/catalog/pg_cast.dat b/src/include/catalog/pg_cast.dat index a26ba34e869..ab46be606f0 100644 --- a/src/include/catalog/pg_cast.dat +++ b/src/include/catalog/pg_cast.dat @@ -320,6 +320,20 @@ { castsource => 'varchar', casttarget => 'name', castfunc => 'name(varchar)', castcontext => 'i', castmethod => 'f' }, +# Allow explicit coercions between bytea and integer types +{ castsource => 'int2', casttarget => 'bytea', castfunc => 'bytea(int2)', + castcontext => 'e', castmethod => 'f' }, +{ castsource => 'int4', casttarget => 'bytea', castfunc => 'bytea(int4)', + castcontext => 'e', castmethod => 'f' }, +{ castsource => 'int8', casttarget => 'bytea', castfunc => 'bytea(int8)', + castcontext => 'e', castmethod => 'f' }, +{ castsource => 'bytea', casttarget => 'int2', castfunc => 'int2(bytea)', + castcontext => 'e', castmethod => 'f' }, +{ castsource => 'bytea', casttarget => 'int4', castfunc => 'int4(bytea)', + castcontext => 'e', castmethod => 'f' }, +{ castsource => 'bytea', casttarget => 'int8', castfunc => 'int8(bytea)', + castcontext => 'e', castmethod => 'f' }, + # Allow explicit coercions between int4 and "char" { castsource => 'char', casttarget => 'int4', castfunc => 'int4(char)', castcontext => 'e', castmethod => 'f' }, diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat index b37e8a6f882..c9d9b91e282 100644 --- a/src/include/catalog/pg_proc.dat +++ b/src/include/catalog/pg_proc.dat @@ -1164,6 +1164,24 @@ { oid => '409', descr => 'convert char(n) to name', proname => 'name', proleakproof => 't', prorettype => 'name', proargtypes => 'bpchar', prosrc => 'bpchar_name' }, +{ oid => '8577', descr => 'convert int2 to bytea', + proname => 'bytea', proleakproof => 't', prorettype => 'bytea', + proargtypes => 'int2', prosrc => 'int2_bytea' }, +{ oid => '8578', descr => 'convert int4 to bytea', + proname => 'bytea', proleakproof => 't', prorettype => 'bytea', + proargtypes => 'int4', prosrc => 'int4_bytea' }, +{ oid => '8579', descr => 'convert int8 to bytea', + proname => 'bytea', proleakproof => 't', prorettype => 'bytea', + proargtypes => 'int8', prosrc => 'int8_bytea' }, +{ oid => '8580', descr => 'convert bytea to int2', + proname => 'int2', proleakproof => 't', prorettype => 'int2', + proargtypes => 'bytea', prosrc => 'bytea_int2' }, +{ oid => '8581', descr => 'convert bytea to int4', + proname => 'int4', proleakproof => 't', prorettype => 'int4', + proargtypes => 'bytea', prosrc => 'bytea_int4' }, +{ oid => '8582', descr => 'convert bytea to int8', + proname => 'int8', proleakproof => 't', prorettype => 'int8', + proargtypes => 'bytea', prosrc => 'bytea_int8' }, { oid => '449', descr => 'hash', proname => 'hashint2', prorettype => 'int4', proargtypes => 'int2', diff --git a/src/test/regress/expected/opr_sanity.out b/src/test/regress/expected/opr_sanity.out index b673642ad1d..462c56b7887 100644 --- a/src/test/regress/expected/opr_sanity.out +++ b/src/test/regress/expected/opr_sanity.out @@ -875,6 +875,12 @@ uuid_extract_timestamp(uuid) uuid_extract_version(uuid) crc32(bytea) crc32c(bytea) +bytea(smallint) +bytea(integer) +bytea(bigint) +int2(bytea) +int4(bytea) +int8(bytea) bytea_larger(bytea,bytea) bytea_smaller(bytea,bytea) -- Check that functions without argument are not marked as leakproof. diff --git a/src/test/regress/expected/strings.out b/src/test/regress/expected/strings.out index b65bb2d5368..e35ae5d29c5 100644 --- a/src/test/regress/expected/strings.out +++ b/src/test/regress/expected/strings.out @@ -2690,3 +2690,123 @@ ERROR: invalid Unicode code point: 2FFFFF SELECT unistr('wrong: \xyz'); ERROR: invalid Unicode escape HINT: Unicode escapes must be \XXXX, \+XXXXXX, \uXXXX, or \UXXXXXXXX. +-- +-- Test coercions between bytea and integer types +-- +SET bytea_output TO hex; +SELECT 0x1234::int2::bytea; + bytea +-------- + \x1234 +(1 row) + +SELECT 0x12345678::int4::bytea; + bytea +------------ + \x12345678 +(1 row) + +SELECT 0x1122334455667788::int8::bytea; + bytea +-------------------- + \x1122334455667788 +(1 row) + +SELECT ''::bytea::int2 = 0; + ?column? +---------- + t +(1 row) + +SELECT '\x12'::bytea::int2 = 0x12; + ?column? +---------- + t +(1 row) + +SELECT '\x1234'::bytea::int2 = 0x1234; + ?column? +---------- + t +(1 row) + +SELECT '\x123456'::bytea::int2; -- error +ERROR: bytea out of valid range, ''..'\xFFFF' +SELECT ''::bytea::int4 = 0; + ?column? +---------- + t +(1 row) + +SELECT '\x12'::bytea::int4 = 0x12; + ?column? +---------- + t +(1 row) + +SELECT '\x12345678'::bytea::int4 = 0x12345678; + ?column? +---------- + t +(1 row) + +SELECT '\x123456789A'::bytea::int4; -- error +ERROR: bytea out of valid range, ''..'\xFFFFFFFF' +SELECT ''::bytea::int8 = 0; + ?column? +---------- + t +(1 row) + +SELECT '\x12'::bytea::int8 = 0x12; + ?column? +---------- + t +(1 row) + +SELECT '\x1122334455667788'::bytea::int8 = 0x1122334455667788; + ?column? +---------- + t +(1 row) + +SELECT '\x112233445566778899'::bytea::int8; -- error +ERROR: bytea out of valid range, ''..'\xFFFFFFFFFFFFFFFF' +-- max integer values +SELECT '\x7FFF'::bytea::int2 = 0x7FFF; + ?column? +---------- + t +(1 row) + +SELECT '\x7FFFFFFF'::bytea::int4 = 0x7FFFFFFF; + ?column? +---------- + t +(1 row) + +SELECT '\x7FFFFFFFFFFFFFFF'::bytea::int8 = 0x7FFFFFFFFFFFFFFF; + ?column? +---------- + t +(1 row) + +-- min integer values +SELECT '\x8000'::bytea::int2 = -0x8000; + ?column? +---------- + t +(1 row) + +SELECT '\x80000000'::bytea::int4 = -0x80000000; + ?column? +---------- + t +(1 row) + +SELECT '\x8000000000000000'::bytea::int8 = -0x8000000000000000; + ?column? +---------- + t +(1 row) + diff --git a/src/test/regress/sql/strings.sql b/src/test/regress/sql/strings.sql index 8e0f3a0e75f..16cceb5c746 100644 --- a/src/test/regress/sql/strings.sql +++ b/src/test/regress/sql/strings.sql @@ -848,3 +848,37 @@ SELECT unistr('wrong: \udb99\u0061'); SELECT unistr('wrong: \U0000db99\U00000061'); SELECT unistr('wrong: \U002FFFFF'); SELECT unistr('wrong: \xyz'); + +-- +-- Test coercions between bytea and integer types +-- +SET bytea_output TO hex; + +SELECT 0x1234::int2::bytea; +SELECT 0x12345678::int4::bytea; +SELECT 0x1122334455667788::int8::bytea; + +SELECT ''::bytea::int2 = 0; +SELECT '\x12'::bytea::int2 = 0x12; +SELECT '\x1234'::bytea::int2 = 0x1234; +SELECT '\x123456'::bytea::int2; -- error + +SELECT ''::bytea::int4 = 0; +SELECT '\x12'::bytea::int4 = 0x12; +SELECT '\x12345678'::bytea::int4 = 0x12345678; +SELECT '\x123456789A'::bytea::int4; -- error + +SELECT ''::bytea::int8 = 0; +SELECT '\x12'::bytea::int8 = 0x12; +SELECT '\x1122334455667788'::bytea::int8 = 0x1122334455667788; +SELECT '\x112233445566778899'::bytea::int8; -- error + +-- max integer values +SELECT '\x7FFF'::bytea::int2 = 0x7FFF; +SELECT '\x7FFFFFFF'::bytea::int4 = 0x7FFFFFFF; +SELECT '\x7FFFFFFFFFFFFFFF'::bytea::int8 = 0x7FFFFFFFFFFFFFFF; + +-- min integer values +SELECT '\x8000'::bytea::int2 = -0x8000; +SELECT '\x80000000'::bytea::int4 = -0x80000000; +SELECT '\x8000000000000000'::bytea::int8 = -0x8000000000000000; -- 2.47.1
