jsonpath.c File Reference

#include "postgres.h"
#include "catalog/pg_type.h"
#include "lib/stringinfo.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/miscnodes.h"
#include "nodes/nodeFuncs.h"
#include "utils/fmgrprotos.h"
#include "utils/formatting.h"
#include "utils/json.h"
#include "utils/jsonpath.h"

Include dependency graph for jsonpath.c:

Go to the source code of this file.

Data Structures
struct	JsonPathMutableContext

Macros
#define	read_byte(v, b, p)
#define	read_int32(v, b, p)
#define	read_int32_n(v, b, p, n)

Enumerations
enum	JsonPathDatatypeStatus { jpdsNonDateTime , jpdsUnknownDateTime , jpdsDateTimeZoned , jpdsDateTimeNonZoned }

Functions
static Datum	jsonPathFromCstring (char *in, int len, struct Node *escontext)
static char *	jsonPathToCstring (StringInfo out, JsonPath *in, int estimated_len)
static bool	flattenJsonPathParseItem (StringInfo buf, int *result, struct Node *escontext, JsonPathParseItem *item, int nestingLevel, bool insideArraySubscript)
static void	alignStringInfoInt (StringInfo buf)
static int32	reserveSpaceForItemPointer (StringInfo buf)
static void	printJsonPathItem (StringInfo buf, JsonPathItem *v, bool inKey, bool printBracketes)
static int	operationPriority (JsonPathItemType op)
Datum	jsonpath_in (PG_FUNCTION_ARGS)
Datum	jsonpath_recv (PG_FUNCTION_ARGS)
Datum	jsonpath_out (PG_FUNCTION_ARGS)
Datum	jsonpath_send (PG_FUNCTION_ARGS)
const char *	jspOperationName (JsonPathItemType type)
void	jspInit (JsonPathItem *v, JsonPath *js)
void	jspInitByBuffer (JsonPathItem *v, char *base, int32 pos)
void	jspGetArg (JsonPathItem *v, JsonPathItem *a)
bool	jspGetNext (JsonPathItem *v, JsonPathItem *a)
void	jspGetLeftArg (JsonPathItem *v, JsonPathItem *a)
void	jspGetRightArg (JsonPathItem *v, JsonPathItem *a)
bool	jspGetBool (JsonPathItem *v)
Numeric	jspGetNumeric (JsonPathItem *v)
char *	jspGetString (JsonPathItem *v, int32 *len)
bool	jspGetArraySubscript (JsonPathItem *v, JsonPathItem *from, JsonPathItem *to, int i)
static enum JsonPathDatatypeStatus	jspIsMutableWalker (JsonPathItem *jpi, struct JsonPathMutableContext *cxt)
bool	jspIsMutable (JsonPath *path, List *varnames, List *varexprs)

Macro Definition Documentation

read_byte

#define read_byte	(		v,
			b,
			p
	)

Value:

    do {            \
    (v) = *(uint8*)((b) + (p));         \
    (p) += 1;                           \
} while(0)                              \

Definition at line 1039 of file jsonpath.c.

                              {         \
    (v) = *(uint8*)((b) + (p));         \
    (p) += 1;                           \
} while(0)                              \
 

read_int32

#define read_int32	(		v,
			b,
			p
	)

Value:

    do {        \
    (v) = *(uint32*)((b) + (p));        \
    (p) += sizeof(int32);               \
} while(0)                              \

Definition at line 1044 of file jsonpath.c.

                               {        \
    (v) = *(uint32*)((b) + (p));        \
    (p) += sizeof(int32);               \
} while(0)                              \
 

read_int32_n

#define read_int32_n	(		v,
			b,
			p,
			n
	)

Value:

    do {    \
    (v) = (void *)((b) + (p));          \
    (p) += sizeof(int32) * (n);         \
} while(0)                              \

Definition at line 1049 of file jsonpath.c.

                                    {   \
    (v) = (void *)((b) + (p));          \
    (p) += sizeof(int32) * (n);         \
} while(0)                              \
 

Enumeration Type Documentation

JsonPathDatatypeStatus

enum JsonPathDatatypeStatus

Enumerator
jpdsNonDateTime
jpdsUnknownDateTime
jpdsDateTimeZoned
jpdsDateTimeNonZoned

Definition at line 1355 of file jsonpath.c.

{
    jpdsNonDateTime,            /* null, bool, numeric, string, array, object */
    jpdsUnknownDateTime,        /* unknown datetime type */
    jpdsDateTimeZoned,          /* timetz, timestamptz */
    jpdsDateTimeNonZoned,       /* time, timestamp, date */
};

Function Documentation

alignStringInfoInt()

static void alignStringInfoInt ( StringInfo  buf )

static

Definition at line 492 of file jsonpath.c.

{
    switch (INTALIGN(buf->len) - buf->len)
    {
        case 3:
            appendStringInfoCharMacro(buf, 0);
            pg_fallthrough;
        case 2:
            appendStringInfoCharMacro(buf, 0);
            pg_fallthrough;
        case 1:
            appendStringInfoCharMacro(buf, 0);
            pg_fallthrough;
        default:
            break;
    }
}

