jsonpath_exec.c File Reference

#include "postgres.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/miscnodes.h"
#include "nodes/nodeFuncs.h"
#include "regex/regex.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/datetime.h"
#include "utils/float.h"
#include "utils/formatting.h"
#include "utils/json.h"
#include "utils/jsonpath.h"
#include "utils/memutils.h"
#include "utils/timestamp.h"

Include dependency graph for jsonpath_exec.c:

Go to the source code of this file.

Data Structures
struct	JsonBaseObjectInfo
struct	JsonPathExecContext
struct	JsonLikeRegexContext
struct	JsonValueList
struct	JsonValueListIterator
struct	JsonTablePlanRowSource
struct	JsonTablePlanState
struct	JsonTableExecContext

Macros
#define	jperIsError(jper)   ((jper) == jperError)
#define	JSON_TABLE_EXEC_CONTEXT_MAGIC   418352867
#define	jspStrictAbsenceOfErrors(cxt)   (!(cxt)->laxMode)
#define	jspAutoUnwrap(cxt)   ((cxt)->laxMode)
#define	jspAutoWrap(cxt)   ((cxt)->laxMode)
#define	jspIgnoreStructuralErrors(cxt)   ((cxt)->ignoreStructuralErrors)
#define	jspThrowErrors(cxt)   ((cxt)->throwErrors)
#define	RETURN_ERROR(throw_error)

Typedefs
typedef struct JsonBaseObjectInfo	JsonBaseObjectInfo
typedef JsonbValue *(*	JsonPathGetVarCallback) (void *vars, char *varName, int varNameLen, JsonbValue *baseObject, int *baseObjectId)
typedef int(*	JsonPathCountVarsCallback) (void *vars)
typedef struct JsonPathExecContext	JsonPathExecContext
typedef struct JsonLikeRegexContext	JsonLikeRegexContext
typedef enum JsonPathBool	JsonPathBool
typedef enum JsonPathExecResult	JsonPathExecResult
typedef struct JsonValueList	JsonValueList
typedef struct JsonValueListIterator	JsonValueListIterator
typedef struct JsonTablePlanRowSource	JsonTablePlanRowSource
typedef struct JsonTablePlanState	JsonTablePlanState
typedef struct JsonTableExecContext	JsonTableExecContext
typedef JsonPathBool(*	JsonPathPredicateCallback) (JsonPathItem *jsp, JsonbValue *larg, JsonbValue *rarg, void *param)
typedef Numeric(*	BinaryArithmFunc) (Numeric num1, Numeric num2, bool *error)

Enumerations
enum	JsonPathBool { jpbFalse = 0 , jpbTrue = 1 , jpbUnknown = 2 }
enum	JsonPathExecResult { jperOk = 0 , jperNotFound = 1 , jperError = 2 }

Functions
static JsonPathExecResult	executeJsonPath (JsonPath *path, void *vars, JsonPathGetVarCallback getVar, JsonPathCountVarsCallback countVars, Jsonb *json, bool throwErrors, JsonValueList *result, bool useTz)
static JsonPathExecResult	executeItem (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found)
static JsonPathExecResult	executeItemOptUnwrapTarget (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found, bool unwrap)
static JsonPathExecResult	executeItemUnwrapTargetArray (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found, bool unwrapElements)
static JsonPathExecResult	executeNextItem (JsonPathExecContext *cxt, JsonPathItem *cur, JsonPathItem *next, JsonbValue *v, JsonValueList *found, bool copy)
static JsonPathExecResult	executeItemOptUnwrapResult (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, JsonValueList *found)
static JsonPathExecResult	executeItemOptUnwrapResultNoThrow (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, JsonValueList *found)
static JsonPathBool	executeBoolItem (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool canHaveNext)
static JsonPathBool	executeNestedBoolItem (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb)
static JsonPathExecResult	executeAnyItem (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbContainer *jbc, JsonValueList *found, uint32 level, uint32 first, uint32 last, bool ignoreStructuralErrors, bool unwrapNext)
static JsonPathBool	executePredicate (JsonPathExecContext *cxt, JsonPathItem *pred, JsonPathItem *larg, JsonPathItem *rarg, JsonbValue *jb, bool unwrapRightArg, JsonPathPredicateCallback exec, void *param)
static JsonPathExecResult	executeBinaryArithmExpr (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, BinaryArithmFunc func, JsonValueList *found)
static JsonPathExecResult	executeUnaryArithmExpr (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, PGFunction func, JsonValueList *found)
static JsonPathBool	executeStartsWith (JsonPathItem *jsp, JsonbValue *whole, JsonbValue *initial, void *param)
static JsonPathBool	executeLikeRegex (JsonPathItem *jsp, JsonbValue *str, JsonbValue *rarg, void *param)
static JsonPathExecResult	executeNumericItemMethod (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, PGFunction func, JsonValueList *found)
static JsonPathExecResult	executeDateTimeMethod (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found)
static JsonPathExecResult	executeKeyValueMethod (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found)
static JsonPathExecResult	appendBoolResult (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonValueList *found, JsonPathBool res)
static void	getJsonPathItem (JsonPathExecContext *cxt, JsonPathItem *item, JsonbValue *value)
static JsonbValue *	GetJsonPathVar (void *cxt, char *varName, int varNameLen, JsonbValue *baseObject, int *baseObjectId)
static int	CountJsonPathVars (void *cxt)
static void	JsonItemFromDatum (Datum val, Oid typid, int32 typmod, JsonbValue *res)
static void	JsonbValueInitNumericDatum (JsonbValue *jbv, Datum num)
static void	getJsonPathVariable (JsonPathExecContext *cxt, JsonPathItem *variable, JsonbValue *value)
static int	countVariablesFromJsonb (void *varsJsonb)
static JsonbValue *	getJsonPathVariableFromJsonb (void *varsJsonb, char *varName, int varNameLength, JsonbValue *baseObject, int *baseObjectId)
static int	JsonbArraySize (JsonbValue *jb)
static JsonPathBool	executeComparison (JsonPathItem *cmp, JsonbValue *lv, JsonbValue *rv, void *p)
static JsonPathBool	compareItems (int32 op, JsonbValue *jb1, JsonbValue *jb2, bool useTz)
static int	compareNumeric (Numeric a, Numeric b)
static JsonbValue *	copyJsonbValue (JsonbValue *src)
static JsonPathExecResult	getArrayIndex (JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, int32 *index)
static JsonBaseObjectInfo	setBaseObject (JsonPathExecContext *cxt, JsonbValue *jbv, int32 id)
static void	JsonValueListClear (JsonValueList *jvl)
static void	JsonValueListAppend (JsonValueList *jvl, JsonbValue *jbv)
static int	JsonValueListLength (const JsonValueList *jvl)
static bool	JsonValueListIsEmpty (JsonValueList *jvl)
static JsonbValue *	JsonValueListHead (JsonValueList *jvl)
static List *	JsonValueListGetList (JsonValueList *jvl)
static void	JsonValueListInitIterator (const JsonValueList *jvl, JsonValueListIterator *it)
static JsonbValue *	JsonValueListNext (const JsonValueList *jvl, JsonValueListIterator *it)
static JsonbValue *	JsonbInitBinary (JsonbValue *jbv, Jsonb *jb)
static int	JsonbType (JsonbValue *jb)
static JsonbValue *	getScalar (JsonbValue *scalar, enum jbvType type)
static JsonbValue *	wrapItemsInArray (const JsonValueList *items)
static int	compareDatetime (Datum val1, Oid typid1, Datum val2, Oid typid2, bool useTz, bool *cast_error)
static void	checkTimezoneIsUsedForCast (bool useTz, const char *type1, const char *type2)
static void	JsonTableInitOpaque (TableFuncScanState *state, int natts)
static JsonTablePlanState *	JsonTableInitPlan (JsonTableExecContext *cxt, JsonTablePlan *plan, JsonTablePlanState *parentstate, List *args, MemoryContext mcxt)
static void	JsonTableSetDocument (TableFuncScanState *state, Datum value)
static void	JsonTableResetRowPattern (JsonTablePlanState *planstate, Datum item)
static bool	JsonTableFetchRow (TableFuncScanState *state)
static Datum	JsonTableGetValue (TableFuncScanState *state, int colnum, Oid typid, int32 typmod, bool *isnull)
static void	JsonTableDestroyOpaque (TableFuncScanState *state)
static bool	JsonTablePlanScanNextRow (JsonTablePlanState *planstate)
static void	JsonTableResetNestedPlan (JsonTablePlanState *planstate)
static bool	JsonTablePlanJoinNextRow (JsonTablePlanState *planstate)
static bool	JsonTablePlanNextRow (JsonTablePlanState *planstate)
static Datum	jsonb_path_exists_internal (FunctionCallInfo fcinfo, bool tz)
Datum	jsonb_path_exists (PG_FUNCTION_ARGS)
Datum	jsonb_path_exists_tz (PG_FUNCTION_ARGS)
Datum	jsonb_path_exists_opr (PG_FUNCTION_ARGS)
static Datum	jsonb_path_match_internal (FunctionCallInfo fcinfo, bool tz)
Datum	jsonb_path_match (PG_FUNCTION_ARGS)
Datum	jsonb_path_match_tz (PG_FUNCTION_ARGS)
Datum	jsonb_path_match_opr (PG_FUNCTION_ARGS)
static Datum	jsonb_path_query_internal (FunctionCallInfo fcinfo, bool tz)
Datum	jsonb_path_query (PG_FUNCTION_ARGS)
Datum	jsonb_path_query_tz (PG_FUNCTION_ARGS)
static Datum	jsonb_path_query_array_internal (FunctionCallInfo fcinfo, bool tz)
Datum	jsonb_path_query_array (PG_FUNCTION_ARGS)
Datum	jsonb_path_query_array_tz (PG_FUNCTION_ARGS)
static Datum	jsonb_path_query_first_internal (FunctionCallInfo fcinfo, bool tz)
Datum	jsonb_path_query_first (PG_FUNCTION_ARGS)
Datum	jsonb_path_query_first_tz (PG_FUNCTION_ARGS)
static int	binaryCompareStrings (const char *s1, int len1, const char *s2, int len2)
static int	compareStrings (const char *mbstr1, int mblen1, const char *mbstr2, int mblen2)
static Datum	castTimeToTimeTz (Datum time, bool useTz)
static int	cmpDateToTimestamp (DateADT date1, Timestamp ts2, bool useTz)
static int	cmpDateToTimestampTz (DateADT date1, TimestampTz tstz2, bool useTz)
static int	cmpTimestampToTimestampTz (Timestamp ts1, TimestampTz tstz2, bool useTz)
bool	JsonPathExists (Datum jb, JsonPath *jp, bool *error, List *vars)
Datum	JsonPathQuery (Datum jb, JsonPath *jp, JsonWrapper wrapper, bool *empty, bool *error, List *vars, const char *column_name)
JsonbValue *	JsonPathValue (Datum jb, JsonPath *jp, bool *empty, bool *error, List *vars, const char *column_name)
static JsonTableExecContext *	GetJsonTableExecContext (TableFuncScanState *state, const char *fname)

Variables
const TableFuncRoutine	JsonbTableRoutine

Macro Definition Documentation

jperIsError

#define jperIsError

(

jper

)

((jper) == jperError)

Definition at line 142 of file jsonpath_exec.c.

JSON_TABLE_EXEC_CONTEXT_MAGIC

#define JSON_TABLE_EXEC_CONTEXT_MAGIC   418352867

Definition at line 219 of file jsonpath_exec.c.

jspAutoUnwrap

#define jspAutoUnwrap

(

cxt

)

((cxt)->laxMode)

Definition at line 237 of file jsonpath_exec.c.

jspAutoWrap

#define jspAutoWrap

(

cxt

)

((cxt)->laxMode)

Definition at line 238 of file jsonpath_exec.c.

jspIgnoreStructuralErrors

#define jspIgnoreStructuralErrors

(

cxt

)

((cxt)->ignoreStructuralErrors)

Definition at line 239 of file jsonpath_exec.c.

jspStrictAbsenceOfErrors

#define jspStrictAbsenceOfErrors

(

cxt

)

(!(cxt)->laxMode)

Definition at line 236 of file jsonpath_exec.c.

jspThrowErrors

#define jspThrowErrors

(

cxt

)

((cxt)->throwErrors)

Definition at line 240 of file jsonpath_exec.c.

RETURN_ERROR

#define RETURN_ERROR

(

throw_error

)

Value:

do { \
    if (jspThrowErrors(cxt)) \
        throw_error; \
    else \
        return jperError; \
} while (0)

Definition at line 243 of file jsonpath_exec.c.

Typedef Documentation

BinaryArithmFunc

typedef Numeric(* BinaryArithmFunc) (Numeric num1, Numeric num2, bool *error)

Definition at line 255 of file jsonpath_exec.c.

JsonBaseObjectInfo

typedef struct JsonBaseObjectInfo JsonBaseObjectInfo

JsonLikeRegexContext

typedef struct JsonLikeRegexContext JsonLikeRegexContext

JsonPathBool

typedef enum JsonPathBool JsonPathBool

JsonPathCountVarsCallback

typedef int(* JsonPathCountVarsCallback) (void *vars)

Definition at line 91 of file jsonpath_exec.c.

JsonPathExecContext

typedef struct JsonPathExecContext JsonPathExecContext

JsonPathExecResult

typedef enum JsonPathExecResult JsonPathExecResult

JsonPathGetVarCallback

typedef JsonbValue *(* JsonPathGetVarCallback) (void *vars, char *varName, int varNameLen, JsonbValue *baseObject, int *baseObjectId)

Definition at line 89 of file jsonpath_exec.c.

JsonPathPredicateCallback

typedef JsonPathBool(* JsonPathPredicateCallback) (JsonPathItem *jsp, JsonbValue *larg, JsonbValue *rarg, void *param)

Definition at line 251 of file jsonpath_exec.c.

JsonTableExecContext

typedef struct JsonTableExecContext JsonTableExecContext

JsonTablePlanRowSource

typedef struct JsonTablePlanRowSource JsonTablePlanRowSource

JsonTablePlanState

typedef struct JsonTablePlanState JsonTablePlanState

JsonValueList

typedef struct JsonValueList JsonValueList

JsonValueListIterator

typedef struct JsonValueListIterator JsonValueListIterator

Enumeration Type Documentation

JsonPathBool

enum JsonPathBool

Enumerator
jpbFalse
jpbTrue
jpbUnknown

Definition at line 127 of file jsonpath_exec.c.

{
    jpbFalse = 0,
    jpbTrue = 1,
    jpbUnknown = 2
} JsonPathBool;

JsonPathExecResult

enum JsonPathExecResult

Enumerator
jperOk
jperNotFound
jperError

Definition at line 135 of file jsonpath_exec.c.

{
    jperOk = 0,
    jperNotFound = 1,
    jperError = 2
} JsonPathExecResult;

Function Documentation

appendBoolResult()

static JsonPathExecResult appendBoolResult ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonValueList *  found, JsonPathBool  res  )

static

Definition at line 2929 of file jsonpath_exec.c.

{
    JsonPathItem next;
    JsonbValue  jbv;
 
    if (!jspGetNext(jsp, &next) && !found)
        return jperOk;          /* found singleton boolean value */
 
    if (res == jpbUnknown)
    {
        jbv.type = jbvNull;
    }
    else
    {
        jbv.type = jbvBool;
        jbv.val.boolean = res == jpbTrue;
    }
 
    return executeNextItem(cxt, jsp, &next, &jbv, found, true);
}

References executeNextItem(), jbvBool, jbvNull, jpbTrue, jpbUnknown, jperOk, jspGetNext(), next, JsonbValue::type, and JsonbValue::val.

Referenced by executeItemOptUnwrapTarget().

binaryCompareStrings()

static int binaryCompareStrings ( const char *  s1, int  len1, const char *  s2, int  len2  )

static

Definition at line 3252 of file jsonpath_exec.c.

{
    int         cmp;
 
    cmp = memcmp(s1, s2, Min(len1, len2));
 
    if (cmp != 0)
        return cmp;
 
    if (len1 == len2)
        return 0;
 
    return len1 < len2 ? -1 : 1;
}

References cmp(), Min, s1, and s2.

Referenced by compareStrings().

castTimeToTimeTz()

static Datum castTimeToTimeTz ( Datum  time, bool  useTz  )

static

Definition at line 3677 of file jsonpath_exec.c.

{
    checkTimezoneIsUsedForCast(useTz, "time", "timetz");
 
    return DirectFunctionCall1(time_timetz, time);
}

References checkTimezoneIsUsedForCast(), DirectFunctionCall1, and time_timetz().

Referenced by compareDatetime().

checkTimezoneIsUsedForCast()

static void checkTimezoneIsUsedForCast ( bool  useTz, const char *  type1, const char *  type2  )

static

Definition at line 3665 of file jsonpath_exec.c.

{
    if (!useTz)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot convert value from %s to %s without time zone usage",
                        type1, type2),
                 errhint("Use *_tz() function for time zone support.")));
}

References ereport, errcode(), errhint(), errmsg(), and ERROR.

Referenced by castTimeToTimeTz(), cmpDateToTimestampTz(), cmpTimestampToTimestampTz(), and executeDateTimeMethod().

cmpDateToTimestamp()

static int cmpDateToTimestamp ( DateADT  date1, Timestamp  ts2, bool  useTz  )

static

Definition at line 3689 of file jsonpath_exec.c.

{
    return date_cmp_timestamp_internal(date1, ts2);
}

References date_cmp_timestamp_internal().

Referenced by compareDatetime().

cmpDateToTimestampTz()

static int cmpDateToTimestampTz ( DateADT  date1, TimestampTz  tstz2, bool  useTz  )

static

Definition at line 3698 of file jsonpath_exec.c.

{
    checkTimezoneIsUsedForCast(useTz, "date", "timestamptz");
 
    return date_cmp_timestamptz_internal(date1, tstz2);
}

References checkTimezoneIsUsedForCast(), and date_cmp_timestamptz_internal().

Referenced by compareDatetime().

cmpTimestampToTimestampTz()

static int cmpTimestampToTimestampTz ( Timestamp  ts1, TimestampTz  tstz2, bool  useTz  )

static

Definition at line 3709 of file jsonpath_exec.c.

{
    checkTimezoneIsUsedForCast(useTz, "timestamp", "timestamptz");
 
    return timestamp_cmp_timestamptz_internal(ts1, tstz2);
}

References checkTimezoneIsUsedForCast(), and timestamp_cmp_timestamptz_internal().

Referenced by compareDatetime().

compareDatetime()

static int compareDatetime ( Datum  val1, Oid  typid1, Datum  val2, Oid  typid2, bool  useTz, bool *  cast_error  )

static

Definition at line 3722 of file jsonpath_exec.c.

