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

Include dependency graph for jsonpath.c:

Data Structures
struct	JsonPathMutableContext

Macros
#define	read_byte(v, b, p)

#define	read_int32(v, b, p)

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

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

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

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

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

static void	alignStringInfoInt (StringInfo buf)

static int32	reserveSpaceForItemPointer (StringInfo buf)

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

static int	operationPriority (JsonPathItemType op)

Datum	jsonpath_in (PG_FUNCTION_ARGS)

Datum	jsonpath_recv (PG_FUNCTION_ARGS)

Datum	jsonpath_out (PG_FUNCTION_ARGS)

Datum	jsonpath_send (PG_FUNCTION_ARGS)

const char *	jspOperationName (JsonPathItemType type)

void	jspInit (JsonPathItem v, JsonPath js)

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

void	jspGetArg (JsonPathItem v, JsonPathItem a)

bool	jspGetNext (JsonPathItem v, JsonPathItem a)

void	jspGetLeftArg (JsonPathItem v, JsonPathItem a)

void	jspGetRightArg (JsonPathItem v, JsonPathItem a)

bool	jspGetBool (JsonPathItem *v)

Numeric	jspGetNumeric (JsonPathItem *v)

char *	jspGetString (JsonPathItem v, int32 len)

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

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

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

Macro Definition Documentation

◆ read_byte

#define read_byte	(	v,
		b,
		p
	)

Value:

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

Definition at line 961 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 966 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 971 of file jsonpath.c.

Enumeration Type Documentation

◆ JsonPathDatatypeStatus

enum JsonPathDatatypeStatus

Enumerator
jpdsNonDateTime
jpdsUnknownDateTime
jpdsDateTimeZoned
jpdsDateTimeNonZoned

Definition at line 1254 of file jsonpath.c.

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

Function Documentation

◆ alignStringInfoInt()

static void alignStringInfoInt ( StringInfo buf )

