#include "lib/stringinfo.h"
#include "utils/array.h"
#include "utils/numeric.h"

Include dependency graph for jsonb.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	JsonbContainer

struct	Jsonb

struct	JsonbValue

struct	JsonbPair

struct	JsonbInState

struct	JsonbParseState

struct	JsonbIterator

Macros
#define	JsonbContainsStrategyNumber 7

#define	JsonbExistsStrategyNumber 9

#define	JsonbExistsAnyStrategyNumber 10

#define	JsonbExistsAllStrategyNumber 11

#define	JsonbJsonpathExistsStrategyNumber 15

#define	JsonbJsonpathPredicateStrategyNumber 16

#define	JGINFLAG_KEY 0x01 /* key (or string array element) */

#define	JGINFLAG_NULL 0x02 /* null value */

#define	JGINFLAG_BOOL 0x03 /* boolean value */

#define	JGINFLAG_NUM 0x04 /* numeric value */

#define	JGINFLAG_STR 0x05 /* string value (if not an array element) */

#define	JGINFLAG_HASHED 0x10 /* OR'd into flag if value was hashed */

#define	JGIN_MAXLENGTH 125 /* max length of text part before hashing */

#define	JENTRY_OFFLENMASK 0x0FFFFFFF

#define	JENTRY_TYPEMASK 0x70000000

#define	JENTRY_HAS_OFF 0x80000000

#define	JENTRY_ISSTRING 0x00000000

#define	JENTRY_ISNUMERIC 0x10000000

#define	JENTRY_ISBOOL_FALSE 0x20000000

#define	JENTRY_ISBOOL_TRUE 0x30000000

#define	JENTRY_ISNULL 0x40000000

#define	JENTRY_ISCONTAINER 0x50000000 /* array or object */

#define	JBE_OFFLENFLD(je_) ((je_) & JENTRY_OFFLENMASK)

#define	JBE_HAS_OFF(je_) (((je_) & JENTRY_HAS_OFF) != 0)

#define	JBE_ISSTRING(je_) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISSTRING)

#define	JBE_ISNUMERIC(je_) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISNUMERIC)

#define	JBE_ISCONTAINER(je_) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISCONTAINER)

#define	JBE_ISNULL(je_) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISNULL)

#define	JBE_ISBOOL_TRUE(je_) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISBOOL_TRUE)

#define	JBE_ISBOOL_FALSE(je_) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISBOOL_FALSE)

#define	JBE_ISBOOL(je_) (JBE_ISBOOL_TRUE(je_) \|\| JBE_ISBOOL_FALSE(je_))

#define	JBE_ADVANCE_OFFSET(offset, je)

#define	JB_OFFSET_STRIDE 32

#define	JB_CMASK 0x0FFFFFFF /* mask for count field */

#define	JB_FSCALAR 0x10000000 /* flag bits */

#define	JB_FOBJECT 0x20000000

#define	JB_FARRAY 0x40000000

#define	JsonContainerSize(jc) ((jc)->header & JB_CMASK)

#define	JsonContainerIsScalar(jc) (((jc)->header & JB_FSCALAR) != 0)

#define	JsonContainerIsObject(jc) (((jc)->header & JB_FOBJECT) != 0)

#define	JsonContainerIsArray(jc) (((jc)->header & JB_FARRAY) != 0)

#define	JB_ROOT_COUNT(jbp_) ((uint32 ) VARDATA(jbp_) & JB_CMASK)

#define	JB_ROOT_IS_SCALAR(jbp_) (((uint32 ) VARDATA(jbp_) & JB_FSCALAR) != 0)

#define	JB_ROOT_IS_OBJECT(jbp_) (((uint32 ) VARDATA(jbp_) & JB_FOBJECT) != 0)

#define	JB_ROOT_IS_ARRAY(jbp_) (((uint32 ) VARDATA(jbp_) & JB_FARRAY) != 0)

#define	IsAJsonbScalar(jsonbval)

#define	PG_GETARG_JSONB_P(x) DatumGetJsonbP(PG_GETARG_DATUM(x))

#define	PG_GETARG_JSONB_P_COPY(x) DatumGetJsonbPCopy(PG_GETARG_DATUM(x))

#define	PG_RETURN_JSONB_P(x) PG_RETURN_POINTER(x)

Typedefs
typedef struct JsonbPair	JsonbPair

typedef struct JsonbValue	JsonbValue

typedef struct JsonbParseState	JsonbParseState

typedef uint32	JEntry

typedef struct JsonbContainer	JsonbContainer

typedef struct JsonbInState	JsonbInState

typedef struct JsonbIterator	JsonbIterator

Enumerations
enum	JsonbIteratorToken { WJB_DONE , WJB_KEY , WJB_VALUE , WJB_ELEM , WJB_BEGIN_ARRAY , WJB_END_ARRAY , WJB_BEGIN_OBJECT , WJB_END_OBJECT }

