#include "postgres.h"
#include "funcapi.h"
#include "lib/stringinfo.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "utils/builtins.h"
#include "utils/json.h"
#include "utils/jsonpath.h"

Include dependency graph for jsonpath.c:

Macros
#define	read_byte(v, b, p)

#define	read_int32(v, b, p)

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

Functions
static Datum	jsonPathFromCstring (char *in, int len)

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

static int	flattenJsonPathParseItem (StringInfo buf, 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)

Macro Definition Documentation

◆ read_byte

#define read_byte	(	v,
		b,
		p
	)

Value:

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

Definition at line 801 of file jsonpath.c.

Referenced by jspInitByBuffer().

◆ read_int32

#define read_int32	(	v,
		b,
		p
	)

Value:

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

Definition at line 806 of file jsonpath.c.

Referenced by jspInitByBuffer().

◆ 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 811 of file jsonpath.c.

Referenced by jspInitByBuffer().

Function Documentation

◆ alignStringInfoInt()

static void alignStringInfoInt ( StringInfo buf )

static

Definition at line 437 of file jsonpath.c.

References appendStringInfoCharMacro, INTALIGN, and StringInfoData::len.

Referenced by flattenJsonPathParseItem().

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

◆ flattenJsonPathParseItem()

static int flattenJsonPathParseItem	(	StringInfo	buf,
		JsonPathParseItem *	item,
		int	nestingLevel,
		bool	insideArraySubscript
	)

static

Definition at line 229 of file jsonpath.c.

Referenced by jsonPathFromCstring().

 {
     /* 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, (char *) &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, (char *) item->value.numeric,
                                    VARSIZE(item->value.numeric));
             break;
         case jpiBool:
             appendBinaryStringInfo(buf, (char *) &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:
             {
                 /*
                  * 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);
 
                 chld = !item->value.args.left ? pos :
                     flattenJsonPathParseItem(buf, item->value.args.left,
                                              nestingLevel + argNestingLevel,
                                              insideArraySubscript);
                 *(int32 *) (buf->data + left) = chld - pos;
 
                 chld = !item->value.args.right ? pos :
                     flattenJsonPathParseItem(buf, item->value.args.right,
                                              nestingLevel + argNestingLevel,
                                              insideArraySubscript);
                 *(int32 *) (buf->data + right) = chld - pos;
             }
             break;
         case jpiLikeRegex:
             {
                 int32       offs;
 
                 appendBinaryStringInfo(buf,
                                        (char *) &item->value.like_regex.flags,
                                        sizeof(item->value.like_regex.flags));
                 offs = reserveSpaceForItemPointer(buf);
                 appendBinaryStringInfo(buf,
                                        (char *) &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');
 
                 chld = flattenJsonPathParseItem(buf, item->value.like_regex.expr,
                                                 nestingLevel,
                                                 insideArraySubscript);
                 *(int32 *) (buf->data + offs) = chld - pos;
             }
             break;
         case jpiFilter:
             argNestingLevel++;
             /* FALLTHROUGH */
         case jpiIsUnknown:
         case jpiNot:
         case jpiPlus:
         case jpiMinus:
         case jpiExists:
             {
                 int32       arg = reserveSpaceForItemPointer(buf);
 
                 chld = flattenJsonPathParseItem(buf, item->value.arg,
                                                 nestingLevel + argNestingLevel,
                                                 insideArraySubscript);
                 *(int32 *) (buf->data + arg) = chld - pos;
             }
             break;
         case jpiNull:
             break;
         case jpiRoot:
             break;
         case jpiAnyArray:
         case jpiAnyKey:
             break;
         case jpiCurrent:
             if (nestingLevel <= 0)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("@ is not allowed in root expressions")));
             break;
         case jpiLast:
             if (!insideArraySubscript)
                 ereport(ERROR,
                         (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, (char *) &nelems, sizeof(nelems));
 
                 offset = buf->len;
 
                 appendStringInfoSpaces(buf, sizeof(int32) * 2 * nelems);
 
                 for (i = 0; i < nelems; i++)
                 {
                     int32      *ppos;
                     int32       topos;
                     int32       frompos =
                     flattenJsonPathParseItem(buf,
                                              item->value.array.elems[i].from,
                                              nestingLevel, true) - pos;
 
                     if (item->value.array.elems[i].to)
                         topos = flattenJsonPathParseItem(buf,
                                                          item->value.array.elems[i].to,
                                                          nestingLevel, true) - pos;
                     else
                         topos = 0;
 
                     ppos = (int32 *) &buf->data[offset + i * 2 * sizeof(int32)];
 
                     ppos[0] = frompos;
                     ppos[1] = topos;
                 }
             }
             break;
         case jpiAny:
             appendBinaryStringInfo(buf,
                                    (char *) &item->value.anybounds.first,
                                    sizeof(item->value.anybounds.first));
             appendBinaryStringInfo(buf,
                                    (char *) &item->value.anybounds.last,
                                    sizeof(item->value.anybounds.last));
             break;
         case jpiType:
         case jpiSize:
         case jpiAbs:
         case jpiFloor:
         case jpiCeiling:
         case jpiDouble:
         case jpiKeyValue:
             break;
         default:
             elog(ERROR, "unrecognized jsonpath item type: %d", item->type);
     }
 
     if (item->next)
     {
         chld = flattenJsonPathParseItem(buf, item->next, nestingLevel,
                                         insideArraySubscript) - pos;
         *(int32 *) (buf->data + next) = chld;
     }
 
     return pos;
 }

