jsonb_util.c File Reference

#include "postgres.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_type.h"
#include "common/hashfn.h"
#include "miscadmin.h"
#include "port/pg_bitutils.h"
#include "utils/date.h"
#include "utils/datetime.h"
#include "utils/datum.h"
#include "utils/fmgrprotos.h"
#include "utils/json.h"
#include "utils/jsonb.h"
#include "utils/memutils.h"
#include "utils/varlena.h"

Include dependency graph for jsonb_util.c:

Go to the source code of this file.

Macros
#define	JSONB_MAX_ELEMS   (Min(MaxAllocSize / sizeof(JsonbValue), JB_CMASK))
#define	JSONB_MAX_PAIRS   (Min(MaxAllocSize / sizeof(JsonbPair), JB_CMASK))

Functions
static void	fillJsonbValue (JsonbContainer *container, int index, char *base_addr, uint32 offset, JsonbValue *result)
static bool	equalsJsonbScalarValue (JsonbValue *a, JsonbValue *b)
static int	compareJsonbScalarValue (JsonbValue *a, JsonbValue *b)
static Jsonb *	convertToJsonb (JsonbValue *val)
static void	convertJsonbValue (StringInfo buffer, JEntry *header, JsonbValue *val, int level)
static void	convertJsonbArray (StringInfo buffer, JEntry *header, JsonbValue *val, int level)
static void	convertJsonbObject (StringInfo buffer, JEntry *header, JsonbValue *val, int level)
static void	convertJsonbScalar (StringInfo buffer, JEntry *header, JsonbValue *scalarVal)
static int	reserveFromBuffer (StringInfo buffer, int len)
static void	appendToBuffer (StringInfo buffer, const void *data, int len)
static void	copyToBuffer (StringInfo buffer, int offset, const void *data, int len)
static short	padBufferToInt (StringInfo buffer)
static JsonbIterator *	iteratorFromContainer (JsonbContainer *container, JsonbIterator *parent)
static JsonbIterator *	freeAndGetParent (JsonbIterator *it)
static JsonbParseState *	pushState (JsonbInState *pstate)
static void	appendKey (JsonbInState *pstate, JsonbValue *string, bool needCopy)
static void	appendValue (JsonbInState *pstate, JsonbValue *scalarVal, bool needCopy)
static void	appendElement (JsonbInState *pstate, JsonbValue *scalarVal, bool needCopy)
static void	copyScalarSubstructure (JsonbValue *v, MemoryContext outcontext)
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 *binequal)
static void	uniqueifyJsonbObject (JsonbValue *object, bool unique_keys, bool skip_nulls)
static void	pushJsonbValueScalar (JsonbInState *pstate, JsonbIteratorToken seq, JsonbValue *scalarVal)
void	JsonbToJsonbValue (Jsonb *jsonb, JsonbValue *val)
Jsonb *	JsonbValueToJsonb (JsonbValue *val)
uint32	getJsonbOffset (const JsonbContainer *jc, int index)
uint32	getJsonbLength (const JsonbContainer *jc, int index)
int	compareJsonbContainers (JsonbContainer *a, JsonbContainer *b)
JsonbValue *	findJsonbValueFromContainer (JsonbContainer *container, uint32 flags, JsonbValue *key)
JsonbValue *	getKeyJsonValueFromContainer (JsonbContainer *container, const char *keyVal, int keyLen, JsonbValue *res)
JsonbValue *	getIthJsonbValueFromContainer (JsonbContainer *container, uint32 i)
void	pushJsonbValue (JsonbInState *pstate, JsonbIteratorToken seq, JsonbValue *jbval)
JsonbIterator *	JsonbIteratorInit (JsonbContainer *container)
JsonbIteratorToken	JsonbIteratorNext (JsonbIterator **it, JsonbValue *val, bool skipNested)
bool	JsonbDeepContains (JsonbIterator **val, JsonbIterator **mContained)
void	JsonbHashScalarValue (const JsonbValue *scalarVal, uint32 *hash)
void	JsonbHashScalarValueExtended (const JsonbValue *scalarVal, uint64 *hash, uint64 seed)

Macro Definition Documentation

JSONB_MAX_ELEMS

#define JSONB_MAX_ELEMS   (Min(MaxAllocSize / sizeof(JsonbValue), JB_CMASK))

Definition at line 39 of file jsonb_util.c.

JSONB_MAX_PAIRS

#define JSONB_MAX_PAIRS   (Min(MaxAllocSize / sizeof(JsonbPair), JB_CMASK))

Definition at line 40 of file jsonb_util.c.

Function Documentation

appendElement()

static void appendElement ( JsonbInState *  pstate, JsonbValue *  scalarVal, bool  needCopy  )

static

Definition at line 837 of file jsonb_util.c.

{
    JsonbParseState *ppstate = pstate->parseState;
    JsonbValue *array = &ppstate->contVal;
    JsonbValue *elem;
 
    Assert(array->type == jbvArray);
 
    if (array->val.array.nElems >= ppstate->size)
    {
        if (unlikely(array->val.array.nElems >= JSONB_MAX_ELEMS))
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("number of jsonb array elements exceeds the maximum allowed (%zu)",
                            JSONB_MAX_ELEMS)));
        ppstate->size = Min(ppstate->size * 2, JSONB_MAX_ELEMS);
        array->val.array.elems = repalloc(array->val.array.elems,
                                          sizeof(JsonbValue) * ppstate->size);
    }
 
    elem = &array->val.array.elems[array->val.array.nElems];
    *elem = *scalarVal;
    array->val.array.nElems++;
 
    if (needCopy)
        copyScalarSubstructure(elem, pstate->outcontext);
}

References Assert(), JsonbParseState::contVal, copyScalarSubstructure(), ereport, errcode(), errmsg(), ERROR, jbvArray, JSONB_MAX_ELEMS, Min, JsonbInState::outcontext, JsonbInState::parseState, repalloc(), JsonbParseState::size, JsonbValue::type, unlikely, and JsonbValue::val.

Referenced by pushJsonbValueScalar().

appendKey()

static void appendKey ( JsonbInState *  pstate, JsonbValue *  string, bool  needCopy  )

static

Definition at line 785 of file jsonb_util.c.

{
    JsonbParseState *ppstate = pstate->parseState;
    JsonbValue *object = &ppstate->contVal;
    JsonbPair  *pair;
 
    Assert(object->type == jbvObject);
    Assert(string->type == jbvString);
 
    if (object->val.object.nPairs >= ppstate->size)
    {
        if (unlikely(object->val.object.nPairs >= JSONB_MAX_PAIRS))
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("number of jsonb object pairs exceeds the maximum allowed (%zu)",
                            JSONB_MAX_PAIRS)));
        ppstate->size = Min(ppstate->size * 2, JSONB_MAX_PAIRS);
        object->val.object.pairs = repalloc(object->val.object.pairs,
                                            sizeof(JsonbPair) * ppstate->size);
    }
 
    pair = &object->val.object.pairs[object->val.object.nPairs];
    pair->key = *string;
    pair->order = object->val.object.nPairs;
 
    if (needCopy)
        copyScalarSubstructure(&pair->key, pstate->outcontext);
}

References Assert(), JsonbParseState::contVal, copyScalarSubstructure(), ereport, errcode(), errmsg(), ERROR, jbvObject, jbvString, JSONB_MAX_PAIRS, JsonbPair::key, Min, JsonbPair::order, JsonbInState::outcontext, JsonbInState::parseState, repalloc(), JsonbParseState::size, JsonbValue::type, unlikely, and JsonbValue::val.

Referenced by pushJsonbValueScalar().

appendToBuffer()

static void appendToBuffer ( StringInfo  buffer, const void *  data, int  len  )

static

Definition at line 1640 of file jsonb_util.c.

{
    int         offset;
 
    offset = reserveFromBuffer(buffer, len);
    copyToBuffer(buffer, offset, data, len);
}

References copyToBuffer(), data, len, and reserveFromBuffer().

Referenced by convertJsonbArray(), convertJsonbObject(), and convertJsonbScalar().

appendValue()

static void appendValue ( JsonbInState *  pstate, JsonbValue *  scalarVal, bool  needCopy  )

static

Definition at line 818 of file jsonb_util.c.

{
    JsonbValue *object = &pstate->parseState->contVal;
    JsonbPair  *pair;
 
    Assert(object->type == jbvObject);
 
    pair = &object->val.object.pairs[object->val.object.nPairs];
    pair->value = *scalarVal;
    object->val.object.nPairs++;
 
    if (needCopy)
        copyScalarSubstructure(&pair->value, pstate->outcontext);
}

References Assert(), JsonbParseState::contVal, copyScalarSubstructure(), jbvObject, JsonbInState::outcontext, JsonbInState::parseState, JsonbValue::type, JsonbValue::val, and JsonbPair::value.

Referenced by pushJsonbValueScalar().

compareJsonbContainers()

int compareJsonbContainers	(	JsonbContainer *	a,
		JsonbContainer *	b
	)

Definition at line 194 of file jsonb_util.c.

