#include "postgres.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "lib/stringinfo.h"
#include "miscadmin.h"
#include "regex/regex.h"
#include "utils/builtins.h"
#include "utils/datetime.h"
#include "utils/datum.h"
#include "utils/formatting.h"
#include "utils/float.h"
#include "utils/guc.h"
#include "utils/json.h"
#include "utils/jsonpath.h"
#include "utils/date.h"
#include "utils/timestamp.h"
#include "utils/varlena.h"

Include dependency graph for jsonpath_exec.c:

Data Structures
struct	JsonBaseObjectInfo

struct	JsonPathExecContext

struct	JsonLikeRegexContext

struct	JsonValueList

struct	JsonValueListIterator

Macros
#define	jperIsError(jper) ((jper) == jperError)

#define	jspStrictAbsenseOfErrors(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 struct JsonPathExecContext	JsonPathExecContext

typedef struct JsonLikeRegexContext	JsonLikeRegexContext

typedef enum JsonPathBool	JsonPathBool

typedef enum JsonPathExecResult	JsonPathExecResult

typedef struct JsonValueList	JsonValueList

typedef struct JsonValueListIterator	JsonValueListIterator

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, Jsonb vars, 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 void	getJsonPathVariable (JsonPathExecContext cxt, JsonPathItem variable, Jsonb vars, JsonbValue value)

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	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 int	JsonbType (JsonbValue *jb)

static JsonbValue *	JsonbInitBinary (JsonbValue jbv, Jsonb 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 *have_error)

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)

Macro Definition Documentation

◆ jperIsError

#define jperIsError ( jper ) ((jper) == jperError)

Definition at line 137 of file jsonpath_exec.c.

Referenced by executeAnyItem(), executeBinaryArithmExpr(), executeBoolItem(), executeDateTimeMethod(), executeItemOptUnwrapResult(), executeItemOptUnwrapTarget(), executeJsonPath(), executeKeyValueMethod(), executePredicate(), executeUnaryArithmExpr(), getArrayIndex(), and jsonb_path_exists_internal().

◆ jspAutoUnwrap

#define jspAutoUnwrap ( cxt ) ((cxt)->laxMode)

Definition at line 157 of file jsonpath_exec.c.

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

◆ jspAutoWrap

#define jspAutoWrap ( cxt ) ((cxt)->laxMode)

Definition at line 158 of file jsonpath_exec.c.

Referenced by executeItemOptUnwrapTarget().

◆ jspIgnoreStructuralErrors

#define jspIgnoreStructuralErrors ( cxt ) ((cxt)->ignoreStructuralErrors)

Definition at line 159 of file jsonpath_exec.c.

Referenced by executeItemOptUnwrapTarget().

◆ jspStrictAbsenseOfErrors

#define jspStrictAbsenseOfErrors ( cxt ) (!(cxt)->laxMode)

Definition at line 156 of file jsonpath_exec.c.

Referenced by executeBoolItem(), executeJsonPath(), and executePredicate().

◆ jspThrowErrors

#define jspThrowErrors ( cxt ) ((cxt)->throwErrors)

Definition at line 160 of file jsonpath_exec.c.

Referenced by executeBinaryArithmExpr(), executeDateTimeMethod(), and executeItemOptUnwrapTarget().

◆ RETURN_ERROR

#define RETURN_ERROR ( throw_error )

Value:

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

Definition at line 163 of file jsonpath_exec.c.

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

Typedef Documentation

◆ BinaryArithmFunc

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

Definition at line 175 of file jsonpath_exec.c.

◆ JsonBaseObjectInfo

typedef struct JsonBaseObjectInfo JsonBaseObjectInfo

◆ JsonLikeRegexContext

typedef struct JsonLikeRegexContext JsonLikeRegexContext

◆ JsonPathBool

typedef enum JsonPathBool JsonPathBool

◆ JsonPathExecContext

typedef struct JsonPathExecContext JsonPathExecContext

◆ JsonPathExecResult

typedef enum JsonPathExecResult JsonPathExecResult

◆ JsonPathPredicateCallback

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

Definition at line 171 of file jsonpath_exec.c.

◆ JsonValueList

typedef struct JsonValueList JsonValueList

◆ JsonValueListIterator

typedef struct JsonValueListIterator JsonValueListIterator

Enumeration Type Documentation

◆ JsonPathBool

enum JsonPathBool

Enumerator
jpbFalse
jpbTrue
jpbUnknown

Definition at line 122 of file jsonpath_exec.c.

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

◆ JsonPathExecResult

enum JsonPathExecResult

Enumerator
jperOk
jperNotFound
jperError