References appendStringInfoCharMacro, buf, INTALIGN, and pg_fallthrough.

Referenced by flattenJsonPathParseItem().

flattenJsonPathParseItem()

static bool flattenJsonPathParseItem ( StringInfo  buf, int *  result, struct Node *  escontext, JsonPathParseItem *  item, int  nestingLevel, bool  insideArraySubscript  )

static

Definition at line 239 of file jsonpath.c.

{
    /* position from beginning of jsonpath data */
    int32       pos = buf->len - JSONPATH_HDRSZ;
    int32       chld;
    int32       next;
    int         argNestingLevel = 0;
 
    check_stack_depth();
    CHECK_FOR_INTERRUPTS();
 
    appendStringInfoChar(buf, (char) (item->type));
 
    /*
     * We align buffer to int32 because a series of int32 values often goes
     * after the header, and we want to read them directly by dereferencing
     * int32 pointer (see jspInitByBuffer()).
     */
    alignStringInfoInt(buf);
 
    /*
     * Reserve space for next item pointer.  Actual value will be recorded
     * later, after next and children items processing.
     */
    next = reserveSpaceForItemPointer(buf);
 
    switch (item->type)
    {
        case jpiString:
        case jpiVariable:
        case jpiKey:
            appendBinaryStringInfo(buf, &item->value.string.len,
                                   sizeof(item->value.string.len));
            appendBinaryStringInfo(buf, item->value.string.val,
                                   item->value.string.len);
            appendStringInfoChar(buf, '\0');
            break;
        case jpiNumeric:
            appendBinaryStringInfo(buf, item->value.numeric,
                                   VARSIZE(item->value.numeric));
            break;
        case jpiBool:
            appendBinaryStringInfo(buf, &item->value.boolean,
                                   sizeof(item->value.boolean));
            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:
            {
                /*
                 * First, reserve place for left/right arg's positions, then
                 * record both args and sets actual position in reserved
                 * places.
                 */
                int32       left = reserveSpaceForItemPointer(buf);
                int32       right = reserveSpaceForItemPointer(buf);
 
                if (!item->value.args.left)
                    chld = pos;
                else if (!flattenJsonPathParseItem(buf, &chld, escontext,
                                                   item->value.args.left,
                                                   nestingLevel + argNestingLevel,
                                                   insideArraySubscript))
                    return false;
                *(int32 *) (buf->data + left) = chld - pos;
 
                if (!item->value.args.right)
                    chld = pos;
                else if (!flattenJsonPathParseItem(buf, &chld, escontext,
                                                   item->value.args.right,
                                                   nestingLevel + argNestingLevel,
                                                   insideArraySubscript))
                    return false;
                *(int32 *) (buf->data + right) = chld - pos;
            }
            break;
        case jpiLikeRegex:
            {
                int32       offs;
 
                appendBinaryStringInfo(buf,
                                       &item->value.like_regex.flags,
                                       sizeof(item->value.like_regex.flags));
                offs = reserveSpaceForItemPointer(buf);
                appendBinaryStringInfo(buf,
                                       &item->value.like_regex.patternlen,
                                       sizeof(item->value.like_regex.patternlen));
                appendBinaryStringInfo(buf, item->value.like_regex.pattern,
                                       item->value.like_regex.patternlen);
                appendStringInfoChar(buf, '\0');
 
                if (!flattenJsonPathParseItem(buf, &chld, escontext,
                                              item->value.like_regex.expr,
                                              nestingLevel,
                                              insideArraySubscript))
                    return false;
                *(int32 *) (buf->data + offs) = chld - pos;
            }
            break;
        case jpiFilter:
            argNestingLevel++;
            pg_fallthrough;
        case jpiIsUnknown:
        case jpiNot:
        case jpiPlus:
        case jpiMinus:
        case jpiExists:
        case jpiDatetime:
        case jpiTime:
        case jpiTimeTz:
        case jpiTimestamp:
        case jpiTimestampTz:
        case jpiStrLtrim:
        case jpiStrRtrim:
        case jpiStrBtrim:
            {
                int32       arg = reserveSpaceForItemPointer(buf);
 
                if (!item->value.arg)
                    chld = pos;
                else if (!flattenJsonPathParseItem(buf, &chld, escontext,
                                                   item->value.arg,
                                                   nestingLevel + argNestingLevel,
                                                   insideArraySubscript))
                    return false;
                *(int32 *) (buf->data + arg) = chld - pos;
            }
            break;
        case jpiNull:
            break;
        case jpiRoot:
            break;
        case jpiAnyArray:
        case jpiAnyKey:
            break;
        case jpiCurrent:
            if (nestingLevel <= 0)
                ereturn(escontext, false,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("@ is not allowed in root expressions")));
            break;
        case jpiLast:
            if (!insideArraySubscript)
                ereturn(escontext, false,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("LAST is allowed only in array subscripts")));
            break;
        case jpiIndexArray:
            {
                int32       nelems = item->value.array.nelems;
                int         offset;
                int         i;
 
                appendBinaryStringInfo(buf, &nelems, sizeof(nelems));
 
                offset = buf->len;
 
                appendStringInfoSpaces(buf, sizeof(int32) * 2 * nelems);
 
                for (i = 0; i < nelems; i++)
                {
                    int32      *ppos;
                    int32       topos;
                    int32       frompos;
 
                    if (!flattenJsonPathParseItem(buf, &frompos, escontext,
                                                  item->value.array.elems[i].from,
                                                  nestingLevel, true))
                        return false;
                    frompos -= pos;
 
                    if (item->value.array.elems[i].to)
                    {
                        if (!flattenJsonPathParseItem(buf, &topos, escontext,
                                                      item->value.array.elems[i].to,
                                                      nestingLevel, true))
                            return false;
                        topos -= pos;
                    }
                    else
                        topos = 0;
 
                    ppos = (int32 *) &buf->data[offset + i * 2 * sizeof(int32)];
 
                    ppos[0] = frompos;
                    ppos[1] = topos;
                }
            }
            break;
        case jpiAny:
            appendBinaryStringInfo(buf,
                                   &item->value.anybounds.first,
                                   sizeof(item->value.anybounds.first));
            appendBinaryStringInfo(buf,
                                   &item->value.anybounds.last,
                                   sizeof(item->value.anybounds.last));
            break;
        case jpiType:
        case jpiSize:
        case jpiAbs:
        case jpiFloor:
        case jpiCeiling:
        case jpiDouble:
        case jpiKeyValue:
        case jpiBigint:
        case jpiBoolean:
        case jpiDate:
        case jpiInteger:
        case jpiNumber:
        case jpiStringFunc:
        case jpiStrLower:
        case jpiStrUpper:
        case jpiStrInitcap:
            break;
        default:
            elog(ERROR, "unrecognized jsonpath item type: %d", item->type);
    }
 
    if (item->next)
    {
        if (!flattenJsonPathParseItem(buf, &chld, escontext,
                                      item->next, nestingLevel,
                                      insideArraySubscript))
            return false;
        chld -= pos;
        *(int32 *) (buf->data + next) = chld;
    }
 
    if (result)
        *result = pos;
    return true;
}

