/*-------------------------------------------------------------------------

 *

 * jsonpath_exec.c

 *   Routines for SQL/JSON path execution.

 *

 * Jsonpath is executed in the global context stored in JsonPathExecContext,

 * which is passed to almost every function involved into execution.  Entry

 * point for jsonpath execution is executeJsonPath() function, which

 * initializes execution context including initial JsonPathItem and JsonbValue,

 * flags, stack for calculation of @ in filters.

 *

 * The result of jsonpath query execution is enum JsonPathExecResult and

 * if succeeded sequence of JsonbValue, written to JsonValueList *found, which

 * is passed through the jsonpath items.  When found == NULL, we're inside

 * exists-query and we're interested only in whether result is empty.  In this

 * case execution is stopped once first result item is found, and the only

 * execution result is JsonPathExecResult.  The values of JsonPathExecResult

 * are following:

 * - jperOk     -- result sequence is not empty

 * - jperNotFound -- result sequence is empty

 * - jperError    -- error occurred during execution

 *

 * Jsonpath is executed recursively (see executeItem()) starting form the

 * first path item (which in turn might be, for instance, an arithmetic

 * expression evaluated separately).  On each step single JsonbValue obtained

 * from previous path item is processed.  The result of processing is a

 * sequence of JsonbValue (probably empty), which is passed to the next path

 * item one by one.  When there is no next path item, then JsonbValue is added

 * to the 'found' list.  When found == NULL, then execution functions just

 * return jperOk (see executeNextItem()).

 *

 * Many of jsonpath operations require automatic unwrapping of arrays in lax

 * mode.  So, if input value is array, then corresponding operation is

 * processed not on array itself, but on all of its members one by one.

 * executeItemOptUnwrapTarget() function have 'unwrap' argument, which indicates

 * whether unwrapping of array is needed.  When unwrap == true, each of array

 * members is passed to executeItemOptUnwrapTarget() again but with unwrap == false

 * in order to avoid subsequent array unwrapping.

 *

 * All boolean expressions (predicates) are evaluated by executeBoolItem()

 * function, which returns tri-state JsonPathBool.  When error is occurred

 * during predicate execution, it returns jpbUnknown.  According to standard

 * predicates can be only inside filters.  But we support their usage as

 * jsonpath expression.  This helps us to implement @@ operator.  In this case

 * resulting JsonPathBool is transformed into jsonb bool or null.

 *

 * Arithmetic and boolean expression are evaluated recursively from expression

 * tree top down to the leaves.  Therefore, for binary arithmetic expressions

 * we calculate operands first.  Then we check that results are numeric

 * singleton lists, calculate the result and pass it to the next path item.

 *

 * Copyright (c) 2019-2025, PostgreSQL Global Development Group

 *

 * IDENTIFICATION

 *  src/backend/utils/adt/jsonpath_exec.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "catalog/pg_collation.h"

#include "catalog/pg_type.h"

#include "funcapi.h"

#include "miscadmin.h"

#include "nodes/miscnodes.h"

#include "nodes/nodeFuncs.h"

#include "regex/regex.h"

#include "utils/builtins.h"

#include "utils/date.h"

#include "utils/datetime.h"

#include "utils/float.h"

#include "utils/formatting.h"

#include "utils/json.h"

#include "utils/jsonpath.h"

#include "utils/memutils.h"

#include "utils/timestamp.h"

/*

 * Represents "base object" and its "id" for .keyvalue() evaluation.

 */

typedef struct JsonBaseObjectInfo

{

  JsonbContainer *jbc;

  int     id;

} JsonBaseObjectInfo;

/* Callbacks for executeJsonPath() */

typedef JsonbValue *(*JsonPathGetVarCallback) (void *vars, char *varName, int varNameLen,

                         JsonbValue *baseObject, int *baseObjectId);

typedef int (*JsonPathCountVarsCallback) (void *vars);

/*

 * Context of jsonpath execution.

 */

typedef struct JsonPathExecContext

