jsonpath.h File Reference

#include "executor/tablefunc.h"
#include "fmgr.h"
#include "nodes/pg_list.h"
#include "nodes/primnodes.h"
#include "utils/jsonb.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	JsonPathVariable

Macros
#define	JSONPATH_VERSION   (0x01)
#define	JSONPATH_LAX   (0x80000000)
#define	JSONPATH_HDRSZ   (offsetof(JsonPath, data))
#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 JsonPathVariable	JsonPathVariable

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 , jpiBigint ,   jpiBoolean , jpiDate , jpiDecimal , jpiInteger ,   jpiNumber , jpiStringFunc , jpiTime , jpiTimeTz ,   jpiTimestamp , jpiTimestampTz , jpiStrReplace , jpiStrLower ,   jpiStrUpper , jpiStrLtrim , jpiStrRtrim , jpiStrBtrim ,   jpiStrInitcap , jpiStrSplitPart }

Functions
static JsonPath *	DatumGetJsonPathP (Datum d)
static JsonPath *	DatumGetJsonPathPCopy (Datum d)
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, struct Node *escontext)
bool	jspConvertRegexFlags (uint32 xflags, int *result, struct Node *escontext)
bool	JsonPathExists (Datum jb, JsonPath *jp, bool *error, List *vars)
Datum	JsonPathQuery (Datum jb, JsonPath *jp, JsonWrapper wrapper, bool *empty, bool *error, List *vars, const char *column_name)
JsonbValue *	JsonPathValue (Datum jb, JsonPath *jp, bool *empty, bool *error, List *vars, const char *column_name)

Variables
PGDLLIMPORT const TableFuncRoutine	JsonbTableRoutine

Macro Definition Documentation

JSONPATH_HDRSZ

#define JSONPATH_HDRSZ   (offsetof(JsonPath, data))

Definition at line 32 of file jsonpath.h.

JSONPATH_LAX

#define JSONPATH_LAX   (0x80000000)

Definition at line 31 of file jsonpath.h.

JSONPATH_VERSION

#define JSONPATH_VERSION   (0x01)

Definition at line 30 of file jsonpath.h.

JSP_REGEX_DOTALL

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

Definition at line 130 of file jsonpath.h.

JSP_REGEX_ICASE

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

Definition at line 129 of file jsonpath.h.

JSP_REGEX_MLINE

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

Definition at line 131 of file jsonpath.h.

JSP_REGEX_QUOTE

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

Definition at line 133 of file jsonpath.h.

JSP_REGEX_WSPACE

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

Definition at line 132 of file jsonpath.h.

jspHasNext

#define jspHasNext

(

jsp

)

((jsp)->nextPos > 0)

Definition at line 202 of file jsonpath.h.

jspIsScalar

#define jspIsScalar

(

type

)

((type) >= jpiNull && (type) <= jpiBool)

Definition at line 50 of file jsonpath.h.

PG_GETARG_JSONPATH_P

#define PG_GETARG_JSONPATH_P

(

x

)

DatumGetJsonPathP(PG_GETARG_DATUM(x))

Definition at line 46 of file jsonpath.h.

PG_GETARG_JSONPATH_P_COPY

#define PG_GETARG_JSONPATH_P_COPY

(

x

)

DatumGetJsonPathPCopy(PG_GETARG_DATUM(x))

Definition at line 47 of file jsonpath.h.

PG_RETURN_JSONPATH_P

#define PG_RETURN_JSONPATH_P

(

p

)

PG_RETURN_POINTER(p)

Definition at line 48 of file jsonpath.h.

Typedef Documentation

JsonPathItem

typedef struct JsonPathItem JsonPathItem

JsonPathItemType

typedef enum JsonPathItemType JsonPathItemType

JsonPathParseItem

typedef struct JsonPathParseItem JsonPathParseItem

Definition at line 223 of file jsonpath.h.

JsonPathParseResult

typedef struct JsonPathParseResult JsonPathParseResult

JsonPathVariable

