Speed up byteain by not parsing traditional-style input twice.

Instead of laboriously computing the exact output length, use strlen
to get an upper bound cheaply.  (This is still O(N) of course, but
the constant factor is a lot less.)  This will typically result in
overallocating the output datum, but that's of little concern since
it's a short-lived allocation in just about all use-cases.

A simple microbenchmark showed about 40% speedup for long input
strings.

While here, make some cosmetic cleanups and add a test case that
covers the double-backslash code path in byteain and byteaout.

Author: Steven Niu <niushiji@gmail.com>
Reviewed-by: Kirill Reshke <reshkekirill@gmail.com>
Reviewed-by: Stepan Neretin <slpmcf@gmail.com>
Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us>
Discussion: https://postgr.es/m/ca315729-140b-426e-81a6-6cd5cfe7ecc5@gmail.com

diff --git a/src/backend/utils/adt/bytea.c b/src/backend/utils/adt/bytea.c
index 2e539c2504e8da823a4d8abca76e1ebd74693b5b..6e7b914c56395fa4d941d3e8c4b43c9534703904 100644 (file)
--- a/src/backend/utils/adt/bytea.c
+++ b/src/backend/utils/adt/bytea.c
@@ -182,27 +182,21 @@ bytea_overlay(bytea *t1, bytea *t2, int sp, int sl)
  *
  *             Non-printable characters must be passed as '\nnn' (octal) and are
  *             converted to internal form.  '\' must be passed as '\\'.