enum	jbvType { jbvNull = 0x0 , jbvString , jbvNumeric , jbvBool , jbvArray = 0x10 , jbvObject , jbvBinary , jbvDatetime = 0x20 }

enum	JsonbIterState { JBI_ARRAY_START , JBI_ARRAY_ELEM , JBI_OBJECT_START , JBI_OBJECT_KEY , JBI_OBJECT_VALUE }

Functions
static Jsonb *	DatumGetJsonbP (Datum d)

static Jsonb *	DatumGetJsonbPCopy (Datum d)

static Datum	JsonbPGetDatum (const Jsonb *p)

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)

void	JsonbToJsonbValue (Jsonb jsonb, JsonbValue val)

Jsonb *	JsonbValueToJsonb (JsonbValue *val)

bool	JsonbDeepContains (JsonbIterator val, JsonbIterator mContained)

void	JsonbHashScalarValue (const JsonbValue scalarVal, uint32 hash)

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

char *	JsonbToCString (StringInfo out, JsonbContainer *in, int estimated_len)

char *	JsonbToCStringIndent (StringInfo out, JsonbContainer *in, int estimated_len)

char *	JsonbUnquote (Jsonb *jb)

bool	JsonbExtractScalar (JsonbContainer jbc, JsonbValue res)

const char *	JsonbTypeName (JsonbValue *val)

Datum	jsonb_set_element (Jsonb jb, const Datum path, int path_len, JsonbValue *newval)

Datum	jsonb_get_element (Jsonb jb, const Datum path, int npath, bool *isnull, bool as_text)

bool	to_jsonb_is_immutable (Oid typoid)

Datum	jsonb_build_object_worker (int nargs, const Datum args, const bool nulls, const Oid *types, bool absent_on_null, bool unique_keys)

Datum	jsonb_build_array_worker (int nargs, const Datum args, const bool nulls, const Oid *types, bool absent_on_null)

Macro Definition Documentation

◆ IsAJsonbScalar

#define IsAJsonbScalar ( jsonbval )

Value:

                                      (((jsonbval)->type >= jbvNull && \
                                      (jsonbval)->type <= jbvBool) || \
                                      (jsonbval)->type == jbvDatetime)

Definition at line 299 of file jsonb.h.

◆ JB_CMASK

#define JB_CMASK 0x0FFFFFFF /* mask for count field */

Definition at line 202 of file jsonb.h.

◆ JB_FARRAY

#define JB_FARRAY 0x40000000

Definition at line 205 of file jsonb.h.

◆ JB_FOBJECT

#define JB_FOBJECT 0x20000000

Definition at line 204 of file jsonb.h.

◆ JB_FSCALAR

#define JB_FSCALAR 0x10000000 /* flag bits */

Definition at line 203 of file jsonb.h.

◆ JB_OFFSET_STRIDE

#define JB_OFFSET_STRIDE 32

Definition at line 180 of file jsonb.h.

◆ JB_ROOT_COUNT

#define JB_ROOT_COUNT ( jbp_ ) (*(uint32 *) VARDATA(jbp_) & JB_CMASK)

Definition at line 221 of file jsonb.h.

◆ JB_ROOT_IS_ARRAY

#define JB_ROOT_IS_ARRAY ( jbp_ ) ((*(uint32 *) VARDATA(jbp_) & JB_FARRAY) != 0)

Definition at line 224 of file jsonb.h.

◆ JB_ROOT_IS_OBJECT

#define JB_ROOT_IS_OBJECT ( jbp_ ) ((*(uint32 *) VARDATA(jbp_) & JB_FOBJECT) != 0)

Definition at line 223 of file jsonb.h.

◆ JB_ROOT_IS_SCALAR

#define JB_ROOT_IS_SCALAR ( jbp_ ) ((*(uint32 *) VARDATA(jbp_) & JB_FSCALAR) != 0)

Definition at line 222 of file jsonb.h.

◆ JBE_ADVANCE_OFFSET

#define JBE_ADVANCE_OFFSET	(	offset,
		je
	)

Value:

    do { \
        JEntry  je_ = (je); \
        if (JBE_HAS_OFF(je_)) \
            (offset) = JBE_OFFLENFLD(je_); \
        else \
            (offset) += JBE_OFFLENFLD(je_); \
    } while(0)

Definition at line 164 of file jsonb.h.

◆ JBE_HAS_OFF

#define JBE_HAS_OFF ( je_ ) (((je_) & JENTRY_HAS_OFF) != 0)

Definition at line 154 of file jsonb.h.

◆ JBE_ISBOOL

#define JBE_ISBOOL ( je_ ) (JBE_ISBOOL_TRUE(je_) || JBE_ISBOOL_FALSE(je_))

Definition at line 161 of file jsonb.h.

◆ JBE_ISBOOL_FALSE

#define JBE_ISBOOL_FALSE ( je_ ) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISBOOL_FALSE)

Definition at line 160 of file jsonb.h.

◆ JBE_ISBOOL_TRUE