{

  void     *vars;     /* variables to substitute into jsonpath */

  JsonPathGetVarCallback getVar;  /* callback to extract a given variable

                   * from 'vars' */

  JsonbValue *root;     /* for $ evaluation */

  JsonbValue *current;    /* for @ evaluation */

  JsonBaseObjectInfo baseObject;  /* "base object" for .keyvalue()

                   * evaluation */

  int     lastGeneratedObjectId;  /* "id" counter for .keyvalue()

                     * evaluation */

  int     innermostArraySize; /* for LAST array index evaluation */

  bool    laxMode;    /* true for "lax" mode, false for "strict"

                 * mode */

  bool    ignoreStructuralErrors; /* with "true" structural errors such

                     * as absence of required json item or

                     * unexpected json item type are

                     * ignored */

  bool    throwErrors;  /* with "false" all suppressible errors are

                 * suppressed */

  bool    useTz;

} JsonPathExecContext;

/* Context for LIKE_REGEX execution. */

typedef struct JsonLikeRegexContext

{

  text     *regex;

  int     cflags;

} JsonLikeRegexContext;

/* Result of jsonpath predicate evaluation */

typedef enum JsonPathBool

{

  jpbFalse = 0,

  jpbTrue = 1,

  jpbUnknown = 2

} JsonPathBool;

/* Result of jsonpath expression evaluation */

typedef enum JsonPathExecResult

{

  jperOk = 0,

  jperNotFound = 1,

  jperError = 2

} JsonPathExecResult;

#define jperIsError(jper)     ((jper) == jperError)

/*

 * List of jsonb values with shortcut for single-value list.

 */

typedef struct JsonValueList

{

  JsonbValue *singleton;

  List     *list;

} JsonValueList;

typedef struct JsonValueListIterator

{

  JsonbValue *value;

  List     *list;

  ListCell   *next;

} JsonValueListIterator;

/* Structures for JSON_TABLE execution  */

/*

 * Struct holding the result of jsonpath evaluation, to be used as source row

 * for JsonTableGetValue() which in turn computes the values of individual

 * JSON_TABLE columns.

 */

typedef struct JsonTablePlanRowSource

{

  Datum   value;

  bool    isnull;

} JsonTablePlanRowSource;

/*

 * State of evaluation of row pattern derived by applying jsonpath given in

 * a JsonTablePlan to an input document given in the parent TableFunc.

 */

typedef struct JsonTablePlanState

{

  /* Original plan */

  JsonTablePlan *plan;

  /* The following fields are only valid for JsonTablePathScan plans */

  /* jsonpath to evaluate against the input doc to get the row pattern */

  JsonPath   *path;

  /*

   * Memory context to use when evaluating the row pattern from the jsonpath

   */

  MemoryContext mcxt;

  /* PASSING arguments passed to jsonpath executor */

  List     *args;

  /* List and iterator of jsonpath result values */

  JsonValueList found;

  JsonValueListIterator iter;

  /* Currently selected row for JsonTableGetValue() to use */

  JsonTablePlanRowSource current;

  /* Counter for ORDINAL columns */

  int     ordinal;

  /* Nested plan, if any */

  struct JsonTablePlanState *nested;

  /* Left sibling, if any */

  struct JsonTablePlanState *left;

  /* Right sibling, if any */

  struct JsonTablePlanState *right;

  /* Parent plan, if this is a nested plan */

  struct JsonTablePlanState *parent;

} JsonTablePlanState;

/* Random number to identify JsonTableExecContext for sanity checking */

#define JSON_TABLE_EXEC_CONTEXT_MAGIC   418352867

typedef struct JsonTableExecContext

{

  int     magic;

  /* State of the plan providing a row evaluated from "root" jsonpath */

  JsonTablePlanState *rootplanstate;

  /*

   * Per-column JsonTablePlanStates for all columns including the nested

   * ones.

   */

  JsonTablePlanState **colplanstates;

} JsonTableExecContext;

/* strict/lax flags is decomposed into four [un]wrap/error flags */

#define jspStrictAbsenceOfErrors(cxt) (!(cxt)->laxMode)

#define jspAutoUnwrap(cxt)        ((cxt)->laxMode)

#define jspAutoWrap(cxt)        ((cxt)->laxMode)

#define jspIgnoreStructuralErrors(cxt)  ((cxt)->ignoreStructuralErrors)

#define jspThrowErrors(cxt)       ((cxt)->throwErrors)

/* Convenience macro: return or throw error depending on context */

#define RETURN_ERROR(throw_error) \

do { \

  if (jspThrowErrors(cxt)) \

    throw_error; \

  else \

    return jperError; \

} while (0)

typedef JsonPathBool (*JsonPathPredicateCallback) (JsonPathItem *jsp,

                           JsonbValue *larg,

                           JsonbValue *rarg,

                           void *param);