◆ jsonpath_in()

Datum jsonpath_in ( PG_FUNCTION_ARGS )

Definition at line 93 of file jsonpath.c.

References jsonPathFromCstring(), and PG_GETARG_CSTRING.

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

◆ jsonpath_out()

Datum jsonpath_out ( PG_FUNCTION_ARGS )

Definition at line 129 of file jsonpath.c.

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

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

◆ jsonpath_recv()

Datum jsonpath_recv ( PG_FUNCTION_ARGS )

Definition at line 110 of file jsonpath.c.

References buf, StringInfoData::cursor, elog, ERROR, JSONPATH_VERSION, jsonPathFromCstring(), StringInfoData::len, PG_GETARG_POINTER, pq_getmsgint(), pq_getmsgtext(), and generate_unaccent_rules::str.

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

◆ jsonpath_send()

Datum jsonpath_send ( PG_FUNCTION_ARGS )

Definition at line 142 of file jsonpath.c.

References buf, StringInfoData::data, initStringInfo(), JSONPATH_VERSION, jsonPathToCstring(), StringInfoData::len, pfree(), PG_GETARG_JSONPATH_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint8(), pq_sendtext(), and VARSIZE.

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

◆ jsonPathFromCstring()

static Datum jsonPathFromCstring	(	char *	in,
		int	len
	)

static

Definition at line 168 of file jsonpath.c.

References appendStringInfoSpaces(), buf, StringInfoData::data, enlargeStringInfo(), ereport, errcode(), errmsg(), ERROR, JsonPathParseResult::expr, flattenJsonPathParseItem(), JsonPath::header, initStringInfo(), JSONPATH_HDRSZ, JSONPATH_LAX, JSONPATH_VERSION, JsonPathParseResult::lax, StringInfoData::len, parsejsonpath(), PG_RETURN_JSONPATH_P, and SET_VARSIZE.

Referenced by jsonpath_in(), and jsonpath_recv().

 {
     JsonPathParseResult *jsonpath = parsejsonpath(in, len);
     JsonPath   *res;
     StringInfoData buf;
 
     initStringInfo(&buf);
     enlargeStringInfo(&buf, 4 * len /* estimation */ );
 
     appendStringInfoSpaces(&buf, JSONPATH_HDRSZ);
 
     if (!jsonpath)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid input syntax for type %s: \"%s\"", "jsonpath",
                         in)));
 
     flattenJsonPathParseItem(&buf, jsonpath->expr, 0, false);
 
     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);
 }

◆ jsonPathToCstring()

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

static

Definition at line 203 of file jsonpath.c.

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

Referenced by jsonpath_out(), and jsonpath_send().

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

◆ jspGetArg()

void jspGetArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 909 of file jsonpath.c.

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

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

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

◆ jspGetArraySubscript()

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

Definition at line 1046 of file jsonpath.c.

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

Referenced by executeItemOptUnwrapTarget(), and printJsonPathItem().

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

◆ jspGetBool()

bool jspGetBool ( JsonPathItem * v )

Definition at line 1018 of file jsonpath.c.

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

Referenced by getJsonPathItem(), and printJsonPathItem().

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

◆ jspGetLeftArg()

void jspGetLeftArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 976 of file jsonpath.c.

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

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

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

◆ jspGetNext()

bool jspGetNext	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 922 of file jsonpath.c.