#define JBE_ISBOOL_TRUE ( je_ ) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISBOOL_TRUE)

Definition at line 159 of file jsonb.h.

◆ JBE_ISCONTAINER

#define JBE_ISCONTAINER ( je_ ) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISCONTAINER)

Definition at line 157 of file jsonb.h.

◆ JBE_ISNULL

#define JBE_ISNULL ( je_ ) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISNULL)

Definition at line 158 of file jsonb.h.

◆ JBE_ISNUMERIC

#define JBE_ISNUMERIC ( je_ ) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISNUMERIC)

Definition at line 156 of file jsonb.h.

◆ JBE_ISSTRING

#define JBE_ISSTRING ( je_ ) (((je_) & JENTRY_TYPEMASK) == JENTRY_ISSTRING)

Definition at line 155 of file jsonb.h.

◆ JBE_OFFLENFLD

#define JBE_OFFLENFLD ( je_ ) ((je_) & JENTRY_OFFLENMASK)

Definition at line 153 of file jsonb.h.

◆ JENTRY_HAS_OFF

#define JENTRY_HAS_OFF 0x80000000

Definition at line 142 of file jsonb.h.

◆ JENTRY_ISBOOL_FALSE

#define JENTRY_ISBOOL_FALSE 0x20000000

Definition at line 147 of file jsonb.h.

◆ JENTRY_ISBOOL_TRUE

#define JENTRY_ISBOOL_TRUE 0x30000000

Definition at line 148 of file jsonb.h.

◆ JENTRY_ISCONTAINER

#define JENTRY_ISCONTAINER 0x50000000 /* array or object */

Definition at line 150 of file jsonb.h.

◆ JENTRY_ISNULL

#define JENTRY_ISNULL 0x40000000

Definition at line 149 of file jsonb.h.

◆ JENTRY_ISNUMERIC

#define JENTRY_ISNUMERIC 0x10000000

Definition at line 146 of file jsonb.h.

◆ JENTRY_ISSTRING

#define JENTRY_ISSTRING 0x00000000

Definition at line 145 of file jsonb.h.

◆ JENTRY_OFFLENMASK

#define JENTRY_OFFLENMASK 0x0FFFFFFF

Definition at line 140 of file jsonb.h.

◆ JENTRY_TYPEMASK

#define JENTRY_TYPEMASK 0x70000000

Definition at line 141 of file jsonb.h.

◆ JGIN_MAXLENGTH

#define JGIN_MAXLENGTH 125 /* max length of text part before hashing */

Definition at line 68 of file jsonb.h.

◆ JGINFLAG_BOOL

#define JGINFLAG_BOOL 0x03 /* boolean value */

Definition at line 64 of file jsonb.h.

◆ JGINFLAG_HASHED

#define JGINFLAG_HASHED 0x10 /* OR'd into flag if value was hashed */

Definition at line 67 of file jsonb.h.

◆ JGINFLAG_KEY

#define JGINFLAG_KEY 0x01 /* key (or string array element) */

Definition at line 62 of file jsonb.h.

◆ JGINFLAG_NULL

#define JGINFLAG_NULL 0x02 /* null value */

Definition at line 63 of file jsonb.h.

◆ JGINFLAG_NUM

#define JGINFLAG_NUM 0x04 /* numeric value */

Definition at line 65 of file jsonb.h.

◆ JGINFLAG_STR

#define JGINFLAG_STR 0x05 /* string value (if not an array element) */

Definition at line 66 of file jsonb.h.

◆ JsonbContainsStrategyNumber

#define JsonbContainsStrategyNumber 7

Definition at line 33 of file jsonb.h.

◆ JsonbExistsAllStrategyNumber

#define JsonbExistsAllStrategyNumber 11

Definition at line 36 of file jsonb.h.

◆ JsonbExistsAnyStrategyNumber

#define JsonbExistsAnyStrategyNumber 10

Definition at line 35 of file jsonb.h.

◆ JsonbExistsStrategyNumber

#define JsonbExistsStrategyNumber 9

Definition at line 34 of file jsonb.h.

◆ JsonbJsonpathExistsStrategyNumber

#define JsonbJsonpathExistsStrategyNumber 15

Definition at line 37 of file jsonb.h.

◆ JsonbJsonpathPredicateStrategyNumber

#define JsonbJsonpathPredicateStrategyNumber 16

Definition at line 38 of file jsonb.h.

◆ JsonContainerIsArray

#define JsonContainerIsArray ( jc ) (((jc)->header & JB_FARRAY) != 0)

Definition at line 211 of file jsonb.h.

◆ JsonContainerIsObject

#define JsonContainerIsObject ( jc ) (((jc)->header & JB_FOBJECT) != 0)

Definition at line 210 of file jsonb.h.

◆ JsonContainerIsScalar

#define JsonContainerIsScalar ( jc ) (((jc)->header & JB_FSCALAR) != 0)

Definition at line 209 of file jsonb.h.

◆ JsonContainerSize