typedef struct JsonPathVariable JsonPathVariable

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
jpiBigint
jpiBoolean
jpiDate
jpiDecimal
jpiInteger
jpiNumber
jpiStringFunc
jpiTime
jpiTimeTz
jpiTimestamp
jpiTimestampTz
jpiStrReplace
jpiStrLower
jpiStrUpper
jpiStrLtrim
jpiStrRtrim
jpiStrBtrim
jpiStrInitcap
jpiStrSplitPart

Definition at line 62 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 */
    jpiBigint,                  /* .bigint() item method */
    jpiBoolean,                 /* .boolean() item method */
    jpiDate,                    /* .date() item method */
    jpiDecimal,                 /* .decimal() item method */
    jpiInteger,                 /* .integer() item method */
    jpiNumber,                  /* .number() item method */
    jpiStringFunc,              /* .string() item method */
    jpiTime,                    /* .time() item method */
    jpiTimeTz,                  /* .time_tz() item method */
    jpiTimestamp,               /* .timestamp() item method */
    jpiTimestampTz,             /* .timestamp_tz() item method */
    jpiStrReplace,              /* .replace() item method */
    jpiStrLower,                /* .lower() item method */
    jpiStrUpper,                /* .upper() item method */
    jpiStrLtrim,                /* .ltrim() item method */
    jpiStrRtrim,                /* .rtrim() item method */
    jpiStrBtrim,                /* .btrim() item method */
    jpiStrInitcap,              /* .initcap() item method */
    jpiStrSplitPart,            /* .split_part() item method */
} JsonPathItemType;

Function Documentation

DatumGetJsonPathP()

static JsonPath * DatumGetJsonPathP ( Datum  d )

inlinestatic

Definition at line 35 of file jsonpath.h.

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

References PG_DETOAST_DATUM.

Referenced by contain_mutable_functions_walker(), ExecEvalJsonExprPath(), and JsonTableInitPlan().

DatumGetJsonPathPCopy()

static JsonPath * DatumGetJsonPathPCopy ( Datum  d )

inlinestatic

Definition at line 41 of file jsonpath.h.

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

References PG_DETOAST_DATUM_COPY.

JsonPathExists()

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

extern

Definition at line 4202 of file jsonpath_exec.c.

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

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

Referenced by ExecEvalJsonExprPath().

JsonPathQuery()

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

extern

Definition at line 4225 of file jsonpath_exec.c.

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

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

Referenced by ExecEvalJsonExprPath().

JsonPathValue()

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

extern

Definition at line 4315 of file jsonpath_exec.c.

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

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

Referenced by ExecEvalJsonExprPath().

jspConvertRegexFlags()

bool jspConvertRegexFlags ( uint32  xflags, int *  result, struct Node *  escontext  )

extern

Referenced by executeLikeRegex().

jspGetArg()

void jspGetArg ( JsonPathItem *  v, JsonPathItem *  a  )

extern

Definition at line 1167 of file jsonpath.c.

{
    Assert(v->type == jpiNot ||
           v->type == jpiIsUnknown ||
           v->type == jpiPlus ||
           v->type == jpiMinus ||
           v->type == jpiFilter ||
           v->type == jpiExists ||
           v->type == jpiDatetime ||
           v->type == jpiTime ||
           v->type == jpiTimeTz ||
           v->type == jpiTimestamp ||
           v->type == jpiTimestampTz ||
           v->type == jpiStrLtrim ||
           v->type == jpiStrRtrim ||
           v->type == jpiStrBtrim);
 
    jspInitByBuffer(a, v->base, v->content.arg);
}

References a, JsonPathItem::arg, Assert, JsonPathItem::base, JsonPathItem::content, jpiDatetime, jpiExists, jpiFilter, jpiIsUnknown, jpiMinus, jpiNot, jpiPlus, jpiStrBtrim, jpiStrLtrim, jpiStrRtrim, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, jspInitByBuffer(), and JsonPathItem::type.

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

jspGetArraySubscript()

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