typedef Numeric (*BinaryArithmFunc) (Numeric num1, Numeric num2, bool *error);

static JsonPathExecResult executeJsonPath(JsonPath *path, void *vars,

                      JsonPathGetVarCallback getVar,

                      JsonPathCountVarsCallback countVars,

                      Jsonb *json, bool throwErrors,

                      JsonValueList *result, bool useTz);

static JsonPathExecResult executeItem(JsonPathExecContext *cxt,

                    JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found);

static JsonPathExecResult executeItemOptUnwrapTarget(JsonPathExecContext *cxt,

                           JsonPathItem *jsp, JsonbValue *jb,

                           JsonValueList *found, bool unwrap);

static JsonPathExecResult executeItemUnwrapTargetArray(JsonPathExecContext *cxt,

                             JsonPathItem *jsp, JsonbValue *jb,

                             JsonValueList *found, bool unwrapElements);

static JsonPathExecResult executeNextItem(JsonPathExecContext *cxt,

                      JsonPathItem *cur, JsonPathItem *next,

                      JsonbValue *v, JsonValueList *found, bool copy);

static JsonPathExecResult executeItemOptUnwrapResult(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb,

                           bool unwrap, JsonValueList *found);

static JsonPathExecResult executeItemOptUnwrapResultNoThrow(JsonPathExecContext *cxt, JsonPathItem *jsp,

                              JsonbValue *jb, bool unwrap, JsonValueList *found);

static JsonPathBool executeBoolItem(JsonPathExecContext *cxt,

                  JsonPathItem *jsp, JsonbValue *jb, bool canHaveNext);

static JsonPathBool executeNestedBoolItem(JsonPathExecContext *cxt,

                      JsonPathItem *jsp, JsonbValue *jb);

static JsonPathExecResult executeAnyItem(JsonPathExecContext *cxt,

                     JsonPathItem *jsp, JsonbContainer *jbc, JsonValueList *found,

                     uint32 level, uint32 first, uint32 last,

                     bool ignoreStructuralErrors, bool unwrapNext);

static JsonPathBool executePredicate(JsonPathExecContext *cxt,

                   JsonPathItem *pred, JsonPathItem *larg, JsonPathItem *rarg,

                   JsonbValue *jb, bool unwrapRightArg,

                   JsonPathPredicateCallback exec, void *param);

static JsonPathExecResult executeBinaryArithmExpr(JsonPathExecContext *cxt,

                          JsonPathItem *jsp, JsonbValue *jb,

                          BinaryArithmFunc func, JsonValueList *found);

static JsonPathExecResult executeUnaryArithmExpr(JsonPathExecContext *cxt,

                         JsonPathItem *jsp, JsonbValue *jb, PGFunction func,

                         JsonValueList *found);

static JsonPathBool executeStartsWith(JsonPathItem *jsp,

                    JsonbValue *whole, JsonbValue *initial, void *param);

static JsonPathBool executeLikeRegex(JsonPathItem *jsp, JsonbValue *str,

                   JsonbValue *rarg, void *param);

static JsonPathExecResult executeNumericItemMethod(JsonPathExecContext *cxt,

                           JsonPathItem *jsp, JsonbValue *jb, bool unwrap, PGFunction func,

                           JsonValueList *found);

static JsonPathExecResult executeDateTimeMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,

                        JsonbValue *jb, JsonValueList *found);

static JsonPathExecResult executeKeyValueMethod(JsonPathExecContext *cxt,

                        JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found);

static JsonPathExecResult appendBoolResult(JsonPathExecContext *cxt,

                       JsonPathItem *jsp, JsonValueList *found, JsonPathBool res);

static void getJsonPathItem(JsonPathExecContext *cxt, JsonPathItem *item,

              JsonbValue *value);

static JsonbValue *GetJsonPathVar(void *cxt, char *varName, int varNameLen,

                  JsonbValue *baseObject, int *baseObjectId);

static int  CountJsonPathVars(void *cxt);

static void JsonItemFromDatum(Datum val, Oid typid, int32 typmod,

                JsonbValue *res);

static void JsonbValueInitNumericDatum(JsonbValue *jbv, Datum num);

static void getJsonPathVariable(JsonPathExecContext *cxt,

                JsonPathItem *variable, JsonbValue *value);