Definition at line 130 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 2036 of file jsonpath_exec.c.

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

Referenced by executeItemOptUnwrapTarget().

 {
     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);
 }

◆ binaryCompareStrings()

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

static

Definition at line 2170 of file jsonpath_exec.c.

References cmp(), and Min.

Referenced by compareStrings().

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

◆ compareDatetime()

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

static

Definition at line 2579 of file jsonpath_exec.c.

References date2timestamp_opt_error(), date2timestamptz_opt_error(), date_cmp(), DatumGetDateADT, DatumGetInt32, DatumGetTimestamp, DirectFunctionCall1, DirectFunctionCall2, elog, ereport, errcode(), errhint(), errmsg(), ERROR, time_cmp(), time_timetz(), timestamp2timestamptz_opt_error(), timestamp_cmp(), TimestampGetDatum, TimestampTzGetDatum, and timetz_cmp().

Referenced by compareItems().

 {
     PGFunction cmpfunc = NULL;
 
     switch (typid1)
     {
         case DATEOID:
             switch (typid2)
             {
                 case DATEOID:
                     cmpfunc = date_cmp;
 
                     break;
 
                 case TIMESTAMPOID:
                     val1 = TimestampGetDatum(date2timestamp_opt_error(DatumGetDateADT(val1), have_error));
                     if (have_error && *have_error)
                         return 0;
                     cmpfunc = timestamp_cmp;
 
                     break;
 
                 case TIMESTAMPTZOID:
                     if (!useTz)
                         ereport(ERROR,
                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                  errmsg("cannot convert value from %s to %s without timezone usage",
                                         "date", "timestamptz"),
                                  errhint("use *_tz() function for timezone support")));
                     val1 = TimestampTzGetDatum(date2timestamptz_opt_error(DatumGetDateADT(val1), have_error));
                     if (have_error && *have_error)
                         return 0;
                     cmpfunc = timestamp_cmp;
 
                     break;
 
                 case TIMEOID:
                 case TIMETZOID:
                     *have_error = true;
                     return 0;
             }
             break;
 
         case TIMEOID:
             switch (typid2)
             {
                 case TIMEOID:
                     cmpfunc = time_cmp;
 
                     break;
 
                 case TIMETZOID:
                     if (!useTz)
                         ereport(ERROR,
                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                  errmsg("cannot convert value from %s to %s without timezone usage",
                                         "time", "timetz"),
                                  errhint("use *_tz() function for timezone support")));
                     val1 = DirectFunctionCall1(time_timetz, val1);
                     cmpfunc = timetz_cmp;
 
                     break;
 
                 case DATEOID:
                 case TIMESTAMPOID:
                 case TIMESTAMPTZOID:
                     *have_error = true;
                     return 0;
             }
             break;
 
         case TIMETZOID:
             switch (typid2)
             {
                 case TIMEOID:
                     if (!useTz)
                         ereport(ERROR,
                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                  errmsg("cannot convert value from %s to %s without timezone usage",
                                         "time", "timetz"),
                                  errhint("use *_tz() function for timezone support")));
                     val2 = DirectFunctionCall1(time_timetz, val2);
                     cmpfunc = timetz_cmp;
 
                     break;
 
                 case TIMETZOID:
                     cmpfunc = timetz_cmp;
 
                     break;
 
                 case DATEOID:
                 case TIMESTAMPOID:
                 case TIMESTAMPTZOID:
                     *have_error = true;
                     return 0;
             }
             break;
 
         case TIMESTAMPOID:
             switch (typid2)
             {
                 case DATEOID:
                     val2 = TimestampGetDatum(date2timestamp_opt_error(DatumGetDateADT(val2), have_error));
                     if (have_error && *have_error)
                         return 0;
                     cmpfunc = timestamp_cmp;
 
                     break;
 
                 case TIMESTAMPOID:
                     cmpfunc = timestamp_cmp;
 
                     break;
 
                 case TIMESTAMPTZOID:
                     if (!useTz)
                         ereport(ERROR,
                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                  errmsg("cannot convert value from %s to %s without timezone usage",
                                         "timestamp", "timestamptz"),
                                  errhint("use *_tz() function for timezone support")));
                     val1 = TimestampTzGetDatum(timestamp2timestamptz_opt_error(DatumGetTimestamp(val1), have_error));
                     if (have_error && *have_error)
                         return 0;
                     cmpfunc = timestamp_cmp;
 
                     break;
 
                 case TIMEOID:
                 case TIMETZOID:
                     *have_error = true;
                     return 0;
             }
             break;
 
         case TIMESTAMPTZOID:
             switch (typid2)
             {
                 case DATEOID:
                     if (!useTz)
                         ereport(ERROR,
                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                  errmsg("cannot convert value from %s to %s without timezone usage",
                                         "date", "timestamptz"),
                                  errhint("use *_tz() function for timezone support")));
                     val2 = TimestampTzGetDatum(date2timestamptz_opt_error(DatumGetDateADT(val2), have_error));
                     if (have_error && *have_error)
                         return 0;
                     cmpfunc = timestamp_cmp;
 
                     break;
 
                 case TIMESTAMPOID:
                     if (!useTz)
                         ereport(ERROR,
                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                  errmsg("cannot convert value from %s to %s without timezone usage",
                                         "timestamp", "timestamptz"),
                                  errhint("use *_tz() function for timezone support")));
                     val2 = TimestampTzGetDatum(timestamp2timestamptz_opt_error(DatumGetTimestamp(val2), have_error));
                     if (have_error && *have_error)
                         return 0;
                     cmpfunc = timestamp_cmp;
 
                     break;
 
                 case TIMESTAMPTZOID:
                     cmpfunc = timestamp_cmp;
 
                     break;
 
                 case TIMEOID:
                 case TIMETZOID:
                     *have_error = true;
                     return 0;
             }
             break;
 
         default:
             elog(ERROR, "unrecognized SQL/JSON datetime type oid: %d",
                  typid1);
     }
 
     if (*have_error)
         return 0;
 
     if (!cmpfunc)
         elog(ERROR, "unrecognized SQL/JSON datetime type oid: %d",
              typid2);
 
     *have_error = false;
 
     return DatumGetInt32(DirectFunctionCall2(cmpfunc, val1, val2));
 }