#define JsonContainerSize ( jc ) ((jc)->header & JB_CMASK)

Definition at line 208 of file jsonb.h.

◆ PG_GETARG_JSONB_P

#define PG_GETARG_JSONB_P ( x ) DatumGetJsonbP(PG_GETARG_DATUM(x))

Definition at line 418 of file jsonb.h.

◆ PG_GETARG_JSONB_P_COPY

#define PG_GETARG_JSONB_P_COPY ( x ) DatumGetJsonbPCopy(PG_GETARG_DATUM(x))

Definition at line 419 of file jsonb.h.

◆ PG_RETURN_JSONB_P

#define PG_RETURN_JSONB_P ( x ) PG_RETURN_POINTER(x)

Definition at line 420 of file jsonb.h.

Typedef Documentation

◆ JEntry

typedef uint32 JEntry

Definition at line 138 of file jsonb.h.

◆ JsonbContainer

typedef struct JsonbContainer JsonbContainer

◆ JsonbInState

typedef struct JsonbInState JsonbInState

◆ JsonbIterator

typedef struct JsonbIterator JsonbIterator

◆ JsonbPair

typedef struct JsonbPair JsonbPair

Definition at line 71 of file jsonb.h.

◆ JsonbParseState

typedef struct JsonbParseState JsonbParseState

Definition at line 73 of file jsonb.h.

◆ JsonbValue

typedef struct JsonbValue JsonbValue

Definition at line 72 of file jsonb.h.

Enumeration Type Documentation

◆ jbvType

enum jbvType

Enumerator
jbvNull
jbvString
jbvNumeric
jbvBool
jbvArray
jbvObject
jbvBinary
jbvDatetime

Definition at line 227 of file jsonb.h.

{
    /* Scalar types */
    jbvNull = 0x0,
    jbvString,
    jbvNumeric,
    jbvBool,
    /* Composite types */
    jbvArray = 0x10,
    jbvObject,
    /* Binary (i.e. struct Jsonb) jbvArray/jbvObject */
    jbvBinary,
 
    /*
     * Virtual types.
     *
     * These types are used only for in-memory JSON processing and serialized
     * into JSON strings when outputted to json/jsonb.
     */
    jbvDatetime = 0x20,
};

◆ JsonbIteratorToken

enum JsonbIteratorToken

Enumerator
WJB_DONE
WJB_KEY
WJB_VALUE
WJB_ELEM
WJB_BEGIN_ARRAY
WJB_END_ARRAY
WJB_BEGIN_OBJECT
WJB_END_OBJECT

Definition at line 20 of file jsonb.h.

{
    WJB_DONE,
    WJB_KEY,
    WJB_VALUE,
    WJB_ELEM,
    WJB_BEGIN_ARRAY,
    WJB_END_ARRAY,
    WJB_BEGIN_OBJECT,
    WJB_END_OBJECT,
} JsonbIteratorToken;

◆ JsonbIterState

enum JsonbIterState

Enumerator
JBI_ARRAY_START
JBI_ARRAY_ELEM
JBI_OBJECT_START
JBI_OBJECT_KEY
JBI_OBJECT_VALUE

Definition at line 359 of file jsonb.h.

{
    JBI_ARRAY_START,
    JBI_ARRAY_ELEM,
    JBI_OBJECT_START,
    JBI_OBJECT_KEY,
    JBI_OBJECT_VALUE,
} JsonbIterState;

Function Documentation

◆ 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().

◆ DatumGetJsonbP()

static Jsonb * DatumGetJsonbP ( Datum d )

inlinestatic

Definition at line 401 of file jsonb.h.

{
    return (Jsonb *) PG_DETOAST_DATUM(d);
}

References PG_DETOAST_DATUM.

Referenced by datum_to_jsonb_internal(), ExecEvalJsonIsPredicate(), json_populate_type(), jsonb_subscript_assign(), jsonb_subscript_fetch(), jsonb_subscript_fetch_old(), JsonItemFromDatum(), JsonPathExists(), JsonPathQuery(), JsonPathValue(), and JsonTableResetRowPattern().

◆ DatumGetJsonbPCopy()

static Jsonb * DatumGetJsonbPCopy ( Datum d )

inlinestatic

Definition at line 407 of file jsonb.h.

{
    return (Jsonb *) PG_DETOAST_DATUM_COPY(d);
}

References PG_DETOAST_DATUM_COPY.

◆ 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().

◆ 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().

◆ jsonb_build_array_worker()

Datum jsonb_build_array_worker	(	int	nargs,
		const Datum *	args,
		const bool *	nulls,
		const Oid *	types,
		bool	absent_on_null
	)

Definition at line 1247 of file jsonb.c.