static int  countVariablesFromJsonb(void *varsJsonb);

static JsonbValue *getJsonPathVariableFromJsonb(void *varsJsonb, char *varName,

                        int varNameLength,

                        JsonbValue *baseObject,

                        int *baseObjectId);

static int  JsonbArraySize(JsonbValue *jb);

static JsonPathBool executeComparison(JsonPathItem *cmp, JsonbValue *lv,

                    JsonbValue *rv, void *p);

static JsonPathBool compareItems(int32 op, JsonbValue *jb1, JsonbValue *jb2,

                 bool useTz);

static int  compareNumeric(Numeric a, Numeric b);

static JsonbValue *copyJsonbValue(JsonbValue *src);

static JsonPathExecResult getArrayIndex(JsonPathExecContext *cxt,

                    JsonPathItem *jsp, JsonbValue *jb, int32 *index);

static JsonBaseObjectInfo setBaseObject(JsonPathExecContext *cxt,

                    JsonbValue *jbv, int32 id);

static void JsonValueListClear(JsonValueList *jvl);

static void JsonValueListAppend(JsonValueList *jvl, JsonbValue *jbv);

static int  JsonValueListLength(const JsonValueList *jvl);

static bool JsonValueListIsEmpty(JsonValueList *jvl);

static JsonbValue *JsonValueListHead(JsonValueList *jvl);

static List *JsonValueListGetList(JsonValueList *jvl);

static void JsonValueListInitIterator(const JsonValueList *jvl,

                    JsonValueListIterator *it);

static JsonbValue *JsonValueListNext(const JsonValueList *jvl,

                   JsonValueListIterator *it);

static JsonbValue *JsonbInitBinary(JsonbValue *jbv, Jsonb *jb);

static int  JsonbType(JsonbValue *jb);

static JsonbValue *getScalar(JsonbValue *scalar, enum jbvType type);

static JsonbValue *wrapItemsInArray(const JsonValueList *items);

static int  compareDatetime(Datum val1, Oid typid1, Datum val2, Oid typid2,

              bool useTz, bool *cast_error);

static void checkTimezoneIsUsedForCast(bool useTz, const char *type1,

                     const char *type2);

static void JsonTableInitOpaque(TableFuncScanState *state, int natts);

static JsonTablePlanState *JsonTableInitPlan(JsonTableExecContext *cxt,

                       JsonTablePlan *plan,

                       JsonTablePlanState *parentstate,

                       List *args,

                       MemoryContext mcxt);

static void JsonTableSetDocument(TableFuncScanState *state, Datum value);

static void JsonTableResetRowPattern(JsonTablePlanState *planstate, Datum item);

static bool JsonTableFetchRow(TableFuncScanState *state);

static Datum JsonTableGetValue(TableFuncScanState *state, int colnum,

                 Oid typid, int32 typmod, bool *isnull);

static void JsonTableDestroyOpaque(TableFuncScanState *state);

static bool JsonTablePlanScanNextRow(JsonTablePlanState *planstate);

static void JsonTableResetNestedPlan(JsonTablePlanState *planstate);

static bool JsonTablePlanJoinNextRow(JsonTablePlanState *planstate);

static bool JsonTablePlanNextRow(JsonTablePlanState *planstate);

const TableFuncRoutine JsonbTableRoutine =

{

  .InitOpaque = JsonTableInitOpaque,

  .SetDocument = JsonTableSetDocument,

  .SetNamespace = NULL,

  .SetRowFilter = NULL,

  .SetColumnFilter = NULL,

  .FetchRow = JsonTableFetchRow,

  .GetValue = JsonTableGetValue,

  .DestroyOpaque = JsonTableDestroyOpaque

};

/****************** User interface to JsonPath executor ********************/

/*

 * jsonb_path_exists

 *    Returns true if jsonpath returns at least one item for the specified

 *    jsonb value.  This function and jsonb_path_match() are used to

 *    implement @? and @@ operators, which in turn are intended to have an

 *    index support.  Thus, it's desirable to make it easier to achieve

 *    consistency between index scan results and sequential scan results.

 *    So, we throw as few errors as possible.  Regarding this function,

 *    such behavior also matches behavior of JSON_EXISTS() clause of

 *    SQL/JSON.  Regarding jsonb_path_match(), this function doesn't have

 *    an analogy in SQL/JSON, so we define its behavior on our own.

 */