References alignStringInfoInt(), JsonPathParseItem::anybounds, appendBinaryStringInfo(), appendStringInfoChar(), appendStringInfoSpaces(), arg, JsonPathParseItem::arg, JsonPathParseItem::args, JsonPathParseItem::array, JsonPathParseItem::boolean, buf, CHECK_FOR_INTERRUPTS, check_stack_depth(), JsonPathParseItem::elems, elog, ereturn, errcode(), errmsg, ERROR, JsonPathParseItem::expr, fb(), JsonPathParseItem::first, JsonPathParseItem::flags, flattenJsonPathParseItem(), i, 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, JSONPATH_HDRSZ, JsonPathParseItem::last, JsonPathParseItem::left, JsonPathParseItem::len, JsonPathParseItem::like_regex, JsonPathParseItem::nelems, next, JsonPathParseItem::next, JsonPathParseItem::numeric, JsonPathParseItem::pattern, JsonPathParseItem::patternlen, pg_fallthrough, reserveSpaceForItemPointer(), result, JsonPathParseItem::right, JsonPathParseItem::string, JsonPathParseItem::type, JsonPathParseItem::val, JsonPathParseItem::value, and VARSIZE().

Referenced by flattenJsonPathParseItem(), and jsonPathFromCstring().

jsonpath_in()

Datum jsonpath_in

(

PG_FUNCTION_ARGS

)

Definition at line 98 of file jsonpath.c.

{
    char       *in = PG_GETARG_CSTRING(0);
    int         len = strlen(in);
 
    return jsonPathFromCstring(in, len, fcinfo->context);
}

References fb(), jsonPathFromCstring(), len, and PG_GETARG_CSTRING.

Referenced by makeJsonTablePathScan().

jsonpath_out()

Datum jsonpath_out

(

PG_FUNCTION_ARGS

)

Definition at line 134 of file jsonpath.c.

{
    JsonPath   *in = PG_GETARG_JSONPATH_P(0);
 
    PG_RETURN_CSTRING(jsonPathToCstring(NULL, in, VARSIZE(in)));
}

References fb(), jsonPathToCstring(), PG_GETARG_JSONPATH_P, PG_RETURN_CSTRING, and VARSIZE().

jsonpath_recv()

Datum jsonpath_recv

(

PG_FUNCTION_ARGS

)

Definition at line 115 of file jsonpath.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    int         version = pq_getmsgint(buf, 1);
    char       *str;
    int         nbytes;
 
    if (version == JSONPATH_VERSION)
        str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
    else
        elog(ERROR, "unsupported jsonpath version number: %d", version);
 
    return jsonPathFromCstring(str, nbytes, NULL);
}

References buf, elog, ERROR, fb(), JSONPATH_VERSION, jsonPathFromCstring(), PG_GETARG_POINTER, pq_getmsgint(), pq_getmsgtext(), and str.

jsonpath_send()

Datum jsonpath_send

(

PG_FUNCTION_ARGS

)

Definition at line 147 of file jsonpath.c.