extern

Definition at line 1339 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, JsonPathItem::elems, i, jpiIndexArray, jspInitByBuffer(), and JsonPathItem::type.

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

jspGetBool()

bool jspGetBool ( JsonPathItem *  v )

extern

Definition at line 1311 of file jsonpath.c.

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

References Assert, JsonPathItem::content, JsonPathItem::data, jpiBool, JsonPathItem::type, and JsonPathItem::value.

Referenced by getJsonPathItem(), and printJsonPathItem().

jspGetLeftArg()

void jspGetLeftArg ( JsonPathItem *  v, JsonPathItem *  a  )

extern

Definition at line 1263 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 ||
           v->type == jpiDecimal ||
           v->type == jpiStrReplace ||
           v->type == jpiStrSplitPart);
 
    jspInitByBuffer(a, v->base, v->content.args.left);
}

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

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

jspGetNext()

bool jspGetNext ( JsonPathItem *  v, JsonPathItem *  a  )

extern

Definition at line 1188 of file jsonpath.c.

{
    if (jspHasNext(v))
    {
        Assert(v->type == jpiNull ||
               v->type == jpiString ||
               v->type == jpiNumeric ||
               v->type == jpiBool ||
               v->type == jpiAnd ||
               v->type == jpiOr ||
               v->type == jpiNot ||
               v->type == jpiIsUnknown ||
               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 == jpiPlus ||
               v->type == jpiMinus ||
               v->type == jpiAnyArray ||
               v->type == jpiAnyKey ||
               v->type == jpiIndexArray ||
               v->type == jpiAny ||
               v->type == jpiKey ||
               v->type == jpiCurrent ||
               v->type == jpiRoot ||
               v->type == jpiVariable ||
               v->type == jpiFilter ||
               v->type == jpiExists ||
               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 == jpiLast ||
               v->type == jpiStartsWith ||
               v->type == jpiLikeRegex ||
               v->type == jpiBigint ||
               v->type == jpiBoolean ||
               v->type == jpiDate ||
               v->type == jpiDecimal ||
               v->type == jpiInteger ||
               v->type == jpiNumber ||
               v->type == jpiStringFunc ||
               v->type == jpiTime ||
               v->type == jpiTimeTz ||
               v->type == jpiTimestamp ||
               v->type == jpiTimestampTz ||
               v->type == jpiStrReplace ||
               v->type == jpiStrLower ||
               v->type == jpiStrUpper ||
               v->type == jpiStrLtrim ||
               v->type == jpiStrRtrim ||
               v->type == jpiStrBtrim ||
               v->type == jpiStrInitcap ||
               v->type == jpiStrSplitPart);
 
        if (a)
            jspInitByBuffer(a, v->base, v->nextPos);
        return true;
    }
 
    return false;
}

References a, Assert, JsonPathItem::base, jpiAbs, jpiAdd, jpiAnd, jpiAny, jpiAnyArray, jpiAnyKey, jpiBigint, jpiBool, jpiBoolean, jpiCeiling, jpiCurrent, jpiDate, jpiDatetime, jpiDecimal, jpiDiv, jpiDouble, jpiEqual, jpiExists, jpiFilter, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiIndexArray, jpiInteger, jpiIsUnknown, jpiKey, jpiKeyValue, jpiLast, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumber, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiStrBtrim, jpiString, jpiStringFunc, jpiStrInitcap, jpiStrLower, jpiStrLtrim, jpiStrReplace, jpiStrRtrim, jpiStrSplitPart, jpiStrUpper, jpiSub, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, jpiType, jpiVariable, jspHasNext, jspInitByBuffer(), JsonPathItem::nextPos, and JsonPathItem::type.

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

jspGetNumeric()

Numeric jspGetNumeric ( JsonPathItem *  v )

extern

Definition at line 1319 of file jsonpath.c.

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

References Assert, JsonPathItem::content, JsonPathItem::data, jpiNumeric, JsonPathItem::type, and JsonPathItem::value.

