1
0
mirror of https://github.com/postgres/postgres.git synced 2025-06-08 22:02:03 +03:00
Andrew Dunstan 66ea94e8e6 Implement various jsonpath methods
This commit implements ithe jsonpath .bigint(), .boolean(),
.date(), .decimal([precision [, scale]]), .integer(), .number(),
.string(), .time(), .time_tz(), .timestamp(), and .timestamp_tz()
methods.

.bigint() converts the given JSON string or a numeric value to
the bigint type representation.

.boolean() converts the given JSON string, numeric, or boolean
value to the boolean type representation.  In the numeric case, only
integers are allowed. We use the parse_bool() backend function
to convert a string to a bool.

.decimal([precision [, scale]]) converts the given JSON string
or a numeric value to the numeric type representation.  If precision
and scale are provided for .decimal(), then it is converted to the
equivalent numeric typmod and applied to the numeric number.

.integer() and .number() convert the given JSON string or a
numeric value to the int4 and numeric type representation.

.string() uses the datatype's output function to convert numeric
and various date/time types to the string representation.

The JSON string representing a valid date/time is converted to the
specific date or time type representation using jsonpath .date(),
.time(), .time_tz(), .timestamp(), .timestamp_tz() methods.  The
changes use the infrastructure of the .datetime() method and perform
the datatype conversion as appropriate.  Unlike the .datetime()
method, none of these methods accept a format template and use ISO
DateTime format instead.  However, except for .date(), the
date/time related methods take an optional precision to adjust the
fractional seconds.

Jeevan Chalke, reviewed by Peter Eisentraut and Andrew Dunstan.
2024-01-25 10:15:43 -05:00

1243 lines
30 KiB
C