◆ compareItems()

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

static

Definition at line 2258 of file jsonpath_exec.c.

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

 {
     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        have_error = false;
 
                 cmp = compareDatetime(jb1->val.datetime.value,
                                       jb1->val.datetime.typid,
                                       jb2->val.datetime.value,
                                       jb2->val.datetime.typid,
                                       useTz,
                                       &have_error);
 
                 if (have_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;
 }

◆ compareNumeric()

static int compareNumeric	(	Numeric	a,
		Numeric	b
	)

static

Definition at line 2354 of file jsonpath_exec.c.

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

Referenced by compareItems().

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

◆ compareStrings()

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

static

Definition at line 2191 of file jsonpath_exec.c.

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

Referenced by compareItems().

 {
     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;
     }
 }

◆ copyJsonbValue()

static JsonbValue * copyJsonbValue ( JsonbValue * src )

static

Definition at line 2362 of file jsonpath_exec.c.

References palloc().

Referenced by executeAnyItem(), and executeNextItem().

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

◆ 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 1380 of file jsonpath_exec.c.

References Assert, check_stack_depth(), copyJsonbValue(), 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 executeItemOptUnwrapTarget(), and executeItemUnwrapTargetArray().

 {
     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;
 }

◆ executeBinaryArithmExpr()

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

static

Definition at line 1551 of file jsonpath_exec.c.

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

Referenced by executeItemOptUnwrapTarget().

 {
     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);
 }

◆ executeBoolItem()

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

static

Definition at line 1226 of file jsonpath_exec.c.

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

