#include "fmgr.h"
#include "executor/tablefunc.h"
#include "nodes/pg_list.h"
#include "nodes/primnodes.h"
#include "utils/jsonb.h"
#include "utils/jsonfuncs.h"

Include dependency graph for jsonpath.h:

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

Go to the source code of this file.

Data Structures
struct	JsonPath

struct	JsonPathItem

struct	JsonPathParseItem

struct	JsonPathParseResult

struct	JsonPathVariableEvalContext

Macros
#define	JSONPATH_VERSION (0x01)

#define	JSONPATH_LAX (0x80000000)

#define	JSONPATH_HDRSZ (offsetof(JsonPath, data))

#define	DatumGetJsonPathP(d) ((JsonPath *) DatumGetPointer(PG_DETOAST_DATUM(d)))

#define	DatumGetJsonPathPCopy(d) ((JsonPath *) DatumGetPointer(PG_DETOAST_DATUM_COPY(d)))

#define	PG_GETARG_JSONPATH_P(x) DatumGetJsonPathP(PG_GETARG_DATUM(x))

#define	PG_GETARG_JSONPATH_P_COPY(x) DatumGetJsonPathPCopy(PG_GETARG_DATUM(x))

#define	PG_RETURN_JSONPATH_P(p) PG_RETURN_POINTER(p)

#define	jspIsScalar(type) ((type) >= jpiNull && (type) <= jpiBool)

#define	JSP_REGEX_ICASE 0x01 /* i flag, case insensitive */

#define	JSP_REGEX_DOTALL 0x02 /* s flag, dot matches newline */

#define	JSP_REGEX_MLINE 0x04 /* m flag, ^/$ match at newlines */

#define	JSP_REGEX_WSPACE 0x08 /* x flag, ignore whitespace in pattern */

#define	JSP_REGEX_QUOTE 0x10 /* q flag, no special characters */

#define	jspHasNext(jsp) ((jsp)->nextPos > 0)

Typedefs
typedef enum JsonPathItemType	JsonPathItemType

typedef struct JsonPathItem	JsonPathItem

typedef struct JsonPathParseItem	JsonPathParseItem

typedef struct JsonPathParseResult	JsonPathParseResult

typedef struct JsonPathVariableEvalContext	JsonPathVariableEvalContext

Enumerations
enum	JsonPathItemType { jpiNull = jbvNull , jpiString = jbvString , jpiNumeric = jbvNumeric , jpiBool = jbvBool , jpiAnd , jpiOr , jpiNot , jpiIsUnknown , jpiEqual , jpiNotEqual , jpiLess , jpiGreater , jpiLessOrEqual , jpiGreaterOrEqual , jpiAdd , jpiSub , jpiMul , jpiDiv , jpiMod , jpiPlus , jpiMinus , jpiAnyArray , jpiAnyKey , jpiIndexArray , jpiAny , jpiKey , jpiCurrent , jpiRoot , jpiVariable , jpiFilter , jpiExists , jpiType , jpiSize , jpiAbs , jpiFloor , jpiCeiling , jpiDouble , jpiDatetime , jpiKeyValue , jpiSubscript , jpiLast , jpiStartsWith , jpiLikeRegex }

Functions
void	jspInit (JsonPathItem v, JsonPath js)

void	jspInitByBuffer (JsonPathItem v, char base, int32 pos)

bool	jspGetNext (JsonPathItem v, JsonPathItem a)

void	jspGetArg (JsonPathItem v, JsonPathItem a)

void	jspGetLeftArg (JsonPathItem v, JsonPathItem a)

void	jspGetRightArg (JsonPathItem v, JsonPathItem a)

Numeric	jspGetNumeric (JsonPathItem *v)

bool	jspGetBool (JsonPathItem *v)

char *	jspGetString (JsonPathItem v, int32 len)

bool	jspGetArraySubscript (JsonPathItem v, JsonPathItem from, JsonPathItem *to, int i)

bool	jspIsMutable (JsonPath path, List varnames, List *varexprs)

const char *	jspOperationName (JsonPathItemType type)

JsonPathParseResult *	parsejsonpath (const char *str, int len)

int	jspConvertRegexFlags (uint32 xflags)

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

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

Datum	JsonPathQuery (Datum jb, JsonPath jp, JsonWrapper wrapper, bool empty, bool error, List vars)

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