{
    JsonbIterator *ita,
               *itb;
    int         res = 0;
 
    ita = JsonbIteratorInit(a);
    itb = JsonbIteratorInit(b);
 
    do
    {
        JsonbValue  va,
                    vb;
        JsonbIteratorToken ra,
                    rb;
 
        ra = JsonbIteratorNext(&ita, &va, false);
        rb = JsonbIteratorNext(&itb, &vb, false);
 
        if (ra == rb)
        {
            if (ra == WJB_DONE)
            {
                /* Decisively equal */
                break;
            }
 
            if (ra == WJB_END_ARRAY || ra == WJB_END_OBJECT)
            {
                /*
                 * There is no array or object to compare at this stage of
                 * processing.  jbvArray/jbvObject values are compared
                 * initially, at the WJB_BEGIN_ARRAY and WJB_BEGIN_OBJECT
                 * tokens.
                 */
                continue;
            }
 
            if (va.type == vb.type)
            {
                switch (va.type)
                {
                    case jbvString:
                    case jbvNull:
                    case jbvNumeric:
                    case jbvBool:
                        res = compareJsonbScalarValue(&va, &vb);
                        break;
                    case jbvArray:
 
                        /*
                         * This could be a "raw scalar" pseudo array.  That's
                         * a special case here though, since we still want the
                         * general type-based comparisons to apply, and as far
                         * as we're concerned a pseudo array is just a scalar.
                         */
                        if (va.val.array.rawScalar != vb.val.array.rawScalar)
                            res = (va.val.array.rawScalar) ? -1 : 1;
 
                        /*
                         * There should be an "else" here, to prevent us from
                         * overriding the above, but we can't change the sort
                         * order now, so there is a mild anomaly that an empty
                         * top level array sorts less than null.
                         */
                        if (va.val.array.nElems != vb.val.array.nElems)
                            res = (va.val.array.nElems > vb.val.array.nElems) ? 1 : -1;
                        break;
                    case jbvObject:
                        if (va.val.object.nPairs != vb.val.object.nPairs)
                            res = (va.val.object.nPairs > vb.val.object.nPairs) ? 1 : -1;
                        break;
                    case jbvBinary:
                        elog(ERROR, "unexpected jbvBinary value");
                        break;
                    case jbvDatetime:
                        elog(ERROR, "unexpected jbvDatetime value");
                        break;
                }
            }
            else
            {
                /* Type-defined order */
                res = (va.type > vb.type) ? 1 : -1;
            }
        }
        else
        {
            /*
             * It's not possible for one iterator to report end of array or
             * object while the other one reports something else, because we
             * would have detected a length mismatch when we processed the
             * container-start tokens above.  Likewise we can't see WJB_DONE
             * from one but not the other.  So we have two different-type
             * containers, or a container and some scalar type, or two
             * different scalar types.  Sort on the basis of the type code.
             */
            Assert(ra != WJB_DONE && ra != WJB_END_ARRAY && ra != WJB_END_OBJECT);
            Assert(rb != WJB_DONE && rb != WJB_END_ARRAY && rb != WJB_END_OBJECT);
 
            Assert(va.type != vb.type);
            Assert(va.type != jbvBinary);
            Assert(vb.type != jbvBinary);
            /* Type-defined order */
            res = (va.type > vb.type) ? 1 : -1;
        }
    }
    while (res == 0);
 
    while (ita != NULL)
    {
        JsonbIterator *i = ita->parent;
 
        pfree(ita);
        ita = i;
    }
    while (itb != NULL)
    {
        JsonbIterator *i = itb->parent;
 
        pfree(itb);
        itb = i;
    }
 
    return res;
}

References a, Assert(), b, compareJsonbScalarValue(), elog, ERROR, i, jbvArray, jbvBinary, jbvBool, jbvDatetime, jbvNull, jbvNumeric, jbvObject, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), JsonbIterator::parent, pfree(), JsonbValue::type, JsonbValue::val, WJB_DONE, WJB_END_ARRAY, and WJB_END_OBJECT.

Referenced by jsonb_cmp(), jsonb_eq(), jsonb_ge(), jsonb_gt(), jsonb_le(), jsonb_lt(), and jsonb_ne().

compareJsonbScalarValue()

static int compareJsonbScalarValue ( JsonbValue *  a, JsonbValue *  b  )

static

Definition at line 1560 of file jsonb_util.c.

{
    if (a->type == b->type)
    {
        switch (a->type)
        {
            case jbvNull:
                return 0;
            case jbvString:
                return varstr_cmp(a->val.string.val,
                                  a->val.string.len,
                                  b->val.string.val,
                                  b->val.string.len,
                                  DEFAULT_COLLATION_OID);
            case jbvNumeric:
                return DatumGetInt32(DirectFunctionCall2(numeric_cmp,
                                                         PointerGetDatum(a->val.numeric),
                                                         PointerGetDatum(b->val.numeric)));
            case jbvBool:
                if (a->val.boolean == b->val.boolean)
                    return 0;
                else if (a->val.boolean > b->val.boolean)
                    return 1;
                else
                    return -1;
            default:
                elog(ERROR, "invalid jsonb scalar type");
        }
    }
    elog(ERROR, "jsonb scalar type mismatch");
    return -1;
}

References a, b, DatumGetInt32(), DirectFunctionCall2, elog, ERROR, jbvBool, jbvNull, jbvNumeric, jbvString, numeric_cmp(), PointerGetDatum(), and varstr_cmp().

Referenced by compareJsonbContainers().

convertJsonbArray()

static void convertJsonbArray ( StringInfo  buffer, JEntry *  header, JsonbValue *  val, int  level  )

static

Definition at line 1742 of file jsonb_util.c.

{
    int         base_offset;
    int         jentry_offset;
    int         i;
    int         totallen;
    uint32      containerhead;
    int         nElems = val->val.array.nElems;
 
    /* Remember where in the buffer this array starts. */
    base_offset = buffer->len;
 
    /* Align to 4-byte boundary (any padding counts as part of my data) */
    padBufferToInt(buffer);
 
    /*
     * Construct the header Jentry and store it in the beginning of the
     * variable-length payload.
     */
    containerhead = nElems | JB_FARRAY;
    if (val->val.array.rawScalar)
    {
        Assert(nElems == 1);
        Assert(level == 0);
        containerhead |= JB_FSCALAR;
    }
 
    appendToBuffer(buffer, &containerhead, sizeof(uint32));
 
    /* Reserve space for the JEntries of the elements. */
    jentry_offset = reserveFromBuffer(buffer, sizeof(JEntry) * nElems);
 
    totallen = 0;
    for (i = 0; i < nElems; i++)
    {
        JsonbValue *elem = &val->val.array.elems[i];
        int         len;
        JEntry      meta;
 
        /*
         * Convert element, producing a JEntry and appending its
         * variable-length data to buffer
         */
        convertJsonbValue(buffer, &meta, elem, level + 1);
 
        len = JBE_OFFLENFLD(meta);
        totallen += len;
 
        /*
         * Bail out if total variable-length data exceeds what will fit in a
         * JEntry length field.  We check this in each iteration, not just
         * once at the end, to forestall possible integer overflow.
         */
        if (totallen > JENTRY_OFFLENMASK)
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("total size of jsonb array elements exceeds the maximum of %d bytes",
                            JENTRY_OFFLENMASK)));
 
        /*
         * Convert each JB_OFFSET_STRIDE'th length to an offset.
         */
        if ((i % JB_OFFSET_STRIDE) == 0)
            meta = (meta & JENTRY_TYPEMASK) | totallen | JENTRY_HAS_OFF;
 
        copyToBuffer(buffer, jentry_offset, &meta, sizeof(JEntry));
        jentry_offset += sizeof(JEntry);
    }
 
    /* Total data size is everything we've appended to buffer */
    totallen = buffer->len - base_offset;
 
    /* Check length again, since we didn't include the metadata above */
    if (totallen > JENTRY_OFFLENMASK)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("total size of jsonb array elements exceeds the maximum of %d bytes",
                        JENTRY_OFFLENMASK)));
 
    /* Initialize the header of this node in the container's JEntry array */
    *header = JENTRY_ISCONTAINER | totallen;
}

References appendToBuffer(), Assert(), convertJsonbValue(), copyToBuffer(), ereport, errcode(), errmsg(), ERROR, i, JB_FARRAY, JB_FSCALAR, JB_OFFSET_STRIDE, JBE_OFFLENFLD, JENTRY_HAS_OFF, JENTRY_ISCONTAINER, JENTRY_OFFLENMASK, JENTRY_TYPEMASK, StringInfoData::len, len, padBufferToInt(), reserveFromBuffer(), and val.

Referenced by convertJsonbValue().

convertJsonbObject()

static void convertJsonbObject ( StringInfo  buffer, JEntry *  header, JsonbValue *  val, int  level  )

static

Definition at line 1826 of file jsonb_util.c.