{
    PGFunction  cmpfunc;
 
    *cast_error = false;
 
    switch (typid1)
    {
        case DATEOID:
            switch (typid2)
            {
                case DATEOID:
                    cmpfunc = date_cmp;
 
                    break;
 
                case TIMESTAMPOID:
                    return cmpDateToTimestamp(DatumGetDateADT(val1),
                                              DatumGetTimestamp(val2),
                                              useTz);
 
                case TIMESTAMPTZOID:
                    return cmpDateToTimestampTz(DatumGetDateADT(val1),
                                                DatumGetTimestampTz(val2),
                                                useTz);
 
                case TIMEOID:
                case TIMETZOID:
                    *cast_error = true; /* uncomparable types */
                    return 0;
 
                default:
                    elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
                         typid2);
            }
            break;
 
        case TIMEOID:
            switch (typid2)
            {
                case TIMEOID:
                    cmpfunc = time_cmp;
 
                    break;
 
                case TIMETZOID:
                    val1 = castTimeToTimeTz(val1, useTz);
                    cmpfunc = timetz_cmp;
 
                    break;
 
                case DATEOID:
                case TIMESTAMPOID:
                case TIMESTAMPTZOID:
                    *cast_error = true; /* uncomparable types */
                    return 0;
 
                default:
                    elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
                         typid2);
            }
            break;
 
        case TIMETZOID:
            switch (typid2)
            {
                case TIMEOID:
                    val2 = castTimeToTimeTz(val2, useTz);
                    cmpfunc = timetz_cmp;
 
                    break;
 
                case TIMETZOID:
                    cmpfunc = timetz_cmp;
 
                    break;
 
                case DATEOID:
                case TIMESTAMPOID:
                case TIMESTAMPTZOID:
                    *cast_error = true; /* uncomparable types */
                    return 0;
 
                default:
                    elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
                         typid2);
            }
            break;
 
        case TIMESTAMPOID:
            switch (typid2)
            {
                case DATEOID:
                    return -cmpDateToTimestamp(DatumGetDateADT(val2),
                                               DatumGetTimestamp(val1),
                                               useTz);
 
                case TIMESTAMPOID:
                    cmpfunc = timestamp_cmp;
 
                    break;
 
                case TIMESTAMPTZOID:
                    return cmpTimestampToTimestampTz(DatumGetTimestamp(val1),
                                                     DatumGetTimestampTz(val2),
                                                     useTz);
 
                case TIMEOID:
                case TIMETZOID:
                    *cast_error = true; /* uncomparable types */
                    return 0;
 
                default:
                    elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
                         typid2);
            }
            break;
 
        case TIMESTAMPTZOID:
            switch (typid2)
            {
                case DATEOID:
                    return -cmpDateToTimestampTz(DatumGetDateADT(val2),
                                                 DatumGetTimestampTz(val1),
                                                 useTz);
 
                case TIMESTAMPOID:
                    return -cmpTimestampToTimestampTz(DatumGetTimestamp(val2),
                                                      DatumGetTimestampTz(val1),
                                                      useTz);
 
                case TIMESTAMPTZOID:
                    cmpfunc = timestamp_cmp;
 
                    break;
 
                case TIMEOID:
                case TIMETZOID:
                    *cast_error = true; /* uncomparable types */
                    return 0;
 
                default:
                    elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
                         typid2);
            }
            break;
 
        default:
            elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u", typid1);
    }
 
    if (*cast_error)
        return 0;               /* cast error */
 
    return DatumGetInt32(DirectFunctionCall2(cmpfunc, val1, val2));
}

References castTimeToTimeTz(), cmpDateToTimestamp(), cmpDateToTimestampTz(), cmpTimestampToTimestampTz(), date_cmp(), DatumGetDateADT(), DatumGetInt32(), DatumGetTimestamp(), DatumGetTimestampTz(), DirectFunctionCall2, elog, ERROR, time_cmp(), timestamp_cmp(), and timetz_cmp().

Referenced by compareItems().

compareItems()

static JsonPathBool compareItems ( int32  op, JsonbValue *  jb1, JsonbValue *  jb2, bool  useTz  )

static

Definition at line 3340 of file jsonpath_exec.c.

{
    int         cmp;
    bool        res;
 
    if (jb1->type != jb2->type)
    {
        if (jb1->type == jbvNull || jb2->type == jbvNull)
 
            /*
             * Equality and order comparison of nulls to non-nulls returns
             * always false, but inequality comparison returns true.
             */
            return op == jpiNotEqual ? jpbTrue : jpbFalse;
 
        /* Non-null items of different types are not comparable. */
        return jpbUnknown;
    }
 
    switch (jb1->type)
    {
        case jbvNull:
            cmp = 0;
            break;
        case jbvBool:
            cmp = jb1->val.boolean == jb2->val.boolean ? 0 :
                jb1->val.boolean ? 1 : -1;
            break;
        case jbvNumeric:
            cmp = compareNumeric(jb1->val.numeric, jb2->val.numeric);
            break;
        case jbvString:
            if (op == jpiEqual)
                return jb1->val.string.len != jb2->val.string.len ||
                    memcmp(jb1->val.string.val,
                           jb2->val.string.val,
                           jb1->val.string.len) ? jpbFalse : jpbTrue;
 
            cmp = compareStrings(jb1->val.string.val, jb1->val.string.len,
                                 jb2->val.string.val, jb2->val.string.len);
            break;
        case jbvDatetime:
            {
                bool        cast_error;
 
                cmp = compareDatetime(jb1->val.datetime.value,
                                      jb1->val.datetime.typid,
                                      jb2->val.datetime.value,
                                      jb2->val.datetime.typid,
                                      useTz,
                                      &cast_error);
 
                if (cast_error)
                    return jpbUnknown;
            }
            break;
 
        case jbvBinary:
        case jbvArray:
        case jbvObject:
            return jpbUnknown;  /* non-scalars are not comparable */
 
        default:
            elog(ERROR, "invalid jsonb value type %d", jb1->type);
    }
 
    switch (op)
    {
        case jpiEqual:
            res = (cmp == 0);
            break;
        case jpiNotEqual:
            res = (cmp != 0);
            break;
        case jpiLess:
            res = (cmp < 0);
            break;
        case jpiGreater:
            res = (cmp > 0);
            break;
        case jpiLessOrEqual:
            res = (cmp <= 0);
            break;
        case jpiGreaterOrEqual:
            res = (cmp >= 0);
            break;
        default:
            elog(ERROR, "unrecognized jsonpath operation: %d", op);
            return jpbUnknown;
    }
 
    return res ? jpbTrue : jpbFalse;
}

References cmp(), compareDatetime(), compareNumeric(), compareStrings(), elog, ERROR, jbvArray, jbvBinary, jbvBool, jbvDatetime, jbvNull, jbvNumeric, jbvObject, jbvString, jpbFalse, jpbTrue, jpbUnknown, jpiEqual, jpiGreater, jpiGreaterOrEqual, jpiLess, jpiLessOrEqual, jpiNotEqual, JsonbValue::type, and JsonbValue::val.

Referenced by executeComparison().

compareNumeric()

static int compareNumeric ( Numeric  a, Numeric  b  )

static

Definition at line 3436 of file jsonpath_exec.c.

{
    return DatumGetInt32(DirectFunctionCall2(numeric_cmp,
                                             NumericGetDatum(a),
                                             NumericGetDatum(b)));
}

References a, b, DatumGetInt32(), DirectFunctionCall2, numeric_cmp(), and NumericGetDatum().

Referenced by compareItems().

compareStrings()

static int compareStrings ( const char *  mbstr1, int  mblen1, const char *  mbstr2, int  mblen2  )

static

Definition at line 3273 of file jsonpath_exec.c.

{
    if (GetDatabaseEncoding() == PG_SQL_ASCII ||
        GetDatabaseEncoding() == PG_UTF8)
    {
        /*
         * It's known property of UTF-8 strings that their per-byte comparison
         * result matches codepoints comparison result.  ASCII can be
         * considered as special case of UTF-8.
         */
        return binaryCompareStrings(mbstr1, mblen1, mbstr2, mblen2);
    }
    else
    {
        char       *utf8str1,
                   *utf8str2;
        int         cmp,
                    utf8len1,
                    utf8len2;
 
        /*
         * We have to convert other encodings to UTF-8 first, then compare.
         * Input strings may be not null-terminated and pg_server_to_any() may
         * return them "as is".  So, use strlen() only if there is real
         * conversion.
         */
        utf8str1 = pg_server_to_any(mbstr1, mblen1, PG_UTF8);
        utf8str2 = pg_server_to_any(mbstr2, mblen2, PG_UTF8);
        utf8len1 = (mbstr1 == utf8str1) ? mblen1 : strlen(utf8str1);
        utf8len2 = (mbstr2 == utf8str2) ? mblen2 : strlen(utf8str2);
 
        cmp = binaryCompareStrings(utf8str1, utf8len1, utf8str2, utf8len2);
 
        /*
         * If pg_server_to_any() did no real conversion, then we actually
         * compared original strings.  So, we already done.
         */
        if (mbstr1 == utf8str1 && mbstr2 == utf8str2)
            return cmp;
 
        /* Free memory if needed */
        if (mbstr1 != utf8str1)
            pfree(utf8str1);
        if (mbstr2 != utf8str2)
            pfree(utf8str2);
 
        /*
         * When all Unicode codepoints are equal, return result of binary
         * comparison.  In some edge cases, same characters may have different
         * representations in encoding.  Then our behavior could diverge from
         * standard.  However, that allow us to do simple binary comparison
         * for "==" operator, which is performance critical in typical cases.
         * In future to implement strict standard conformance, we can do
         * normalization of input JSON strings.
         */
        if (cmp == 0)
            return binaryCompareStrings(mbstr1, mblen1, mbstr2, mblen2);
        else
            return cmp;
    }
}

References binaryCompareStrings(), cmp(), GetDatabaseEncoding(), pfree(), pg_server_to_any(), PG_SQL_ASCII, and PG_UTF8.

Referenced by compareItems().

copyJsonbValue()

static JsonbValue * copyJsonbValue ( JsonbValue *  src )

static

Definition at line 3444 of file jsonpath_exec.c.

{
    JsonbValue *dst = palloc(sizeof(*dst));
 
    *dst = *src;
 
    return dst;
}

References palloc().

Referenced by executeAnyItem(), and executeNextItem().

CountJsonPathVars()

static int CountJsonPathVars ( void *  cxt )

static

Definition at line 3035 of file jsonpath_exec.c.

{
    List       *vars = (List *) cxt;
 
    return list_length(vars);
}

References list_length().

Referenced by JsonPathExists(), JsonPathQuery(), JsonPathValue(), and JsonTableResetRowPattern().

countVariablesFromJsonb()

static int countVariablesFromJsonb ( void *  varsJsonb )

static

Definition at line 3202 of file jsonpath_exec.c.

{
    Jsonb      *vars = varsJsonb;
 
    if (vars && !JsonContainerIsObject(&vars->root))
    {
        ereport(ERROR,
                errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                errmsg("\"vars\" argument is not an object"),
                errdetail("Jsonpath parameters should be encoded as key-value pairs of \"vars\" object."));
    }
 
    /* count of base objects */
    return vars != NULL ? 1 : 0;
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, and JsonContainerIsObject.

Referenced by jsonb_path_exists_internal(), jsonb_path_match_internal(), jsonb_path_query_array_internal(), jsonb_path_query_first_internal(), and jsonb_path_query_internal().

executeAnyItem()

static JsonPathExecResult executeAnyItem ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbContainer *  jbc, JsonValueList *  found, uint32  level, uint32  first, uint32  last, bool  ignoreStructuralErrors, bool  unwrapNext  )

static

Definition at line 1933 of file jsonpath_exec.c.

{
    JsonPathExecResult res = jperNotFound;
    JsonbIterator *it;
    int32       r;
    JsonbValue  v;
 
    check_stack_depth();
 
    if (level > last)
        return res;
 
    it = JsonbIteratorInit(jbc);
 
    /*
     * Recursively iterate over jsonb objects/arrays
     */
    while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE)
    {
        if (r == WJB_KEY)
        {
            r = JsonbIteratorNext(&it, &v, true);
            Assert(r == WJB_VALUE);
        }
 
        if (r == WJB_VALUE || r == WJB_ELEM)
        {
 
            if (level >= first ||
                (first == PG_UINT32_MAX && last == PG_UINT32_MAX &&
                 v.type != jbvBinary))  /* leaves only requested */
            {
                /* check expression */
                if (jsp)
                {
                    if (ignoreStructuralErrors)
                    {
                        bool        savedIgnoreStructuralErrors;
 
                        savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors;
                        cxt->ignoreStructuralErrors = true;
                        res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext);
                        cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors;
                    }
                    else
                        res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext);
 
                    if (jperIsError(res))
                        break;
 
                    if (res == jperOk && !found)
                        break;
                }
                else if (found)
                    JsonValueListAppend(found, copyJsonbValue(&v));
                else
                    return jperOk;
            }
 
            if (level < last && v.type == jbvBinary)
            {
                res = executeAnyItem
                    (cxt, jsp, v.val.binary.data, found,
                     level + 1, first, last,
                     ignoreStructuralErrors, unwrapNext);
 
                if (jperIsError(res))
                    break;
 
                if (res == jperOk && found == NULL)
                    break;
            }
        }
    }
 
    return res;
}

References Assert(), check_stack_depth(), copyJsonbValue(), executeAnyItem(), executeItemOptUnwrapTarget(), JsonPathExecContext::ignoreStructuralErrors, jbvBinary, jperIsError, jperNotFound, jperOk, JsonbIteratorInit(), JsonbIteratorNext(), JsonValueListAppend(), PG_UINT32_MAX, JsonbValue::type, JsonbValue::val, WJB_DONE, WJB_ELEM, WJB_KEY, and WJB_VALUE.

Referenced by executeAnyItem(), executeItemOptUnwrapTarget(), and executeItemUnwrapTargetArray().

executeBinaryArithmExpr()

static JsonPathExecResult executeBinaryArithmExpr ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, BinaryArithmFunc  func, JsonValueList *  found  )

static

Definition at line 2104 of file jsonpath_exec.c.

{
    JsonPathExecResult jper;
    JsonPathItem elem;
    JsonValueList lseq = {0};
    JsonValueList rseq = {0};
    JsonbValue *lval;
    JsonbValue *rval;
    Numeric     res;
 
    jspGetLeftArg(jsp, &elem);
 
    /*
     * XXX: By standard only operands of multiplicative expressions are
     * unwrapped.  We extend it to other binary arithmetic expressions too.
     */
    jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &lseq);
    if (jperIsError(jper))
        return jper;
 
    jspGetRightArg(jsp, &elem);
 
    jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &rseq);
    if (jperIsError(jper))
        return jper;
 
    if (JsonValueListLength(&lseq) != 1 ||
        !(lval = getScalar(JsonValueListHead(&lseq), jbvNumeric)))
        RETURN_ERROR(ereport(ERROR,
                             (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
                              errmsg("left operand of jsonpath operator %s is not a single numeric value",
                                     jspOperationName(jsp->type)))));
 
    if (JsonValueListLength(&rseq) != 1 ||
        !(rval = getScalar(JsonValueListHead(&rseq), jbvNumeric)))
        RETURN_ERROR(ereport(ERROR,
                             (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
                              errmsg("right operand of jsonpath operator %s is not a single numeric value",
                                     jspOperationName(jsp->type)))));
 
    if (jspThrowErrors(cxt))
    {
        res = func(lval->val.numeric, rval->val.numeric, NULL);
    }
    else
    {
        bool        error = false;
 
        res = func(lval->val.numeric, rval->val.numeric, &error);
 
        if (error)
            return jperError;
    }
 
    if (!jspGetNext(jsp, &elem) && !found)
        return jperOk;
 
    lval = palloc(sizeof(*lval));
    lval->type = jbvNumeric;
    lval->val.numeric = res;
 
    return executeNextItem(cxt, jsp, &elem, lval, found, false);
}

References ereport, errcode(), errmsg(), ERROR, error(), executeItemOptUnwrapResult(), executeNextItem(), getScalar(), jbvNumeric, jperError, jperIsError, jperOk, JsonValueListHead(), JsonValueListLength(), jspGetLeftArg(), jspGetNext(), jspGetRightArg(), jspOperationName(), jspThrowErrors, palloc(), RETURN_ERROR, JsonbValue::type, JsonPathItem::type, and JsonbValue::val.

Referenced by executeItemOptUnwrapTarget().

executeBoolItem()

static JsonPathBool executeBoolItem ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, bool  canHaveNext  )

static

Definition at line 1776 of file jsonpath_exec.c.

{
    JsonPathItem larg;
    JsonPathItem rarg;
    JsonPathBool res;
    JsonPathBool res2;
 
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    if (!canHaveNext && jspHasNext(jsp))
        elog(ERROR, "boolean jsonpath item cannot have next item");
 
    switch (jsp->type)
    {
        case jpiAnd:
            jspGetLeftArg(jsp, &larg);
            res = executeBoolItem(cxt, &larg, jb, false);
 
            if (res == jpbFalse)
                return jpbFalse;
 
            /*
             * SQL/JSON says that we should check second arg in case of
             * jperError
             */
 
            jspGetRightArg(jsp, &rarg);
            res2 = executeBoolItem(cxt, &rarg, jb, false);
 
            return res2 == jpbTrue ? res : res2;
 
        case jpiOr:
            jspGetLeftArg(jsp, &larg);
            res = executeBoolItem(cxt, &larg, jb, false);
 
            if (res == jpbTrue)
                return jpbTrue;
 
            jspGetRightArg(jsp, &rarg);
            res2 = executeBoolItem(cxt, &rarg, jb, false);
 
            return res2 == jpbFalse ? res : res2;
 
        case jpiNot:
            jspGetArg(jsp, &larg);
 
            res = executeBoolItem(cxt, &larg, jb, false);
 
            if (res == jpbUnknown)
                return jpbUnknown;
 
            return res == jpbTrue ? jpbFalse : jpbTrue;
 
        case jpiIsUnknown:
            jspGetArg(jsp, &larg);
            res = executeBoolItem(cxt, &larg, jb, false);
            return res == jpbUnknown ? jpbTrue : jpbFalse;
 
        case jpiEqual:
        case jpiNotEqual:
        case jpiLess:
        case jpiGreater:
        case jpiLessOrEqual:
        case jpiGreaterOrEqual:
            jspGetLeftArg(jsp, &larg);
            jspGetRightArg(jsp, &rarg);
            return executePredicate(cxt, jsp, &larg, &rarg, jb, true,
                                    executeComparison, cxt);
 
        case jpiStartsWith:     /* 'whole STARTS WITH initial' */
            jspGetLeftArg(jsp, &larg);  /* 'whole' */
            jspGetRightArg(jsp, &rarg); /* 'initial' */
            return executePredicate(cxt, jsp, &larg, &rarg, jb, false,
                                    executeStartsWith, NULL);
 
        case jpiLikeRegex:      /* 'expr LIKE_REGEX pattern FLAGS flags' */
            {
                /*
                 * 'expr' is a sequence-returning expression.  'pattern' is a
                 * regex string literal.  SQL/JSON standard requires XQuery
                 * regexes, but we use Postgres regexes here.  'flags' is a
                 * string literal converted to integer flags at compile-time.
                 */
                JsonLikeRegexContext lrcxt = {0};
 
                jspInitByBuffer(&larg, jsp->base,
                                jsp->content.like_regex.expr);
 
                return executePredicate(cxt, jsp, &larg, NULL, jb, false,
                                        executeLikeRegex, &lrcxt);
            }
 
        case jpiExists:
            jspGetArg(jsp, &larg);
 
            if (jspStrictAbsenceOfErrors(cxt))
            {
                /*
                 * In strict mode we must get a complete list of values to
                 * check that there are no errors at all.
                 */
                JsonValueList vals = {0};
                JsonPathExecResult res =
                    executeItemOptUnwrapResultNoThrow(cxt, &larg, jb,
                                                      false, &vals);
 
                if (jperIsError(res))
                    return jpbUnknown;
 
                return JsonValueListIsEmpty(&vals) ? jpbFalse : jpbTrue;
            }
            else
            {
                JsonPathExecResult res =
                    executeItemOptUnwrapResultNoThrow(cxt, &larg, jb,
                                                      false, NULL);
 
                if (jperIsError(res))
                    return jpbUnknown;
 
                return res == jperOk ? jpbTrue : jpbFalse;
            }
 
        default:
            elog(ERROR, "invalid boolean jsonpath item type: %d", jsp->type);
            return jpbUnknown;
    }
}

References JsonPathItem::base, check_stack_depth(), JsonPathItem::content, elog, ERROR, executeBoolItem(), executeComparison(), executeItemOptUnwrapResultNoThrow(), executeLikeRegex(), executePredicate(), executeStartsWith(), JsonPathItem::expr, jpbFalse, jpbTrue, jpbUnknown, jperIsError, jperOk, jpiAnd, jpiEqual, jpiExists, jpiGreater, jpiGreaterOrEqual, jpiIsUnknown, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiNot, jpiNotEqual, jpiOr, jpiStartsWith, JsonValueListIsEmpty(), jspGetArg(), jspGetLeftArg(), jspGetRightArg(), jspHasNext, jspInitByBuffer(), jspStrictAbsenceOfErrors, JsonPathItem::like_regex, and JsonPathItem::type.