int	EvalJsonPathVar (void vars, char varName, int varNameLen, JsonbValue val, JsonbValue baseObject)

Variables
PGDLLIMPORT const TableFuncRoutine	JsonbTableRoutine

Macro Definition Documentation

◆ DatumGetJsonPathP

#define DatumGetJsonPathP ( d ) ((JsonPath *) DatumGetPointer(PG_DETOAST_DATUM(d)))

Definition at line 35 of file jsonpath.h.

◆ DatumGetJsonPathPCopy

#define DatumGetJsonPathPCopy ( d ) ((JsonPath *) DatumGetPointer(PG_DETOAST_DATUM_COPY(d)))

Definition at line 36 of file jsonpath.h.

◆ JSONPATH_HDRSZ

#define JSONPATH_HDRSZ (offsetof(JsonPath, data))

Definition at line 33 of file jsonpath.h.

◆ JSONPATH_LAX

#define JSONPATH_LAX (0x80000000)

Definition at line 32 of file jsonpath.h.

◆ JSONPATH_VERSION

#define JSONPATH_VERSION (0x01)

Definition at line 31 of file jsonpath.h.

◆ JSP_REGEX_DOTALL

#define JSP_REGEX_DOTALL 0x02 /* s flag, dot matches newline */

Definition at line 95 of file jsonpath.h.

◆ JSP_REGEX_ICASE

#define JSP_REGEX_ICASE 0x01 /* i flag, case insensitive */

Definition at line 94 of file jsonpath.h.

◆ JSP_REGEX_MLINE

#define JSP_REGEX_MLINE 0x04 /* m flag, ^/$ match at newlines */

Definition at line 96 of file jsonpath.h.

◆ JSP_REGEX_QUOTE

#define JSP_REGEX_QUOTE 0x10 /* q flag, no special characters */

Definition at line 98 of file jsonpath.h.

◆ JSP_REGEX_WSPACE

#define JSP_REGEX_WSPACE 0x08 /* x flag, ignore whitespace in pattern */

Definition at line 97 of file jsonpath.h.

◆ jspHasNext

#define jspHasNext ( jsp ) ((jsp)->nextPos > 0)

Definition at line 167 of file jsonpath.h.

◆ jspIsScalar

#define jspIsScalar ( type ) ((type) >= jpiNull && (type) <= jpiBool)

Definition at line 41 of file jsonpath.h.

◆ PG_GETARG_JSONPATH_P

#define PG_GETARG_JSONPATH_P ( x ) DatumGetJsonPathP(PG_GETARG_DATUM(x))

Definition at line 37 of file jsonpath.h.

◆ PG_GETARG_JSONPATH_P_COPY

#define PG_GETARG_JSONPATH_P_COPY ( x ) DatumGetJsonPathPCopy(PG_GETARG_DATUM(x))

Definition at line 38 of file jsonpath.h.

◆ PG_RETURN_JSONPATH_P

#define PG_RETURN_JSONPATH_P ( p ) PG_RETURN_POINTER(p)

Definition at line 39 of file jsonpath.h.

Typedef Documentation

◆ JsonPathItem

typedef struct JsonPathItem JsonPathItem

◆ JsonPathItemType

typedef enum JsonPathItemType JsonPathItemType

◆ JsonPathParseItem

typedef struct JsonPathParseItem JsonPathParseItem

Definition at line 182 of file jsonpath.h.

◆ JsonPathParseResult

typedef struct JsonPathParseResult JsonPathParseResult

◆ JsonPathVariableEvalContext

typedef struct JsonPathVariableEvalContext JsonPathVariableEvalContext

Enumeration Type Documentation

◆ JsonPathItemType

enum JsonPathItemType

Enumerator
jpiNull
jpiString
jpiNumeric
jpiBool
jpiAnd
jpiOr
jpiNot
jpiIsUnknown
jpiEqual
jpiNotEqual
jpiLess
jpiGreater
jpiLessOrEqual
jpiGreaterOrEqual
jpiAdd
jpiSub
jpiMul
jpiDiv
jpiMod
jpiPlus
jpiMinus
jpiAnyArray
jpiAnyKey
jpiIndexArray
jpiAny
jpiKey
jpiCurrent
jpiRoot
jpiVariable
jpiFilter
jpiExists
jpiType
jpiSize
jpiAbs
jpiFloor
jpiCeiling
jpiDouble
jpiDatetime
jpiKeyValue
jpiSubscript
jpiLast
jpiStartsWith
jpiLikeRegex