static Datum

jsonb_path_exists_internal(FunctionCallInfo fcinfo, bool tz)

{

  Jsonb    *jb = PG_GETARG_JSONB_P(0);

  JsonPath   *jp = PG_GETARG_JSONPATH_P(1);

  JsonPathExecResult res;

  Jsonb    *vars = NULL;

  bool    silent = true;

  if (PG_NARGS() == 4)

  {

    vars = PG_GETARG_JSONB_P(2);

    silent = PG_GETARG_BOOL(3);

  }

  res = executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,

              countVariablesFromJsonb,

              jb, !silent, NULL, tz);

  PG_FREE_IF_COPY(jb, 0);

  PG_FREE_IF_COPY(jp, 1);

  if (jperIsError(res))

    PG_RETURN_NULL();

  PG_RETURN_BOOL(res == jperOk);

}

Datum

jsonb_path_exists(PG_FUNCTION_ARGS)

{

  return jsonb_path_exists_internal(fcinfo, false);

}

Datum

jsonb_path_exists_tz(PG_FUNCTION_ARGS)

{

  return jsonb_path_exists_internal(fcinfo, true);

}

/*

 * jsonb_path_exists_opr

 *    Implementation of operator "jsonb @? jsonpath" (2-argument version of

 *    jsonb_path_exists()).

 */

Datum

jsonb_path_exists_opr(PG_FUNCTION_ARGS)

{

  /* just call the other one -- it can handle both cases */

  return jsonb_path_exists_internal(fcinfo, false);

}

/*

 * jsonb_path_match

 *    Returns jsonpath predicate result item for the specified jsonb value.

 *    See jsonb_path_exists() comment for details regarding error handling.

 */

static Datum

jsonb_path_match_internal(FunctionCallInfo fcinfo, bool tz)

{

  Jsonb    *jb = PG_GETARG_JSONB_P(0);

  JsonPath   *jp = PG_GETARG_JSONPATH_P(1);

  JsonValueList found = {0};

  Jsonb    *vars = NULL;

  bool    silent = true;

  if (PG_NARGS() == 4)

  {

    vars = PG_GETARG_JSONB_P(2);

    silent = PG_GETARG_BOOL(3);

  }

  (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,

               countVariablesFromJsonb,

               jb, !silent, &found, tz);

  PG_FREE_IF_COPY(jb, 0);

  PG_FREE_IF_COPY(jp, 1);

  if (JsonValueListLength(&found) == 1)

  {

    JsonbValue *jbv = JsonValueListHead(&found);

    if (jbv->type == jbvBool)

      PG_RETURN_BOOL(jbv->val.boolean);

    if (jbv->type == jbvNull)

      PG_RETURN_NULL();

  }

  if (!silent)

    ereport(ERROR,

        (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),

         errmsg("single boolean result is expected")));

  PG_RETURN_NULL();

}

Datum

jsonb_path_match(PG_FUNCTION_ARGS)

{

  return jsonb_path_match_internal(fcinfo, false);

}

Datum

jsonb_path_match_tz(PG_FUNCTION_ARGS)

{

  return jsonb_path_match_internal(fcinfo, true);

}

/*

 * jsonb_path_match_opr

 *    Implementation of operator "jsonb @@ jsonpath" (2-argument version of

 *    jsonb_path_match()).

 */

Datum

jsonb_path_match_opr(PG_FUNCTION_ARGS)

{

  /* just call the other one -- it can handle both cases */

  return jsonb_path_match_internal(fcinfo, false);

}

/*

 * jsonb_path_query

 *    Executes jsonpath for given jsonb document and returns result as

 *    rowset.

 */

static Datum

jsonb_path_query_internal(FunctionCallInfo fcinfo, bool tz)