Referenced by executeDateTimeMethod(), executeItemOptUnwrapTarget(), executeStringInternalMethod(), getJsonPathItem(), and printJsonPathItem().

jspGetRightArg()

void jspGetRightArg ( JsonPathItem *  v, JsonPathItem *  a  )

extern

Definition at line 1287 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 ||
           v->type == jpiDecimal ||
           v->type == jpiStrReplace ||
           v->type == jpiStrSplitPart);
 
    jspInitByBuffer(a, v->base, v->content.args.right);
}

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

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

jspGetString()

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

extern

Definition at line 1327 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, JsonPathItem::data, JsonPathItem::datalen, jpiKey, jpiString, jpiVariable, len, JsonPathItem::type, and JsonPathItem::value.

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

jspInit()

void jspInit ( JsonPathItem *  v, JsonPath *  js  )

extern

Definition at line 1058 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  )

extern

Definition at line 1068 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:
        case jpiBigint:
        case jpiBoolean:
        case jpiDate:
        case jpiInteger:
        case jpiNumber:
        case jpiStringFunc:
        case jpiStrLower:
        case jpiStrUpper:
        case jpiStrInitcap:
            break;
        case jpiString:
        case jpiKey:
        case jpiVariable:
            read_int32(v->content.value.datalen, base, pos);
            pg_fallthrough;
        case jpiNumeric:
        case jpiBool:
            v->content.value.data = base + pos;
            break;
        case jpiAnd:
        case jpiOr:
        case jpiEqual:
        case jpiNotEqual:
        case jpiLess:
        case jpiGreater:
        case jpiLessOrEqual:
        case jpiGreaterOrEqual:
        case jpiAdd:
        case jpiSub:
        case jpiMul:
        case jpiDiv:
        case jpiMod:
        case jpiStartsWith:
        case jpiDecimal:
        case jpiStrReplace:
        case jpiStrSplitPart:
            read_int32(v->content.args.left, base, pos);
            read_int32(v->content.args.right, base, pos);
            break;
        case jpiNot:
        case jpiIsUnknown:
        case jpiExists:
        case jpiPlus:
        case jpiMinus:
        case jpiFilter:
        case jpiDatetime:
        case jpiTime:
        case jpiTimeTz:
        case jpiTimestamp:
        case jpiTimestampTz:
        case jpiStrLtrim:
        case jpiStrRtrim:
        case jpiStrBtrim:
            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;
        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;
        default:
            elog(ERROR, "unrecognized jsonpath item type: %d", v->type);
    }
}

References JsonPathItem::anybounds, JsonPathItem::arg, JsonPathItem::args, JsonPathItem::array, JsonPathItem::base, JsonPathItem::content, JsonPathItem::data, JsonPathItem::datalen, JsonPathItem::elems, elog, ERROR, JsonPathItem::expr, fb(), JsonPathItem::first, JsonPathItem::flags, INTALIGN, jpiAbs, jpiAdd, jpiAnd, jpiAny, jpiAnyArray, jpiAnyKey, jpiBigint, jpiBool, jpiBoolean, jpiCeiling, jpiCurrent, jpiDate, jpiDatetime, jpiDecimal, jpiDiv, jpiDouble, jpiEqual, jpiExists, jpiFilter, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiIndexArray, jpiInteger, jpiIsUnknown, jpiKey, jpiKeyValue, jpiLast, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumber, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiStrBtrim, jpiString, jpiStringFunc, jpiStrInitcap, jpiStrLower, jpiStrLtrim, jpiStrReplace, jpiStrRtrim, jpiStrSplitPart, jpiStrUpper, jpiSub, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, jpiType, jpiVariable, JsonPathItem::last, JsonPathItem::left, JsonPathItem::like_regex, JsonPathItem::nelems, JsonPathItem::nextPos, JsonPathItem::pattern, JsonPathItem::patternlen, pg_fallthrough, read_byte, read_int32, read_int32_n, JsonPathItem::right, 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  )

extern