Definition at line 46 of file jsonpath.h.

 {
     jpiNull = jbvNull,          /* NULL literal */
     jpiString = jbvString,      /* string literal */
     jpiNumeric = jbvNumeric,    /* numeric literal */
     jpiBool = jbvBool,          /* boolean literal: TRUE or FALSE */
     jpiAnd,                     /* predicate && predicate */
     jpiOr,                      /* predicate || predicate */
     jpiNot,                     /* ! predicate */
     jpiIsUnknown,               /* (predicate) IS UNKNOWN */
     jpiEqual,                   /* expr == expr */
     jpiNotEqual,                /* expr != expr */
     jpiLess,                    /* expr < expr */
     jpiGreater,                 /* expr > expr */
     jpiLessOrEqual,             /* expr <= expr */
     jpiGreaterOrEqual,          /* expr >= expr */
     jpiAdd,                     /* expr + expr */
     jpiSub,                     /* expr - expr */
     jpiMul,                     /* expr * expr */
     jpiDiv,                     /* expr / expr */
     jpiMod,                     /* expr % expr */
     jpiPlus,                    /* + expr */
     jpiMinus,                   /* - expr */
     jpiAnyArray,                /* [*] */
     jpiAnyKey,                  /* .* */
     jpiIndexArray,              /* [subscript, ...] */
     jpiAny,                     /* .** */
     jpiKey,                     /* .key */
     jpiCurrent,                 /* @ */
     jpiRoot,                    /* $ */
     jpiVariable,                /* $variable */
     jpiFilter,                  /* ? (predicate) */
     jpiExists,                  /* EXISTS (expr) predicate */
     jpiType,                    /* .type() item method */
     jpiSize,                    /* .size() item method */
     jpiAbs,                     /* .abs() item method */
     jpiFloor,                   /* .floor() item method */
     jpiCeiling,                 /* .ceiling() item method */
     jpiDouble,                  /* .double() item method */
     jpiDatetime,                /* .datetime() item method */
     jpiKeyValue,                /* .keyvalue() item method */
     jpiSubscript,               /* array subscript: 'expr' or 'expr TO expr' */
     jpiLast,                    /* LAST array subscript */
     jpiStartsWith,              /* STARTS WITH predicate */
     jpiLikeRegex,               /* LIKE_REGEX predicate */
 } JsonPathItemType;

Function Documentation

◆ EvalJsonPathVar()

int EvalJsonPathVar	(	void *	vars,
		char *	varName,
		int	varNameLen,
		JsonbValue *	val,
		JsonbValue *	baseObject
	)

Definition at line 4695 of file execExprInterp.c.

 {
     JsonPathVariableEvalContext *var = NULL;
     List       *vars = cxt;
     ListCell   *lc;
     int         id = 1;
  
     if (!varName)
         return list_length(vars);
  
     foreach(lc, vars)
     {
         var = lfirst(lc);
  
         if (!strncmp(var->name, varName, varNameLen))
             break;
  
         var = NULL;
         id++;
     }
  
     if (!var)
         return -1;
  
     if (!var->evaluated)
     {
         MemoryContext oldcxt = var->mcxt ?
         MemoryContextSwitchTo(var->mcxt) : NULL;
  
         var->value = ExecEvalExpr(var->estate, var->econtext, &var->isnull);
         var->evaluated = true;
  
         if (oldcxt)
             MemoryContextSwitchTo(oldcxt);
     }
  
     if (var->isnull)
     {
         val->type = jbvNull;
         return 0;
     }
  
     JsonItemFromDatum(var->value, var->typid, var->typmod, val);
  
     *baseObject = *val;
     return id;
 }

References ExecEvalExpr(), jbvNull, JsonItemFromDatum(), lfirst, list_length(), MemoryContextSwitchTo(), val, and ExprEvalStep::var.

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

◆ JsonItemFromDatum()

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

Definition at line 3062 of file jsonpath_exec.c.

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

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

Referenced by EvalJsonPathVar().

◆ JsonPathExists()

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

Definition at line 2904 of file jsonpath_exec.c.

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

References Assert(), DatumGetJsonbP, error(), EvalJsonPathVar(), executeJsonPath(), jperIsError, jperOk, and res.

