LCOV - code coverage report
Current view: top level - src/backend/utils/adt - jsonpath_exec.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 970 1048 92.6 %
Date: 2020-05-29 01:06:25 Functions: 61 65 93.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * jsonpath_exec.c
       4             :  *   Routines for SQL/JSON path execution.
       5             :  *
       6             :  * Jsonpath is executed in the global context stored in JsonPathExecContext,
       7             :  * which is passed to almost every function involved into execution.  Entry
       8             :  * point for jsonpath execution is executeJsonPath() function, which
       9             :  * initializes execution context including initial JsonPathItem and JsonbValue,
      10             :  * flags, stack for calculation of @ in filters.
      11             :  *
      12             :  * The result of jsonpath query execution is enum JsonPathExecResult and
      13             :  * if succeeded sequence of JsonbValue, written to JsonValueList *found, which
      14             :  * is passed through the jsonpath items.  When found == NULL, we're inside
      15             :  * exists-query and we're interested only in whether result is empty.  In this
      16             :  * case execution is stopped once first result item is found, and the only
      17             :  * execution result is JsonPathExecResult.  The values of JsonPathExecResult
      18             :  * are following:
      19             :  * - jperOk         -- result sequence is not empty
      20             :  * - jperNotFound   -- result sequence is empty
      21             :  * - jperError      -- error occurred during execution
      22             :  *
      23             :  * Jsonpath is executed recursively (see executeItem()) starting form the
      24             :  * first path item (which in turn might be, for instance, an arithmetic
      25             :  * expression evaluated separately).  On each step single JsonbValue obtained
      26             :  * from previous path item is processed.  The result of processing is a
      27             :  * sequence of JsonbValue (probably empty), which is passed to the next path
      28             :  * item one by one.  When there is no next path item, then JsonbValue is added
      29             :  * to the 'found' list.  When found == NULL, then execution functions just
      30             :  * return jperOk (see executeNextItem()).
      31             :  *
      32             :  * Many of jsonpath operations require automatic unwrapping of arrays in lax
      33             :  * mode.  So, if input value is array, then corresponding operation is
      34             :  * processed not on array itself, but on all of its members one by one.
      35             :  * executeItemOptUnwrapTarget() function have 'unwrap' argument, which indicates
      36             :  * whether unwrapping of array is needed.  When unwrap == true, each of array
      37             :  * members is passed to executeItemOptUnwrapTarget() again but with unwrap == false
      38             :  * in order to evade subsequent array unwrapping.
      39             :  *
      40             :  * All boolean expressions (predicates) are evaluated by executeBoolItem()
      41             :  * function, which returns tri-state JsonPathBool.  When error is occurred
      42             :  * during predicate execution, it returns jpbUnknown.  According to standard
      43             :  * predicates can be only inside filters.  But we support their usage as
      44             :  * jsonpath expression.  This helps us to implement @@ operator.  In this case
      45             :  * resulting JsonPathBool is transformed into jsonb bool or null.
      46             :  *
      47             :  * Arithmetic and boolean expression are evaluated recursively from expression
      48             :  * tree top down to the leaves.  Therefore, for binary arithmetic expressions
      49             :  * we calculate operands first.  Then we check that results are numeric
      50             :  * singleton lists, calculate the result and pass it to the next path item.
      51             :  *
      52             :  * Copyright (c) 2019-2020, PostgreSQL Global Development Group
      53             :  *
      54             :  * IDENTIFICATION
      55             :  *  src/backend/utils/adt/jsonpath_exec.c
      56             :  *
      57             :  *-------------------------------------------------------------------------
      58             :  */
      59             : 
      60             : #include "postgres.h"
      61             : 
      62             : #include "catalog/pg_collation.h"
      63             : #include "catalog/pg_type.h"
      64             : #include "funcapi.h"
      65             : #include "lib/stringinfo.h"
      66             : #include "miscadmin.h"
      67             : #include "regex/regex.h"
      68             : #include "utils/builtins.h"
      69             : #include "utils/date.h"
      70             : #include "utils/datetime.h"
      71             : #include "utils/datum.h"
      72             : #include "utils/float.h"
      73             : #include "utils/formatting.h"
      74             : #include "utils/guc.h"
      75             : #include "utils/json.h"
      76             : #include "utils/jsonpath.h"
      77             : #include "utils/timestamp.h"
      78             : #include "utils/varlena.h"
      79             : 
      80             : /*
      81             :  * Represents "base object" and it's "id" for .keyvalue() evaluation.
      82             :  */
      83             : typedef struct JsonBaseObjectInfo
      84             : {
      85             :     JsonbContainer *jbc;
      86             :     int         id;
      87             : } JsonBaseObjectInfo;
      88             : 
      89             : /*
      90             :  * Context of jsonpath execution.
      91             :  */
      92             : typedef struct JsonPathExecContext
      93             : {
      94             :     Jsonb      *vars;           /* variables to substitute into jsonpath */
      95             :     JsonbValue *root;           /* for $ evaluation */
      96             :     JsonbValue *current;        /* for @ evaluation */
      97             :     JsonBaseObjectInfo baseObject;  /* "base object" for .keyvalue()
      98             :                                      * evaluation */
      99             :     int         lastGeneratedObjectId;  /* "id" counter for .keyvalue()
     100             :                                          * evaluation */
     101             :     int         innermostArraySize; /* for LAST array index evaluation */
     102             :     bool        laxMode;        /* true for "lax" mode, false for "strict"
     103             :                                  * mode */
     104             :     bool        ignoreStructuralErrors; /* with "true" structural errors such
     105             :                                          * as absence of required json item or
     106             :                                          * unexpected json item type are
     107             :                                          * ignored */
     108             :     bool        throwErrors;    /* with "false" all suppressible errors are
     109             :                                  * suppressed */
     110             :     bool        useTz;
     111             : } JsonPathExecContext;
     112             : 
     113             : /* Context for LIKE_REGEX execution. */
     114             : typedef struct JsonLikeRegexContext
     115             : {
     116             :     text       *regex;
     117             :     int         cflags;
     118             : } JsonLikeRegexContext;
     119             : 
     120             : /* Result of jsonpath predicate evaluation */
     121             : typedef enum JsonPathBool
     122             : {
     123             :     jpbFalse = 0,
     124             :     jpbTrue = 1,
     125             :     jpbUnknown = 2
     126             : } JsonPathBool;
     127             : 
     128             : /* Result of jsonpath expression evaluation */
     129             : typedef enum JsonPathExecResult
     130             : {
     131             :     jperOk = 0,
     132             :     jperNotFound = 1,
     133             :     jperError = 2
     134             : } JsonPathExecResult;
     135             : 
     136             : #define jperIsError(jper)           ((jper) == jperError)
     137             : 
     138             : /*
     139             :  * List of jsonb values with shortcut for single-value list.
     140             :  */
     141             : typedef struct JsonValueList
     142             : {
     143             :     JsonbValue *singleton;
     144             :     List       *list;
     145             : } JsonValueList;
     146             : 
     147             : typedef struct JsonValueListIterator
     148             : {
     149             :     JsonbValue *value;
     150             :     List       *list;
     151             :     ListCell   *next;
     152             : } JsonValueListIterator;
     153             : 
     154             : /* strict/lax flags is decomposed into four [un]wrap/error flags */
     155             : #define jspStrictAbsenseOfErrors(cxt)   (!(cxt)->laxMode)
     156             : #define jspAutoUnwrap(cxt)              ((cxt)->laxMode)
     157             : #define jspAutoWrap(cxt)                ((cxt)->laxMode)
     158             : #define jspIgnoreStructuralErrors(cxt)  ((cxt)->ignoreStructuralErrors)
     159             : #define jspThrowErrors(cxt)             ((cxt)->throwErrors)
     160             : 
     161             : /* Convenience macro: return or throw error depending on context */
     162             : #define RETURN_ERROR(throw_error) \
     163             : do { \
     164             :     if (jspThrowErrors(cxt)) \
     165             :         throw_error; \
     166             :     else \
     167             :         return jperError; \
     168             : } while (0)
     169             : 
     170             : typedef JsonPathBool (*JsonPathPredicateCallback) (JsonPathItem *jsp,
     171             :                                                    JsonbValue *larg,
     172             :                                                    JsonbValue *rarg,
     173             :                                                    void *param);
     174             : typedef Numeric (*BinaryArithmFunc) (Numeric num1, Numeric num2, bool *error);
     175             : 
     176             : static JsonPathExecResult executeJsonPath(JsonPath *path, Jsonb *vars,
     177             :                                           Jsonb *json, bool throwErrors,
     178             :                                           JsonValueList *result, bool useTz);
     179             : static JsonPathExecResult executeItem(JsonPathExecContext *cxt,
     180             :                                       JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found);
     181             : static JsonPathExecResult executeItemOptUnwrapTarget(JsonPathExecContext *cxt,
     182             :                                                      JsonPathItem *jsp, JsonbValue *jb,
     183             :                                                      JsonValueList *found, bool unwrap);
     184             : static JsonPathExecResult executeItemUnwrapTargetArray(JsonPathExecContext *cxt,
     185             :                                                        JsonPathItem *jsp, JsonbValue *jb,
     186             :                                                        JsonValueList *found, bool unwrapElements);
     187             : static JsonPathExecResult executeNextItem(JsonPathExecContext *cxt,
     188             :                                           JsonPathItem *cur, JsonPathItem *next,
     189             :                                           JsonbValue *v, JsonValueList *found, bool copy);
     190             : static JsonPathExecResult executeItemOptUnwrapResult(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb,
     191             :                                                      bool unwrap, JsonValueList *found);
     192             : static JsonPathExecResult executeItemOptUnwrapResultNoThrow(JsonPathExecContext *cxt, JsonPathItem *jsp,
     193             :                                                             JsonbValue *jb, bool unwrap, JsonValueList *found);
     194             : static JsonPathBool executeBoolItem(JsonPathExecContext *cxt,
     195             :                                     JsonPathItem *jsp, JsonbValue *jb, bool canHaveNext);
     196             : static JsonPathBool executeNestedBoolItem(JsonPathExecContext *cxt,
     197             :                                           JsonPathItem *jsp, JsonbValue *jb);
     198             : static JsonPathExecResult executeAnyItem(JsonPathExecContext *cxt,
     199             :                                          JsonPathItem *jsp, JsonbContainer *jbc, JsonValueList *found,
     200             :                                          uint32 level, uint32 first, uint32 last,
     201             :                                          bool ignoreStructuralErrors, bool unwrapNext);
     202             : static JsonPathBool executePredicate(JsonPathExecContext *cxt,
     203             :                                      JsonPathItem *pred, JsonPathItem *larg, JsonPathItem *rarg,
     204             :                                      JsonbValue *jb, bool unwrapRightArg,
     205             :                                      JsonPathPredicateCallback exec, void *param);
     206             : static JsonPathExecResult executeBinaryArithmExpr(JsonPathExecContext *cxt,
     207             :                                                   JsonPathItem *jsp, JsonbValue *jb,
     208             :                                                   BinaryArithmFunc func, JsonValueList *found);
     209             : static JsonPathExecResult executeUnaryArithmExpr(JsonPathExecContext *cxt,
     210             :                                                  JsonPathItem *jsp, JsonbValue *jb, PGFunction func,
     211             :                                                  JsonValueList *found);
     212             : static JsonPathBool executeStartsWith(JsonPathItem *jsp,
     213             :                                       JsonbValue *whole, JsonbValue *initial, void *param);
     214             : static JsonPathBool executeLikeRegex(JsonPathItem *jsp, JsonbValue *str,
     215             :                                      JsonbValue *rarg, void *param);
     216             : static JsonPathExecResult executeNumericItemMethod(JsonPathExecContext *cxt,
     217             :                                                    JsonPathItem *jsp, JsonbValue *jb, bool unwrap, PGFunction func,
     218             :                                                    JsonValueList *found);
     219             : static JsonPathExecResult executeDateTimeMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
     220             :                                                 JsonbValue *jb, JsonValueList *found);
     221             : static JsonPathExecResult executeKeyValueMethod(JsonPathExecContext *cxt,
     222             :                                                 JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found);
     223             : static JsonPathExecResult appendBoolResult(JsonPathExecContext *cxt,
     224             :                                            JsonPathItem *jsp, JsonValueList *found, JsonPathBool res);
     225             : static void getJsonPathItem(JsonPathExecContext *cxt, JsonPathItem *item,
     226             :                             JsonbValue *value);
     227             : static void getJsonPathVariable(JsonPathExecContext *cxt,
     228             :                                 JsonPathItem *variable, Jsonb *vars, JsonbValue *value);
     229             : static int  JsonbArraySize(JsonbValue *jb);
     230             : static JsonPathBool executeComparison(JsonPathItem *cmp, JsonbValue *lv,
     231             :                                       JsonbValue *rv, void *p);
     232             : static JsonPathBool compareItems(int32 op, JsonbValue *jb1, JsonbValue *jb2,
     233             :                                  bool useTz);
     234             : static int  compareNumeric(Numeric a, Numeric b);
     235             : static JsonbValue *copyJsonbValue(JsonbValue *src);
     236             : static JsonPathExecResult getArrayIndex(JsonPathExecContext *cxt,
     237             :                                         JsonPathItem *jsp, JsonbValue *jb, int32 *index);
     238             : static JsonBaseObjectInfo setBaseObject(JsonPathExecContext *cxt,
     239             :                                         JsonbValue *jbv, int32 id);
     240             : static void JsonValueListAppend(JsonValueList *jvl, JsonbValue *jbv);
     241             : static int  JsonValueListLength(const JsonValueList *jvl);
     242             : static bool JsonValueListIsEmpty(JsonValueList *jvl);
     243             : static JsonbValue *JsonValueListHead(JsonValueList *jvl);
     244             : static List *JsonValueListGetList(JsonValueList *jvl);
     245             : static void JsonValueListInitIterator(const JsonValueList *jvl,
     246             :                                       JsonValueListIterator *it);
     247             : static JsonbValue *JsonValueListNext(const JsonValueList *jvl,
     248             :                                      JsonValueListIterator *it);
     249             : static int  JsonbType(JsonbValue *jb);
     250             : static JsonbValue *JsonbInitBinary(JsonbValue *jbv, Jsonb *jb);
     251             : static int  JsonbType(JsonbValue *jb);
     252             : static JsonbValue *getScalar(JsonbValue *scalar, enum jbvType type);
     253             : static JsonbValue *wrapItemsInArray(const JsonValueList *items);
     254             : static int  compareDatetime(Datum val1, Oid typid1, Datum val2, Oid typid2,
     255             :                             bool useTz, bool *have_error);
     256             : 
     257             : /****************** User interface to JsonPath executor ********************/
     258             : 
     259             : /*
     260             :  * jsonb_path_exists
     261             :  *      Returns true if jsonpath returns at least one item for the specified
     262             :  *      jsonb value.  This function and jsonb_path_match() are used to
     263             :  *      implement @? and @@ operators, which in turn are intended to have an
     264             :  *      index support.  Thus, it's desirable to make it easier to achieve
     265             :  *      consistency between index scan results and sequential scan results.
     266             :  *      So, we throw as less errors as possible.  Regarding this function,
     267             :  *      such behavior also matches behavior of JSON_EXISTS() clause of
     268             :  *      SQL/JSON.  Regarding jsonb_path_match(), this function doesn't have
     269             :  *      an analogy in SQL/JSON, so we define its behavior on our own.
     270             :  */
     271             : static Datum
     272       70260 : jsonb_path_exists_internal(FunctionCallInfo fcinfo, bool tz)
     273             : {
     274       70260 :     Jsonb      *jb = PG_GETARG_JSONB_P(0);
     275       70260 :     JsonPath   *jp = PG_GETARG_JSONPATH_P(1);
     276             :     JsonPathExecResult res;
     277       70260 :     Jsonb      *vars = NULL;
     278       70260 :     bool        silent = true;
     279             : 
     280       70260 :     if (PG_NARGS() == 4)
     281             :     {
     282          28 :         vars = PG_GETARG_JSONB_P(2);
     283          28 :         silent = PG_GETARG_BOOL(3);
     284             :     }
     285             : 
     286       70260 :     res = executeJsonPath(jp, vars, jb, !silent, NULL, tz);
     287             : 
     288       70256 :     PG_FREE_IF_COPY(jb, 0);
     289       70256 :     PG_FREE_IF_COPY(jp, 1);
     290             : 
     291       70256 :     if (jperIsError(res))
     292          36 :         PG_RETURN_NULL();
     293             : 
     294       70220 :     PG_RETURN_BOOL(res == jperOk);
     295             : }
     296             : 
     297             : Datum
     298          28 : jsonb_path_exists(PG_FUNCTION_ARGS)
     299             : {
     300          28 :     return jsonb_path_exists_internal(fcinfo, false);
     301             : }
     302             : 
     303             : Datum
     304           0 : jsonb_path_exists_tz(PG_FUNCTION_ARGS)
     305             : {
     306           0 :     return jsonb_path_exists_internal(fcinfo, true);
     307             : }
     308             : 
     309             : /*
     310             :  * jsonb_path_exists_opr
     311             :  *      Implementation of operator "jsonb @? jsonpath" (2-argument version of
     312             :  *      jsonb_path_exists()).
     313             :  */
     314             : Datum
     315       70232 : jsonb_path_exists_opr(PG_FUNCTION_ARGS)
     316             : {
     317             :     /* just call the other one -- it can handle both cases */
     318       70232 :     return jsonb_path_exists_internal(fcinfo, false);
     319             : }
     320             : 
     321             : /*
     322             :  * jsonb_path_match
     323             :  *      Returns jsonpath predicate result item for the specified jsonb value.
     324             :  *      See jsonb_path_exists() comment for details regarding error handling.
     325             :  */
     326             : static Datum
     327       81832 : jsonb_path_match_internal(FunctionCallInfo fcinfo, bool tz)
     328             : {
     329       81832 :     Jsonb      *jb = PG_GETARG_JSONB_P(0);
     330       81832 :     JsonPath   *jp = PG_GETARG_JSONPATH_P(1);
     331       81832 :     JsonValueList found = {0};
     332       81832 :     Jsonb      *vars = NULL;
     333       81832 :     bool        silent = true;
     334             : 
     335       81832 :     if (PG_NARGS() == 4)
     336             :     {
     337          76 :         vars = PG_GETARG_JSONB_P(2);
     338          76 :         silent = PG_GETARG_BOOL(3);
     339             :     }
     340             : 
     341       81832 :     (void) executeJsonPath(jp, vars, jb, !silent, &found, tz);
     342             : 
     343       81828 :     PG_FREE_IF_COPY(jb, 0);
     344       81828 :     PG_FREE_IF_COPY(jp, 1);
     345             : 
     346       81828 :     if (JsonValueListLength(&found) == 1)
     347             :     {
     348       81808 :         JsonbValue *jbv = JsonValueListHead(&found);
     349             : 
     350       81808 :         if (jbv->type == jbvBool)
     351       81760 :             PG_RETURN_BOOL(jbv->val.boolean);
     352             : 
     353          48 :         if (jbv->type == jbvNull)
     354          16 :             PG_RETURN_NULL();
     355             :     }
     356             : 
     357          52 :     if (!silent)
     358          24 :         ereport(ERROR,
     359             :                 (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
     360             :                  errmsg("single boolean result is expected")));
     361             : 
     362          28 :     PG_RETURN_NULL();
     363             : }
     364             : 
     365             : Datum
     366          76 : jsonb_path_match(PG_FUNCTION_ARGS)
     367             : {
     368          76 :     return jsonb_path_match_internal(fcinfo, false);
     369             : }
     370             : 
     371             : Datum
     372           0 : jsonb_path_match_tz(PG_FUNCTION_ARGS)
     373             : {
     374           0 :     return jsonb_path_match_internal(fcinfo, true);
     375             : }
     376             : 
     377             : /*
     378             :  * jsonb_path_match_opr
     379             :  *      Implementation of operator "jsonb @@ jsonpath" (2-argument version of
     380             :  *      jsonb_path_match()).
     381             :  */
     382             : Datum
     383       81756 : jsonb_path_match_opr(PG_FUNCTION_ARGS)
     384             : {
     385             :     /* just call the other one -- it can handle both cases */
     386       81756 :     return jsonb_path_match_internal(fcinfo, false);
     387             : }
     388             : 
     389             : /*
     390             :  * jsonb_path_query
     391             :  *      Executes jsonpath for given jsonb document and returns result as
     392             :  *      rowset.
     393             :  */
     394             : static Datum
     395        2376 : jsonb_path_query_internal(FunctionCallInfo fcinfo, bool tz)
     396             : {
     397             :     FuncCallContext *funcctx;
     398             :     List       *found;
     399             :     JsonbValue *v;
     400             :     ListCell   *c;
     401             : 
     402        2376 :     if (SRF_IS_FIRSTCALL())
     403             :     {
     404             :         JsonPath   *jp;
     405             :         Jsonb      *jb;
     406             :         MemoryContext oldcontext;
     407             :         Jsonb      *vars;
     408             :         bool        silent;
     409        1216 :         JsonValueList found = {0};
     410             : 
     411        1216 :         funcctx = SRF_FIRSTCALL_INIT();
     412        1216 :         oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
     413             : 
     414        1216 :         jb = PG_GETARG_JSONB_P_COPY(0);
     415        1216 :         jp = PG_GETARG_JSONPATH_P_COPY(1);
     416        1216 :         vars = PG_GETARG_JSONB_P_COPY(2);
     417        1216 :         silent = PG_GETARG_BOOL(3);
     418             : 
     419        1216 :         (void) executeJsonPath(jp, vars, jb, !silent, &found, tz);
     420             : 
     421         940 :         funcctx->user_fctx = JsonValueListGetList(&found);
     422             : 
     423         940 :         MemoryContextSwitchTo(oldcontext);
     424             :     }
     425             : 
     426        2100 :     funcctx = SRF_PERCALL_SETUP();
     427        2100 :     found = funcctx->user_fctx;
     428             : 
     429        2100 :     c = list_head(found);
     430             : 
     431        2100 :     if (c == NULL)
     432         940 :         SRF_RETURN_DONE(funcctx);
     433             : 
     434        1160 :     v = lfirst(c);
     435        1160 :     funcctx->user_fctx = list_delete_first(found);
     436             : 
     437        1160 :     SRF_RETURN_NEXT(funcctx, JsonbPGetDatum(JsonbValueToJsonb(v)));
     438             : }
     439             : 
     440             : Datum
     441        2120 : jsonb_path_query(PG_FUNCTION_ARGS)
     442             : {
     443        2120 :     return jsonb_path_query_internal(fcinfo, false);
     444             : }
     445             : 
     446             : Datum
     447         256 : jsonb_path_query_tz(PG_FUNCTION_ARGS)
     448             : {
     449         256 :     return jsonb_path_query_internal(fcinfo, true);
     450             : }
     451             : 
     452             : /*
     453             :  * jsonb_path_query_array
     454             :  *      Executes jsonpath for given jsonb document and returns result as
     455             :  *      jsonb array.
     456             :  */
     457             : static Datum
     458          24 : jsonb_path_query_array_internal(FunctionCallInfo fcinfo, bool tz)
     459             : {
     460          24 :     Jsonb      *jb = PG_GETARG_JSONB_P(0);
     461          24 :     JsonPath   *jp = PG_GETARG_JSONPATH_P(1);
     462          24 :     JsonValueList found = {0};
     463          24 :     Jsonb      *vars = PG_GETARG_JSONB_P(2);
     464          24 :     bool        silent = PG_GETARG_BOOL(3);
     465             : 
     466          24 :     (void) executeJsonPath(jp, vars, jb, !silent, &found, tz);
     467             : 
     468          20 :     PG_RETURN_JSONB_P(JsonbValueToJsonb(wrapItemsInArray(&found)));
     469             : }
     470             : 
     471             : Datum
     472          24 : jsonb_path_query_array(PG_FUNCTION_ARGS)
     473             : {
     474          24 :     return jsonb_path_query_array_internal(fcinfo, false);
     475             : }
     476             : 
     477             : Datum
     478           0 : jsonb_path_query_array_tz(PG_FUNCTION_ARGS)
     479             : {
     480           0 :     return jsonb_path_query_array_internal(fcinfo, true);
     481             : }
     482             : 
     483             : /*
     484             :  * jsonb_path_query_first
     485             :  *      Executes jsonpath for given jsonb document and returns first result
     486             :  *      item.  If there are no items, NULL returned.
     487             :  */
     488             : static Datum
     489        2908 : jsonb_path_query_first_internal(FunctionCallInfo fcinfo, bool tz)
     490             : {
     491        2908 :     Jsonb      *jb = PG_GETARG_JSONB_P(0);
     492        2908 :     JsonPath   *jp = PG_GETARG_JSONPATH_P(1);
     493        2908 :     JsonValueList found = {0};
     494        2908 :     Jsonb      *vars = PG_GETARG_JSONB_P(2);
     495        2908 :     bool        silent = PG_GETARG_BOOL(3);
     496             : 
     497        2908 :     (void) executeJsonPath(jp, vars, jb, !silent, &found, tz);
     498             : 
     499        2904 :     if (JsonValueListLength(&found) >= 1)
     500        2896 :         PG_RETURN_JSONB_P(JsonbValueToJsonb(JsonValueListHead(&found)));
     501             :     else
     502           8 :         PG_RETURN_NULL();
     503             : }
     504             : 
     505             : Datum
     506        2908 : jsonb_path_query_first(PG_FUNCTION_ARGS)
     507             : {
     508        2908 :     return jsonb_path_query_first_internal(fcinfo, false);
     509             : }
     510             : 
     511             : Datum
     512           0 : jsonb_path_query_first_tz(PG_FUNCTION_ARGS)
     513             : {
     514           0 :     return jsonb_path_query_first_internal(fcinfo, true);
     515             : }
     516             : 
     517             : /********************Execute functions for JsonPath**************************/
     518             : 
     519             : /*
     520             :  * Interface to jsonpath executor
     521             :  *
     522             :  * 'path' - jsonpath to be executed
     523             :  * 'vars' - variables to be substituted to jsonpath
     524             :  * 'json' - target document for jsonpath evaluation
     525             :  * 'throwErrors' - whether we should throw suppressible errors
     526             :  * 'result' - list to store result items into
     527             :  *
     528             :  * Returns an error if a recoverable error happens during processing, or NULL
     529             :  * on no error.
     530             :  *
     531             :  * Note, jsonb and jsonpath values should be available and untoasted during
     532             :  * work because JsonPathItem, JsonbValue and result item could have pointers
     533             :  * into input values.  If caller needs to just check if document matches
     534             :  * jsonpath, then it doesn't provide a result arg.  In this case executor
     535             :  * works till first positive result and does not check the rest if possible.
     536             :  * In other case it tries to find all the satisfied result items.
     537             :  */
     538             : static JsonPathExecResult
     539      156240 : executeJsonPath(JsonPath *path, Jsonb *vars, Jsonb *json, bool throwErrors,
     540             :                 JsonValueList *result, bool useTz)
     541             : {
     542             :     JsonPathExecContext cxt;
     543             :     JsonPathExecResult res;
     544             :     JsonPathItem jsp;
     545             :     JsonbValue  jbv;
     546             : 
     547      156240 :     jspInit(&jsp, path);
     548             : 
     549      156240 :     if (!JsonbExtractScalar(&json->root, &jbv))
     550      155800 :         JsonbInitBinary(&jbv, json);
     551             : 
     552      156240 :     if (vars && !JsonContainerIsObject(&vars->root))
     553             :     {
     554           8 :         ereport(ERROR,
     555             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     556             :                  errmsg("\"vars\" argument is not an object"),
     557             :                  errdetail("Jsonpath parameters should be encoded as key-value pairs of \"vars\" object.")));
     558             :     }
     559             : 
     560      156232 :     cxt.vars = vars;
     561      156232 :     cxt.laxMode = (path->header & JSONPATH_LAX) != 0;
     562      156232 :     cxt.ignoreStructuralErrors = cxt.laxMode;
     563      156232 :     cxt.root = &jbv;
     564      156232 :     cxt.current = &jbv;
     565      156232 :     cxt.baseObject.jbc = NULL;
     566      156232 :     cxt.baseObject.id = 0;
     567      156232 :     cxt.lastGeneratedObjectId = vars ? 2 : 1;
     568      156232 :     cxt.innermostArraySize = -1;
     569      156232 :     cxt.throwErrors = throwErrors;
     570      156232 :     cxt.useTz = useTz;
     571             : 
     572      156232 :     if (jspStrictAbsenseOfErrors(&cxt) && !result)
     573             :     {
     574             :         /*
     575             :          * In strict mode we must get a complete list of values to check that
     576             :          * there are no errors at all.
     577             :          */
     578          36 :         JsonValueList vals = {0};
     579             : 
     580          36 :         res = executeItem(&cxt, &jsp, &jbv, &vals);
     581             : 
     582          32 :         if (jperIsError(res))
     583          28 :             return res;
     584             : 
     585           4 :         return JsonValueListIsEmpty(&vals) ? jperNotFound : jperOk;
     586             :     }
     587             : 
     588      156196 :     res = executeItem(&cxt, &jsp, &jbv, result);
     589             : 
     590             :     Assert(!throwErrors || !jperIsError(res));
     591             : 
     592      155916 :     return res;
     593             : }
     594             : 
     595             : /*
     596             :  * Execute jsonpath with automatic unwrapping of current item in lax mode.
     597             :  */
     598             : static JsonPathExecResult
     599      476420 : executeItem(JsonPathExecContext *cxt, JsonPathItem *jsp,
     600             :             JsonbValue *jb, JsonValueList *found)
     601             : {
     602      476420 :     return executeItemOptUnwrapTarget(cxt, jsp, jb, found, jspAutoUnwrap(cxt));
     603             : }
     604             : 
     605             : /*
     606             :  * Main jsonpath executor function: walks on jsonpath structure, finds
     607             :  * relevant parts of jsonb and evaluates expressions over them.
     608             :  * When 'unwrap' is true current SQL/JSON item is unwrapped if it is an array.
     609             :  */
     610             : static JsonPathExecResult
     611      479076 : executeItemOptUnwrapTarget(JsonPathExecContext *cxt, JsonPathItem *jsp,
     612             :                            JsonbValue *jb, JsonValueList *found, bool unwrap)
     613             : {
     614             :     JsonPathItem elem;
     615      479076 :     JsonPathExecResult res = jperNotFound;
     616             :     JsonBaseObjectInfo baseObject;
     617             : 
     618      479076 :     check_stack_depth();
     619      479076 :     CHECK_FOR_INTERRUPTS();
     620             : 
     621      479076 :     switch (jsp->type)
     622             :     {
     623             :             /* all boolean item types: */
     624       84672 :         case jpiAnd:
     625             :         case jpiOr:
     626             :         case jpiNot:
     627             :         case jpiIsUnknown:
     628             :         case jpiEqual:
     629             :         case jpiNotEqual:
     630             :         case jpiLess:
     631             :         case jpiGreater:
     632             :         case jpiLessOrEqual:
     633             :         case jpiGreaterOrEqual:
     634             :         case jpiExists:
     635             :         case jpiStartsWith:
     636             :         case jpiLikeRegex:
     637             :             {
     638       84672 :                 JsonPathBool st = executeBoolItem(cxt, jsp, jb, true);
     639             : 
     640       84672 :                 res = appendBoolResult(cxt, jsp, found, st);
     641       84672 :                 break;
     642             :             }
     643             : 
     644      138052 :         case jpiKey:
     645      138052 :             if (JsonbType(jb) == jbvObject)
     646             :             {
     647             :                 JsonbValue *v;
     648             :                 JsonbValue  key;
     649             : 
     650      137884 :                 key.type = jbvString;
     651      137884 :                 key.val.string.val = jspGetString(jsp, &key.val.string.len);
     652             : 
     653      137884 :                 v = findJsonbValueFromContainer(jb->val.binary.data,
     654             :                                                 JB_FOBJECT, &key);
     655             : 
     656      137884 :                 if (v != NULL)
     657             :                 {
     658       19892 :                     res = executeNextItem(cxt, jsp, NULL,
     659             :                                           v, found, false);
     660             : 
     661             :                     /* free value if it was not added to found list */
     662       19892 :                     if (jspHasNext(jsp) || !found)
     663       12236 :                         pfree(v);
     664             :                 }
     665      117992 :                 else if (!jspIgnoreStructuralErrors(cxt))
     666             :                 {
     667             :                     Assert(found);
     668             : 
     669          48 :                     if (!jspThrowErrors(cxt))
     670          32 :                         return jperError;
     671             : 
     672          16 :                     ereport(ERROR,
     673             :                             (errcode(ERRCODE_SQL_JSON_MEMBER_NOT_FOUND), \
     674             :                              errmsg("JSON object does not contain key \"%s\"",
     675             :                                     pnstrdup(key.val.string.val,
     676             :                                              key.val.string.len))));
     677             :                 }
     678             :             }
     679         168 :             else if (unwrap && JsonbType(jb) == jbvArray)
     680           4 :                 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
     681         164 :             else if (!jspIgnoreStructuralErrors(cxt))
     682             :             {
     683             :                 Assert(found);
     684          44 :                 RETURN_ERROR(ereport(ERROR,
     685             :                                      (errcode(ERRCODE_SQL_JSON_MEMBER_NOT_FOUND),
     686             :                                       errmsg("jsonpath member accessor can only be applied to an object"))));
     687             :             }
     688      137956 :             break;
     689             : 
     690      165220 :         case jpiRoot:
     691      165220 :             jb = cxt->root;
     692      165220 :             baseObject = setBaseObject(cxt, jb, 0);
     693      165220 :             res = executeNextItem(cxt, jsp, NULL, jb, found, true);
     694      164968 :             cxt->baseObject = baseObject;
     695      164968 :             break;
     696             : 
     697       18376 :         case jpiCurrent:
     698       18376 :             res = executeNextItem(cxt, jsp, NULL, cxt->current,
     699             :                                   found, true);
     700       18376 :             break;
     701             : 
     702         876 :         case jpiAnyArray:
     703         876 :             if (JsonbType(jb) == jbvArray)
     704             :             {
     705         752 :                 bool        hasNext = jspGetNext(jsp, &elem);
     706             : 
     707         752 :                 res = executeItemUnwrapTargetArray(cxt, hasNext ? &elem : NULL,
     708         752 :                                                    jb, found, jspAutoUnwrap(cxt));
     709             :             }
     710         124 :             else if (jspAutoWrap(cxt))
     711         116 :                 res = executeNextItem(cxt, jsp, NULL, jb, found, true);
     712           8 :             else if (!jspIgnoreStructuralErrors(cxt))
     713           8 :                 RETURN_ERROR(ereport(ERROR,
     714             :                                      (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),
     715             :                                       errmsg("jsonpath wildcard array accessor can only be applied to an array"))));
     716         784 :             break;
     717             : 
     718         192 :         case jpiIndexArray:
     719         192 :             if (JsonbType(jb) == jbvArray || jspAutoWrap(cxt))
     720         116 :             {
     721         184 :                 int         innermostArraySize = cxt->innermostArraySize;
     722             :                 int         i;
     723         184 :                 int         size = JsonbArraySize(jb);
     724         184 :                 bool        singleton = size < 0;
     725         184 :                 bool        hasNext = jspGetNext(jsp, &elem);
     726             : 
     727         184 :                 if (singleton)
     728           4 :                     size = 1;
     729             : 
     730         184 :                 cxt->innermostArraySize = size; /* for LAST evaluation */
     731             : 
     732         288 :                 for (i = 0; i < jsp->content.array.nelems; i++)
     733             :                 {
     734             :                     JsonPathItem from;
     735             :                     JsonPathItem to;
     736             :                     int32       index;
     737             :                     int32       index_from;
     738             :                     int32       index_to;
     739         192 :                     bool        range = jspGetArraySubscript(jsp, &from,
     740             :                                                              &to, i);
     741             : 
     742         192 :                     res = getArrayIndex(cxt, &from, jb, &index_from);
     743             : 
     744         176 :                     if (jperIsError(res))
     745          20 :                         break;
     746             : 
     747         160 :                     if (range)
     748             :                     {
     749          20 :                         res = getArrayIndex(cxt, &to, jb, &index_to);
     750             : 
     751          16 :                         if (jperIsError(res))
     752           0 :                             break;
     753             :                     }
     754             :                     else
     755         140 :                         index_to = index_from;
     756             : 
     757         156 :                     if (!jspIgnoreStructuralErrors(cxt) &&
     758          56 :                         (index_from < 0 ||
     759          48 :                          index_from > index_to ||
     760          48 :                          index_to >= size))
     761          48 :                         RETURN_ERROR(ereport(ERROR,
     762             :                                              (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
     763             :                                               errmsg("jsonpath array subscript is out of bounds"))));
     764             : 
     765         124 :                     if (index_from < 0)
     766           8 :                         index_from = 0;
     767             : 
     768         124 :                     if (index_to >= size)
     769          12 :                         index_to = size - 1;
     770             : 
     771         124 :                     res = jperNotFound;
     772             : 
     773         240 :                     for (index = index_from; index <= index_to; index++)
     774             :                     {
     775             :                         JsonbValue *v;
     776             :                         bool        copy;
     777             : 
     778         136 :                         if (singleton)
     779             :                         {
     780           4 :                             v = jb;
     781           4 :                             copy = true;
     782             :                         }
     783             :                         else
     784             :                         {
     785         132 :                             v = getIthJsonbValueFromContainer(jb->val.binary.data,
     786             :                                                               (uint32) index);
     787             : 
     788         132 :                             if (v == NULL)
     789           0 :                                 continue;
     790             : 
     791         132 :                             copy = false;
     792             :                         }
     793             : 
     794         136 :                         if (!hasNext && !found)
     795          16 :                             return jperOk;
     796             : 
     797         120 :                         res = executeNextItem(cxt, jsp, &elem, v, found,
     798             :                                               copy);
     799             : 
     800         120 :                         if (jperIsError(res))
     801           0 :                             break;
     802             : 
     803         120 :                         if (res == jperOk && !found)
     804           4 :                             break;
     805             :                     }
     806             : 
     807         108 :                     if (jperIsError(res))
     808           0 :                         break;
     809             : 
     810         108 :                     if (res == jperOk && !found)
     811           4 :                         break;
     812             :                 }
     813             : 
     814         116 :                 cxt->innermostArraySize = innermostArraySize;
     815             :             }
     816           8 :             else if (!jspIgnoreStructuralErrors(cxt))
     817             :             {
     818           8 :                 RETURN_ERROR(ereport(ERROR,
     819             :                                      (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),
     820             :                                       errmsg("jsonpath array accessor can only be applied to an array"))));
     821             :             }
     822         116 :             break;
     823             : 
     824          44 :         case jpiLast:
     825          44 :             {
     826             :                 JsonbValue  tmpjbv;
     827             :                 JsonbValue *lastjbv;
     828             :                 int         last;
     829          44 :                 bool        hasNext = jspGetNext(jsp, &elem);
     830             : 
     831          44 :                 if (cxt->innermostArraySize < 0)
     832           0 :                     elog(ERROR, "evaluating jsonpath LAST outside of array subscript");
     833             : 
     834          44 :                 if (!hasNext && !found)
     835             :                 {
     836           4 :                     res = jperOk;
     837           4 :                     break;
     838             :                 }
     839             : 
     840          40 :                 last = cxt->innermostArraySize - 1;
     841             : 
     842          40 :                 lastjbv = hasNext ? &tmpjbv : palloc(sizeof(*lastjbv));
     843             : 
     844          40 :                 lastjbv->type = jbvNumeric;
     845          40 :                 lastjbv->val.numeric =
     846          40 :                     DatumGetNumeric(DirectFunctionCall1(int4_numeric,
     847             :                                                         Int32GetDatum(last)));
     848             : 
     849          40 :                 res = executeNextItem(cxt, jsp, &elem,
     850             :                                       lastjbv, found, hasNext);
     851             :             }
     852          40 :             break;
     853             : 
     854          56 :         case jpiAnyKey:
     855          56 :             if (JsonbType(jb) == jbvObject)
     856             :             {
     857          44 :                 bool        hasNext = jspGetNext(jsp, &elem);
     858             : 
     859          44 :                 if (jb->type != jbvBinary)
     860           0 :                     elog(ERROR, "invalid jsonb object type: %d", jb->type);
     861             : 
     862          44 :                 return executeAnyItem
     863             :                     (cxt, hasNext ? &elem : NULL,
     864             :                      jb->val.binary.data, found, 1, 1, 1,
     865          44 :                      false, jspAutoUnwrap(cxt));
     866             :             }
     867          12 :             else if (unwrap && JsonbType(jb) == jbvArray)
     868           0 :                 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
     869          12 :             else if (!jspIgnoreStructuralErrors(cxt))
     870             :             {
     871             :                 Assert(found);
     872           8 :                 RETURN_ERROR(ereport(ERROR,
     873             :                                      (errcode(ERRCODE_SQL_JSON_OBJECT_NOT_FOUND),
     874             :                                       errmsg("jsonpath wildcard member accessor can only be applied to an object"))));
     875             :             }
     876           4 :             break;
     877             : 
     878         112 :         case jpiAdd:
     879         112 :             return executeBinaryArithmExpr(cxt, jsp, jb,
     880             :                                            numeric_add_opt_error, found);
     881             : 
     882          40 :         case jpiSub:
     883          40 :             return executeBinaryArithmExpr(cxt, jsp, jb,
     884             :                                            numeric_sub_opt_error, found);
     885             : 
     886          24 :         case jpiMul:
     887          24 :             return executeBinaryArithmExpr(cxt, jsp, jb,
     888             :                                            numeric_mul_opt_error, found);
     889             : 
     890          44 :         case jpiDiv:
     891          44 :             return executeBinaryArithmExpr(cxt, jsp, jb,
     892             :                                            numeric_div_opt_error, found);
     893             : 
     894           8 :         case jpiMod:
     895           8 :             return executeBinaryArithmExpr(cxt, jsp, jb,
     896             :                                            numeric_mod_opt_error, found);
     897             : 
     898          40 :         case jpiPlus:
     899          40 :             return executeUnaryArithmExpr(cxt, jsp, jb, NULL, found);
     900             : 
     901          84 :         case jpiMinus:
     902          84 :             return executeUnaryArithmExpr(cxt, jsp, jb, numeric_uminus,
     903             :                                           found);
     904             : 
     905       17848 :         case jpiFilter:
     906             :             {
     907             :                 JsonPathBool st;
     908             : 
     909       17848 :                 if (unwrap && JsonbType(jb) == jbvArray)
     910          84 :                     return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
     911             :                                                         false);
     912             : 
     913       17764 :                 jspGetArg(jsp, &elem);
     914       17764 :                 st = executeNestedBoolItem(cxt, &elem, jb);
     915       17700 :                 if (st != jpbTrue)
     916       16400 :                     res = jperNotFound;
     917             :                 else
     918        1300 :                     res = executeNextItem(cxt, jsp, NULL,
     919             :                                           jb, found, true);
     920       17700 :                 break;
     921             :             }
     922             : 
     923         204 :         case jpiAny:
     924             :             {
     925         204 :                 bool        hasNext = jspGetNext(jsp, &elem);
     926             : 
     927             :                 /* first try without any intermediate steps */
     928         204 :                 if (jsp->content.anybounds.first == 0)
     929             :                 {
     930             :                     bool        savedIgnoreStructuralErrors;
     931             : 
     932         112 :                     savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors;
     933         112 :                     cxt->ignoreStructuralErrors = true;
     934         112 :                     res = executeNextItem(cxt, jsp, &elem,
     935             :                                           jb, found, true);
     936         112 :                     cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors;
     937             : 
     938         112 :                     if (res == jperOk && !found)
     939           4 :                         break;
     940             :                 }
     941             : 
     942         200 :                 if (jb->type == jbvBinary)
     943         200 :                     res = executeAnyItem
     944             :                         (cxt, hasNext ? &elem : NULL,
     945             :                          jb->val.binary.data, found,
     946             :                          1,
     947             :                          jsp->content.anybounds.first,
     948             :                          jsp->content.anybounds.last,
     949         200 :                          true, jspAutoUnwrap(cxt));
     950         200 :                 break;
     951             :             }
     952             : 
     953       50564 :         case jpiNull:
     954             :         case jpiBool:
     955             :         case jpiNumeric:
     956             :         case jpiString:
     957             :         case jpiVariable:
     958           4 :             {
     959             :                 JsonbValue  vbuf;
     960             :                 JsonbValue *v;
     961       50564 :                 bool        hasNext = jspGetNext(jsp, &elem);
     962             : 
     963       50564 :                 if (!hasNext && !found)
     964             :                 {
     965           4 :                     res = jperOk;   /* skip evaluation */
     966           4 :                     break;
     967             :                 }
     968             : 
     969       50560 :                 v = hasNext ? &vbuf : palloc(sizeof(*v));
     970             : 
     971       50560 :                 baseObject = cxt->baseObject;
     972       50560 :                 getJsonPathItem(cxt, jsp, v);
     973             : 
     974       50556 :                 res = executeNextItem(cxt, jsp, &elem,
     975             :                                       v, found, hasNext);
     976       50556 :                 cxt->baseObject = baseObject;
     977             :             }
     978       50556 :             break;
     979             : 
     980         140 :         case jpiType:
     981             :             {
     982         140 :                 JsonbValue *jbv = palloc(sizeof(*jbv));
     983             : 
     984         140 :                 jbv->type = jbvString;
     985         140 :                 jbv->val.string.val = pstrdup(JsonbTypeName(jb));
     986         140 :                 jbv->val.string.len = strlen(jbv->val.string.val);
     987             : 
     988         140 :                 res = executeNextItem(cxt, jsp, NULL, jbv,
     989             :                                       found, false);
     990             :             }
     991         140 :             break;
     992             : 
     993          48 :         case jpiSize:
     994             :             {
     995          48 :                 int         size = JsonbArraySize(jb);
     996             : 
     997          48 :                 if (size < 0)
     998             :                 {
     999          32 :                     if (!jspAutoWrap(cxt))
    1000             :                     {
    1001           8 :                         if (!jspIgnoreStructuralErrors(cxt))
    1002           8 :                             RETURN_ERROR(ereport(ERROR,
    1003             :                                                  (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),
    1004             :                                                   errmsg("jsonpath item method .%s() can only be applied to an array",
    1005             :                                                          jspOperationName(jsp->type)))));
    1006           0 :                         break;
    1007             :                     }
    1008             : 
    1009          24 :                     size = 1;
    1010             :                 }
    1011             : 
    1012          40 :                 jb = palloc(sizeof(*jb));
    1013             : 
    1014          40 :                 jb->type = jbvNumeric;
    1015          40 :                 jb->val.numeric =
    1016          40 :                     DatumGetNumeric(DirectFunctionCall1(int4_numeric,
    1017             :                                                         Int32GetDatum(size)));
    1018             : 
    1019          40 :                 res = executeNextItem(cxt, jsp, NULL, jb, found, false);
    1020             :             }
    1021          40 :             break;
    1022             : 
    1023          72 :         case jpiAbs:
    1024          72 :             return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_abs,
    1025             :                                             found);
    1026             : 
    1027          32 :         case jpiFloor:
    1028          32 :             return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_floor,
    1029             :                                             found);
    1030             : 
    1031          68 :         case jpiCeiling:
    1032          68 :             return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_ceil,
    1033             :                                             found);
    1034             : 
    1035          72 :         case jpiDouble:
    1036          44 :             {
    1037             :                 JsonbValue  jbv;
    1038             : 
    1039          72 :                 if (unwrap && JsonbType(jb) == jbvArray)
    1040           4 :                     return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
    1041             :                                                         false);
    1042             : 
    1043          68 :                 if (jb->type == jbvNumeric)
    1044             :                 {
    1045           4 :                     char       *tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
    1046             :                                                                           NumericGetDatum(jb->val.numeric)));
    1047           4 :                     bool        have_error = false;
    1048             : 
    1049           4 :                     (void) float8in_internal_opt_error(tmp,
    1050             :                                                        NULL,
    1051             :                                                        "double precision",
    1052             :                                                        tmp,
    1053             :                                                        &have_error);
    1054             : 
    1055           4 :                     if (have_error)
    1056           0 :                         RETURN_ERROR(ereport(ERROR,
    1057             :                                              (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
    1058             :                                               errmsg("jsonpath item method .%s() can only be applied to a numeric value",
    1059             :                                                      jspOperationName(jsp->type)))));
    1060           4 :                     res = jperOk;
    1061             :                 }
    1062          64 :                 else if (jb->type == jbvString)
    1063             :                 {
    1064             :                     /* cast string as double */
    1065             :                     double      val;
    1066          32 :                     char       *tmp = pnstrdup(jb->val.string.val,
    1067          32 :                                                jb->val.string.len);
    1068          32 :                     bool        have_error = false;
    1069             : 
    1070          32 :                     val = float8in_internal_opt_error(tmp,
    1071             :                                                       NULL,
    1072             :                                                       "double precision",
    1073             :                                                       tmp,
    1074             :                                                       &have_error);
    1075             : 
    1076          32 :                     if (have_error || isinf(val))
    1077          20 :                         RETURN_ERROR(ereport(ERROR,
    1078             :                                              (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
    1079             :                                               errmsg("jsonpath item method .%s() can only be applied to a numeric value",
    1080             :                                                      jspOperationName(jsp->type)))));
    1081             : 
    1082          12 :                     jb = &jbv;
    1083          12 :                     jb->type = jbvNumeric;
    1084          12 :                     jb->val.numeric = DatumGetNumeric(DirectFunctionCall1(float8_numeric,
    1085             :                                                                           Float8GetDatum(val)));
    1086          12 :                     res = jperOk;
    1087             :                 }
    1088             : 
    1089          48 :                 if (res == jperNotFound)
    1090          32 :                     RETURN_ERROR(ereport(ERROR,
    1091             :                                          (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
    1092             :                                           errmsg("jsonpath item method .%s() can only be applied to a string or numeric value",
    1093             :                                                  jspOperationName(jsp->type)))));
    1094             : 
    1095          16 :                 res = executeNextItem(cxt, jsp, NULL, jb, found, true);
    1096             :             }
    1097          16 :             break;
    1098             : 
    1099        2128 :         case jpiDatetime:
    1100        2128 :             if (unwrap && JsonbType(jb) == jbvArray)
    1101           4 :                 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
    1102             : 
    1103        2124 :             return executeDateTimeMethod(cxt, jsp, jb, found);
    1104             : 
    1105          60 :         case jpiKeyValue:
    1106          60 :             if (unwrap && JsonbType(jb) == jbvArray)
    1107           4 :                 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
    1108             : 
    1109          56 :             return executeKeyValueMethod(cxt, jsp, jb, found);
    1110             : 
    1111           0 :         default:
    1112           0 :             elog(ERROR, "unrecognized jsonpath item type: %d", jsp->type);
    1113             :     }
    1114             : 
    1115      475580 :     return res;
    1116             : }
    1117             : 
    1118             : /*
    1119             :  * Unwrap current array item and execute jsonpath for each of its elements.
    1120             :  */
    1121             : static JsonPathExecResult
    1122         888 : executeItemUnwrapTargetArray(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1123             :                              JsonbValue *jb, JsonValueList *found,
    1124             :                              bool unwrapElements)
    1125             : {
    1126         888 :     if (jb->type != jbvBinary)
    1127             :     {
    1128             :         Assert(jb->type != jbvArray);
    1129           0 :         elog(ERROR, "invalid jsonb array value type: %d", jb->type);
    1130             :     }
    1131             : 
    1132         888 :     return executeAnyItem
    1133             :         (cxt, jsp, jb->val.binary.data, found, 1, 1, 1,
    1134             :          false, unwrapElements);
    1135             : }
    1136             : 
    1137             : /*
    1138             :  * Execute next jsonpath item if exists.  Otherwise put "v" to the "found"
    1139             :  * list if provided.
    1140             :  */
    1141             : static JsonPathExecResult
    1142      343052 : executeNextItem(JsonPathExecContext *cxt,
    1143             :                 JsonPathItem *cur, JsonPathItem *next,
    1144             :                 JsonbValue *v, JsonValueList *found, bool copy)
    1145             : {
    1146             :     JsonPathItem elem;
    1147             :     bool        hasNext;
    1148             : 
    1149      343052 :     if (!cur)
    1150           0 :         hasNext = next != NULL;
    1151      343052 :     else if (next)
    1152      137952 :         hasNext = jspHasNext(cur);
    1153             :     else
    1154             :     {
    1155      205100 :         next = &elem;
    1156      205100 :         hasNext = jspGetNext(cur, next);
    1157             :     }
    1158             : 
    1159      343052 :     if (hasNext)
    1160      157192 :         return executeItem(cxt, next, v, found);
    1161             : 
    1162      185860 :     if (found)
    1163      149140 :         JsonValueListAppend(found, copy ? copyJsonbValue(v) : v);
    1164             : 
    1165      185860 :     return jperOk;
    1166             : }
    1167             : 
    1168             : /*
    1169             :  * Same as executeItem(), but when "unwrap == true" automatically unwraps
    1170             :  * each array item from the resulting sequence in lax mode.
    1171             :  */
    1172             : static JsonPathExecResult
    1173      162784 : executeItemOptUnwrapResult(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1174             :                            JsonbValue *jb, bool unwrap,
    1175             :                            JsonValueList *found)
    1176             : {
    1177      162784 :     if (unwrap && jspAutoUnwrap(cxt))
    1178             :     {
    1179      100568 :         JsonValueList seq = {0};
    1180             :         JsonValueListIterator it;
    1181      100568 :         JsonPathExecResult res = executeItem(cxt, jsp, jb, &seq);
    1182             :         JsonbValue *item;
    1183             : 
    1184      100552 :         if (jperIsError(res))
    1185          44 :             return res;
    1186             : 
    1187      100508 :         JsonValueListInitIterator(&seq, &it);
    1188      163796 :         while ((item = JsonValueListNext(&seq, &it)))
    1189             :         {
    1190             :             Assert(item->type != jbvArray);
    1191             : 
    1192       63288 :             if (JsonbType(item) == jbvArray)
    1193          36 :                 executeItemUnwrapTargetArray(cxt, NULL, item, found, false);
    1194             :             else
    1195       63252 :                 JsonValueListAppend(found, item);
    1196             :         }
    1197             : 
    1198      100508 :         return jperOk;
    1199             :     }
    1200             : 
    1201       62216 :     return executeItem(cxt, jsp, jb, found);
    1202             : }
    1203             : 
    1204             : /*
    1205             :  * Same as executeItemOptUnwrapResult(), but with error suppression.
    1206             :  */
    1207             : static JsonPathExecResult
    1208      162208 : executeItemOptUnwrapResultNoThrow(JsonPathExecContext *cxt,
    1209             :                                   JsonPathItem *jsp,
    1210             :                                   JsonbValue *jb, bool unwrap,
    1211             :                                   JsonValueList *found)
    1212             : {
    1213             :     JsonPathExecResult res;
    1214      162208 :     bool        throwErrors = cxt->throwErrors;
    1215             : 
    1216      162208 :     cxt->throwErrors = false;
    1217      162208 :     res = executeItemOptUnwrapResult(cxt, jsp, jb, unwrap, found);
    1218      162204 :     cxt->throwErrors = throwErrors;
    1219             : 
    1220      162204 :     return res;
    1221             : }
    1222             : 
    1223             : /* Execute boolean-valued jsonpath expression. */
    1224             : static JsonPathBool
    1225      142192 : executeBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1226             :                 JsonbValue *jb, bool canHaveNext)
    1227             : {
    1228             :     JsonPathItem larg;
    1229             :     JsonPathItem rarg;
    1230             :     JsonPathBool res;
    1231             :     JsonPathBool res2;
    1232             : 
    1233      142192 :     if (!canHaveNext && jspHasNext(jsp))
    1234           0 :         elog(ERROR, "boolean jsonpath item cannot have next item");
    1235             : 
    1236      142192 :     switch (jsp->type)
    1237             :     {
    1238       20252 :         case jpiAnd:
    1239       20252 :             jspGetLeftArg(jsp, &larg);
    1240       20252 :             res = executeBoolItem(cxt, &larg, jb, false);
    1241             : 
    1242       20252 :             if (res == jpbFalse)
    1243       18028 :                 return jpbFalse;
    1244             : 
    1245             :             /*
    1246             :              * SQL/JSON says that we should check second arg in case of
    1247             :              * jperError
    1248             :              */
    1249             : 
    1250        2224 :             jspGetRightArg(jsp, &rarg);
    1251        2224 :             res2 = executeBoolItem(cxt, &rarg, jb, false);
    1252             : 
    1253        2224 :             return res2 == jpbTrue ? res : res2;
    1254             : 
    1255        9444 :         case jpiOr:
    1256        9444 :             jspGetLeftArg(jsp, &larg);
    1257        9444 :             res = executeBoolItem(cxt, &larg, jb, false);
    1258             : 
    1259        9444 :             if (res == jpbTrue)
    1260        1820 :                 return jpbTrue;
    1261             : 
    1262        7624 :             jspGetRightArg(jsp, &rarg);
    1263        7624 :             res2 = executeBoolItem(cxt, &rarg, jb, false);
    1264             : 
    1265        7624 :             return res2 == jpbFalse ? res : res2;
    1266             : 
    1267          72 :         case jpiNot:
    1268          72 :             jspGetArg(jsp, &larg);
    1269             : 
    1270          72 :             res = executeBoolItem(cxt, &larg, jb, false);
    1271             : 
    1272          72 :             if (res == jpbUnknown)
    1273          24 :                 return jpbUnknown;
    1274             : 
    1275          48 :             return res == jpbTrue ? jpbFalse : jpbTrue;
    1276             : 
    1277         140 :         case jpiIsUnknown:
    1278         140 :             jspGetArg(jsp, &larg);
    1279         140 :             res = executeBoolItem(cxt, &larg, jb, false);
    1280         140 :             return res == jpbUnknown ? jpbTrue : jpbFalse;
    1281             : 
    1282       49880 :         case jpiEqual:
    1283             :         case jpiNotEqual:
    1284             :         case jpiLess:
    1285             :         case jpiGreater:
    1286             :         case jpiLessOrEqual:
    1287             :         case jpiGreaterOrEqual:
    1288       49880 :             jspGetLeftArg(jsp, &larg);
    1289       49880 :             jspGetRightArg(jsp, &rarg);
    1290       49880 :             return executePredicate(cxt, jsp, &larg, &rarg, jb, true,
    1291             :                                     executeComparison, cxt);
    1292             : 
    1293          56 :         case jpiStartsWith:     /* 'whole STARTS WITH initial' */
    1294          56 :             jspGetLeftArg(jsp, &larg);  /* 'whole' */
    1295          56 :             jspGetRightArg(jsp, &rarg); /* 'initial' */
    1296          56 :             return executePredicate(cxt, jsp, &larg, &rarg, jb, false,
    1297             :                                     executeStartsWith, NULL);
    1298             : 
    1299         264 :         case jpiLikeRegex:      /* 'expr LIKE_REGEX pattern FLAGS flags' */
    1300             :             {
    1301             :                 /*
    1302             :                  * 'expr' is a sequence-returning expression.  'pattern' is a
    1303             :                  * regex string literal.  SQL/JSON standard requires XQuery
    1304             :                  * regexes, but we use Postgres regexes here.  'flags' is a
    1305             :                  * string literal converted to integer flags at compile-time.
    1306             :                  */
    1307         264 :                 JsonLikeRegexContext lrcxt = {0};
    1308             : 
    1309         264 :                 jspInitByBuffer(&larg, jsp->base,
    1310             :                                 jsp->content.like_regex.expr);
    1311             : 
    1312         264 :                 return executePredicate(cxt, jsp, &larg, NULL, jb, false,
    1313             :                                         executeLikeRegex, &lrcxt);
    1314             :             }
    1315             : 
    1316       62084 :         case jpiExists:
    1317       62084 :             jspGetArg(jsp, &larg);
    1318             : 
    1319       62084 :             if (jspStrictAbsenseOfErrors(cxt))
    1320             :             {
    1321             :                 /*
    1322             :                  * In strict mode we must get a complete list of values to
    1323             :                  * check that there are no errors at all.
    1324             :                  */
    1325          32 :                 JsonValueList vals = {0};
    1326             :                 JsonPathExecResult res =
    1327          32 :                 executeItemOptUnwrapResultNoThrow(cxt, &larg, jb,
    1328             :                                                   false, &vals);
    1329             : 
    1330          32 :                 if (jperIsError(res))
    1331          24 :                     return jpbUnknown;
    1332             : 
    1333           8 :                 return JsonValueListIsEmpty(&vals) ? jpbFalse : jpbTrue;
    1334             :             }
    1335             :             else
    1336             :             {
    1337             :                 JsonPathExecResult res =
    1338       62052 :                 executeItemOptUnwrapResultNoThrow(cxt, &larg, jb,
    1339             :                                                   false, NULL);
    1340             : 
    1341       62052 :                 if (jperIsError(res))
    1342          16 :                     return jpbUnknown;
    1343             : 
    1344       62036 :                 return res == jperOk ? jpbTrue : jpbFalse;
    1345             :             }
    1346             : 
    1347           0 :         default:
    1348           0 :             elog(ERROR, "invalid boolean jsonpath item type: %d", jsp->type);
    1349             :             return jpbUnknown;
    1350             :     }
    1351             : }
    1352             : 
    1353             : /*
    1354             :  * Execute nested (filters etc.) boolean expression pushing current SQL/JSON
    1355             :  * item onto the stack.
    1356             :  */
    1357             : static JsonPathBool
    1358       17764 : executeNestedBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1359             :                       JsonbValue *jb)
    1360             : {
    1361             :     JsonbValue *prev;
    1362             :     JsonPathBool res;
    1363             : 
    1364       17764 :     prev = cxt->current;
    1365       17764 :     cxt->current = jb;
    1366       17764 :     res = executeBoolItem(cxt, jsp, jb, false);
    1367       17700 :     cxt->current = prev;
    1368             : 
    1369       17700 :     return res;
    1370             : }
    1371             : 
    1372             : /*
    1373             :  * Implementation of several jsonpath nodes:
    1374             :  *  - jpiAny (.** accessor),
    1375             :  *  - jpiAnyKey (.* accessor),
    1376             :  *  - jpiAnyArray ([*] accessor)
    1377             :  */
    1378             : static JsonPathExecResult
    1379        1256 : executeAnyItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbContainer *jbc,
    1380             :                JsonValueList *found, uint32 level, uint32 first, uint32 last,
    1381             :                bool ignoreStructuralErrors, bool unwrapNext)
    1382             : {
    1383        1256 :     JsonPathExecResult res = jperNotFound;
    1384             :     JsonbIterator *it;
    1385             :     int32       r;
    1386             :     JsonbValue  v;
    1387             : 
    1388        1256 :     check_stack_depth();
    1389             : 
    1390        1256 :     if (level > last)
    1391          20 :         return res;
    1392             : 
    1393        1236 :     it = JsonbIteratorInit(jbc);
    1394             : 
    1395             :     /*
    1396             :      * Recursively iterate over jsonb objects/arrays
    1397             :      */
    1398        6388 :     while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE)
    1399             :     {
    1400        5536 :         if (r == WJB_KEY)
    1401             :         {
    1402         368 :             r = JsonbIteratorNext(&it, &v, true);
    1403             :             Assert(r == WJB_VALUE);
    1404             :         }
    1405             : 
    1406        5536 :         if (r == WJB_VALUE || r == WJB_ELEM)
    1407             :         {
    1408             : 
    1409        3448 :             if (level >= first ||
    1410           8 :                 (first == PG_UINT32_MAX && last == PG_UINT32_MAX &&
    1411           8 :                  v.type != jbvBinary))  /* leaves only requested */
    1412             :             {
    1413             :                 /* check expression */
    1414        3408 :                 if (jsp)
    1415             :                 {
    1416        2656 :                     if (ignoreStructuralErrors)
    1417             :                     {
    1418             :                         bool        savedIgnoreStructuralErrors;
    1419             : 
    1420         232 :                         savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors;
    1421         232 :                         cxt->ignoreStructuralErrors = true;
    1422         232 :                         res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext);
    1423         232 :                         cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors;
    1424             :                     }
    1425             :                     else
    1426        2424 :                         res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext);
    1427             : 
    1428        2572 :                     if (jperIsError(res))
    1429          44 :                         break;
    1430             : 
    1431        2528 :                     if (res == jperOk && !found)
    1432         216 :                         break;
    1433             :                 }
    1434         752 :                 else if (found)
    1435         736 :                     JsonValueListAppend(found, copyJsonbValue(&v));
    1436             :                 else
    1437          16 :                     return jperOk;
    1438             :             }
    1439             : 
    1440        3088 :             if (level < last && v.type == jbvBinary)
    1441             :             {
    1442         124 :                 res = executeAnyItem
    1443             :                     (cxt, jsp, v.val.binary.data, found,
    1444             :                      level + 1, first, last,
    1445             :                      ignoreStructuralErrors, unwrapNext);
    1446             : 
    1447         124 :                 if (jperIsError(res))
    1448           0 :                     break;
    1449             : 
    1450         124 :                 if (res == jperOk && found == NULL)
    1451          24 :                     break;
    1452             :             }
    1453             :         }
    1454             :     }
    1455             : 
    1456        1136 :     return res;
    1457             : }
    1458             : 
    1459             : /*
    1460             :  * Execute unary or binary predicate.
    1461             :  *
    1462             :  * Predicates have existence semantics, because their operands are item
    1463             :  * sequences.  Pairs of items from the left and right operand's sequences are
    1464             :  * checked.  TRUE returned only if any pair satisfying the condition is found.
    1465             :  * In strict mode, even if the desired pair has already been found, all pairs
    1466             :  * still need to be examined to check the absence of errors.  If any error
    1467             :  * occurs, UNKNOWN (analogous to SQL NULL) is returned.
    1468             :  */
    1469             : static JsonPathBool
    1470       50200 : executePredicate(JsonPathExecContext *cxt, JsonPathItem *pred,
    1471             :                  JsonPathItem *larg, JsonPathItem *rarg, JsonbValue *jb,
    1472             :                  bool unwrapRightArg, JsonPathPredicateCallback exec,
    1473             :                  void *param)
    1474             : {
    1475             :     JsonPathExecResult res;
    1476             :     JsonValueListIterator lseqit;
    1477       50200 :     JsonValueList lseq = {0};
    1478       50200 :     JsonValueList rseq = {0};
    1479             :     JsonbValue *lval;
    1480       50200 :     bool        error = false;
    1481       50200 :     bool        found = false;
    1482             : 
    1483             :     /* Left argument is always auto-unwrapped. */
    1484       50200 :     res = executeItemOptUnwrapResultNoThrow(cxt, larg, jb, true, &lseq);
    1485       50200 :     if (jperIsError(res))
    1486          12 :         return jpbUnknown;
    1487             : 
    1488       50188 :     if (rarg)
    1489             :     {
    1490             :         /* Right argument is conditionally auto-unwrapped. */
    1491       49924 :         res = executeItemOptUnwrapResultNoThrow(cxt, rarg, jb,
    1492             :                                                 unwrapRightArg, &rseq);
    1493       49920 :         if (jperIsError(res))
    1494          36 :             return jpbUnknown;
    1495             :     }
    1496             : 
    1497       50148 :     JsonValueListInitIterator(&lseq, &lseqit);
    1498       64076 :     while ((lval = JsonValueListNext(&lseq, &lseqit)))
    1499             :     {
    1500             :         JsonValueListIterator rseqit;
    1501             :         JsonbValue *rval;
    1502       17320 :         bool        first = true;
    1503             : 
    1504       17320 :         JsonValueListInitIterator(&rseq, &rseqit);
    1505       17320 :         if (rarg)
    1506       17056 :             rval = JsonValueListNext(&rseq, &rseqit);
    1507             :         else
    1508         264 :             rval = NULL;
    1509             : 
    1510             :         /* Loop over right arg sequence or do single pass otherwise */
    1511       26920 :         while (rarg ? (rval != NULL) : first)
    1512             :         {
    1513       12992 :             JsonPathBool res = exec(pred, lval, rval, param);
    1514             : 
    1515       12932 :             if (res == jpbUnknown)
    1516             :             {
    1517         452 :                 if (jspStrictAbsenseOfErrors(cxt))
    1518        3332 :                     return jpbUnknown;
    1519             : 
    1520         436 :                 error = true;
    1521             :             }
    1522       12480 :             else if (res == jpbTrue)
    1523             :             {
    1524        3348 :                 if (!jspStrictAbsenseOfErrors(cxt))
    1525        3316 :                     return jpbTrue;
    1526             : 
    1527          32 :                 found = true;
    1528             :             }
    1529             : 
    1530        9600 :             first = false;
    1531        9600 :             if (rarg)
    1532        9404 :                 rval = JsonValueListNext(&rseq, &rseqit);
    1533             :         }
    1534             :     }
    1535             : 
    1536       46756 :     if (found)                  /* possible only in strict mode */
    1537          12 :         return jpbTrue;
    1538             : 
    1539       46744 :     if (error)                  /* possible only in lax mode */
    1540         416 :         return jpbUnknown;
    1541             : 
    1542       46328 :     return jpbFalse;
    1543             : }
    1544             : 
    1545             : /*
    1546             :  * Execute binary arithmetic expression on singleton numeric operands.
    1547             :  * Array operands are automatically unwrapped in lax mode.
    1548             :  */
    1549             : static JsonPathExecResult
    1550         228 : executeBinaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1551             :                         JsonbValue *jb, BinaryArithmFunc func,
    1552             :                         JsonValueList *found)
    1553             : {
    1554             :     JsonPathExecResult jper;
    1555             :     JsonPathItem elem;
    1556         228 :     JsonValueList lseq = {0};
    1557         228 :     JsonValueList rseq = {0};
    1558             :     JsonbValue *lval;
    1559             :     JsonbValue *rval;
    1560             :     Numeric     res;
    1561             : 
    1562         228 :     jspGetLeftArg(jsp, &elem);
    1563             : 
    1564             :     /*
    1565             :      * XXX: By standard only operands of multiplicative expressions are
    1566             :      * unwrapped.  We extend it to other binary arithmetic expressions too.
    1567             :      */
    1568         228 :     jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &lseq);
    1569         224 :     if (jperIsError(jper))
    1570           0 :         return jper;
    1571             : 
    1572         224 :     jspGetRightArg(jsp, &elem);
    1573             : 
    1574         224 :     jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &rseq);
    1575         220 :     if (jperIsError(jper))
    1576           0 :         return jper;
    1577             : 
    1578         396 :     if (JsonValueListLength(&lseq) != 1 ||
    1579         176 :         !(lval = getScalar(JsonValueListHead(&lseq), jbvNumeric)))
    1580          44 :         RETURN_ERROR(ereport(ERROR,
    1581             :                              (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
    1582             :                               errmsg("left operand of jsonpath operator %s is not a single numeric value",
    1583             :                                      jspOperationName(jsp->type)))));
    1584             : 
    1585         332 :     if (JsonValueListLength(&rseq) != 1 ||
    1586         156 :         !(rval = getScalar(JsonValueListHead(&rseq), jbvNumeric)))
    1587          36 :         RETURN_ERROR(ereport(ERROR,
    1588             :                              (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
    1589             :                               errmsg("right operand of jsonpath operator %s is not a single numeric value",
    1590             :                                      jspOperationName(jsp->type)))));
    1591             : 
    1592         140 :     if (jspThrowErrors(cxt))
    1593             :     {
    1594          52 :         res = func(lval->val.numeric, rval->val.numeric, NULL);
    1595             :     }
    1596             :     else
    1597             :     {
    1598          88 :         bool        error = false;
    1599             : 
    1600          88 :         res = func(lval->val.numeric, rval->val.numeric, &error);
    1601             : 
    1602          88 :         if (error)
    1603           8 :             return jperError;
    1604             :     }
    1605             : 
    1606         116 :     if (!jspGetNext(jsp, &elem) && !found)
    1607           4 :         return jperOk;
    1608             : 
    1609         112 :     lval = palloc(sizeof(*lval));
    1610         112 :     lval->type = jbvNumeric;
    1611         112 :     lval->val.numeric = res;
    1612             : 
    1613         112 :     return executeNextItem(cxt, jsp, &elem, lval, found, false);
    1614             : }
    1615             : 
    1616             : /*
    1617             :  * Execute unary arithmetic expression for each numeric item in its operand's
    1618             :  * sequence.  Array operand is automatically unwrapped in lax mode.
    1619             :  */
    1620             : static JsonPathExecResult
    1621         124 : executeUnaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1622             :                        JsonbValue *jb, PGFunction func, JsonValueList *found)
    1623             : {
    1624             :     JsonPathExecResult jper;
    1625             :     JsonPathExecResult jper2;
    1626             :     JsonPathItem elem;
    1627         124 :     JsonValueList seq = {0};
    1628             :     JsonValueListIterator it;
    1629             :     JsonbValue *val;
    1630             :     bool        hasNext;
    1631             : 
    1632         124 :     jspGetArg(jsp, &elem);
    1633         124 :     jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &seq);
    1634             : 
    1635         120 :     if (jperIsError(jper))
    1636           0 :         return jper;
    1637             : 
    1638         120 :     jper = jperNotFound;
    1639             : 
    1640         120 :     hasNext = jspGetNext(jsp, &elem);
    1641             : 
    1642         120 :     JsonValueListInitIterator(&seq, &it);
    1643         216 :     while ((val = JsonValueListNext(&seq, &it)))
    1644             :     {
    1645         128 :         if ((val = getScalar(val, jbvNumeric)))
    1646             :         {
    1647         100 :             if (!found && !hasNext)
    1648           8 :                 return jperOk;
    1649             :         }
    1650             :         else
    1651             :         {
    1652          28 :             if (!found && !hasNext)
    1653           4 :                 continue;       /* skip non-numerics processing */
    1654             : 
    1655          24 :             RETURN_ERROR(ereport(ERROR,
    1656             :                                  (errcode(ERRCODE_SQL_JSON_NUMBER_NOT_FOUND),
    1657             :                                   errmsg("operand of unary jsonpath operator %s is not a numeric value",
    1658             :                                          jspOperationName(jsp->type)))));
    1659             :         }
    1660             : 
    1661          92 :         if (func)
    1662          56 :             val->val.numeric =
    1663          56 :                 DatumGetNumeric(DirectFunctionCall1(func,
    1664             :                                                     NumericGetDatum(val->val.numeric)));
    1665             : 
    1666          92 :         jper2 = executeNextItem(cxt, jsp, &elem, val, found, false);
    1667             : 
    1668          92 :         if (jperIsError(jper2))
    1669           0 :             return jper2;
    1670             : 
    1671          92 :         if (jper2 == jperOk)
    1672             :         {
    1673          92 :             if (!found)
    1674           0 :                 return jperOk;
    1675          92 :             jper = jperOk;
    1676             :         }
    1677             :     }
    1678             : 
    1679          88 :     return jper;
    1680             : }
    1681             : 
    1682             : /*
    1683             :  * STARTS_WITH predicate callback.
    1684             :  *
    1685             :  * Check if the 'whole' string starts from 'initial' string.
    1686             :  */
    1687             : static JsonPathBool
    1688         116 : executeStartsWith(JsonPathItem *jsp, JsonbValue *whole, JsonbValue *initial,
    1689             :                   void *param)
    1690             : {
    1691         116 :     if (!(whole = getScalar(whole, jbvString)))
    1692          32 :         return jpbUnknown;      /* error */
    1693             : 
    1694          84 :     if (!(initial = getScalar(initial, jbvString)))
    1695           0 :         return jpbUnknown;      /* error */
    1696             : 
    1697          84 :     if (whole->val.string.len >= initial->val.string.len &&
    1698         120 :         !memcmp(whole->val.string.val,
    1699          60 :                 initial->val.string.val,
    1700          60 :                 initial->val.string.len))
    1701          36 :         return jpbTrue;
    1702             : 
    1703          48 :     return jpbFalse;
    1704             : }
    1705             : 
    1706             : /*
    1707             :  * LIKE_REGEX predicate callback.
    1708             :  *
    1709             :  * Check if the string matches regex pattern.
    1710             :  */
    1711             : static JsonPathBool
    1712         264 : executeLikeRegex(JsonPathItem *jsp, JsonbValue *str, JsonbValue *rarg,
    1713             :                  void *param)
    1714             : {
    1715         264 :     JsonLikeRegexContext *cxt = param;
    1716             : 
    1717         264 :     if (!(str = getScalar(str, jbvString)))
    1718          80 :         return jpbUnknown;
    1719             : 
    1720             :     /* Cache regex text and converted flags. */
    1721         184 :     if (!cxt->regex)
    1722             :     {
    1723         184 :         cxt->regex =
    1724         184 :             cstring_to_text_with_len(jsp->content.like_regex.pattern,
    1725             :                                      jsp->content.like_regex.patternlen);
    1726         184 :         cxt->cflags = jspConvertRegexFlags(jsp->content.like_regex.flags);
    1727             :     }
    1728             : 
    1729         184 :     if (RE_compile_and_execute(cxt->regex, str->val.string.val,
    1730             :                                str->val.string.len,
    1731             :                                cxt->cflags, DEFAULT_COLLATION_OID, 0, NULL))
    1732          68 :         return jpbTrue;
    1733             : 
    1734         116 :     return jpbFalse;
    1735             : }
    1736             : 
    1737             : /*
    1738             :  * Execute numeric item methods (.abs(), .floor(), .ceil()) using the specified
    1739             :  * user function 'func'.
    1740             :  */
    1741             : static JsonPathExecResult
    1742         172 : executeNumericItemMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1743             :                          JsonbValue *jb, bool unwrap, PGFunction func,
    1744             :                          JsonValueList *found)
    1745             : {
    1746             :     JsonPathItem next;
    1747             :     Datum       datum;
    1748             : 
    1749         172 :     if (unwrap && JsonbType(jb) == jbvArray)
    1750           0 :         return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
    1751             : 
    1752         172 :     if (!(jb = getScalar(jb, jbvNumeric)))
    1753          24 :         RETURN_ERROR(ereport(ERROR,
    1754             :                              (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
    1755             :                               errmsg("jsonpath item method .%s() can only be applied to a numeric value",
    1756             :                                      jspOperationName(jsp->type)))));
    1757             : 
    1758         148 :     datum = DirectFunctionCall1(func, NumericGetDatum(jb->val.numeric));
    1759             : 
    1760         148 :     if (!jspGetNext(jsp, &next) && !found)
    1761           0 :         return jperOk;
    1762             : 
    1763         148 :     jb = palloc(sizeof(*jb));
    1764         148 :     jb->type = jbvNumeric;
    1765         148 :     jb->val.numeric = DatumGetNumeric(datum);
    1766             : 
    1767         148 :     return executeNextItem(cxt, jsp, &next, jb, found, false);
    1768             : }
    1769             : 
    1770             : /*
    1771             :  * Implementation of the .datetime() method.
    1772             :  *
    1773             :  * Converts a string into a date/time value. The actual type is determined at run time.
    1774             :  * If an argument is provided, this argument is used as a template string.
    1775             :  * Otherwise, the first fitting ISO format is selected.
    1776             :  */
    1777             : static JsonPathExecResult
    1778        2124 : executeDateTimeMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1779             :                       JsonbValue *jb, JsonValueList *found)
    1780             : {
    1781             :     JsonbValue  jbvbuf;
    1782             :     Datum       value;
    1783             :     text       *datetime;
    1784             :     Oid         collid;
    1785             :     Oid         typid;
    1786        2124 :     int32       typmod = -1;
    1787        2124 :     int         tz = 0;
    1788             :     bool        hasNext;
    1789        2124 :     JsonPathExecResult res = jperNotFound;
    1790             :     JsonPathItem elem;
    1791             : 
    1792        2124 :     if (!(jb = getScalar(jb, jbvString)))
    1793          20 :         RETURN_ERROR(ereport(ERROR,
    1794             :                              (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
    1795             :                               errmsg("jsonpath item method .%s() can only be applied to a string",
    1796             :                                      jspOperationName(jsp->type)))));
    1797             : 
    1798        2104 :     datetime = cstring_to_text_with_len(jb->val.string.val,
    1799             :                                         jb->val.string.len);
    1800             : 
    1801             :     /*
    1802             :      * At some point we might wish to have callers supply the collation to
    1803             :      * use, but right now it's unclear that they'd be able to do better than
    1804             :      * DEFAULT_COLLATION_OID anyway.
    1805             :      */
    1806        2104 :     collid = DEFAULT_COLLATION_OID;
    1807             : 
    1808        2104 :     if (jsp->content.arg)
    1809             :     {
    1810             :         text       *template;
    1811             :         char       *template_str;
    1812             :         int         template_len;
    1813        1088 :         bool        have_error = false;
    1814             : 
    1815        1088 :         jspGetArg(jsp, &elem);
    1816             : 
    1817        1088 :         if (elem.type != jpiString)
    1818           0 :             elog(ERROR, "invalid jsonpath item type for .datetime() argument");
    1819             : 
    1820        1088 :         template_str = jspGetString(&elem, &template_len);
    1821             : 
    1822        1088 :         template = cstring_to_text_with_len(template_str,
    1823             :                                             template_len);
    1824             : 
    1825        1088 :         value = parse_datetime(datetime, template, collid, true,
    1826             :                                &typid, &typmod, &tz,
    1827        1088 :                                jspThrowErrors(cxt) ? NULL : &have_error);
    1828             : 
    1829        1056 :         if (have_error)
    1830           0 :             res = jperError;
    1831             :         else
    1832        1056 :             res = jperOk;
    1833             :     }
    1834             :     else
    1835             :     {
    1836             :         /*
    1837             :          * According to SQL/JSON standard enumerate ISO formats for: date,
    1838             :          * timetz, time, timestamptz, timestamp.
    1839             :          */
    1840             :         static const char *fmt_str[] =
    1841             :         {
    1842             :             "yyyy-mm-dd",
    1843             :             "HH24:MI:SS TZH:TZM",
    1844             :             "HH24:MI:SS TZH",
    1845             :             "HH24:MI:SS",
    1846             :             "yyyy-mm-dd HH24:MI:SS TZH:TZM",
    1847             :             "yyyy-mm-dd HH24:MI:SS TZH",
    1848             :             "yyyy-mm-dd HH24:MI:SS"
    1849             :         };
    1850             : 
    1851             :         /* cache for format texts */
    1852             :         static text *fmt_txt[lengthof(fmt_str)] = {0};
    1853             :         int         i;
    1854             : 
    1855             :         /* loop until datetime format fits */
    1856        4464 :         for (i = 0; i < lengthof(fmt_str); i++)
    1857             :         {
    1858        4460 :             bool        have_error = false;
    1859             : 
    1860        4460 :             if (!fmt_txt[i])
    1861             :             {
    1862             :                 MemoryContext oldcxt =
    1863          28 :                 MemoryContextSwitchTo(TopMemoryContext);
    1864             : 
    1865          28 :                 fmt_txt[i] = cstring_to_text(fmt_str[i]);
    1866          28 :                 MemoryContextSwitchTo(oldcxt);
    1867             :             }
    1868             : 
    1869        4460 :             value = parse_datetime(datetime, fmt_txt[i], collid, true,
    1870             :                                    &typid, &typmod, &tz,
    1871             :                                    &have_error);
    1872             : 
    1873        4460 :             if (!have_error)
    1874             :             {
    1875        1012 :                 res = jperOk;
    1876        1012 :                 break;
    1877             :             }
    1878             :         }
    1879             : 
    1880        1016 :         if (res == jperNotFound)
    1881           4 :             RETURN_ERROR(ereport(ERROR,
    1882             :                                  (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
    1883             :                                   errmsg("datetime format is not recognized: \"%s\"",
    1884             :                                          text_to_cstring(datetime)),
    1885             :                                   errhint("Use a datetime template argument to specify the input data format."))));
    1886             :     }
    1887             : 
    1888        2068 :     pfree(datetime);
    1889             : 
    1890        2068 :     if (jperIsError(res))
    1891           0 :         return res;
    1892             : 
    1893        2068 :     hasNext = jspGetNext(jsp, &elem);
    1894             : 
    1895        2068 :     if (!hasNext && !found)
    1896           4 :         return res;
    1897             : 
    1898        2064 :     jb = hasNext ? &jbvbuf : palloc(sizeof(*jb));
    1899             : 
    1900        2064 :     jb->type = jbvDatetime;
    1901        2064 :     jb->val.datetime.value = value;
    1902        2064 :     jb->val.datetime.typid = typid;
    1903        2064 :     jb->val.datetime.typmod = typmod;
    1904        2064 :     jb->val.datetime.tz = tz;
    1905             : 
    1906        2064 :     return executeNextItem(cxt, jsp, &elem, jb, found, hasNext);
    1907             : }
    1908             : 
    1909             : /*
    1910             :  * Implementation of .keyvalue() method.
    1911             :  *
    1912             :  * .keyvalue() method returns a sequence of object's key-value pairs in the
    1913             :  * following format: '{ "key": key, "value": value, "id": id }'.
    1914             :  *
    1915             :  * "id" field is an object identifier which is constructed from the two parts:
    1916             :  * base object id and its binary offset in base object's jsonb:
    1917             :  * id = 10000000000 * base_object_id + obj_offset_in_base_object
    1918             :  *
    1919             :  * 10000000000 (10^10) -- is a first round decimal number greater than 2^32
    1920             :  * (maximal offset in jsonb).  Decimal multiplier is used here to improve the
    1921             :  * readability of identifiers.
    1922             :  *
    1923             :  * Base object is usually a root object of the path: context item '$' or path
    1924             :  * variable '$var', literals can't produce objects for now.  But if the path
    1925             :  * contains generated objects (.keyvalue() itself, for example), then they
    1926             :  * become base object for the subsequent .keyvalue().
    1927             :  *
    1928             :  * Id of '$' is 0. Id of '$var' is its ordinal (positive) number in the list
    1929             :  * of variables (see getJsonPathVariable()).  Ids for generated objects
    1930             :  * are assigned using global counter JsonPathExecContext.lastGeneratedObjectId.
    1931             :  */
    1932             : static JsonPathExecResult
    1933          56 : executeKeyValueMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1934             :                       JsonbValue *jb, JsonValueList *found)
    1935             : {
    1936          56 :     JsonPathExecResult res = jperNotFound;
    1937             :     JsonPathItem next;
    1938             :     JsonbContainer *jbc;
    1939             :     JsonbValue  key;
    1940             :     JsonbValue  val;
    1941             :     JsonbValue  idval;
    1942             :     JsonbValue  keystr;
    1943             :     JsonbValue  valstr;
    1944             :     JsonbValue  idstr;
    1945             :     JsonbIterator *it;
    1946             :     JsonbIteratorToken tok;
    1947             :     int64       id;
    1948             :     bool        hasNext;
    1949             : 
    1950          56 :     if (JsonbType(jb) != jbvObject || jb->type != jbvBinary)
    1951          16 :         RETURN_ERROR(ereport(ERROR,
    1952             :                              (errcode(ERRCODE_SQL_JSON_OBJECT_NOT_FOUND),
    1953             :                               errmsg("jsonpath item method .%s() can only be applied to an object",
    1954             :                                      jspOperationName(jsp->type)))));
    1955             : 
    1956          40 :     jbc = jb->val.binary.data;
    1957             : 
    1958          40 :     if (!JsonContainerSize(jbc))
    1959          12 :         return jperNotFound;    /* no key-value pairs */
    1960             : 
    1961          28 :     hasNext = jspGetNext(jsp, &next);
    1962             : 
    1963          28 :     keystr.type = jbvString;
    1964          28 :     keystr.val.string.val = "key";
    1965          28 :     keystr.val.string.len = 3;
    1966             : 
    1967          28 :     valstr.type = jbvString;
    1968          28 :     valstr.val.string.val = "value";
    1969          28 :     valstr.val.string.len = 5;
    1970             : 
    1971          28 :     idstr.type = jbvString;
    1972          28 :     idstr.val.string.val = "id";
    1973          28 :     idstr.val.string.len = 2;
    1974             : 
    1975             :     /* construct object id from its base object and offset inside that */
    1976          28 :     id = jb->type != jbvBinary ? 0 :
    1977          28 :         (int64) ((char *) jbc - (char *) cxt->baseObject.jbc);
    1978          28 :     id += (int64) cxt->baseObject.id * INT64CONST(10000000000);
    1979             : 
    1980          28 :     idval.type = jbvNumeric;
    1981          28 :     idval.val.numeric = DatumGetNumeric(DirectFunctionCall1(int8_numeric,
    1982             :                                                             Int64GetDatum(id)));
    1983             : 
    1984          28 :     it = JsonbIteratorInit(jbc);
    1985             : 
    1986         112 :     while ((tok = JsonbIteratorNext(&it, &key, true)) != WJB_DONE)
    1987             :     {
    1988             :         JsonBaseObjectInfo baseObject;
    1989             :         JsonbValue  obj;
    1990             :         JsonbParseState *ps;
    1991             :         JsonbValue *keyval;
    1992             :         Jsonb      *jsonb;
    1993             : 
    1994          92 :         if (tok != WJB_KEY)
    1995          48 :             continue;
    1996             : 
    1997          44 :         res = jperOk;
    1998             : 
    1999          44 :         if (!hasNext && !found)
    2000           8 :             break;
    2001             : 
    2002          40 :         tok = JsonbIteratorNext(&it, &val, true);
    2003             :         Assert(tok == WJB_VALUE);
    2004             : 
    2005          40 :         ps = NULL;
    2006          40 :         pushJsonbValue(&ps, WJB_BEGIN_OBJECT, NULL);
    2007             : 
    2008          40 :         pushJsonbValue(&ps, WJB_KEY, &keystr);
    2009          40 :         pushJsonbValue(&ps, WJB_VALUE, &key);
    2010             : 
    2011          40 :         pushJsonbValue(&ps, WJB_KEY, &valstr);
    2012          40 :         pushJsonbValue(&ps, WJB_VALUE, &val);
    2013             : 
    2014          40 :         pushJsonbValue(&ps, WJB_KEY, &idstr);
    2015          40 :         pushJsonbValue(&ps, WJB_VALUE, &idval);
    2016             : 
    2017          40 :         keyval = pushJsonbValue(&ps, WJB_END_OBJECT, NULL);
    2018             : 
    2019          40 :         jsonb = JsonbValueToJsonb(keyval);
    2020             : 
    2021          40 :         JsonbInitBinary(&obj, jsonb);
    2022             : 
    2023          40 :         baseObject = setBaseObject(cxt, &obj, cxt->lastGeneratedObjectId++);
    2024             : 
    2025          40 :         res = executeNextItem(cxt, jsp, &next, &obj, found, true);
    2026             : 
    2027          40 :         cxt->baseObject = baseObject;
    2028             : 
    2029          40 :         if (jperIsError(res))
    2030           0 :             return res;
    2031             : 
    2032          40 :         if (res == jperOk && !found)
    2033           4 :             break;
    2034             :     }
    2035             : 
    2036          28 :     return res;
    2037             : }
    2038             : 
    2039             : /*
    2040             :  * Convert boolean execution status 'res' to a boolean JSON item and execute
    2041             :  * next jsonpath.
    2042             :  */
    2043             : static JsonPathExecResult
    2044       84672 : appendBoolResult(JsonPathExecContext *cxt, JsonPathItem *jsp,
    2045             :                  JsonValueList *found, JsonPathBool res)
    2046             : {
    2047             :     JsonPathItem next;
    2048             :     JsonbValue  jbv;
    2049             : 
    2050       84672 :     if (!jspGetNext(jsp, &next) && !found)
    2051           4 :         return jperOk;          /* found singleton boolean value */
    2052             : 
    2053       84668 :     if (res == jpbUnknown)
    2054             :     {
    2055          20 :         jbv.type = jbvNull;
    2056             :     }
    2057             :     else
    2058             :     {
    2059       84648 :         jbv.type = jbvBool;
    2060       84648 :         jbv.val.boolean = res == jpbTrue;
    2061             :     }
    2062             : 
    2063       84668 :     return executeNextItem(cxt, jsp, &next, &jbv, found, true);
    2064             : }
    2065             : 
    2066             : /*
    2067             :  * Convert jsonpath's scalar or variable node to actual jsonb value.
    2068             :  *
    2069             :  * If node is a variable then its id returned, otherwise 0 returned.
    2070             :  */
    2071             : static void
    2072       50560 : getJsonPathItem(JsonPathExecContext *cxt, JsonPathItem *item,
    2073             :                 JsonbValue *value)
    2074             : {
    2075       50560 :     switch (item->type)
    2076             :     {
    2077        7880 :         case jpiNull:
    2078        7880 :             value->type = jbvNull;
    2079        7880 :             break;
    2080         960 :         case jpiBool:
    2081         960 :             value->type = jbvBool;
    2082         960 :             value->val.boolean = jspGetBool(item);
    2083         960 :             break;
    2084       16552 :         case jpiNumeric:
    2085       16552 :             value->type = jbvNumeric;
    2086       16552 :             value->val.numeric = jspGetNumeric(item);
    2087       16552 :             break;
    2088       21684 :         case jpiString:
    2089       21684 :             value->type = jbvString;
    2090       43368 :             value->val.string.val = jspGetString(item,
    2091       21684 :                                                  &value->val.string.len);
    2092       21684 :             break;
    2093        3484 :         case jpiVariable:
    2094        3484 :             getJsonPathVariable(cxt, item, cxt->vars, value);
    2095        3480 :             return;
    2096           0 :         default:
    2097           0 :             elog(ERROR, "unexpected jsonpath item type");
    2098             :     }
    2099             : }
    2100             : 
    2101             : /*
    2102             :  * Get the value of variable passed to jsonpath executor
    2103             :  */
    2104             : static void
    2105        3484 : getJsonPathVariable(JsonPathExecContext *cxt, JsonPathItem *variable,
    2106             :                     Jsonb *vars, JsonbValue *value)
    2107             : {
    2108             :     char       *varName;
    2109             :     int         varNameLength;
    2110             :     JsonbValue  tmp;
    2111             :     JsonbValue *v;
    2112             : 
    2113        3484 :     if (!vars)
    2114             :     {
    2115           0 :         value->type = jbvNull;
    2116           0 :         return;
    2117             :     }
    2118             : 
    2119             :     Assert(variable->type == jpiVariable);
    2120        3484 :     varName = jspGetString(variable, &varNameLength);
    2121        3484 :     tmp.type = jbvString;
    2122        3484 :     tmp.val.string.val = varName;
    2123        3484 :     tmp.val.string.len = varNameLength;
    2124             : 
    2125        3484 :     v = findJsonbValueFromContainer(&vars->root, JB_FOBJECT, &tmp);
    2126             : 
    2127        3484 :     if (v)
    2128             :     {
    2129        3480 :         *value = *v;
    2130        3480 :         pfree(v);
    2131             :     }
    2132             :     else
    2133             :     {
    2134           4 :         ereport(ERROR,
    2135             :                 (errcode(ERRCODE_UNDEFINED_OBJECT),
    2136             :                  errmsg("could not find jsonpath variable \"%s\"",
    2137             :                         pnstrdup(varName, varNameLength))));
    2138             :     }
    2139             : 
    2140        3480 :     JsonbInitBinary(&tmp, vars);
    2141        3480 :     setBaseObject(cxt, &tmp, 1);
    2142             : }
    2143             : 
    2144             : /**************** Support functions for JsonPath execution *****************/
    2145             : 
    2146             : /*
    2147             :  * Returns the size of an array item, or -1 if item is not an array.
    2148             :  */
    2149             : static int
    2150         232 : JsonbArraySize(JsonbValue *jb)
    2151             : {
    2152             :     Assert(jb->type != jbvArray);
    2153             : 
    2154         232 :     if (jb->type == jbvBinary)
    2155             :     {
    2156         204 :         JsonbContainer *jbc = jb->val.binary.data;
    2157             : 
    2158         204 :         if (JsonContainerIsArray(jbc) && !JsonContainerIsScalar(jbc))
    2159         196 :             return JsonContainerSize(jbc);
    2160             :     }
    2161             : 
    2162          36 :     return -1;
    2163             : }
    2164             : 
    2165             : /* Comparison predicate callback. */
    2166             : static JsonPathBool
    2167       12612 : executeComparison(JsonPathItem *cmp, JsonbValue *lv, JsonbValue *rv, void *p)
    2168             : {
    2169       12612 :     JsonPathExecContext *cxt = (JsonPathExecContext *) p;
    2170             : 
    2171       12612 :     return compareItems(cmp->type, lv, rv, cxt->useTz);
    2172             : }
    2173             : 
    2174             : /*
    2175             :  * Perform per-byte comparison of two strings.
    2176             :  */
    2177             : static int
    2178        2304 : binaryCompareStrings(const char *s1, int len1,
    2179             :                      const char *s2, int len2)
    2180             : {
    2181             :     int         cmp;
    2182             : 
    2183        2304 :     cmp = memcmp(s1, s2, Min(len1, len2));
    2184             : 
    2185        2304 :     if (cmp != 0)
    2186        1312 :         return cmp;
    2187             : 
    2188         992 :     if (len1 == len2)
    2189         192 :         return 0;
    2190             : 
    2191         800 :     return len1 < len2 ? -1 : 1;
    2192             : }
    2193             : 
    2194             : /*
    2195             :  * Compare two strings in the current server encoding using Unicode codepoint
    2196             :  * collation.
    2197             :  */
    2198             : static int
    2199        2304 : compareStrings(const char *mbstr1, int mblen1,
    2200             :                const char *mbstr2, int mblen2)
    2201             : {
    2202        4608 :     if (GetDatabaseEncoding() == PG_SQL_ASCII ||
    2203        2304 :         GetDatabaseEncoding() == PG_UTF8)
    2204             :     {
    2205             :         /*
    2206             :          * It's known property of UTF-8 strings that their per-byte comparison
    2207             :          * result matches codepoints comparison result.  ASCII can be
    2208             :          * considered as special case of UTF-8.
    2209             :          */
    2210        2304 :         return binaryCompareStrings(mbstr1, mblen1, mbstr2, mblen2);
    2211             :     }
    2212             :     else
    2213             :     {
    2214             :         char       *utf8str1,
    2215             :                    *utf8str2;
    2216             :         int         cmp,
    2217             :                     utf8len1,
    2218             :                     utf8len2;
    2219             : 
    2220             :         /*
    2221             :          * We have to convert other encodings to UTF-8 first, then compare.
    2222             :          * Input strings may be not null-terminated and pg_server_to_any() may
    2223             :          * return them "as is".  So, use strlen() only if there is real
    2224             :          * conversion.
    2225             :          */
    2226           0 :         utf8str1 = pg_server_to_any(mbstr1, mblen1, PG_UTF8);
    2227           0 :         utf8str2 = pg_server_to_any(mbstr2, mblen2, PG_UTF8);
    2228           0 :         utf8len1 = (mbstr1 == utf8str1) ? mblen1 : strlen(utf8str1);
    2229           0 :         utf8len2 = (mbstr2 == utf8str2) ? mblen2 : strlen(utf8str2);
    2230             : 
    2231           0 :         cmp = binaryCompareStrings(utf8str1, utf8len1, utf8str2, utf8len2);
    2232             : 
    2233             :         /*
    2234             :          * If pg_server_to_any() did no real conversion, then we actually
    2235             :          * compared original strings.  So, we already done.
    2236             :          */
    2237           0 :         if (mbstr1 == utf8str1 && mbstr2 == utf8str2)
    2238           0 :             return cmp;
    2239             : 
    2240             :         /* Free memory if needed */
    2241           0 :         if (mbstr1 != utf8str1)
    2242           0 :             pfree(utf8str1);
    2243           0 :         if (mbstr2 != utf8str2)
    2244           0 :             pfree(utf8str2);
    2245             : 
    2246             :         /*
    2247             :          * When all Unicode codepoints are equal, return result of binary
    2248             :          * comparison.  In some edge cases, same characters may have different
    2249             :          * representations in encoding.  Then our behavior could diverge from
    2250             :          * standard.  However, that allow us to do simple binary comparison
    2251             :          * for "==" operator, which is performance critical in typical cases.
    2252             :          * In future to implement strict standard conformance, we can do
    2253             :          * normalization of input JSON strings.
    2254             :          */
    2255           0 :         if (cmp == 0)
    2256           0 :             return binaryCompareStrings(mbstr1, mblen1, mbstr2, mblen2);
    2257             :         else
    2258           0 :             return cmp;
    2259             :     }
    2260             : }
    2261             : 
    2262             : /*
    2263             :  * Compare two SQL/JSON items using comparison operation 'op'.
    2264             :  */
    2265             : static JsonPathBool
    2266       12612 : compareItems(int32 op, JsonbValue *jb1, JsonbValue *jb2, bool useTz)
    2267             : {
    2268             :     int         cmp;
    2269             :     bool        res;
    2270             : 
    2271       12612 :     if (jb1->type != jb2->type)
    2272             :     {
    2273        2760 :         if (jb1->type == jbvNull || jb2->type == jbvNull)
    2274             : 
    2275             :             /*
    2276             :              * Equality and order comparison of nulls to non-nulls returns
    2277             :              * always false, but inequality comparison returns true.
    2278             :              */
    2279        2596 :             return op == jpiNotEqual ? jpbTrue : jpbFalse;
    2280             : 
    2281             :         /* Non-null items of different types are not comparable. */
    2282         164 :         return jpbUnknown;
    2283             :     }
    2284             : 
    2285        9852 :     switch (jb1->type)
    2286             :     {
    2287         124 :         case jbvNull:
    2288         124 :             cmp = 0;
    2289         124 :             break;
    2290         604 :         case jbvBool:
    2291         868 :             cmp = jb1->val.boolean == jb2->val.boolean ? 0 :
    2292         264 :                 jb1->val.boolean ? 1 : -1;
    2293         604 :             break;
    2294         824 :         case jbvNumeric:
    2295         824 :             cmp = compareNumeric(jb1->val.numeric, jb2->val.numeric);
    2296         824 :             break;
    2297        7340 :         case jbvString:
    2298        7340 :             if (op == jpiEqual)
    2299        5036 :                 return jb1->val.string.len != jb2->val.string.len ||
    2300        5736 :                     memcmp(jb1->val.string.val,
    2301        2868 :                            jb2->val.string.val,
    2302        5036 :                            jb1->val.string.len) ? jpbFalse : jpbTrue;
    2303             : 
    2304        4608 :             cmp = compareStrings(jb1->val.string.val, jb1->val.string.len,
    2305        2304 :                                  jb2->val.string.val, jb2->val.string.len);
    2306        2304 :             break;
    2307         952 :         case jbvDatetime:
    2308         724 :             {
    2309             :                 bool        cast_error;
    2310             : 
    2311         952 :                 cmp = compareDatetime(jb1->val.datetime.value,
    2312             :                                       jb1->val.datetime.typid,
    2313             :                                       jb2->val.datetime.value,
    2314             :                                       jb2->val.datetime.typid,
    2315             :                                       useTz,
    2316             :                                       &cast_error);
    2317             : 
    2318         892 :                 if (cast_error)
    2319         168 :                     return jpbUnknown;
    2320             :             }
    2321         724 :             break;
    2322             : 
    2323           8 :         case jbvBinary:
    2324             :         case jbvArray:
    2325             :         case jbvObject:
    2326           8 :             return jpbUnknown;  /* non-scalars are not comparable */
    2327             : 
    2328           0 :         default:
    2329           0 :             elog(ERROR, "invalid jsonb value type %d", jb1->type);
    2330             :     }
    2331             : 
    2332        4580 :     switch (op)
    2333             :     {
    2334        1196 :         case jpiEqual:
    2335        1196 :             res = (cmp == 0);
    2336        1196 :             break;
    2337           4 :         case jpiNotEqual:
    2338           4 :             res = (cmp != 0);
    2339           4 :             break;
    2340         944 :         case jpiLess:
    2341         944 :             res = (cmp < 0);
    2342         944 :             break;
    2343         956 :         case jpiGreater:
    2344         956 :             res = (cmp > 0);
    2345         956 :             break;
    2346         584 :         case jpiLessOrEqual:
    2347         584 :             res = (cmp <= 0);
    2348         584 :             break;
    2349         896 :         case jpiGreaterOrEqual:
    2350         896 :             res = (cmp >= 0);
    2351         896 :             break;
    2352           0 :         default:
    2353           0 :             elog(ERROR, "unrecognized jsonpath operation: %d", op);
    2354             :             return jpbUnknown;
    2355             :     }
    2356             : 
    2357        4580 :     return res ? jpbTrue : jpbFalse;
    2358             : }
    2359             : 
    2360             : /* Compare two numerics */
    2361             : static int
    2362         824 : compareNumeric(Numeric a, Numeric b)
    2363             : {
    2364         824 :     return DatumGetInt32(DirectFunctionCall2(numeric_cmp,
    2365             :                                              NumericGetDatum(a),
    2366             :                                              NumericGetDatum(b)));
    2367             : }
    2368             : 
    2369             : static JsonbValue *
    2370       91028 : copyJsonbValue(JsonbValue *src)
    2371             : {
    2372       91028 :     JsonbValue *dst = palloc(sizeof(*dst));
    2373             : 
    2374       91028 :     *dst = *src;
    2375             : 
    2376       91028 :     return dst;
    2377             : }
    2378             : 
    2379             : /*
    2380             :  * Execute array subscript expression and convert resulting numeric item to
    2381             :  * the integer type with truncation.
    2382             :  */
    2383             : static JsonPathExecResult
    2384         212 : getArrayIndex(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb,
    2385             :               int32 *index)
    2386             : {
    2387             :     JsonbValue *jbv;
    2388         212 :     JsonValueList found = {0};
    2389         212 :     JsonPathExecResult res = executeItem(cxt, jsp, jb, &found);
    2390             :     Datum       numeric_index;
    2391         208 :     bool        have_error = false;
    2392             : 
    2393         208 :     if (jperIsError(res))
    2394           0 :         return res;
    2395             : 
    2396         408 :     if (JsonValueListLength(&found) != 1 ||
    2397         200 :         !(jbv = getScalar(JsonValueListHead(&found), jbvNumeric)))
    2398          16 :         RETURN_ERROR(ereport(ERROR,
    2399             :                              (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
    2400             :                               errmsg("jsonpath array subscript is not a single numeric value"))));
    2401             : 
    2402         192 :     numeric_index = DirectFunctionCall2(numeric_trunc,
    2403             :                                         NumericGetDatum(jbv->val.numeric),
    2404             :                                         Int32GetDatum(0));
    2405             : 
    2406         192 :     *index = numeric_int4_opt_error(DatumGetNumeric(numeric_index),
    2407             :                                     &have_error);
    2408             : 
    2409         192 :     if (have_error)
    2410          16 :         RETURN_ERROR(ereport(ERROR,
    2411             :                              (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
    2412             :                               errmsg("jsonpath array subscript is out of integer range"))));
    2413             : 
    2414         176 :     return jperOk;
    2415             : }
    2416             : 
    2417             : /* Save base object and its id needed for the execution of .keyvalue(). */
    2418             : static JsonBaseObjectInfo
    2419      168740 : setBaseObject(JsonPathExecContext *cxt, JsonbValue *jbv, int32 id)
    2420             : {
    2421      168740 :     JsonBaseObjectInfo baseObject = cxt->baseObject;
    2422             : 
    2423      168740 :     cxt->baseObject.jbc = jbv->type != jbvBinary ? NULL :
    2424             :         (JsonbContainer *) jbv->val.binary.data;
    2425      168740 :     cxt->baseObject.id = id;
    2426             : 
    2427      168740 :     return baseObject;
    2428             : }
    2429             : 
    2430             : static void
    2431      213128 : JsonValueListAppend(JsonValueList *jvl, JsonbValue *jbv)
    2432             : {
    2433      213128 :     if (jvl->singleton)
    2434             :     {
    2435         656 :         jvl->list = list_make2(jvl->singleton, jbv);
    2436         656 :         jvl->singleton = NULL;
    2437             :     }
    2438      212472 :     else if (!jvl->list)
    2439      211872 :         jvl->singleton = jbv;
    2440             :     else
    2441         600 :         jvl->list = lappend(jvl->list, jbv);
    2442      213128 : }
    2443             : 
    2444             : static int
    2445       85336 : JsonValueListLength(const JsonValueList *jvl)
    2446             : {
    2447       85336 :     return jvl->singleton ? 1 : list_length(jvl->list);
    2448             : }
    2449             : 
    2450             : static bool
    2451          12 : JsonValueListIsEmpty(JsonValueList *jvl)
    2452             : {
    2453          12 :     return !jvl->singleton && list_length(jvl->list) <= 0;
    2454             : }
    2455             : 
    2456             : static JsonbValue *
    2457       85236 : JsonValueListHead(JsonValueList *jvl)
    2458             : {
    2459       85236 :     return jvl->singleton ? jvl->singleton : linitial(jvl->list);
    2460             : }
    2461             : 
    2462             : static List *
    2463         940 : JsonValueListGetList(JsonValueList *jvl)
    2464             : {
    2465         940 :     if (jvl->singleton)
    2466         552 :         return list_make1(jvl->singleton);
    2467             : 
    2468         388 :     return jvl->list;
    2469             : }
    2470             : 
    2471             : static void
    2472      168116 : JsonValueListInitIterator(const JsonValueList *jvl, JsonValueListIterator *it)
    2473             : {
    2474      168116 :     if (jvl->singleton)
    2475             :     {
    2476       92492 :         it->value = jvl->singleton;
    2477       92492 :         it->list = NIL;
    2478       92492 :         it->next = NULL;
    2479             :     }
    2480       75624 :     else if (jvl->list != NIL)
    2481             :     {
    2482         412 :         it->value = (JsonbValue *) linitial(jvl->list);
    2483         412 :         it->list = jvl->list;
    2484         412 :         it->next = list_second_cell(jvl->list);
    2485             :     }
    2486             :     else
    2487             :     {
    2488       75212 :         it->value = NULL;
    2489       75212 :         it->list = NIL;
    2490       75212 :         it->next = NULL;
    2491             :     }
    2492      168116 : }
    2493             : 
    2494             : /*
    2495             :  * Get the next item from the sequence advancing iterator.
    2496             :  */
    2497             : static JsonbValue *
    2498      254588 : JsonValueListNext(const JsonValueList *jvl, JsonValueListIterator *it)
    2499             : {
    2500      254588 :     JsonbValue *result = it->value;
    2501             : 
    2502      254588 :     if (it->next)
    2503             :     {
    2504         712 :         it->value = lfirst(it->next);
    2505         712 :         it->next = lnext(it->list, it->next);
    2506             :     }
    2507             :     else
    2508             :     {
    2509      253876 :         it->value = NULL;
    2510             :     }
    2511             : 
    2512      254588 :     return result;
    2513             : }
    2514             : 
    2515             : /*
    2516             :  * Initialize a binary JsonbValue with the given jsonb container.
    2517             :  */
    2518             : static JsonbValue *
    2519      159320 : JsonbInitBinary(JsonbValue *jbv, Jsonb *jb)
    2520             : {
    2521      159320 :     jbv->type = jbvBinary;
    2522      159320 :     jbv->val.binary.data = &jb->root;
    2523      159320 :     jbv->val.binary.len = VARSIZE_ANY_EXHDR(jb);
    2524             : 
    2525      159320 :     return jbv;
    2526             : }
    2527             : 
    2528             : /*
    2529             :  * Returns jbv* type of JsonbValue. Note, it never returns jbvBinary as is.
    2530             :  */
    2531             : static int
    2532      222692 : JsonbType(JsonbValue *jb)
    2533             : {
    2534      222692 :     int         type = jb->type;
    2535             : 
    2536      222692 :     if (jb->type == jbvBinary)
    2537             :     {
    2538      152372 :         JsonbContainer *jbc = (void *) jb->val.binary.data;
    2539             : 
    2540             :         /* Scalars should be always extracted during jsonpath execution. */
    2541             :         Assert(!JsonContainerIsScalar(jbc));
    2542             : 
    2543      152372 :         if (JsonContainerIsObject(jbc))
    2544      151284 :             type = jbvObject;
    2545        1088 :         else if (JsonContainerIsArray(jbc))
    2546        1088 :             type = jbvArray;
    2547             :         else
    2548           0 :             elog(ERROR, "invalid jsonb container type: 0x%08x", jbc->header);
    2549             :     }
    2550             : 
    2551      222692 :     return type;
    2552             : }
    2553             : 
    2554             : /* Get scalar of given type or NULL on type mismatch */
    2555             : static JsonbValue *
    2556        3420 : getScalar(JsonbValue *scalar, enum jbvType type)
    2557             : {
    2558             :     /* Scalars should be always extracted during jsonpath execution. */
    2559             :     Assert(scalar->type != jbvBinary ||
    2560             :            !JsonContainerIsScalar(scalar->val.binary.data));
    2561             : 
    2562        3420 :     return scalar->type == type ? scalar : NULL;
    2563             : }
    2564             : 
    2565             : /* Construct a JSON array from the item list */
    2566             : static JsonbValue *
    2567          20 : wrapItemsInArray(const JsonValueList *items)
    2568             : {
    2569          20 :     JsonbParseState *ps = NULL;
    2570             :     JsonValueListIterator it;
    2571             :     JsonbValue *jbv;
    2572             : 
    2573          20 :     pushJsonbValue(&ps, WJB_BEGIN_ARRAY, NULL);
    2574             : 
    2575          20 :     JsonValueListInitIterator(items, &it);
    2576          40 :     while ((jbv = JsonValueListNext(items, &it)))
    2577          20 :         pushJsonbValue(&ps, WJB_ELEM, jbv);
    2578             : 
    2579          20 :     return pushJsonbValue(&ps, WJB_END_ARRAY, NULL);
    2580             : }
    2581             : 
    2582             : /* Check if the timezone required for casting from type1 to type2 is used */
    2583             : static void
    2584         252 : checkTimezoneIsUsedForCast(bool useTz, const char *type1, const char *type2)
    2585             : {
    2586         252 :     if (!useTz)
    2587          60 :         ereport(ERROR,
    2588             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    2589             :                  errmsg("cannot convert value from %s to %s without timezone usage",
    2590             :                         type1, type2),
    2591             :                  errhint("Use *_tz() function for timezone support.")));
    2592         192 : }
    2593             : 
    2594             : /* Convert time datum to timetz datum */
    2595             : static Datum
    2596          96 : castTimeToTimeTz(Datum time, bool useTz)
    2597             : {
    2598          96 :     checkTimezoneIsUsedForCast(useTz, "time", "timetz");
    2599             : 
    2600          72 :     return DirectFunctionCall1(time_timetz, time);
    2601             : }
    2602             : 
    2603             : /*---
    2604             :  * Compares 'ts1' and 'ts2' timestamp, assuming that ts1 might be overflowed
    2605             :  * during cast from another datatype.
    2606             :  *
    2607             :  * 'overflow1' specifies overflow of 'ts1' value:
    2608             :  *  0 - no overflow,
    2609             :  * -1 - exceed lower boundary,
    2610             :  *  1 - exceed upper boundary.
    2611             :  */
    2612             : static int
    2613         196 : cmpTimestampWithOverflow(Timestamp ts1, int overflow1, Timestamp ts2)
    2614             : {
    2615             :     /*
    2616             :      * All the timestamps we deal with in jsonpath are produced by
    2617             :      * to_datetime() method.  So, they should be valid.
    2618             :      */
    2619             :     Assert(IS_VALID_TIMESTAMP(ts2));
    2620             : 
    2621             :     /*
    2622             :      * Timestamp, which exceed lower (upper) bound, is always lower (higher)
    2623             :      * than any valid timestamp except minus (plus) infinity.
    2624             :      */
    2625         196 :     if (overflow1)
    2626             :     {
    2627           4 :         if (overflow1 < 0)
    2628             :         {
    2629           0 :             if (TIMESTAMP_IS_NOBEGIN(ts2))
    2630           0 :                 return 1;
    2631             :             else
    2632           0 :                 return -1;
    2633             :         }
    2634           4 :         if (overflow1 > 0)
    2635             :         {
    2636           4 :             if (TIMESTAMP_IS_NOEND(ts2))
    2637           0 :                 return -1;
    2638             :             else
    2639           4 :                 return 1;
    2640             :         }
    2641             :     }
    2642             : 
    2643         192 :     return timestamp_cmp_internal(ts1, ts2);
    2644             : }
    2645             : 
    2646             : /*
    2647             :  * Compare date to timestamptz without throwing overflow error during cast.
    2648             :  */
    2649             : static int
    2650          76 : cmpDateToTimestamp(DateADT date1, Timestamp ts2, bool useTz)
    2651             : {
    2652             :     TimestampTz ts1;
    2653          76 :     int         overflow = 0;
    2654             : 
    2655          76 :     ts1 = date2timestamp_opt_overflow(date1, &overflow);
    2656             : 
    2657          76 :     return cmpTimestampWithOverflow(ts1, overflow, ts2);
    2658             : }
    2659             : 
    2660             : /*
    2661             :  * Compare date to timestamptz without throwing overflow error during cast.
    2662             :  */
    2663             : static int
    2664          60 : cmpDateToTimestampTz(DateADT date1, TimestampTz tstz2, bool useTz)
    2665             : {
    2666             :     TimestampTz tstz1;
    2667          60 :     int         overflow = 0;
    2668             : 
    2669          60 :     checkTimezoneIsUsedForCast(useTz, "date", "timestamptz");
    2670             : 
    2671          48 :     tstz1 = date2timestamptz_opt_overflow(date1, &overflow);
    2672             : 
    2673          48 :     return cmpTimestampWithOverflow(tstz1, overflow, tstz2);
    2674             : }
    2675             : 
    2676             : /*
    2677             :  * Compare timestamp to timestamptz without throwing overflow error during cast.
    2678             :  */
    2679             : static int
    2680          96 : cmpTimestampToTimestampTz(Timestamp ts1, TimestampTz tstz2, bool useTz)
    2681             : {
    2682             :     TimestampTz tstz1;
    2683          96 :     int         overflow = 0;
    2684             : 
    2685          96 :     checkTimezoneIsUsedForCast(useTz, "timestamp", "timestamptz");
    2686             : 
    2687          72 :     tstz1 = timestamp2timestamptz_opt_overflow(ts1, &overflow);
    2688             : 
    2689          72 :     return cmpTimestampWithOverflow(tstz1, overflow, tstz2);
    2690             : }
    2691             : 
    2692             : /*
    2693             :  * Cross-type comparison of two datetime SQL/JSON items.  If items are
    2694             :  * uncomparable *cast_error flag is set, otherwise *cast_error is unset.
    2695             :  * If the cast requires timezone and it is not used, then explicit error is thrown.
    2696             :  */
    2697             : static int
    2698         952 : compareDatetime(Datum val1, Oid typid1, Datum val2, Oid typid2,
    2699             :                 bool useTz, bool *cast_error)
    2700             : {
    2701             :     PGFunction cmpfunc;
    2702             : 
    2703         952 :     *cast_error = false;
    2704             : 
    2705         952 :     switch (typid1)
    2706             :     {
    2707         148 :         case DATEOID:
    2708             :             switch (typid2)
    2709             :             {
    2710          72 :                 case DATEOID:
    2711          72 :                     cmpfunc = date_cmp;
    2712             : 
    2713          72 :                     break;
    2714             : 
    2715          28 :                 case TIMESTAMPOID:
    2716          28 :                     return cmpDateToTimestamp(DatumGetDateADT(val1),
    2717             :                                               DatumGetTimestamp(val2),
    2718             :                                               useTz);
    2719             : 
    2720          24 :                 case TIMESTAMPTZOID:
    2721          24 :                     return cmpDateToTimestampTz(DatumGetDateADT(val1),
    2722             :                                                 DatumGetTimestampTz(val2),
    2723             :                                                 useTz);
    2724             : 
    2725          24 :                 case TIMEOID:
    2726             :                 case TIMETZOID:
    2727          24 :                     *cast_error = true; /* uncomparable types */
    2728          24 :                     return 0;
    2729             : 
    2730           0 :                 default:
    2731           0 :                     elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
    2732             :                          typid2);
    2733             :             }
    2734          72 :             break;
    2735             : 
    2736         168 :         case TIMEOID:
    2737             :             switch (typid2)
    2738             :             {
    2739          72 :                 case TIMEOID:
    2740          72 :                     cmpfunc = time_cmp;
    2741             : 
    2742          72 :                     break;
    2743             : 
    2744          48 :                 case TIMETZOID:
    2745          48 :                     val1 = castTimeToTimeTz(val1, useTz);
    2746          36 :                     cmpfunc = timetz_cmp;
    2747             : 
    2748          36 :                     break;
    2749             : 
    2750          48 :                 case DATEOID:
    2751             :                 case TIMESTAMPOID:
    2752             :                 case TIMESTAMPTZOID:
    2753          48 :                     *cast_error = true; /* uncomparable types */
    2754          48 :                     return 0;
    2755             : 
    2756           0 :                 default:
    2757           0 :                     elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
    2758             :                          typid2);
    2759             :             }
    2760         108 :             break;
    2761             : 
    2762         216 :         case TIMETZOID:
    2763             :             switch (typid2)
    2764             :             {
    2765          48 :                 case TIMEOID:
    2766          48 :                     val2 = castTimeToTimeTz(val2, useTz);
    2767          36 :                     cmpfunc = timetz_cmp;
    2768             : 
    2769          36 :                     break;
    2770             : 
    2771         120 :                 case TIMETZOID:
    2772         120 :                     cmpfunc = timetz_cmp;
    2773             : 
    2774         120 :                     break;
    2775             : 
    2776          48 :                 case DATEOID:
    2777             :                 case TIMESTAMPOID:
    2778             :                 case TIMESTAMPTZOID:
    2779          48 :                     *cast_error = true; /* uncomparable types */
    2780          48 :                     return 0;
    2781             : 
    2782           0 :                 default:
    2783           0 :                     elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
    2784             :                          typid2);
    2785             :             }
    2786         156 :             break;
    2787             : 
    2788         192 :         case TIMESTAMPOID:
    2789             :             switch (typid2)
    2790             :             {
    2791          48 :                 case DATEOID:
    2792          48 :                     return -cmpDateToTimestamp(DatumGetDateADT(val2),
    2793             :                                                DatumGetTimestamp(val1),
    2794             :                                                useTz);
    2795             : 
    2796          72 :                 case TIMESTAMPOID:
    2797          72 :                     cmpfunc = timestamp_cmp;
    2798             : 
    2799          72 :                     break;
    2800             : 
    2801          48 :                 case TIMESTAMPTZOID:
    2802          48 :                     return cmpTimestampToTimestampTz(DatumGetTimestamp(val1),
    2803             :                                                      DatumGetTimestampTz(val2),
    2804             :                                                      useTz);
    2805             : 
    2806          24 :                 case TIMEOID:
    2807             :                 case TIMETZOID:
    2808          24 :                     *cast_error = true; /* uncomparable types */
    2809          24 :                     return 0;
    2810             : 
    2811           0 :                 default:
    2812           0 :                     elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
    2813             :                          typid2);
    2814             :             }
    2815          72 :             break;
    2816             : 
    2817         228 :         case TIMESTAMPTZOID:
    2818             :             switch (typid2)
    2819             :             {
    2820          36 :                 case DATEOID:
    2821          36 :                     return -cmpDateToTimestampTz(DatumGetDateADT(val2),
    2822             :                                                  DatumGetTimestampTz(val1),
    2823             :                                                  useTz);
    2824             : 
    2825          48 :                 case TIMESTAMPOID:
    2826          48 :                     return -cmpTimestampToTimestampTz(DatumGetTimestamp(val2),
    2827             :                                                       DatumGetTimestampTz(val1),
    2828             :                                                       useTz);
    2829             : 
    2830         120 :                 case TIMESTAMPTZOID:
    2831         120 :                     cmpfunc = timestamp_cmp;
    2832             : 
    2833         120 :                     break;
    2834             : 
    2835          24 :                 case TIMEOID:
    2836             :                 case TIMETZOID:
    2837          24 :                     *cast_error = true; /* uncomparable types */
    2838          24 :                     return 0;
    2839             : 
    2840           0 :                 default:
    2841           0 :                     elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
    2842             :                          typid2);
    2843             :             }
    2844         120 :             break;
    2845             : 
    2846           0 :         default:
    2847           0 :             elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u", typid1);
    2848             :     }
    2849             : 
    2850         528 :     if (*cast_error)
    2851           0 :         return 0;               /* cast error */
    2852             : 
    2853         528 :     return DatumGetInt32(DirectFunctionCall2(cmpfunc, val1, val2));
    2854             : }

Generated by: LCOV version 1.13