{

  FuncCallContext *funcctx;

  List     *found;

  JsonbValue *v;

  ListCell   *c;

  if (SRF_IS_FIRSTCALL())

  {

    JsonPath   *jp;

    Jsonb    *jb;

    MemoryContext oldcontext;

    Jsonb    *vars;

    bool    silent;

    JsonValueList found = {0};

    funcctx = SRF_FIRSTCALL_INIT();

    oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

    jb = PG_GETARG_JSONB_P_COPY(0);

    jp = PG_GETARG_JSONPATH_P_COPY(1);

    vars = PG_GETARG_JSONB_P_COPY(2);

    silent = PG_GETARG_BOOL(3);

    (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,

                 countVariablesFromJsonb,

                 jb, !silent, &found, tz);

    funcctx->user_fctx = JsonValueListGetList(&found);

    MemoryContextSwitchTo(oldcontext);

  }

  funcctx = SRF_PERCALL_SETUP();

  found = funcctx->user_fctx;

  c = list_head(found);

  if (c == NULL)

    SRF_RETURN_DONE(funcctx);

  v = lfirst(c);

  funcctx->user_fctx = list_delete_first(found);

  SRF_RETURN_NEXT(funcctx, JsonbPGetDatum(JsonbValueToJsonb(v)));

}

Datum

jsonb_path_query(PG_FUNCTION_ARGS)

{

  return jsonb_path_query_internal(fcinfo, false);

}

Datum

jsonb_path_query_tz(PG_FUNCTION_ARGS)

{

  return jsonb_path_query_internal(fcinfo, true);

}

/*

 * jsonb_path_query_array

 *    Executes jsonpath for given jsonb document and returns result as

 *    jsonb array.

 */

static Datum

jsonb_path_query_array_internal(FunctionCallInfo fcinfo, bool tz)

{

  Jsonb    *jb = PG_GETARG_JSONB_P(0);

  JsonPath   *jp = PG_GETARG_JSONPATH_P(1);

  JsonValueList found = {0};

  Jsonb    *vars = PG_GETARG_JSONB_P(2);

  bool    silent = PG_GETARG_BOOL(3);

  (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,

               countVariablesFromJsonb,

               jb, !silent, &found, tz);

  PG_RETURN_JSONB_P(JsonbValueToJsonb(wrapItemsInArray(&found)));

}

Datum

jsonb_path_query_array(PG_FUNCTION_ARGS)

{

  return jsonb_path_query_array_internal(fcinfo, false);

}

Datum

jsonb_path_query_array_tz(PG_FUNCTION_ARGS)

{

  return jsonb_path_query_array_internal(fcinfo, true);

}

/*

 * jsonb_path_query_first

 *    Executes jsonpath for given jsonb document and returns first result

 *    item.  If there are no items, NULL returned.

 */

static Datum

jsonb_path_query_first_internal(FunctionCallInfo fcinfo, bool tz)

{

  Jsonb    *jb = PG_GETARG_JSONB_P(0);

  JsonPath   *jp = PG_GETARG_JSONPATH_P(1);

  JsonValueList found = {0};

  Jsonb    *vars = PG_GETARG_JSONB_P(2);

  bool    silent = PG_GETARG_BOOL(3);

  (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,

               countVariablesFromJsonb,

               jb, !silent, &found, tz);

  if (JsonValueListLength(&found) >= 1)

    PG_RETURN_JSONB_P(JsonbValueToJsonb(JsonValueListHead(&found)));

  else

    PG_RETURN_NULL();

}

Datum

jsonb_path_query_first(PG_FUNCTION_ARGS)

{

  return jsonb_path_query_first_internal(fcinfo, false);

}

Datum

jsonb_path_query_first_tz(PG_FUNCTION_ARGS)

{

  return jsonb_path_query_first_internal(fcinfo, true);

}

/********************Execute functions for JsonPath**************************/

/*

 * Interface to jsonpath executor

 *

 * 'path' - jsonpath to be executed

 * 'vars' - variables to be substituted to jsonpath

 * 'getVar' - callback used by getJsonPathVariable() to extract variables from

 *    'vars'

 * 'countVars' - callback to count the number of jsonpath variables in 'vars'

 * 'json' - target document for jsonpath evaluation

 * 'throwErrors' - whether we should throw suppressible errors

 * 'result' - list to store result items into

 *

 * Returns an error if a recoverable error happens during processing, or NULL

 * on no error.

 *

 * Note, jsonb and jsonpath values should be available and untoasted during

 * work because JsonPathItem, JsonbValue and result item could have pointers

 * into input values.  If caller needs to just check if document matches

 * jsonpath, then it doesn't provide a result arg.  In this case executor

 * works till first positive result and does not check the rest if possible.

 * In other case it tries to find all the satisfied result items.

 */

static JsonPathExecResult

executeJsonPath(JsonPath *path, void *vars, JsonPathGetVarCallback getVar,

        JsonPathCountVarsCallback countVars,

        Jsonb *json, bool throwErrors, JsonValueList *result,

        bool useTz)