Referenced by ExecEvalJsonExpr().

◆ JsonPathQuery()

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

Definition at line 2919 of file jsonpath_exec.c.

 {
     JsonbValue *first;
     bool        wrap;
     JsonValueList found = {0};
     JsonPathExecResult res PG_USED_FOR_ASSERTS_ONLY;
     int         count;
  
     res = executeJsonPath(jp, vars, EvalJsonPathVar, DatumGetJsonbP(jb), !error,
                           &found, true);
  
     Assert(error || !jperIsError(res));
  
     if (error && jperIsError(res))
     {
         *error = true;
         *empty = false;
         return (Datum) 0;
     }
  
     count = JsonValueListLength(&found);
  
     first = count ? JsonValueListHead(&found) : NULL;
  
     if (!first)
         wrap = false;
     else if (wrapper == JSW_NONE)
         wrap = false;
     else if (wrapper == JSW_UNCONDITIONAL)
         wrap = true;
     else if (wrapper == JSW_CONDITIONAL)
         wrap = count > 1 ||
             IsAJsonbScalar(first) ||
             (first->type == jbvBinary &&
              JsonContainerIsScalar(first->val.binary.data));
     else
     {
         elog(ERROR, "unrecognized json wrapper %d", wrapper);
         wrap = false;
     }
  
     if (wrap)
         return JsonbPGetDatum(JsonbValueToJsonb(wrapItemsInArray(&found)));
  
     if (count > 1)
     {
         if (error)
         {
             *error = true;
             return (Datum) 0;
         }
  
         ereport(ERROR,
                 (errcode(ERRCODE_MORE_THAN_ONE_SQL_JSON_ITEM),
                  errmsg("JSON path expression in JSON_QUERY should return "
                         "singleton item without wrapper"),
                  errhint("use WITH WRAPPER clause to wrap SQL/JSON item "
                          "sequence into array")));
     }
  
     if (first)
         return JsonbPGetDatum(JsonbValueToJsonb(first));
  
     *empty = true;
     return PointerGetDatum(NULL);
 }

References Assert(), DatumGetJsonbP, elog(), ereport, errcode(), errhint(), errmsg(), ERROR, error(), EvalJsonPathVar(), executeJsonPath(), IsAJsonbScalar, jbvBinary, jperIsError, JsonbPGetDatum, JsonbValueToJsonb(), JsonContainerIsScalar, JsonValueListHead(), JsonValueListLength(), JSW_CONDITIONAL, JSW_NONE, JSW_UNCONDITIONAL, PG_USED_FOR_ASSERTS_ONLY, PointerGetDatum, res, JsonbValue::type, JsonbValue::val, and wrapItemsInArray().

Referenced by ExecEvalJsonExpr().

◆ JsonPathValue()

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

Definition at line 2988 of file jsonpath_exec.c.

 {
     JsonbValue *res;
     JsonValueList found = {0};
     JsonPathExecResult jper PG_USED_FOR_ASSERTS_ONLY;
     int         count;
  
     jper = executeJsonPath(jp, vars, EvalJsonPathVar, DatumGetJsonbP(jb), !error,
                            &found, true);
  
     Assert(error || !jperIsError(jper));
  
     if (error && jperIsError(jper))
     {
         *error = true;
         *empty = false;
         return NULL;
     }
  
     count = JsonValueListLength(&found);
  
     *empty = !count;
  
     if (*empty)
         return NULL;
  
     if (count > 1)
     {
         if (error)
         {
             *error = true;
             return NULL;
         }
  
         ereport(ERROR,
                 (errcode(ERRCODE_MORE_THAN_ONE_SQL_JSON_ITEM),
                  errmsg("JSON path expression in JSON_VALUE should return "
                         "singleton scalar item")));
     }
  
     res = JsonValueListHead(&found);
  
     if (res->type == jbvBinary &&
         JsonContainerIsScalar(res->val.binary.data))
         JsonbExtractScalar(res->val.binary.data, res);
  
     if (!IsAJsonbScalar(res))
     {
         if (error)
         {
             *error = true;
             return NULL;
         }
  
         ereport(ERROR,
                 (errcode(ERRCODE_SQL_JSON_SCALAR_REQUIRED),
                  errmsg("JSON path expression in JSON_VALUE should return "
                         "singleton scalar item")));
     }
  
     if (res->type == jbvNull)
         return NULL;
  
     return res;
 }