{
    int         i;
    JsonbInState result;
 
    memset(&result, 0, sizeof(JsonbInState));
 
    pushJsonbValue(&result, WJB_BEGIN_ARRAY, NULL);
 
    for (i = 0; i < nargs; i++)
    {
        if (absent_on_null && nulls[i])
            continue;
 
        add_jsonb(args[i], nulls[i], &result, types[i], false);
    }
 
    pushJsonbValue(&result, WJB_END_ARRAY, NULL);
 
    return JsonbPGetDatum(JsonbValueToJsonb(result.result));
}

References add_jsonb(), generate_unaccent_rules::args, i, JsonbPGetDatum(), JsonbValueToJsonb(), pushJsonbValue(), JsonbInState::result, types, WJB_BEGIN_ARRAY, and WJB_END_ARRAY.

Referenced by ExecEvalJsonConstructor(), and jsonb_build_array().

◆ jsonb_build_object_worker()

Datum jsonb_build_object_worker	(	int	nargs,
		const Datum *	args,
		const bool *	nulls,
		const Oid *	types,
		bool	absent_on_null,
		bool	unique_keys
	)

Definition at line 1162 of file jsonb.c.

{
    int         i;
    JsonbInState result;
 
    if (nargs % 2 != 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("argument list must have even number of elements"),
        /* translator: %s is a SQL function name */
                 errhint("The arguments of %s must consist of alternating keys and values.",
                         "jsonb_build_object()")));
 
    memset(&result, 0, sizeof(JsonbInState));
 
    pushJsonbValue(&result, WJB_BEGIN_OBJECT, NULL);
    result.parseState->unique_keys = unique_keys;
    result.parseState->skip_nulls = absent_on_null;
 
    for (i = 0; i < nargs; i += 2)
    {
        /* process key */
        bool        skip;
 
        if (nulls[i])
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("argument %d: key must not be null", i + 1)));
 
        /* skip null values if absent_on_null */
        skip = absent_on_null && nulls[i + 1];
 
        /* we need to save skipped keys for the key uniqueness check */
        if (skip && !unique_keys)
            continue;
 
        add_jsonb(args[i], false, &result, types[i], true);
 
        /* process value */
        add_jsonb(args[i + 1], nulls[i + 1], &result, types[i + 1], false);
    }
 
    pushJsonbValue(&result, WJB_END_OBJECT, NULL);
 
    return JsonbPGetDatum(JsonbValueToJsonb(result.result));
}

References add_jsonb(), generate_unaccent_rules::args, ereport, errcode(), errhint(), errmsg(), ERROR, i, JsonbPGetDatum(), JsonbValueToJsonb(), JsonbInState::parseState, pushJsonbValue(), JsonbInState::result, skip, JsonbParseState::skip_nulls, types, JsonbParseState::unique_keys, WJB_BEGIN_OBJECT, and WJB_END_OBJECT.

Referenced by ExecEvalJsonConstructor(), and jsonb_build_object().

◆ jsonb_get_element()

Datum jsonb_get_element	(	Jsonb *	jb,
		const Datum *	path,
		int	npath,
		bool *	isnull,
		bool	as_text
	)

Definition at line 1531 of file jsonfuncs.c.

{
    JsonbContainer *container = &jb->root;
    JsonbValue *jbvp = NULL;
    int         i;
    bool        have_object = false,
                have_array = false;
 
    *isnull = false;
 
    /* Identify whether we have object, array, or scalar at top-level */
    if (JB_ROOT_IS_OBJECT(jb))
        have_object = true;
    else if (JB_ROOT_IS_ARRAY(jb) && !JB_ROOT_IS_SCALAR(jb))
        have_array = true;
    else
    {
        Assert(JB_ROOT_IS_ARRAY(jb) && JB_ROOT_IS_SCALAR(jb));
        /* Extract the scalar value, if it is what we'll return */
        if (npath <= 0)
            jbvp = getIthJsonbValueFromContainer(container, 0);
    }
 
    /*
     * If the array is empty, return the entire LHS object, on the grounds
     * that we should do zero field or element extractions.  For the
     * non-scalar case we can just hand back the object without much work. For
     * the scalar case, fall through and deal with the value below the loop.
     * (This inconsistency arises because there's no easy way to generate a
     * JsonbValue directly for root-level containers.)
     */
    if (npath <= 0 && jbvp == NULL)
    {
        if (as_text)
        {
            return PointerGetDatum(cstring_to_text(JsonbToCString(NULL,
                                                                  container,
                                                                  VARSIZE(jb))));
        }
        else
        {
            /* not text mode - just hand back the jsonb */
            PG_RETURN_JSONB_P(jb);
        }
    }
 
    for (i = 0; i < npath; i++)
    {
        if (have_object)
        {
            text       *subscr = DatumGetTextPP(path[i]);
 
            jbvp = getKeyJsonValueFromContainer(container,
                                                VARDATA_ANY(subscr),
                                                VARSIZE_ANY_EXHDR(subscr),
                                                NULL);
        }
        else if (have_array)
        {
            int         lindex;
            uint32      index;
            char       *indextext = TextDatumGetCString(path[i]);
            char       *endptr;
 
            errno = 0;
            lindex = strtoint(indextext, &endptr, 10);
            if (endptr == indextext || *endptr != '\0' || errno != 0)
            {
                *isnull = true;
                return PointerGetDatum(NULL);
            }
 
            if (lindex >= 0)
            {
                index = (uint32) lindex;
            }
            else
            {
                /* Handle negative subscript */
                uint32      nelements;
 
                /* Container must be array, but make sure */
                if (!JsonContainerIsArray(container))
                    elog(ERROR, "not a jsonb array");
 
                nelements = JsonContainerSize(container);
 
                if (lindex == INT_MIN || -lindex > nelements)
                {
                    *isnull = true;
                    return PointerGetDatum(NULL);
                }
                else
                    index = nelements + lindex;
            }
 
            jbvp = getIthJsonbValueFromContainer(container, index);
        }
        else
        {
            /* scalar, extraction yields a null */
            *isnull = true;
            return PointerGetDatum(NULL);
        }
 
        if (jbvp == NULL)
        {
            *isnull = true;
            return PointerGetDatum(NULL);
        }
        else if (i == npath - 1)
            break;
 
        if (jbvp->type == jbvBinary)
        {
            container = jbvp->val.binary.data;
            have_object = JsonContainerIsObject(container);
            have_array = JsonContainerIsArray(container);
            Assert(!JsonContainerIsScalar(container));
        }
        else
        {
            Assert(IsAJsonbScalar(jbvp));
            have_object = false;
            have_array = false;
        }
    }
 
    if (as_text)
    {
        if (jbvp->type == jbvNull)
        {
            *isnull = true;
            return PointerGetDatum(NULL);
        }
 
        return PointerGetDatum(JsonbValueAsText(jbvp));
    }
    else
    {
        Jsonb      *res = JsonbValueToJsonb(jbvp);
 
        /* not text mode - just hand back the jsonb */
        PG_RETURN_JSONB_P(res);
    }
}