{
    JsonPath   *in = PG_GETARG_JSONPATH_P(0);
    StringInfoData buf;
    StringInfoData jtext;
    int         version = JSONPATH_VERSION;
 
    initStringInfo(&jtext);
    (void) jsonPathToCstring(&jtext, in, VARSIZE(in));
 
    pq_begintypsend(&buf);
    pq_sendint8(&buf, version);
    pq_sendtext(&buf, jtext.data, jtext.len);
    pfree(jtext.data);
 
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, fb(), initStringInfo(), JSONPATH_VERSION, jsonPathToCstring(), pfree(), PG_GETARG_JSONPATH_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint8(), pq_sendtext(), and VARSIZE().

jsonPathFromCstring()

static Datum jsonPathFromCstring ( char *  in, int  len, struct Node *  escontext  )

static

Definition at line 173 of file jsonpath.c.

{
    JsonPathParseResult *jsonpath = parsejsonpath(in, len, escontext);
    JsonPath   *res;
    StringInfoData buf;
 
    if (SOFT_ERROR_OCCURRED(escontext))
        return (Datum) 0;
 
    if (!jsonpath)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"", "jsonpath",
                        in)));
 
    initStringInfo(&buf);
    enlargeStringInfo(&buf, 4 * len /* estimation */ );
 
    appendStringInfoSpaces(&buf, JSONPATH_HDRSZ);
 
    if (!flattenJsonPathParseItem(&buf, NULL, escontext,
                                  jsonpath->expr, 0, false))
        return (Datum) 0;
 
    res = (JsonPath *) buf.data;
    SET_VARSIZE(res, buf.len);
    res->header = JSONPATH_VERSION;
    if (jsonpath->lax)
        res->header |= JSONPATH_LAX;
 
    PG_RETURN_JSONPATH_P(res);
}

References appendStringInfoSpaces(), buf, JsonPath::data, enlargeStringInfo(), ereturn, errcode(), errmsg, fb(), flattenJsonPathParseItem(), JsonPath::header, initStringInfo(), JSONPATH_HDRSZ, JSONPATH_LAX, JSONPATH_VERSION, len, parsejsonpath(), PG_RETURN_JSONPATH_P, SET_VARSIZE(), and SOFT_ERROR_OCCURRED.

Referenced by jsonpath_in(), and jsonpath_recv().

jsonPathToCstring()

static char * jsonPathToCstring ( StringInfo  out, JsonPath *  in, int  estimated_len  )

static

Definition at line 213 of file jsonpath.c.

{
    StringInfoData buf;
    JsonPathItem v;
 
    if (!out)
    {
        out = &buf;
        initStringInfo(out);
    }
    enlargeStringInfo(out, estimated_len);
 
    if (!(in->header & JSONPATH_LAX))
        appendStringInfoString(out, "strict ");
 
    jspInit(&v, in);
    printJsonPathItem(out, &v, false, true);
 
    return out->data;
}

References appendStringInfoString(), buf, StringInfoData::data, enlargeStringInfo(), fb(), JsonPath::header, initStringInfo(), JSONPATH_LAX, jspInit(), and printJsonPathItem().

Referenced by jsonpath_out(), and jsonpath_send().

jspGetArg()

void jspGetArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

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
	)

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

)

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
	)

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
	)

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

)

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
	)

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
	)

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
	)

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
	)

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
	)

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

jspIsMutableWalker()

static enum JsonPathDatatypeStatus jspIsMutableWalker ( JsonPathItem *  jpi, struct JsonPathMutableContext *  cxt  )

static

Definition at line 1402 of file jsonpath.c.

