From b7cf59a809539cfaa5207cb23aca578af2b04977 Mon Sep 17 00:00:00 2001 From: Aleksander Alekseev Date: Mon, 26 Aug 2024 12:09:59 +0300 Subject: [PATCH v5 1/2] 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 TODO FIXME Discussion: https://postgr.es/m/CAJ7c6TPtOp6%2BkFX5QX3fH1SVr7v65uHr-7yEJ%3DGMGQi5uhGtcA%40mail.gmail.com BUMP CATVERSION --- src/backend/utils/adt/int.c | 55 ++++++++++++++++ src/include/catalog/pg_cast.dat | 14 ++++ src/include/catalog/pg_proc.dat | 18 ++++++ src/test/regress/expected/opr_sanity.out | 15 ++++- src/test/regress/expected/strings.out | 82 ++++++++++++++++++++++++ src/test/regress/sql/strings.sql | 24 +++++++ 6 files changed, 205 insertions(+), 3 deletions(-) diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c index 234f20796b..a9ab582283 100644 --- a/src/backend/utils/adt/int.c +++ b/src/backend/utils/adt/int.c @@ -330,6 +330,61 @@ int4send(PG_FUNCTION_ARGS) } +/* + * Common code for bytea_int2, bytea_int4 and bytea_int8 + */ +static int64 +bytea_integer(bytea* v, int max_size) +{ + 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 size %d out of valid range, 0..%d", + len, max_size))); + while (len--) + { + result = result << 8; + result |= ((unsigned char *) VARDATA_ANY(v))[offset]; + offset++; + } + + return result; +} + +/* + * bytea_int2 - converts bytea to int2 + */ +Datum +bytea_int2(PG_FUNCTION_ARGS) +{ + bytea *v = PG_GETARG_BYTEA_PP(0); + PG_RETURN_INT16((int16)bytea_integer(v, sizeof(int16))); +} + +/* + * bytea_int4 - converts bytea to int4 + */ +Datum +bytea_int4(PG_FUNCTION_ARGS) +{ + bytea *v = PG_GETARG_BYTEA_PP(0); + PG_RETURN_INT32((int32)bytea_integer(v, sizeof(int32))); +} + +/* + * bytea_int8 - converts bytea to int8 + */ +Datum +bytea_int8(PG_FUNCTION_ARGS) +{ + bytea *v = PG_GETARG_BYTEA_PP(0); + PG_RETURN_INT64(bytea_integer(v, sizeof(int64))); +} + /* * =================== * CONVERSION ROUTINES diff --git a/src/include/catalog/pg_cast.dat b/src/include/catalog/pg_cast.dat index ca7b6d7191..c0350e7f09 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 7c0b74fe05..0336110b0d 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 => 'int2send' }, +{ oid => '8578', descr => 'convert int4 to bytea', + proname => 'bytea', proleakproof => 't', prorettype => 'bytea', + proargtypes => 'int4', prosrc => 'int4send' }, +{ oid => '8579', descr => 'convert int8 to bytea', + proname => 'bytea', proleakproof => 't', prorettype => 'bytea', + proargtypes => 'int8', prosrc => 'int8send' }, +{ 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 34a32bd11d..4b1ebef8fa 100644 --- 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) -- Look for uses of different type OIDs in the argument/result type fields -- for different aliases of the same built-in function. @@ -876,6 +879,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) -- restore normal output mode diff --git a/src/test/regress/expected/strings.out b/src/test/regress/expected/strings.out index b65bb2d536..709f58ad7f 100644 --- a/src/test/regress/expected/strings.out +++ b/src/test/regress/expected/strings.out @@ -2690,3 +2690,85 @@ 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 size 3 out of valid range, 0..2 +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 size 5 out of valid range, 0..4 +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 size 9 out of valid range, 0..8 diff --git a/src/test/regress/sql/strings.sql b/src/test/regress/sql/strings.sql index 8e0f3a0e75..b8858c9aea 100644 --- a/src/test/regress/sql/strings.sql +++ b/src/test/regress/sql/strings.sql @@ -848,3 +848,27 @@ 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 -- 2.47.0