{
    int         base_offset;
    int         jentry_offset;
    int         i;
    int         totallen;
    uint32      containerheader;
    int         nPairs = val->val.object.nPairs;
 
    /* Remember where in the buffer this object starts. */
    base_offset = buffer->len;
 
    /* Align to 4-byte boundary (any padding counts as part of my data) */
    padBufferToInt(buffer);
 
    /*
     * Construct the header Jentry and store it in the beginning of the
     * variable-length payload.
     */
    containerheader = nPairs | JB_FOBJECT;
    appendToBuffer(buffer, &containerheader, sizeof(uint32));
 
    /* Reserve space for the JEntries of the keys and values. */
    jentry_offset = reserveFromBuffer(buffer, sizeof(JEntry) * nPairs * 2);
 
    /*
     * Iterate over the keys, then over the values, since that is the ordering
     * we want in the on-disk representation.
     */
    totallen = 0;
    for (i = 0; i < nPairs; i++)
    {
        JsonbPair  *pair = &val->val.object.pairs[i];
        int         len;
        JEntry      meta;
 
        /*
         * Convert key, producing a JEntry and appending its variable-length
         * data to buffer
         */
        convertJsonbScalar(buffer, &meta, &pair->key);
 
        len = JBE_OFFLENFLD(meta);
        totallen += len;
 
        /*
         * Bail out if total variable-length data exceeds what will fit in a
         * JEntry length field.  We check this in each iteration, not just
         * once at the end, to forestall possible integer overflow.
         */
        if (totallen > JENTRY_OFFLENMASK)
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("total size of jsonb object elements exceeds the maximum of %d bytes",
                            JENTRY_OFFLENMASK)));
 
        /*
         * Convert each JB_OFFSET_STRIDE'th length to an offset.
         */
        if ((i % JB_OFFSET_STRIDE) == 0)
            meta = (meta & JENTRY_TYPEMASK) | totallen | JENTRY_HAS_OFF;
 
        copyToBuffer(buffer, jentry_offset, &meta, sizeof(JEntry));
        jentry_offset += sizeof(JEntry);
    }
    for (i = 0; i < nPairs; i++)
    {
        JsonbPair  *pair = &val->val.object.pairs[i];
        int         len;
        JEntry      meta;
 
        /*
         * Convert value, producing a JEntry and appending its variable-length
         * data to buffer
         */
        convertJsonbValue(buffer, &meta, &pair->value, level + 1);
 
        len = JBE_OFFLENFLD(meta);
        totallen += len;
 
        /*
         * Bail out if total variable-length data exceeds what will fit in a
         * JEntry length field.  We check this in each iteration, not just
         * once at the end, to forestall possible integer overflow.
         */
        if (totallen > JENTRY_OFFLENMASK)
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("total size of jsonb object elements exceeds the maximum of %d bytes",
                            JENTRY_OFFLENMASK)));
 
        /*
         * Convert each JB_OFFSET_STRIDE'th length to an offset.
         */
        if (((i + nPairs) % JB_OFFSET_STRIDE) == 0)
            meta = (meta & JENTRY_TYPEMASK) | totallen | JENTRY_HAS_OFF;
 
        copyToBuffer(buffer, jentry_offset, &meta, sizeof(JEntry));
        jentry_offset += sizeof(JEntry);
    }
 
    /* Total data size is everything we've appended to buffer */
    totallen = buffer->len - base_offset;
 
    /* Check length again, since we didn't include the metadata above */
    if (totallen > JENTRY_OFFLENMASK)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("total size of jsonb object elements exceeds the maximum of %d bytes",
                        JENTRY_OFFLENMASK)));
 
    /* Initialize the header of this node in the container's JEntry array */
    *header = JENTRY_ISCONTAINER | totallen;
}

References appendToBuffer(), convertJsonbScalar(), convertJsonbValue(), copyToBuffer(), ereport, errcode(), errmsg(), ERROR, i, JB_FOBJECT, JB_OFFSET_STRIDE, JBE_OFFLENFLD, JENTRY_HAS_OFF, JENTRY_ISCONTAINER, JENTRY_OFFLENMASK, JENTRY_TYPEMASK, JsonbPair::key, StringInfoData::len, len, padBufferToInt(), reserveFromBuffer(), val, and JsonbPair::value.

Referenced by convertJsonbValue().

convertJsonbScalar()

static void convertJsonbScalar ( StringInfo  buffer, JEntry *  header, JsonbValue *  scalarVal  )

static

Definition at line 1942 of file jsonb_util.c.

{
    int         numlen;
    short       padlen;
 
    switch (scalarVal->type)
    {
        case jbvNull:
            *header = JENTRY_ISNULL;
            break;
 
        case jbvString:
            appendToBuffer(buffer, scalarVal->val.string.val, scalarVal->val.string.len);
 
            *header = scalarVal->val.string.len;
            break;
 
        case jbvNumeric:
            numlen = VARSIZE_ANY(scalarVal->val.numeric);
            padlen = padBufferToInt(buffer);
 
            appendToBuffer(buffer, scalarVal->val.numeric, numlen);
 
            *header = JENTRY_ISNUMERIC | (padlen + numlen);
            break;
 
        case jbvBool:
            *header = (scalarVal->val.boolean) ?
                JENTRY_ISBOOL_TRUE : JENTRY_ISBOOL_FALSE;
            break;
 
        case jbvDatetime:
            {
                char        buf[MAXDATELEN + 1];
                size_t      len;
 
                JsonEncodeDateTime(buf,
                                   scalarVal->val.datetime.value,
                                   scalarVal->val.datetime.typid,
                                   &scalarVal->val.datetime.tz);
                len = strlen(buf);
                appendToBuffer(buffer, buf, len);
 
                *header = len;
            }
            break;
 
        default:
            elog(ERROR, "invalid jsonb scalar type");
    }
}

References appendToBuffer(), buf, elog, ERROR, jbvBool, jbvDatetime, jbvNull, jbvNumeric, jbvString, JENTRY_ISBOOL_FALSE, JENTRY_ISBOOL_TRUE, JENTRY_ISNULL, JENTRY_ISNUMERIC, JsonEncodeDateTime(), len, MAXDATELEN, padBufferToInt(), JsonbValue::type, JsonbValue::val, and VARSIZE_ANY().

Referenced by convertJsonbObject(), and convertJsonbValue().

convertJsonbValue()

static void convertJsonbValue ( StringInfo  buffer, JEntry *  header, JsonbValue *  val, int  level  )

static

Definition at line 1717 of file jsonb_util.c.

{
    check_stack_depth();
 
    if (!val)
        return;
 
    /*
     * A JsonbValue passed as val should never have a type of jbvBinary, and
     * neither should any of its sub-components. Those values will be produced
     * by convertJsonbArray and convertJsonbObject, the results of which will
     * not be passed back to this function as an argument.
     */
 
    if (IsAJsonbScalar(val))
        convertJsonbScalar(buffer, header, val);
    else if (val->type == jbvArray)
        convertJsonbArray(buffer, header, val, level);
    else if (val->type == jbvObject)
        convertJsonbObject(buffer, header, val, level);
    else
        elog(ERROR, "unknown type of jsonb container to convert");
}

References check_stack_depth(), convertJsonbArray(), convertJsonbObject(), convertJsonbScalar(), elog, ERROR, IsAJsonbScalar, jbvArray, jbvObject, and val.

Referenced by convertJsonbArray(), convertJsonbObject(), and convertToJsonb().

convertToJsonb()

static Jsonb * convertToJsonb ( JsonbValue *  val )

static

Definition at line 1675 of file jsonb_util.c.

{
    StringInfoData buffer;
    JEntry      jentry;
    Jsonb      *res;
 
    /* Should not already have binary representation */
    Assert(val->type != jbvBinary);
 
    /* Allocate an output buffer. It will be enlarged as needed */
    initStringInfo(&buffer);
 
    /* Make room for the varlena header */
    reserveFromBuffer(&buffer, VARHDRSZ);
 
    convertJsonbValue(&buffer, &jentry, val, 0);
 
    /*
     * Note: the JEntry of the root is discarded. Therefore the root
     * JsonbContainer struct must contain enough information to tell what kind
     * of value it is.
     */
 
    res = (Jsonb *) buffer.data;
 
    SET_VARSIZE(res, buffer.len);
 
    return res;
}

References Assert(), convertJsonbValue(), StringInfoData::data, initStringInfo(), jbvBinary, StringInfoData::len, reserveFromBuffer(), SET_VARSIZE(), val, and VARHDRSZ.

Referenced by JsonbValueToJsonb().

copyScalarSubstructure()

static void copyScalarSubstructure ( JsonbValue *  v, MemoryContext  outcontext  )

static

Definition at line 873 of file jsonb_util.c.

{
    MemoryContext oldcontext;
 
    /* Nothing to do if caller did not specify an outcontext */
    if (outcontext == NULL)
        return;
    switch (v->type)
    {
        case jbvNull:
        case jbvBool:
            /* pass-by-value, nothing to do */
            break;
        case jbvString:
            {
                char       *buf = MemoryContextAlloc(outcontext,
                                                     v->val.string.len);
 
                memcpy(buf, v->val.string.val, v->val.string.len);
                v->val.string.val = buf;
            }
            break;
        case jbvNumeric:
            oldcontext = MemoryContextSwitchTo(outcontext);
            v->val.numeric =
                DatumGetNumeric(datumCopy(NumericGetDatum(v->val.numeric),
                                          false, -1));
            MemoryContextSwitchTo(oldcontext);
            break;
        case jbvDatetime:
            switch (v->val.datetime.typid)
            {
                case DATEOID:
                case TIMEOID:
                case TIMESTAMPOID:
                case TIMESTAMPTZOID:
                    /* pass-by-value, nothing to do */
                    break;
                case TIMETZOID:
                    /* pass-by-reference */
                    oldcontext = MemoryContextSwitchTo(outcontext);
                    v->val.datetime.value = datumCopy(v->val.datetime.value,
                                                      false, TIMETZ_TYPLEN);
                    MemoryContextSwitchTo(oldcontext);
                    break;
                default:
                    elog(ERROR, "unexpected jsonb datetime type oid %u",
                         v->val.datetime.typid);
            }
            break;
        default:
            elog(ERROR, "invalid jsonb scalar type");
    }
}

References buf, datumCopy(), DatumGetNumeric(), elog, ERROR, jbvBool, jbvDatetime, jbvNull, jbvNumeric, jbvString, MemoryContextAlloc(), MemoryContextSwitchTo(), NumericGetDatum(), TIMETZ_TYPLEN, JsonbValue::type, and JsonbValue::val.

Referenced by appendElement(), appendKey(), and appendValue().

copyToBuffer()

static void copyToBuffer ( StringInfo  buffer, int  offset, const void *  data, int  len  )

static

Definition at line 1631 of file jsonb_util.c.

{
    memcpy(buffer->data + offset, data, len);
}

References StringInfoData::data, data, and len.

Referenced by appendToBuffer(), convertJsonbArray(), and convertJsonbObject().

equalsJsonbScalarValue()

static bool equalsJsonbScalarValue ( JsonbValue *  a, JsonbValue *  b  )

static