{
    JsonPathItem next;
    enum JsonPathDatatypeStatus status = jpdsNonDateTime;
 
    while (!cxt->mutable)
    {
        JsonPathItem arg;
        enum JsonPathDatatypeStatus leftStatus;
        enum JsonPathDatatypeStatus rightStatus;
 
        switch (jpi->type)
        {
            case jpiRoot:
                Assert(status == jpdsNonDateTime);
                break;
 
            case jpiCurrent:
                Assert(status == jpdsNonDateTime);
                status = cxt->current;
                break;
 
            case jpiFilter:
                {
                    enum JsonPathDatatypeStatus prevStatus = cxt->current;
 
                    cxt->current = status;
                    jspGetArg(jpi, &arg);
                    jspIsMutableWalker(&arg, cxt);
 
                    cxt->current = prevStatus;
                    break;
                }
 
            case jpiVariable:
                {
                    int32       len;
                    const char *name = jspGetString(jpi, &len);
                    ListCell   *lc1;
                    ListCell   *lc2;
 
                    Assert(status == jpdsNonDateTime);
 
                    forboth(lc1, cxt->varnames, lc2, cxt->varexprs)
                    {
                        String     *varname = lfirst_node(String, lc1);
                        Node       *varexpr = lfirst(lc2);
 
                        if (strncmp(varname->sval, name, len))
                            continue;
 
                        switch (exprType(varexpr))
                        {
                            case DATEOID:
                            case TIMEOID:
                            case TIMESTAMPOID:
                                status = jpdsDateTimeNonZoned;
                                break;
 
                            case TIMETZOID:
                            case TIMESTAMPTZOID:
                                status = jpdsDateTimeZoned;
                                break;
 
                            default:
                                status = jpdsNonDateTime;
                                break;
                        }
 
                        break;
                    }
                    break;
                }
 
            case jpiEqual:
            case jpiNotEqual:
            case jpiLess:
            case jpiGreater:
            case jpiLessOrEqual:
            case jpiGreaterOrEqual:
                Assert(status == jpdsNonDateTime);
                jspGetLeftArg(jpi, &arg);
                leftStatus = jspIsMutableWalker(&arg, cxt);
 
                jspGetRightArg(jpi, &arg);
                rightStatus = jspIsMutableWalker(&arg, cxt);
 
                /*
                 * Comparison of datetime type with different timezone status
                 * is mutable.
                 */
                if (leftStatus != jpdsNonDateTime &&
                    rightStatus != jpdsNonDateTime &&
                    (leftStatus == jpdsUnknownDateTime ||
                     rightStatus == jpdsUnknownDateTime ||
                     leftStatus != rightStatus))
                    cxt->mutable = true;
                break;
 
            case jpiNot:
            case jpiIsUnknown:
            case jpiExists:
            case jpiPlus:
            case jpiMinus:
                Assert(status == jpdsNonDateTime);
                jspGetArg(jpi, &arg);
                jspIsMutableWalker(&arg, cxt);
                break;
 
            case jpiAnd:
            case jpiOr:
            case jpiAdd:
            case jpiSub:
            case jpiMul:
            case jpiDiv:
            case jpiMod:
            case jpiStartsWith:
                Assert(status == jpdsNonDateTime);
                jspGetLeftArg(jpi, &arg);
                jspIsMutableWalker(&arg, cxt);
                jspGetRightArg(jpi, &arg);
                jspIsMutableWalker(&arg, cxt);
                break;
 
            case jpiIndexArray:
                for (int i = 0; i < jpi->content.array.nelems; i++)
                {
                    JsonPathItem from;
                    JsonPathItem to;
 
                    if (jspGetArraySubscript(jpi, &from, &to, i))
                        jspIsMutableWalker(&to, cxt);
 
                    jspIsMutableWalker(&from, cxt);
                }
                pg_fallthrough;
 
            case jpiAnyArray:
                if (!cxt->lax)
                    status = jpdsNonDateTime;
                break;
 
            case jpiAny:
                if (jpi->content.anybounds.first > 0)
                    status = jpdsNonDateTime;
                break;
 
            case jpiDatetime:
                if (jpi->content.arg)
                {
                    char       *template;
 
                    jspGetArg(jpi, &arg);
                    if (arg.type != jpiString)
                    {
                        status = jpdsNonDateTime;
                        break;  /* there will be runtime error */
                    }
 
                    template = jspGetString(&arg, NULL);
                    if (datetime_format_has_tz(template))
                        status = jpdsDateTimeZoned;
                    else
                        status = jpdsDateTimeNonZoned;
                }
                else
                {
                    status = jpdsUnknownDateTime;
                }
                break;
 
            case jpiLikeRegex:
                Assert(status == jpdsNonDateTime);
                jspInitByBuffer(&arg, jpi->base, jpi->content.like_regex.expr);
                jspIsMutableWalker(&arg, cxt);
                break;
 
                /* literals */
            case jpiNull:
            case jpiString:
            case jpiNumeric:
            case jpiBool:
                break;
                /* accessors */
            case jpiKey:
            case jpiAnyKey:
                /* special items */
            case jpiSubscript:
            case jpiLast:
                /* item methods */
            case jpiType:
            case jpiSize:
            case jpiAbs:
            case jpiFloor:
            case jpiCeiling:
            case jpiDouble:
            case jpiKeyValue:
            case jpiBigint:
            case jpiBoolean:
            case jpiDecimal:
            case jpiInteger:
            case jpiNumber:
            case jpiStringFunc:
            case jpiStrReplace:
            case jpiStrLower:
            case jpiStrUpper:
            case jpiStrLtrim:
            case jpiStrRtrim:
            case jpiStrBtrim:
            case jpiStrInitcap:
            case jpiStrSplitPart:
                status = jpdsNonDateTime;
                break;
 
            case jpiTime:
            case jpiDate:
            case jpiTimestamp:
                status = jpdsDateTimeNonZoned;
                cxt->mutable = true;
                break;
 
            case jpiTimeTz:
            case jpiTimestampTz:
                status = jpdsDateTimeNonZoned;
                cxt->mutable = true;
                break;
 
        }
 
        if (!jspGetNext(jpi, &next))
            break;
 
        jpi = &next;
    }
 
    return status;
}

References arg, Assert, JsonPathMutableContext::current, datetime_format_has_tz(), exprType(), fb(), forboth, i, jpdsDateTimeNonZoned, jpdsDateTimeZoned, jpdsNonDateTime, jpdsUnknownDateTime, 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, jpiSubscript, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, jpiType, jpiVariable, jspGetArg(), jspGetArraySubscript(), jspGetLeftArg(), jspGetNext(), jspGetRightArg(), jspGetString(), jspInitByBuffer(), jspIsMutableWalker(), JsonPathMutableContext::lax, len, lfirst, lfirst_node, JsonPathMutableContext::mutable, name, next, pg_fallthrough, String::sval, JsonPathMutableContext::varexprs, and JsonPathMutableContext::varnames.