static

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

 {
     /* position from beginning of jsonpath data */
     int32       pos = buf->len - JSONPATH_HDRSZ;
     int32       chld;
     int32       next;
     int         argNestingLevel = 0;
  
     check_stack_depth();
     CHECK_FOR_INTERRUPTS();
  
     appendStringInfoChar(buf, (char) (item->type));
  
     /*
      * We align buffer to int32 because a series of int32 values often goes
      * after the header, and we want to read them directly by dereferencing
      * int32 pointer (see jspInitByBuffer()).
      */
     alignStringInfoInt(buf);
  
     /*
      * Reserve space for next item pointer.  Actual value will be recorded
      * later, after next and children items processing.
      */
     next = reserveSpaceForItemPointer(buf);
  
     switch (item->type)
     {
         case jpiString:
         case jpiVariable:
         case jpiKey:
             appendBinaryStringInfo(buf, &item->value.string.len,
                                    sizeof(item->value.string.len));
             appendBinaryStringInfo(buf, item->value.string.val,
                                    item->value.string.len);
             appendStringInfoChar(buf, '\0');
             break;
         case jpiNumeric:
             appendBinaryStringInfo(buf, item->value.numeric,
                                    VARSIZE(item->value.numeric));
             break;
         case jpiBool:
             appendBinaryStringInfo(buf, &item->value.boolean,
                                    sizeof(item->value.boolean));
             break;
         case jpiAnd:
         case jpiOr:
         case jpiEqual:
         case jpiNotEqual:
         case jpiLess:
         case jpiGreater:
         case jpiLessOrEqual:
         case jpiGreaterOrEqual:
         case jpiAdd:
         case jpiSub:
         case jpiMul:
         case jpiDiv:
         case jpiMod:
         case jpiStartsWith:
         case jpiDecimal:
             {
                 /*
                  * 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:
         case jpiTime:
         case jpiTimeTz:
         case jpiTimestamp:
         case jpiTimestampTz:
             {
                 int32       arg = reserveSpaceForItemPointer(buf);
  
                 if (!item->value.arg)
                     chld = pos;
                 else if (!flattenJsonPathParseItem(buf, &chld, escontext,
                                                    item->value.arg,
                                                    nestingLevel + argNestingLevel,
                                                    insideArraySubscript))
                     return false;
                 *(int32 *) (buf->data + arg) = chld - pos;
             }
             break;
         case jpiNull:
             break;
         case jpiRoot:
             break;
         case jpiAnyArray:
         case jpiAnyKey:
             break;
         case jpiCurrent:
             if (nestingLevel <= 0)
                 ereturn(escontext, false,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("@ is not allowed in root expressions")));
             break;
         case jpiLast:
             if (!insideArraySubscript)
                 ereturn(escontext, false,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("LAST is allowed only in array subscripts")));
             break;
         case jpiIndexArray:
             {
                 int32       nelems = item->value.array.nelems;
                 int         offset;
                 int         i;
  
                 appendBinaryStringInfo(buf, &nelems, sizeof(nelems));
  
                 offset = buf->len;
  
                 appendStringInfoSpaces(buf, sizeof(int32) * 2 * nelems);
  
                 for (i = 0; i < nelems; i++)
                 {
                     int32      *ppos;
                     int32       topos;
                     int32       frompos;
  
                     if (!flattenJsonPathParseItem(buf, &frompos, escontext,
                                                   item->value.array.elems[i].from,
                                                   nestingLevel, true))
                         return false;
                     frompos -= pos;
  
                     if (item->value.array.elems[i].to)
                     {
                         if (!flattenJsonPathParseItem(buf, &topos, escontext,
                                                       item->value.array.elems[i].to,
                                                       nestingLevel, true))
                             return false;
                         topos -= pos;
                     }
                     else
                         topos = 0;
  
                     ppos = (int32 *) &buf->data[offset + i * 2 * sizeof(int32)];
  
                     ppos[0] = frompos;
                     ppos[1] = topos;
                 }
             }
             break;
         case jpiAny:
             appendBinaryStringInfo(buf,
                                    &item->value.anybounds.first,
                                    sizeof(item->value.anybounds.first));
             appendBinaryStringInfo(buf,
                                    &item->value.anybounds.last,
                                    sizeof(item->value.anybounds.last));
             break;
         case jpiType:
         case jpiSize:
         case jpiAbs:
         case jpiFloor:
         case jpiCeiling:
         case jpiDouble:
         case jpiKeyValue:
         case jpiBigint:
         case jpiBoolean:
         case jpiDate:
         case jpiInteger:
         case jpiNumber:
         case jpiStringFunc:
             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 98 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.

Referenced by makeJsonTablePathScan().

◆ jsonpath_out()

Datum jsonpath_out ( PG_FUNCTION_ARGS )

Definition at line 134 of file jsonpath.c.

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

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

◆ jsonpath_recv()

Datum jsonpath_recv ( PG_FUNCTION_ARGS )

Definition at line 115 of file jsonpath.c.

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

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

◆ jsonpath_send()

Datum jsonpath_send ( PG_FUNCTION_ARGS )

Definition at line 147 of file jsonpath.c.

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

References buf, 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 173 of file jsonpath.c.

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

References appendStringInfoSpaces(), buf, 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 213 of file jsonpath.c.

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

References appendStringInfoString(), buf, StringInfoData::data, enlargeStringInfo(), 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 1081 of file jsonpath.c.

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

References a, JsonPathItem::arg, Assert, JsonPathItem::base, JsonPathItem::content, jpiDatetime, jpiExists, jpiFilter, jpiIsUnknown, jpiMinus, jpiNot, jpiPlus, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, 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 1238 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 1210 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 1166 of file jsonpath.c.

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

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

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

◆ jspGetNext()

bool jspGetNext	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 1099 of file jsonpath.c.

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

References a, Assert, JsonPathItem::base, jpiAbs, jpiAdd, jpiAnd, jpiAny, jpiAnyArray, jpiAnyKey, jpiBigint, jpiBool, jpiBoolean, jpiCeiling, jpiCurrent, jpiDate, jpiDatetime, jpiDecimal, jpiDiv, jpiDouble, jpiEqual, jpiExists, jpiFilter, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiIndexArray, jpiInteger, jpiIsUnknown, jpiKey, jpiKeyValue, jpiLast, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumber, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiString, jpiStringFunc, jpiSub, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, 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 1218 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 executeDateTimeMethod(), executeItemOptUnwrapTarget(), getJsonPathItem(), and printJsonPathItem().

◆ jspGetRightArg()

void jspGetRightArg	(	JsonPathItem *	v,
		JsonPathItem *	a
	)

Definition at line 1188 of file jsonpath.c.

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

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

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

◆ jspGetString()

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

Definition at line 1226 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 980 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 990 of file jsonpath.c.

 {
     v->base = base + pos;
  
     read_byte(v->type, base, pos);
     pos = INTALIGN((uintptr_t) (base + pos)) - (uintptr_t) base;
     read_int32(v->nextPos, base, pos);
  
     switch (v->type)
     {
         case jpiNull:
         case jpiRoot:
         case jpiCurrent:
         case jpiAnyArray:
         case jpiAnyKey:
         case jpiType:
         case jpiSize:
         case jpiAbs:
         case jpiFloor:
         case jpiCeiling:
         case jpiDouble:
         case jpiKeyValue:
         case jpiLast:
         case jpiBigint:
         case jpiBoolean:
         case jpiDate:
         case jpiInteger:
         case jpiNumber:
         case jpiStringFunc:
             break;
         case jpiString:
         case jpiKey:
         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 jpiEqual:
         case jpiNotEqual:
         case jpiLess:
         case jpiGreater:
         case jpiLessOrEqual:
         case jpiGreaterOrEqual:
         case jpiAdd:
         case jpiSub:
         case jpiMul:
         case jpiDiv:
         case jpiMod:
         case jpiStartsWith:
         case jpiDecimal:
             read_int32(v->content.args.left, base, pos);
             read_int32(v->content.args.right, base, pos);
             break;
         case jpiNot:
         case jpiIsUnknown:
         case jpiExists:
         case jpiPlus:
         case jpiMinus:
         case jpiFilter:
         case jpiDatetime:
         case jpiTime:
         case jpiTimeTz:
         case jpiTimestamp:
         case jpiTimestampTz:
             read_int32(v->content.arg, base, pos);
             break;
         case jpiIndexArray:
             read_int32(v->content.array.nelems, base, pos);
             read_int32_n(v->content.array.elems, base, pos,
                          v->content.array.nelems * 2);
             break;
         case jpiAny:
             read_int32(v->content.anybounds.first, base, pos);
             read_int32(v->content.anybounds.last, base, pos);
             break;
         case jpiLikeRegex:
             read_int32(v->content.like_regex.flags, base, pos);
             read_int32(v->content.like_regex.expr, base, pos);
             read_int32(v->content.like_regex.patternlen, base, pos);
             v->content.like_regex.pattern = base + pos;
             break;
         default:
             elog(ERROR, "unrecognized jsonpath item type: %d", v->type);
     }
 }

References JsonPathItem::anybounds, JsonPathItem::arg, JsonPathItem::args, JsonPathItem::array, JsonPathItem::base, JsonPathItem::content, elog, ERROR, INTALIGN, jpiAbs, jpiAdd, jpiAnd, jpiAny, jpiAnyArray, jpiAnyKey, jpiBigint, jpiBool, jpiBoolean, jpiCeiling, jpiCurrent, jpiDate, jpiDatetime, jpiDecimal, jpiDiv, jpiDouble, jpiEqual, jpiExists, jpiFilter, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiIndexArray, jpiInteger, jpiIsUnknown, jpiKey, jpiKeyValue, jpiLast, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumber, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiString, jpiStringFunc, jpiSub, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, 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().

◆ jspIsMutable()

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

Definition at line 1280 of file jsonpath.c.

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

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

Referenced by contain_mutable_functions_walker().

◆ jspIsMutableWalker()

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

static

Definition at line 1280 of file jsonpath.c.

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

Referenced by jspIsMutable().

◆ jspOperationName()

const char* jspOperationName ( JsonPathItemType type )

Definition at line 843 of file jsonpath.c.

 {
     switch (type)
     {
         case jpiAnd:
             return "&&";
         case jpiOr:
             return "||";
         case jpiEqual:
             return "==";
         case jpiNotEqual:
             return "!=";
         case jpiLess:
             return "<";
         case jpiGreater:
             return ">";
         case jpiLessOrEqual:
             return "<=";
         case jpiGreaterOrEqual:
             return ">=";
         case jpiAdd:
         case jpiPlus:
             return "+";
         case jpiSub:
         case jpiMinus:
             return "-";
         case jpiMul:
             return "*";
         case jpiDiv:
             return "/";
         case jpiMod:
             return "%";
         case jpiType:
             return "type";
         case jpiSize:
             return "size";
         case jpiAbs:
             return "abs";
         case jpiFloor:
             return "floor";
         case jpiCeiling:
             return "ceiling";
         case jpiDouble:
             return "double";
         case jpiDatetime:
             return "datetime";
         case jpiKeyValue:
             return "keyvalue";
         case jpiStartsWith:
             return "starts with";
         case jpiLikeRegex:
             return "like_regex";
         case jpiBigint:
             return "bigint";
         case jpiBoolean:
             return "boolean";
         case jpiDate:
             return "date";
         case jpiDecimal:
             return "decimal";
         case jpiInteger:
             return "integer";
         case jpiNumber:
             return "number";
         case jpiStringFunc:
             return "string";
         case jpiTime:
             return "time";
         case jpiTimeTz:
             return "time_tz";
         case jpiTimestamp:
             return "timestamp";
         case jpiTimestampTz:
             return "timestamp_tz";
         default:
             elog(ERROR, "unrecognized jsonpath item type: %d", type);
             return NULL;
     }
 }

References elog, ERROR, jpiAbs, jpiAdd, jpiAnd, jpiBigint, jpiBoolean, jpiCeiling, jpiDate, jpiDatetime, jpiDecimal, jpiDiv, jpiDouble, jpiEqual, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiInteger, jpiKeyValue, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNotEqual, jpiNumber, jpiOr, jpiPlus, jpiSize, jpiStartsWith, jpiStringFunc, jpiSub, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, jpiType, and type.

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

◆ operationPriority()

static int operationPriority ( JsonPathItemType op )

static

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

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

References JsonPathItem::anybounds, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), JsonPathItem::arg, JsonPathItem::args, JsonPathItem::array, Assert, JsonPathItem::base, buf, CHECK_FOR_INTERRUPTS, check_stack_depth(), JsonPathItem::content, DatumGetCString(), DirectFunctionCall1, elog, ERROR, escape_json_with_len(), i, jpiAbs, jpiAdd, jpiAnd, jpiAny, jpiAnyArray, jpiAnyKey, jpiBigint, jpiBool, jpiBoolean, jpiCeiling, jpiCurrent, jpiDate, jpiDatetime, jpiDecimal, jpiDiv, jpiDouble, jpiEqual, jpiExists, jpiFilter, jpiFloor, jpiGreater, jpiGreaterOrEqual, jpiIndexArray, jpiInteger, jpiIsUnknown, jpiKey, jpiKeyValue, jpiLast, jpiLess, jpiLessOrEqual, jpiLikeRegex, jpiMinus, jpiMod, jpiMul, jpiNot, jpiNotEqual, jpiNull, jpiNumber, jpiNumeric, jpiOr, jpiPlus, jpiRoot, jpiSize, jpiStartsWith, jpiString, jpiStringFunc, jpiSub, jpiTime, jpiTimestamp, jpiTimestampTz, jpiTimeTz, jpiType, jpiVariable, JSP_REGEX_DOTALL, JSP_REGEX_ICASE, JSP_REGEX_MLINE, JSP_REGEX_QUOTE, JSP_REGEX_WSPACE, jspGetArg(), jspGetArraySubscript(), jspGetBool(), jspGetLeftArg(), jspGetNext(), jspGetNumeric(), jspGetRightArg(), jspGetString(), jspHasNext, jspInitByBuffer(), jspOperationName(), len, JsonPathItem::like_regex, numeric_out(), NumericGetDatum(), operationPriority(), PG_UINT32_MAX, range(), str, and JsonPathItem::type.

Referenced by jsonPathToCstring().

◆ reserveSpaceForItemPointer()

static int32 reserveSpaceForItemPointer ( StringInfo buf )

static

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

Data Structures

Macros

Enumerations

Functions

Macro Definition Documentation

◆ read_byte

◆ read_int32

◆ read_int32_n

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