References Assert(), pg_result::binary, DatumGetJsonbP, ereport, errcode(), errmsg(), ERROR, error(), EvalJsonPathVar(), executeJsonPath(), IsAJsonbScalar, jbvBinary, jbvNull, jperIsError, JsonbExtractScalar(), JsonContainerIsScalar, JsonValueListHead(), JsonValueListLength(), PG_USED_FOR_ASSERTS_ONLY, and res.

Referenced by ExecEvalJsonExpr().

◆ jspConvertRegexFlags()

int jspConvertRegexFlags ( uint32 xflags )

Referenced by executeLikeRegex().

◆ jspGetArg()

void jspGetArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 929 of file jsonpath.c.

 {
     Assert(v->type == jpiFilter ||
            v->type == jpiNot ||
            v->type == jpiIsUnknown ||
            v->type == jpiExists ||
            v->type == jpiPlus ||
            v->type == jpiMinus ||
            v->type == jpiDatetime);
  
     jspInitByBuffer(a, v->base, v->content.arg);
 }

References a, JsonPathItem::arg, Assert(), JsonPathItem::base, JsonPathItem::content, jpiDatetime, jpiExists, jpiFilter, jpiIsUnknown, jpiMinus, jpiNot, jpiPlus, jspInitByBuffer(), and JsonPathItem::type.

Referenced by executeBoolItem(), executeDateTimeMethod(), executeItemOptUnwrapTarget(), executeUnaryArithmExpr(), extract_jsp_bool_expr(), extract_jsp_path_expr_nodes(), jspIsMutableWalker(), and printJsonPathItem().

◆ jspGetArraySubscript()

bool jspGetArraySubscript	(	JsonPathItem *	v,
		JsonPathItem *	from,
		JsonPathItem *	to,
		int	i
	)

Definition at line 1068 of file jsonpath.c.

 {
     Assert(v->type == jpiIndexArray);
  
     jspInitByBuffer(from, v->base, v->content.array.elems[i].from);
  
     if (!v->content.array.elems[i].to)
         return false;
  
     jspInitByBuffer(to, v->base, v->content.array.elems[i].to);
  
     return true;
 }

References JsonPathItem::array, Assert(), JsonPathItem::base, JsonPathItem::content, i, jpiIndexArray, jspInitByBuffer(), and JsonPathItem::type.

Referenced by executeItemOptUnwrapTarget(), jspIsMutableWalker(), and printJsonPathItem().

◆ jspGetBool()

bool jspGetBool ( JsonPathItem * v )

Definition at line 1040 of file jsonpath.c.

 {
     Assert(v->type == jpiBool);
  
     return (bool) *v->content.value.data;
 }

References Assert(), JsonPathItem::content, jpiBool, JsonPathItem::type, and JsonPathItem::value.

Referenced by getJsonPathItem(), and printJsonPathItem().

◆ jspGetLeftArg()

void jspGetLeftArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 998 of file jsonpath.c.

 {
     Assert(v->type == jpiAnd ||
            v->type == jpiOr ||
            v->type == jpiEqual ||
            v->type == jpiNotEqual ||
            v->type == jpiLess ||
            v->type == jpiGreater ||
            v->type == jpiLessOrEqual ||
            v->type == jpiGreaterOrEqual ||
            v->type == jpiAdd ||
            v->type == jpiSub ||
            v->type == jpiMul ||
            v->type == jpiDiv ||
            v->type == jpiMod ||
            v->type == jpiStartsWith);
  
     jspInitByBuffer(a, v->base, v->content.args.left);
 }

References a, JsonPathItem::args, Assert(), JsonPathItem::base, JsonPathItem::content, jpiAdd, jpiAnd, jpiDiv, jpiEqual, jpiGreater, jpiGreaterOrEqual, jpiLess, jpiLessOrEqual, jpiMod, jpiMul, jpiNotEqual, jpiOr, jpiStartsWith, jpiSub, jspInitByBuffer(), and JsonPathItem::type.

Referenced by executeBinaryArithmExpr(), executeBoolItem(), extract_jsp_bool_expr(), jspIsMutableWalker(), and printJsonPathItem().

◆ jspGetNext()