Definition at line 1528 of file jsonb_util.c.

{
    if (a->type == b->type)
    {
        switch (a->type)
        {
            case jbvNull:
                return true;
            case jbvString:
                return lengthCompareJsonbStringValue(a, b) == 0;
            case jbvNumeric:
                return DatumGetBool(DirectFunctionCall2(numeric_eq,
                                                        PointerGetDatum(a->val.numeric),
                                                        PointerGetDatum(b->val.numeric)));
            case jbvBool:
                return a->val.boolean == b->val.boolean;
 
            default:
                elog(ERROR, "invalid jsonb scalar type");
        }
    }
    elog(ERROR, "jsonb scalar type mismatch");
    return false;
}

References a, b, DatumGetBool(), DirectFunctionCall2, elog, ERROR, jbvBool, jbvNull, jbvNumeric, jbvString, lengthCompareJsonbStringValue(), numeric_eq(), and PointerGetDatum().

Referenced by findJsonbValueFromContainer(), and JsonbDeepContains().

fillJsonbValue()

static void fillJsonbValue ( JsonbContainer *  container, int  index, char *  base_addr, uint32  offset, JsonbValue *  result  )

static

Definition at line 509 of file jsonb_util.c.

{
    JEntry      entry = container->children[index];
 
    if (JBE_ISNULL(entry))
    {
        result->type = jbvNull;
    }
    else if (JBE_ISSTRING(entry))
    {
        result->type = jbvString;
        result->val.string.val = base_addr + offset;
        result->val.string.len = getJsonbLength(container, index);
        Assert(result->val.string.len >= 0);
    }
    else if (JBE_ISNUMERIC(entry))
    {
        result->type = jbvNumeric;
        result->val.numeric = (Numeric) (base_addr + INTALIGN(offset));
    }
    else if (JBE_ISBOOL_TRUE(entry))
    {
        result->type = jbvBool;
        result->val.boolean = true;
    }
    else if (JBE_ISBOOL_FALSE(entry))
    {
        result->type = jbvBool;
        result->val.boolean = false;
    }
    else
    {
        Assert(JBE_ISCONTAINER(entry));
        result->type = jbvBinary;
        /* Remove alignment padding from data pointer and length */
        result->val.binary.data = (JsonbContainer *) (base_addr + INTALIGN(offset));
        result->val.binary.len = getJsonbLength(container, index) -
            (INTALIGN(offset) - offset);
    }
}

References Assert(), JsonbContainer::children, getJsonbLength(), INTALIGN, JBE_ISBOOL_FALSE, JBE_ISBOOL_TRUE, JBE_ISCONTAINER, JBE_ISNULL, JBE_ISNUMERIC, JBE_ISSTRING, jbvBinary, jbvBool, jbvNull, jbvNumeric, jbvString, JsonbValue::type, and JsonbValue::val.

Referenced by findJsonbValueFromContainer(), getIthJsonbValueFromContainer(), getKeyJsonValueFromContainer(), and JsonbIteratorNext().

findJsonbValueFromContainer()

JsonbValue * findJsonbValueFromContainer	(	JsonbContainer *	container,
		uint32	flags,
		JsonbValue *	key
	)

Definition at line 348 of file jsonb_util.c.

{
    JEntry     *children = container->children;
    int         count = JsonContainerSize(container);
 
    Assert((flags & ~(JB_FARRAY | JB_FOBJECT)) == 0);
 
    /* Quick out without a palloc cycle if object/array is empty */
    if (count <= 0)
        return NULL;
 
    if ((flags & JB_FARRAY) && JsonContainerIsArray(container))
    {
        JsonbValue *result = palloc_object(JsonbValue);
        char       *base_addr = (char *) (children + count);
        uint32      offset = 0;
        int         i;
 
        for (i = 0; i < count; i++)
        {
            fillJsonbValue(container, i, base_addr, offset, result);
 
            if (key->type == result->type)
            {
                if (equalsJsonbScalarValue(key, result))
                    return result;
            }
 
            JBE_ADVANCE_OFFSET(offset, children[i]);
        }
 
        pfree(result);
    }
    else if ((flags & JB_FOBJECT) && JsonContainerIsObject(container))
    {
        /* Object key passed by caller must be a string */
        Assert(key->type == jbvString);
 
        return getKeyJsonValueFromContainer(container, key->val.string.val,
                                            key->val.string.len, NULL);
    }
 
    /* Not found */
    return NULL;
}

References Assert(), JsonbContainer::children, equalsJsonbScalarValue(), fillJsonbValue(), getKeyJsonValueFromContainer(), i, JB_FARRAY, JB_FOBJECT, JBE_ADVANCE_OFFSET, jbvString, JsonContainerIsArray, JsonContainerIsObject, JsonContainerSize, sort-test::key, palloc_object, pfree(), and JsonbValue::type.

Referenced by executeItemOptUnwrapTarget(), getJsonPathVariableFromJsonb(), jsonb_exists(), jsonb_exists_all(), jsonb_exists_any(), and JsonbDeepContains().

freeAndGetParent()

static JsonbIterator * freeAndGetParent ( JsonbIterator *  it )

static

Definition at line 1168 of file jsonb_util.c.

{
    JsonbIterator *v = it->parent;
 
    pfree(it);
    return v;
}

References JsonbIterator::parent, and pfree().

Referenced by JsonbIteratorNext().

getIthJsonbValueFromContainer()

JsonbValue * getIthJsonbValueFromContainer	(	JsonbContainer *	container,
		uint32	i
	)

Definition at line 472 of file jsonb_util.c.

{
    JsonbValue *result;
    char       *base_addr;
    uint32      nelements;
 
    if (!JsonContainerIsArray(container))
        elog(ERROR, "not a jsonb array");
 
    nelements = JsonContainerSize(container);
    base_addr = (char *) &container->children[nelements];
 
    if (i >= nelements)
        return NULL;
 
    result = palloc_object(JsonbValue);
 
    fillJsonbValue(container, i, base_addr,
                   getJsonbOffset(container, i),
                   result);
 
    return result;
}

References JsonbContainer::children, elog, ERROR, fillJsonbValue(), getJsonbOffset(), i, if(), JsonContainerIsArray, JsonContainerSize, and palloc_object.

Referenced by executeItemOptUnwrapTarget(), jsonb_array_element(), jsonb_array_element_text(), and jsonb_get_element().

getJsonbLength()

uint32 getJsonbLength	(	const JsonbContainer *	jc,
		int	index
	)

Definition at line 162 of file jsonb_util.c.

{
    uint32      off;
    uint32      len;
 
    /*
     * If the length is stored directly in the JEntry, just return it.
     * Otherwise, get the begin offset of the entry, and subtract that from
     * the stored end+1 offset.
     */
    if (JBE_HAS_OFF(jc->children[index]))
    {
        off = getJsonbOffset(jc, index);
        len = JBE_OFFLENFLD(jc->children[index]) - off;
    }
    else
        len = JBE_OFFLENFLD(jc->children[index]);
 
    return len;
}

References JsonbContainer::children, getJsonbOffset(), JBE_HAS_OFF, JBE_OFFLENFLD, and len.

Referenced by fillJsonbValue(), and getKeyJsonValueFromContainer().

getJsonbOffset()

uint32 getJsonbOffset	(	const JsonbContainer *	jc,
		int	index
	)

Definition at line 137 of file jsonb_util.c.

{
    uint32      offset = 0;
    int         i;
 
    /*
     * Start offset of this entry is equal to the end offset of the previous
     * entry.  Walk backwards to the most recent entry stored as an end
     * offset, returning that offset plus any lengths in between.
     */
    for (i = index - 1; i >= 0; i--)
    {
        offset += JBE_OFFLENFLD(jc->children[i]);
        if (JBE_HAS_OFF(jc->children[i]))
            break;
    }
 
    return offset;
}

References JsonbContainer::children, i, JBE_HAS_OFF, and JBE_OFFLENFLD.

Referenced by getIthJsonbValueFromContainer(), getJsonbLength(), getKeyJsonValueFromContainer(), and JsonbIteratorNext().

getKeyJsonValueFromContainer()

JsonbValue * getKeyJsonValueFromContainer	(	JsonbContainer *	container,
		const char *	keyVal,
		int	keyLen,
		JsonbValue *	res
	)

Definition at line 402 of file jsonb_util.c.

{
    JEntry     *children = container->children;
    int         count = JsonContainerSize(container);
    char       *baseAddr;
    uint32      stopLow,
                stopHigh;
 
    Assert(JsonContainerIsObject(container));
 
    /* Quick out without a palloc cycle if object is empty */
    if (count <= 0)
        return NULL;
 
    /*
     * 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;
 
        stopMiddle = stopLow + (stopHigh - stopLow) / 2;
 
        candidateVal = baseAddr + getJsonbOffset(container, stopMiddle);
        candidateLen = getJsonbLength(container, stopMiddle);
 
        difference = lengthCompareJsonbString(candidateVal, candidateLen,
                                              keyVal, keyLen);
 
        if (difference == 0)
        {
            /* Found our key, return corresponding value */
            int         index = stopMiddle + count;
 
            if (!res)
                res = palloc_object(JsonbValue);
 
            fillJsonbValue(container, index, baseAddr,
                           getJsonbOffset(container, index),
                           res);
 
            return res;
        }
        else
        {
            if (difference < 0)
                stopLow = stopMiddle + 1;
            else
                stopHigh = stopMiddle;
        }
    }
 
    /* Not found */
    return NULL;
}

References Assert(), JsonbContainer::children, difference(), fillJsonbValue(), getJsonbLength(), getJsonbOffset(), JsonContainerIsObject, JsonContainerSize, lengthCompareJsonbString(), and palloc_object.