- *             ereport(ERROR, ...) if bad form.
- *
- *             BUGS:
- *                             The input is scanned twice.
- *                             The error checking of input is minimal.
  */
 Datum
 byteain(PG_FUNCTION_ARGS)
 {
        char       *inputText = PG_GETARG_CSTRING(0);
        Node       *escontext = fcinfo->context;
+       size_t          len = strlen(inputText);
+       size_t          bc;
        char       *tp;
        char       *rp;
-       int                     bc;
        bytea      *result;
 
        /* Recognize hex input */
        if (inputText[0] == '\\' && inputText[1] == 'x')
        {
-               size_t          len = strlen(inputText);
-
                bc = (len - 2) / 2 + VARHDRSZ;  /* maximum possible length */
                result = palloc(bc);
                bc = hex_decode_safe(inputText + 2, len - 2, VARDATA(result),
@@ -213,33 +207,7 @@ byteain(PG_FUNCTION_ARGS)
        }
 
        /* Else, it's the traditional escaped style */
-       for (bc = 0, tp = inputText; *tp != '\0'; bc++)
-       {
-               if (tp[0] != '\\')
-                       tp++;
-               else if ((tp[0] == '\\') &&
-                                (tp[1] >= '0' && tp[1] <= '3') &&
-                                (tp[2] >= '0' && tp[2] <= '7') &&
-                                (tp[3] >= '0' && tp[3] <= '7'))
-                       tp += 4;
-               else if ((tp[0] == '\\') &&
-                                (tp[1] == '\\'))
-                       tp += 2;
-               else
-               {
-                       /*
-                        * one backslash, not followed by another or ### valid octal
-                        */
-                       ereturn(escontext, (Datum) 0,
-                                       (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
-                                        errmsg("invalid input syntax for type %s", "bytea")));
-               }
-       }
-
-       bc += VARHDRSZ;
-
-       result = (bytea *) palloc(bc);
-       SET_VARSIZE(result, bc);
+       result = (bytea *) palloc(len + VARHDRSZ);      /* maximum possible length */
 
        tp = inputText;
        rp = VARDATA(result);
@@ -247,21 +215,21 @@ byteain(PG_FUNCTION_ARGS)
        {
                if (tp[0] != '\\')
                        *rp++ = *tp++;
-               else if ((tp[0] == '\\') &&
-                                (tp[1] >= '0' && tp[1] <= '3') &&
+               else if ((tp[1] >= '0' && tp[1] <= '3') &&
                                 (tp[2] >= '0' && tp[2] <= '7') &&
                                 (tp[3] >= '0' && tp[3] <= '7'))
                {
-                       bc = VAL(tp[1]);
-                       bc <<= 3;
-                       bc += VAL(tp[2]);
-                       bc <<= 3;
-                       *rp++ = bc + VAL(tp[3]);
+                       int                     v;
+
+                       v = VAL(tp[1]);
+                       v <<= 3;
+                       v += VAL(tp[2]);
+                       v <<= 3;
+                       *rp++ = v + VAL(tp[3]);
 
                        tp += 4;
                }
-               else if ((tp[0] == '\\') &&
-                                (tp[1] == '\\'))
+               else if (tp[1] == '\\')
                {
                        *rp++ = '\\';
                        tp += 2;
@@ -269,7 +237,7 @@ byteain(PG_FUNCTION_ARGS)
                else
                {
                        /*
-                        * We should never get here. The first pass should not allow it.
+                        * one backslash, not followed by another or ### valid octal
                         */
                        ereturn(escontext, (Datum) 0,
                                        (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
@@ -277,6 +245,9 @@ byteain(PG_FUNCTION_ARGS)
                }
        }
 
+       bc = rp - VARDATA(result);      /* actual length */
+       SET_VARSIZE(result, bc + VARHDRSZ);
+
        PG_RETURN_BYTEA_P(result);
 }
 

diff --git a/src/test/regress/expected/strings.out b/src/test/regress/expected/strings.out
index 788844abd20e39a6b1a0f67ef13f7fb043733b35..1bfd33de3f3c38b1be9934f993e6a11d8e358f9d 100644 (file)
--- a/src/test/regress/expected/strings.out
+++ b/src/test/regress/expected/strings.out
@@ -236,6 +236,12 @@ SELECT E'De\\678dBeEf'::bytea;
 ERROR:  invalid input syntax for type bytea
 LINE 1: SELECT E'De\\678dBeEf'::bytea;
                ^
+SELECT E'DeAd\\\\BeEf'::bytea;
+        bytea         
+----------------------
+ \x446541645c42654566
+(1 row)
+
 SELECT reverse(''::bytea);
  reverse 
 ---------
@@ -291,6 +297,12 @@ SELECT E'De\\123dBeEf'::bytea;
  DeSdBeEf
 (1 row)
 
+SELECT E'DeAd\\\\BeEf'::bytea;
+   bytea    
+------------
+ DeAd\\BeEf
+(1 row)
+
 -- Test non-error-throwing API too
 SELECT pg_input_is_valid(E'\\xDeAdBeE', 'bytea');
  pg_input_is_valid 

diff --git a/src/test/regress/sql/strings.sql b/src/test/regress/sql/strings.sql
index 2577a42987de751a06d4843569baf5744b898e43..92c445c24396123355b065d514ef4ac39cc47719 100644 (file)
--- a/src/test/regress/sql/strings.sql
+++ b/src/test/regress/sql/strings.sql
@@ -76,6 +76,7 @@ SELECT E'De\\000dBeEf'::bytea;
 SELECT E'De\123dBeEf'::bytea;
 SELECT E'De\\123dBeEf'::bytea;
 SELECT E'De\\678dBeEf'::bytea;
+SELECT E'DeAd\\\\BeEf'::bytea;
 
 SELECT reverse(''::bytea);
 SELECT reverse('\xaa'::bytea);
@@ -88,6 +89,7 @@ SELECT E'\\xDe00BeEf'::bytea;
 SELECT E'DeAdBeEf'::bytea;
 SELECT E'De\\000dBeEf'::bytea;
 SELECT E'De\\123dBeEf'::bytea;
+SELECT E'DeAd\\\\BeEf'::bytea;
 
 -- Test non-error-throwing API too
 SELECT pg_input_is_valid(E'\\xDeAdBeE', 'bytea');