References Assert(), cstring_to_text(), DatumGetTextPP, elog, ERROR, getIthJsonbValueFromContainer(), getKeyJsonValueFromContainer(), i, IsAJsonbScalar, JB_ROOT_IS_ARRAY, JB_ROOT_IS_OBJECT, JB_ROOT_IS_SCALAR, jbvBinary, jbvNull, JsonbToCString(), JsonbValueAsText(), JsonbValueToJsonb(), JsonContainerIsArray, JsonContainerIsObject, JsonContainerIsScalar, JsonContainerSize, PG_RETURN_JSONB_P, PointerGetDatum(), Jsonb::root, strtoint(), TextDatumGetCString, JsonbValue::type, JsonbValue::val, VARDATA_ANY(), VARSIZE(), and VARSIZE_ANY_EXHDR().

Referenced by get_jsonb_path_all(), jsonb_subscript_fetch(), and jsonb_subscript_fetch_old().

◆ jsonb_set_element()

Datum jsonb_set_element	(	Jsonb *	jb,
		const Datum *	path,
		int	path_len,
		JsonbValue *	newval
	)

Definition at line 1679 of file jsonfuncs.c.

{
    JsonbInState state = {0};
    JsonbIterator *it;
    bool       *path_nulls = palloc0_array(bool, path_len);
 
    if (newval->type == jbvArray && newval->val.array.rawScalar)
        *newval = newval->val.array.elems[0];
 
    it = JsonbIteratorInit(&jb->root);
 
    setPath(&it, path, path_nulls, path_len, &state, 0, newval,
            JB_PATH_CREATE | JB_PATH_FILL_GAPS |
            JB_PATH_CONSISTENT_POSITION);
 
    pfree(path_nulls);
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(state.result));
}

References JB_PATH_CONSISTENT_POSITION, JB_PATH_CREATE, JB_PATH_FILL_GAPS, jbvArray, JsonbIteratorInit(), JsonbValueToJsonb(), newval, palloc0_array, pfree(), PG_RETURN_JSONB_P, Jsonb::root, and setPath().

Referenced by jsonb_subscript_assign().

◆ 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().

◆ JsonbExtractScalar()

bool JsonbExtractScalar	(	JsonbContainer *	jbc,
		JsonbValue *	res
	)

Definition at line 1778 of file jsonb.c.

{
    JsonbIterator *it;
    JsonbIteratorToken tok PG_USED_FOR_ASSERTS_ONLY;
    JsonbValue  tmp;
 
    if (!JsonContainerIsArray(jbc) || !JsonContainerIsScalar(jbc))
    {
        /* inform caller about actual type of container */
        res->type = (JsonContainerIsArray(jbc)) ? jbvArray : jbvObject;
        return false;
    }
 
    /*
     * A root scalar is stored as an array of one element, so we get the array
     * and then its first (and only) member.
     */
    it = JsonbIteratorInit(jbc);
 
    tok = JsonbIteratorNext(&it, &tmp, true);
    Assert(tok == WJB_BEGIN_ARRAY);
    Assert(tmp.val.array.nElems == 1 && tmp.val.array.rawScalar);
 
    tok = JsonbIteratorNext(&it, res, true);
    Assert(tok == WJB_ELEM);
    Assert(IsAJsonbScalar(res));
 
    tok = JsonbIteratorNext(&it, &tmp, true);
    Assert(tok == WJB_END_ARRAY);
 
    tok = JsonbIteratorNext(&it, &tmp, true);
    Assert(tok == WJB_DONE);
 
    return true;
}

