Split out code into new getKeyJsonValueFromContainer()

The new function stashes its output value in a JsonbValue that can be
passed in by the caller, which enables some of them to pass
stack-allocated structs -- saving palloc cycles.  It also allows some
callers that know they are handling a jsonb object to use this new jsonb
object-specific API, instead of going through generic container
findJsonbValueFromContainer.

Author: Nikita Glukhov
Discussion: https://postgr.es/m/7c417f90-f95f-247e-ba63-d95e39c0ad14@postgrespro.ru

diff --git a/src/backend/utils/adt/jsonb_util.c b/src/backend/utils/adt/jsonb_util.c
index ac04c4a57bc134210ab866f3fd61928ddada2223..7e0d9de7f0c6f531f38053c445d78aaaa308b82a 100644 (file)
--- a/src/backend/utils/adt/jsonb_util.c
+++ b/src/backend/utils/adt/jsonb_util.c
@@ -56,6 +56,8 @@ static void appendKey(JsonbParseState *pstate, JsonbValue *scalarVal);
 static void appendValue(JsonbParseState *pstate, JsonbValue *scalarVal);
 static void appendElement(JsonbParseState *pstate, JsonbValue *scalarVal);
 static int lengthCompareJsonbStringValue(const void *a, const void *b);
+static int lengthCompareJsonbString(const char *val1, int len1,
+                                    const char *val2, int len2);
 static int lengthCompareJsonbPair(const void *a, const void *b, void *arg);
 static void uniqueifyJsonbObject(JsonbValue *object);
 static JsonbValue *pushJsonbValueScalar(JsonbParseState **pstate,
@@ -329,7 +331,6 @@ findJsonbValueFromContainer(JsonbContainer *container, uint32 flags,
 {
    JEntry     *children = container->children;
    int         count = JsonContainerSize(container);
-   JsonbValue *result;
 
    Assert((flags & ~(JB_FARRAY | JB_FOBJECT)) == 0);
 
@@ -337,10 +338,9 @@ findJsonbValueFromContainer(JsonbContainer *container, uint32 flags,
    if (count <= 0)
        return NULL;
 
-   result = palloc(sizeof(JsonbValue));
-
    if ((flags & JB_FARRAY) && JsonContainerIsArray(container))
    {
+       JsonbValue *result = palloc(sizeof(JsonbValue));
        char       *base_addr = (char *) (children + count);
        uint32      offset = 0;
        int         i;
@@ -357,56 +357,90 @@ findJsonbValueFromContainer(JsonbContainer *container, uint32 flags,
 
            JBE_ADVANCE_OFFSET(offset, children[i]);
        }
+
+       pfree(result);
    }
    else if ((flags & JB_FOBJECT) && JsonContainerIsObject(container))
    {
-       /* Since this is an object, account for *Pairs* of Jentrys */
-       char       *base_addr = (char *) (children + count * 2);
-       uint32      stopLow = 0,
-                   stopHigh = count;
-
        /* Object key passed by caller must be a string */
        Assert(key->type == jbvString);
 
-       /* Binary search on object/pair keys *only* */
-       while (stopLow < stopHigh)
-       {
-           uint32      stopMiddle;
-           int         difference;
-           JsonbValue  candidate;
+       return getKeyJsonValueFromContainer(container, key->val.string.val,
+                                           key->val.string.len, NULL);
+   }
+
+   /* Not found */
+   return NULL;
+}
+
+/*
+ * Find value by key in Jsonb object and fetch it into 'res', which is also
+ * returned.
+ *
+ * 'res' can be passed in as NULL, in which case it's newly palloc'ed here.
+ */
+JsonbValue *
+getKeyJsonValueFromContainer(JsonbContainer *container,
+                            const char *keyVal, int keyLen, JsonbValue *res)
+{
+   JEntry     *children = container->children;
+   int         count = JsonContainerSize(container);
+   char       *baseAddr;
+   uint32      stopLow,
+               stopHigh;
 
-           stopMiddle = stopLow + (stopHigh - stopLow) / 2;
+   Assert(JsonContainerIsObject(container));
 
-           candidate.type = jbvString;
-           candidate.val.string.val =
-               base_addr + getJsonbOffset(container, stopMiddle);
-           candidate.val.string.len = getJsonbLength(container, stopMiddle);
+   /* Quick out without a palloc cycle if object is empty */
+   if (count <= 0)
+       return NULL;
 
-           difference = lengthCompareJsonbStringValue(&candidate, key);
+   /*
+    * Binary search the container. Since we know this is an object, account
+    * for *Pairs* of Jentrys
+    */
+   baseAddr = (char *) (children + count * 2);
+   stopLow = 0;
+   stopHigh = count;
+   while (stopLow < stopHigh)
+   {
+       uint32      stopMiddle;
+       int         difference;
+       const char *candidateVal;
+       int         candidateLen;
 
-           if (difference == 0)
-           {
-               /* Found our key, return corresponding value */
-               int         index = stopMiddle + count;
+       stopMiddle = stopLow + (stopHigh - stopLow) / 2;
 
-               fillJsonbValue(container, index, base_addr,
-                              getJsonbOffset(container, index),
-                              result);
+       candidateVal = baseAddr + getJsonbOffset(container, stopMiddle);
+       candidateLen = getJsonbLength(container, stopMiddle);
 
-               return result;
-           }
+       difference = lengthCompareJsonbString(candidateVal, candidateLen,
+                                             keyVal, keyLen);
+
+       if (difference == 0)
+       {
+           /* Found our key, return corresponding value */
+           int         index = stopMiddle + count;
+
+           if (!res)
+               res = palloc(sizeof(JsonbValue));
+
+           fillJsonbValue(container, index, baseAddr,
+                          getJsonbOffset(container, index),
+                          res);
+
+           return res;
+       }
+       else
+       {
+           if (difference < 0)
+               stopLow = stopMiddle + 1;
            else
-           {
-               if (difference < 0)
-                   stopLow = stopMiddle + 1;
-               else
-                   stopHigh = stopMiddle;
-           }
+               stopHigh = stopMiddle;
        }
    }
 
    /* Not found */
-   pfree(result);
    return NULL;
 }
 
@@ -1009,6 +1043,7 @@ JsonbDeepContains(JsonbIterator **val, JsonbIterator **mContained)
        for (;;)
        {
            JsonbValue *lhsVal; /* lhsVal is from pair in lhs object */
+           JsonbValue  lhsValBuf;
 
            rcont = JsonbIteratorNext(mContained, &vcontained, false);
 
@@ -1021,12 +1056,14 @@ JsonbDeepContains(JsonbIterator **val, JsonbIterator **mContained)
                return true;
 
            Assert(rcont == WJB_KEY);
+           Assert(vcontained.type == jbvString);
 
            /* First, find value by key... */
-           lhsVal = findJsonbValueFromContainer((*val)->container,
-                                                JB_FOBJECT,
-                                                &vcontained);
-
+           lhsVal =
+               getKeyJsonValueFromContainer((*val)->container,
+                                            vcontained.val.string.val,
+                                            vcontained.val.string.len,
+                                            &lhsValBuf);
            if (!lhsVal)
                return false;
 
@@ -1771,21 +1808,27 @@ lengthCompareJsonbStringValue(const void *a, const void *b)
 {
    const JsonbValue *va = (const JsonbValue *) a;
    const JsonbValue *vb = (const JsonbValue *) b;
-   int         res;
 
    Assert(va->type == jbvString);
    Assert(vb->type == jbvString);
 
-   if (va->val.string.len == vb->val.string.len)
-   {
-       res = memcmp(va->val.string.val, vb->val.string.val, va->val.string.len);
-   }
-   else
-   {
-       res = (va->val.string.len > vb->val.string.len) ? 1 : -1;
-   }
+   return lengthCompareJsonbString(va->val.string.val, va->val.string.len,
+                                   vb->val.string.val, vb->val.string.len);
+}
 
-   return res;
+/*
+ * Subroutine for lengthCompareJsonbStringValue
+ *
+ * This is also useful separately to implement binary search on
+ * JsonbContainers.
+ */
+static int
+lengthCompareJsonbString(const char *val1, int len1, const char *val2, int len2)
+{
+   if (len1 == len2)
+       return memcmp(val1, val2, len1);
+   else
+       return len1 > len2 ? 1 : -1;
 }
 
 /*

diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c
index aba687243422b66a958750a708b16ce6c55e9dbc..3553a304b8c1861e86f48f998163b35e6f2bd052 100644 (file)
--- a/src/backend/utils/adt/jsonfuncs.c
+++ b/src/backend/utils/adt/jsonfuncs.c
@@ -454,12 +454,6 @@ static Datum populate_array(ArrayIOData *aio, const char *colname,
 static Datum populate_domain(DomainIOData *io, Oid typid, const char *colname,
                             MemoryContext mcxt, JsValue *jsv, bool isnull);
 
-/* Worker that takes care of common setup for us */
-static JsonbValue *findJsonbValueFromContainerLen(JsonbContainer *container,
-                                                 uint32 flags,
-                                                 char *key,
-                                                 uint32 keylen);
-
 /* functions supporting jsonb_delete, jsonb_set and jsonb_concat */
 static JsonbValue *IteratorConcat(JsonbIterator **it1, JsonbIterator **it2,
                                  JsonbParseState **state);
@@ -718,13 +712,15 @@ jsonb_object_field(PG_FUNCTION_ARGS)
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    text       *key = PG_GETARG_TEXT_PP(1);
    JsonbValue *v;
+   JsonbValue  vbuf;
 
    if (!JB_ROOT_IS_OBJECT(jb))
        PG_RETURN_NULL();
 
-   v = findJsonbValueFromContainerLen(&jb->root, JB_FOBJECT,
-                                      VARDATA_ANY(key),
-                                      VARSIZE_ANY_EXHDR(key));
+   v = getKeyJsonValueFromContainer(&jb->root,
+                                    VARDATA_ANY(key),
+                                    VARSIZE_ANY_EXHDR(key),
+                                    &vbuf);
 
    if (v != NULL)
        PG_RETURN_JSONB_P(JsonbValueToJsonb(v));
@@ -754,14 +750,15 @@ jsonb_object_field_text(PG_FUNCTION_ARGS)
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    text       *key = PG_GETARG_TEXT_PP(1);
    JsonbValue *v;
+   JsonbValue  vbuf;
 
    if (!JB_ROOT_IS_OBJECT(jb))
        PG_RETURN_NULL();
 
-   v = findJsonbValueFromContainerLen(&jb->root, JB_FOBJECT,
-                                      VARDATA_ANY(key),
-                                      VARSIZE_ANY_EXHDR(key));
-
+   v = getKeyJsonValueFromContainer(&jb->root,
+                                    VARDATA_ANY(key),
+                                    VARSIZE_ANY_EXHDR(key),
+                                    &vbuf);
 
    if (v != NULL && v->type != jbvNull)
        PG_RETURN_TEXT_P(JsonbValueAsText(v));
@@ -1336,6 +1333,7 @@ get_jsonb_path_all(FunctionCallInfo fcinfo, bool as_text)
    bool        have_object = false,
                have_array = false;
    JsonbValue *jbvp = NULL;
+   JsonbValue  jbvbuf;
    JsonbContainer *container;
 
    /*
@@ -1393,10 +1391,10 @@ get_jsonb_path_all(FunctionCallInfo fcinfo, bool as_text)
    {
        if (have_object)
        {
-           jbvp = findJsonbValueFromContainerLen(container,
-                                                 JB_FOBJECT,
-                                                 VARDATA(pathtext[i]),
-                                                 VARSIZE(pathtext[i]) - VARHDRSZ);
+           jbvp = getKeyJsonValueFromContainer(container,
+                                               VARDATA(pathtext[i]),
+                                               VARSIZE(pathtext[i]) - VARHDRSZ,
+                                               &jbvbuf);
        }
        else if (have_array)
        {
@@ -3023,8 +3021,8 @@ JsObjectGetField(JsObject *obj, char *field, JsValue *jsv)
    else
    {
        jsv->val.jsonb = !obj->val.jsonb_cont ? NULL :
-           findJsonbValueFromContainerLen(obj->val.jsonb_cont, JB_FOBJECT,
-                                          field, strlen(field));
+           getKeyJsonValueFromContainer(obj->val.jsonb_cont, field, strlen(field),
+                                        NULL);
 
        return jsv->val.jsonb != NULL;
    }
@@ -3848,22 +3846,6 @@ populate_recordset_object_field_end(void *state, char *fname, bool isnull)
    }
 }
 
-/*
- * findJsonbValueFromContainer() wrapper that sets up JsonbValue key string.
- */
-static JsonbValue *
-findJsonbValueFromContainerLen(JsonbContainer *container, uint32 flags,
-                              char *key, uint32 keylen)
-{
-   JsonbValue  k;
-
-   k.type = jbvString;
-   k.val.string.val = key;
-   k.val.string.len = keylen;
-
-   return findJsonbValueFromContainer(container, flags, &k);
-}
-
 /*
  * Semantic actions for json_strip_nulls.
  *

diff --git a/src/include/utils/jsonb.h b/src/include/utils/jsonb.h
index ac52b75f51d8496dd3c8724a85746d0422b30cce..35766e106a8a5794474578f78563a9224b9ac36e 100644 (file)
--- a/src/include/utils/jsonb.h
+++ b/src/include/utils/jsonb.h
@@ -364,6 +364,9 @@ extern int  compareJsonbContainers(JsonbContainer *a, JsonbContainer *b);
 extern JsonbValue *findJsonbValueFromContainer(JsonbContainer *sheader,
                                               uint32 flags,
                                               JsonbValue *key);
+extern JsonbValue *getKeyJsonValueFromContainer(JsonbContainer *container,
+                                               const char *keyVal, int keyLen,
+                                               JsonbValue *res);
 extern JsonbValue *getIthJsonbValueFromContainer(JsonbContainer *sheader,
                                                 uint32 i);
 extern JsonbValue *pushJsonbValue(JsonbParseState **pstate,