Referenced by executeItemOptUnwrapTarget(), and executeNestedBoolItem().

 {
     JsonPathItem larg;
     JsonPathItem rarg;
     JsonPathBool res;
     JsonPathBool res2;
 
     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 (jspStrictAbsenseOfErrors(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;
     }
 }

◆ executeComparison()

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

static

Definition at line 2159 of file jsonpath_exec.c.

References compareItems(), JsonPathItem::type, and JsonPathExecContext::useTz.

Referenced by executeBoolItem().

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

◆ executeDateTimeMethod()

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

static

Definition at line 1779 of file jsonpath_exec.c.

References JsonPathItem::arg, JsonPathItem::content, cstring_to_text(), cstring_to_text_with_len(), elog, ereport, errcode(), errhint(), errmsg(), ERROR, executeNextItem(), getScalar(), i, jbvDatetime, jbvString, jperError, jperIsError, jperNotFound, jperOk, jpiString, jspGetArg(), jspGetNext(), jspGetString(), jspOperationName(), jspThrowErrors, lengthof, MemoryContextSwitchTo(), palloc(), parse_datetime(), pfree(), RETURN_ERROR, TopMemoryContext, JsonPathItem::type, JsonbValue::type, JsonbValue::val, and value.

Referenced by executeItemOptUnwrapTarget().

 {
     JsonbValue  jbvbuf;
     Datum       value;
     text       *datetime;
     Oid         typid;
     int32       typmod = -1;
     int         tz = 0;
     bool        hasNext;
     JsonPathExecResult res = jperNotFound;
     JsonPathItem elem;
 
     if (!(jb = getScalar(jb, jbvString)))
         RETURN_ERROR(ereport(ERROR,
                              (errcode(ERRCODE_INVALID_ARGUMENT_FOR_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);
 
     if (jsp->content.arg)
     {
         text       *template;
         char       *template_str;
         int         template_len;
         bool        have_error = false;
 
         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, true,
                                &typid, &typmod, &tz,
                                jspThrowErrors(cxt) ? NULL : &have_error);
 
         if (have_error)
             res = jperError;
         else
             res = jperOk;
     }
     else
     {
         /*
          * According to SQL/JSON standard enumerate ISO formats for: date,
          * timetz, time, timestamptz, timestamp.
          */
         static const char *fmt_str[] =
         {
             "yyyy-mm-dd",
             "HH24:MI:SS TZH:TZM",
             "HH24:MI:SS TZH",
             "HH24:MI:SS",
             "yyyy-mm-dd HH24:MI:SS TZH:TZM",
             "yyyy-mm-dd HH24:MI:SS TZH",
             "yyyy-mm-dd HH24:MI:SS"
         };
 
         /* cache for format texts */
         static text *fmt_txt[lengthof(fmt_str)] = {0};
         int         i;
 
         /* loop until datetime format fits */
         for (i = 0; i < lengthof(fmt_str); i++)
         {
             bool        have_error = false;
 
             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], true,
                                    &typid, &typmod, &tz,
                                    &have_error);
 
             if (!have_error)
             {
                 res = jperOk;
                 break;
             }
         }
 
         if (res == jperNotFound)
             RETURN_ERROR(ereport(ERROR,
                                  (errcode(ERRCODE_INVALID_ARGUMENT_FOR_JSON_DATETIME_FUNCTION),
                                   errmsg("datetime format is not unrecognized"),
                                   errhint("use datetime template argument for explicit format specification"))));
     }
 
     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);
 }

◆ executeItem()

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

static

Definition at line 600 of file jsonpath_exec.c.

References executeItemOptUnwrapTarget(), and jspAutoUnwrap.

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

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

◆ executeItemOptUnwrapResult()

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

static

Definition at line 1174 of file jsonpath_exec.c.

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

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

 {
     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);
 }

◆ executeItemOptUnwrapResultNoThrow()

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

static

Definition at line 1209 of file jsonpath_exec.c.

References executeItemOptUnwrapResult(), and JsonPathExecContext::throwErrors.

Referenced by executeBoolItem(), and executePredicate().

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

◆ executeItemOptUnwrapTarget()

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

static

Definition at line 612 of file jsonpath_exec.c.

References JsonPathItem::anybounds, appendBoolResult(), JsonPathItem::array, Assert, JsonPathExecContext::baseObject, CHECK_FOR_INTERRUPTS, check_stack_depth(), JsonPathItem::content, JsonPathExecContext::current, DatumGetCString, DatumGetNumeric, DirectFunctionCall1, elog, ereport, errcode(), errmsg(), ERROR, executeAnyItem(), executeBinaryArithmExpr(), executeBoolItem(), executeDateTimeMethod(), executeItemUnwrapTargetArray(), executeKeyValueMethod(), executeNestedBoolItem(), executeNextItem(), executeNumericItemMethod(), executeUnaryArithmExpr(), findJsonbValueFromContainer(), float8_numeric(), Float8GetDatum(), float8in_internal_opt_error(), getArrayIndex(), getIthJsonbValueFromContainer(), getJsonPathItem(), i, JsonPathExecContext::ignoreStructuralErrors, JsonPathExecContext::innermostArraySize, Int32GetDatum, int4_numeric(), isinf(), JB_FOBJECT, jbvArray, jbvBinary, jbvNumeric, jbvObject, jbvString, jpbTrue, jperError, jperIsError, jperNotFound, jperOk, jpiAbs, jpiAdd, jpiAnd, jpiAny, jpiAnyArray, jpiAnyKey, jpiBool, jpiCeiling, jpiCurrent, jpiDatetime, jpiDiv, jpiDouble, jpiEqual, jpiExists, jpiFilter, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiIndexArray, jpiIsUnknown, jpiKey, jpiKeyValue, jpiLast, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiString, jpiSub, jpiType, jpiVariable, JsonbArraySize(), JsonbType(), JsonbTypeName(), jspAutoUnwrap, jspAutoWrap, jspGetArg(), jspGetArraySubscript(), jspGetNext(), jspGetString(), jspHasNext, jspIgnoreStructuralErrors, jspOperationName(), jspThrowErrors, sort-test::key, numeric_abs(), numeric_add_opt_error(), numeric_ceil(), numeric_div_opt_error(), numeric_floor(), numeric_mod_opt_error(), numeric_mul_opt_error(), numeric_out(), numeric_sub_opt_error(), numeric_uminus(), NumericGetDatum, palloc(), pfree(), pnstrdup(), pstrdup(), range(), RETURN_ERROR, JsonPathExecContext::root, setBaseObject(), JsonPathItem::type, JsonbValue::type, JsonbValue::val, and val.