Referenced by jspIsMutable(), and jspIsMutableWalker().

jspOperationName()

const char * jspOperationName

(

JsonPathItemType

type

)

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

operationPriority()

static int operationPriority ( JsonPathItemType  op )

static

Definition at line 1002 of file jsonpath.c.

{
    switch (op)
    {
        case jpiOr:
            return 0;
        case jpiAnd:
            return 1;
        case jpiEqual:
        case jpiNotEqual:
        case jpiLess:
        case jpiGreater:
        case jpiLessOrEqual:
        case jpiGreaterOrEqual:
        case jpiStartsWith:
            return 2;
        case jpiAdd:
        case jpiSub:
            return 3;
        case jpiMul:
        case jpiDiv:
        case jpiMod:
            return 4;
        case jpiPlus:
        case jpiMinus:
            return 5;
        default:
            return 6;
    }
}

References jpiAdd, jpiAnd, jpiDiv, jpiEqual, jpiGreater, jpiGreaterOrEqual, jpiLess, jpiLessOrEqual, jpiMinus, jpiMod, jpiMul, jpiNotEqual, jpiOr, jpiPlus, jpiStartsWith, and jpiSub.

Referenced by printJsonPathItem().

printJsonPathItem()

static void printJsonPathItem ( StringInfo  buf, JsonPathItem *  v, bool  inKey, bool  printBracketes  )

static

Definition at line 529 of file jsonpath.c.

