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

Include dependency graph for jsonpath.c:

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)

Typedefs
typedef enum JsonPathDatatypeStatus	JsonPathDatatypeStatus

typedef struct JsonPathMutableContext	JsonPathMutableContext

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

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)

static JsonPathDatatypeStatus	jspIsMutableWalker (JsonPathItem jpi, 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 820 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 825 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 830 of file jsonpath.c.

Typedef Documentation

◆ JsonPathDatatypeStatus

typedef enum JsonPathDatatypeStatus JsonPathDatatypeStatus

◆ JsonPathMutableContext

typedef struct JsonPathMutableContext JsonPathMutableContext

Enumeration Type Documentation

◆ JsonPathDatatypeStatus

enum JsonPathDatatypeStatus

Enumerator
jpdsNonDateTime
jpdsUnknownDateTime
jpdsDateTimeZoned
jpdsDateTimeNonZoned

Definition at line 1084 of file jsonpath.c.

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

Function Documentation

◆ alignStringInfoInt()

static void alignStringInfoInt ( StringInfo buf )

static

Definition at line 441 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 int flattenJsonPathParseItem	(	StringInfo	buf,
		JsonPathParseItem *	item,
		int	nestingLevel,
		bool	insideArraySubscript
	)

static

Definition at line 231 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, (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:
         case jpiDatetime:
             {
                 int32       arg = reserveSpaceForItemPointer(buf);
  
                 chld = !item->value.arg ? pos :
                     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;
 }

Referenced by jsonPathFromCstring().

◆ jsonpath_in()

Datum jsonpath_in ( PG_FUNCTION_ARGS )

Definition at line 95 of file jsonpath.c.

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

References jsonPathFromCstring(), len, and PG_GETARG_CSTRING.

Referenced by makeParentJsonTableNode().

◆ jsonpath_out()

Datum jsonpath_out ( PG_FUNCTION_ARGS )

Definition at line 131 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 112 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);
 }

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

static

Definition at line 170 of file jsonpath.c.

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

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

Referenced by jsonpath_in(), and jsonpath_recv().

◆ jsonPathToCstring()

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

static

Definition at line 205 of file jsonpath.c.

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

References appendBinaryStringInfo(), 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 929 of file jsonpath.c.

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

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

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

◆ jspGetArraySubscript()

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

Definition at line 1068 of file jsonpath.c.

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

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

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

◆ jspGetBool()

bool jspGetBool ( JsonPathItem * v )

Definition at line 1040 of file jsonpath.c.

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

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

Referenced by getJsonPathItem(), and printJsonPathItem().

◆ jspGetLeftArg()

void jspGetLeftArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 998 of file jsonpath.c.

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

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

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

◆ jspGetNext()

bool jspGetNext	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 943 of file jsonpath.c.

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

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

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

◆ jspGetNumeric()

Numeric jspGetNumeric ( JsonPathItem * v )

Definition at line 1048 of file jsonpath.c.

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

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

Referenced by getJsonPathItem(), and printJsonPathItem().

◆ jspGetRightArg()

void jspGetRightArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 1019 of file jsonpath.c.

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

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

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

◆ jspGetString()

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

Definition at line 1056 of file jsonpath.c.

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

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

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

◆ jspInit()

void jspInit	(	JsonPathItem *	v,
		JsonPath *	js
	)

Definition at line 839 of file jsonpath.c.

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

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

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

◆ jspInitByBuffer()

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

Definition at line 849 of file jsonpath.c.

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

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

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

◆ jspIsMutable()

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

Definition at line 1321 of file jsonpath.c.

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

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

Referenced by contain_mutable_functions_walker().

◆ jspIsMutableWalker()

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

static

Definition at line 1106 of file jsonpath.c.

 {
     JsonPathItem next;
     JsonPathDatatypeStatus status = jpdsNonDateTime;
  
     while (!cxt->mutable)
     {
         JsonPathItem arg;
         JsonPathDatatypeStatus leftStatus;
         JsonPathDatatypeStatus rightStatus;
  
         switch (jpi->type)
         {
             case jpiRoot:
                 Assert(status == jpdsNonDateTime);
                 break;
  
             case jpiCurrent:
                 Assert(status == jpdsNonDateTime);
                 status = cxt->current;
                 break;
  
             case jpiFilter:
                 {
                     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);
                 }
                 /* 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;
                     int         flags;
  
                     jspGetArg(jpi, &arg);
                     if (arg.type != jpiString)
                     {
                         status = jpdsNonDateTime;
                         break;  /* there will be runtime error */
                     }
  
                     template = jspGetString(&arg, NULL);
                     flags = datetime_format_flags(template, NULL);
                     if (flags & DCH_ZONED)
                         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:
                 /* 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:
                 status = jpdsNonDateTime;
                 break;
         }
  
         if (!jspGetNext(jpi, &next))
             break;
  
         jpi = &next;
     }
  
     return status;
 }

References JsonPathItem::anybounds, arg, JsonPathItem::arg, JsonPathItem::array, Assert(), JsonPathItem::base, JsonPathItem::content, JsonPathMutableContext::current, datetime_format_flags(), DCH_ZONED, exprType(), forboth, i, jpdsDateTimeNonZoned, jpdsDateTimeZoned, jpdsNonDateTime, jpdsUnknownDateTime, 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, jpiSubscript, jpiType, jpiVariable, jspGetArg(), jspGetArraySubscript(), jspGetLeftArg(), jspGetNext(), jspGetRightArg(), jspGetString(), jspInitByBuffer(), JsonPathMutableContext::lax, len, lfirst, lfirst_node, JsonPathItem::like_regex, JsonPathMutableContext::mutable, name, next, status(), String::sval, JsonPathItem::type, JsonPathMutableContext::varexprs, and JsonPathMutableContext::varnames.

Referenced by jspIsMutable().

◆ jspOperationName()

const char* jspOperationName ( JsonPathItemType type )

Definition at line 724 of file jsonpath.c.

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

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

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

◆ operationPriority()

static int operationPriority ( JsonPathItemType op )

static

Definition at line 783 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 478 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))
                 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_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:
             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)
                     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:
             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 jpiDatetime:
             appendBinaryStringInfo(buf, ".datetime(", 10);
             if (v->content.arg)
             {
                 jspGetArg(v, &elem);
                 printJsonPathItem(buf, &elem, false, false);
             }
             appendStringInfoChar(buf, ')');
             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);
 }

References JsonPathItem::anybounds, appendBinaryStringInfo(), 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 464 of file jsonpath.c.

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

References appendBinaryStringInfo(), and buf.

Referenced by flattenJsonPathParseItem().

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ read_byte

◆ read_int32

◆ read_int32_n

Typedef Documentation

◆ JsonPathDatatypeStatus

◆ JsonPathMutableContext

Enumeration Type Documentation

◆ JsonPathDatatypeStatus

Function Documentation

◆ alignStringInfoInt()

◆ flattenJsonPathParseItem()

◆ jsonpath_in()

◆ jsonpath_out()

◆ jsonpath_recv()

◆ jsonpath_send()

◆ jsonPathFromCstring()

◆ jsonPathToCstring()

◆ jspGetArg()

◆ jspGetArraySubscript()

◆ jspGetBool()

◆ jspGetLeftArg()

◆ jspGetNext()

◆ jspGetNumeric()

◆ jspGetRightArg()

◆ jspGetString()

◆ jspInit()

◆ jspInitByBuffer()

◆ jspIsMutable()

◆ jspIsMutableWalker()

◆ jspOperationName()

◆ operationPriority()

◆ printJsonPathItem()

◆ reserveSpaceForItemPointer()