From d2bfc203ff92d1cce7ea10a27c86f6d42162a842 Mon Sep 17 00:00:00 2001 From: Masahiko Sawada Date: Thu, 25 Jun 2026 10:03:44 -0700 Subject: [PATCH v6 1/2] Use hex_decode_safe() to speed up UUID input. Previously, string_to_uuid() decoded one byte at a time, calling isxdigit() twice and strtoul() once for every pair of hexadecimal digits. That loop dominated the cost of uuid_in(). Commit ec8719ccbfcd made hex_decode_safe() decode a run of hexadecimal digits in bulk, so this commit adds a fast path for the two common shapes: a bare string of 32 hexadecimal digits, and the canonical 8x-4x-4x-4x-12x form (where "nx" means n hexadecimal digits), each optionally wrapped in braces. Both are compacted into 32 contiguous hexadecimal digits and decoded with hex_decode_safe(). Any other shape, or any decoding error, is handed off to the original byte-at-a-time parser, now string_to_uuid_scalar(), so the accepted grammar and the error messages are unchanged. hex_decode_safe() silently skips whitespace while the UUID grammar does not, so a decode can succeed and still write fewer than UUID_LEN bytes. The fast path therefore treats a short result as a failure, just like an error, and lets the scalar parser reject the input and report the syntax error. Rejecting an input that has one of the fast-path shapes now costs a second parse, since the error is reported by string_to_uuid_scalar() rather than by the failed decode. That keeps the message independent of which path rejected the input. Callers that throw absorb the extra parse in the error path, and callers that use a soft error context, such as pg_input_is_valid(), pay only a few nanoseconds per value. The fast path is deliberately not conditional on SIMD support. hex_decode_safe() selects a vectorized or scalar implementation itself, and even its scalar implementation is an order of magnitude faster than decoding a byte at a time, so gating this on USE_NO_SIMD would only penalize platforms that have neither SSE2 nor NEON. Reviewed-by: Bharath Rupireddy Reviewed-by: Haibo Yan Reviewed-by: Chao Li Reviewed-by: John Naylor Discussion: https://postgr.es/m/CAD21AoCqeR4UQU77Q_yOMNNzJ7AVeiO5QZT+4HnzPm4Wm-e02Q@mail.gmail.com --- src/backend/utils/adt/uuid.c | 101 +++++++++++++++++++++++++++-- src/test/regress/expected/uuid.out | 75 +++++++++++++++++++++ src/test/regress/sql/uuid.sql | 25 +++++++ 3 files changed, 196 insertions(+), 5 deletions(-) diff --git a/src/backend/utils/adt/uuid.c b/src/backend/utils/adt/uuid.c index 28e18940a9d..c019e17f21b 100644 --- a/src/backend/utils/adt/uuid.c +++ b/src/backend/utils/adt/uuid.c @@ -19,7 +19,9 @@ #include "common/hashfn.h" #include "lib/hyperloglog.h" #include "libpq/pqformat.h" +#include "nodes/miscnodes.h" #include "port/pg_bswap.h" +#include "utils/builtins.h" #include "utils/fmgrprotos.h" #include "utils/guc.h" #include "utils/skipsupport.h" @@ -139,13 +141,13 @@ uuid_out(PG_FUNCTION_ARGS) } /* - * We allow UUIDs as a series of 32 hexadecimal digits with an optional dash - * after each group of 4 hexadecimal digits, and optionally surrounded by {}. - * (The canonical format 8x-4x-4x-4x-12x, where "nx" means n hexadecimal - * digits, is the only one used for output.) + * Reference implementation of the UUID grammar, parsing one byte at a time. + * string_to_uuid() recognizes the common shapes more cheaply and defers to + * this function for everything else, so this is also the only place that + * reports a syntax error. */ static void -string_to_uuid(const char *source, pg_uuid_t *uuid, Node *escontext) +string_to_uuid_scalar(const char *source, pg_uuid_t *uuid, Node *escontext) { const char *src = source; bool braces = false; @@ -194,6 +196,95 @@ syntax_error: "uuid", source))); } +/* + * We allow UUIDs as a series of 32 hexadecimal digits with an optional dash + * after each group of 4 hexadecimal digits, and optionally surrounded by {}. + * (The canonical format 8x-4x-4x-4x-12x, where "nx" means n hexadecimal + * digits, is the only one used for output.) + * + * The two common shapes -- a bare string of 32 hexadecimal digits and the + * canonical form, each optionally wrapped in braces -- are compacted into 32 + * contiguous hex digits and decoded with hex_decode_safe(), which is much + * faster than the byte-at-a-time loop. Any other shape, or any decoding + * error, is handed off to string_to_uuid_scalar() so that the accepted + * grammar and the error messages are unchanged. + */ +static void +string_to_uuid(const char *source, pg_uuid_t *uuid, Node *escontext) +{ + const char *body = source; + const char *hexsrc = NULL; + char hexbuf[32]; + uint64 written; + size_t len; + ErrorSaveContext private_escontext = {T_ErrorSaveContext}; + + /* + * Measure the input only far enough to classify its shape. The bound must + * exceed the longest shape handled here, the braced canonical form at 38 + * characters: strnlen() returns the bound for anything at least that + * long, so stopping at an accepted length would accept a longer string + * that merely starts with a valid UUID. + */ + len = strnlen(source, 64); + + /* Strip one optional surrounding brace pair */ + if (len >= 2 && source[0] == '{' && source[len - 1] == '}') + { + body = source + 1; + len -= 2; + } + + if (len == 32) + { + /* + * Body is already 32 contiguous hex digits -- decode straight from + * the input. hex_decode_safe() reads exactly body[0..31], so it never + * touches the trailing NUL or '}'. + */ + hexsrc = body; + } + else if (len == 36 && body[8] == '-' && body[13] == '-' && + body[18] == '-' && body[23] == '-') + { + /* + * Canonical 8x-4x-4x-4x-12x form; compact them into hexbuf with + * fixed-offset copies, dropping the dashes. + */ + memcpy(&hexbuf[0], &body[0], 8); + memcpy(&hexbuf[8], &body[9], 4); + memcpy(&hexbuf[12], &body[14], 4); + memcpy(&hexbuf[16], &body[19], 4); + memcpy(&hexbuf[20], &body[24], 12); + hexsrc = hexbuf; + } + + if (hexsrc == NULL) + { + /* Uncommon shape; let the general parse handle it */ + string_to_uuid_scalar(source, uuid, escontext); + return; + } + + /* + * The shape matched, so the decode is expected to succeed. Any error is + * routed into a private context and discarded, leaving + * string_to_uuid_scalar() to parse the input again and report the syntax + * error, so that the message does not depend on which path rejected the + * input. + */ + written = hex_decode_safe(hexsrc, 32, (char *) uuid->data, + (Node *) &private_escontext); + + /* + * A short result must be rejected as well as an error: hex_decode_safe() + * skips whitespace, so it can succeed yet write fewer than UUID_LEN + * bytes, whereas the UUID grammar forbids whitespace. + */ + if (private_escontext.error_occurred || written != UUID_LEN) + string_to_uuid_scalar(source, uuid, escontext); +} + Datum uuid_recv(PG_FUNCTION_ARGS) { diff --git a/src/test/regress/expected/uuid.out b/src/test/regress/expected/uuid.out index d542eb14b26..6e35f439c68 100644 --- a/src/test/regress/expected/uuid.out +++ b/src/test/regress/expected/uuid.out @@ -375,5 +375,80 @@ SELECT v = v::bytea::uuid as matched FROM gen_random_uuid() v; t (1 row) +-- Test UUID shapes that the parser uses the fast path. +SELECT '5b35380a-7143-4912-9b55-f322699c6770'::uuid; + uuid +-------------------------------------- + 5b35380a-7143-4912-9b55-f322699c6770 +(1 row) + +SELECT '{5b35380a-7143-4912-9b55-f322699c6770}'::uuid; + uuid +-------------------------------------- + 5b35380a-7143-4912-9b55-f322699c6770 +(1 row) + +SELECT '5b35380a714349129b55f322699c6770'::uuid; + uuid +-------------------------------------- + 5b35380a-7143-4912-9b55-f322699c6770 +(1 row) + +SELECT '{5b35380a714349129b55f322699c6770}'::uuid; + uuid +-------------------------------------- + 5b35380a-7143-4912-9b55-f322699c6770 +(1 row) + +-- Test if the UUID parser using the fast path correctly rejects invalid UUID +-- string format. +SELECT '5b35380a714349129b55f32 99c6770'::uuid; +ERROR: invalid input syntax for type uuid: "5b35380a714349129b55f32 99c6770" +LINE 1: SELECT '5b35380a714349129b55f32 99c6770'::uuid; + ^ +SELECT '5b35380a-7143-4912-9b55-f322699c67 '::uuid; +ERROR: invalid input syntax for type uuid: "5b35380a-7143-4912-9b55-f322699c67 " +LINE 1: SELECT '5b35380a-7143-4912-9b55-f322699c67 '::uuid; + ^ +SELECT ' 35380a-7143-4912-9b55-f322699c6770'::uuid; +ERROR: invalid input syntax for type uuid: " 35380a-7143-4912-9b55-f322699c6770" +LINE 1: SELECT ' 35380a-7143-4912-9b55-f322699c6770'::uuid; + ^ +SELECT 'AZ35380a-7143-4912-9b55-f322699c6770'::uuid; +ERROR: invalid input syntax for type uuid: "AZ35380a-7143-4912-9b55-f322699c6770" +LINE 1: SELECT 'AZ35380a-7143-4912-9b55-f322699c6770'::uuid; + ^ +SELECT '{AZ35380a-7143-4912-9b55-f322699c6770}'::uuid; +ERROR: invalid input syntax for type uuid: "{AZ35380a-7143-4912-9b55-f322699c6770}" +LINE 1: SELECT '{AZ35380a-7143-4912-9b55-f322699c6770}'::uuid; + ^ +SELECT '{AZ35380a714349129b55f322699c6770}'::uuid; +ERROR: invalid input syntax for type uuid: "{AZ35380a714349129b55f322699c6770}" +LINE 1: SELECT '{AZ35380a714349129b55f322699c6770}'::uuid; + ^ +SELECT '{AZ35380a714349129b55f322699c67 }'::uuid; +ERROR: invalid input syntax for type uuid: "{AZ35380a714349129b55f322699c67 }" +LINE 1: SELECT '{AZ35380a714349129b55f322699c67 }'::uuid; + ^ +-- The parser only measures the input far enough to classify its shape. If it +-- stopped measuring at one of the accepted lengths, a longer string that +-- merely starts with a valid UUID would look like that UUID and be accepted +-- with the rest silently ignored, so check that trailing data is rejected. +SELECT '5b35380a714349129b55f322699c6770TRAILING'::uuid; +ERROR: invalid input syntax for type uuid: "5b35380a714349129b55f322699c6770TRAILING" +LINE 1: SELECT '5b35380a714349129b55f322699c6770TRAILING'::uuid; + ^ +SELECT '{5b35380a714349129b55f322699c6770}TRAILING'::uuid; +ERROR: invalid input syntax for type uuid: "{5b35380a714349129b55f322699c6770}TRAILING" +LINE 1: SELECT '{5b35380a714349129b55f322699c6770}TRAILING'::uuid; + ^ +SELECT '5b35380a-7143-4912-9b55-f322699c6770TRAILING'::uuid; +ERROR: invalid input syntax for type uuid: "5b35380a-7143-4912-9b55-f322699c6770TRAILING" +LINE 1: SELECT '5b35380a-7143-4912-9b55-f322699c6770TRAILING'::uuid; + ^ +SELECT '{5b35380a-7143-4912-9b55-f322699c6770}TRAILING'::uuid; +ERROR: invalid input syntax for type uuid: "{5b35380a-7143-4912-9b55-f322699c6770}TRAILING" +LINE 1: SELECT '{5b35380a-7143-4912-9b55-f322699c6770}TRAILING'::uui... + ^ -- clean up DROP TABLE guid1, guid2, guid3 CASCADE; diff --git a/src/test/regress/sql/uuid.sql b/src/test/regress/sql/uuid.sql index 54f0d8f8255..0719700fda3 100644 --- a/src/test/regress/sql/uuid.sql +++ b/src/test/regress/sql/uuid.sql @@ -178,5 +178,30 @@ SELECT '\x019a2f859ced7225b99d9c55044a2563'::bytea::uuid; SELECT '\x1234567890abcdef'::bytea::uuid; -- error SELECT v = v::bytea::uuid as matched FROM gen_random_uuid() v; +-- Test UUID shapes that the parser uses the fast path. +SELECT '5b35380a-7143-4912-9b55-f322699c6770'::uuid; +SELECT '{5b35380a-7143-4912-9b55-f322699c6770}'::uuid; +SELECT '5b35380a714349129b55f322699c6770'::uuid; +SELECT '{5b35380a714349129b55f322699c6770}'::uuid; + +-- Test if the UUID parser using the fast path correctly rejects invalid UUID +-- string format. +SELECT '5b35380a714349129b55f32 99c6770'::uuid; +SELECT '5b35380a-7143-4912-9b55-f322699c67 '::uuid; +SELECT ' 35380a-7143-4912-9b55-f322699c6770'::uuid; +SELECT 'AZ35380a-7143-4912-9b55-f322699c6770'::uuid; +SELECT '{AZ35380a-7143-4912-9b55-f322699c6770}'::uuid; +SELECT '{AZ35380a714349129b55f322699c6770}'::uuid; +SELECT '{AZ35380a714349129b55f322699c67 }'::uuid; + +-- The parser only measures the input far enough to classify its shape. If it +-- stopped measuring at one of the accepted lengths, a longer string that +-- merely starts with a valid UUID would look like that UUID and be accepted +-- with the rest silently ignored, so check that trailing data is rejected. +SELECT '5b35380a714349129b55f322699c6770TRAILING'::uuid; +SELECT '{5b35380a714349129b55f322699c6770}TRAILING'::uuid; +SELECT '5b35380a-7143-4912-9b55-f322699c6770TRAILING'::uuid; +SELECT '{5b35380a-7143-4912-9b55-f322699c6770}TRAILING'::uuid; + -- clean up DROP TABLE guid1, guid2, guid3 CASCADE; -- 2.55.0