Referenced by executeAnyItem(), and executeItem().

 {
     JsonPathItem elem;
     JsonPathExecResult res = jperNotFound;
     JsonBaseObjectInfo baseObject;
 
     check_stack_depth();
     CHECK_FOR_INTERRUPTS();
 
     switch (jsp->type)
     {
             /* 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 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 jpiRoot:
             jb = cxt->root;
             baseObject = setBaseObject(cxt, jb, 0);
             res = executeNextItem(cxt, jsp, NULL, jb, found, true);
             cxt->baseObject = baseObject;
             break;
 
         case jpiCurrent:
             res = executeNextItem(cxt, jsp, NULL, cxt->current,
                                   found, true);
             break;
 
         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 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 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 =
                     DatumGetNumeric(DirectFunctionCall1(int4_numeric,
                                                         Int32GetDatum(last)));
 
                 res = executeNextItem(cxt, jsp, &elem,
                                       lastjbv, found, hasNext);
             }
             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 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 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 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 jpiNull:
         case jpiBool:
         case jpiNumeric:
         case jpiString:
         case jpiVariable:
             {
                 JsonbValue  vbuf;
                 JsonbValue *v;
                 bool        hasNext = jspGetNext(jsp, &elem);
 
                 if (!hasNext && !found)
                 {
                     res = jperOk;   /* skip evaluation */
                     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;
 
         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 =
                     DatumGetNumeric(DirectFunctionCall1(int4_numeric,
                                                         Int32GetDatum(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)));
                     bool        have_error = false;
 
                     (void) float8in_internal_opt_error(tmp,
                                                        NULL,
                                                        "double precision",
                                                        tmp,
                                                        &have_error);
 
                     if (have_error)
                         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)))));
                     res = jperOk;
                 }
                 else if (jb->type == jbvString)
                 {
                     /* cast string as double */
                     double      val;
                     char       *tmp = pnstrdup(jb->val.string.val,
                                                jb->val.string.len);
                     bool        have_error = false;
 
                     val = float8in_internal_opt_error(tmp,
                                                       NULL,
                                                       "double precision",
                                                       tmp,
                                                       &have_error);
 
                     if (have_error || isinf(val))
                         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)))));
 
                     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:
             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);
 
         default:
             elog(ERROR, "unrecognized jsonpath item type: %d", jsp->type);
     }
 
     return res;
 }

◆ executeItemUnwrapTargetArray()

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

static

Definition at line 1123 of file jsonpath_exec.c.

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

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

 {
     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);
 }

◆ executeJsonPath()

static JsonPathExecResult executeJsonPath	(	JsonPath *	path,
		Jsonb *	vars,
		Jsonb *	json,
		bool	throwErrors,
		JsonValueList *	result,
		bool	useTz
	)

static