bool jspGetNext	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 943 of file jsonpath.c.

 {
     if (jspHasNext(v))
     {
         Assert(v->type == jpiString ||
                v->type == jpiNumeric ||
                v->type == jpiBool ||
                v->type == jpiNull ||
                v->type == jpiKey ||
                v->type == jpiAny ||
                v->type == jpiAnyArray ||
                v->type == jpiAnyKey ||
                v->type == jpiIndexArray ||
                v->type == jpiFilter ||
                v->type == jpiCurrent ||
                v->type == jpiExists ||
                v->type == jpiRoot ||
                v->type == jpiVariable ||
                v->type == jpiLast ||
                v->type == jpiAdd ||
                v->type == jpiSub ||
                v->type == jpiMul ||
                v->type == jpiDiv ||
                v->type == jpiMod ||
                v->type == jpiPlus ||
                v->type == jpiMinus ||
                v->type == jpiEqual ||
                v->type == jpiNotEqual ||
                v->type == jpiGreater ||
                v->type == jpiGreaterOrEqual ||
                v->type == jpiLess ||
                v->type == jpiLessOrEqual ||
                v->type == jpiAnd ||
                v->type == jpiOr ||
                v->type == jpiNot ||
                v->type == jpiIsUnknown ||
                v->type == jpiType ||
                v->type == jpiSize ||
                v->type == jpiAbs ||
                v->type == jpiFloor ||
                v->type == jpiCeiling ||
                v->type == jpiDouble ||
                v->type == jpiDatetime ||
                v->type == jpiKeyValue ||
                v->type == jpiStartsWith);
  
         if (a)
             jspInitByBuffer(a, v->base, v->nextPos);
         return true;
     }
  
     return false;
 }

References a, Assert(), JsonPathItem::base, 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, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiString, jpiSub, jpiType, jpiVariable, jspHasNext, jspInitByBuffer(), JsonPathItem::nextPos, and JsonPathItem::type.

Referenced by appendBoolResult(), executeBinaryArithmExpr(), executeDateTimeMethod(), executeItemOptUnwrapTarget(), executeKeyValueMethod(), executeNextItem(), executeNumericItemMethod(), executeUnaryArithmExpr(), extract_jsp_path_expr_nodes(), jspIsMutableWalker(), and printJsonPathItem().

◆ jspGetNumeric()

Numeric jspGetNumeric ( JsonPathItem * v )

Definition at line 1048 of file jsonpath.c.

 {
     Assert(v->type == jpiNumeric);
  
     return (Numeric) v->content.value.data;
 }

References Assert(), JsonPathItem::content, jpiNumeric, JsonPathItem::type, and JsonPathItem::value.

Referenced by getJsonPathItem(), and printJsonPathItem().

◆ jspGetRightArg()

void jspGetRightArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 1019 of file jsonpath.c.

 {
     Assert(v->type == jpiAnd ||
            v->type == jpiOr ||
            v->type == jpiEqual ||
            v->type == jpiNotEqual ||
            v->type == jpiLess ||
            v->type == jpiGreater ||
            v->type == jpiLessOrEqual ||
            v->type == jpiGreaterOrEqual ||
            v->type == jpiAdd ||
            v->type == jpiSub ||
            v->type == jpiMul ||
            v->type == jpiDiv ||
            v->type == jpiMod ||
            v->type == jpiStartsWith);
  
     jspInitByBuffer(a, v->base, v->content.args.right);
 }

References a, JsonPathItem::args, Assert(), JsonPathItem::base, JsonPathItem::content, jpiAdd, jpiAnd, jpiDiv, jpiEqual, jpiGreater, jpiGreaterOrEqual, jpiLess, jpiLessOrEqual, jpiMod, jpiMul, jpiNotEqual, jpiOr, jpiStartsWith, jpiSub, jspInitByBuffer(), and JsonPathItem::type.

Referenced by executeBinaryArithmExpr(), executeBoolItem(), extract_jsp_bool_expr(), jspIsMutableWalker(), and printJsonPathItem().

◆ jspGetString()

char* jspGetString	(	JsonPathItem *	v,
		int32 *	len
	)

Definition at line 1056 of file jsonpath.c.

 {
     Assert(v->type == jpiKey ||
            v->type == jpiString ||
            v->type == jpiVariable);
  
     if (len)
         *len = v->content.value.datalen;
     return v->content.value.data;
 }

