Add support for binary I/O of ltree, lquery, and ltxtquery types.

Not much to say here --- does what it says on the tin.  The "binary"
representation in each case is really just the same as the text format,
though we prefix a version-number byte in case anyone ever feels
motivated to change that.  Thus, there's not any expectation of improved
speed or reduced space; the point here is just to allow clients to use
binary format for all columns of a query result or COPY data.

This makes use of the recently added ALTER TYPE support to add binary
I/O functions to an existing data type.  As in commit a80818605,
we can piggy-back on there already being a new-for-v13 version of the
ltree extension, so we don't need a new update script file.

Nino Floris, reviewed by Alexander Korotkov and myself

Discussion: https://postgr.es/m/CANmj9Vxx50jOo1L7iSRxd142NyTz6Bdcgg7u9P3Z8o0=HGkYyQ@mail.gmail.com

diff --git a/contrib/ltree/crc32.c b/contrib/ltree/crc32.c
index 0c3e45923b2e4f6d7b2fd5bd85a5d9912e9341e4..8fed3346e8a005780497844a6b58edeb847d5087 100644 (file)
--- a/contrib/ltree/crc32.c
+++ b/contrib/ltree/crc32.c
@@ -20,10 +20,10 @@
 #include "utils/pg_crc.h"
 
 unsigned int