Definition at line 540 of file jsonpath_exec.c.

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

 {
     JsonPathExecContext cxt;
     JsonPathExecResult res;
     JsonPathItem jsp;
     JsonbValue  jbv;
 
     jspInit(&jsp, path);
 
     if (!JsonbExtractScalar(&json->root, &jbv))
         JsonbInitBinary(&jbv, json);
 
     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.")));
     }
 
     cxt.vars = vars;
     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;
     cxt.lastGeneratedObjectId = vars ? 2 : 1;
     cxt.innermostArraySize = -1;
     cxt.throwErrors = throwErrors;
     cxt.useTz = useTz;
 
     if (jspStrictAbsenseOfErrors(&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;
 }

◆ executeKeyValueMethod()

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

static

Definition at line 1925 of file jsonpath_exec.c.

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

Referenced by executeItemOptUnwrapTarget().

 {
     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 = DatumGetNumeric(DirectFunctionCall1(int8_numeric,
                                                             Int64GetDatum(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;
 }

◆ executeLikeRegex()

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

static

Definition at line 1713 of file jsonpath_exec.c.

References JsonLikeRegexContext::cflags, JsonPathItem::content, cstring_to_text_with_len(), getScalar(), jbvString, jpbFalse, jpbTrue, jpbUnknown, jspConvertRegexFlags(), JsonPathItem::like_regex, RE_compile_and_execute(), JsonLikeRegexContext::regex, and JsonbValue::val.

Referenced by executeBoolItem().

 {
     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);
         cxt->cflags = jspConvertRegexFlags(jsp->content.like_regex.flags);
     }
 
     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;
 }

◆ executeNestedBoolItem()

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

static

Definition at line 1359 of file jsonpath_exec.c.

References JsonPathExecContext::current, and executeBoolItem().

Referenced by executeItemOptUnwrapTarget().

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

◆ executeNextItem()

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

static

Definition at line 1143 of file jsonpath_exec.c.

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

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

 {
     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;
 }

◆ executeNumericItemMethod()

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

static

Definition at line 1743 of file jsonpath_exec.c.

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

Referenced by executeItemOptUnwrapTarget().

 {
     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);
 }

◆ executePredicate()

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

static

Definition at line 1471 of file jsonpath_exec.c.

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

Referenced by executeBoolItem().

 {
     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 (jspStrictAbsenseOfErrors(cxt))
                     return jpbUnknown;
 
                 error = true;
             }
             else if (res == jpbTrue)
             {
                 if (!jspStrictAbsenseOfErrors(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;
 }

◆ executeStartsWith()

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

static

Definition at line 1689 of file jsonpath_exec.c.

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

Referenced by executeBoolItem().

 {
     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;
 }

◆ executeUnaryArithmExpr()

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

static

Definition at line 1622 of file jsonpath_exec.c.

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

Referenced by executeItemOptUnwrapTarget().

 {
     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;
 }

◆ getArrayIndex()

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

static

Definition at line 2376 of file jsonpath_exec.c.

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

 {
     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;
 }

◆ getJsonPathItem()

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

static

Definition at line 2064 of file jsonpath_exec.c.

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

Referenced by executeItemOptUnwrapTarget().

 {
     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, cxt->vars, value);
             return;
         default:
             elog(ERROR, "unexpected jsonpath item type");
     }
 }

◆ getJsonPathVariable()

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

static

Definition at line 2097 of file jsonpath_exec.c.

References Assert, ereport, errcode(), errmsg(), ERROR, findJsonbValueFromContainer(), JB_FOBJECT, jbvNull, jbvString, jpiVariable, JsonbInitBinary(), jspGetString(), pfree(), pnstrdup(), Jsonb::root, setBaseObject(), JsonPathItem::type, JsonbValue::type, and JsonbValue::val.

Referenced by getJsonPathItem().

 {
     char       *varName;
     int         varNameLength;
     JsonbValue  tmp;
     JsonbValue *v;
 
     if (!vars)
     {
         value->type = jbvNull;
         return;
     }
 
     Assert(variable->type == jpiVariable);
     varName = jspGetString(variable, &varNameLength);
     tmp.type = jbvString;
     tmp.val.string.val = varName;
     tmp.val.string.len = varNameLength;
 
     v = findJsonbValueFromContainer(&vars->root, JB_FOBJECT, &tmp);
 
     if (v)
     {
         *value = *v;
         pfree(v);
     }
     else
     {
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("could not find jsonpath variable \"%s\"",
                         pnstrdup(varName, varNameLength))));
     }
 
     JsonbInitBinary(&tmp, vars);
     setBaseObject(cxt, &tmp, 1);
 }

◆ getScalar()

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

static

Definition at line 2548 of file jsonpath_exec.c.

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

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

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

◆ jsonb_path_exists()

Datum jsonb_path_exists ( PG_FUNCTION_ARGS )

Definition at line 299 of file jsonpath_exec.c.

References jsonb_path_exists_internal().

 {
     return jsonb_path_exists_internal(fcinfo, false);
 }

◆ jsonb_path_exists_internal()

static Datum jsonb_path_exists_internal	(	FunctionCallInfo	fcinfo,
		bool	tz
	)

static

Definition at line 273 of file jsonpath_exec.c.

References executeJsonPath(), 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      *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, 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);
 }

◆ jsonb_path_exists_opr()

Datum jsonb_path_exists_opr ( PG_FUNCTION_ARGS )

Definition at line 316 of file jsonpath_exec.c.

References jsonb_path_exists_internal().

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

◆ jsonb_path_exists_tz()

Datum jsonb_path_exists_tz ( PG_FUNCTION_ARGS )

Definition at line 305 of file jsonpath_exec.c.

References jsonb_path_exists_internal().

 {
     return jsonb_path_exists_internal(fcinfo, true);
 }

◆ jsonb_path_match()

Datum jsonb_path_match ( PG_FUNCTION_ARGS )

Definition at line 367 of file jsonpath_exec.c.