Referenced by executeBoolItem(), executeItemOptUnwrapTarget(), and executeNestedBoolItem().

executeComparison()

static JsonPathBool executeComparison ( JsonPathItem *  cmp, JsonbValue *  lv, JsonbValue *  rv, void *  p  )

static

Definition at line 3241 of file jsonpath_exec.c.

{
    JsonPathExecContext *cxt = (JsonPathExecContext *) p;
 
    return compareItems(cmp->type, lv, rv, cxt->useTz);
}

References cmp(), compareItems(), and JsonPathExecContext::useTz.

Referenced by executeBoolItem().

executeDateTimeMethod()

static JsonPathExecResult executeDateTimeMethod ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, JsonValueList *  found  )

static

Definition at line 2338 of file jsonpath_exec.c.

{
    JsonbValue  jbvbuf;
    Datum       value;
    text       *datetime;
    Oid         collid;
    Oid         typid;
    int32       typmod = -1;
    int         tz = 0;
    bool        hasNext;
    JsonPathExecResult res = jperNotFound;
    JsonPathItem elem;
    int32       time_precision = -1;
 
    if (!(jb = getScalar(jb, jbvString)))
        RETURN_ERROR(ereport(ERROR,
                             (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
                              errmsg("jsonpath item method .%s() can only be applied to a string",
                                     jspOperationName(jsp->type)))));
 
    datetime = cstring_to_text_with_len(jb->val.string.val,
                                        jb->val.string.len);
 
    /*
     * At some point we might wish to have callers supply the collation to
     * use, but right now it's unclear that they'd be able to do better than
     * DEFAULT_COLLATION_OID anyway.
     */
    collid = DEFAULT_COLLATION_OID;
 
    /*
     * .datetime(template) has an argument, the rest of the methods don't have
     * an argument.  So we handle that separately.
     */
    if (jsp->type == jpiDatetime && jsp->content.arg)
    {
        text       *template;
        char       *template_str;
        int         template_len;
        ErrorSaveContext escontext = {T_ErrorSaveContext};
 
        jspGetArg(jsp, &elem);
 
        if (elem.type != jpiString)
            elog(ERROR, "invalid jsonpath item type for .datetime() argument");
 
        template_str = jspGetString(&elem, &template_len);
 
        template = cstring_to_text_with_len(template_str,
                                            template_len);
 
        value = parse_datetime(datetime, template, collid, true,
                               &typid, &typmod, &tz,
                               jspThrowErrors(cxt) ? NULL : (Node *) &escontext);
 
        if (escontext.error_occurred)
            res = jperError;
        else
            res = jperOk;
    }
    else
    {
        /*
         * According to SQL/JSON standard enumerate ISO formats for: date,
         * timetz, time, timestamptz, timestamp.
         *
         * We also support ISO 8601 format (with "T") for timestamps, because
         * to_json[b]() functions use this format.
         */
        static const char *fmt_str[] =
        {
            "yyyy-mm-dd",       /* date */
            "HH24:MI:SS.USTZ",  /* timetz */
            "HH24:MI:SSTZ",
            "HH24:MI:SS.US",    /* time without tz */
            "HH24:MI:SS",
            "yyyy-mm-dd HH24:MI:SS.USTZ",   /* timestamptz */
            "yyyy-mm-dd HH24:MI:SSTZ",
            "yyyy-mm-dd\"T\"HH24:MI:SS.USTZ",
            "yyyy-mm-dd\"T\"HH24:MI:SSTZ",
            "yyyy-mm-dd HH24:MI:SS.US", /* timestamp without tz */
            "yyyy-mm-dd HH24:MI:SS",
            "yyyy-mm-dd\"T\"HH24:MI:SS.US",
            "yyyy-mm-dd\"T\"HH24:MI:SS"
        };
 
        /* cache for format texts */
        static text *fmt_txt[lengthof(fmt_str)] = {0};
        int         i;
 
        /*
         * Check for optional precision for methods other than .datetime() and
         * .date()
         */
        if (jsp->type != jpiDatetime && jsp->type != jpiDate &&
            jsp->content.arg)
        {
            bool        have_error;
 
            jspGetArg(jsp, &elem);
 
            if (elem.type != jpiNumeric)
                elog(ERROR, "invalid jsonpath item type for %s argument",
                     jspOperationName(jsp->type));
 
            time_precision = numeric_int4_opt_error(jspGetNumeric(&elem),
                                                    &have_error);
            if (have_error)
                RETURN_ERROR(ereport(ERROR,
                                     (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
                                      errmsg("time precision of jsonpath item method .%s() is out of range for type integer",
                                             jspOperationName(jsp->type)))));
        }
 
        /* loop until datetime format fits */
        for (i = 0; i < lengthof(fmt_str); i++)
        {
            ErrorSaveContext escontext = {T_ErrorSaveContext};
 
            if (!fmt_txt[i])
            {
                MemoryContext oldcxt =
                    MemoryContextSwitchTo(TopMemoryContext);
 
                fmt_txt[i] = cstring_to_text(fmt_str[i]);
                MemoryContextSwitchTo(oldcxt);
            }
 
            value = parse_datetime(datetime, fmt_txt[i], collid, true,
                                   &typid, &typmod, &tz,
                                   (Node *) &escontext);
 
            if (!escontext.error_occurred)
            {
                res = jperOk;
                break;
            }
        }
 
        if (res == jperNotFound)
        {
            if (jsp->type == jpiDatetime)
                RETURN_ERROR(ereport(ERROR,
                                     (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
                                      errmsg("%s format is not recognized: \"%s\"",
                                             "datetime", text_to_cstring(datetime)),
                                      errhint("Use a datetime template argument to specify the input data format."))));
            else
                RETURN_ERROR(ereport(ERROR,
                                     (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
                                      errmsg("%s format is not recognized: \"%s\"",
                                             jspOperationName(jsp->type), text_to_cstring(datetime)))));
 
        }
    }
 
    /*
     * parse_datetime() processes the entire input string per the template or
     * ISO format and returns the Datum in best fitted datetime type.  So, if
     * this call is for a specific datatype, then we do the conversion here.
     * Throw an error for incompatible types.
     */
    switch (jsp->type)
    {
        case jpiDatetime:       /* Nothing to do for DATETIME */
            break;
        case jpiDate:
            {
                /* Convert result type to date */
                switch (typid)
                {
                    case DATEOID:   /* Nothing to do for DATE */
                        break;
                    case TIMEOID:
                    case TIMETZOID:
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
                                              errmsg("%s format is not recognized: \"%s\"",
                                                     "date", text_to_cstring(datetime)))));
                        break;
                    case TIMESTAMPOID:
                        value = DirectFunctionCall1(timestamp_date,
                                                    value);
                        break;
                    case TIMESTAMPTZOID:
                        checkTimezoneIsUsedForCast(cxt->useTz,
                                                   "timestamptz", "date");
                        value = DirectFunctionCall1(timestamptz_date,
                                                    value);
                        break;
                    default:
                        elog(ERROR, "type with oid %u not supported", typid);
                }
 
                typid = DATEOID;
            }
            break;
        case jpiTime:
            {
                /* Convert result type to time without time zone */
                switch (typid)
                {
                    case DATEOID:
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
                                              errmsg("%s format is not recognized: \"%s\"",
                                                     "time", text_to_cstring(datetime)))));
                        break;
                    case TIMEOID:   /* Nothing to do for TIME */
                        break;
                    case TIMETZOID:
                        checkTimezoneIsUsedForCast(cxt->useTz,
                                                   "timetz", "time");
                        value = DirectFunctionCall1(timetz_time,
                                                    value);
                        break;
                    case TIMESTAMPOID:
                        value = DirectFunctionCall1(timestamp_time,
                                                    value);
                        break;
                    case TIMESTAMPTZOID:
                        checkTimezoneIsUsedForCast(cxt->useTz,
                                                   "timestamptz", "time");
                        value = DirectFunctionCall1(timestamptz_time,
                                                    value);
                        break;
                    default:
                        elog(ERROR, "type with oid %u not supported", typid);
                }
 
                /* Force the user-given time precision, if any */
                if (time_precision != -1)
                {
                    TimeADT     result;
 
                    /* Get a warning when precision is reduced */
                    time_precision = anytime_typmod_check(false,
                                                          time_precision);
                    result = DatumGetTimeADT(value);
                    AdjustTimeForTypmod(&result, time_precision);
                    value = TimeADTGetDatum(result);
 
                    /* Update the typmod value with the user-given precision */
                    typmod = time_precision;
                }
 
                typid = TIMEOID;
            }
            break;
        case jpiTimeTz:
            {
                /* Convert result type to time with time zone */
                switch (typid)
                {
                    case DATEOID:
                    case TIMESTAMPOID:
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
                                              errmsg("%s format is not recognized: \"%s\"",
                                                     "time_tz", text_to_cstring(datetime)))));
                        break;
                    case TIMEOID:
                        checkTimezoneIsUsedForCast(cxt->useTz,
                                                   "time", "timetz");
                        value = DirectFunctionCall1(time_timetz,
                                                    value);
                        break;
                    case TIMETZOID: /* Nothing to do for TIMETZ */
                        break;
                    case TIMESTAMPTZOID:
                        value = DirectFunctionCall1(timestamptz_timetz,
                                                    value);
                        break;
                    default:
                        elog(ERROR, "type with oid %u not supported", typid);
                }
 
                /* Force the user-given time precision, if any */
                if (time_precision != -1)
                {
                    TimeTzADT  *result;
 
                    /* Get a warning when precision is reduced */
                    time_precision = anytime_typmod_check(true,
                                                          time_precision);
                    result = DatumGetTimeTzADTP(value);
                    AdjustTimeForTypmod(&result->time, time_precision);
                    value = TimeTzADTPGetDatum(result);
 
                    /* Update the typmod value with the user-given precision */
                    typmod = time_precision;
                }
 
                typid = TIMETZOID;
            }
            break;
        case jpiTimestamp:
            {
                /* Convert result type to timestamp without time zone */
                switch (typid)
                {
                    case DATEOID:
                        value = DirectFunctionCall1(date_timestamp,
                                                    value);
                        break;
                    case TIMEOID:
                    case TIMETZOID:
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
                                              errmsg("%s format is not recognized: \"%s\"",
                                                     "timestamp", text_to_cstring(datetime)))));
                        break;
                    case TIMESTAMPOID:  /* Nothing to do for TIMESTAMP */
                        break;
                    case TIMESTAMPTZOID:
                        checkTimezoneIsUsedForCast(cxt->useTz,
                                                   "timestamptz", "timestamp");
                        value = DirectFunctionCall1(timestamptz_timestamp,
                                                    value);
                        break;
                    default:
                        elog(ERROR, "type with oid %u not supported", typid);
                }
 
                /* Force the user-given time precision, if any */
                if (time_precision != -1)
                {
                    Timestamp   result;
                    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
                    /* Get a warning when precision is reduced */
                    time_precision = anytimestamp_typmod_check(false,
                                                               time_precision);
                    result = DatumGetTimestamp(value);
                    AdjustTimestampForTypmod(&result, time_precision,
                                             (Node *) &escontext);
                    if (escontext.error_occurred)   /* should not happen */
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
                                              errmsg("time precision of jsonpath item method .%s() is invalid",
                                                     jspOperationName(jsp->type)))));
                    value = TimestampGetDatum(result);
 
                    /* Update the typmod value with the user-given precision */
                    typmod = time_precision;
                }
 
                typid = TIMESTAMPOID;
            }
            break;
        case jpiTimestampTz:
            {
                struct pg_tm tm;
                fsec_t      fsec;
 
                /* Convert result type to timestamp with time zone */
                switch (typid)
                {
                    case DATEOID:
                        checkTimezoneIsUsedForCast(cxt->useTz,
                                                   "date", "timestamptz");
 
                        /*
                         * Get the timezone value explicitly since JsonbValue
                         * keeps that separate.
                         */
                        j2date(DatumGetDateADT(value) + POSTGRES_EPOCH_JDATE,
                               &(tm.tm_year), &(tm.tm_mon), &(tm.tm_mday));
                        tm.tm_hour = 0;
                        tm.tm_min = 0;
                        tm.tm_sec = 0;
                        tz = DetermineTimeZoneOffset(&tm, session_timezone);
 
                        value = DirectFunctionCall1(date_timestamptz,
                                                    value);
                        break;
                    case TIMEOID:
                    case TIMETZOID:
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
                                              errmsg("%s format is not recognized: \"%s\"",
                                                     "timestamp_tz", text_to_cstring(datetime)))));
                        break;
                    case TIMESTAMPOID:
                        checkTimezoneIsUsedForCast(cxt->useTz,
                                                   "timestamp", "timestamptz");
 
                        /*
                         * Get the timezone value explicitly since JsonbValue
                         * keeps that separate.
                         */
                        if (timestamp2tm(DatumGetTimestamp(value), NULL, &tm,
                                         &fsec, NULL, NULL) == 0)
                            tz = DetermineTimeZoneOffset(&tm,
                                                         session_timezone);
 
                        value = DirectFunctionCall1(timestamp_timestamptz,
                                                    value);
                        break;
                    case TIMESTAMPTZOID:    /* Nothing to do for TIMESTAMPTZ */
                        break;
                    default:
                        elog(ERROR, "type with oid %u not supported", typid);
                }
 
                /* Force the user-given time precision, if any */
                if (time_precision != -1)
                {
                    Timestamp   result;
                    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
                    /* Get a warning when precision is reduced */
                    time_precision = anytimestamp_typmod_check(true,
                                                               time_precision);
                    result = DatumGetTimestampTz(value);
                    AdjustTimestampForTypmod(&result, time_precision,
                                             (Node *) &escontext);
                    if (escontext.error_occurred)   /* should not happen */
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
                                              errmsg("time precision of jsonpath item method .%s() is invalid",
                                                     jspOperationName(jsp->type)))));
                    value = TimestampTzGetDatum(result);
 
                    /* Update the typmod value with the user-given precision */
                    typmod = time_precision;
                }
 
                typid = TIMESTAMPTZOID;
            }
            break;
        default:
            elog(ERROR, "unrecognized jsonpath item type: %d", jsp->type);
    }
 
    pfree(datetime);
 
    if (jperIsError(res))
        return res;
 
    hasNext = jspGetNext(jsp, &elem);
 
    if (!hasNext && !found)
        return res;
 
    jb = hasNext ? &jbvbuf : palloc(sizeof(*jb));
 
    jb->type = jbvDatetime;
    jb->val.datetime.value = value;
    jb->val.datetime.typid = typid;
    jb->val.datetime.typmod = typmod;
    jb->val.datetime.tz = tz;
 
    return executeNextItem(cxt, jsp, &elem, jb, found, hasNext);
}

References AdjustTimeForTypmod(), AdjustTimestampForTypmod(), anytime_typmod_check(), anytimestamp_typmod_check(), JsonPathItem::arg, checkTimezoneIsUsedForCast(), collid, JsonPathItem::content, cstring_to_text(), cstring_to_text_with_len(), date_timestamp(), date_timestamptz(), DatumGetDateADT(), DatumGetTimeADT(), DatumGetTimestamp(), DatumGetTimestampTz(), DatumGetTimeTzADTP(), DetermineTimeZoneOffset(), DirectFunctionCall1, elog, ereport, errcode(), errhint(), errmsg(), ERROR, ErrorSaveContext::error_occurred, executeNextItem(), getScalar(), i, j2date(), jbvDatetime, jbvString, jperError, jperIsError, jperNotFound, jperOk, jpiDate, jpiDatetime, jpiNumeric, jpiString, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, jspGetArg(), jspGetNext(), jspGetNumeric(), jspGetString(), jspOperationName(), jspThrowErrors, lengthof, MemoryContextSwitchTo(), numeric_int4_opt_error(), palloc(), parse_datetime(), pfree(), POSTGRES_EPOCH_JDATE, RETURN_ERROR, session_timezone, text_to_cstring(), TimeTzADT::time, time_timetz(), TimeADTGetDatum(), timestamp2tm(), timestamp_date(), timestamp_time(), timestamp_timestamptz(), TimestampGetDatum(), timestamptz_date(), timestamptz_time(), timestamptz_timestamp(), timestamptz_timetz(), TimestampTzGetDatum(), timetz_time(), TimeTzADTPGetDatum(), tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, TopMemoryContext, JsonbValue::type, JsonPathItem::type, JsonPathExecContext::useTz, JsonbValue::val, and value.

Referenced by executeItemOptUnwrapTarget().

executeItem()

static JsonPathExecResult executeItem ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, JsonValueList *  found  )

static

Definition at line 733 of file jsonpath_exec.c.

{
    return executeItemOptUnwrapTarget(cxt, jsp, jb, found, jspAutoUnwrap(cxt));
}

References executeItemOptUnwrapTarget(), and jspAutoUnwrap.

Referenced by executeItemOptUnwrapResult(), executeJsonPath(), executeNextItem(), and getArrayIndex().

executeItemOptUnwrapResult()

static JsonPathExecResult executeItemOptUnwrapResult ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, bool  unwrap, JsonValueList *  found  )

static

Definition at line 1724 of file jsonpath_exec.c.

{
    if (unwrap && jspAutoUnwrap(cxt))
    {
        JsonValueList seq = {0};
        JsonValueListIterator it;
        JsonPathExecResult res = executeItem(cxt, jsp, jb, &seq);
        JsonbValue *item;
 
        if (jperIsError(res))
            return res;
 
        JsonValueListInitIterator(&seq, &it);
        while ((item = JsonValueListNext(&seq, &it)))
        {
            Assert(item->type != jbvArray);
 
            if (JsonbType(item) == jbvArray)
                executeItemUnwrapTargetArray(cxt, NULL, item, found, false);
            else
                JsonValueListAppend(found, item);
        }
 
        return jperOk;
    }
 
    return executeItem(cxt, jsp, jb, found);
}

References Assert(), executeItem(), executeItemUnwrapTargetArray(), jbvArray, jperIsError, jperOk, JsonbType(), JsonValueListAppend(), JsonValueListInitIterator(), JsonValueListNext(), jspAutoUnwrap, and JsonbValue::type.

Referenced by executeBinaryArithmExpr(), executeItemOptUnwrapResultNoThrow(), and executeUnaryArithmExpr().

executeItemOptUnwrapResultNoThrow()

static JsonPathExecResult executeItemOptUnwrapResultNoThrow ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, bool  unwrap, JsonValueList *  found  )

static

Definition at line 1759 of file jsonpath_exec.c.

{
    JsonPathExecResult res;
    bool        throwErrors = cxt->throwErrors;
 
    cxt->throwErrors = false;
    res = executeItemOptUnwrapResult(cxt, jsp, jb, unwrap, found);
    cxt->throwErrors = throwErrors;
 
    return res;
}

References executeItemOptUnwrapResult(), and JsonPathExecContext::throwErrors.

Referenced by executeBoolItem(), and executePredicate().

executeItemOptUnwrapTarget()

static JsonPathExecResult executeItemOptUnwrapTarget ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, JsonValueList *  found, bool  unwrap  )

static

Definition at line 745 of file jsonpath_exec.c.

