/src/postgres/src/backend/utils/adt/jsonpath.c

Source (jump to first uncovered line)
/*-------------------------------------------------------------------------
 *
 * 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-2025, PostgreSQL Global Development Group
 *
 * IDENTIFICATION
 *  src/backend/utils/adt/jsonpath.c
 *
 *-------------------------------------------------------------------------
 */

#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"


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

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

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

/* Context for jspIsMutableWalker() */
struct JsonPathMutableContext
{
  List     *varnames;   /* list of variable names */
  List     *varexprs;   /* list of variable expressions */
  enum JsonPathDatatypeStatus current;  /* status of @ item */
  bool    lax;      /* jsonpath is lax or strict */
  bool    mutable;    /* resulting mutability status */
};

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

/*
 * Function to check whether jsonpath expression is mutable to be used in the
 * planner function contain_mutable_functions().
 */
bool
jspIsMutable(JsonPath *path, List *varnames, List *varexprs)
{
  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;
}

/*
 * Recursive walker for jspIsMutable()
 */
static enum JsonPathDatatypeStatus
jspIsMutableWalker(JsonPathItem *jpi, struct JsonPathMutableContext *cxt)
{
  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;
}

Coverage Report

Created: 2025-06-15 06:31