#include "postgres.h"
#include "funcapi.h"
#include "lib/stringinfo.h"
#include "libpq/pqformat.h"
#include "nodes/miscnodes.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, 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)

Macro Definition Documentation

◆ read_byte

#define read_byte	(	v,
		b,
		p
	)

Value:

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

Definition at line 850 of file jsonpath.c.

◆ read_int32

#define read_int32	(	v,
		b,
		p
	)

Value:

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

Definition at line 855 of file jsonpath.c.

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

Function Documentation

◆ alignStringInfoInt()

static void alignStringInfoInt ( StringInfo buf )

static

Definition at line 471 of file jsonpath.c.

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

References appendStringInfoCharMacro, buf, and INTALIGN.

Referenced by flattenJsonPathParseItem().

◆ flattenJsonPathParseItem()

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

static

Definition at line 237 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:
             {
                 /*
                  * 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++;
             /* FALLTHROUGH */
         case jpiIsUnknown:
         case jpiNot:
         case jpiPlus:
         case jpiMinus:
         case jpiExists:
         case jpiDatetime:
             {
                 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:
             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;
 }

Referenced by jsonPathFromCstring().

◆ jsonpath_in()

Datum jsonpath_in ( PG_FUNCTION_ARGS )

Definition at line 96 of file jsonpath.c.

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

References jsonPathFromCstring(), len, and PG_GETARG_CSTRING.

◆ jsonpath_out()

Datum jsonpath_out ( PG_FUNCTION_ARGS )

Definition at line 132 of file jsonpath.c.

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

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

◆ jsonpath_recv()

Datum jsonpath_recv ( PG_FUNCTION_ARGS )

Definition at line 113 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, JSONPATH_VERSION, jsonPathFromCstring(), PG_GETARG_POINTER, pq_getmsgint(), pq_getmsgtext(), and generate_unaccent_rules::str.

◆ jsonpath_send()

Datum jsonpath_send ( PG_FUNCTION_ARGS )

Definition at line 145 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, 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.

◆ jsonPathFromCstring()

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

static

Definition at line 171 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, enlargeStringInfo(), ereturn, errcode(), errmsg(), JsonPathParseResult::expr, flattenJsonPathParseItem(), initStringInfo(), JSONPATH_HDRSZ, JSONPATH_LAX, JSONPATH_VERSION, JsonPathParseResult::lax, len, parsejsonpath(), PG_RETURN_JSONPATH_P, res, 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 211 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(), 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 959 of file jsonpath.c.

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

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

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

◆ jspGetArraySubscript()

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

Definition at line 1098 of file jsonpath.c.

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

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

Referenced by executeItemOptUnwrapTarget(), and printJsonPathItem().

◆ jspGetBool()

bool jspGetBool ( JsonPathItem * v )

Definition at line 1070 of file jsonpath.c.

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

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

Referenced by getJsonPathItem(), and printJsonPathItem().

◆ jspGetLeftArg()

void jspGetLeftArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 1028 of file jsonpath.c.

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

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

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

◆ jspGetNext()

bool jspGetNext	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 973 of file jsonpath.c.

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

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

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

◆ jspGetNumeric()

Numeric jspGetNumeric ( JsonPathItem * v )

Definition at line 1078 of file jsonpath.c.

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

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

Referenced by getJsonPathItem(), and printJsonPathItem().

◆ jspGetRightArg()

void jspGetRightArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 1049 of file jsonpath.c.

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

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

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

◆ jspGetString()

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

Definition at line 1086 of file jsonpath.c.

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

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

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

◆ jspInit()

void jspInit	(	JsonPathItem *	v,
		JsonPath *	js
	)

Definition at line 869 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(), and jsonPathToCstring().

◆ jspInitByBuffer()

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

Definition at line 879 of file jsonpath.c.

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

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

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

◆ jspOperationName()

const char* jspOperationName ( JsonPathItemType type )

Definition at line 754 of file jsonpath.c.

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

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

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

◆ operationPriority()

static int operationPriority ( JsonPathItemType op )

static

Definition at line 813 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 508 of file jsonpath.c.

 {
     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:
             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 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(buf, v->content.like_regex.pattern);
  
             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 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:
             appendStringInfoString(buf, "?(");
             jspGetArg(v, &elem);
             printJsonPathItem(buf, &elem, false, false);
             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 jpiExists:
             appendStringInfoString(buf, "exists (");
             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:
             appendStringInfoString(buf, "last");
             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 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;
         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::array, Assert(), JsonPathItem::base, buf, CHECK_FOR_INTERRUPTS, check_stack_depth(), JsonPathItem::content, DatumGetCString(), DirectFunctionCall1, elog(), ERROR, escape_json(), i, jpiAbs, jpiAdd, jpiAnd, jpiAny, jpiAnyArray, jpiAnyKey, jpiBool, jpiCeiling, jpiCurrent, jpiDatetime, jpiDiv, jpiDouble, jpiEqual, jpiExists, jpiFilter, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiIndexArray, jpiIsUnknown, jpiKey, jpiKeyValue, jpiLast, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiString, jpiSub, jpiType, jpiVariable, 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::like_regex, numeric_out(), NumericGetDatum(), operationPriority(), PG_UINT32_MAX, range(), and JsonPathItem::type.

Referenced by jsonPathToCstring().

◆ reserveSpaceForItemPointer()

static int32 reserveSpaceForItemPointer ( StringInfo buf )

static

Definition at line 494 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().

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