Referenced by findJsonbValueFromContainer(), JsObjectGetField(), jsonb_get_element(), jsonb_object_field(), jsonb_object_field_text(), and JsonbDeepContains().

iteratorFromContainer()

static JsonbIterator * iteratorFromContainer ( JsonbContainer *  container, JsonbIterator *  parent  )

static

Definition at line 1126 of file jsonb_util.c.

{
    JsonbIterator *it;
 
    it = palloc0_object(JsonbIterator);
    it->container = container;
    it->parent = parent;
    it->nElems = JsonContainerSize(container);
 
    /* Array starts just after header */
    it->children = container->children;
 
    switch (container->header & (JB_FARRAY | JB_FOBJECT))
    {
        case JB_FARRAY:
            it->dataProper =
                (char *) it->children + it->nElems * sizeof(JEntry);
            it->isScalar = JsonContainerIsScalar(container);
            /* This is either a "raw scalar", or an array */
            Assert(!it->isScalar || it->nElems == 1);
 
            it->state = JBI_ARRAY_START;
            break;
 
        case JB_FOBJECT:
            it->dataProper =
                (char *) it->children + it->nElems * sizeof(JEntry) * 2;
            it->state = JBI_OBJECT_START;
            break;
 
        default:
            elog(ERROR, "unknown type of jsonb container");
    }
 
    return it;
}

References Assert(), JsonbContainer::children, JsonbIterator::children, JsonbIterator::container, JsonbIterator::dataProper, elog, ERROR, JsonbContainer::header, JsonbIterator::isScalar, JB_FARRAY, JB_FOBJECT, JBI_ARRAY_START, JBI_OBJECT_START, JsonContainerIsScalar, JsonContainerSize, JsonbIterator::nElems, palloc0_object, JsonbIterator::parent, and JsonbIterator::state.

Referenced by JsonbIteratorInit(), and JsonbIteratorNext().

JsonbDeepContains()

bool JsonbDeepContains	(	JsonbIterator **	val,
		JsonbIterator **	mContained
	)

Definition at line 1189 of file jsonb_util.c.

{
    JsonbValue  vval,
                vcontained;
    JsonbIteratorToken rval,
                rcont;
 
    /*
     * Guard against stack overflow due to overly complex Jsonb.
     *
     * Functions called here independently take this precaution, but that
     * might not be sufficient since this is also a recursive function.
     */
    check_stack_depth();
 
    rval = JsonbIteratorNext(val, &vval, false);
    rcont = JsonbIteratorNext(mContained, &vcontained, false);
 
    if (rval != rcont)
    {
        /*
         * The differing return values can immediately be taken as indicating
         * two differing container types at this nesting level, which is
         * sufficient reason to give up entirely (but it should be the case
         * that they're both some container type).
         */
        Assert(rval == WJB_BEGIN_OBJECT || rval == WJB_BEGIN_ARRAY);
        Assert(rcont == WJB_BEGIN_OBJECT || rcont == WJB_BEGIN_ARRAY);
        return false;
    }
    else if (rcont == WJB_BEGIN_OBJECT)
    {
        Assert(vval.type == jbvObject);
        Assert(vcontained.type == jbvObject);
 
        /*
         * If the lhs has fewer pairs than the rhs, it can't possibly contain
         * the rhs.  (This conclusion is safe only because we de-duplicate
         * keys in all Jsonb objects; thus there can be no corresponding
         * optimization in the array case.)  The case probably won't arise
         * often, but since it's such a cheap check we may as well make it.
         */
        if (vval.val.object.nPairs < vcontained.val.object.nPairs)
            return false;
 
        /* Work through rhs "is it contained within?" object */
        for (;;)
        {
            JsonbValue *lhsVal; /* lhsVal is from pair in lhs object */
            JsonbValue  lhsValBuf;
 
            rcont = JsonbIteratorNext(mContained, &vcontained, false);
 
            /*
             * When we get through caller's rhs "is it contained within?"
             * object without failing to find one of its values, it's
             * contained.
             */
            if (rcont == WJB_END_OBJECT)
                return true;
 
            Assert(rcont == WJB_KEY);
            Assert(vcontained.type == jbvString);
 
            /* First, find value by key... */
            lhsVal =
                getKeyJsonValueFromContainer((*val)->container,
                                             vcontained.val.string.val,
                                             vcontained.val.string.len,
                                             &lhsValBuf);
            if (!lhsVal)
                return false;
 
            /*
             * ...at this stage it is apparent that there is at least a key
             * match for this rhs pair.
             */
            rcont = JsonbIteratorNext(mContained, &vcontained, true);
 
            Assert(rcont == WJB_VALUE);
 
            /*
             * Compare rhs pair's value with lhs pair's value just found using
             * key
             */
            if (lhsVal->type != vcontained.type)
            {
                return false;
            }
            else if (IsAJsonbScalar(lhsVal))
            {
                if (!equalsJsonbScalarValue(lhsVal, &vcontained))
                    return false;
            }
            else
            {
                /* Nested container value (object or array) */
                JsonbIterator *nestval,
                           *nestContained;
 
                Assert(lhsVal->type == jbvBinary);
                Assert(vcontained.type == jbvBinary);
 
                nestval = JsonbIteratorInit(lhsVal->val.binary.data);
                nestContained = JsonbIteratorInit(vcontained.val.binary.data);
 
                /*
                 * Match "value" side of rhs datum object's pair recursively.
                 * It's a nested structure.
                 *
                 * Note that nesting still has to "match up" at the right
                 * nesting sub-levels.  However, there need only be zero or
                 * more matching pairs (or elements) at each nesting level
                 * (provided the *rhs* pairs/elements *all* match on each
                 * level), which enables searching nested structures for a
                 * single String or other primitive type sub-datum quite
                 * effectively (provided the user constructed the rhs nested
                 * structure such that we "know where to look").
                 *
                 * In other words, the mapping of container nodes in the rhs
                 * "vcontained" Jsonb to internal nodes on the lhs is
                 * injective, and parent-child edges on the rhs must be mapped
                 * to parent-child edges on the lhs to satisfy the condition
                 * of containment (plus of course the mapped nodes must be
                 * equal).
                 */
                if (!JsonbDeepContains(&nestval, &nestContained))
                    return false;
            }
        }
    }
    else if (rcont == WJB_BEGIN_ARRAY)
    {
        JsonbValue *lhsConts = NULL;
        uint32      nLhsElems = vval.val.array.nElems;
 
        Assert(vval.type == jbvArray);
        Assert(vcontained.type == jbvArray);
 
        /*
         * Handle distinction between "raw scalar" pseudo arrays, and real
         * arrays.
         *
         * A raw scalar may contain another raw scalar, and an array may
         * contain a raw scalar, but a raw scalar may not contain an array. We
         * don't do something like this for the object case, since objects can
         * only contain pairs, never raw scalars (a pair is represented by an
         * rhs object argument with a single contained pair).
         */
        if (vval.val.array.rawScalar && !vcontained.val.array.rawScalar)
            return false;
 
        /* Work through rhs "is it contained within?" array */
        for (;;)
        {
            rcont = JsonbIteratorNext(mContained, &vcontained, true);
 
            /*
             * When we get through caller's rhs "is it contained within?"
             * array without failing to find one of its values, it's
             * contained.
             */
            if (rcont == WJB_END_ARRAY)
                return true;
 
            Assert(rcont == WJB_ELEM);
 
            if (IsAJsonbScalar(&vcontained))
            {
                if (!findJsonbValueFromContainer((*val)->container,
                                                 JB_FARRAY,
                                                 &vcontained))
                    return false;
            }
            else
            {
                uint32      i;
 
                /*
                 * If this is first container found in rhs array (at this
                 * depth), initialize temp lhs array of containers
                 */
                if (lhsConts == NULL)
                {
                    uint32      j = 0;
 
                    /* Make room for all possible values */
                    lhsConts = palloc_array(JsonbValue, nLhsElems);
 
                    for (i = 0; i < nLhsElems; i++)
                    {
                        /* Store all lhs elements in temp array */
                        rcont = JsonbIteratorNext(val, &vval, true);
                        Assert(rcont == WJB_ELEM);
 
                        if (vval.type == jbvBinary)
                            lhsConts[j++] = vval;
                    }
 
                    /* No container elements in temp array, so give up now */
                    if (j == 0)
                        return false;
 
                    /* We may have only partially filled array */
                    nLhsElems = j;
                }
 
                /* XXX: Nested array containment is O(N^2) */
                for (i = 0; i < nLhsElems; i++)
                {
                    /* Nested container value (object or array) */
                    JsonbIterator *nestval,
                               *nestContained;
                    bool        contains;
 
                    nestval = JsonbIteratorInit(lhsConts[i].val.binary.data);
                    nestContained = JsonbIteratorInit(vcontained.val.binary.data);
 
                    contains = JsonbDeepContains(&nestval, &nestContained);
 
                    if (nestval)
                        pfree(nestval);
                    if (nestContained)
                        pfree(nestContained);
                    if (contains)
                        break;
                }
 
                /*
                 * Report rhs container value is not contained if couldn't
                 * match rhs container to *some* lhs cont
                 */
                if (i == nLhsElems)
                    return false;
            }
        }
    }
    else
    {
        elog(ERROR, "invalid jsonb container type");
    }
 
    elog(ERROR, "unexpectedly fell off end of jsonb container");
    return false;
}

References Assert(), check_stack_depth(), elog, equalsJsonbScalarValue(), ERROR, findJsonbValueFromContainer(), getKeyJsonValueFromContainer(), i, IsAJsonbScalar, j, JB_FARRAY, jbvArray, jbvBinary, jbvObject, jbvString, JsonbDeepContains(), JsonbIteratorInit(), JsonbIteratorNext(), palloc_array, pfree(), JsonbValue::type, JsonbValue::val, val, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