-ltree_crc32_sz(char *buf, int size)
+ltree_crc32_sz(const char *buf, int size)
 {
    pg_crc32    crc;
-   char       *p = buf;
+   const char *p = buf;
 
    INIT_TRADITIONAL_CRC32(crc);
    while (size > 0)

diff --git a/contrib/ltree/crc32.h b/contrib/ltree/crc32.h
index 269d05d0c11b87870f38abddd51fcfdeef6bd066..958812214df7da063d4a41f45ead9fbd0ea6f424 100644 (file)
--- a/contrib/ltree/crc32.h
+++ b/contrib/ltree/crc32.h
@@ -4,7 +4,7 @@
 /* contrib/ltree/crc32.h */
 
 /* Returns crc32 of data block */
-extern unsigned int ltree_crc32_sz(char *buf, int size);
+extern unsigned int ltree_crc32_sz(const char *buf, int size);
 
 /* Returns crc32 of null-terminated string */
 #define crc32(buf) ltree_crc32_sz((buf),strlen(buf))

diff --git a/contrib/ltree/ltree--1.1--1.2.sql b/contrib/ltree/ltree--1.1--1.2.sql
index 186381e61d87a78339cc2a32696805c558cf7567..e38e76b31e2defa6a26ca588c7043745d31cd574 100644 (file)
--- a/contrib/ltree/ltree--1.1--1.2.sql
+++ b/contrib/ltree/ltree--1.1--1.2.sql
@@ -3,6 +3,43 @@
 -- complain if script is sourced in psql, rather than via ALTER EXTENSION
 \echo Use "ALTER EXTENSION ltree UPDATE TO '1.2'" to load this file. \quit
 
+CREATE FUNCTION ltree_recv(internal)
+RETURNS ltree
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
+
+CREATE FUNCTION ltree_send(ltree)
+RETURNS bytea
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
+
+ALTER TYPE ltree SET ( RECEIVE = ltree_recv, SEND = ltree_send );
+
+CREATE FUNCTION lquery_recv(internal)
+RETURNS lquery
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
+
+CREATE FUNCTION lquery_send(lquery)
+RETURNS bytea
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
+
+ALTER TYPE lquery SET ( RECEIVE = lquery_recv, SEND = lquery_send );
+
+CREATE FUNCTION ltxtq_recv(internal)
+RETURNS ltxtquery
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
+
+CREATE FUNCTION ltxtq_send(ltxtquery)
+RETURNS bytea
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
+
+ALTER TYPE ltxtquery SET ( RECEIVE = ltxtq_recv, SEND = ltxtq_send );
+
+
 CREATE FUNCTION ltree_gist_options(internal)
 RETURNS void
 AS 'MODULE_PATHNAME', 'ltree_gist_options'

diff --git a/contrib/ltree/ltree_io.c b/contrib/ltree/ltree_io.c
index c6ea5dec8c94edaeb53c664eb02f172f3fc620e8..b928b82d624080bce7b2d0e099e71545320161cd 100644 (file)
--- a/contrib/ltree/ltree_io.c
+++ b/contrib/ltree/ltree_io.c
@@ -8,18 +8,14 @@
 #include <ctype.h>
 
 #include "crc32.h"
+#include "libpq/pqformat.h"
 #include "ltree.h"
 #include "utils/memutils.h"
 
-PG_FUNCTION_INFO_V1(ltree_in);
-PG_FUNCTION_INFO_V1(ltree_out);
-PG_FUNCTION_INFO_V1(lquery_in);
-PG_FUNCTION_INFO_V1(lquery_out);
-
 
 typedef struct
 {
-   char       *start;
+   const char *start;
    int         len;            /* length in bytes */
    int         flag;
    int         wlen;           /* length in characters */
@@ -28,11 +24,14 @@ typedef struct
 #define LTPRS_WAITNAME 0
 #define LTPRS_WAITDELIM 1
 
-Datum
-ltree_in(PG_FUNCTION_ARGS)
+/*
+ * expects a null terminated string
+ * returns an ltree
+ */
+static ltree *
+parse_ltree(const char *buf)
 {
-   char       *buf = (char *) PG_GETARG_POINTER(0);
-   char       *ptr;
+   const char *ptr;
    nodeitem   *list,
               *lptr;
    int         num = 0,
@@ -141,15 +140,18 @@ ltree_in(PG_FUNCTION_ARGS)
    }
 
    pfree(list);
-   PG_RETURN_POINTER(result);
+   return result;
 
 #undef UNCHAR
 }
 
-Datum
-ltree_out(PG_FUNCTION_ARGS)
+/*
+ * expects an ltree
+ * returns a null terminated string
+ */
+static char *
+deparse_ltree(const ltree *in)
 {
-   ltree      *in = PG_GETARG_LTREE_P(0);
    char       *buf,
               *ptr;
    int         i;
@@ -170,11 +172,84 @@ ltree_out(PG_FUNCTION_ARGS)
    }
 
    *ptr = '\0';
-   PG_FREE_IF_COPY(in, 0);
+   return buf;
+}
+
+/*
+ * Basic ltree I/O functions
+ */
+PG_FUNCTION_INFO_V1(ltree_in);
+Datum
+ltree_in(PG_FUNCTION_ARGS)
+{
+   char       *buf = (char *) PG_GETARG_POINTER(0);
+
+   PG_RETURN_POINTER(parse_ltree(buf));
+}
+
+PG_FUNCTION_INFO_V1(ltree_out);
+Datum
+ltree_out(PG_FUNCTION_ARGS)
+{
+   ltree      *in = PG_GETARG_LTREE_P(0);
+
+   PG_RETURN_POINTER(deparse_ltree(in));
+}
+
+/*
+ * ltree type send function
+ *
+ * The type is sent as text in binary mode, so this is almost the same
+ * as the output function, but it's prefixed with a version number so we
+ * can change the binary format sent in future if necessary. For now,
+ * only version 1 is supported.
+ */
+PG_FUNCTION_INFO_V1(ltree_send);
+Datum
+ltree_send(PG_FUNCTION_ARGS)
+{
+   ltree      *in = PG_GETARG_LTREE_P(0);
+   StringInfoData buf;
+   int         version = 1;
+   char       *res = deparse_ltree(in);
+
+   pq_begintypsend(&buf);
+   pq_sendint8(&buf, version);
+   pq_sendtext(&buf, res, strlen(res));
+   pfree(res);
+
+   PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+}
+
+/*
+ * ltree type recv function
+ *
+ * The type is sent as text in binary mode, so this is almost the same
+ * as the input function, but it's prefixed with a version number so we
+ * can change the binary format sent in future if necessary. For now,
+ * only version 1 is supported.
+ */
+PG_FUNCTION_INFO_V1(ltree_recv);
+Datum
+ltree_recv(PG_FUNCTION_ARGS)
+{
+   StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
+   int         version = pq_getmsgint(buf, 1);
+   char       *str;
+   int         nbytes;
+   ltree      *res;
 
-   PG_RETURN_POINTER(buf);
+   if (version != 1)
+       elog(ERROR, "unsupported ltree version number %d", version);
+
+   str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
+   res = parse_ltree(str);
+   pfree(str);
+
+   PG_RETURN_POINTER(res);
 }
 