References jsonb_path_match_internal().

 {
     return jsonb_path_match_internal(fcinfo, false);
 }

◆ jsonb_path_match_internal()

static Datum jsonb_path_match_internal	(	FunctionCallInfo	fcinfo,
		bool	tz
	)

static

Definition at line 328 of file jsonpath_exec.c.

References ereport, errcode(), errmsg(), ERROR, executeJsonPath(), 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      *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, 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();
 }

◆ jsonb_path_match_opr()

Datum jsonb_path_match_opr ( PG_FUNCTION_ARGS )

Definition at line 384 of file jsonpath_exec.c.

References jsonb_path_match_internal().

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

◆ jsonb_path_match_tz()

Datum jsonb_path_match_tz ( PG_FUNCTION_ARGS )

Definition at line 373 of file jsonpath_exec.c.

References jsonb_path_match_internal().

 {
     return jsonb_path_match_internal(fcinfo, true);
 }

◆ jsonb_path_query()

Datum jsonb_path_query ( PG_FUNCTION_ARGS )

Definition at line 442 of file jsonpath_exec.c.

References jsonb_path_query_internal().

 {
     return jsonb_path_query_internal(fcinfo, false);
 }

◆ jsonb_path_query_array()

Datum jsonb_path_query_array ( PG_FUNCTION_ARGS )

Definition at line 473 of file jsonpath_exec.c.

References jsonb_path_query_array_internal().

 {
     return jsonb_path_query_array_internal(fcinfo, false);
 }

◆ jsonb_path_query_array_internal()

static Datum jsonb_path_query_array_internal	(	FunctionCallInfo	fcinfo,
		bool	tz
	)

static

Definition at line 459 of file jsonpath_exec.c.

References executeJsonPath(), 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      *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, jb, !silent, &found, tz);
 
     PG_RETURN_JSONB_P(JsonbValueToJsonb(wrapItemsInArray(&found)));
 }

◆ jsonb_path_query_array_tz()

Datum jsonb_path_query_array_tz ( PG_FUNCTION_ARGS )

Definition at line 479 of file jsonpath_exec.c.

References jsonb_path_query_array_internal().

 {
     return jsonb_path_query_array_internal(fcinfo, true);
 }

◆ jsonb_path_query_first()

Datum jsonb_path_query_first ( PG_FUNCTION_ARGS )

Definition at line 507 of file jsonpath_exec.c.

References jsonb_path_query_first_internal().

 {
     return jsonb_path_query_first_internal(fcinfo, false);
 }

◆ jsonb_path_query_first_internal()

static Datum jsonb_path_query_first_internal	(	FunctionCallInfo	fcinfo,
		bool	tz
	)

static

Definition at line 490 of file jsonpath_exec.c.

References executeJsonPath(), 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      *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, jb, !silent, &found, tz);
 
     if (JsonValueListLength(&found) >= 1)
         PG_RETURN_JSONB_P(JsonbValueToJsonb(JsonValueListHead(&found)));
     else
         PG_RETURN_NULL();
 }

◆ jsonb_path_query_first_tz()

Datum jsonb_path_query_first_tz ( PG_FUNCTION_ARGS )

Definition at line 513 of file jsonpath_exec.c.

References jsonb_path_query_first_internal().

 {
     return jsonb_path_query_first_internal(fcinfo, true);
 }

◆ jsonb_path_query_internal()

static Datum jsonb_path_query_internal	(	FunctionCallInfo	fcinfo,
		bool	tz
	)

static

Definition at line 396 of file jsonpath_exec.c.

References executeJsonPath(), 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().

 {
     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, 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)));
 }

◆ jsonb_path_query_tz()

Datum jsonb_path_query_tz ( PG_FUNCTION_ARGS )

Definition at line 448 of file jsonpath_exec.c.

References jsonb_path_query_internal().

 {
     return jsonb_path_query_internal(fcinfo, true);
 }

◆ JsonbArraySize()

static int JsonbArraySize ( JsonbValue * jb )

static

Definition at line 2142 of file jsonpath_exec.c.

References Assert, JsonBaseObjectInfo::jbc, jbvArray, jbvBinary, JsonContainerIsArray, JsonContainerIsScalar, JsonContainerSize, JsonbValue::type, and JsonbValue::val.

Referenced by executeItemOptUnwrapTarget().

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

◆ JsonbInitBinary()

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

static

Definition at line 2511 of file jsonpath_exec.c.

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

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

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

◆ JsonbType()

static int JsonbType ( JsonbValue * jb )

static

Definition at line 2524 of file jsonpath_exec.c.