Referenced by jsonb_contained(), jsonb_contains(), and JsonbDeepContains().

JsonbHashScalarValue()

void JsonbHashScalarValue	(	const JsonbValue *	scalarVal,
		uint32 *	hash
	)

Definition at line 1443 of file jsonb_util.c.

{
    uint32      tmp;
 
    /* Compute hash value for scalarVal */
    switch (scalarVal->type)
    {
        case jbvNull:
            tmp = 0x01;
            break;
        case jbvString:
            tmp = DatumGetUInt32(hash_any((const unsigned char *) scalarVal->val.string.val,
                                          scalarVal->val.string.len));
            break;
        case jbvNumeric:
            /* Must hash equal numerics to equal hash codes */
            tmp = DatumGetUInt32(DirectFunctionCall1(hash_numeric,
                                                     NumericGetDatum(scalarVal->val.numeric)));
            break;
        case jbvBool:
            tmp = scalarVal->val.boolean ? 0x02 : 0x04;
 
            break;
        default:
            elog(ERROR, "invalid jsonb scalar type");
            tmp = 0;            /* keep compiler quiet */
            break;
    }
 
    /*
     * Combine hash values of successive keys, values and elements by rotating
     * the previous value left 1 bit, then XOR'ing in the new
     * key/value/element's hash value.
     */
    *hash = pg_rotate_left32(*hash, 1);
    *hash ^= tmp;
}

References DatumGetUInt32(), DirectFunctionCall1, elog, ERROR, hash(), hash_any(), hash_numeric(), jbvBool, jbvNull, jbvNumeric, jbvString, NumericGetDatum(), pg_rotate_left32(), JsonbValue::type, and JsonbValue::val.

Referenced by gin_extract_jsonb_path(), jsonb_hash(), jsonb_path_ops__add_path_item(), and jsonb_path_ops__extract_nodes().

JsonbHashScalarValueExtended()

void JsonbHashScalarValueExtended	(	const JsonbValue *	scalarVal,
		uint64 *	hash,
		uint64	seed
	)

Definition at line 1486 of file jsonb_util.c.

{
    uint64      tmp;
 
    switch (scalarVal->type)
    {
        case jbvNull:
            tmp = seed + 0x01;
            break;
        case jbvString:
            tmp = DatumGetUInt64(hash_any_extended((const unsigned char *) scalarVal->val.string.val,
                                                   scalarVal->val.string.len,
                                                   seed));
            break;
        case jbvNumeric:
            tmp = DatumGetUInt64(DirectFunctionCall2(hash_numeric_extended,
                                                     NumericGetDatum(scalarVal->val.numeric),
                                                     UInt64GetDatum(seed)));
            break;
        case jbvBool:
            if (seed)
                tmp = DatumGetUInt64(DirectFunctionCall2(hashcharextended,
                                                         BoolGetDatum(scalarVal->val.boolean),
                                                         UInt64GetDatum(seed)));
            else
                tmp = scalarVal->val.boolean ? 0x02 : 0x04;
 
            break;
        default:
            elog(ERROR, "invalid jsonb scalar type");
            break;
    }
 
    *hash = ROTATE_HIGH_AND_LOW_32BITS(*hash);
    *hash ^= tmp;
}

References BoolGetDatum(), DatumGetUInt64(), DirectFunctionCall2, elog, ERROR, hash(), hash_any_extended(), hash_numeric_extended(), hashcharextended(), jbvBool, jbvNull, jbvNumeric, jbvString, NumericGetDatum(), ROTATE_HIGH_AND_LOW_32BITS, JsonbValue::type, UInt64GetDatum(), and JsonbValue::val.

Referenced by jsonb_hash_extended().

JsonbIteratorInit()

JsonbIterator * JsonbIteratorInit

(

JsonbContainer *

container

)

Definition at line 935 of file jsonb_util.c.

{
    return iteratorFromContainer(container, NULL);
}

References iteratorFromContainer().

Referenced by compareJsonbContainers(), datum_to_jsonb_internal(), each_worker_jsonb(), elements_worker_jsonb(), executeAnyItem(), executeKeyValueMethod(), gin_extract_jsonb(), gin_extract_jsonb_path(), iterate_jsonb_values(), jsonb_concat(), jsonb_contained(), jsonb_contains(), jsonb_delete(), jsonb_delete_array(), jsonb_delete_idx(), jsonb_delete_path(), jsonb_hash(), jsonb_hash_extended(), jsonb_insert(), jsonb_object_keys(), jsonb_set(), jsonb_set_element(), jsonb_strip_nulls(), Jsonb_to_SV(), JsonbDeepContains(), JsonbExtractScalar(), JsonbToCStringWorker(), parse_jsonb_index_flags(), PLyObject_FromJsonbContainer(), populate_array_dim_jsonb(), populate_recordset_worker(), pushJsonbValue(), and transform_jsonb_string_values().

JsonbIteratorNext()

JsonbIteratorToken JsonbIteratorNext	(	JsonbIterator **	it,
		JsonbValue *	val,
		bool	skipNested
	)

Definition at line 973 of file jsonb_util.c.

{
    if (*it == NULL)
    {
        val->type = jbvNull;
        return WJB_DONE;
    }
 
    /*
     * When stepping into a nested container, we jump back here to start
     * processing the child. We will not recurse further in one call, because
     * processing the child will always begin in JBI_ARRAY_START or
     * JBI_OBJECT_START state.
     */
recurse:
    switch ((*it)->state)
    {
        case JBI_ARRAY_START:
            /* Set v to array on first array call */
            val->type = jbvArray;
            val->val.array.nElems = (*it)->nElems;
 
            /*
             * v->val.array.elems is not actually set, because we aren't doing
             * a full conversion
             */
            val->val.array.rawScalar = (*it)->isScalar;
            (*it)->curIndex = 0;
            (*it)->curDataOffset = 0;
            (*it)->curValueOffset = 0;  /* not actually used */
            /* Set state for next call */
            (*it)->state = JBI_ARRAY_ELEM;
            return WJB_BEGIN_ARRAY;
 
        case JBI_ARRAY_ELEM:
            if ((*it)->curIndex >= (*it)->nElems)
            {
                /*
                 * All elements within array already processed.  Report this
                 * to caller, and give it back original parent iterator (which
                 * independently tracks iteration progress at its level of
                 * nesting).
                 */
                *it = freeAndGetParent(*it);
                val->type = jbvNull;
                return WJB_END_ARRAY;
            }
 
            fillJsonbValue((*it)->container, (*it)->curIndex,
                           (*it)->dataProper, (*it)->curDataOffset,
                           val);
 
            JBE_ADVANCE_OFFSET((*it)->curDataOffset,
                               (*it)->children[(*it)->curIndex]);
            (*it)->curIndex++;
 
            if (!IsAJsonbScalar(val) && !skipNested)
            {
                /* Recurse into container. */
                *it = iteratorFromContainer(val->val.binary.data, *it);
                goto recurse;
            }
            else
            {
                /*
                 * Scalar item in array, or a container and caller didn't want
                 * us to recurse into it.
                 */
                return WJB_ELEM;
            }
 
        case JBI_OBJECT_START:
            /* Set v to object on first object call */
            val->type = jbvObject;
            val->val.object.nPairs = (*it)->nElems;
 
            /*
             * v->val.object.pairs is not actually set, because we aren't
             * doing a full conversion
             */
            (*it)->curIndex = 0;
            (*it)->curDataOffset = 0;
            (*it)->curValueOffset = getJsonbOffset((*it)->container,
                                                   (*it)->nElems);
            /* Set state for next call */
            (*it)->state = JBI_OBJECT_KEY;
            return WJB_BEGIN_OBJECT;
 
        case JBI_OBJECT_KEY:
            if ((*it)->curIndex >= (*it)->nElems)
            {
                /*
                 * All pairs within object already processed.  Report this to
                 * caller, and give it back original containing iterator
                 * (which independently tracks iteration progress at its level
                 * of nesting).
                 */
                *it = freeAndGetParent(*it);
                val->type = jbvNull;
                return WJB_END_OBJECT;
            }
            else
            {
                /* Return key of a key/value pair.  */
                fillJsonbValue((*it)->container, (*it)->curIndex,
                               (*it)->dataProper, (*it)->curDataOffset,
                               val);
                if (val->type != jbvString)
                    elog(ERROR, "unexpected jsonb type as object key");
 
                /* Set state for next call */
                (*it)->state = JBI_OBJECT_VALUE;
                return WJB_KEY;
            }
 
        case JBI_OBJECT_VALUE:
            /* Set state for next call */
            (*it)->state = JBI_OBJECT_KEY;
 
            fillJsonbValue((*it)->container, (*it)->curIndex + (*it)->nElems,
                           (*it)->dataProper, (*it)->curValueOffset,
                           val);
 
            JBE_ADVANCE_OFFSET((*it)->curDataOffset,
                               (*it)->children[(*it)->curIndex]);
            JBE_ADVANCE_OFFSET((*it)->curValueOffset,
                               (*it)->children[(*it)->curIndex + (*it)->nElems]);
            (*it)->curIndex++;
 
            /*
             * Value may be a container, in which case we recurse with new,
             * child iterator (unless the caller asked not to, by passing
             * skipNested).
             */
            if (!IsAJsonbScalar(val) && !skipNested)
            {
                *it = iteratorFromContainer(val->val.binary.data, *it);
                goto recurse;
            }
            else
                return WJB_VALUE;
    }
 
    elog(ERROR, "invalid jsonb iterator state");
    /* satisfy compilers that don't know that elog(ERROR) doesn't return */
    val->type = jbvNull;
    return WJB_DONE;
}