{
    JsonPathItem elem;
    JsonPathExecResult res = jperNotFound;
    JsonBaseObjectInfo baseObject;
 
    check_stack_depth();
    CHECK_FOR_INTERRUPTS();
 
    switch (jsp->type)
    {
        case jpiNull:
        case jpiBool:
        case jpiNumeric:
        case jpiString:
        case jpiVariable:
            {
                JsonbValue  vbuf;
                JsonbValue *v;
                bool        hasNext = jspGetNext(jsp, &elem);
 
                if (!hasNext && !found && jsp->type != jpiVariable)
                {
                    /*
                     * Skip evaluation, but not for variables.  We must
                     * trigger an error for the missing variable.
                     */
                    res = jperOk;
                    break;
                }
 
                v = hasNext ? &vbuf : palloc(sizeof(*v));
 
                baseObject = cxt->baseObject;
                getJsonPathItem(cxt, jsp, v);
 
                res = executeNextItem(cxt, jsp, &elem,
                                      v, found, hasNext);
                cxt->baseObject = baseObject;
            }
            break;
 
            /* all boolean item types: */
        case jpiAnd:
        case jpiOr:
        case jpiNot:
        case jpiIsUnknown:
        case jpiEqual:
        case jpiNotEqual:
        case jpiLess:
        case jpiGreater:
        case jpiLessOrEqual:
        case jpiGreaterOrEqual:
        case jpiExists:
        case jpiStartsWith:
        case jpiLikeRegex:
            {
                JsonPathBool st = executeBoolItem(cxt, jsp, jb, true);
 
                res = appendBoolResult(cxt, jsp, found, st);
                break;
            }
 
        case jpiAdd:
            return executeBinaryArithmExpr(cxt, jsp, jb,
                                           numeric_add_opt_error, found);
 
        case jpiSub:
            return executeBinaryArithmExpr(cxt, jsp, jb,
                                           numeric_sub_opt_error, found);
 
        case jpiMul:
            return executeBinaryArithmExpr(cxt, jsp, jb,
                                           numeric_mul_opt_error, found);
 
        case jpiDiv:
            return executeBinaryArithmExpr(cxt, jsp, jb,
                                           numeric_div_opt_error, found);
 
        case jpiMod:
            return executeBinaryArithmExpr(cxt, jsp, jb,
                                           numeric_mod_opt_error, found);
 
        case jpiPlus:
            return executeUnaryArithmExpr(cxt, jsp, jb, NULL, found);
 
        case jpiMinus:
            return executeUnaryArithmExpr(cxt, jsp, jb, numeric_uminus,
                                          found);
 
        case jpiAnyArray:
            if (JsonbType(jb) == jbvArray)
            {
                bool        hasNext = jspGetNext(jsp, &elem);
 
                res = executeItemUnwrapTargetArray(cxt, hasNext ? &elem : NULL,
                                                   jb, found, jspAutoUnwrap(cxt));
            }
            else if (jspAutoWrap(cxt))
                res = executeNextItem(cxt, jsp, NULL, jb, found, true);
            else if (!jspIgnoreStructuralErrors(cxt))
                RETURN_ERROR(ereport(ERROR,
                                     (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),
                                      errmsg("jsonpath wildcard array accessor can only be applied to an array"))));
            break;
 
        case jpiAnyKey:
            if (JsonbType(jb) == jbvObject)
            {
                bool        hasNext = jspGetNext(jsp, &elem);
 
                if (jb->type != jbvBinary)
                    elog(ERROR, "invalid jsonb object type: %d", jb->type);
 
                return executeAnyItem
                    (cxt, hasNext ? &elem : NULL,
                     jb->val.binary.data, found, 1, 1, 1,
                     false, jspAutoUnwrap(cxt));
            }
            else if (unwrap && JsonbType(jb) == jbvArray)
                return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
            else if (!jspIgnoreStructuralErrors(cxt))
            {
                Assert(found);
                RETURN_ERROR(ereport(ERROR,
                                     (errcode(ERRCODE_SQL_JSON_OBJECT_NOT_FOUND),
                                      errmsg("jsonpath wildcard member accessor can only be applied to an object"))));
            }
            break;
 
        case jpiIndexArray:
            if (JsonbType(jb) == jbvArray || jspAutoWrap(cxt))
            {
                int         innermostArraySize = cxt->innermostArraySize;
                int         i;
                int         size = JsonbArraySize(jb);
                bool        singleton = size < 0;
                bool        hasNext = jspGetNext(jsp, &elem);
 
                if (singleton)
                    size = 1;
 
                cxt->innermostArraySize = size; /* for LAST evaluation */
 
                for (i = 0; i < jsp->content.array.nelems; i++)
                {
                    JsonPathItem from;
                    JsonPathItem to;
                    int32       index;
                    int32       index_from;
                    int32       index_to;
                    bool        range = jspGetArraySubscript(jsp, &from,
                                                             &to, i);
 
                    res = getArrayIndex(cxt, &from, jb, &index_from);
 
                    if (jperIsError(res))
                        break;
 
                    if (range)
                    {
                        res = getArrayIndex(cxt, &to, jb, &index_to);
 
                        if (jperIsError(res))
                            break;
                    }
                    else
                        index_to = index_from;
 
                    if (!jspIgnoreStructuralErrors(cxt) &&
                        (index_from < 0 ||
                         index_from > index_to ||
                         index_to >= size))
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
                                              errmsg("jsonpath array subscript is out of bounds"))));
 
                    if (index_from < 0)
                        index_from = 0;
 
                    if (index_to >= size)
                        index_to = size - 1;
 
                    res = jperNotFound;
 
                    for (index = index_from; index <= index_to; index++)
                    {
                        JsonbValue *v;
                        bool        copy;
 
                        if (singleton)
                        {
                            v = jb;
                            copy = true;
                        }
                        else
                        {
                            v = getIthJsonbValueFromContainer(jb->val.binary.data,
                                                              (uint32) index);
 
                            if (v == NULL)
                                continue;
 
                            copy = false;
                        }
 
                        if (!hasNext && !found)
                            return jperOk;
 
                        res = executeNextItem(cxt, jsp, &elem, v, found,
                                              copy);
 
                        if (jperIsError(res))
                            break;
 
                        if (res == jperOk && !found)
                            break;
                    }
 
                    if (jperIsError(res))
                        break;
 
                    if (res == jperOk && !found)
                        break;
                }
 
                cxt->innermostArraySize = innermostArraySize;
            }
            else if (!jspIgnoreStructuralErrors(cxt))
            {
                RETURN_ERROR(ereport(ERROR,
                                     (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),
                                      errmsg("jsonpath array accessor can only be applied to an array"))));
            }
            break;
 
        case jpiAny:
            {
                bool        hasNext = jspGetNext(jsp, &elem);
 
                /* first try without any intermediate steps */
                if (jsp->content.anybounds.first == 0)
                {
                    bool        savedIgnoreStructuralErrors;
 
                    savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors;
                    cxt->ignoreStructuralErrors = true;
                    res = executeNextItem(cxt, jsp, &elem,
                                          jb, found, true);
                    cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors;
 
                    if (res == jperOk && !found)
                        break;
                }
 
                if (jb->type == jbvBinary)
                    res = executeAnyItem
                        (cxt, hasNext ? &elem : NULL,
                         jb->val.binary.data, found,
                         1,
                         jsp->content.anybounds.first,
                         jsp->content.anybounds.last,
                         true, jspAutoUnwrap(cxt));
                break;
            }
 
        case jpiKey:
            if (JsonbType(jb) == jbvObject)
            {
                JsonbValue *v;
                JsonbValue  key;
 
                key.type = jbvString;
                key.val.string.val = jspGetString(jsp, &key.val.string.len);
 
                v = findJsonbValueFromContainer(jb->val.binary.data,
                                                JB_FOBJECT, &key);
 
                if (v != NULL)
                {
                    res = executeNextItem(cxt, jsp, NULL,
                                          v, found, false);
 
                    /* free value if it was not added to found list */
                    if (jspHasNext(jsp) || !found)
                        pfree(v);
                }
                else if (!jspIgnoreStructuralErrors(cxt))
                {
                    Assert(found);
 
                    if (!jspThrowErrors(cxt))
                        return jperError;
 
                    ereport(ERROR,
                            (errcode(ERRCODE_SQL_JSON_MEMBER_NOT_FOUND), \
                             errmsg("JSON object does not contain key \"%s\"",
                                    pnstrdup(key.val.string.val,
                                             key.val.string.len))));
                }
            }
            else if (unwrap && JsonbType(jb) == jbvArray)
                return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
            else if (!jspIgnoreStructuralErrors(cxt))
            {
                Assert(found);
                RETURN_ERROR(ereport(ERROR,
                                     (errcode(ERRCODE_SQL_JSON_MEMBER_NOT_FOUND),
                                      errmsg("jsonpath member accessor can only be applied to an object"))));
            }
            break;
 
        case jpiCurrent:
            res = executeNextItem(cxt, jsp, NULL, cxt->current,
                                  found, true);
            break;
 
        case jpiRoot:
            jb = cxt->root;
            baseObject = setBaseObject(cxt, jb, 0);
            res = executeNextItem(cxt, jsp, NULL, jb, found, true);
            cxt->baseObject = baseObject;
            break;
 
        case jpiFilter:
            {
                JsonPathBool st;
 
                if (unwrap && JsonbType(jb) == jbvArray)
                    return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
                                                        false);
 
                jspGetArg(jsp, &elem);
                st = executeNestedBoolItem(cxt, &elem, jb);
                if (st != jpbTrue)
                    res = jperNotFound;
                else
                    res = executeNextItem(cxt, jsp, NULL,
                                          jb, found, true);
                break;
            }
 
        case jpiType:
            {
                JsonbValue *jbv = palloc(sizeof(*jbv));
 
                jbv->type = jbvString;
                jbv->val.string.val = pstrdup(JsonbTypeName(jb));
                jbv->val.string.len = strlen(jbv->val.string.val);
 
                res = executeNextItem(cxt, jsp, NULL, jbv,
                                      found, false);
            }
            break;
 
        case jpiSize:
            {
                int         size = JsonbArraySize(jb);
 
                if (size < 0)
                {
                    if (!jspAutoWrap(cxt))
                    {
                        if (!jspIgnoreStructuralErrors(cxt))
                            RETURN_ERROR(ereport(ERROR,
                                                 (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),
                                                  errmsg("jsonpath item method .%s() can only be applied to an array",
                                                         jspOperationName(jsp->type)))));
                        break;
                    }
 
                    size = 1;
                }
 
                jb = palloc(sizeof(*jb));
 
                jb->type = jbvNumeric;
                jb->val.numeric = int64_to_numeric(size);
 
                res = executeNextItem(cxt, jsp, NULL, jb, found, false);
            }
            break;
 
        case jpiAbs:
            return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_abs,
                                            found);
 
        case jpiFloor:
            return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_floor,
                                            found);
 
        case jpiCeiling:
            return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_ceil,
                                            found);
 
        case jpiDouble:
            {
                JsonbValue  jbv;
 
                if (unwrap && JsonbType(jb) == jbvArray)
                    return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
                                                        false);
 
                if (jb->type == jbvNumeric)
                {
                    char       *tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
                                                                          NumericGetDatum(jb->val.numeric)));
                    double      val;
                    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
                    val = float8in_internal(tmp,
                                            NULL,
                                            "double precision",
                                            tmp,
                                            (Node *) &escontext);
 
                    if (escontext.error_occurred)
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
                                                     tmp, jspOperationName(jsp->type), "double precision"))));
                    if (isinf(val) || isnan(val))
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("NaN or Infinity is not allowed for jsonpath item method .%s()",
                                                     jspOperationName(jsp->type)))));
                    res = jperOk;
                }
                else if (jb->type == jbvString)
                {
                    /* cast string as double */
                    double      val;
                    char       *tmp = pnstrdup(jb->val.string.val,
                                               jb->val.string.len);
                    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
                    val = float8in_internal(tmp,
                                            NULL,
                                            "double precision",
                                            tmp,
                                            (Node *) &escontext);
 
                    if (escontext.error_occurred)
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
                                                     tmp, jspOperationName(jsp->type), "double precision"))));
                    if (isinf(val) || isnan(val))
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("NaN or Infinity is not allowed for jsonpath item method .%s()",
                                                     jspOperationName(jsp->type)))));
 
                    jb = &jbv;
                    jb->type = jbvNumeric;
                    jb->val.numeric = DatumGetNumeric(DirectFunctionCall1(float8_numeric,
                                                                          Float8GetDatum(val)));
                    res = jperOk;
                }
 
                if (res == jperNotFound)
                    RETURN_ERROR(ereport(ERROR,
                                         (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                          errmsg("jsonpath item method .%s() can only be applied to a string or numeric value",
                                                 jspOperationName(jsp->type)))));
 
                res = executeNextItem(cxt, jsp, NULL, jb, found, true);
            }
            break;
 
        case jpiDatetime:
        case jpiDate:
        case jpiTime:
        case jpiTimeTz:
        case jpiTimestamp:
        case jpiTimestampTz:
            if (unwrap && JsonbType(jb) == jbvArray)
                return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
 
            return executeDateTimeMethod(cxt, jsp, jb, found);
 
        case jpiKeyValue:
            if (unwrap && JsonbType(jb) == jbvArray)
                return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
 
            return executeKeyValueMethod(cxt, jsp, jb, found);
 
        case jpiLast:
            {
                JsonbValue  tmpjbv;
                JsonbValue *lastjbv;
                int         last;
                bool        hasNext = jspGetNext(jsp, &elem);
 
                if (cxt->innermostArraySize < 0)
                    elog(ERROR, "evaluating jsonpath LAST outside of array subscript");
 
                if (!hasNext && !found)
                {
                    res = jperOk;
                    break;
                }
 
                last = cxt->innermostArraySize - 1;
 
                lastjbv = hasNext ? &tmpjbv : palloc(sizeof(*lastjbv));
 
                lastjbv->type = jbvNumeric;
                lastjbv->val.numeric = int64_to_numeric(last);
 
                res = executeNextItem(cxt, jsp, &elem,
                                      lastjbv, found, hasNext);
            }
            break;
 
        case jpiBigint:
            {
                JsonbValue  jbv;
                Datum       datum;
 
                if (unwrap && JsonbType(jb) == jbvArray)
                    return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
                                                        false);
 
                if (jb->type == jbvNumeric)
                {
                    bool        have_error;
                    int64       val;
 
                    val = numeric_int8_opt_error(jb->val.numeric, &have_error);
                    if (have_error)
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
                                                     DatumGetCString(DirectFunctionCall1(numeric_out,
                                                                                         NumericGetDatum(jb->val.numeric))),
                                                     jspOperationName(jsp->type),
                                                     "bigint"))));
 
                    datum = Int64GetDatum(val);
                    res = jperOk;
                }
                else if (jb->type == jbvString)
                {
                    /* cast string as bigint */
                    char       *tmp = pnstrdup(jb->val.string.val,
                                               jb->val.string.len);
                    ErrorSaveContext escontext = {T_ErrorSaveContext};
                    bool        noerr;
 
                    noerr = DirectInputFunctionCallSafe(int8in, tmp,
                                                        InvalidOid, -1,
                                                        (Node *) &escontext,
                                                        &datum);
 
                    if (!noerr || escontext.error_occurred)
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
                                                     tmp, jspOperationName(jsp->type), "bigint"))));
                    res = jperOk;
                }
 
                if (res == jperNotFound)
                    RETURN_ERROR(ereport(ERROR,
                                         (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                          errmsg("jsonpath item method .%s() can only be applied to a string or numeric value",
                                                 jspOperationName(jsp->type)))));
 
                jb = &jbv;
                jb->type = jbvNumeric;
                jb->val.numeric = DatumGetNumeric(DirectFunctionCall1(int8_numeric,
                                                                      datum));
 
                res = executeNextItem(cxt, jsp, NULL, jb, found, true);
            }
            break;
 
        case jpiBoolean:
            {
                JsonbValue  jbv;
                bool        bval;
 
                if (unwrap && JsonbType(jb) == jbvArray)
                    return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
                                                        false);
 
                if (jb->type == jbvBool)
                {
                    bval = jb->val.boolean;
 
                    res = jperOk;
                }
                else if (jb->type == jbvNumeric)
                {
                    int         ival;
                    Datum       datum;
                    bool        noerr;
                    char       *tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
                                                                          NumericGetDatum(jb->val.numeric)));
                    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
                    noerr = DirectInputFunctionCallSafe(int4in, tmp,
                                                        InvalidOid, -1,
                                                        (Node *) &escontext,
                                                        &datum);
 
                    if (!noerr || escontext.error_occurred)
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
                                                     tmp, jspOperationName(jsp->type), "boolean"))));
 
                    ival = DatumGetInt32(datum);
                    if (ival == 0)
                        bval = false;
                    else
                        bval = true;
 
                    res = jperOk;
                }
                else if (jb->type == jbvString)
                {
                    /* cast string as boolean */
                    char       *tmp = pnstrdup(jb->val.string.val,
                                               jb->val.string.len);
 
                    if (!parse_bool(tmp, &bval))
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
                                                     tmp, jspOperationName(jsp->type), "boolean"))));
 
                    res = jperOk;
                }
 
                if (res == jperNotFound)
                    RETURN_ERROR(ereport(ERROR,
                                         (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                          errmsg("jsonpath item method .%s() can only be applied to a boolean, string, or numeric value",
                                                 jspOperationName(jsp->type)))));
 
                jb = &jbv;
                jb->type = jbvBool;
                jb->val.boolean = bval;
 
                res = executeNextItem(cxt, jsp, NULL, jb, found, true);
            }
            break;
 
        case jpiDecimal:
        case jpiNumber:
            {
                JsonbValue  jbv;
                Numeric     num;
                char       *numstr = NULL;
 
                if (unwrap && JsonbType(jb) == jbvArray)
                    return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
                                                        false);
 
                if (jb->type == jbvNumeric)
                {
                    num = jb->val.numeric;
                    if (numeric_is_nan(num) || numeric_is_inf(num))
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("NaN or Infinity is not allowed for jsonpath item method .%s()",
                                                     jspOperationName(jsp->type)))));
 
                    if (jsp->type == jpiDecimal)
                        numstr = DatumGetCString(DirectFunctionCall1(numeric_out,
                                                                     NumericGetDatum(num)));
                    res = jperOk;
                }
                else if (jb->type == jbvString)
                {
                    /* cast string as number */
                    Datum       datum;
                    bool        noerr;
                    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
                    numstr = pnstrdup(jb->val.string.val, jb->val.string.len);
 
                    noerr = DirectInputFunctionCallSafe(numeric_in, numstr,
                                                        InvalidOid, -1,
                                                        (Node *) &escontext,
                                                        &datum);
 
                    if (!noerr || escontext.error_occurred)
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
                                                     numstr, jspOperationName(jsp->type), "numeric"))));
 
                    num = DatumGetNumeric(datum);
                    if (numeric_is_nan(num) || numeric_is_inf(num))
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("NaN or Infinity is not allowed for jsonpath item method .%s()",
                                                     jspOperationName(jsp->type)))));
 
                    res = jperOk;
                }
 
                if (res == jperNotFound)
                    RETURN_ERROR(ereport(ERROR,
                                         (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                          errmsg("jsonpath item method .%s() can only be applied to a string or numeric value",
                                                 jspOperationName(jsp->type)))));
 
                /*
                 * If we have arguments, then they must be the precision and
                 * optional scale used in .decimal().  Convert them to the
                 * typmod equivalent and then truncate the numeric value per
                 * this typmod details.
                 */
                if (jsp->type == jpiDecimal && jsp->content.args.left)
                {
                    Datum       numdatum;
                    Datum       dtypmod;
                    int32       precision;
                    int32       scale = 0;
                    bool        have_error;
                    bool        noerr;
                    ArrayType  *arrtypmod;
                    Datum       datums[2];
                    char        pstr[12];   /* sign, 10 digits and '\0' */
                    char        sstr[12];   /* sign, 10 digits and '\0' */
                    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
                    jspGetLeftArg(jsp, &elem);
                    if (elem.type != jpiNumeric)
                        elog(ERROR, "invalid jsonpath item type for .decimal() precision");
 
                    precision = numeric_int4_opt_error(jspGetNumeric(&elem),
                                                       &have_error);
                    if (have_error)
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("precision of jsonpath item method .%s() is out of range for type integer",
                                                     jspOperationName(jsp->type)))));
 
                    if (jsp->content.args.right)
                    {
                        jspGetRightArg(jsp, &elem);
                        if (elem.type != jpiNumeric)
                            elog(ERROR, "invalid jsonpath item type for .decimal() scale");
 
                        scale = numeric_int4_opt_error(jspGetNumeric(&elem),
                                                       &have_error);
                        if (have_error)
                            RETURN_ERROR(ereport(ERROR,
                                                 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                                  errmsg("scale of jsonpath item method .%s() is out of range for type integer",
                                                         jspOperationName(jsp->type)))));
                    }
 
                    /*
                     * numerictypmodin() takes the precision and scale in the
                     * form of CString arrays.
                     */
                    pg_ltoa(precision, pstr);
                    datums[0] = CStringGetDatum(pstr);
                    pg_ltoa(scale, sstr);
                    datums[1] = CStringGetDatum(sstr);
                    arrtypmod = construct_array_builtin(datums, 2, CSTRINGOID);
 
                    dtypmod = DirectFunctionCall1(numerictypmodin,
                                                  PointerGetDatum(arrtypmod));
 
                    /* Convert numstr to Numeric with typmod */
                    Assert(numstr != NULL);
                    noerr = DirectInputFunctionCallSafe(numeric_in, numstr,
                                                        InvalidOid, dtypmod,
                                                        (Node *) &escontext,
                                                        &numdatum);
 
                    if (!noerr || escontext.error_occurred)
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
                                                     numstr, jspOperationName(jsp->type), "numeric"))));
 
                    num = DatumGetNumeric(numdatum);
                    pfree(arrtypmod);
                }
 
                jb = &jbv;
                jb->type = jbvNumeric;
                jb->val.numeric = num;
 
                res = executeNextItem(cxt, jsp, NULL, jb, found, true);
            }
            break;
 
        case jpiInteger:
            {
                JsonbValue  jbv;
                Datum       datum;
 
                if (unwrap && JsonbType(jb) == jbvArray)
                    return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
                                                        false);
 
                if (jb->type == jbvNumeric)
                {
                    bool        have_error;
                    int32       val;
 
                    val = numeric_int4_opt_error(jb->val.numeric, &have_error);
                    if (have_error)
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
                                                     DatumGetCString(DirectFunctionCall1(numeric_out,
                                                                                         NumericGetDatum(jb->val.numeric))),
                                                     jspOperationName(jsp->type), "integer"))));
 
                    datum = Int32GetDatum(val);
                    res = jperOk;
                }
                else if (jb->type == jbvString)
                {
                    /* cast string as integer */
                    char       *tmp = pnstrdup(jb->val.string.val,
                                               jb->val.string.len);
                    ErrorSaveContext escontext = {T_ErrorSaveContext};
                    bool        noerr;
 
                    noerr = DirectInputFunctionCallSafe(int4in, tmp,
                                                        InvalidOid, -1,
                                                        (Node *) &escontext,
                                                        &datum);
 
                    if (!noerr || escontext.error_occurred)
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
                                                     tmp, jspOperationName(jsp->type), "integer"))));
                    res = jperOk;
                }
 
                if (res == jperNotFound)
                    RETURN_ERROR(ereport(ERROR,
                                         (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                          errmsg("jsonpath item method .%s() can only be applied to a string or numeric value",
                                                 jspOperationName(jsp->type)))));
 
                jb = &jbv;
                jb->type = jbvNumeric;
                jb->val.numeric = DatumGetNumeric(DirectFunctionCall1(int4_numeric,
                                                                      datum));
 
                res = executeNextItem(cxt, jsp, NULL, jb, found, true);
            }
            break;
 
        case jpiStringFunc:
            {
                JsonbValue  jbv;
                char       *tmp = NULL;
 
                if (unwrap && JsonbType(jb) == jbvArray)
                    return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
 
                switch (JsonbType(jb))
                {
                    case jbvString:
 
                        /*
                         * Value is not necessarily null-terminated, so we do
                         * pnstrdup() here.
                         */
                        tmp = pnstrdup(jb->val.string.val,
                                       jb->val.string.len);
                        break;
                    case jbvNumeric:
                        tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
                                                                  NumericGetDatum(jb->val.numeric)));
                        break;
                    case jbvBool:
                        tmp = (jb->val.boolean) ? "true" : "false";
                        break;
                    case jbvDatetime:
                        {
                            char        buf[MAXDATELEN + 1];
 
                            JsonEncodeDateTime(buf,
                                               jb->val.datetime.value,
                                               jb->val.datetime.typid,
                                               &jb->val.datetime.tz);
                            tmp = pstrdup(buf);
                        }
                        break;
                    case jbvNull:
                    case jbvArray:
                    case jbvObject:
                    case jbvBinary:
                        RETURN_ERROR(ereport(ERROR,
                                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                                              errmsg("jsonpath item method .%s() can only be applied to a boolean, string, numeric, or datetime value",
                                                     jspOperationName(jsp->type)))));
                        break;
                }
 
                jb = &jbv;
                Assert(tmp != NULL);    /* We must have set tmp above */
                jb->val.string.val = tmp;
                jb->val.string.len = strlen(jb->val.string.val);
                jb->type = jbvString;
 
                res = executeNextItem(cxt, jsp, NULL, jb, found, true);
            }
            break;
 
        default:
            elog(ERROR, "unrecognized jsonpath item type: %d", jsp->type);
    }
 
    return res;
}