References Assert, elog, ERROR, JsonbContainer::header, JsonBaseObjectInfo::jbc, jbvArray, jbvBinary, jbvObject, JsonContainerIsArray, JsonContainerIsObject, JsonContainerIsScalar, JsonbValue::type, generate_unaccent_rules::type, and JsonbValue::val.

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

 {
     int         type = jb->type;
 
     if (jb->type == jbvBinary)
     {
         JsonbContainer *jbc = (void *) 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;
 }

◆ JsonValueListAppend()

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

static

Definition at line 2423 of file jsonpath_exec.c.

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

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

 {
     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);
 }

◆ JsonValueListGetList()

static List * JsonValueListGetList ( JsonValueList * jvl )

static

Definition at line 2455 of file jsonpath_exec.c.

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

Referenced by jsonb_path_query_internal().

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

◆ JsonValueListHead()

static JsonbValue * JsonValueListHead ( JsonValueList * jvl )

static

Definition at line 2449 of file jsonpath_exec.c.

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

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

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

◆ JsonValueListInitIterator()

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

static

Definition at line 2464 of file jsonpath_exec.c.

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

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

 {
     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;
     }
 }

◆ JsonValueListIsEmpty()

static bool JsonValueListIsEmpty ( JsonValueList * jvl )

static

Definition at line 2443 of file jsonpath_exec.c.

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

Referenced by executeBoolItem(), and executeJsonPath().

 {
     return !jvl->singleton && list_length(jvl->list) <= 0;
 }

◆ JsonValueListLength()

static int JsonValueListLength ( const JsonValueList * jvl )

static

Definition at line 2437 of file jsonpath_exec.c.

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

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

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

◆ JsonValueListNext()

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

static

Definition at line 2490 of file jsonpath_exec.c.

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

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

 {
     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;
 }

◆ setBaseObject()

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

static

Definition at line 2411 of file jsonpath_exec.c.

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

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

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

◆ wrapItemsInArray()

static JsonbValue * wrapItemsInArray ( const JsonValueList * items )

static

Definition at line 2559 of file jsonpath_exec.c.

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

Referenced by jsonb_path_query_array_internal().

 {
     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);
 }

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ jperIsError

◆ jspAutoUnwrap

◆ jspAutoWrap

◆ jspIgnoreStructuralErrors

◆ jspStrictAbsenseOfErrors

◆ jspThrowErrors

◆ RETURN_ERROR

Typedef Documentation

◆ BinaryArithmFunc

◆ JsonBaseObjectInfo

◆ JsonLikeRegexContext

◆ JsonPathBool

◆ JsonPathExecContext

◆ JsonPathExecResult

◆ JsonPathPredicateCallback

◆ JsonValueList

◆ JsonValueListIterator

Enumeration Type Documentation

◆ JsonPathBool

◆ JsonPathExecResult

Function Documentation

◆ appendBoolResult()

◆ binaryCompareStrings()

◆ compareDatetime()

◆ compareItems()

◆ compareNumeric()

◆ compareStrings()

◆ copyJsonbValue()

◆ executeAnyItem()

◆ executeBinaryArithmExpr()

◆ executeBoolItem()

◆ executeComparison()

◆ executeDateTimeMethod()

◆ executeItem()

◆ executeItemOptUnwrapResult()

◆ executeItemOptUnwrapResultNoThrow()

◆ executeItemOptUnwrapTarget()

◆ executeItemUnwrapTargetArray()

◆ executeJsonPath()

◆ executeKeyValueMethod()

◆ executeLikeRegex()

◆ executeNestedBoolItem()

◆ executeNextItem()

◆ executeNumericItemMethod()

◆ executePredicate()

◆ executeStartsWith()

◆ executeUnaryArithmExpr()

◆ getArrayIndex()

◆ getJsonPathItem()

◆ getJsonPathVariable()

◆ getScalar()

◆ jsonb_path_exists()

◆ jsonb_path_exists_internal()

◆ jsonb_path_exists_opr()

◆ jsonb_path_exists_tz()

◆ jsonb_path_match()

◆ jsonb_path_match_internal()

◆ jsonb_path_match_opr()

◆ jsonb_path_match_tz()

◆ jsonb_path_query()

◆ jsonb_path_query_array()

◆ jsonb_path_query_array_internal()

◆ jsonb_path_query_array_tz()

◆ jsonb_path_query_first()

◆ jsonb_path_query_first_internal()

◆ jsonb_path_query_first_tz()

◆ jsonb_path_query_internal()

◆ jsonb_path_query_tz()

◆ JsonbArraySize()

◆ JsonbInitBinary()

◆ JsonbType()

◆ JsonValueListAppend()

◆ JsonValueListGetList()

◆ JsonValueListHead()