Definition at line 1381 of file jsonpath.c.

{
    struct 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);
    (void) jspIsMutableWalker(&jpi, &cxt);
 
    return cxt.mutable;
}

References JsonPathMutableContext::current, fb(), 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 )

extern

Definition at line 905 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 jpiAdd:
        case jpiPlus:
            return "+";
        case jpiSub:
        case jpiMinus:
            return "-";
        case jpiMul:
            return "*";
        case jpiDiv:
            return "/";
        case jpiMod:
            return "%";
        case jpiType:
            return "type";
        case jpiSize:
            return "size";
        case jpiAbs:
            return "abs";
        case jpiFloor:
            return "floor";
        case jpiCeiling:
            return "ceiling";
        case jpiDouble:
            return "double";
        case jpiDatetime:
            return "datetime";
        case jpiKeyValue:
            return "keyvalue";
        case jpiStartsWith:
            return "starts with";
        case jpiLikeRegex:
            return "like_regex";
        case jpiBigint:
            return "bigint";
        case jpiBoolean:
            return "boolean";
        case jpiDate:
            return "date";
        case jpiDecimal:
            return "decimal";
        case jpiInteger:
            return "integer";
        case jpiNumber:
            return "number";
        case jpiStringFunc:
            return "string";
        case jpiTime:
            return "time";
        case jpiTimeTz:
            return "time_tz";
        case jpiTimestamp:
            return "timestamp";
        case jpiTimestampTz:
            return "timestamp_tz";
        case jpiStrReplace:
            return "replace";
        case jpiStrLower:
            return "lower";
        case jpiStrUpper:
            return "upper";
        case jpiStrLtrim:
            return "ltrim";
        case jpiStrRtrim:
            return "rtrim";
        case jpiStrBtrim:
            return "btrim";
        case jpiStrInitcap:
            return "initcap";
        case jpiStrSplitPart:
            return "split_part";
        default:
            elog(ERROR, "unrecognized jsonpath item type: %d", type);
            return NULL;
    }
}

References elog, ERROR, fb(), jpiAbs, jpiAdd, jpiAnd, jpiBigint, jpiBoolean, jpiCeiling, jpiDate, jpiDatetime, jpiDecimal, jpiDiv, jpiDouble, jpiEqual, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiInteger, jpiKeyValue, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNotEqual, jpiNumber, jpiOr, jpiPlus, jpiSize, jpiStartsWith, jpiStrBtrim, jpiStringFunc, jpiStrInitcap, jpiStrLower, jpiStrLtrim, jpiStrReplace, jpiStrRtrim, jpiStrSplitPart, jpiStrUpper, jpiSub, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, jpiType, and type.

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

parsejsonpath()

JsonPathParseResult * parsejsonpath ( const char *  str, int  len, struct Node *  escontext  )

extern

Definition at line 536 of file jsonpath_scan.l.

{
    JsonPathParseResult *parseresult;
    yyscan_t    scanner;
    struct jsonpath_yy_extra_type yyext;
 
    if (jsonpath_yylex_init(&scanner) != 0)
        elog(ERROR, "yylex_init() failed: %m");
 
    yyset_extra(&yyext, scanner);
 
    if (len <= 0)
        len = strlen(str);
 
    jsonpath_yy_scan_bytes(str, len, scanner);
 
    if (jsonpath_yyparse(&parseresult, escontext, scanner) != 0)
        jsonpath_yyerror(NULL, escontext, scanner, "invalid input");    /* shouldn't happen */
 
    jsonpath_yylex_destroy(scanner);
 
    return parseresult;
}

References elog, ERROR, fb(), jsonpath_yyerror(), jsonpath_yyparse(), len, parseresult, and str.

Referenced by jsonPathFromCstring().

Variable Documentation

JsonbTableRoutine

PGDLLIMPORT const TableFuncRoutine JsonbTableRoutine

extern

Definition at line 400 of file jsonpath_exec.c.

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

Referenced by ExecInitTableFuncScan().