References Assert(), IsAJsonbScalar, jbvArray, jbvObject, JsonbIteratorInit(), JsonbIteratorNext(), JsonContainerIsArray, JsonContainerIsScalar, PG_USED_FOR_ASSERTS_ONLY, JsonbValue::type, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_DONE, WJB_ELEM, and WJB_END_ARRAY.

Referenced by executeJsonPath(), jsonb_bool(), jsonb_float4(), jsonb_float8(), jsonb_int2(), jsonb_int4(), jsonb_int8(), jsonb_numeric(), JsonbContainerTypeName(), JsonbUnquote(), JsonItemFromDatum(), and JsonPathValue().

◆ 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().

◆ JsonbPGetDatum()

static Datum JsonbPGetDatum ( const Jsonb * p )

inlinestatic

Definition at line 413 of file jsonb.h.

{
    return PointerGetDatum(p);
}

References PointerGetDatum().

Referenced by datum_to_jsonb(), ExecEvalJsonExprPath(), ExecGetJsonValueItemString(), jsonb_build_array_worker(), jsonb_build_object_worker(), jsonb_path_query_internal(), JsonItemFromDatum(), JsonPathQuery(), JsonTablePlanScanNextRow(), and populate_scalar().

◆ JsonbToCString()

char * JsonbToCString	(	StringInfo	out,
		JsonbContainer *	in,
		int	estimated_len
	)

Definition at line 466 of file jsonb.c.

{
    return JsonbToCStringWorker(out, in, estimated_len, false);
}

References JsonbToCStringWorker().

Referenced by jsonb_get_element(), jsonb_out(), jsonb_send(), JsonbUnquote(), JsonbValueAsText(), and populate_scalar().

◆ JsonbToCStringIndent()

char * JsonbToCStringIndent	(	StringInfo	out,
		JsonbContainer *	in,
		int	estimated_len
	)

Definition at line 475 of file jsonb.c.

{
    return JsonbToCStringWorker(out, in, estimated_len, true);
}

References JsonbToCStringWorker().

Referenced by jsonb_pretty().

◆ 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().

◆ JsonbTypeName()

const char * JsonbTypeName ( JsonbValue * val )

Definition at line 173 of file jsonb.c.

{
    switch (val->type)
    {
        case jbvBinary:
            return JsonbContainerTypeName(val->val.binary.data);
        case jbvObject:
            return "object";
        case jbvArray:
            return "array";
        case jbvNumeric:
            return "number";
        case jbvString:
            return "string";
        case jbvBool:
            return "boolean";
        case jbvNull:
            return "null";
        case jbvDatetime:
            switch (val->val.datetime.typid)
            {
                case DATEOID:
                    return "date";
                case TIMEOID:
                    return "time without time zone";
                case TIMETZOID:
                    return "time with time zone";
                case TIMESTAMPOID:
                    return "timestamp without time zone";
                case TIMESTAMPTZOID:
                    return "timestamp with time zone";
                default:
                    elog(ERROR, "unrecognized jsonb value datetime type: %d",
                         val->val.datetime.typid);
            }
            return "unknown";
        default:
            elog(ERROR, "unrecognized jsonb value type: %d", val->type);
            return "unknown";
    }
}

References elog, ERROR, jbvArray, jbvBinary, jbvBool, jbvDatetime, jbvNull, jbvNumeric, jbvObject, jbvString, JsonbContainerTypeName(), and val.

Referenced by executeItemOptUnwrapTarget(), and JsonbContainerTypeName().

◆ JsonbUnquote()

char * JsonbUnquote ( Jsonb * jb )

Definition at line 2039 of file jsonb.c.

{
    if (JB_ROOT_IS_SCALAR(jb))
    {
        JsonbValue  v;
 
        (void) JsonbExtractScalar(&jb->root, &v);
 
        if (v.type == jbvString)
            return pnstrdup(v.val.string.val, v.val.string.len);
        else if (v.type == jbvBool)
            return pstrdup(v.val.boolean ? "true" : "false");
        else if (v.type == jbvNumeric)
            return DatumGetCString(DirectFunctionCall1(numeric_out,
                                                       PointerGetDatum(v.val.numeric)));
        else if (v.type == jbvNull)
            return pstrdup("null");
        else
        {
            elog(ERROR, "unrecognized jsonb value type %d", v.type);
            return NULL;
        }
    }
    else
        return JsonbToCString(NULL, &jb->root, VARSIZE(jb));
}