{

  JsonPathExecContext cxt;

  JsonPathExecResult res;

  JsonPathItem jsp;

  JsonbValue  jbv;

  jspInit(&jsp, path);

  if (!JsonbExtractScalar(&json->root, &jbv))

    JsonbInitBinary(&jbv, json);

  cxt.vars = vars;

  cxt.getVar = getVar;

  cxt.laxMode = (path->header & JSONPATH_LAX) != 0;

  cxt.ignoreStructuralErrors = cxt.laxMode;

  cxt.root = &jbv;

  cxt.current = &jbv;

  cxt.baseObject.jbc = NULL;

  cxt.baseObject.id = 0;

  /* 1 + number of base objects in vars */

  cxt.lastGeneratedObjectId = 1 + countVars(vars);

  cxt.innermostArraySize = -1;

  cxt.throwErrors = throwErrors;

  cxt.useTz = useTz;

  if (jspStrictAbsenceOfErrors(&cxt) && !result)

  {

    /*

     * In strict mode we must get a complete list of values to check that

     * there are no errors at all.

     */

    JsonValueList vals = {0};

    res = executeItem(&cxt, &jsp, &jbv, &vals);

    if (jperIsError(res))

      return res;

    return JsonValueListIsEmpty(&vals) ? jperNotFound : jperOk;

  }

  res = executeItem(&cxt, &jsp, &jbv, result);

  Assert(!throwErrors || !jperIsError(res));

  return res;

}

/*

 * Execute jsonpath with automatic unwrapping of current item in lax mode.

 */

static JsonPathExecResult

executeItem(JsonPathExecContext *cxt, JsonPathItem *jsp,

      JsonbValue *jb, JsonValueList *found)

{

  return executeItemOptUnwrapTarget(cxt, jsp, jb, found, jspAutoUnwrap(cxt));

}

/*

 * Main jsonpath executor function: walks on jsonpath structure, finds

 * relevant parts of jsonb and evaluates expressions over them.

 * When 'unwrap' is true current SQL/JSON item is unwrapped if it is an array.

 */

static JsonPathExecResult

executeItemOptUnwrapTarget(JsonPathExecContext *cxt, JsonPathItem *jsp,

               JsonbValue *jb, JsonValueList *found, bool unwrap)