References JsonPathItem::anybounds, appendBoolResult(), JsonPathItem::args, JsonPathItem::array, Assert(), JsonPathExecContext::baseObject, buf, CHECK_FOR_INTERRUPTS, check_stack_depth(), construct_array_builtin(), JsonPathItem::content, CStringGetDatum(), JsonPathExecContext::current, DatumGetCString(), DatumGetInt32(), DatumGetNumeric(), DirectFunctionCall1, DirectInputFunctionCallSafe(), elog, ereport, errcode(), errmsg(), ERROR, ErrorSaveContext::error_occurred, executeAnyItem(), executeBinaryArithmExpr(), executeBoolItem(), executeDateTimeMethod(), executeItemUnwrapTargetArray(), executeKeyValueMethod(), executeNestedBoolItem(), executeNextItem(), executeNumericItemMethod(), executeUnaryArithmExpr(), findJsonbValueFromContainer(), JsonPathItem::first, float8_numeric(), Float8GetDatum(), float8in_internal(), getArrayIndex(), getIthJsonbValueFromContainer(), getJsonPathItem(), i, JsonPathExecContext::ignoreStructuralErrors, JsonPathExecContext::innermostArraySize, Int32GetDatum(), int4_numeric(), int4in(), int64_to_numeric(), Int64GetDatum(), int8_numeric(), int8in(), InvalidOid, JB_FOBJECT, jbvArray, jbvBinary, jbvBool, jbvDatetime, jbvNull, jbvNumeric, jbvObject, jbvString, jpbTrue, jperError, jperIsError, jperNotFound, jperOk, jpiAbs, jpiAdd, jpiAnd, jpiAny, jpiAnyArray, jpiAnyKey, jpiBigint, jpiBool, jpiBoolean, jpiCeiling, jpiCurrent, jpiDate, jpiDatetime, jpiDecimal, jpiDiv, jpiDouble, jpiEqual, jpiExists, jpiFilter, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiIndexArray, jpiInteger, jpiIsUnknown, jpiKey, jpiKeyValue, jpiLast, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumber, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiString, jpiStringFunc, jpiSub, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, jpiType, jpiVariable, JsonbArraySize(), JsonbType(), JsonbTypeName(), JsonEncodeDateTime(), jspAutoUnwrap, jspAutoWrap, jspGetArg(), jspGetArraySubscript(), jspGetLeftArg(), jspGetNext(), jspGetNumeric(), jspGetRightArg(), jspGetString(), jspHasNext, jspIgnoreStructuralErrors, jspOperationName(), jspThrowErrors, sort-test::key, JsonPathItem::last, JsonPathItem::left, MAXDATELEN, JsonPathItem::nelems, numeric_abs(), numeric_add_opt_error(), numeric_ceil(), numeric_div_opt_error(), numeric_floor(), numeric_in(), numeric_int4_opt_error(), numeric_int8_opt_error(), numeric_is_inf(), numeric_is_nan(), numeric_mod_opt_error(), numeric_mul_opt_error(), numeric_out(), numeric_sub_opt_error(), numeric_uminus(), NumericGetDatum(), numerictypmodin(), palloc(), parse_bool(), pfree(), pg_ltoa(), pnstrdup(), PointerGetDatum(), pstrdup(), range(), RETURN_ERROR, JsonPathItem::right, JsonPathExecContext::root, scale, setBaseObject(), JsonbValue::type, JsonPathItem::type, JsonbValue::val, and val.

Referenced by executeAnyItem(), and executeItem().

executeItemUnwrapTargetArray()

static JsonPathExecResult executeItemUnwrapTargetArray ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, JsonValueList *  found, bool  unwrapElements  )

static

Definition at line 1673 of file jsonpath_exec.c.

{
    if (jb->type != jbvBinary)
    {
        Assert(jb->type != jbvArray);
        elog(ERROR, "invalid jsonb array value type: %d", jb->type);
    }
 
    return executeAnyItem
        (cxt, jsp, jb->val.binary.data, found, 1, 1, 1,
         false, unwrapElements);
}

References Assert(), elog, ERROR, executeAnyItem(), jbvArray, jbvBinary, JsonbValue::type, and JsonbValue::val.

Referenced by executeItemOptUnwrapResult(), executeItemOptUnwrapTarget(), and executeNumericItemMethod().

executeJsonPath()

static JsonPathExecResult executeJsonPath ( JsonPath *  path, void *  vars, JsonPathGetVarCallback  getVar, JsonPathCountVarsCallback  countVars, Jsonb *  json, bool  throwErrors, JsonValueList *  result, bool  useTz  )

static

Definition at line 677 of file jsonpath_exec.c.

{
    JsonPathExecContext cxt;
    JsonPathExecResult res;
    JsonPathItem jsp;
    JsonbValue  jbv;
 
    jspInit(&jsp, path);
 
    if (!JsonbExtractScalar(&json->root, &jbv))
        JsonbInitBinary(&jbv, json);
 
    cxt.vars = vars;
    cxt.getVar = getVar;
    cxt.laxMode = (path->header & JSONPATH_LAX) != 0;
    cxt.ignoreStructuralErrors = cxt.laxMode;
    cxt.root = &jbv;
    cxt.current = &jbv;
    cxt.baseObject.jbc = NULL;
    cxt.baseObject.id = 0;
    /* 1 + number of base objects in vars */
    cxt.lastGeneratedObjectId = 1 + countVars(vars);
    cxt.innermostArraySize = -1;
    cxt.throwErrors = throwErrors;
    cxt.useTz = useTz;
 
    if (jspStrictAbsenceOfErrors(&cxt) && !result)
    {
        /*
         * In strict mode we must get a complete list of values to check that
         * there are no errors at all.
         */
        JsonValueList vals = {0};
 
        res = executeItem(&cxt, &jsp, &jbv, &vals);
 
        if (jperIsError(res))
            return res;
 
        return JsonValueListIsEmpty(&vals) ? jperNotFound : jperOk;
    }
 
    res = executeItem(&cxt, &jsp, &jbv, result);
 
    Assert(!throwErrors || !jperIsError(res));
 
    return res;
}

References Assert(), JsonPathExecContext::baseObject, JsonPathExecContext::current, executeItem(), JsonPathExecContext::getVar, JsonPath::header, JsonBaseObjectInfo::id, JsonPathExecContext::ignoreStructuralErrors, JsonPathExecContext::innermostArraySize, JsonBaseObjectInfo::jbc, jperIsError, jperNotFound, jperOk, JsonbExtractScalar(), JsonbInitBinary(), JSONPATH_LAX, JsonValueListIsEmpty(), jspInit(), jspStrictAbsenceOfErrors, JsonPathExecContext::lastGeneratedObjectId, JsonPathExecContext::laxMode, JsonPathExecContext::root, Jsonb::root, JsonPathExecContext::throwErrors, JsonPathExecContext::useTz, and JsonPathExecContext::vars.

Referenced by jsonb_path_exists_internal(), jsonb_path_match_internal(), jsonb_path_query_array_internal(), jsonb_path_query_first_internal(), jsonb_path_query_internal(), JsonPathExists(), JsonPathQuery(), JsonPathValue(), and JsonTableResetRowPattern().

executeKeyValueMethod()

static JsonPathExecResult executeKeyValueMethod ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, JsonValueList *  found  )

static

Definition at line 2819 of file jsonpath_exec.c.

{
    JsonPathExecResult res = jperNotFound;
    JsonPathItem next;
    JsonbContainer *jbc;
    JsonbValue  key;
    JsonbValue  val;
    JsonbValue  idval;
    JsonbValue  keystr;
    JsonbValue  valstr;
    JsonbValue  idstr;
    JsonbIterator *it;
    JsonbIteratorToken tok;
    int64       id;
    bool        hasNext;
 
    if (JsonbType(jb) != jbvObject || jb->type != jbvBinary)
        RETURN_ERROR(ereport(ERROR,
                             (errcode(ERRCODE_SQL_JSON_OBJECT_NOT_FOUND),
                              errmsg("jsonpath item method .%s() can only be applied to an object",
                                     jspOperationName(jsp->type)))));
 
    jbc = jb->val.binary.data;
 
    if (!JsonContainerSize(jbc))
        return jperNotFound;    /* no key-value pairs */
 
    hasNext = jspGetNext(jsp, &next);
 
    keystr.type = jbvString;
    keystr.val.string.val = "key";
    keystr.val.string.len = 3;
 
    valstr.type = jbvString;
    valstr.val.string.val = "value";
    valstr.val.string.len = 5;
 
    idstr.type = jbvString;
    idstr.val.string.val = "id";
    idstr.val.string.len = 2;
 
    /* construct object id from its base object and offset inside that */
    id = jb->type != jbvBinary ? 0 :
        (int64) ((char *) jbc - (char *) cxt->baseObject.jbc);
    id += (int64) cxt->baseObject.id * INT64CONST(10000000000);
 
    idval.type = jbvNumeric;
    idval.val.numeric = int64_to_numeric(id);
 
    it = JsonbIteratorInit(jbc);
 
    while ((tok = JsonbIteratorNext(&it, &key, true)) != WJB_DONE)
    {
        JsonBaseObjectInfo baseObject;
        JsonbValue  obj;
        JsonbParseState *ps;
        JsonbValue *keyval;
        Jsonb      *jsonb;
 
        if (tok != WJB_KEY)
            continue;
 
        res = jperOk;
 
        if (!hasNext && !found)
            break;
 
        tok = JsonbIteratorNext(&it, &val, true);
        Assert(tok == WJB_VALUE);
 
        ps = NULL;
        pushJsonbValue(&ps, WJB_BEGIN_OBJECT, NULL);
 
        pushJsonbValue(&ps, WJB_KEY, &keystr);
        pushJsonbValue(&ps, WJB_VALUE, &key);
 
        pushJsonbValue(&ps, WJB_KEY, &valstr);
        pushJsonbValue(&ps, WJB_VALUE, &val);
 
        pushJsonbValue(&ps, WJB_KEY, &idstr);
        pushJsonbValue(&ps, WJB_VALUE, &idval);
 
        keyval = pushJsonbValue(&ps, WJB_END_OBJECT, NULL);
 
        jsonb = JsonbValueToJsonb(keyval);
 
        JsonbInitBinary(&obj, jsonb);
 
        baseObject = setBaseObject(cxt, &obj, cxt->lastGeneratedObjectId++);
 
        res = executeNextItem(cxt, jsp, &next, &obj, found, true);
 
        cxt->baseObject = baseObject;
 
        if (jperIsError(res))
            return res;
 
        if (res == jperOk && !found)
            break;
    }
 
    return res;
}

References Assert(), JsonPathExecContext::baseObject, ereport, errcode(), errmsg(), ERROR, executeNextItem(), JsonBaseObjectInfo::id, int64_to_numeric(), INT64CONST, JsonBaseObjectInfo::jbc, jbvBinary, jbvNumeric, jbvObject, jbvString, jperIsError, jperNotFound, jperOk, JsonbInitBinary(), JsonbIteratorInit(), JsonbIteratorNext(), JsonbType(), JsonbValueToJsonb(), JsonContainerSize, jspGetNext(), jspOperationName(), sort-test::key, JsonPathExecContext::lastGeneratedObjectId, next, ps, pushJsonbValue(), RETURN_ERROR, setBaseObject(), JsonbValue::type, JsonPathItem::type, JsonbValue::val, val, WJB_BEGIN_OBJECT, WJB_DONE, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

Referenced by executeItemOptUnwrapTarget().

executeLikeRegex()

static JsonPathBool executeLikeRegex ( JsonPathItem *  jsp, JsonbValue *  str, JsonbValue *  rarg, void *  param  )

static

Definition at line 2266 of file jsonpath_exec.c.

{
    JsonLikeRegexContext *cxt = param;
 
    if (!(str = getScalar(str, jbvString)))
        return jpbUnknown;
 
    /* Cache regex text and converted flags. */
    if (!cxt->regex)
    {
        cxt->regex =
            cstring_to_text_with_len(jsp->content.like_regex.pattern,
                                     jsp->content.like_regex.patternlen);
        (void) jspConvertRegexFlags(jsp->content.like_regex.flags,
                                    &(cxt->cflags), NULL);
    }
 
    if (RE_compile_and_execute(cxt->regex, str->val.string.val,
                               str->val.string.len,
                               cxt->cflags, DEFAULT_COLLATION_OID, 0, NULL))
        return jpbTrue;
 
    return jpbFalse;
}

References JsonLikeRegexContext::cflags, JsonPathItem::content, cstring_to_text_with_len(), JsonPathItem::flags, getScalar(), jbvString, jpbFalse, jpbTrue, jpbUnknown, jspConvertRegexFlags(), JsonPathItem::like_regex, JsonPathItem::pattern, JsonPathItem::patternlen, RE_compile_and_execute(), JsonLikeRegexContext::regex, and str.

Referenced by executeBoolItem().

executeNestedBoolItem()

static JsonPathBool executeNestedBoolItem ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb  )

static

Definition at line 1912 of file jsonpath_exec.c.

{
    JsonbValue *prev;
    JsonPathBool res;
 
    prev = cxt->current;
    cxt->current = jb;
    res = executeBoolItem(cxt, jsp, jb, false);
    cxt->current = prev;
 
    return res;
}

References JsonPathExecContext::current, and executeBoolItem().

Referenced by executeItemOptUnwrapTarget().

executeNextItem()

static JsonPathExecResult executeNextItem ( JsonPathExecContext *  cxt, JsonPathItem *  cur, JsonPathItem *  next, JsonbValue *  v, JsonValueList *  found, bool  copy  )

static

Definition at line 1693 of file jsonpath_exec.c.

{
    JsonPathItem elem;
    bool        hasNext;
 
    if (!cur)
        hasNext = next != NULL;
    else if (next)
        hasNext = jspHasNext(cur);
    else
    {
        next = &elem;
        hasNext = jspGetNext(cur, next);
    }
 
    if (hasNext)
        return executeItem(cxt, next, v, found);
 
    if (found)
        JsonValueListAppend(found, copy ? copyJsonbValue(v) : v);
 
    return jperOk;
}

References copyJsonbValue(), cur, executeItem(), jperOk, JsonValueListAppend(), jspGetNext(), jspHasNext, and next.

Referenced by appendBoolResult(), executeBinaryArithmExpr(), executeDateTimeMethod(), executeItemOptUnwrapTarget(), executeKeyValueMethod(), executeNumericItemMethod(), and executeUnaryArithmExpr().

executeNumericItemMethod()

static JsonPathExecResult executeNumericItemMethod ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, bool  unwrap, PGFunction  func, JsonValueList *  found  )

static

Definition at line 2297 of file jsonpath_exec.c.

{
    JsonPathItem next;
    Datum       datum;
 
    if (unwrap && JsonbType(jb) == jbvArray)
        return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
 
    if (!(jb = getScalar(jb, jbvNumeric)))
        RETURN_ERROR(ereport(ERROR,
                             (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
                              errmsg("jsonpath item method .%s() can only be applied to a numeric value",
                                     jspOperationName(jsp->type)))));
 
    datum = DirectFunctionCall1(func, NumericGetDatum(jb->val.numeric));
 
    if (!jspGetNext(jsp, &next) && !found)
        return jperOk;
 
    jb = palloc(sizeof(*jb));
    jb->type = jbvNumeric;
    jb->val.numeric = DatumGetNumeric(datum);
 
    return executeNextItem(cxt, jsp, &next, jb, found, false);
}