/*-------------------------------------------------------------------------
*
* jsonpath.c
* Input/output and supporting routines for jsonpath
*
* jsonpath expression is a chain of path items. First path item is $, $var,
* literal or arithmetic expression. Subsequent path items are accessors
* (.key, .*, [subscripts], [*]), filters (? (predicate)) and methods (.type(),
* .size() etc).
*
* For instance, structure of path items for simple expression:
*
* $.a[*].type()
*
* is pretty evident:
*
* $ => .a => [*] => .type()
*
* Some path items such as arithmetic operations, predicates or array
* subscripts may comprise subtrees. For instance, more complex expression
*
* ($.a + $[1 to 5, 7] ? (@ > 3).double()).type()
*
* have following structure of path items:
*
* + => .type()
* ___/ \___
* / \
* $ => .a $ => [] => ? => .double()
* _||_ |
* / \ >
* to to / \
* / \ / @ 3
* 1 5 7
*
* Binary encoding of jsonpath constitutes a sequence of 4-bytes aligned
* variable-length path items connected by links. Every item has a header
* consisting of item type (enum JsonPathItemType) and offset of next item
* (zero means no next item). After the header, item may have payload
* depending on item type. For instance, payload of '.key' accessor item is
* length of key name and key name itself. Payload of '>' arithmetic operator
* item is offsets of right and left operands.
*
* So, binary representation of sample expression above is:
* (bottom arrows are next links, top lines are argument links)
*
* _____
* _____ ___/____ \ __
* _ /_ \ _____/__/____ \ \ __ _ /_ \
* / / \ \ / / / \ \ \ / \ / / \ \
* +(LR) $ .a $ [](* to *, * to *) 1 5 7 ?(A) >(LR) @ 3 .double() .type()
* | | ^ | ^| ^| ^ ^
* | |__| |__||________________________||___________________| |
* |_______________________________________________________________________|
*
* Copyright (c) 2019-2024, PostgreSQL Global Development Group
*
* IDENTIFICATION
* src/backend/utils/adt/jsonpath.c
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "funcapi.h"
#include "lib/stringinfo.h"
#include "libpq/pqformat.h"
#include "nodes/miscnodes.h"
#include "miscadmin.h"
#include "utils/builtins.h"
#include "utils/json.h"
#include "utils/jsonpath.h"
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);
/**************************** INPUT/OUTPUT ********************************/
/*
* jsonpath type input function
*/
Datum
jsonpath_in(PG_FUNCTION_ARGS)
{
char *in = PG_GETARG_CSTRING(0);
int len = strlen(in);
return jsonPathFromCstring(in, len, fcinfo->context);
}
/*
* jsonpath type recv function
*
* The type is sent as text in binary mode, so this is almost the same
* as the input function, but it's prefixed with a version number so we
* can change the binary format sent in future if necessary. For now,
* only version 1 is supported.
*/
Datum
jsonpath_recv(PG_FUNCTION_ARGS)
{
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);
}
/*
* jsonpath type output function
*/
Datum
jsonpath_out(PG_FUNCTION_ARGS)
{
JsonPath *in = PG_GETARG_JSONPATH_P(0);
PG_RETURN_CSTRING(jsonPathToCstring(NULL, in, VARSIZE(in)));
}
/*
* jsonpath type send function
*
* Just send jsonpath as a version number, then a string of text
*/
Datum
jsonpath_send(PG_FUNCTION_ARGS)
{
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));
}
/*
* Converts C-string to a jsonpath value.
*
* Uses jsonpath parser to turn string into an AST, then
* flattenJsonPathParseItem() does second pass turning AST into binary
* representation of jsonpath.
*/
static Datum
jsonPathFromCstring(char *in, int len, struct Node *escontext)
{
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);
}
/*
* Converts jsonpath value to a C-string.
*
* If 'out' argument is non-null, the resulting C-string is stored inside the
* StringBuffer. The resulting string is always returned.
*/
static char *
jsonPathToCstring(StringInfo out, JsonPath *in, int estimated_len)
{
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;
}
/*
* Recursive function converting given jsonpath parse item and all its
* children into a binary representation.
*/
static bool
flattenJsonPathParseItem(StringInfo buf, int *result, struct Node *escontext,
JsonPathParseItem *item, int nestingLevel,
bool insideArraySubscript)
{
/* 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;
}
/*
* Align StringInfo to int by adding zero padding bytes
*/
static void
alignStringInfoInt(StringInfo buf)
{
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;
}
}
/*
* Reserve space for int32 JsonPathItem pointer. Now zero pointer is written,
* actual value will be recorded at '(int32 *) &buf->data[pos]' later.
*/
static int32
reserveSpaceForItemPointer(StringInfo buf)
{
int32 pos = buf->len;
int32 ptr = 0;
appendBinaryStringInfo(buf, &ptr, sizeof(ptr));
return pos;
}
/*
* Prints text representation of given jsonpath item and all its children.
*/
static void
printJsonPathItem(StringInfo buf, JsonPathItem *v, bool inKey,
bool printBracketes)
{
JsonPathItem elem;
int i;
check_stack_depth();
CHECK_FOR_INTERRUPTS();
switch (v->type)
{
case jpiNull:
appendStringInfoString(buf, "null");
break;
case jpiString:
escape_json(buf, jspGetString(v, NULL));
break;
case jpiNumeric:
if (jspHasNext(v))
appendStringInfoChar(buf, '(');
appendStringInfoString(buf,
DatumGetCString(DirectFunctionCall1(numeric_out,
NumericGetDatum(jspGetNumeric(v)))));
if (jspHasNext(v))
appendStringInfoChar(buf, ')');
break;
case jpiBool:
if (jspGetBool(v))
appendStringInfoString(buf, "true");
else
appendStringInfoString(buf, "false");
break;
case jpiAnd:
case jpiOr:
case jpiEqual:
case jpiNotEqual:
case jpiLess:
case jpiGreater:
case jpiLessOrEqual:
case jpiGreaterOrEqual:
case jpiAdd:
case jpiSub:
case jpiMul:
case jpiDiv:
case jpiMod:
case jpiStartsWith:
if (printBracketes)
appendStringInfoChar(buf, '(');
jspGetLeftArg(v, &elem);
printJsonPathItem(buf, &elem, false,
operationPriority(elem.type) <=
operationPriority(v->type));
appendStringInfoChar(buf, ' ');
appendStringInfoString(buf, jspOperationName(v->type));
appendStringInfoChar(buf, ' ');
jspGetRightArg(v, &elem);
printJsonPathItem(buf, &elem, false,
operationPriority(elem.type) <=
operationPriority(v->type));
if (printBracketes)
appendStringInfoChar(buf, ')');
break;
case 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, '.');
escape_json(buf, jspGetString(v, NULL));
break;
case jpiCurrent:
Assert(!inKey);
appendStringInfoChar(buf, '@');
break;
case jpiRoot:
Assert(!inKey);
appendStringInfoChar(buf, '$');
break;
case jpiVariable:
appendStringInfoChar(buf, '$');
escape_json(buf, jspGetString(v, NULL));
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(buf, v->content.like_regex.pattern);
if (v->content.like_regex.flags)
{
appendStringInfoString(buf, " flag \"");
if (v->content.like_regex.flags & JSP_REGEX_ICASE)
appendStringInfoChar(buf, 'i');
if (v->content.like_regex.flags & JSP_REGEX_DOTALL)
appendStringInfoChar(buf, 's');
if (v->content.like_regex.flags & JSP_REGEX_MLINE)
appendStringInfoChar(buf, 'm');
if (v->content.like_regex.flags & JSP_REGEX_WSPACE)
appendStringInfoChar(buf, 'x');
if (v->content.like_regex.flags & JSP_REGEX_QUOTE)
appendStringInfoChar(buf, 'q');
appendStringInfoChar(buf, '"');
}
if (printBracketes)
appendStringInfoChar(buf, ')');
break;
case 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);
}
const char *
jspOperationName(JsonPathItemType type)
{
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;
}
}
static int
operationPriority(JsonPathItemType op)
{
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;
}
}
/******************* Support functions for JsonPath *************************/
/*
* Support macros to read stored values
*/
#define read_byte(v, b, p) do { \
(v) = *(uint8*)((b) + (p)); \
(p) += 1; \
} while(0) \
#define read_int32(v, b, p) do { \
(v) = *(uint32*)((b) + (p)); \
(p) += sizeof(int32); \
} while(0) \
#define read_int32_n(v, b, p, n) do { \
(v) = (void *)((b) + (p)); \
(p) += sizeof(int32) * (n); \
} while(0) \
/*
* Read root node and fill root node representation
*/
void
jspInit(JsonPathItem *v, JsonPath *js)
{
Assert((js->header & ~JSONPATH_LAX) == JSONPATH_VERSION);
jspInitByBuffer(v, js->data, 0);
}
/*
* Read node from buffer and fill its representation
*/
void
jspInitByBuffer(JsonPathItem *v, char *base, int32 pos)
{
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);
}
}
void
jspGetArg(JsonPathItem *v, JsonPathItem *a)
{
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);
}
bool
jspGetNext(JsonPathItem *v, JsonPathItem *a)
{
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;
}
void
jspGetLeftArg(JsonPathItem *v, JsonPathItem *a)
{
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);
}
void
jspGetRightArg(JsonPathItem *v, JsonPathItem *a)
{
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);
}
bool
jspGetBool(JsonPathItem *v)
{
Assert(v->type == jpiBool);
return (bool) *v->content.value.data;
}
Numeric
jspGetNumeric(JsonPathItem *v)
{
Assert(v->type == jpiNumeric);
return (Numeric) v->content.value.data;
}
char *
jspGetString(JsonPathItem *v, int32 *len)
{
Assert(v->type == jpiKey ||
v->type == jpiString ||
v->type == jpiVariable);
if (len)
*len = v->content.value.datalen;
return v->content.value.data;
}
bool
jspGetArraySubscript(JsonPathItem *v, JsonPathItem *from, JsonPathItem *to,
int i)
{
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;
}