{

  JsonPathItem elem;

  JsonPathExecResult res = jperNotFound;

  JsonBaseObjectInfo baseObject;

  check_stack_depth();

  CHECK_FOR_INTERRUPTS();

  switch (jsp->type)

  {

    case jpiNull:

    case jpiBool:

    case jpiNumeric:

    case jpiString:

    case jpiVariable:

      {

        JsonbValue  vbuf;

        JsonbValue *v;

        bool    hasNext = jspGetNext(jsp, &elem);

        if (!hasNext && !found && jsp->type != jpiVariable)

        {

          /*

           * Skip evaluation, but not for variables.  We must

           * trigger an error for the missing variable.

           */

          res = jperOk;

          break;

        }

        v = hasNext ? &vbuf : palloc(sizeof(*v));

        baseObject = cxt->baseObject;

        getJsonPathItem(cxt, jsp, v);

        res = executeNextItem(cxt, jsp, &elem,

                    v, found, hasNext);

        cxt->baseObject = baseObject;

      }

      break;

      /* all boolean item types: */

    case jpiAnd:

    case jpiOr:

    case jpiNot:

    case jpiIsUnknown:

    case jpiEqual:

    case jpiNotEqual:

    case jpiLess:

    case jpiGreater:

    case jpiLessOrEqual:

    case jpiGreaterOrEqual:

    case jpiExists:

    case jpiStartsWith:

    case jpiLikeRegex:

      {

        JsonPathBool st = executeBoolItem(cxt, jsp, jb, true);

        res = appendBoolResult(cxt, jsp, found, st);

        break;

      }

    case jpiAdd:

      return executeBinaryArithmExpr(cxt, jsp, jb,

                       numeric_add_opt_error, found);

    case jpiSub:

      return executeBinaryArithmExpr(cxt, jsp, jb,

                       numeric_sub_opt_error, found);

    case jpiMul:

      return executeBinaryArithmExpr(cxt, jsp, jb,

                       numeric_mul_opt_error, found);

    case jpiDiv:

      return executeBinaryArithmExpr(cxt, jsp, jb,

                       numeric_div_opt_error, found);

    case jpiMod:

      return executeBinaryArithmExpr(cxt, jsp, jb,

                       numeric_mod_opt_error, found);

    case jpiPlus:

      return executeUnaryArithmExpr(cxt, jsp, jb, NULL, found);

    case jpiMinus:

      return executeUnaryArithmExpr(cxt, jsp, jb, numeric_uminus,

                      found);

    case jpiAnyArray:

      if (JsonbType(jb) == jbvArray)

      {

        bool    hasNext = jspGetNext(jsp, &elem);

        res = executeItemUnwrapTargetArray(cxt, hasNext ? &elem : NULL,

                           jb, found, jspAutoUnwrap(cxt));

      }

      else if (jspAutoWrap(cxt))

        res = executeNextItem(cxt, jsp, NULL, jb, found, true);

      else if (!jspIgnoreStructuralErrors(cxt))

        RETURN_ERROR(ereport(ERROR,

                   (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),

                    errmsg("jsonpath wildcard array accessor can only be applied to an array"))));

      break;

    case jpiAnyKey:

      if (JsonbType(jb) == jbvObject)

      {

        bool    hasNext = jspGetNext(jsp, &elem);

        if (jb->type != jbvBinary)

          elog(ERROR, "invalid jsonb object type: %d", jb->type);

        return executeAnyItem

          (cxt, hasNext ? &elem : NULL,

           jb->val.binary.data, found, 1, 1, 1,

           false, jspAutoUnwrap(cxt));

      }

      else if (unwrap && JsonbType(jb) == jbvArray)

        return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);

      else if (!jspIgnoreStructuralErrors(cxt))

      {

        Assert(found);

        RETURN_ERROR(ereport(ERROR,

                   (errcode(ERRCODE_SQL_JSON_OBJECT_NOT_FOUND),

                    errmsg("jsonpath wildcard member accessor can only be applied to an object"))));

      }

      break;

    case jpiIndexArray:

      if (JsonbType(jb) == jbvArray || jspAutoWrap(cxt))

      {

        int     innermostArraySize = cxt->innermostArraySize;

        int     i;

        int     size = JsonbArraySize(jb);

        bool    singleton = size < 0;

        bool    hasNext = jspGetNext(jsp, &elem);

        if (singleton)

          size = 1;

        cxt->innermostArraySize = size; /* for LAST evaluation */

        for (i = 0; i < jsp->content.array.nelems; i++)

        {

          JsonPathItem from;

          JsonPathItem to;

          int32   index;

          int32   index_from;

          int32   index_to;

          bool    range = jspGetArraySubscript(jsp, &from,

                               &to, i);

          res = getArrayIndex(cxt, &from, jb, &index_from);

          if (jperIsError(res))

            break;

          if (range)

          {

            res = getArrayIndex(cxt, &to, jb, &index_to);

            if (jperIsError(res))

              break;

          }

          else

            index_to = index_from;

          if (!jspIgnoreStructuralErrors(cxt) &&

            (index_from < 0 ||

             index_from > index_to ||

             index_to >= size))

            RETURN_ERROR(ereport(ERROR,

                       (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),

                        errmsg("jsonpath array subscript is out of bounds"))));

          if (index_from < 0)

            index_from = 0;

          if (index_to >= size)

            index_to = size - 1;

          res = jperNotFound;

          for (index = index_from; index <= index_to; index++)

          {

            JsonbValue *v;

            bool    copy;

            if (singleton)

            {

              v = jb;

              copy = true;

            }

            else

            {

              v = getIthJsonbValueFromContainer(jb->val.binary.data,

                                (uint32) index);

              if (v == NULL)

                continue;

              copy = false;

            }

            if (!hasNext && !found)

              return jperOk;

            res = executeNextItem(cxt, jsp, &elem, v, found,

                        copy);

            if (jperIsError(res))

              break;

            if (res == jperOk && !found)

              break;

          }

          if (jperIsError(res))

            break;

          if (res == jperOk && !found)

            break;

        }

        cxt->innermostArraySize = innermostArraySize;

      }

      else if (!jspIgnoreStructuralErrors(cxt))

      {

        RETURN_ERROR(ereport(ERROR,

                   (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),

                    errmsg("jsonpath array accessor can only be applied to an array"))));