References elog, ERROR, fillJsonbValue(), freeAndGetParent(), getJsonbOffset(), IsAJsonbScalar, iteratorFromContainer(), JBE_ADVANCE_OFFSET, JBI_ARRAY_ELEM, JBI_ARRAY_START, JBI_OBJECT_KEY, JBI_OBJECT_START, JBI_OBJECT_VALUE, jbvArray, jbvNull, jbvObject, jbvString, val, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_DONE, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

Referenced by compareJsonbContainers(), datum_to_jsonb_internal(), each_worker_jsonb(), elements_worker_jsonb(), executeAnyItem(), executeKeyValueMethod(), gin_extract_jsonb(), gin_extract_jsonb_path(), iterate_jsonb_values(), IteratorConcat(), jsonb_delete(), jsonb_delete_array(), jsonb_delete_idx(), jsonb_hash(), jsonb_hash_extended(), jsonb_object_keys(), jsonb_strip_nulls(), Jsonb_to_SV(), JsonbDeepContains(), JsonbExtractScalar(), JsonbToCStringWorker(), parse_jsonb_index_flags(), PLyObject_FromJsonbContainer(), populate_array_dim_jsonb(), populate_recordset_worker(), pushJsonbValue(), setPath(), setPathArray(), setPathObject(), and transform_jsonb_string_values().

JsonbToJsonbValue()

void JsonbToJsonbValue	(	Jsonb *	jsonb,
		JsonbValue *	val
	)

Definition at line 76 of file jsonb_util.c.

{
    val->type = jbvBinary;
    val->val.binary.data = &jsonb->root;
    val->val.binary.len = VARSIZE(jsonb) - VARHDRSZ;
}

References jbvBinary, Jsonb::root, val, VARHDRSZ, and VARSIZE().

Referenced by jsonb_insert(), jsonb_set(), and jsonb_subscript_assign().

JsonbValueToJsonb()

Jsonb * JsonbValueToJsonb

(

JsonbValue *

val

)

Definition at line 96 of file jsonb_util.c.

{
    Jsonb      *out;
 
    if (IsAJsonbScalar(val))
    {
        /* Scalar value, so wrap it in an array */
        JsonbInState pstate = {0};
        JsonbValue  scalarArray;
 
        scalarArray.type = jbvArray;
        scalarArray.val.array.rawScalar = true;
        scalarArray.val.array.nElems = 1;
 
        pushJsonbValue(&pstate, WJB_BEGIN_ARRAY, &scalarArray);
        pushJsonbValue(&pstate, WJB_ELEM, val);
        pushJsonbValue(&pstate, WJB_END_ARRAY, NULL);
 
        out = convertToJsonb(pstate.result);
    }
    else if (val->type == jbvObject || val->type == jbvArray)
    {
        out = convertToJsonb(val);
    }
    else
    {
        Assert(val->type == jbvBinary);
        out = palloc(VARHDRSZ + val->val.binary.len);
        SET_VARSIZE(out, VARHDRSZ + val->val.binary.len);
        memcpy(VARDATA(out), val->val.binary.data, val->val.binary.len);
    }
 
    return out;
}

References Assert(), convertToJsonb(), IsAJsonbScalar, jbvArray, jbvBinary, jbvObject, palloc(), pushJsonbValue(), JsonbInState::result, SET_VARSIZE(), JsonbValue::type, JsonbValue::val, val, VARDATA(), VARHDRSZ, WJB_BEGIN_ARRAY, WJB_ELEM, and WJB_END_ARRAY.

Referenced by datum_to_jsonb(), each_worker_jsonb(), elements_worker_jsonb(), ExecEvalJsonExprPath(), ExecGetJsonValueItemString(), executeKeyValueMethod(), hstore_to_jsonb(), hstore_to_jsonb_loose(), jsonb_agg_finalfn(), jsonb_array_element(), jsonb_build_array_noargs(), jsonb_build_array_worker(), jsonb_build_object_noargs(), jsonb_build_object_worker(), jsonb_concat(), jsonb_delete(), jsonb_delete_array(), jsonb_delete_idx(), jsonb_delete_path(), jsonb_from_cstring(), jsonb_get_element(), jsonb_insert(), jsonb_object(), jsonb_object_agg_finalfn(), jsonb_object_field(), jsonb_object_two_arg(), jsonb_path_query_array_internal(), jsonb_path_query_first_internal(), jsonb_path_query_internal(), jsonb_set(), jsonb_set_element(), jsonb_strip_nulls(), jsonb_subscript_assign(), JsonPathQuery(), JsonTablePlanScanNextRow(), plperl_to_jsonb(), plpython_to_jsonb(), populate_scalar(), and transform_jsonb_string_values().

lengthCompareJsonbPair()

static int lengthCompareJsonbPair ( const void *  a, const void *  b, void *  binequal  )

static

Definition at line 2046 of file jsonb_util.c.

{
    const JsonbPair *pa = (const JsonbPair *) a;
    const JsonbPair *pb = (const JsonbPair *) b;
    int         res;
 
    res = lengthCompareJsonbStringValue(&pa->key, &pb->key);
    if (res == 0 && binequal)
        *((bool *) binequal) = true;
 
    /*
     * Guarantee keeping order of equal pair.  Unique algorithm will prefer
     * first element as value.
     */
    if (res == 0)
        res = (pa->order > pb->order) ? -1 : 1;
 
    return res;
}

References a, b, JsonbPair::key, lengthCompareJsonbStringValue(), and JsonbPair::order.

Referenced by uniqueifyJsonbObject().

lengthCompareJsonbString()

static int lengthCompareJsonbString ( const char *  val1, int  len1, const char *  val2, int  len2  )

static

Definition at line 2026 of file jsonb_util.c.

{
    if (len1 == len2)
        return memcmp(val1, val2, len1);
    else
        return len1 > len2 ? 1 : -1;
}

Referenced by getKeyJsonValueFromContainer(), and lengthCompareJsonbStringValue().

lengthCompareJsonbStringValue()

static int lengthCompareJsonbStringValue ( const void *  a, const void *  b  )

static

Definition at line 2007 of file jsonb_util.c.

{
    const JsonbValue *va = (const JsonbValue *) a;
    const JsonbValue *vb = (const JsonbValue *) b;
 
    Assert(va->type == jbvString);
    Assert(vb->type == jbvString);
 
    return lengthCompareJsonbString(va->val.string.val, va->val.string.len,
                                    vb->val.string.val, vb->val.string.len);
}

References a, Assert(), b, jbvString, lengthCompareJsonbString(), JsonbValue::type, and JsonbValue::val.

Referenced by equalsJsonbScalarValue(), lengthCompareJsonbPair(), and uniqueifyJsonbObject().

padBufferToInt()

static short padBufferToInt ( StringInfo  buffer )

static

Definition at line 1654 of file jsonb_util.c.

{
    int         padlen,
                p,
                offset;
 
    padlen = INTALIGN(buffer->len) - buffer->len;
 
    offset = reserveFromBuffer(buffer, padlen);
 
    /* padlen must be small, so this is probably faster than a memset */
    for (p = 0; p < padlen; p++)
        buffer->data[offset + p] = '\0';
 
    return padlen;
}

References StringInfoData::data, INTALIGN, StringInfoData::len, and reserveFromBuffer().

Referenced by convertJsonbArray(), convertJsonbObject(), and convertJsonbScalar().

pushJsonbValue()

void pushJsonbValue	(	JsonbInState *	pstate,
		JsonbIteratorToken	seq,
		JsonbValue *	jbval
	)

Definition at line 583 of file jsonb_util.c.