References DatumGetNumeric(), DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, executeItemUnwrapTargetArray(), executeNextItem(), getScalar(), jbvArray, jbvNumeric, jperOk, JsonbType(), jspGetNext(), jspOperationName(), next, NumericGetDatum(), palloc(), RETURN_ERROR, JsonbValue::type, JsonPathItem::type, and JsonbValue::val.

Referenced by executeItemOptUnwrapTarget().

executePredicate()

static JsonPathBool executePredicate ( JsonPathExecContext *  cxt, JsonPathItem *  pred, JsonPathItem *  larg, JsonPathItem *  rarg, JsonbValue *  jb, bool  unwrapRightArg, JsonPathPredicateCallback  exec, void *  param  )

static

Definition at line 2024 of file jsonpath_exec.c.

{
    JsonPathExecResult res;
    JsonValueListIterator lseqit;
    JsonValueList lseq = {0};
    JsonValueList rseq = {0};
    JsonbValue *lval;
    bool        error = false;
    bool        found = false;
 
    /* Left argument is always auto-unwrapped. */
    res = executeItemOptUnwrapResultNoThrow(cxt, larg, jb, true, &lseq);
    if (jperIsError(res))
        return jpbUnknown;
 
    if (rarg)
    {
        /* Right argument is conditionally auto-unwrapped. */
        res = executeItemOptUnwrapResultNoThrow(cxt, rarg, jb,
                                                unwrapRightArg, &rseq);
        if (jperIsError(res))
            return jpbUnknown;
    }
 
    JsonValueListInitIterator(&lseq, &lseqit);
    while ((lval = JsonValueListNext(&lseq, &lseqit)))
    {
        JsonValueListIterator rseqit;
        JsonbValue *rval;
        bool        first = true;
 
        JsonValueListInitIterator(&rseq, &rseqit);
        if (rarg)
            rval = JsonValueListNext(&rseq, &rseqit);
        else
            rval = NULL;
 
        /* Loop over right arg sequence or do single pass otherwise */
        while (rarg ? (rval != NULL) : first)
        {
            JsonPathBool res = exec(pred, lval, rval, param);
 
            if (res == jpbUnknown)
            {
                if (jspStrictAbsenceOfErrors(cxt))
                    return jpbUnknown;
 
                error = true;
            }
            else if (res == jpbTrue)
            {
                if (!jspStrictAbsenceOfErrors(cxt))
                    return jpbTrue;
 
                found = true;
            }
 
            first = false;
            if (rarg)
                rval = JsonValueListNext(&rseq, &rseqit);
        }
    }
 
    if (found)                  /* possible only in strict mode */
        return jpbTrue;
 
    if (error)                  /* possible only in lax mode */
        return jpbUnknown;
 
    return jpbFalse;
}

References error(), executeItemOptUnwrapResultNoThrow(), jpbFalse, jpbTrue, jpbUnknown, jperIsError, JsonValueListInitIterator(), JsonValueListNext(), and jspStrictAbsenceOfErrors.

Referenced by executeBoolItem().

executeStartsWith()

static JsonPathBool executeStartsWith ( JsonPathItem *  jsp, JsonbValue *  whole, JsonbValue *  initial, void *  param  )

static

Definition at line 2242 of file jsonpath_exec.c.

{
    if (!(whole = getScalar(whole, jbvString)))
        return jpbUnknown;      /* error */
 
    if (!(initial = getScalar(initial, jbvString)))
        return jpbUnknown;      /* error */
 
    if (whole->val.string.len >= initial->val.string.len &&
        !memcmp(whole->val.string.val,
                initial->val.string.val,
                initial->val.string.len))
        return jpbTrue;
 
    return jpbFalse;
}

References getScalar(), jbvString, jpbFalse, jpbTrue, jpbUnknown, and JsonbValue::val.

Referenced by executeBoolItem().

executeUnaryArithmExpr()

static JsonPathExecResult executeUnaryArithmExpr ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, PGFunction  func, JsonValueList *  found  )

static

Definition at line 2175 of file jsonpath_exec.c.

{
    JsonPathExecResult jper;
    JsonPathExecResult jper2;
    JsonPathItem elem;
    JsonValueList seq = {0};
    JsonValueListIterator it;
    JsonbValue *val;
    bool        hasNext;
 
    jspGetArg(jsp, &elem);
    jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &seq);
 
    if (jperIsError(jper))
        return jper;
 
    jper = jperNotFound;
 
    hasNext = jspGetNext(jsp, &elem);
 
    JsonValueListInitIterator(&seq, &it);
    while ((val = JsonValueListNext(&seq, &it)))
    {
        if ((val = getScalar(val, jbvNumeric)))
        {
            if (!found && !hasNext)
                return jperOk;
        }
        else
        {
            if (!found && !hasNext)
                continue;       /* skip non-numerics processing */
 
            RETURN_ERROR(ereport(ERROR,
                                 (errcode(ERRCODE_SQL_JSON_NUMBER_NOT_FOUND),
                                  errmsg("operand of unary jsonpath operator %s is not a numeric value",
                                         jspOperationName(jsp->type)))));
        }
 
        if (func)
            val->val.numeric =
                DatumGetNumeric(DirectFunctionCall1(func,
                                                    NumericGetDatum(val->val.numeric)));
 
        jper2 = executeNextItem(cxt, jsp, &elem, val, found, false);
 
        if (jperIsError(jper2))
            return jper2;
 
        if (jper2 == jperOk)
        {
            if (!found)
                return jperOk;
            jper = jperOk;
        }
    }
 
    return jper;
}

References DatumGetNumeric(), DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, executeItemOptUnwrapResult(), executeNextItem(), getScalar(), jbvNumeric, jperIsError, jperNotFound, jperOk, JsonValueListInitIterator(), JsonValueListNext(), jspGetArg(), jspGetNext(), jspOperationName(), NumericGetDatum(), RETURN_ERROR, JsonPathItem::type, and val.

Referenced by executeItemOptUnwrapTarget().

getArrayIndex()

static JsonPathExecResult getArrayIndex ( JsonPathExecContext *  cxt, JsonPathItem *  jsp, JsonbValue *  jb, int32 *  index  )

static

Definition at line 3458 of file jsonpath_exec.c.

{
    JsonbValue *jbv;
    JsonValueList found = {0};
    JsonPathExecResult res = executeItem(cxt, jsp, jb, &found);
    Datum       numeric_index;
    bool        have_error = false;
 
    if (jperIsError(res))
        return res;
 
    if (JsonValueListLength(&found) != 1 ||
        !(jbv = getScalar(JsonValueListHead(&found), jbvNumeric)))
        RETURN_ERROR(ereport(ERROR,
                             (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
                              errmsg("jsonpath array subscript is not a single numeric value"))));
 
    numeric_index = DirectFunctionCall2(numeric_trunc,
                                        NumericGetDatum(jbv->val.numeric),
                                        Int32GetDatum(0));
 
    *index = numeric_int4_opt_error(DatumGetNumeric(numeric_index),
                                    &have_error);
 
    if (have_error)
        RETURN_ERROR(ereport(ERROR,
                             (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
                              errmsg("jsonpath array subscript is out of integer range"))));
 
    return jperOk;
}

References DatumGetNumeric(), DirectFunctionCall2, ereport, errcode(), errmsg(), ERROR, executeItem(), getScalar(), Int32GetDatum(), jbvNumeric, jperIsError, jperOk, JsonValueListHead(), JsonValueListLength(), numeric_int4_opt_error(), numeric_trunc(), NumericGetDatum(), RETURN_ERROR, and JsonbValue::val.

Referenced by executeItemOptUnwrapTarget().

getJsonPathItem()

static void getJsonPathItem ( JsonPathExecContext *  cxt, JsonPathItem *  item, JsonbValue *  value  )

static

Definition at line 2957 of file jsonpath_exec.c.

{
    switch (item->type)
    {
        case jpiNull:
            value->type = jbvNull;
            break;
        case jpiBool:
            value->type = jbvBool;
            value->val.boolean = jspGetBool(item);
            break;
        case jpiNumeric:
            value->type = jbvNumeric;
            value->val.numeric = jspGetNumeric(item);
            break;
        case jpiString:
            value->type = jbvString;
            value->val.string.val = jspGetString(item,
                                                 &value->val.string.len);
            break;
        case jpiVariable:
            getJsonPathVariable(cxt, item, value);
            return;
        default:
            elog(ERROR, "unexpected jsonpath item type");
    }
}

References elog, ERROR, getJsonPathVariable(), jbvBool, jbvNull, jbvNumeric, jbvString, jpiBool, jpiNull, jpiNumeric, jpiString, jpiVariable, jspGetBool(), jspGetNumeric(), jspGetString(), JsonPathItem::type, and value.

Referenced by executeItemOptUnwrapTarget().

GetJsonPathVar()

static JsonbValue * GetJsonPathVar ( void *  cxt, char *  varName, int  varNameLen, JsonbValue *  baseObject, int *  baseObjectId  )

static

Definition at line 2990 of file jsonpath_exec.c.

{
    JsonPathVariable *var = NULL;
    List       *vars = cxt;
    ListCell   *lc;
    JsonbValue *result;
    int         id = 1;
 
    foreach(lc, vars)
    {
        JsonPathVariable *curvar = lfirst(lc);
 
        if (curvar->namelen == varNameLen &&
            strncmp(curvar->name, varName, varNameLen) == 0)
        {
            var = curvar;
            break;
        }
 
        id++;
    }
 
    if (var == NULL)
    {
        *baseObjectId = -1;
        return NULL;
    }
 
    result = palloc(sizeof(JsonbValue));
    if (var->isnull)
    {
        *baseObjectId = 0;
        result->type = jbvNull;
    }
    else
        JsonItemFromDatum(var->value, var->typid, var->typmod, result);
 
    *baseObject = *result;
    *baseObjectId = id;
 
    return result;
}

References JsonPathVariable::isnull, jbvNull, JsonItemFromDatum(), lfirst, JsonPathVariable::name, JsonPathVariable::namelen, palloc(), JsonbValue::type, JsonPathVariable::typid, JsonPathVariable::typmod, and JsonPathVariable::value.

Referenced by JsonPathExists(), JsonPathQuery(), JsonPathValue(), and JsonTableResetRowPattern().

getJsonPathVariable()

static void getJsonPathVariable ( JsonPathExecContext *  cxt, JsonPathItem *  variable, JsonbValue *  value  )

static

Definition at line 3140 of file jsonpath_exec.c.

{
    char       *varName;
    int         varNameLength;
    JsonbValue  baseObject;
    int         baseObjectId;
    JsonbValue *v;
 
    Assert(variable->type == jpiVariable);
    varName = jspGetString(variable, &varNameLength);
 
    if (cxt->vars == NULL ||
        (v = cxt->getVar(cxt->vars, varName, varNameLength,
                         &baseObject, &baseObjectId)) == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("could not find jsonpath variable \"%s\"",
                        pnstrdup(varName, varNameLength))));
 
    if (baseObjectId > 0)
    {
        *value = *v;
        setBaseObject(cxt, &baseObject, baseObjectId);
    }
}

References Assert(), ereport, errcode(), errmsg(), ERROR, JsonPathExecContext::getVar, jpiVariable, jspGetString(), pnstrdup(), setBaseObject(), variable::type, value, and JsonPathExecContext::vars.

Referenced by getJsonPathItem().

getJsonPathVariableFromJsonb()

static JsonbValue * getJsonPathVariableFromJsonb ( void *  varsJsonb, char *  varName, int  varNameLength, JsonbValue *  baseObject, int *  baseObjectId  )

static

Definition at line 3172 of file jsonpath_exec.c.

{
    Jsonb      *vars = varsJsonb;
    JsonbValue  tmp;
    JsonbValue *result;
 
    tmp.type = jbvString;
    tmp.val.string.val = varName;
    tmp.val.string.len = varNameLength;
 
    result = findJsonbValueFromContainer(&vars->root, JB_FOBJECT, &tmp);
 
    if (result == NULL)
    {
        *baseObjectId = -1;
        return NULL;
    }
 
    *baseObjectId = 1;
    JsonbInitBinary(baseObject, vars);
 
    return result;
}

References findJsonbValueFromContainer(), JB_FOBJECT, jbvString, JsonbInitBinary(), JsonbValue::type, and JsonbValue::val.

Referenced by jsonb_path_exists_internal(), jsonb_path_match_internal(), jsonb_path_query_array_internal(), jsonb_path_query_first_internal(), and jsonb_path_query_internal().

GetJsonTableExecContext()

static JsonTableExecContext * GetJsonTableExecContext ( TableFuncScanState *  state, const char *  fname  )

inlinestatic

Definition at line 4089 of file jsonpath_exec.c.

{
    JsonTableExecContext *result;
 
    if (!IsA(state, TableFuncScanState))
        elog(ERROR, "%s called with invalid TableFuncScanState", fname);
    result = (JsonTableExecContext *) state->opaque;
    if (result->magic != JSON_TABLE_EXEC_CONTEXT_MAGIC)
        elog(ERROR, "%s called with invalid TableFuncScanState", fname);
 
    return result;
}

References elog, ERROR, if(), IsA, JSON_TABLE_EXEC_CONTEXT_MAGIC, and JsonTableExecContext::magic.

Referenced by JsonTableDestroyOpaque(), JsonTableFetchRow(), JsonTableGetValue(), and JsonTableSetDocument().

getScalar()

static JsonbValue * getScalar ( JsonbValue *  scalar, enum jbvType  type  )

static

Definition at line 3637 of file jsonpath_exec.c.

{
    /* Scalars should be always extracted during jsonpath execution. */
    Assert(scalar->type != jbvBinary ||
           !JsonContainerIsScalar(scalar->val.binary.data));
 
    return scalar->type == type ? scalar : NULL;
}

References Assert(), jbvBinary, JsonContainerIsScalar, type, JsonbValue::type, and JsonbValue::val.

Referenced by executeBinaryArithmExpr(), executeDateTimeMethod(), executeLikeRegex(), executeNumericItemMethod(), executeStartsWith(), executeUnaryArithmExpr(), and getArrayIndex().

jsonb_path_exists()

Datum jsonb_path_exists

(

PG_FUNCTION_ARGS

)

Definition at line 425 of file jsonpath_exec.c.

{
    return jsonb_path_exists_internal(fcinfo, false);
}

References jsonb_path_exists_internal().

jsonb_path_exists_internal()

static Datum jsonb_path_exists_internal ( FunctionCallInfo  fcinfo, bool  tz  )

static

Definition at line 397 of file jsonpath_exec.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    JsonPath   *jp = PG_GETARG_JSONPATH_P(1);
    JsonPathExecResult res;
    Jsonb      *vars = NULL;
    bool        silent = true;
 
    if (PG_NARGS() == 4)
    {
        vars = PG_GETARG_JSONB_P(2);
        silent = PG_GETARG_BOOL(3);
    }
 
    res = executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
                          countVariablesFromJsonb,
                          jb, !silent, NULL, tz);
 
    PG_FREE_IF_COPY(jb, 0);
    PG_FREE_IF_COPY(jp, 1);
 
    if (jperIsError(res))
        PG_RETURN_NULL();
 
    PG_RETURN_BOOL(res == jperOk);
}

References countVariablesFromJsonb(), executeJsonPath(), getJsonPathVariableFromJsonb(), jperIsError, jperOk, PG_FREE_IF_COPY, PG_GETARG_BOOL, PG_GETARG_JSONB_P, PG_GETARG_JSONPATH_P, PG_NARGS, PG_RETURN_BOOL, and PG_RETURN_NULL.

Referenced by jsonb_path_exists(), jsonb_path_exists_opr(), and jsonb_path_exists_tz().

jsonb_path_exists_opr()

Datum jsonb_path_exists_opr

(

PG_FUNCTION_ARGS

)

Definition at line 442 of file jsonpath_exec.c.

{
    /* just call the other one -- it can handle both cases */
    return jsonb_path_exists_internal(fcinfo, false);
}

References jsonb_path_exists_internal().

jsonb_path_exists_tz()

Datum jsonb_path_exists_tz

(

PG_FUNCTION_ARGS

)

Definition at line 431 of file jsonpath_exec.c.

{
    return jsonb_path_exists_internal(fcinfo, true);
}

References jsonb_path_exists_internal().

jsonb_path_match()

Datum jsonb_path_match

(

PG_FUNCTION_ARGS

)

Definition at line 495 of file jsonpath_exec.c.

{
    return jsonb_path_match_internal(fcinfo, false);
}

References jsonb_path_match_internal().

jsonb_path_match_internal()

static Datum jsonb_path_match_internal ( FunctionCallInfo  fcinfo, bool  tz  )

static

Definition at line 454 of file jsonpath_exec.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    JsonPath   *jp = PG_GETARG_JSONPATH_P(1);
    JsonValueList found = {0};
    Jsonb      *vars = NULL;
    bool        silent = true;
 
    if (PG_NARGS() == 4)
    {
        vars = PG_GETARG_JSONB_P(2);
        silent = PG_GETARG_BOOL(3);
    }
 
    (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
                           countVariablesFromJsonb,
                           jb, !silent, &found, tz);
 
    PG_FREE_IF_COPY(jb, 0);
    PG_FREE_IF_COPY(jp, 1);
 
    if (JsonValueListLength(&found) == 1)
    {
        JsonbValue *jbv = JsonValueListHead(&found);
 
        if (jbv->type == jbvBool)
            PG_RETURN_BOOL(jbv->val.boolean);
 
        if (jbv->type == jbvNull)
            PG_RETURN_NULL();
    }
 
    if (!silent)
        ereport(ERROR,
                (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
                 errmsg("single boolean result is expected")));
 
    PG_RETURN_NULL();
}

References countVariablesFromJsonb(), ereport, errcode(), errmsg(), ERROR, executeJsonPath(), getJsonPathVariableFromJsonb(), jbvBool, jbvNull, JsonValueListHead(), JsonValueListLength(), PG_FREE_IF_COPY, PG_GETARG_BOOL, PG_GETARG_JSONB_P, PG_GETARG_JSONPATH_P, PG_NARGS, PG_RETURN_BOOL, PG_RETURN_NULL, JsonbValue::type, and JsonbValue::val.

Referenced by jsonb_path_match(), jsonb_path_match_opr(), and jsonb_path_match_tz().

jsonb_path_match_opr()

Datum jsonb_path_match_opr

(

PG_FUNCTION_ARGS

)

Definition at line 512 of file jsonpath_exec.c.

{
    /* just call the other one -- it can handle both cases */
    return jsonb_path_match_internal(fcinfo, false);
}

References jsonb_path_match_internal().

jsonb_path_match_tz()

Datum jsonb_path_match_tz

(

PG_FUNCTION_ARGS

)

Definition at line 501 of file jsonpath_exec.c.

{
    return jsonb_path_match_internal(fcinfo, true);
}

References jsonb_path_match_internal().

jsonb_path_query()

Datum jsonb_path_query

(

PG_FUNCTION_ARGS

)

Definition at line 572 of file jsonpath_exec.c.

{
    return jsonb_path_query_internal(fcinfo, false);
}

References jsonb_path_query_internal().

jsonb_path_query_array()

Datum jsonb_path_query_array

(

PG_FUNCTION_ARGS

)

Definition at line 605 of file jsonpath_exec.c.

{
    return jsonb_path_query_array_internal(fcinfo, false);
}

References jsonb_path_query_array_internal().

jsonb_path_query_array_internal()

static Datum jsonb_path_query_array_internal ( FunctionCallInfo  fcinfo, bool  tz  )

static

Definition at line 589 of file jsonpath_exec.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    JsonPath   *jp = PG_GETARG_JSONPATH_P(1);
    JsonValueList found = {0};
    Jsonb      *vars = PG_GETARG_JSONB_P(2);
    bool        silent = PG_GETARG_BOOL(3);
 
    (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
                           countVariablesFromJsonb,
                           jb, !silent, &found, tz);
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(wrapItemsInArray(&found)));
}