References Assert, JsonPathItem::base, jpiAbs, jpiAdd, jpiAnd, jpiAny, jpiAnyArray, jpiAnyKey, jpiBool, jpiCeiling, jpiCurrent, jpiDiv, jpiDouble, jpiEqual, jpiExists, jpiFilter, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiIndexArray, jpiIsUnknown, jpiKey, jpiKeyValue, jpiLast, jpiLess, jpiLessOrEqual, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiString, jpiSub, jpiType, jpiVariable, jspHasNext, jspInitByBuffer(), JsonPathItem::nextPos, and JsonPathItem::type.

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

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

◆ jspGetNumeric()

Numeric jspGetNumeric ( JsonPathItem * v )

Definition at line 1026 of file jsonpath.c.

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

Referenced by getJsonPathItem(), and printJsonPathItem().

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

◆ jspGetRightArg()

void jspGetRightArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 997 of file jsonpath.c.

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

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

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

◆ jspGetString()

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

Definition at line 1034 of file jsonpath.c.

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

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

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

◆ jspInit()

void jspInit	(	JsonPathItem *	v,
		JsonPath *	js
	)

Definition at line 820 of file jsonpath.c.

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

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

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

◆ jspInitByBuffer()

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

Definition at line 830 of file jsonpath.c.

References JsonPathItem::anybounds, JsonPathItem::arg, JsonPathItem::args, JsonPathItem::array, JsonPathItem::base, JsonPathItem::content, elog, ERROR, INTALIGN, jpiAbs, jpiAdd, jpiAnd, jpiAny, jpiAnyArray, jpiAnyKey, jpiBool, jpiCeiling, jpiCurrent, jpiDiv, jpiDouble, jpiEqual, jpiExists, jpiFilter, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiIndexArray, jpiIsUnknown, jpiKey, jpiKeyValue, jpiLast, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiString, jpiSub, jpiType, jpiVariable, JsonPathItem::like_regex, JsonPathItem::nextPos, read_byte, read_int32, read_int32_n, JsonPathItem::type, and JsonPathItem::value.

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

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

◆ jspOperationName()

const char* jspOperationName ( JsonPathItemType type )

Definition at line 707 of file jsonpath.c.

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

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

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

◆ operationPriority()

static int operationPriority ( JsonPathItemType op )

static

Definition at line 764 of file jsonpath.c.

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

Referenced by printJsonPathItem().

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

◆ printJsonPathItem()

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

static

Definition at line 474 of file jsonpath.c.

References JsonPathItem::anybounds, appendBinaryStringInfo(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), JsonPathItem::array, Assert, JsonPathItem::base, CHECK_FOR_INTERRUPTS, check_stack_depth(), JsonPathItem::content, DatumGetCString, DirectFunctionCall1, elog, ERROR, escape_json(), i, jpiAbs, jpiAdd, jpiAnd, jpiAny, jpiAnyArray, jpiAnyKey, jpiBool, jpiCeiling, jpiCurrent, jpiDiv, jpiDouble, jpiEqual, jpiExists, jpiFilter, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiIndexArray, jpiIsUnknown, jpiKey, jpiKeyValue, jpiLast, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiString, jpiSub, jpiType, jpiVariable, JSP_REGEX_ICASE, JSP_REGEX_MLINE, JSP_REGEX_QUOTE, JSP_REGEX_SLINE, JSP_REGEX_WSPACE, jspGetArg(), jspGetArraySubscript(), jspGetBool(), jspGetLeftArg(), jspGetNext(), jspGetNumeric(), jspGetRightArg(), jspGetString(), jspInitByBuffer(), jspOperationName(), JsonPathItem::like_regex, numeric_out(), NumericGetDatum, operationPriority(), PG_UINT32_MAX, range(), and JsonPathItem::type.