{
    JsonbIterator *it;
    JsonbValue  v;
    JsonbIteratorToken tok;
    int         i;
 
    /*
     * pushJsonbValueScalar handles all cases not involving pushing a
     * container object as an ELEM or VALUE.
     */
    if (!jbval || IsAJsonbScalar(jbval) ||
        (seq != WJB_ELEM && seq != WJB_VALUE))
    {
        pushJsonbValueScalar(pstate, seq, jbval);
        return;
    }
 
    /* If an object or array is pushed, recursively push its contents */
    if (jbval->type == jbvObject)
    {
        pushJsonbValue(pstate, WJB_BEGIN_OBJECT, NULL);
        for (i = 0; i < jbval->val.object.nPairs; i++)
        {
            pushJsonbValue(pstate, WJB_KEY, &jbval->val.object.pairs[i].key);
            pushJsonbValue(pstate, WJB_VALUE, &jbval->val.object.pairs[i].value);
        }
        pushJsonbValue(pstate, WJB_END_OBJECT, NULL);
        return;
    }
 
    if (jbval->type == jbvArray)
    {
        pushJsonbValue(pstate, WJB_BEGIN_ARRAY, NULL);
        for (i = 0; i < jbval->val.array.nElems; i++)
        {
            pushJsonbValue(pstate, WJB_ELEM, &jbval->val.array.elems[i]);
        }
        pushJsonbValue(pstate, WJB_END_ARRAY, NULL);
        return;
    }
 
    /* Else it must be a jbvBinary value; push its contents */
    Assert(jbval->type == jbvBinary);
 
    it = JsonbIteratorInit(jbval->val.binary.data);
 
    /* ... with a special case for pushing a raw scalar */
    if ((jbval->val.binary.data->header & JB_FSCALAR) &&
        pstate->parseState != NULL)
    {
        tok = JsonbIteratorNext(&it, &v, true);
        Assert(tok == WJB_BEGIN_ARRAY);
        Assert(v.type == jbvArray && v.val.array.rawScalar);
 
        tok = JsonbIteratorNext(&it, &v, true);
        Assert(tok == WJB_ELEM);
 
        pushJsonbValueScalar(pstate, seq, &v);
 
        tok = JsonbIteratorNext(&it, &v, true);
        Assert(tok == WJB_END_ARRAY);
        Assert(it == NULL);
 
        return;
    }
 
    while ((tok = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
        pushJsonbValueScalar(pstate, tok,
                             tok < WJB_BEGIN_ARRAY ||
                             (tok == WJB_BEGIN_ARRAY &&
                              v.val.array.rawScalar) ? &v : NULL);
}

References Assert(), i, IsAJsonbScalar, JB_FSCALAR, jbvArray, jbvBinary, jbvObject, JsonbIteratorInit(), JsonbIteratorNext(), JsonbInState::parseState, pushJsonbValue(), pushJsonbValueScalar(), JsonbValue::type, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_DONE, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

Referenced by array_dim_to_jsonb(), array_to_jsonb_internal(), AV_to_JsonbValue(), composite_to_jsonb(), datum_to_jsonb_internal(), executeKeyValueMethod(), hstore_to_jsonb(), hstore_to_jsonb_loose(), HV_to_JsonbValue(), IteratorConcat(), jsonb_agg_finalfn(), jsonb_agg_transfn_worker(), jsonb_build_array_noargs(), jsonb_build_array_worker(), jsonb_build_object_noargs(), jsonb_build_object_worker(), jsonb_delete(), jsonb_delete_array(), jsonb_delete_idx(), jsonb_in_array_end(), jsonb_in_array_start(), jsonb_in_object_end(), jsonb_in_object_field_start(), jsonb_in_object_start(), jsonb_in_scalar(), jsonb_object(), jsonb_object_agg_finalfn(), jsonb_object_agg_transfn_worker(), jsonb_object_two_arg(), jsonb_strip_nulls(), JsonbValueToJsonb(), PLyMapping_ToJsonbValue(), PLyObject_ToJsonbValue(), PLySequence_ToJsonbValue(), push_null_elements(), push_path(), pushJsonbValue(), setPath(), setPathArray(), setPathObject(), SV_to_JsonbValue(), transform_jsonb_string_values(), and wrapItemsInArray().

pushJsonbValueScalar()

static void pushJsonbValueScalar ( JsonbInState *  pstate, JsonbIteratorToken  seq, JsonbValue *  scalarVal  )

static

Definition at line 663 of file jsonb_util.c.

{
    JsonbParseState *ppstate;
    JsonbValue *val;
    MemoryContext outcontext;
 
    switch (seq)
    {
        case WJB_BEGIN_ARRAY:
            Assert(!scalarVal || scalarVal->val.array.rawScalar);
            ppstate = pushState(pstate);
            val = &ppstate->contVal;
            val->type = jbvArray;
            val->val.array.nElems = 0;
            val->val.array.rawScalar = (scalarVal &&
                                        scalarVal->val.array.rawScalar);
            if (scalarVal && scalarVal->val.array.nElems > 0)
            {
                /* Assume that this array is still really a scalar */
                Assert(scalarVal->type == jbvArray);
                ppstate->size = scalarVal->val.array.nElems;
            }
            else
            {
                ppstate->size = 4;  /* initial guess at array size */
            }
            outcontext = pstate->outcontext ? pstate->outcontext : CurrentMemoryContext;
            val->val.array.elems = MemoryContextAlloc(outcontext,
                                                      sizeof(JsonbValue) *
                                                      ppstate->size);
            break;
        case WJB_BEGIN_OBJECT:
            Assert(!scalarVal);
            ppstate = pushState(pstate);
            val = &ppstate->contVal;
            val->type = jbvObject;
            val->val.object.nPairs = 0;
            ppstate->size = 4;  /* initial guess at object size */
            outcontext = pstate->outcontext ? pstate->outcontext : CurrentMemoryContext;
            val->val.object.pairs = MemoryContextAlloc(outcontext,
                                                       sizeof(JsonbPair) *
                                                       ppstate->size);
            break;
        case WJB_KEY:
            Assert(scalarVal->type == jbvString);
            appendKey(pstate, scalarVal, true);
            break;
        case WJB_VALUE:
            Assert(IsAJsonbScalar(scalarVal));
            appendValue(pstate, scalarVal, true);
            break;
        case WJB_ELEM:
            Assert(IsAJsonbScalar(scalarVal));
            appendElement(pstate, scalarVal, true);
            break;
        case WJB_END_OBJECT:
            ppstate = pstate->parseState;
            uniqueifyJsonbObject(&ppstate->contVal,
                                 ppstate->unique_keys,
                                 ppstate->skip_nulls);
            /* fall through! */
        case WJB_END_ARRAY:
            /* Steps here common to WJB_END_OBJECT case */
            Assert(!scalarVal);
            ppstate = pstate->parseState;
            val = &ppstate->contVal;
 
            /*
             * Pop stack and push current array/object as value in parent
             * array/object, or return it as the final result.  We don't need
             * to re-copy any scalars that are in the data structure.
             */
            pstate->parseState = ppstate = ppstate->next;
            if (ppstate)
            {
                switch (ppstate->contVal.type)
                {
                    case jbvArray:
                        appendElement(pstate, val, false);
                        break;
                    case jbvObject:
                        appendValue(pstate, val, false);
                        break;
                    default:
                        elog(ERROR, "invalid jsonb container type");
                }
            }
            else
                pstate->result = val;
            break;
        default:
            elog(ERROR, "unrecognized jsonb sequential processing token");
    }
}

References appendElement(), appendKey(), appendValue(), Assert(), JsonbParseState::contVal, CurrentMemoryContext, elog, ERROR, IsAJsonbScalar, jbvArray, jbvObject, jbvString, MemoryContextAlloc(), JsonbParseState::next, JsonbInState::outcontext, JsonbInState::parseState, pushState(), JsonbInState::result, JsonbParseState::size, JsonbParseState::skip_nulls, JsonbValue::type, JsonbParseState::unique_keys, uniqueifyJsonbObject(), JsonbValue::val, val, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

Referenced by pushJsonbValue().

pushState()

static JsonbParseState * pushState ( JsonbInState *  pstate )

static

Definition at line 766 of file jsonb_util.c.

{
    MemoryContext outcontext = pstate->outcontext ? pstate->outcontext : CurrentMemoryContext;
    JsonbParseState *ns = MemoryContextAlloc(outcontext,
                                             sizeof(JsonbParseState));
 
    ns->next = pstate->parseState;
    /* This module never changes these fields, but callers can: */
    ns->unique_keys = false;
    ns->skip_nulls = false;
 
    pstate->parseState = ns;
    return ns;
}

References CurrentMemoryContext, MemoryContextAlloc(), JsonbParseState::next, JsonbInState::outcontext, JsonbInState::parseState, JsonbParseState::skip_nulls, and JsonbParseState::unique_keys.

Referenced by pushJsonbValueScalar().

reserveFromBuffer()

static int reserveFromBuffer ( StringInfo  buffer, int  len  )

static

Definition at line 1605 of file jsonb_util.c.

{
    int         offset;
 
    /* Make more room if needed */
    enlargeStringInfo(buffer, len);
 
    /* remember current offset */
    offset = buffer->len;
 
    /* reserve the space */
    buffer->len += len;
 
    /*
     * Keep a trailing null in place, even though it's not useful for us; it
     * seems best to preserve the invariants of StringInfos.
     */
    buffer->data[buffer->len] = '\0';
 
    return offset;
}

References StringInfoData::data, enlargeStringInfo(), StringInfoData::len, and len.

Referenced by appendToBuffer(), convertJsonbArray(), convertJsonbObject(), convertToJsonb(), and padBufferToInt().

uniqueifyJsonbObject()

static void uniqueifyJsonbObject ( JsonbValue *  object, bool  unique_keys, bool  skip_nulls  )

static

Definition at line 2070 of file jsonb_util.c.

{
    bool        hasNonUniq = false;
 
    Assert(object->type == jbvObject);
 
    if (object->val.object.nPairs > 1)
        qsort_arg(object->val.object.pairs, object->val.object.nPairs, sizeof(JsonbPair),
                  lengthCompareJsonbPair, &hasNonUniq);
 
    if (hasNonUniq && unique_keys)
        ereport(ERROR,
                errcode(ERRCODE_DUPLICATE_JSON_OBJECT_KEY_VALUE),
                errmsg("duplicate JSON object key value"));
 
    if (hasNonUniq || skip_nulls)
    {
        JsonbPair  *ptr,
                   *res;
 
        while (skip_nulls && object->val.object.nPairs > 0 &&
               object->val.object.pairs->value.type == jbvNull)
        {
            /* If skip_nulls is true, remove leading items with null */
            object->val.object.pairs++;
            object->val.object.nPairs--;
        }
 
        if (object->val.object.nPairs > 0)
        {
            ptr = object->val.object.pairs + 1;
            res = object->val.object.pairs;
 
            while (ptr - object->val.object.pairs < object->val.object.nPairs)
            {
                /* Avoid copying over duplicate or null */
                if (lengthCompareJsonbStringValue(ptr, res) != 0 &&
                    (!skip_nulls || ptr->value.type != jbvNull))
                {
                    res++;
                    if (ptr != res)
                        memcpy(res, ptr, sizeof(JsonbPair));
                }
                ptr++;
            }
 
            object->val.object.nPairs = res + 1 - object->val.object.pairs;
        }
    }
}

References Assert(), ereport, errcode(), errmsg(), ERROR, jbvNull, jbvObject, lengthCompareJsonbPair(), lengthCompareJsonbStringValue(), qsort_arg(), JsonbValue::type, JsonbValue::val, and JsonbPair::value.

Referenced by pushJsonbValueScalar().