References countVariablesFromJsonb(), executeJsonPath(), getJsonPathVariableFromJsonb(), JsonbValueToJsonb(), PG_GETARG_BOOL, PG_GETARG_JSONB_P, PG_GETARG_JSONPATH_P, PG_RETURN_JSONB_P, and wrapItemsInArray().

Referenced by jsonb_path_query_array(), and jsonb_path_query_array_tz().

jsonb_path_query_array_tz()

Datum jsonb_path_query_array_tz

(

PG_FUNCTION_ARGS

)

Definition at line 611 of file jsonpath_exec.c.

{
    return jsonb_path_query_array_internal(fcinfo, true);
}

References jsonb_path_query_array_internal().

jsonb_path_query_first()

Datum jsonb_path_query_first

(

PG_FUNCTION_ARGS

)

Definition at line 641 of file jsonpath_exec.c.

{
    return jsonb_path_query_first_internal(fcinfo, false);
}

References jsonb_path_query_first_internal().

jsonb_path_query_first_internal()

static Datum jsonb_path_query_first_internal ( FunctionCallInfo  fcinfo, bool  tz  )

static

Definition at line 622 of file jsonpath_exec.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    JsonPath   *jp = PG_GETARG_JSONPATH_P(1);
    JsonValueList found = {0};
    Jsonb      *vars = PG_GETARG_JSONB_P(2);
    bool        silent = PG_GETARG_BOOL(3);
 
    (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
                           countVariablesFromJsonb,
                           jb, !silent, &found, tz);
 
    if (JsonValueListLength(&found) >= 1)
        PG_RETURN_JSONB_P(JsonbValueToJsonb(JsonValueListHead(&found)));
    else
        PG_RETURN_NULL();
}

References countVariablesFromJsonb(), executeJsonPath(), getJsonPathVariableFromJsonb(), JsonbValueToJsonb(), JsonValueListHead(), JsonValueListLength(), PG_GETARG_BOOL, PG_GETARG_JSONB_P, PG_GETARG_JSONPATH_P, PG_RETURN_JSONB_P, and PG_RETURN_NULL.

Referenced by jsonb_path_query_first(), and jsonb_path_query_first_tz().

jsonb_path_query_first_tz()

Datum jsonb_path_query_first_tz

(

PG_FUNCTION_ARGS

)

Definition at line 647 of file jsonpath_exec.c.

{
    return jsonb_path_query_first_internal(fcinfo, true);
}

References jsonb_path_query_first_internal().

jsonb_path_query_internal()

static Datum jsonb_path_query_internal ( FunctionCallInfo  fcinfo, bool  tz  )

static

Definition at line 524 of file jsonpath_exec.c.

{
    FuncCallContext *funcctx;
    List       *found;
    JsonbValue *v;
    ListCell   *c;
 
    if (SRF_IS_FIRSTCALL())
    {
        JsonPath   *jp;
        Jsonb      *jb;
        MemoryContext oldcontext;
        Jsonb      *vars;
        bool        silent;
        JsonValueList found = {0};
 
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        jb = PG_GETARG_JSONB_P_COPY(0);
        jp = PG_GETARG_JSONPATH_P_COPY(1);
        vars = PG_GETARG_JSONB_P_COPY(2);
        silent = PG_GETARG_BOOL(3);
 
        (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
                               countVariablesFromJsonb,
                               jb, !silent, &found, tz);
 
        funcctx->user_fctx = JsonValueListGetList(&found);
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    funcctx = SRF_PERCALL_SETUP();
    found = funcctx->user_fctx;
 
    c = list_head(found);
 
    if (c == NULL)
        SRF_RETURN_DONE(funcctx);
 
    v = lfirst(c);
    funcctx->user_fctx = list_delete_first(found);
 
    SRF_RETURN_NEXT(funcctx, JsonbPGetDatum(JsonbValueToJsonb(v)));
}

References countVariablesFromJsonb(), executeJsonPath(), getJsonPathVariableFromJsonb(), JsonbPGetDatum(), JsonbValueToJsonb(), JsonValueListGetList(), lfirst, list_delete_first(), list_head(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, PG_GETARG_BOOL, PG_GETARG_JSONB_P_COPY, PG_GETARG_JSONPATH_P_COPY, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, and FuncCallContext::user_fctx.

Referenced by jsonb_path_query(), and jsonb_path_query_tz().

jsonb_path_query_tz()

Datum jsonb_path_query_tz

(

PG_FUNCTION_ARGS

)

Definition at line 578 of file jsonpath_exec.c.

{
    return jsonb_path_query_internal(fcinfo, true);
}

References jsonb_path_query_internal().

JsonbArraySize()

static int JsonbArraySize ( JsonbValue *  jb )

static

Definition at line 3224 of file jsonpath_exec.c.

{
    Assert(jb->type != jbvArray);
 
    if (jb->type == jbvBinary)
    {
        JsonbContainer *jbc = jb->val.binary.data;
 
        if (JsonContainerIsArray(jbc) && !JsonContainerIsScalar(jbc))
            return JsonContainerSize(jbc);
    }
 
    return -1;
}

References Assert(), jbvArray, jbvBinary, JsonContainerIsArray, JsonContainerIsScalar, JsonContainerSize, JsonbValue::type, and JsonbValue::val.

Referenced by executeItemOptUnwrapTarget().

JsonbInitBinary()

static JsonbValue * JsonbInitBinary ( JsonbValue *  jbv, Jsonb *  jb  )

static

Definition at line 3600 of file jsonpath_exec.c.

{
    jbv->type = jbvBinary;
    jbv->val.binary.data = &jb->root;
    jbv->val.binary.len = VARSIZE_ANY_EXHDR(jb);
 
    return jbv;
}

References jbvBinary, Jsonb::root, JsonbValue::type, JsonbValue::val, and VARSIZE_ANY_EXHDR.

Referenced by executeJsonPath(), executeKeyValueMethod(), getJsonPathVariableFromJsonb(), and JsonItemFromDatum().

JsonbType()

static int JsonbType ( JsonbValue *  jb )

static

Definition at line 3613 of file jsonpath_exec.c.

{
    int         type = jb->type;
 
    if (jb->type == jbvBinary)
    {
        JsonbContainer *jbc = jb->val.binary.data;
 
        /* Scalars should be always extracted during jsonpath execution. */
        Assert(!JsonContainerIsScalar(jbc));
 
        if (JsonContainerIsObject(jbc))
            type = jbvObject;
        else if (JsonContainerIsArray(jbc))
            type = jbvArray;
        else
            elog(ERROR, "invalid jsonb container type: 0x%08x", jbc->header);
    }
 
    return type;
}

References Assert(), elog, ERROR, JsonbContainer::header, jbvArray, jbvBinary, jbvObject, JsonContainerIsArray, JsonContainerIsObject, JsonContainerIsScalar, type, JsonbValue::type, and JsonbValue::val.

Referenced by executeItemOptUnwrapResult(), executeItemOptUnwrapTarget(), executeKeyValueMethod(), and executeNumericItemMethod().

JsonbValueInitNumericDatum()

static void JsonbValueInitNumericDatum ( JsonbValue *  jbv, Datum  num  )

static

Definition at line 3130 of file jsonpath_exec.c.

{
    jbv->type = jbvNumeric;
    jbv->val.numeric = DatumGetNumeric(num);
}

References DatumGetNumeric(), jbvNumeric, JsonbValue::type, and JsonbValue::val.

Referenced by JsonItemFromDatum().

JsonItemFromDatum()

static void JsonItemFromDatum ( Datum  val, Oid  typid, int32  typmod, JsonbValue *  res  )

static

Definition at line 3048 of file jsonpath_exec.c.

{
    switch (typid)
    {
        case BOOLOID:
            res->type = jbvBool;
            res->val.boolean = DatumGetBool(val);
            break;
        case NUMERICOID:
            JsonbValueInitNumericDatum(res, val);
            break;
        case INT2OID:
            JsonbValueInitNumericDatum(res, DirectFunctionCall1(int2_numeric, val));
            break;
        case INT4OID:
            JsonbValueInitNumericDatum(res, DirectFunctionCall1(int4_numeric, val));
            break;
        case INT8OID:
            JsonbValueInitNumericDatum(res, DirectFunctionCall1(int8_numeric, val));
            break;
        case FLOAT4OID:
            JsonbValueInitNumericDatum(res, DirectFunctionCall1(float4_numeric, val));
            break;
        case FLOAT8OID:
            JsonbValueInitNumericDatum(res, DirectFunctionCall1(float8_numeric, val));
            break;
        case TEXTOID:
        case VARCHAROID:
            res->type = jbvString;
            res->val.string.val = VARDATA_ANY(val);
            res->val.string.len = VARSIZE_ANY_EXHDR(val);
            break;
        case DATEOID:
        case TIMEOID:
        case TIMETZOID:
        case TIMESTAMPOID:
        case TIMESTAMPTZOID:
            res->type = jbvDatetime;
            res->val.datetime.value = val;
            res->val.datetime.typid = typid;
            res->val.datetime.typmod = typmod;
            res->val.datetime.tz = 0;
            break;
        case JSONBOID:
            {
                JsonbValue *jbv = res;
                Jsonb      *jb = DatumGetJsonbP(val);
 
                if (JsonContainerIsScalar(&jb->root))
                {
                    bool        result PG_USED_FOR_ASSERTS_ONLY;
 
                    result = JsonbExtractScalar(&jb->root, jbv);
                    Assert(result);
                }
                else
                    JsonbInitBinary(jbv, jb);
                break;
            }
        case JSONOID:
            {
                text       *txt = DatumGetTextP(val);
                char       *str = text_to_cstring(txt);
                Jsonb      *jb;
 
                jb = DatumGetJsonbP(DirectFunctionCall1(jsonb_in,
                                                        CStringGetDatum(str)));
                pfree(str);
 
                JsonItemFromDatum(JsonbPGetDatum(jb), JSONBOID, -1, res);
                break;
            }
        default:
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                    errmsg("could not convert value of type %s to jsonpath",
                           format_type_be(typid)));
    }
}

References Assert(), CStringGetDatum(), DatumGetBool(), DatumGetJsonbP(), DatumGetTextP, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, float4_numeric(), float8_numeric(), format_type_be(), int2_numeric(), int4_numeric(), int8_numeric(), jbvBool, jbvDatetime, jbvString, jsonb_in(), JsonbExtractScalar(), JsonbInitBinary(), JsonbPGetDatum(), JsonbValueInitNumericDatum(), JsonContainerIsScalar, JsonItemFromDatum(), pfree(), PG_USED_FOR_ASSERTS_ONLY, Jsonb::root, str, text_to_cstring(), JsonbValue::type, JsonbValue::val, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by GetJsonPathVar(), and JsonItemFromDatum().

JsonPathExists()

bool JsonPathExists	(	Datum	jb,
		JsonPath *	jp,
		bool *	error,
		List *	vars
	)

Definition at line 3887 of file jsonpath_exec.c.

{
    JsonPathExecResult res;
 
    res = executeJsonPath(jp, vars,
                          GetJsonPathVar, CountJsonPathVars,
                          DatumGetJsonbP(jb), !error, NULL, true);
 
    Assert(error || !jperIsError(res));
 
    if (error && jperIsError(res))
        *error = true;
 
    return res == jperOk;
}

References Assert(), CountJsonPathVars(), DatumGetJsonbP(), error(), executeJsonPath(), GetJsonPathVar(), jperIsError, and jperOk.

Referenced by ExecEvalJsonExprPath().

JsonPathQuery()

Datum JsonPathQuery	(	Datum	jb,
		JsonPath *	jp,
		JsonWrapper	wrapper,
		bool *	empty,
		bool *	error,
		List *	vars,
		const char *	column_name
	)

Definition at line 3910 of file jsonpath_exec.c.

{
    JsonbValue *singleton;
    bool        wrap;
    JsonValueList found = {0};
    JsonPathExecResult res;
    int         count;
 
    res = executeJsonPath(jp, vars,
                          GetJsonPathVar, CountJsonPathVars,
                          DatumGetJsonbP(jb), !error, &found, true);
    Assert(error || !jperIsError(res));
    if (error && jperIsError(res))
    {
        *error = true;
        *empty = false;
        return (Datum) 0;
    }
 
    /*
     * Determine whether to wrap the result in a JSON array or not.
     *
     * First, count the number of SQL/JSON items in the returned
     * JsonValueList. If the list is empty (singleton == NULL), no wrapping is
     * necessary.
     *
     * If the wrapper mode is JSW_NONE or JSW_UNSPEC, wrapping is explicitly
     * disabled. This enforces a WITHOUT WRAPPER clause, which is also the
     * default when no WRAPPER clause is specified.
     *
     * If the mode is JSW_UNCONDITIONAL, wrapping is enforced regardless of
     * the number of SQL/JSON items, enforcing a WITH WRAPPER or WITH
     * UNCONDITIONAL WRAPPER clause.
     *
     * For JSW_CONDITIONAL, wrapping occurs only if there is more than one
     * SQL/JSON item in the list, enforcing a WITH CONDITIONAL WRAPPER clause.
     */
    count = JsonValueListLength(&found);
    singleton = count > 0 ? JsonValueListHead(&found) : NULL;
    if (singleton == NULL)
        wrap = false;
    else if (wrapper == JSW_NONE || wrapper == JSW_UNSPEC)
        wrap = false;
    else if (wrapper == JSW_UNCONDITIONAL)
        wrap = true;
    else if (wrapper == JSW_CONDITIONAL)
        wrap = count > 1;
    else
    {
        elog(ERROR, "unrecognized json wrapper %d", (int) wrapper);
        wrap = false;
    }
 
    if (wrap)
        return JsonbPGetDatum(JsonbValueToJsonb(wrapItemsInArray(&found)));
 
    /* No wrapping means only one item is expected. */
    if (count > 1)
    {
        if (error)
        {
            *error = true;
            return (Datum) 0;
        }
 
        if (column_name)
            ereport(ERROR,
                    (errcode(ERRCODE_MORE_THAN_ONE_SQL_JSON_ITEM),
                     errmsg("JSON path expression for column \"%s\" must return single item when no wrapper is requested",
                            column_name),
                     errhint("Use the WITH WRAPPER clause to wrap SQL/JSON items into an array.")));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_MORE_THAN_ONE_SQL_JSON_ITEM),
                     errmsg("JSON path expression in JSON_QUERY must return single item when no wrapper is requested"),
                     errhint("Use the WITH WRAPPER clause to wrap SQL/JSON items into an array.")));
    }
 
    if (singleton)
        return JsonbPGetDatum(JsonbValueToJsonb(singleton));
 
    *empty = true;
    return PointerGetDatum(NULL);
}

References Assert(), CountJsonPathVars(), DatumGetJsonbP(), elog, ereport, errcode(), errhint(), errmsg(), ERROR, error(), executeJsonPath(), GetJsonPathVar(), jperIsError, JsonbPGetDatum(), JsonbValueToJsonb(), JsonValueListHead(), JsonValueListLength(), JSW_CONDITIONAL, JSW_NONE, JSW_UNCONDITIONAL, JSW_UNSPEC, PointerGetDatum(), and wrapItemsInArray().

Referenced by ExecEvalJsonExprPath().

JsonPathValue()

JsonbValue * JsonPathValue	(	Datum	jb,
		JsonPath *	jp,
		bool *	empty,
		bool *	error,
		List *	vars,
		const char *	column_name
	)

Definition at line 4004 of file jsonpath_exec.c.

{
    JsonbValue *res;
    JsonValueList found = {0};
    JsonPathExecResult jper PG_USED_FOR_ASSERTS_ONLY;
    int         count;
 
    jper = executeJsonPath(jp, vars, GetJsonPathVar, CountJsonPathVars,
                           DatumGetJsonbP(jb),
                           !error, &found, true);
 
    Assert(error || !jperIsError(jper));
 
    if (error && jperIsError(jper))
    {
        *error = true;
        *empty = false;
        return NULL;
    }
 
    count = JsonValueListLength(&found);
 
    *empty = (count == 0);
 
    if (*empty)
        return NULL;
 
    /* JSON_VALUE expects to get only singletons. */
    if (count > 1)
    {
        if (error)
        {
            *error = true;
            return NULL;
        }
 
        if (column_name)
            ereport(ERROR,
                    (errcode(ERRCODE_MORE_THAN_ONE_SQL_JSON_ITEM),
                     errmsg("JSON path expression for column \"%s\" must return single scalar item",
                            column_name)));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_MORE_THAN_ONE_SQL_JSON_ITEM),
                     errmsg("JSON path expression in JSON_VALUE must return single scalar item")));
    }
 
    res = JsonValueListHead(&found);
    if (res->type == jbvBinary && JsonContainerIsScalar(res->val.binary.data))
        JsonbExtractScalar(res->val.binary.data, res);
 
    /* JSON_VALUE expects to get only scalars. */
    if (!IsAJsonbScalar(res))
    {
        if (error)
        {
            *error = true;
            return NULL;
        }
 
        if (column_name)
            ereport(ERROR,
                    (errcode(ERRCODE_SQL_JSON_SCALAR_REQUIRED),
                     errmsg("JSON path expression for column \"%s\" must return single scalar item",
                            column_name)));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_SQL_JSON_SCALAR_REQUIRED),
                     errmsg("JSON path expression in JSON_VALUE must return single scalar item")));
    }
 
    if (res->type == jbvNull)
        return NULL;
 
    return res;
}

References Assert(), CountJsonPathVars(), DatumGetJsonbP(), ereport, errcode(), errmsg(), ERROR, error(), executeJsonPath(), GetJsonPathVar(), IsAJsonbScalar, jbvBinary, jbvNull, jperIsError, JsonbExtractScalar(), JsonContainerIsScalar, JsonValueListHead(), JsonValueListLength(), PG_USED_FOR_ASSERTS_ONLY, JsonbValue::type, and JsonbValue::val.

Referenced by ExecEvalJsonExprPath().

JsonTableDestroyOpaque()

static void JsonTableDestroyOpaque ( TableFuncScanState *  state )

static

Definition at line 4175 of file jsonpath_exec.c.

{
    JsonTableExecContext *cxt =
        GetJsonTableExecContext(state, "JsonTableDestroyOpaque");
 
    /* not valid anymore */
    cxt->magic = 0;
 
    state->opaque = NULL;
}

References GetJsonTableExecContext(), and JsonTableExecContext::magic.

JsonTableFetchRow()

static bool JsonTableFetchRow ( TableFuncScanState *  state )

static

Definition at line 4437 of file jsonpath_exec.c.

{
    JsonTableExecContext *cxt =
        GetJsonTableExecContext(state, "JsonTableFetchRow");
 
    return JsonTablePlanNextRow(cxt->rootplanstate);
}

References GetJsonTableExecContext(), JsonTablePlanNextRow(), and JsonTableExecContext::rootplanstate.

JsonTableGetValue()

static Datum JsonTableGetValue ( TableFuncScanState *  state, int  colnum, Oid  typid, int32  typmod, bool *  isnull  )

static

Definition at line 4453 of file jsonpath_exec.c.

{
    JsonTableExecContext *cxt =
        GetJsonTableExecContext(state, "JsonTableGetValue");
    ExprContext *econtext = state->ss.ps.ps_ExprContext;
    ExprState  *estate = list_nth(state->colvalexprs, colnum);
    JsonTablePlanState *planstate = cxt->colplanstates[colnum];
    JsonTablePlanRowSource *current = &planstate->current;
    Datum       result;
 
    /* Row pattern value is NULL */
    if (current->isnull)
    {
        result = (Datum) 0;
        *isnull = true;
    }
    /* Evaluate JsonExpr. */
    else if (estate)
    {
        Datum       saved_caseValue = econtext->caseValue_datum;
        bool        saved_caseIsNull = econtext->caseValue_isNull;
 
        /* Pass the row pattern value via CaseTestExpr. */
        econtext->caseValue_datum = current->value;
        econtext->caseValue_isNull = false;
 
        result = ExecEvalExpr(estate, econtext, isnull);
 
        econtext->caseValue_datum = saved_caseValue;
        econtext->caseValue_isNull = saved_caseIsNull;
    }
    /* ORDINAL column */
    else
    {
        result = Int32GetDatum(planstate->ordinal);
        *isnull = false;
    }
 
    return result;
}