References Assert(), JsonPathItem::content, jpiKey, jpiString, jpiVariable, len, JsonPathItem::type, and JsonPathItem::value.

Referenced by executeDateTimeMethod(), executeItemOptUnwrapTarget(), getJsonPathItem(), getJsonPathVariable(), jsonb_ops__add_path_item(), jsonb_path_ops__add_path_item(), jspIsMutableWalker(), and printJsonPathItem().

◆ jspInit()

void jspInit	(	JsonPathItem *	v,
		JsonPath *	js
	)

Definition at line 839 of file jsonpath.c.

 {
     Assert((js->header & ~JSONPATH_LAX) == JSONPATH_VERSION);
     jspInitByBuffer(v, js->data, 0);
 }

References Assert(), JsonPath::data, JsonPath::header, JSONPATH_LAX, JSONPATH_VERSION, and jspInitByBuffer().

Referenced by executeJsonPath(), extract_jsp_query(), jsonPathToCstring(), and jspIsMutable().

◆ jspInitByBuffer()

void jspInitByBuffer	(	JsonPathItem *	v,
		char *	base,
		int32	pos
	)

Definition at line 849 of file jsonpath.c.

 {
     v->base = base + pos;
  
     read_byte(v->type, base, pos);
     pos = INTALIGN((uintptr_t) (base + pos)) - (uintptr_t) base;
     read_int32(v->nextPos, base, pos);
  
     switch (v->type)
     {
         case jpiNull:
         case jpiRoot:
         case jpiCurrent:
         case jpiAnyArray:
         case jpiAnyKey:
         case jpiType:
         case jpiSize:
         case jpiAbs:
         case jpiFloor:
         case jpiCeiling:
         case jpiDouble:
         case jpiKeyValue:
         case jpiLast:
             break;
         case jpiKey:
         case jpiString:
         case jpiVariable:
             read_int32(v->content.value.datalen, base, pos);
             /* FALLTHROUGH */
         case jpiNumeric:
         case jpiBool:
             v->content.value.data = base + pos;
             break;
         case jpiAnd:
         case jpiOr:
         case jpiAdd:
         case jpiSub:
         case jpiMul:
         case jpiDiv:
         case jpiMod:
         case jpiEqual:
         case jpiNotEqual:
         case jpiLess:
         case jpiGreater:
         case jpiLessOrEqual:
         case jpiGreaterOrEqual:
         case jpiStartsWith:
             read_int32(v->content.args.left, base, pos);
             read_int32(v->content.args.right, base, pos);
             break;
         case jpiLikeRegex:
             read_int32(v->content.like_regex.flags, base, pos);
             read_int32(v->content.like_regex.expr, base, pos);
             read_int32(v->content.like_regex.patternlen, base, pos);
             v->content.like_regex.pattern = base + pos;
             break;
         case jpiNot:
         case jpiExists:
         case jpiIsUnknown:
         case jpiPlus:
         case jpiMinus:
         case jpiFilter:
         case jpiDatetime:
             read_int32(v->content.arg, base, pos);
             break;
         case jpiIndexArray:
             read_int32(v->content.array.nelems, base, pos);
             read_int32_n(v->content.array.elems, base, pos,
                          v->content.array.nelems * 2);
             break;
         case jpiAny:
             read_int32(v->content.anybounds.first, base, pos);
             read_int32(v->content.anybounds.last, base, pos);
             break;
         default:
             elog(ERROR, "unrecognized jsonpath item type: %d", v->type);
     }
 }

References JsonPathItem::anybounds, JsonPathItem::arg, JsonPathItem::args, JsonPathItem::array, JsonPathItem::base, JsonPathItem::content, elog(), ERROR, INTALIGN, 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, JsonPathItem::like_regex, JsonPathItem::nextPos, read_byte, read_int32, read_int32_n, JsonPathItem::type, and JsonPathItem::value.

Referenced by executeBoolItem(), jspGetArg(), jspGetArraySubscript(), jspGetLeftArg(), jspGetNext(), jspGetRightArg(), jspInit(), jspIsMutableWalker(), and printJsonPathItem().

◆ jspIsMutable()

bool jspIsMutable	(	JsonPath *	path,
		List *	varnames,
		List *	varexprs
	)