References DatumGetCString(), DirectFunctionCall1, elog, ERROR, JB_ROOT_IS_SCALAR, jbvBool, jbvNull, jbvNumeric, jbvString, JsonbExtractScalar(), JsonbToCString(), numeric_out(), pnstrdup(), PointerGetDatum(), pstrdup(), Jsonb::root, JsonbValue::type, JsonbValue::val, and VARSIZE().

Referenced by json_populate_type().

◆ 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().

◆ 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().

◆ to_jsonb_is_immutable()

bool to_jsonb_is_immutable ( Oid typoid )

Definition at line 1086 of file jsonb.c.

{
    JsonTypeCategory tcategory;
    Oid         outfuncoid;
 
    json_categorize_type(typoid, true, &tcategory, &outfuncoid);
 
    switch (tcategory)
    {
        case JSONTYPE_NULL:
        case JSONTYPE_BOOL:
        case JSONTYPE_JSON:
        case JSONTYPE_JSONB:
            return true;
 
        case JSONTYPE_DATE:
        case JSONTYPE_TIMESTAMP:
        case JSONTYPE_TIMESTAMPTZ:
            return false;
 
        case JSONTYPE_ARRAY:
            return false;       /* TODO recurse into elements */
 
        case JSONTYPE_COMPOSITE:
            return false;       /* TODO recurse into fields */
 
        case JSONTYPE_NUMERIC:
        case JSONTYPE_CAST:
        case JSONTYPE_OTHER:
            return func_volatile(outfuncoid) == PROVOLATILE_IMMUTABLE;
    }
 
    return false;               /* not reached */
}

References func_volatile(), json_categorize_type(), JSONTYPE_ARRAY, JSONTYPE_BOOL, JSONTYPE_CAST, JSONTYPE_COMPOSITE, JSONTYPE_DATE, JSONTYPE_JSON, JSONTYPE_JSONB, JSONTYPE_NULL, JSONTYPE_NUMERIC, JSONTYPE_OTHER, JSONTYPE_TIMESTAMP, and JSONTYPE_TIMESTAMPTZ.

Referenced by contain_mutable_functions_walker().

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ IsAJsonbScalar

◆ JB_CMASK

◆ JB_FARRAY

◆ JB_FOBJECT

◆ JB_FSCALAR

◆ JB_OFFSET_STRIDE

◆ JB_ROOT_COUNT

◆ JB_ROOT_IS_ARRAY

◆ JB_ROOT_IS_OBJECT

◆ JB_ROOT_IS_SCALAR

◆ JBE_ADVANCE_OFFSET

◆ JBE_HAS_OFF

◆ JBE_ISBOOL

◆ JBE_ISBOOL_FALSE

◆ JBE_ISBOOL_TRUE

◆ JBE_ISCONTAINER

◆ JBE_ISNULL

◆ JBE_ISNUMERIC

◆ JBE_ISSTRING

◆ JBE_OFFLENFLD

◆ JENTRY_HAS_OFF

◆ JENTRY_ISBOOL_FALSE

◆ JENTRY_ISBOOL_TRUE

◆ JENTRY_ISCONTAINER

◆ JENTRY_ISNULL

◆ JENTRY_ISNUMERIC

◆ JENTRY_ISSTRING

◆ JENTRY_OFFLENMASK

◆ JENTRY_TYPEMASK

◆ JGIN_MAXLENGTH

◆ JGINFLAG_BOOL

◆ JGINFLAG_HASHED

◆ JGINFLAG_KEY

◆ JGINFLAG_NULL

◆ JGINFLAG_NUM

◆ JGINFLAG_STR

◆ JsonbContainsStrategyNumber

◆ JsonbExistsAllStrategyNumber

◆ JsonbExistsAnyStrategyNumber

◆ JsonbExistsStrategyNumber

◆ JsonbJsonpathExistsStrategyNumber

◆ JsonbJsonpathPredicateStrategyNumber

◆ JsonContainerIsArray

◆ JsonContainerIsObject

◆ JsonContainerIsScalar

◆ JsonContainerSize

◆ PG_GETARG_JSONB_P

◆ PG_GETARG_JSONB_P_COPY

◆ PG_RETURN_JSONB_P

Typedef Documentation

◆ JEntry

◆ JsonbContainer

◆ JsonbInState

◆ JsonbIterator

◆ JsonbPair

◆ JsonbParseState

◆ JsonbValue

Enumeration Type Documentation

◆ jbvType

◆ JsonbIteratorToken

◆ JsonbIterState

Function Documentation

◆ compareJsonbContainers()

◆ DatumGetJsonbP()

◆ DatumGetJsonbPCopy()

◆ findJsonbValueFromContainer()

◆ getIthJsonbValueFromContainer()

◆ getJsonbLength()

◆ getJsonbOffset()

◆ getKeyJsonValueFromContainer()

◆ jsonb_build_array_worker()

◆ jsonb_build_object_worker()

◆ jsonb_get_element()

◆ jsonb_set_element()