References ExprContext::caseValue_datum, ExprContext::caseValue_isNull, JsonTableExecContext::colplanstates, JsonTablePlanState::current, ExecEvalExpr(), GetJsonTableExecContext(), Int32GetDatum(), JsonTablePlanRowSource::isnull, list_nth(), JsonTablePlanState::ordinal, and JsonTablePlanRowSource::value.

JsonTableInitOpaque()

static void JsonTableInitOpaque ( TableFuncScanState *  state, int  natts  )

static

Definition at line 4110 of file jsonpath_exec.c.

{
    JsonTableExecContext *cxt;
    PlanState  *ps = &state->ss.ps;
    TableFuncScan *tfs = castNode(TableFuncScan, ps->plan);
    TableFunc  *tf = tfs->tablefunc;
    JsonTablePlan *rootplan = (JsonTablePlan *) tf->plan;
    JsonExpr   *je = castNode(JsonExpr, tf->docexpr);
    List       *args = NIL;
 
    cxt = palloc0(sizeof(JsonTableExecContext));
    cxt->magic = JSON_TABLE_EXEC_CONTEXT_MAGIC;
 
    /*
     * Evaluate JSON_TABLE() PASSING arguments to be passed to the jsonpath
     * executor via JsonPathVariables.
     */
    if (state->passingvalexprs)
    {
        ListCell   *exprlc;
        ListCell   *namelc;
 
        Assert(list_length(state->passingvalexprs) ==
               list_length(je->passing_names));
        forboth(exprlc, state->passingvalexprs,
                namelc, je->passing_names)
        {
            ExprState  *state = lfirst_node(ExprState, exprlc);
            String     *name = lfirst_node(String, namelc);
            JsonPathVariable *var = palloc(sizeof(*var));
 
            var->name = pstrdup(name->sval);
            var->namelen = strlen(var->name);
            var->typid = exprType((Node *) state->expr);
            var->typmod = exprTypmod((Node *) state->expr);
 
            /*
             * Evaluate the expression and save the value to be returned by
             * GetJsonPathVar().
             */
            var->value = ExecEvalExpr(state, ps->ps_ExprContext,
                                      &var->isnull);
 
            args = lappend(args, var);
        }
    }
 
    cxt->colplanstates = palloc(sizeof(JsonTablePlanState *) *
                                list_length(tf->colvalexprs));
 
    /*
     * Initialize plan for the root path and, recursively, also any child
     * plans that compute the NESTED paths.
     */
    cxt->rootplanstate = JsonTableInitPlan(cxt, rootplan, NULL, args,
                                           CurrentMemoryContext);
 
    state->opaque = cxt;
}

References generate_unaccent_rules::args, Assert(), castNode, JsonTableExecContext::colplanstates, CurrentMemoryContext, TableFunc::docexpr, ExecEvalExpr(), exprType(), exprTypmod(), forboth, JsonPathVariable::isnull, JSON_TABLE_EXEC_CONTEXT_MAGIC, JsonTableInitPlan(), lappend(), lfirst_node, list_length(), JsonTableExecContext::magic, name, JsonPathVariable::name, JsonPathVariable::namelen, NIL, palloc(), palloc0(), ps, pstrdup(), JsonTableExecContext::rootplanstate, TableFuncScan::tablefunc, JsonPathVariable::typid, JsonPathVariable::typmod, and JsonPathVariable::value.

JsonTableInitPlan()

static JsonTablePlanState * JsonTableInitPlan ( JsonTableExecContext *  cxt, JsonTablePlan *  plan, JsonTablePlanState *  parentstate, List *  args, MemoryContext  mcxt  )

static

Definition at line 4192 of file jsonpath_exec.c.

{
    JsonTablePlanState *planstate = palloc0(sizeof(*planstate));
 
    planstate->plan = plan;
    planstate->parent = parentstate;
 
    if (IsA(plan, JsonTablePathScan))
    {
        JsonTablePathScan *scan = (JsonTablePathScan *) plan;
        int         i;
 
        planstate->path = DatumGetJsonPathP(scan->path->value->constvalue);
        planstate->args = args;
        planstate->mcxt = AllocSetContextCreate(mcxt, "JsonTableExecContext",
                                                ALLOCSET_DEFAULT_SIZES);
 
        /* No row pattern evaluated yet. */
        planstate->current.value = PointerGetDatum(NULL);
        planstate->current.isnull = true;
 
        for (i = scan->colMin; i >= 0 && i <= scan->colMax; i++)
            cxt->colplanstates[i] = planstate;
 
        planstate->nested = scan->child ?
            JsonTableInitPlan(cxt, scan->child, planstate, args, mcxt) : NULL;
    }
    else if (IsA(plan, JsonTableSiblingJoin))
    {
        JsonTableSiblingJoin *join = (JsonTableSiblingJoin *) plan;
 
        planstate->left = JsonTableInitPlan(cxt, join->lplan, parentstate,
                                            args, mcxt);
        planstate->right = JsonTableInitPlan(cxt, join->rplan, parentstate,
                                             args, mcxt);
    }
 
    return planstate;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, generate_unaccent_rules::args, JsonTablePlanState::args, JsonTablePathScan::child, JsonTablePathScan::colMin, JsonTableExecContext::colplanstates, JsonTablePlanState::current, DatumGetJsonPathP(), i, IsA, JsonTablePlanRowSource::isnull, JsonTableInitPlan(), JsonTablePlanState::left, JsonTableSiblingJoin::lplan, JsonTablePlanState::mcxt, JsonTablePlanState::nested, palloc0(), JsonTablePlanState::parent, JsonTablePlanState::path, JsonTablePathScan::path, JsonTablePlanState::plan, plan, PointerGetDatum(), JsonTablePlanState::right, JsonTableSiblingJoin::rplan, JsonTablePlanRowSource::value, and JsonTablePath::value.

Referenced by JsonTableInitOpaque(), and JsonTableInitPlan().

JsonTablePlanJoinNextRow()

static bool JsonTablePlanJoinNextRow ( JsonTablePlanState *  planstate )

static

Definition at line 4410 of file jsonpath_exec.c.

{
 
    /* Fetch row from left sibling. */
    if (!JsonTablePlanNextRow(planstate->left))
    {
        /*
         * Left sibling ran out of rows, so start fetching from the right
         * sibling.
         */
        if (!JsonTablePlanNextRow(planstate->right))
        {
            /* Right sibling ran out of row, so there are more rows. */
            return false;
        }
    }
 
    return true;
}

References JsonTablePlanNextRow(), JsonTablePlanState::left, and JsonTablePlanState::right.

Referenced by JsonTablePlanNextRow().

JsonTablePlanNextRow()

static bool JsonTablePlanNextRow ( JsonTablePlanState *  planstate )

static

Definition at line 4292 of file jsonpath_exec.c.

{
    if (IsA(planstate->plan, JsonTablePathScan))
        return JsonTablePlanScanNextRow(planstate);
    else if (IsA(planstate->plan, JsonTableSiblingJoin))
        return JsonTablePlanJoinNextRow(planstate);
    else
        elog(ERROR, "invalid JsonTablePlan %d", (int) planstate->plan->type);
 
    Assert(false);
    /* Appease compiler */
    return false;
}

References Assert(), elog, ERROR, IsA, JsonTablePlanJoinNextRow(), JsonTablePlanScanNextRow(), and JsonTablePlanState::plan.

Referenced by JsonTableFetchRow(), JsonTablePlanJoinNextRow(), and JsonTablePlanScanNextRow().

JsonTablePlanScanNextRow()

static bool JsonTablePlanScanNextRow ( JsonTablePlanState *  planstate )

static

Definition at line 4319 of file jsonpath_exec.c.

{
    JsonbValue *jbv;
    MemoryContext oldcxt;
 
    /*
     * If planstate already has an active row and there is a nested plan,
     * check if it has an active row to join with the former.
     */
    if (!planstate->current.isnull)
    {
        if (planstate->nested && JsonTablePlanNextRow(planstate->nested))
            return true;
    }
 
    /* Fetch new row from the list of found values to set as active. */
    jbv = JsonValueListNext(&planstate->found, &planstate->iter);
 
    /* End of list? */
    if (jbv == NULL)
    {
        planstate->current.value = PointerGetDatum(NULL);
        planstate->current.isnull = true;
        return false;
    }
 
    /*
     * Set current row item for subsequent JsonTableGetValue() calls for
     * evaluating individual columns.
     */
    oldcxt = MemoryContextSwitchTo(planstate->mcxt);
    planstate->current.value = JsonbPGetDatum(JsonbValueToJsonb(jbv));
    planstate->current.isnull = false;
    MemoryContextSwitchTo(oldcxt);
 
    /* Next row! */
    planstate->ordinal++;
 
    /* Process nested plan(s), if any. */
    if (planstate->nested)
    {
        /* Re-evaluate the nested path using the above parent row. */
        JsonTableResetNestedPlan(planstate->nested);
 
        /*
         * Now fetch the nested plan's current row to be joined against the
         * parent row.  Any further nested plans' paths will be re-evaluated
         * recursively, level at a time, after setting each nested plan's
         * current row.
         */
        (void) JsonTablePlanNextRow(planstate->nested);
    }
 
    /* There are more rows. */
    return true;
}

References JsonTablePlanState::current, JsonTablePlanState::found, JsonTablePlanRowSource::isnull, JsonTablePlanState::iter, JsonbPGetDatum(), JsonbValueToJsonb(), JsonTablePlanNextRow(), JsonTableResetNestedPlan(), JsonValueListNext(), JsonTablePlanState::mcxt, MemoryContextSwitchTo(), JsonTablePlanState::nested, JsonTablePlanState::ordinal, PointerGetDatum(), and JsonTablePlanRowSource::value.

Referenced by JsonTablePlanNextRow().

JsonTableResetNestedPlan()

static void JsonTableResetNestedPlan ( JsonTablePlanState *  planstate )

static

Definition at line 4381 of file jsonpath_exec.c.

{
    /* This better be a child plan. */
    Assert(planstate->parent != NULL);
    if (IsA(planstate->plan, JsonTablePathScan))
    {
        JsonTablePlanState *parent = planstate->parent;
 
        if (!parent->current.isnull)
            JsonTableResetRowPattern(planstate, parent->current.value);
 
        /*
         * If this plan itself has a child nested plan, it will be reset when
         * the caller calls JsonTablePlanNextRow() on this plan.
         */
    }
    else if (IsA(planstate->plan, JsonTableSiblingJoin))
    {
        JsonTableResetNestedPlan(planstate->left);
        JsonTableResetNestedPlan(planstate->right);
    }
}

References Assert(), JsonTablePlanState::current, IsA, JsonTablePlanRowSource::isnull, JsonTableResetNestedPlan(), JsonTableResetRowPattern(), JsonTablePlanState::left, JsonTablePlanState::parent, JsonTablePlanState::plan, JsonTablePlanState::right, and JsonTablePlanRowSource::value.

Referenced by JsonTablePlanScanNextRow(), and JsonTableResetNestedPlan().

JsonTableResetRowPattern()

static void JsonTableResetRowPattern ( JsonTablePlanState *  planstate, Datum  item  )

static

Definition at line 4252 of file jsonpath_exec.c.

{
    JsonTablePathScan *scan = castNode(JsonTablePathScan, planstate->plan);
    MemoryContext oldcxt;
    JsonPathExecResult res;
    Jsonb      *js = (Jsonb *) DatumGetJsonbP(item);
 
    JsonValueListClear(&planstate->found);
 
    MemoryContextResetOnly(planstate->mcxt);
 
    oldcxt = MemoryContextSwitchTo(planstate->mcxt);
 
    res = executeJsonPath(planstate->path, planstate->args,
                          GetJsonPathVar, CountJsonPathVars,
                          js, scan->errorOnError,
                          &planstate->found,
                          true);
 
    MemoryContextSwitchTo(oldcxt);
 
    if (jperIsError(res))
    {
        Assert(!scan->errorOnError);
        JsonValueListClear(&planstate->found);
    }
 
    /* Reset plan iterator to the beginning of the item list */
    JsonValueListInitIterator(&planstate->found, &planstate->iter);
    planstate->current.value = PointerGetDatum(NULL);
    planstate->current.isnull = true;
    planstate->ordinal = 0;
}

References JsonTablePlanState::args, Assert(), castNode, CountJsonPathVars(), JsonTablePlanState::current, DatumGetJsonbP(), JsonTablePathScan::errorOnError, executeJsonPath(), JsonTablePlanState::found, GetJsonPathVar(), JsonTablePlanRowSource::isnull, JsonTablePlanState::iter, jperIsError, JsonValueListClear(), JsonValueListInitIterator(), JsonTablePlanState::mcxt, MemoryContextResetOnly(), MemoryContextSwitchTo(), JsonTablePlanState::ordinal, JsonTablePlanState::path, JsonTablePlanState::plan, PointerGetDatum(), and JsonTablePlanRowSource::value.

Referenced by JsonTableResetNestedPlan(), and JsonTableSetDocument().

JsonTableSetDocument()

static void JsonTableSetDocument ( TableFuncScanState *  state, Datum  value  )

static

Definition at line 4239 of file jsonpath_exec.c.

{
    JsonTableExecContext *cxt =
        GetJsonTableExecContext(state, "JsonTableSetDocument");
 
    JsonTableResetRowPattern(cxt->rootplanstate, value);
}

References GetJsonTableExecContext(), JsonTableResetRowPattern(), JsonTableExecContext::rootplanstate, and value.

JsonValueListAppend()

static void JsonValueListAppend ( JsonValueList *  jvl, JsonbValue *  jbv  )

static

Definition at line 3512 of file jsonpath_exec.c.

{
    if (jvl->singleton)
    {
        jvl->list = list_make2(jvl->singleton, jbv);
        jvl->singleton = NULL;
    }
    else if (!jvl->list)
        jvl->singleton = jbv;
    else
        jvl->list = lappend(jvl->list, jbv);
}

References lappend(), JsonValueList::list, list_make2, and JsonValueList::singleton.

Referenced by executeAnyItem(), executeItemOptUnwrapResult(), and executeNextItem().

JsonValueListClear()

static void JsonValueListClear ( JsonValueList *  jvl )

static

Definition at line 3505 of file jsonpath_exec.c.

{
    jvl->singleton = NULL;
    jvl->list = NIL;
}

References JsonValueList::list, NIL, and JsonValueList::singleton.

Referenced by JsonTableResetRowPattern().

JsonValueListGetList()

static List * JsonValueListGetList ( JsonValueList *  jvl )

static

Definition at line 3544 of file jsonpath_exec.c.

{
    if (jvl->singleton)
        return list_make1(jvl->singleton);
 
    return jvl->list;
}

References JsonValueList::list, list_make1, and JsonValueList::singleton.

Referenced by jsonb_path_query_internal().

JsonValueListHead()

static JsonbValue * JsonValueListHead ( JsonValueList *  jvl )

static

Definition at line 3538 of file jsonpath_exec.c.

{
    return jvl->singleton ? jvl->singleton : linitial(jvl->list);
}

References linitial, JsonValueList::list, and JsonValueList::singleton.

Referenced by executeBinaryArithmExpr(), getArrayIndex(), jsonb_path_match_internal(), jsonb_path_query_first_internal(), JsonPathQuery(), and JsonPathValue().

JsonValueListInitIterator()

static void JsonValueListInitIterator ( const JsonValueList *  jvl, JsonValueListIterator *  it  )

static

Definition at line 3553 of file jsonpath_exec.c.

{
    if (jvl->singleton)
    {
        it->value = jvl->singleton;
        it->list = NIL;
        it->next = NULL;
    }
    else if (jvl->list != NIL)
    {
        it->value = (JsonbValue *) linitial(jvl->list);
        it->list = jvl->list;
        it->next = list_second_cell(jvl->list);
    }
    else
    {
        it->value = NULL;
        it->list = NIL;
        it->next = NULL;
    }
}

References linitial, JsonValueList::list, JsonValueListIterator::list, list_second_cell(), JsonValueListIterator::next, NIL, JsonValueList::singleton, and JsonValueListIterator::value.

Referenced by executeItemOptUnwrapResult(), executePredicate(), executeUnaryArithmExpr(), JsonTableResetRowPattern(), and wrapItemsInArray().

JsonValueListIsEmpty()

static bool JsonValueListIsEmpty ( JsonValueList *  jvl )

static

Definition at line 3532 of file jsonpath_exec.c.

{
    return !jvl->singleton && (jvl->list == NIL);
}

References JsonValueList::list, NIL, and JsonValueList::singleton.

Referenced by executeBoolItem(), and executeJsonPath().

JsonValueListLength()

static int JsonValueListLength ( const JsonValueList *  jvl )

static

Definition at line 3526 of file jsonpath_exec.c.

{
    return jvl->singleton ? 1 : list_length(jvl->list);
}

References JsonValueList::list, list_length(), and JsonValueList::singleton.

Referenced by executeBinaryArithmExpr(), getArrayIndex(), jsonb_path_match_internal(), jsonb_path_query_first_internal(), JsonPathQuery(), and JsonPathValue().

JsonValueListNext()

static JsonbValue * JsonValueListNext ( const JsonValueList *  jvl, JsonValueListIterator *  it  )

static

Definition at line 3579 of file jsonpath_exec.c.

{
    JsonbValue *result = it->value;
 
    if (it->next)
    {
        it->value = lfirst(it->next);
        it->next = lnext(it->list, it->next);
    }
    else
    {
        it->value = NULL;
    }
 
    return result;
}

References lfirst, JsonValueListIterator::list, lnext(), JsonValueListIterator::next, and JsonValueListIterator::value.

Referenced by executeItemOptUnwrapResult(), executePredicate(), executeUnaryArithmExpr(), JsonTablePlanScanNextRow(), and wrapItemsInArray().

setBaseObject()

static JsonBaseObjectInfo setBaseObject ( JsonPathExecContext *  cxt, JsonbValue *  jbv, int32  id  )

static

Definition at line 3493 of file jsonpath_exec.c.

{
    JsonBaseObjectInfo baseObject = cxt->baseObject;
 
    cxt->baseObject.jbc = jbv->type != jbvBinary ? NULL :
        (JsonbContainer *) jbv->val.binary.data;
    cxt->baseObject.id = id;
 
    return baseObject;
}

References JsonPathExecContext::baseObject, JsonBaseObjectInfo::id, JsonBaseObjectInfo::jbc, jbvBinary, JsonbValue::type, and JsonbValue::val.

Referenced by executeItemOptUnwrapTarget(), executeKeyValueMethod(), and getJsonPathVariable().

wrapItemsInArray()

static JsonbValue * wrapItemsInArray ( const JsonValueList *  items )

static

Definition at line 3648 of file jsonpath_exec.c.

{
    JsonbParseState *ps = NULL;
    JsonValueListIterator it;
    JsonbValue *jbv;
 
    pushJsonbValue(&ps, WJB_BEGIN_ARRAY, NULL);
 
    JsonValueListInitIterator(items, &it);
    while ((jbv = JsonValueListNext(items, &it)))
        pushJsonbValue(&ps, WJB_ELEM, jbv);
 
    return pushJsonbValue(&ps, WJB_END_ARRAY, NULL);
}

References items, JsonValueListInitIterator(), JsonValueListNext(), ps, pushJsonbValue(), WJB_BEGIN_ARRAY, WJB_ELEM, and WJB_END_ARRAY.

Referenced by jsonb_path_query_array_internal(), and JsonPathQuery().

Variable Documentation

JsonbTableRoutine

const TableFuncRoutine JsonbTableRoutine

Initial value:

=
{
    .InitOpaque = JsonTableInitOpaque,
    .SetDocument = JsonTableSetDocument,
    .SetNamespace = NULL,
    .SetRowFilter = NULL,
    .SetColumnFilter = NULL,
    .FetchRow = JsonTableFetchRow,
    .GetValue = JsonTableGetValue,
    .DestroyOpaque = JsonTableDestroyOpaque
}

Definition at line 370 of file jsonpath_exec.c.

Referenced by ExecInitTableFuncScan().