Referenced by jsonPathToCstring().

 {
     JsonPathItem elem;
     int         i;
 
     check_stack_depth();
     CHECK_FOR_INTERRUPTS();
 
     switch (v->type)
     {
         case jpiNull:
             appendStringInfoString(buf, "null");
             break;
         case jpiKey:
             if (inKey)
                 appendStringInfoChar(buf, '.');
             escape_json(buf, jspGetString(v, NULL));
             break;
         case jpiString:
             escape_json(buf, jspGetString(v, NULL));
             break;
         case jpiVariable:
             appendStringInfoChar(buf, '$');
             escape_json(buf, jspGetString(v, NULL));
             break;
         case jpiNumeric:
             appendStringInfoString(buf,
                                    DatumGetCString(DirectFunctionCall1(numeric_out,
                                                                        NumericGetDatum(jspGetNumeric(v)))));
             break;
         case jpiBool:
             if (jspGetBool(v))
                 appendBinaryStringInfo(buf, "true", 4);
             else
                 appendBinaryStringInfo(buf, "false", 5);
             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 jpiLikeRegex:
             if (printBracketes)
                 appendStringInfoChar(buf, '(');
 
             jspInitByBuffer(&elem, v->base, v->content.like_regex.expr);
             printJsonPathItem(buf, &elem, false,
                               operationPriority(elem.type) <=
                               operationPriority(v->type));
 
             appendBinaryStringInfo(buf, " like_regex ", 12);
 
             escape_json(buf, v->content.like_regex.pattern);
 
             if (v->content.like_regex.flags)
             {
                 appendBinaryStringInfo(buf, " flag \"", 7);
 
                 if (v->content.like_regex.flags & JSP_REGEX_ICASE)
                     appendStringInfoChar(buf, 'i');
                 if (v->content.like_regex.flags & JSP_REGEX_SLINE)
                     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 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 jpiFilter:
             appendBinaryStringInfo(buf, "?(", 2);
             jspGetArg(v, &elem);
             printJsonPathItem(buf, &elem, false, false);
             appendStringInfoChar(buf, ')');
             break;
         case jpiNot:
             appendBinaryStringInfo(buf, "!(", 2);
             jspGetArg(v, &elem);
             printJsonPathItem(buf, &elem, false, false);
             appendStringInfoChar(buf, ')');
             break;
         case jpiIsUnknown:
             appendStringInfoChar(buf, '(');
             jspGetArg(v, &elem);
             printJsonPathItem(buf, &elem, false, false);
             appendBinaryStringInfo(buf, ") is unknown", 12);
             break;
         case jpiExists:
             appendBinaryStringInfo(buf, "exists (", 8);
             jspGetArg(v, &elem);
             printJsonPathItem(buf, &elem, false, false);
             appendStringInfoChar(buf, ')');
             break;
         case jpiCurrent:
             Assert(!inKey);
             appendStringInfoChar(buf, '@');
             break;
         case jpiRoot:
             Assert(!inKey);
             appendStringInfoChar(buf, '$');
             break;
         case jpiLast:
             appendBinaryStringInfo(buf, "last", 4);
             break;
         case jpiAnyArray:
             appendBinaryStringInfo(buf, "[*]", 3);
             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)
                 {
                     appendBinaryStringInfo(buf, " to ", 4);
                     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)
                 appendBinaryStringInfo(buf, "**", 2);
             else if (v->content.anybounds.first == v->content.anybounds.last)
             {
                 if (v->content.anybounds.first == PG_UINT32_MAX)
                     appendStringInfo(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 jpiType:
             appendBinaryStringInfo(buf, ".type()", 7);
             break;
         case jpiSize:
             appendBinaryStringInfo(buf, ".size()", 7);
             break;
         case jpiAbs:
             appendBinaryStringInfo(buf, ".abs()", 6);
             break;
         case jpiFloor:
             appendBinaryStringInfo(buf, ".floor()", 8);
             break;
         case jpiCeiling:
             appendBinaryStringInfo(buf, ".ceiling()", 10);
             break;
         case jpiDouble:
             appendBinaryStringInfo(buf, ".double()", 9);
             break;
         case jpiKeyValue:
             appendBinaryStringInfo(buf, ".keyvalue()", 11);
             break;
         default:
             elog(ERROR, "unrecognized jsonpath item type: %d", v->type);
     }
 
     if (jspGetNext(v, &elem))
         printJsonPathItem(buf, &elem, true, true);
 }

◆ reserveSpaceForItemPointer()

static int32 reserveSpaceForItemPointer ( StringInfo buf )

static

Definition at line 460 of file jsonpath.c.

References appendBinaryStringInfo(), and StringInfoData::len.

Referenced by flattenJsonPathParseItem().

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

Macros

Functions

Macro Definition Documentation

◆ read_byte

◆ read_int32

◆ read_int32_n

Function Documentation

◆ alignStringInfoInt()

◆ flattenJsonPathParseItem()

◆ jsonpath_in()

◆ jsonpath_out()

◆ jsonpath_recv()

◆ jsonpath_send()

◆ jsonPathFromCstring()

◆ jsonPathToCstring()

◆ jspGetArg()

◆ jspGetArraySubscript()

◆ jspGetBool()

◆ jspGetLeftArg()

◆ jspGetNext()

◆ jspGetNumeric()

◆ jspGetRightArg()

◆ jspGetString()

◆ jspInit()

◆ jspInitByBuffer()

◆ jspOperationName()

◆ operationPriority()

◆ printJsonPathItem()

◆ reserveSpaceForItemPointer()