Definition at line 1321 of file jsonpath.c.

 {
     JsonPathMutableContext cxt;
     JsonPathItem jpi;
  
     cxt.varnames = varnames;
     cxt.varexprs = varexprs;
     cxt.current = jpdsNonDateTime;
     cxt.lax = (path->header & JSONPATH_LAX) != 0;
     cxt.mutable = false;
  
     jspInit(&jpi, path);
     jspIsMutableWalker(&jpi, &cxt);
  
     return cxt.mutable;
 }

References JsonPathMutableContext::current, JsonPath::header, jpdsNonDateTime, JSONPATH_LAX, jspInit(), jspIsMutableWalker(), JsonPathMutableContext::lax, JsonPathMutableContext::mutable, JsonPathMutableContext::varexprs, and JsonPathMutableContext::varnames.

Referenced by contain_mutable_functions_walker().

◆ jspOperationName()

const char* jspOperationName ( JsonPathItemType type )

Definition at line 724 of file jsonpath.c.

 {
     switch (type)
     {
         case jpiAnd:
             return "&&";
         case jpiOr:
             return "||";
         case jpiEqual:
             return "==";
         case jpiNotEqual:
             return "!=";
         case jpiLess:
             return "<";
         case jpiGreater:
             return ">";
         case jpiLessOrEqual:
             return "<=";
         case jpiGreaterOrEqual:
             return ">=";
         case jpiPlus:
         case jpiAdd:
             return "+";
         case jpiMinus:
         case jpiSub:
             return "-";
         case jpiMul:
             return "*";
         case jpiDiv:
             return "/";
         case jpiMod:
             return "%";
         case jpiStartsWith:
             return "starts with";
         case jpiLikeRegex:
             return "like_regex";
         case jpiType:
             return "type";
         case jpiSize:
             return "size";
         case jpiKeyValue:
             return "keyvalue";
         case jpiDouble:
             return "double";
         case jpiAbs:
             return "abs";
         case jpiFloor:
             return "floor";
         case jpiCeiling:
             return "ceiling";
         case jpiDatetime:
             return "datetime";
         default:
             elog(ERROR, "unrecognized jsonpath item type: %d", type);
             return NULL;
     }
 }

References elog(), ERROR, jpiAbs, jpiAdd, jpiAnd, jpiCeiling, jpiDatetime, jpiDiv, jpiDouble, jpiEqual, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiKeyValue, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNotEqual, jpiOr, jpiPlus, jpiSize, jpiStartsWith, jpiSub, jpiType, and generate_unaccent_rules::type.

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

◆ parsejsonpath()

JsonPathParseResult* parsejsonpath	(	const char *	str,
		int	len
	)

Referenced by jsonPathFromCstring().

Variable Documentation

◆ JsonbTableRoutine

PGDLLIMPORT const TableFuncRoutine JsonbTableRoutine

extern

Definition at line 3553 of file jsonpath_exec.c.

Referenced by ExecInitTableFuncScan().

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ DatumGetJsonPathP

◆ DatumGetJsonPathPCopy

◆ JSONPATH_HDRSZ

◆ JSONPATH_LAX

◆ JSONPATH_VERSION

◆ JSP_REGEX_DOTALL

◆ JSP_REGEX_ICASE

◆ JSP_REGEX_MLINE

◆ JSP_REGEX_QUOTE

◆ JSP_REGEX_WSPACE

◆ jspHasNext

◆ jspIsScalar

◆ PG_GETARG_JSONPATH_P

◆ PG_GETARG_JSONPATH_P_COPY

◆ PG_RETURN_JSONPATH_P

Typedef Documentation

◆ JsonPathItem

◆ JsonPathItemType

◆ JsonPathParseItem

◆ JsonPathParseResult

◆ JsonPathVariableEvalContext

Enumeration Type Documentation

◆ JsonPathItemType

Function Documentation

◆ EvalJsonPathVar()

◆ JsonItemFromDatum()

◆ JsonPathExists()

◆ JsonPathQuery()

◆ JsonPathValue()

◆ jspConvertRegexFlags()

◆ jspGetArg()

◆ jspGetArraySubscript()

◆ jspGetBool()

◆ jspGetLeftArg()

◆ jspGetNext()

◆ jspGetNumeric()

◆ jspGetRightArg()

◆ jspGetString()

◆ jspInit()

◆ jspInitByBuffer()

◆ jspIsMutable()

◆ jspOperationName()

◆ parsejsonpath()

Variable Documentation

◆ JsonbTableRoutine