{
    JsonPathItem elem;
    int         i;
    int32       len;
    char       *str;
 
    check_stack_depth();
    CHECK_FOR_INTERRUPTS();
 
    switch (v->type)
    {
        case jpiNull:
            appendStringInfoString(buf, "null");
            break;
        case jpiString:
            str = jspGetString(v, &len);
            escape_json_with_len(buf, str, len);
            break;
        case jpiNumeric:
            if (jspHasNext(v))
                appendStringInfoChar(buf, '(');
            appendStringInfoString(buf,
                                   DatumGetCString(DirectFunctionCall1(numeric_out,
                                                                       NumericGetDatum(jspGetNumeric(v)))));
            if (jspHasNext(v))
                appendStringInfoChar(buf, ')');
            break;
        case jpiBool:
            if (jspGetBool(v))
                appendStringInfoString(buf, "true");
            else
                appendStringInfoString(buf, "false");
            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:
            if (printBracketes)
                appendStringInfoChar(buf, '(');
            jspGetLeftArg(v, &elem);
            printJsonPathItem(buf, &elem, false,
                              operationPriority(elem.type) <=
                              operationPriority(v->type));
            appendStringInfoChar(buf, ' ');
            appendStringInfoString(buf, jspOperationName(v->type));
            appendStringInfoChar(buf, ' ');
            jspGetRightArg(v, &elem);
            printJsonPathItem(buf, &elem, false,
                              operationPriority(elem.type) <=
                              operationPriority(v->type));
            if (printBracketes)
                appendStringInfoChar(buf, ')');
            break;
        case jpiNot:
            appendStringInfoString(buf, "!(");
            jspGetArg(v, &elem);
            printJsonPathItem(buf, &elem, false, false);
            appendStringInfoChar(buf, ')');
            break;
        case jpiIsUnknown:
            appendStringInfoChar(buf, '(');
            jspGetArg(v, &elem);
            printJsonPathItem(buf, &elem, false, false);
            appendStringInfoString(buf, ") is unknown");
            break;
        case jpiPlus:
        case jpiMinus:
            if (printBracketes)
                appendStringInfoChar(buf, '(');
            appendStringInfoChar(buf, v->type == jpiPlus ? '+' : '-');
            jspGetArg(v, &elem);
            printJsonPathItem(buf, &elem, false,
                              operationPriority(elem.type) <=
                              operationPriority(v->type));
            if (printBracketes)
                appendStringInfoChar(buf, ')');
            break;
        case jpiAnyArray:
            appendStringInfoString(buf, "[*]");
            break;
        case jpiAnyKey:
            if (inKey)
                appendStringInfoChar(buf, '.');
            appendStringInfoChar(buf, '*');
            break;
        case jpiIndexArray:
            appendStringInfoChar(buf, '[');
            for (i = 0; i < v->content.array.nelems; i++)
            {
                JsonPathItem from;
                JsonPathItem to;
                bool        range = jspGetArraySubscript(v, &from, &to, i);
 
                if (i)
                    appendStringInfoChar(buf, ',');
 
                printJsonPathItem(buf, &from, false, false);
 
                if (range)
                {
                    appendStringInfoString(buf, " to ");
                    printJsonPathItem(buf, &to, false, false);
                }
            }
            appendStringInfoChar(buf, ']');
            break;
        case jpiAny:
            if (inKey)
                appendStringInfoChar(buf, '.');
 
            if (v->content.anybounds.first == 0 &&
                v->content.anybounds.last == PG_UINT32_MAX)
                appendStringInfoString(buf, "**");
            else if (v->content.anybounds.first == v->content.anybounds.last)
            {
                if (v->content.anybounds.first == PG_UINT32_MAX)
                    appendStringInfoString(buf, "**{last}");
                else
                    appendStringInfo(buf, "**{%u}",
                                     v->content.anybounds.first);
            }
            else if (v->content.anybounds.first == PG_UINT32_MAX)
                appendStringInfo(buf, "**{last to %u}",
                                 v->content.anybounds.last);
            else if (v->content.anybounds.last == PG_UINT32_MAX)
                appendStringInfo(buf, "**{%u to last}",
                                 v->content.anybounds.first);
            else
                appendStringInfo(buf, "**{%u to %u}",
                                 v->content.anybounds.first,
                                 v->content.anybounds.last);
            break;
        case jpiKey:
            if (inKey)
                appendStringInfoChar(buf, '.');
            str = jspGetString(v, &len);
            escape_json_with_len(buf, str, len);
            break;
        case jpiCurrent:
            Assert(!inKey);
            appendStringInfoChar(buf, '@');
            break;
        case jpiRoot:
            Assert(!inKey);
            appendStringInfoChar(buf, '$');
            break;
        case jpiVariable:
            appendStringInfoChar(buf, '$');
            str = jspGetString(v, &len);
            escape_json_with_len(buf, str, len);
            break;
        case jpiFilter:
            appendStringInfoString(buf, "?(");
            jspGetArg(v, &elem);
            printJsonPathItem(buf, &elem, false, false);
            appendStringInfoChar(buf, ')');
            break;
        case jpiExists:
            appendStringInfoString(buf, "exists (");
            jspGetArg(v, &elem);
            printJsonPathItem(buf, &elem, false, false);
            appendStringInfoChar(buf, ')');
            break;
        case jpiType:
            appendStringInfoString(buf, ".type()");
            break;
        case jpiSize:
            appendStringInfoString(buf, ".size()");
            break;
        case jpiAbs:
            appendStringInfoString(buf, ".abs()");
            break;
        case jpiFloor:
            appendStringInfoString(buf, ".floor()");
            break;
        case jpiCeiling:
            appendStringInfoString(buf, ".ceiling()");
            break;
        case jpiDouble:
            appendStringInfoString(buf, ".double()");
            break;
        case jpiDatetime:
            appendStringInfoString(buf, ".datetime(");
            if (v->content.arg)
            {
                jspGetArg(v, &elem);
                printJsonPathItem(buf, &elem, false, false);
            }
            appendStringInfoChar(buf, ')');
            break;
        case jpiKeyValue:
            appendStringInfoString(buf, ".keyvalue()");
            break;
        case jpiLast:
            appendStringInfoString(buf, "last");
            break;
        case jpiLikeRegex:
            if (printBracketes)
                appendStringInfoChar(buf, '(');
 
            jspInitByBuffer(&elem, v->base, v->content.like_regex.expr);
            printJsonPathItem(buf, &elem, false,
                              operationPriority(elem.type) <=
                              operationPriority(v->type));
 
            appendStringInfoString(buf, " like_regex ");
 
            escape_json_with_len(buf,
                                 v->content.like_regex.pattern,
                                 v->content.like_regex.patternlen);
 
            if (v->content.like_regex.flags)
            {
                appendStringInfoString(buf, " flag \"");
 
                if (v->content.like_regex.flags & JSP_REGEX_ICASE)
                    appendStringInfoChar(buf, 'i');
                if (v->content.like_regex.flags & JSP_REGEX_DOTALL)
                    appendStringInfoChar(buf, 's');
                if (v->content.like_regex.flags & JSP_REGEX_MLINE)
                    appendStringInfoChar(buf, 'm');
                if (v->content.like_regex.flags & JSP_REGEX_WSPACE)
                    appendStringInfoChar(buf, 'x');
                if (v->content.like_regex.flags & JSP_REGEX_QUOTE)
                    appendStringInfoChar(buf, 'q');
 
                appendStringInfoChar(buf, '"');
            }
 
            if (printBracketes)
                appendStringInfoChar(buf, ')');
            break;
        case jpiBigint:
            appendStringInfoString(buf, ".bigint()");
            break;
        case jpiBoolean:
            appendStringInfoString(buf, ".boolean()");
            break;
        case jpiDate:
            appendStringInfoString(buf, ".date()");
            break;
        case jpiDecimal:
            appendStringInfoString(buf, ".decimal(");
            if (v->content.args.left)
            {
                jspGetLeftArg(v, &elem);
                printJsonPathItem(buf, &elem, false, false);
            }
            if (v->content.args.right)
            {
                appendStringInfoChar(buf, ',');
                jspGetRightArg(v, &elem);
                printJsonPathItem(buf, &elem, false, false);
            }
            appendStringInfoChar(buf, ')');
            break;
        case jpiInteger:
            appendStringInfoString(buf, ".integer()");
            break;
        case jpiNumber:
            appendStringInfoString(buf, ".number()");
            break;
        case jpiStringFunc:
            appendStringInfoString(buf, ".string()");
            break;
        case jpiTime:
            appendStringInfoString(buf, ".time(");
            if (v->content.arg)
            {
                jspGetArg(v, &elem);
                printJsonPathItem(buf, &elem, false, false);
            }
            appendStringInfoChar(buf, ')');
            break;
        case jpiTimeTz:
            appendStringInfoString(buf, ".time_tz(");
            if (v->content.arg)
            {
                jspGetArg(v, &elem);
                printJsonPathItem(buf, &elem, false, false);
            }
            appendStringInfoChar(buf, ')');
            break;
        case jpiTimestamp:
            appendStringInfoString(buf, ".timestamp(");
            if (v->content.arg)
            {
                jspGetArg(v, &elem);
                printJsonPathItem(buf, &elem, false, false);
            }
            appendStringInfoChar(buf, ')');
            break;
        case jpiTimestampTz:
            appendStringInfoString(buf, ".timestamp_tz(");
            if (v->content.arg)
            {
                jspGetArg(v, &elem);
                printJsonPathItem(buf, &elem, false, false);
            }
            appendStringInfoChar(buf, ')');
            break;
        case jpiStrReplace:
            appendStringInfoString(buf, ".replace(");
            jspGetLeftArg(v, &elem);
            printJsonPathItem(buf, &elem, false, false);
            appendStringInfoChar(buf, ',');
            jspGetRightArg(v, &elem);
            printJsonPathItem(buf, &elem, false, false);
            appendStringInfoChar(buf, ')');
            break;
        case jpiStrLower:
            appendStringInfoString(buf, ".lower()");
            break;
        case jpiStrUpper:
            appendStringInfoString(buf, ".upper()");
            break;
        case jpiStrSplitPart:
            appendStringInfoString(buf, ".split_part(");
            jspGetLeftArg(v, &elem);
            printJsonPathItem(buf, &elem, false, false);
            appendStringInfoChar(buf, ',');
            jspGetRightArg(v, &elem);
            printJsonPathItem(buf, &elem, false, false);
            appendStringInfoChar(buf, ')');
            break;
        case jpiStrLtrim:
            appendStringInfoString(buf, ".ltrim(");
            if (v->content.arg)
            {
                jspGetArg(v, &elem);
                printJsonPathItem(buf, &elem, false, false);
            }
            appendStringInfoChar(buf, ')');
            break;
        case jpiStrRtrim:
            appendStringInfoString(buf, ".rtrim(");
            if (v->content.arg)
            {
                jspGetArg(v, &elem);
                printJsonPathItem(buf, &elem, false, false);
            }
            appendStringInfoChar(buf, ')');
            break;
        case jpiStrBtrim:
            appendStringInfoString(buf, ".btrim(");
            if (v->content.arg)
            {
                jspGetArg(v, &elem);
                printJsonPathItem(buf, &elem, false, false);
            }
            appendStringInfoChar(buf, ')');
            break;
        case jpiStrInitcap:
            appendStringInfoString(buf, ".initcap()");
            break;
        default:
            elog(ERROR, "unrecognized jsonpath item type: %d", v->type);
    }
 
    if (jspGetNext(v, &elem))
        printJsonPathItem(buf, &elem, true, true);
}