+
 #define LQPRS_WAITLEVEL 0
 #define LQPRS_WAITDELIM 1
 #define LQPRS_WAITOPEN 2
@@ -190,11 +265,14 @@ ltree_out(PG_FUNCTION_ARGS)
 #define ITEMSIZE   MAXALIGN(LQL_HDRSIZE+sizeof(nodeitem*))
 #define NEXTLEV(x) ( (lquery_level*)( ((char*)(x)) + ITEMSIZE) )
 
-Datum
-lquery_in(PG_FUNCTION_ARGS)
+/*
+ * expects a null terminated string
+ * returns an lquery
+ */
+static lquery *
+parse_lquery(const char *buf)
 {
-   char       *buf = (char *) PG_GETARG_POINTER(0);
-   char       *ptr;
+   const char *ptr;
    int         num = 0,
                totallen = 0,
                numOR = 0;
@@ -563,15 +641,18 @@ lquery_in(PG_FUNCTION_ARGS)
    }
 
    pfree(tmpql);
-   PG_RETURN_POINTER(result);
+   return result;
 
 #undef UNCHAR
 }
 
-Datum
-lquery_out(PG_FUNCTION_ARGS)
+/*
+ * expects an lquery
+ * returns a null terminated string
+ */
+static char *
+deparse_lquery(const lquery *in)
 {
-   lquery     *in = PG_GETARG_LQUERY_P(0);
    char       *buf,
               *ptr;
    int         i,
@@ -679,7 +760,79 @@ lquery_out(PG_FUNCTION_ARGS)
    }
 
    *ptr = '\0';
-   PG_FREE_IF_COPY(in, 0);
+   return buf;
+}
+
+/*
+ * Basic lquery I/O functions
+ */
+PG_FUNCTION_INFO_V1(lquery_in);
+Datum
+lquery_in(PG_FUNCTION_ARGS)
+{
+   char       *buf = (char *) PG_GETARG_POINTER(0);
+
+   PG_RETURN_POINTER(parse_lquery(buf));
+}
+
+PG_FUNCTION_INFO_V1(lquery_out);
+Datum
+lquery_out(PG_FUNCTION_ARGS)
+{
+   lquery     *in = PG_GETARG_LQUERY_P(0);
+
+   PG_RETURN_POINTER(deparse_lquery(in));
+}
+
+/*
+ * lquery type send function
+ *
+ * The type is sent as text in binary mode, so this is almost the same
+ * as the output function, but it's prefixed with a version number so we
+ * can change the binary format sent in future if necessary. For now,
+ * only version 1 is supported.
+ */
+PG_FUNCTION_INFO_V1(lquery_send);
+Datum
+lquery_send(PG_FUNCTION_ARGS)
+{
+   lquery     *in = PG_GETARG_LQUERY_P(0);
+   StringInfoData buf;
+   int         version = 1;
+   char       *res = deparse_lquery(in);
+
+   pq_begintypsend(&buf);
+   pq_sendint8(&buf, version);
+   pq_sendtext(&buf, res, strlen(res));
+   pfree(res);
+
+   PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+}
+
+/*
+ * lquery type recv function
+ *
+ * The type is sent as text in binary mode, so this is almost the same
+ * as the input function, but it's prefixed with a version number so we
+ * can change the binary format sent in future if necessary. For now,
+ * only version 1 is supported.
+ */
+PG_FUNCTION_INFO_V1(lquery_recv);
+Datum
+lquery_recv(PG_FUNCTION_ARGS)
+{
+   StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
+   int         version = pq_getmsgint(buf, 1);
+   char       *str;
+   int         nbytes;
+   lquery     *res;
+
+   if (version != 1)
+       elog(ERROR, "unsupported lquery version number %d", version);
+
+   str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
+   res = parse_lquery(str);
+   pfree(str);
 
-   PG_RETURN_POINTER(buf);
+   PG_RETURN_POINTER(res);
 }