References JsonPathItem::anybounds, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), JsonPathItem::arg, JsonPathItem::args, JsonPathItem::array, Assert, JsonPathItem::base, buf, CHECK_FOR_INTERRUPTS, check_stack_depth(), JsonPathItem::content, DatumGetCString(), DirectFunctionCall1, elog, ERROR, escape_json_with_len(), JsonPathItem::expr, fb(), JsonPathItem::first, JsonPathItem::flags, i, 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, JSP_REGEX_DOTALL, JSP_REGEX_ICASE, JSP_REGEX_MLINE, JSP_REGEX_QUOTE, JSP_REGEX_WSPACE, jspGetArg(), jspGetArraySubscript(), jspGetBool(), jspGetLeftArg(), jspGetNext(), jspGetNumeric(), jspGetRightArg(), jspGetString(), jspHasNext, jspInitByBuffer(), jspOperationName(), JsonPathItem::last, JsonPathItem::left, len, JsonPathItem::like_regex, JsonPathItem::nelems, numeric_out(), NumericGetDatum(), operationPriority(), JsonPathItem::pattern, JsonPathItem::patternlen, PG_UINT32_MAX, printJsonPathItem(), range(), JsonPathItem::right, str, and JsonPathItem::type.

Referenced by jsonPathToCstring(), and printJsonPathItem().

reserveSpaceForItemPointer()

static int32 reserveSpaceForItemPointer ( StringInfo  buf )

static

Definition at line 515 of file jsonpath.c.

{
    int32       pos = buf->len;
    int32       ptr = 0;
 
    appendBinaryStringInfo(buf, &ptr, sizeof(ptr));
 
    return pos;
}

References appendBinaryStringInfo(), and buf.

Referenced by flattenJsonPathParseItem().