diff --git a/contrib/ltree/ltxtquery_io.c b/contrib/ltree/ltxtquery_io.c
index db347f77721e16b784207ecc081aa4db012f41da..d967f92110fed68b376885855be79f1ccaa7c363 100644 (file)
--- a/contrib/ltree/ltxtquery_io.c
+++ b/contrib/ltree/ltxtquery_io.c
@@ -8,12 +8,10 @@
 #include <ctype.h>
 
 #include "crc32.h"
+#include "libpq/pqformat.h"
 #include "ltree.h"
 #include "miscadmin.h"
 
-PG_FUNCTION_INFO_V1(ltxtq_in);
-PG_FUNCTION_INFO_V1(ltxtq_out);
-
 
 /* parser's states */
 #define WAITOPERAND 1
@@ -381,12 +379,41 @@ queryin(char *buf)
 /*
  * in without morphology
  */
+PG_FUNCTION_INFO_V1(ltxtq_in);
 Datum
 ltxtq_in(PG_FUNCTION_ARGS)
 {
    PG_RETURN_POINTER(queryin((char *) PG_GETARG_POINTER(0)));
 }
 
+/*
+ * ltxtquery type recv function
+ *
+ * The type is sent as text in binary mode, so this is almost the same
+ * as the input function, but it's prefixed with a version number so we
+ * can change the binary format sent in future if necessary. For now,
+ * only version 1 is supported.
+ */
+PG_FUNCTION_INFO_V1(ltxtq_recv);
+Datum
+ltxtq_recv(PG_FUNCTION_ARGS)
+{
+   StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
+   int         version = pq_getmsgint(buf, 1);
+   char       *str;
+   int         nbytes;
+   ltxtquery  *res;
+
+   if (version != 1)
+       elog(ERROR, "unsupported ltxtquery version number %d", version);
+
+   str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
+   res = queryin(str);
+   pfree(str);
+
+   PG_RETURN_POINTER(res);
+}
+
 /*
  * out function
  */
@@ -511,6 +538,7 @@ infix(INFIX *in, bool first)
    }
 }
 
+PG_FUNCTION_INFO_V1(ltxtq_out);
 Datum
 ltxtq_out(PG_FUNCTION_ARGS)
 {
@@ -530,6 +558,43 @@ ltxtq_out(PG_FUNCTION_ARGS)
    nrm.op = GETOPERAND(query);
    infix(&nrm, true);
 
-   PG_FREE_IF_COPY(query, 0);
    PG_RETURN_POINTER(nrm.buf);
 }
+
+/*
+ * ltxtquery type send function
+ *
+ * The type is sent as text in binary mode, so this is almost the same
+ * as the output function, but it's prefixed with a version number so we
+ * can change the binary format sent in future if necessary. For now,
+ * only version 1 is supported.
+ */
+PG_FUNCTION_INFO_V1(ltxtq_send);
+Datum
+ltxtq_send(PG_FUNCTION_ARGS)
+{
+   ltxtquery  *query = PG_GETARG_LTXTQUERY_P(0);
+   StringInfoData buf;
+   int         version = 1;
+   INFIX       nrm;
+
+   if (query->size == 0)
+       ereport(ERROR,
+               (errcode(ERRCODE_SYNTAX_ERROR),
+                errmsg("syntax error"),
+                errdetail("Empty query.")));
+
+   nrm.curpol = GETQUERY(query);
+   nrm.buflen = 32;
+   nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
+   *(nrm.cur) = '\0';
+   nrm.op = GETOPERAND(query);
+   infix(&nrm, true);
+
+   pq_begintypsend(&buf);
+   pq_sendint8(&buf, version);
+   pq_sendtext(&buf, nrm.buf, strlen(nrm.buf));
+   pfree(nrm.buf);
+
+   PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+}