LCOV - code coverage report
Current view: top level - src/backend/utils/adt - jsonpath_exec.c (source / functions) Hit Total Coverage
Test: PostgreSQL 14devel Lines: 956 1029 92.9 %
Date: 2020-11-27 11:06:40 Functions: 60 64 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 avoid 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        2400 : jsonb_path_query_internal(FunctionCallInfo fcinfo, bool tz)
     396             : {
     397             :     FuncCallContext *funcctx;
     398             :     List       *found;
     399             :     JsonbValue *v;
     400             :     ListCell   *c;
     401             : 
     402        2400 :     if (SRF_IS_FIRSTCALL())
     403             :     {
     404             :         JsonPath   *jp;
     405             :         Jsonb      *jb;
     406             :         MemoryContext oldcontext;
     407             :         Jsonb      *vars;
     408             :         bool        silent;
     409        1240 :         JsonValueList found = {0};
     410             : 
     411        1240 :         funcctx = SRF_FIRSTCALL_INIT();
     412        1240 :         oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
     413             : 
     414        1240 :         jb = PG_GETARG_JSONB_P_COPY(0);
     415        1240 :         jp = PG_GETARG_JSONPATH_P_COPY(1);
     416        1240 :         vars = PG_GETARG_JSONB_P_COPY(2);
     417        1240 :         silent = PG_GETARG_BOOL(3);
     418             : 
     419        1240 :         (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        2144 : jsonb_path_query(PG_FUNCTION_ARGS)
     442             : {
     443        2144 :     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      156264 : 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      156264 :     jspInit(&jsp, path);
     548             : 
     549      156264 :     if (!JsonbExtractScalar(&json->root, &jbv))
     550      155800 :         JsonbInitBinary(&jbv, json);
     551             : 
     552      156264 :     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      156256 :     cxt.vars = vars;
     561      156256 :     cxt.laxMode = (path->header & JSONPATH_LAX) != 0;
     562      156256 :     cxt.ignoreStructuralErrors = cxt.laxMode;
     563      156256 :     cxt.root = &jbv;
     564      156256 :     cxt.current = &jbv;
     565      156256 :     cxt.baseObject.jbc = NULL;
     566      156256 :     cxt.baseObject.id = 0;
     567      156256 :     cxt.lastGeneratedObjectId = vars ? 2 : 1;
     568      156256 :     cxt.innermostArraySize = -1;
     569      156256 :     cxt.throwErrors = throwErrors;
     570      156256 :     cxt.useTz = useTz;
     571             : 
     572      156256 :     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      156220 :     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      476468 : executeItem(JsonPathExecContext *cxt, JsonPathItem *jsp,
     600             :             JsonbValue *jb, JsonValueList *found)
     601             : {
     602      476468 :     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      479124 : executeItemOptUnwrapTarget(JsonPathExecContext *cxt, JsonPathItem *jsp,
     612             :                            JsonbValue *jb, JsonValueList *found, bool unwrap)
     613             : {
     614             :     JsonPathItem elem;
     615      479124 :     JsonPathExecResult res = jperNotFound;
     616             :     JsonBaseObjectInfo baseObject;
     617             : 
     618      479124 :     check_stack_depth();
     619      479124 :     CHECK_FOR_INTERRUPTS();
     620             : 
     621      479124 :     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      165244 :         case jpiRoot:
     691      165244 :             jb = cxt->root;
     692      165244 :             baseObject = setBaseObject(cxt, jb, 0);
     693      165244 :             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 = int64_to_numeric(last);
     846             : 
     847          40 :                 res = executeNextItem(cxt, jsp, &elem,
     848             :                                       lastjbv, found, hasNext);
     849             :             }
     850          40 :             break;
     851             : 
     852          56 :         case jpiAnyKey:
     853          56 :             if (JsonbType(jb) == jbvObject)
     854             :             {
     855          44 :                 bool        hasNext = jspGetNext(jsp, &elem);
     856             : 
     857          44 :                 if (jb->type != jbvBinary)
     858           0 :                     elog(ERROR, "invalid jsonb object type: %d", jb->type);
     859             : 
     860          44 :                 return executeAnyItem
     861             :                     (cxt, hasNext ? &elem : NULL,
     862             :                      jb->val.binary.data, found, 1, 1, 1,
     863          44 :                      false, jspAutoUnwrap(cxt));
     864             :             }
     865          12 :             else if (unwrap && JsonbType(jb) == jbvArray)
     866           0 :                 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
     867          12 :             else if (!jspIgnoreStructuralErrors(cxt))
     868             :             {
     869             :                 Assert(found);
     870           8 :                 RETURN_ERROR(ereport(ERROR,
     871             :                                      (errcode(ERRCODE_SQL_JSON_OBJECT_NOT_FOUND),
     872             :                                       errmsg("jsonpath wildcard member accessor can only be applied to an object"))));
     873             :             }
     874           4 :             break;
     875             : 
     876         112 :         case jpiAdd:
     877         112 :             return executeBinaryArithmExpr(cxt, jsp, jb,
     878             :                                            numeric_add_opt_error, found);
     879             : 
     880          40 :         case jpiSub:
     881          40 :             return executeBinaryArithmExpr(cxt, jsp, jb,
     882             :                                            numeric_sub_opt_error, found);
     883             : 
     884          24 :         case jpiMul:
     885          24 :             return executeBinaryArithmExpr(cxt, jsp, jb,
     886             :                                            numeric_mul_opt_error, found);
     887             : 
     888          44 :         case jpiDiv:
     889          44 :             return executeBinaryArithmExpr(cxt, jsp, jb,
     890             :                                            numeric_div_opt_error, found);
     891             : 
     892           8 :         case jpiMod:
     893           8 :             return executeBinaryArithmExpr(cxt, jsp, jb,
     894             :                                            numeric_mod_opt_error, found);
     895             : 
     896          40 :         case jpiPlus:
     897          40 :             return executeUnaryArithmExpr(cxt, jsp, jb, NULL, found);
     898             : 
     899          84 :         case jpiMinus:
     900          84 :             return executeUnaryArithmExpr(cxt, jsp, jb, numeric_uminus,
     901             :                                           found);
     902             : 
     903       17848 :         case jpiFilter:
     904             :             {
     905             :                 JsonPathBool st;
     906             : 
     907       17848 :                 if (unwrap && JsonbType(jb) == jbvArray)
     908          84 :                     return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
     909             :                                                         false);
     910             : 
     911       17764 :                 jspGetArg(jsp, &elem);
     912       17764 :                 st = executeNestedBoolItem(cxt, &elem, jb);
     913       17700 :                 if (st != jpbTrue)
     914       16400 :                     res = jperNotFound;
     915             :                 else
     916        1300 :                     res = executeNextItem(cxt, jsp, NULL,
     917             :                                           jb, found, true);
     918       17700 :                 break;
     919             :             }
     920             : 
     921         204 :         case jpiAny:
     922             :             {
     923         204 :                 bool        hasNext = jspGetNext(jsp, &elem);
     924             : 
     925             :                 /* first try without any intermediate steps */
     926         204 :                 if (jsp->content.anybounds.first == 0)
     927             :                 {
     928             :                     bool        savedIgnoreStructuralErrors;
     929             : 
     930         112 :                     savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors;
     931         112 :                     cxt->ignoreStructuralErrors = true;
     932         112 :                     res = executeNextItem(cxt, jsp, &elem,
     933             :                                           jb, found, true);
     934         112 :                     cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors;
     935             : 
     936         112 :                     if (res == jperOk && !found)
     937           4 :                         break;
     938             :                 }
     939             : 
     940         200 :                 if (jb->type == jbvBinary)
     941         200 :                     res = executeAnyItem
     942             :                         (cxt, hasNext ? &elem : NULL,
     943             :                          jb->val.binary.data, found,
     944             :                          1,
     945             :                          jsp->content.anybounds.first,
     946             :                          jsp->content.anybounds.last,
     947         200 :                          true, jspAutoUnwrap(cxt));
     948         200 :                 break;
     949             :             }
     950             : 
     951       50564 :         case jpiNull:
     952             :         case jpiBool:
     953             :         case jpiNumeric:
     954             :         case jpiString:
     955             :         case jpiVariable:
     956           4 :             {
     957             :                 JsonbValue  vbuf;
     958             :                 JsonbValue *v;
     959       50564 :                 bool        hasNext = jspGetNext(jsp, &elem);
     960             : 
     961       50564 :                 if (!hasNext && !found)
     962             :                 {
     963           4 :                     res = jperOk;   /* skip evaluation */
     964           4 :                     break;
     965             :                 }
     966             : 
     967       50560 :                 v = hasNext ? &vbuf : palloc(sizeof(*v));
     968             : 
     969       50560 :                 baseObject = cxt->baseObject;
     970       50560 :                 getJsonPathItem(cxt, jsp, v);
     971             : 
     972       50556 :                 res = executeNextItem(cxt, jsp, &elem,
     973             :                                       v, found, hasNext);
     974       50556 :                 cxt->baseObject = baseObject;
     975             :             }
     976       50556 :             break;
     977             : 
     978         140 :         case jpiType:
     979             :             {
     980         140 :                 JsonbValue *jbv = palloc(sizeof(*jbv));
     981             : 
     982         140 :                 jbv->type = jbvString;
     983         140 :                 jbv->val.string.val = pstrdup(JsonbTypeName(jb));
     984         140 :                 jbv->val.string.len = strlen(jbv->val.string.val);
     985             : 
     986         140 :                 res = executeNextItem(cxt, jsp, NULL, jbv,
     987             :                                       found, false);
     988             :             }
     989         140 :             break;
     990             : 
     991          48 :         case jpiSize:
     992             :             {
     993          48 :                 int         size = JsonbArraySize(jb);
     994             : 
     995          48 :                 if (size < 0)
     996             :                 {
     997          32 :                     if (!jspAutoWrap(cxt))
     998             :                     {
     999           8 :                         if (!jspIgnoreStructuralErrors(cxt))
    1000           8 :                             RETURN_ERROR(ereport(ERROR,
    1001             :                                                  (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),
    1002             :                                                   errmsg("jsonpath item method .%s() can only be applied to an array",
    1003             :                                                          jspOperationName(jsp->type)))));
    1004           0 :                         break;
    1005             :                     }
    1006             : 
    1007          24 :                     size = 1;
    1008             :                 }
    1009             : 
    1010          40 :                 jb = palloc(sizeof(*jb));
    1011             : 
    1012          40 :                 jb->type = jbvNumeric;
    1013          40 :                 jb->val.numeric = int64_to_numeric(size);
    1014             : 
    1015          40 :                 res = executeNextItem(cxt, jsp, NULL, jb, found, false);
    1016             :             }
    1017          40 :             break;
    1018             : 
    1019          72 :         case jpiAbs:
    1020          72 :             return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_abs,
    1021             :                                             found);
    1022             : 
    1023          32 :         case jpiFloor:
    1024          32 :             return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_floor,
    1025             :                                             found);
    1026             : 
    1027          68 :         case jpiCeiling:
    1028          68 :             return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_ceil,
    1029             :                                             found);
    1030             : 
    1031          76 :         case jpiDouble:
    1032          36 :             {
    1033             :                 JsonbValue  jbv;
    1034             : 
    1035          76 :                 if (unwrap && JsonbType(jb) == jbvArray)
    1036           4 :                     return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
    1037             :                                                         false);
    1038             : 
    1039          72 :                 if (jb->type == jbvNumeric)
    1040             :                 {
    1041           8 :                     char       *tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
    1042             :                                                                           NumericGetDatum(jb->val.numeric)));
    1043             :                     double      val;
    1044           8 :                     bool        have_error = false;
    1045             : 
    1046           8 :                     val = float8in_internal_opt_error(tmp,
    1047             :                                                       NULL,
    1048             :                                                       "double precision",
    1049             :                                                       tmp,
    1050             :                                                       &have_error);
    1051             : 
    1052           8 :                     if (have_error || isinf(val) || isnan(val))
    1053           4 :                         RETURN_ERROR(ereport(ERROR,
    1054             :                                              (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
    1055             :                                               errmsg("numeric argument of jsonpath item method .%s() is out of range for type double precision",
    1056             :                                                      jspOperationName(jsp->type)))));
    1057           4 :                     res = jperOk;
    1058             :                 }
    1059          64 :                 else if (jb->type == jbvString)
    1060             :                 {
    1061             :                     /* cast string as double */
    1062             :                     double      val;
    1063          32 :                     char       *tmp = pnstrdup(jb->val.string.val,
    1064          32 :                                                jb->val.string.len);
    1065          32 :                     bool        have_error = false;
    1066             : 
    1067          32 :                     val = float8in_internal_opt_error(tmp,
    1068             :                                                       NULL,
    1069             :                                                       "double precision",
    1070             :                                                       tmp,
    1071             :                                                       &have_error);
    1072             : 
    1073          32 :                     if (have_error || isinf(val) || isnan(val))
    1074          28 :                         RETURN_ERROR(ereport(ERROR,
    1075             :                                              (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
    1076             :                                               errmsg("string argument of jsonpath item method .%s() is not a valid representation of a double precision number",
    1077             :                                                      jspOperationName(jsp->type)))));
    1078             : 
    1079           4 :                     jb = &jbv;
    1080           4 :                     jb->type = jbvNumeric;
    1081           4 :                     jb->val.numeric = DatumGetNumeric(DirectFunctionCall1(float8_numeric,
    1082             :                                                                           Float8GetDatum(val)));
    1083           4 :                     res = jperOk;
    1084             :                 }
    1085             : 
    1086          40 :                 if (res == jperNotFound)
    1087          32 :                     RETURN_ERROR(ereport(ERROR,
    1088             :                                          (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
    1089             :                                           errmsg("jsonpath item method .%s() can only be applied to a string or numeric value",
    1090             :                                                  jspOperationName(jsp->type)))));
    1091             : 
    1092           8 :                 res = executeNextItem(cxt, jsp, NULL, jb, found, true);
    1093             :             }
    1094           8 :             break;
    1095             : 
    1096        2148 :         case jpiDatetime:
    1097        2148 :             if (unwrap && JsonbType(jb) == jbvArray)
    1098           4 :                 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
    1099             : 
    1100        2144 :             return executeDateTimeMethod(cxt, jsp, jb, found);
    1101             : 
    1102          60 :         case jpiKeyValue:
    1103          60 :             if (unwrap && JsonbType(jb) == jbvArray)
    1104           4 :                 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
    1105             : 
    1106          56 :             return executeKeyValueMethod(cxt, jsp, jb, found);
    1107             : 
    1108           0 :         default:
    1109           0 :             elog(ERROR, "unrecognized jsonpath item type: %d", jsp->type);
    1110             :     }
    1111             : 
    1112      475572 :     return res;
    1113             : }
    1114             : 
    1115             : /*
    1116             :  * Unwrap current array item and execute jsonpath for each of its elements.
    1117             :  */
    1118             : static JsonPathExecResult
    1119         888 : executeItemUnwrapTargetArray(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1120             :                              JsonbValue *jb, JsonValueList *found,
    1121             :                              bool unwrapElements)
    1122             : {
    1123         888 :     if (jb->type != jbvBinary)
    1124             :     {
    1125             :         Assert(jb->type != jbvArray);
    1126           0 :         elog(ERROR, "invalid jsonb array value type: %d", jb->type);
    1127             :     }
    1128             : 
    1129         888 :     return executeAnyItem
    1130             :         (cxt, jsp, jb->val.binary.data, found, 1, 1, 1,
    1131             :          false, unwrapElements);
    1132             : }
    1133             : 
    1134             : /*
    1135             :  * Execute next jsonpath item if exists.  Otherwise put "v" to the "found"
    1136             :  * list if provided.
    1137             :  */
    1138             : static JsonPathExecResult
    1139      343076 : executeNextItem(JsonPathExecContext *cxt,
    1140             :                 JsonPathItem *cur, JsonPathItem *next,
    1141             :                 JsonbValue *v, JsonValueList *found, bool copy)
    1142             : {
    1143             :     JsonPathItem elem;
    1144             :     bool        hasNext;
    1145             : 
    1146      343076 :     if (!cur)
    1147           0 :         hasNext = next != NULL;
    1148      343076 :     else if (next)
    1149      137960 :         hasNext = jspHasNext(cur);
    1150             :     else
    1151             :     {
    1152      205116 :         next = &elem;
    1153      205116 :         hasNext = jspGetNext(cur, next);
    1154             :     }
    1155             : 
    1156      343076 :     if (hasNext)
    1157      157216 :         return executeItem(cxt, next, v, found);
    1158             : 
    1159      185860 :     if (found)
    1160      149140 :         JsonValueListAppend(found, copy ? copyJsonbValue(v) : v);
    1161             : 
    1162      185860 :     return jperOk;
    1163             : }
    1164             : 
    1165             : /*
    1166             :  * Same as executeItem(), but when "unwrap == true" automatically unwraps
    1167             :  * each array item from the resulting sequence in lax mode.
    1168             :  */
    1169             : static JsonPathExecResult
    1170      162784 : executeItemOptUnwrapResult(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1171             :                            JsonbValue *jb, bool unwrap,
    1172             :                            JsonValueList *found)
    1173             : {
    1174      162784 :     if (unwrap && jspAutoUnwrap(cxt))
    1175             :     {
    1176      100568 :         JsonValueList seq = {0};
    1177             :         JsonValueListIterator it;
    1178      100568 :         JsonPathExecResult res = executeItem(cxt, jsp, jb, &seq);
    1179             :         JsonbValue *item;
    1180             : 
    1181      100552 :         if (jperIsError(res))
    1182          44 :             return res;
    1183             : 
    1184      100508 :         JsonValueListInitIterator(&seq, &it);
    1185      163796 :         while ((item = JsonValueListNext(&seq, &it)))
    1186             :         {
    1187             :             Assert(item->type != jbvArray);
    1188             : 
    1189       63288 :             if (JsonbType(item) == jbvArray)
    1190          36 :                 executeItemUnwrapTargetArray(cxt, NULL, item, found, false);
    1191             :             else
    1192       63252 :                 JsonValueListAppend(found, item);
    1193             :         }
    1194             : 
    1195      100508 :         return jperOk;
    1196             :     }
    1197             : 
    1198       62216 :     return executeItem(cxt, jsp, jb, found);
    1199             : }
    1200             : 
    1201             : /*
    1202             :  * Same as executeItemOptUnwrapResult(), but with error suppression.
    1203             :  */
    1204             : static JsonPathExecResult
    1205      162208 : executeItemOptUnwrapResultNoThrow(JsonPathExecContext *cxt,
    1206             :                                   JsonPathItem *jsp,
    1207             :                                   JsonbValue *jb, bool unwrap,
    1208             :                                   JsonValueList *found)
    1209             : {
    1210             :     JsonPathExecResult res;
    1211      162208 :     bool        throwErrors = cxt->throwErrors;
    1212             : 
    1213      162208 :     cxt->throwErrors = false;
    1214      162208 :     res = executeItemOptUnwrapResult(cxt, jsp, jb, unwrap, found);
    1215      162204 :     cxt->throwErrors = throwErrors;
    1216             : 
    1217      162204 :     return res;
    1218             : }
    1219             : 
    1220             : /* Execute boolean-valued jsonpath expression. */
    1221             : static JsonPathBool
    1222      142192 : executeBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1223             :                 JsonbValue *jb, bool canHaveNext)
    1224             : {
    1225             :     JsonPathItem larg;
    1226             :     JsonPathItem rarg;
    1227             :     JsonPathBool res;
    1228             :     JsonPathBool res2;
    1229             : 
    1230      142192 :     if (!canHaveNext && jspHasNext(jsp))
    1231           0 :         elog(ERROR, "boolean jsonpath item cannot have next item");
    1232             : 
    1233      142192 :     switch (jsp->type)
    1234             :     {
    1235       20252 :         case jpiAnd:
    1236       20252 :             jspGetLeftArg(jsp, &larg);
    1237       20252 :             res = executeBoolItem(cxt, &larg, jb, false);
    1238             : 
    1239       20252 :             if (res == jpbFalse)
    1240       18028 :                 return jpbFalse;
    1241             : 
    1242             :             /*
    1243             :              * SQL/JSON says that we should check second arg in case of
    1244             :              * jperError
    1245             :              */
    1246             : 
    1247        2224 :             jspGetRightArg(jsp, &rarg);
    1248        2224 :             res2 = executeBoolItem(cxt, &rarg, jb, false);
    1249             : 
    1250        2224 :             return res2 == jpbTrue ? res : res2;
    1251             : 
    1252        9444 :         case jpiOr:
    1253        9444 :             jspGetLeftArg(jsp, &larg);
    1254        9444 :             res = executeBoolItem(cxt, &larg, jb, false);
    1255             : 
    1256        9444 :             if (res == jpbTrue)
    1257        1820 :                 return jpbTrue;
    1258             : 
    1259        7624 :             jspGetRightArg(jsp, &rarg);
    1260        7624 :             res2 = executeBoolItem(cxt, &rarg, jb, false);
    1261             : 
    1262        7624 :             return res2 == jpbFalse ? res : res2;
    1263             : 
    1264          72 :         case jpiNot:
    1265          72 :             jspGetArg(jsp, &larg);
    1266             : 
    1267          72 :             res = executeBoolItem(cxt, &larg, jb, false);
    1268             : 
    1269          72 :             if (res == jpbUnknown)
    1270          24 :                 return jpbUnknown;
    1271             : 
    1272          48 :             return res == jpbTrue ? jpbFalse : jpbTrue;
    1273             : 
    1274         140 :         case jpiIsUnknown:
    1275         140 :             jspGetArg(jsp, &larg);
    1276         140 :             res = executeBoolItem(cxt, &larg, jb, false);
    1277         140 :             return res == jpbUnknown ? jpbTrue : jpbFalse;
    1278             : 
    1279       49880 :         case jpiEqual:
    1280             :         case jpiNotEqual:
    1281             :         case jpiLess:
    1282             :         case jpiGreater:
    1283             :         case jpiLessOrEqual:
    1284             :         case jpiGreaterOrEqual:
    1285       49880 :             jspGetLeftArg(jsp, &larg);
    1286       49880 :             jspGetRightArg(jsp, &rarg);
    1287       49880 :             return executePredicate(cxt, jsp, &larg, &rarg, jb, true,
    1288             :                                     executeComparison, cxt);
    1289             : 
    1290          56 :         case jpiStartsWith:     /* 'whole STARTS WITH initial' */
    1291          56 :             jspGetLeftArg(jsp, &larg);  /* 'whole' */
    1292          56 :             jspGetRightArg(jsp, &rarg); /* 'initial' */
    1293          56 :             return executePredicate(cxt, jsp, &larg, &rarg, jb, false,
    1294             :                                     executeStartsWith, NULL);
    1295             : 
    1296         264 :         case jpiLikeRegex:      /* 'expr LIKE_REGEX pattern FLAGS flags' */
    1297             :             {
    1298             :                 /*
    1299             :                  * 'expr' is a sequence-returning expression.  'pattern' is a
    1300             :                  * regex string literal.  SQL/JSON standard requires XQuery
    1301             :                  * regexes, but we use Postgres regexes here.  'flags' is a
    1302             :                  * string literal converted to integer flags at compile-time.
    1303             :                  */
    1304         264 :                 JsonLikeRegexContext lrcxt = {0};
    1305             : 
    1306         264 :                 jspInitByBuffer(&larg, jsp->base,
    1307             :                                 jsp->content.like_regex.expr);
    1308             : 
    1309         264 :                 return executePredicate(cxt, jsp, &larg, NULL, jb, false,
    1310             :                                         executeLikeRegex, &lrcxt);
    1311             :             }
    1312             : 
    1313       62084 :         case jpiExists:
    1314       62084 :             jspGetArg(jsp, &larg);
    1315             : 
    1316       62084 :             if (jspStrictAbsenseOfErrors(cxt))
    1317             :             {
    1318             :                 /*
    1319             :                  * In strict mode we must get a complete list of values to
    1320             :                  * check that there are no errors at all.
    1321             :                  */
    1322          32 :                 JsonValueList vals = {0};
    1323             :                 JsonPathExecResult res =
    1324          32 :                 executeItemOptUnwrapResultNoThrow(cxt, &larg, jb,
    1325             :                                                   false, &vals);
    1326             : 
    1327          32 :                 if (jperIsError(res))
    1328          24 :                     return jpbUnknown;
    1329             : 
    1330           8 :                 return JsonValueListIsEmpty(&vals) ? jpbFalse : jpbTrue;
    1331             :             }
    1332             :             else
    1333             :             {
    1334             :                 JsonPathExecResult res =
    1335       62052 :                 executeItemOptUnwrapResultNoThrow(cxt, &larg, jb,
    1336             :                                                   false, NULL);
    1337             : 
    1338       62052 :                 if (jperIsError(res))
    1339          16 :                     return jpbUnknown;
    1340             : 
    1341       62036 :                 return res == jperOk ? jpbTrue : jpbFalse;
    1342             :             }
    1343             : 
    1344           0 :         default:
    1345           0 :             elog(ERROR, "invalid boolean jsonpath item type: %d", jsp->type);
    1346             :             return jpbUnknown;
    1347             :     }
    1348             : }
    1349             : 
    1350             : /*
    1351             :  * Execute nested (filters etc.) boolean expression pushing current SQL/JSON
    1352             :  * item onto the stack.
    1353             :  */
    1354             : static JsonPathBool
    1355       17764 : executeNestedBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1356             :                       JsonbValue *jb)
    1357             : {
    1358             :     JsonbValue *prev;
    1359             :     JsonPathBool res;
    1360             : 
    1361       17764 :     prev = cxt->current;
    1362       17764 :     cxt->current = jb;
    1363       17764 :     res = executeBoolItem(cxt, jsp, jb, false);
    1364       17700 :     cxt->current = prev;
    1365             : 
    1366       17700 :     return res;
    1367             : }
    1368             : 
    1369             : /*
    1370             :  * Implementation of several jsonpath nodes:
    1371             :  *  - jpiAny (.** accessor),
    1372             :  *  - jpiAnyKey (.* accessor),
    1373             :  *  - jpiAnyArray ([*] accessor)
    1374             :  */
    1375             : static JsonPathExecResult
    1376        1256 : executeAnyItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbContainer *jbc,
    1377             :                JsonValueList *found, uint32 level, uint32 first, uint32 last,
    1378             :                bool ignoreStructuralErrors, bool unwrapNext)
    1379             : {
    1380        1256 :     JsonPathExecResult res = jperNotFound;
    1381             :     JsonbIterator *it;
    1382             :     int32       r;
    1383             :     JsonbValue  v;
    1384             : 
    1385        1256 :     check_stack_depth();
    1386             : 
    1387        1256 :     if (level > last)
    1388          20 :         return res;
    1389             : 
    1390        1236 :     it = JsonbIteratorInit(jbc);
    1391             : 
    1392             :     /*
    1393             :      * Recursively iterate over jsonb objects/arrays
    1394             :      */
    1395        6388 :     while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE)
    1396             :     {
    1397        5536 :         if (r == WJB_KEY)
    1398             :         {
    1399         368 :             r = JsonbIteratorNext(&it, &v, true);
    1400             :             Assert(r == WJB_VALUE);
    1401             :         }
    1402             : 
    1403        5536 :         if (r == WJB_VALUE || r == WJB_ELEM)
    1404             :         {
    1405             : 
    1406        3448 :             if (level >= first ||
    1407           8 :                 (first == PG_UINT32_MAX && last == PG_UINT32_MAX &&
    1408           8 :                  v.type != jbvBinary))  /* leaves only requested */
    1409             :             {
    1410             :                 /* check expression */
    1411        3408 :                 if (jsp)
    1412             :                 {
    1413        2656 :                     if (ignoreStructuralErrors)
    1414             :                     {
    1415             :                         bool        savedIgnoreStructuralErrors;
    1416             : 
    1417         232 :                         savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors;
    1418         232 :                         cxt->ignoreStructuralErrors = true;
    1419         232 :                         res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext);
    1420         232 :                         cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors;
    1421             :                     }
    1422             :                     else
    1423        2424 :                         res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext);
    1424             : 
    1425        2572 :                     if (jperIsError(res))
    1426          44 :                         break;
    1427             : 
    1428        2528 :                     if (res == jperOk && !found)
    1429         216 :                         break;
    1430             :                 }
    1431         752 :                 else if (found)
    1432         736 :                     JsonValueListAppend(found, copyJsonbValue(&v));
    1433             :                 else
    1434          16 :                     return jperOk;
    1435             :             }
    1436             : 
    1437        3088 :             if (level < last && v.type == jbvBinary)
    1438             :             {
    1439         124 :                 res = executeAnyItem
    1440             :                     (cxt, jsp, v.val.binary.data, found,
    1441             :                      level + 1, first, last,
    1442             :                      ignoreStructuralErrors, unwrapNext);
    1443             : 
    1444         124 :                 if (jperIsError(res))
    1445           0 :                     break;
    1446             : 
    1447         124 :                 if (res == jperOk && found == NULL)
    1448          24 :                     break;
    1449             :             }
    1450             :         }
    1451             :     }
    1452             : 
    1453        1136 :     return res;
    1454             : }
    1455             : 
    1456             : /*
    1457             :  * Execute unary or binary predicate.
    1458             :  *
    1459             :  * Predicates have existence semantics, because their operands are item
    1460             :  * sequences.  Pairs of items from the left and right operand's sequences are
    1461             :  * checked.  TRUE returned only if any pair satisfying the condition is found.
    1462             :  * In strict mode, even if the desired pair has already been found, all pairs
    1463             :  * still need to be examined to check the absence of errors.  If any error
    1464             :  * occurs, UNKNOWN (analogous to SQL NULL) is returned.
    1465             :  */
    1466             : static JsonPathBool
    1467       50200 : executePredicate(JsonPathExecContext *cxt, JsonPathItem *pred,
    1468             :                  JsonPathItem *larg, JsonPathItem *rarg, JsonbValue *jb,
    1469             :                  bool unwrapRightArg, JsonPathPredicateCallback exec,
    1470             :                  void *param)
    1471             : {
    1472             :     JsonPathExecResult res;
    1473             :     JsonValueListIterator lseqit;
    1474       50200 :     JsonValueList lseq = {0};
    1475       50200 :     JsonValueList rseq = {0};
    1476             :     JsonbValue *lval;
    1477       50200 :     bool        error = false;
    1478       50200 :     bool        found = false;
    1479             : 
    1480             :     /* Left argument is always auto-unwrapped. */
    1481       50200 :     res = executeItemOptUnwrapResultNoThrow(cxt, larg, jb, true, &lseq);
    1482       50200 :     if (jperIsError(res))
    1483          12 :         return jpbUnknown;
    1484             : 
    1485       50188 :     if (rarg)
    1486             :     {
    1487             :         /* Right argument is conditionally auto-unwrapped. */
    1488       49924 :         res = executeItemOptUnwrapResultNoThrow(cxt, rarg, jb,
    1489             :                                                 unwrapRightArg, &rseq);
    1490       49920 :         if (jperIsError(res))
    1491          36 :             return jpbUnknown;
    1492             :     }
    1493             : 
    1494       50148 :     JsonValueListInitIterator(&lseq, &lseqit);
    1495       64076 :     while ((lval = JsonValueListNext(&lseq, &lseqit)))
    1496             :     {
    1497             :         JsonValueListIterator rseqit;
    1498             :         JsonbValue *rval;
    1499       17320 :         bool        first = true;
    1500             : 
    1501       17320 :         JsonValueListInitIterator(&rseq, &rseqit);
    1502       17320 :         if (rarg)
    1503       17056 :             rval = JsonValueListNext(&rseq, &rseqit);
    1504             :         else
    1505         264 :             rval = NULL;
    1506             : 
    1507             :         /* Loop over right arg sequence or do single pass otherwise */
    1508       26920 :         while (rarg ? (rval != NULL) : first)
    1509             :         {
    1510       12992 :             JsonPathBool res = exec(pred, lval, rval, param);
    1511             : 
    1512       12932 :             if (res == jpbUnknown)
    1513             :             {
    1514         452 :                 if (jspStrictAbsenseOfErrors(cxt))
    1515        3332 :                     return jpbUnknown;
    1516             : 
    1517         436 :                 error = true;
    1518             :             }
    1519       12480 :             else if (res == jpbTrue)
    1520             :             {
    1521        3348 :                 if (!jspStrictAbsenseOfErrors(cxt))
    1522        3316 :                     return jpbTrue;
    1523             : 
    1524          32 :                 found = true;
    1525             :             }
    1526             : 
    1527        9600 :             first = false;
    1528        9600 :             if (rarg)
    1529        9404 :                 rval = JsonValueListNext(&rseq, &rseqit);
    1530             :         }
    1531             :     }
    1532             : 
    1533       46756 :     if (found)                  /* possible only in strict mode */
    1534          12 :         return jpbTrue;
    1535             : 
    1536       46744 :     if (error)                  /* possible only in lax mode */
    1537         416 :         return jpbUnknown;
    1538             : 
    1539       46328 :     return jpbFalse;
    1540             : }
    1541             : 
    1542             : /*
    1543             :  * Execute binary arithmetic expression on singleton numeric operands.
    1544             :  * Array operands are automatically unwrapped in lax mode.
    1545             :  */
    1546             : static JsonPathExecResult
    1547         228 : executeBinaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1548             :                         JsonbValue *jb, BinaryArithmFunc func,
    1549             :                         JsonValueList *found)
    1550             : {
    1551             :     JsonPathExecResult jper;
    1552             :     JsonPathItem elem;
    1553         228 :     JsonValueList lseq = {0};
    1554         228 :     JsonValueList rseq = {0};
    1555             :     JsonbValue *lval;
    1556             :     JsonbValue *rval;
    1557             :     Numeric     res;
    1558             : 
    1559         228 :     jspGetLeftArg(jsp, &elem);
    1560             : 
    1561             :     /*
    1562             :      * XXX: By standard only operands of multiplicative expressions are
    1563             :      * unwrapped.  We extend it to other binary arithmetic expressions too.
    1564             :      */
    1565         228 :     jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &lseq);
    1566         224 :     if (jperIsError(jper))
    1567           0 :         return jper;
    1568             : 
    1569         224 :     jspGetRightArg(jsp, &elem);
    1570             : 
    1571         224 :     jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &rseq);
    1572         220 :     if (jperIsError(jper))
    1573           0 :         return jper;
    1574             : 
    1575         396 :     if (JsonValueListLength(&lseq) != 1 ||
    1576         176 :         !(lval = getScalar(JsonValueListHead(&lseq), jbvNumeric)))
    1577          44 :         RETURN_ERROR(ereport(ERROR,
    1578             :                              (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
    1579             :                               errmsg("left operand of jsonpath operator %s is not a single numeric value",
    1580             :                                      jspOperationName(jsp->type)))));
    1581             : 
    1582         332 :     if (JsonValueListLength(&rseq) != 1 ||
    1583         156 :         !(rval = getScalar(JsonValueListHead(&rseq), jbvNumeric)))
    1584          36 :         RETURN_ERROR(ereport(ERROR,
    1585             :                              (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
    1586             :                               errmsg("right operand of jsonpath operator %s is not a single numeric value",
    1587             :                                      jspOperationName(jsp->type)))));
    1588             : 
    1589         140 :     if (jspThrowErrors(cxt))
    1590             :     {
    1591          52 :         res = func(lval->val.numeric, rval->val.numeric, NULL);
    1592             :     }
    1593             :     else
    1594             :     {
    1595          88 :         bool        error = false;
    1596             : 
    1597          88 :         res = func(lval->val.numeric, rval->val.numeric, &error);
    1598             : 
    1599          88 :         if (error)
    1600           8 :             return jperError;
    1601             :     }
    1602             : 
    1603         116 :     if (!jspGetNext(jsp, &elem) && !found)
    1604           4 :         return jperOk;
    1605             : 
    1606         112 :     lval = palloc(sizeof(*lval));
    1607         112 :     lval->type = jbvNumeric;
    1608         112 :     lval->val.numeric = res;
    1609             : 
    1610         112 :     return executeNextItem(cxt, jsp, &elem, lval, found, false);
    1611             : }
    1612             : 
    1613             : /*
    1614             :  * Execute unary arithmetic expression for each numeric item in its operand's
    1615             :  * sequence.  Array operand is automatically unwrapped in lax mode.
    1616             :  */
    1617             : static JsonPathExecResult
    1618         124 : executeUnaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1619             :                        JsonbValue *jb, PGFunction func, JsonValueList *found)
    1620             : {
    1621             :     JsonPathExecResult jper;
    1622             :     JsonPathExecResult jper2;
    1623             :     JsonPathItem elem;
    1624         124 :     JsonValueList seq = {0};
    1625             :     JsonValueListIterator it;
    1626             :     JsonbValue *val;
    1627             :     bool        hasNext;
    1628             : 
    1629         124 :     jspGetArg(jsp, &elem);
    1630         124 :     jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &seq);
    1631             : 
    1632         120 :     if (jperIsError(jper))
    1633           0 :         return jper;
    1634             : 
    1635         120 :     jper = jperNotFound;
    1636             : 
    1637         120 :     hasNext = jspGetNext(jsp, &elem);
    1638             : 
    1639         120 :     JsonValueListInitIterator(&seq, &it);
    1640         216 :     while ((val = JsonValueListNext(&seq, &it)))
    1641             :     {
    1642         128 :         if ((val = getScalar(val, jbvNumeric)))
    1643             :         {
    1644         100 :             if (!found && !hasNext)
    1645           8 :                 return jperOk;
    1646             :         }
    1647             :         else
    1648             :         {
    1649          28 :             if (!found && !hasNext)
    1650           4 :                 continue;       /* skip non-numerics processing */
    1651             : 
    1652          24 :             RETURN_ERROR(ereport(ERROR,
    1653             :                                  (errcode(ERRCODE_SQL_JSON_NUMBER_NOT_FOUND),
    1654             :                                   errmsg("operand of unary jsonpath operator %s is not a numeric value",
    1655             :                                          jspOperationName(jsp->type)))));
    1656             :         }
    1657             : 
    1658          92 :         if (func)
    1659          56 :             val->val.numeric =
    1660          56 :                 DatumGetNumeric(DirectFunctionCall1(func,
    1661             :                                                     NumericGetDatum(val->val.numeric)));
    1662             : 
    1663          92 :         jper2 = executeNextItem(cxt, jsp, &elem, val, found, false);
    1664             : 
    1665          92 :         if (jperIsError(jper2))
    1666           0 :             return jper2;
    1667             : 
    1668          92 :         if (jper2 == jperOk)
    1669             :         {
    1670          92 :             if (!found)
    1671           0 :                 return jperOk;
    1672          92 :             jper = jperOk;
    1673             :         }
    1674             :     }
    1675             : 
    1676          88 :     return jper;
    1677             : }
    1678             : 
    1679             : /*
    1680             :  * STARTS_WITH predicate callback.
    1681             :  *
    1682             :  * Check if the 'whole' string starts from 'initial' string.
    1683             :  */
    1684             : static JsonPathBool
    1685         116 : executeStartsWith(JsonPathItem *jsp, JsonbValue *whole, JsonbValue *initial,
    1686             :                   void *param)
    1687             : {
    1688         116 :     if (!(whole = getScalar(whole, jbvString)))
    1689          32 :         return jpbUnknown;      /* error */
    1690             : 
    1691          84 :     if (!(initial = getScalar(initial, jbvString)))
    1692           0 :         return jpbUnknown;      /* error */
    1693             : 
    1694          84 :     if (whole->val.string.len >= initial->val.string.len &&
    1695         120 :         !memcmp(whole->val.string.val,
    1696          60 :                 initial->val.string.val,
    1697          60 :                 initial->val.string.len))
    1698          36 :         return jpbTrue;
    1699             : 
    1700          48 :     return jpbFalse;
    1701             : }
    1702             : 
    1703             : /*
    1704             :  * LIKE_REGEX predicate callback.
    1705             :  *
    1706             :  * Check if the string matches regex pattern.
    1707             :  */
    1708             : static JsonPathBool
    1709         264 : executeLikeRegex(JsonPathItem *jsp, JsonbValue *str, JsonbValue *rarg,
    1710             :                  void *param)
    1711             : {
    1712         264 :     JsonLikeRegexContext *cxt = param;
    1713             : 
    1714         264 :     if (!(str = getScalar(str, jbvString)))
    1715          80 :         return jpbUnknown;
    1716             : 
    1717             :     /* Cache regex text and converted flags. */
    1718         184 :     if (!cxt->regex)
    1719             :     {
    1720         184 :         cxt->regex =
    1721         184 :             cstring_to_text_with_len(jsp->content.like_regex.pattern,
    1722             :                                      jsp->content.like_regex.patternlen);
    1723         184 :         cxt->cflags = jspConvertRegexFlags(jsp->content.like_regex.flags);
    1724             :     }
    1725             : 
    1726         184 :     if (RE_compile_and_execute(cxt->regex, str->val.string.val,
    1727             :                                str->val.string.len,
    1728             :                                cxt->cflags, DEFAULT_COLLATION_OID, 0, NULL))
    1729          68 :         return jpbTrue;
    1730             : 
    1731         116 :     return jpbFalse;
    1732             : }
    1733             : 
    1734             : /*
    1735             :  * Execute numeric item methods (.abs(), .floor(), .ceil()) using the specified
    1736             :  * user function 'func'.
    1737             :  */
    1738             : static JsonPathExecResult
    1739         172 : executeNumericItemMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1740             :                          JsonbValue *jb, bool unwrap, PGFunction func,
    1741             :                          JsonValueList *found)
    1742             : {
    1743             :     JsonPathItem next;
    1744             :     Datum       datum;
    1745             : 
    1746         172 :     if (unwrap && JsonbType(jb) == jbvArray)
    1747           0 :         return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
    1748             : 
    1749         172 :     if (!(jb = getScalar(jb, jbvNumeric)))
    1750          24 :         RETURN_ERROR(ereport(ERROR,
    1751             :                              (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
    1752             :                               errmsg("jsonpath item method .%s() can only be applied to a numeric value",
    1753             :                                      jspOperationName(jsp->type)))));
    1754             : 
    1755         148 :     datum = DirectFunctionCall1(func, NumericGetDatum(jb->val.numeric));
    1756             : 
    1757         148 :     if (!jspGetNext(jsp, &next) && !found)
    1758           0 :         return jperOk;
    1759             : 
    1760         148 :     jb = palloc(sizeof(*jb));
    1761         148 :     jb->type = jbvNumeric;
    1762         148 :     jb->val.numeric = DatumGetNumeric(datum);
    1763             : 
    1764         148 :     return executeNextItem(cxt, jsp, &next, jb, found, false);
    1765             : }
    1766             : 
    1767             : /*
    1768             :  * Implementation of the .datetime() method.
    1769             :  *
    1770             :  * Converts a string into a date/time value. The actual type is determined at run time.
    1771             :  * If an argument is provided, this argument is used as a template string.
    1772             :  * Otherwise, the first fitting ISO format is selected.
    1773             :  */
    1774             : static JsonPathExecResult
    1775        2144 : executeDateTimeMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1776             :                       JsonbValue *jb, JsonValueList *found)
    1777             : {
    1778             :     JsonbValue  jbvbuf;
    1779             :     Datum       value;
    1780             :     text       *datetime;
    1781             :     Oid         collid;
    1782             :     Oid         typid;
    1783        2144 :     int32       typmod = -1;
    1784        2144 :     int         tz = 0;
    1785             :     bool        hasNext;
    1786        2144 :     JsonPathExecResult res = jperNotFound;
    1787             :     JsonPathItem elem;
    1788             : 
    1789        2144 :     if (!(jb = getScalar(jb, jbvString)))
    1790          20 :         RETURN_ERROR(ereport(ERROR,
    1791             :                              (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
    1792             :                               errmsg("jsonpath item method .%s() can only be applied to a string",
    1793             :                                      jspOperationName(jsp->type)))));
    1794             : 
    1795        2124 :     datetime = cstring_to_text_with_len(jb->val.string.val,
    1796             :                                         jb->val.string.len);
    1797             : 
    1798             :     /*
    1799             :      * At some point we might wish to have callers supply the collation to
    1800             :      * use, but right now it's unclear that they'd be able to do better than
    1801             :      * DEFAULT_COLLATION_OID anyway.
    1802             :      */
    1803        2124 :     collid = DEFAULT_COLLATION_OID;
    1804             : 
    1805        2124 :     if (jsp->content.arg)
    1806             :     {
    1807             :         text       *template;
    1808             :         char       *template_str;
    1809             :         int         template_len;
    1810        1100 :         bool        have_error = false;
    1811             : 
    1812        1100 :         jspGetArg(jsp, &elem);
    1813             : 
    1814        1100 :         if (elem.type != jpiString)
    1815           0 :             elog(ERROR, "invalid jsonpath item type for .datetime() argument");
    1816             : 
    1817        1100 :         template_str = jspGetString(&elem, &template_len);
    1818             : 
    1819        1100 :         template = cstring_to_text_with_len(template_str,
    1820             :                                             template_len);
    1821             : 
    1822        1100 :         value = parse_datetime(datetime, template, collid, true,
    1823             :                                &typid, &typmod, &tz,
    1824        1100 :                                jspThrowErrors(cxt) ? NULL : &have_error);
    1825             : 
    1826        1060 :         if (have_error)
    1827           0 :             res = jperError;
    1828             :         else
    1829        1060 :             res = jperOk;
    1830             :     }
    1831             :     else
    1832             :     {
    1833             :         /*
    1834             :          * According to SQL/JSON standard enumerate ISO formats for: date,
    1835             :          * timetz, time, timestamptz, timestamp.
    1836             :          *
    1837             :          * We also support ISO 8601 for timestamps, because to_json[b]()
    1838             :          * functions use this format.
    1839             :          */
    1840             :         static const char *fmt_str[] =
    1841             :         {
    1842             :             "yyyy-mm-dd",
    1843             :             "HH24:MI:SSTZH:TZM",
    1844             :             "HH24:MI:SSTZH",
    1845             :             "HH24:MI:SS",
    1846             :             "yyyy-mm-dd HH24:MI:SSTZH:TZM",
    1847             :             "yyyy-mm-dd HH24:MI:SSTZH",
    1848             :             "yyyy-mm-dd HH24:MI:SS",
    1849             :             "yyyy-mm-dd\"T\"HH24:MI:SSTZH:TZM",
    1850             :             "yyyy-mm-dd\"T\"HH24:MI:SSTZH",
    1851             :             "yyyy-mm-dd\"T\"HH24:MI:SS"
    1852             :         };
    1853             : 
    1854             :         /* cache for format texts */
    1855             :         static text *fmt_txt[lengthof(fmt_str)] = {0};
    1856             :         int         i;
    1857             : 
    1858             :         /* loop until datetime format fits */
    1859        4552 :         for (i = 0; i < lengthof(fmt_str); i++)
    1860             :         {
    1861        4544 :             bool        have_error = false;
    1862             : 
    1863        4544 :             if (!fmt_txt[i])
    1864             :             {
    1865             :                 MemoryContext oldcxt =
    1866          40 :                 MemoryContextSwitchTo(TopMemoryContext);
    1867             : 
    1868          40 :                 fmt_txt[i] = cstring_to_text(fmt_str[i]);
    1869          40 :                 MemoryContextSwitchTo(oldcxt);
    1870             :             }
    1871             : 
    1872        4544 :             value = parse_datetime(datetime, fmt_txt[i], collid, true,
    1873             :                                    &typid, &typmod, &tz,
    1874             :                                    &have_error);
    1875             : 
    1876        4544 :             if (!have_error)
    1877             :             {
    1878        1016 :                 res = jperOk;
    1879        1016 :                 break;
    1880             :             }
    1881             :         }
    1882             : 
    1883        1024 :         if (res == jperNotFound)
    1884           8 :             RETURN_ERROR(ereport(ERROR,
    1885             :                                  (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
    1886             :                                   errmsg("datetime format is not recognized: \"%s\"",
    1887             :                                          text_to_cstring(datetime)),
    1888             :                                   errhint("Use a datetime template argument to specify the input data format."))));
    1889             :     }
    1890             : 
    1891        2076 :     pfree(datetime);
    1892             : 
    1893        2076 :     if (jperIsError(res))
    1894           0 :         return res;
    1895             : 
    1896        2076 :     hasNext = jspGetNext(jsp, &elem);
    1897             : 
    1898        2076 :     if (!hasNext && !found)
    1899           4 :         return res;
    1900             : 
    1901        2072 :     jb = hasNext ? &jbvbuf : palloc(sizeof(*jb));
    1902             : 
    1903        2072 :     jb->type = jbvDatetime;
    1904        2072 :     jb->val.datetime.value = value;
    1905        2072 :     jb->val.datetime.typid = typid;
    1906        2072 :     jb->val.datetime.typmod = typmod;
    1907        2072 :     jb->val.datetime.tz = tz;
    1908             : 
    1909        2072 :     return executeNextItem(cxt, jsp, &elem, jb, found, hasNext);
    1910             : }
    1911             : 
    1912             : /*
    1913             :  * Implementation of .keyvalue() method.
    1914             :  *
    1915             :  * .keyvalue() method returns a sequence of object's key-value pairs in the
    1916             :  * following format: '{ "key": key, "value": value, "id": id }'.
    1917             :  *
    1918             :  * "id" field is an object identifier which is constructed from the two parts:
    1919             :  * base object id and its binary offset in base object's jsonb:
    1920             :  * id = 10000000000 * base_object_id + obj_offset_in_base_object
    1921             :  *
    1922             :  * 10000000000 (10^10) -- is a first round decimal number greater than 2^32
    1923             :  * (maximal offset in jsonb).  Decimal multiplier is used here to improve the
    1924             :  * readability of identifiers.
    1925             :  *
    1926             :  * Base object is usually a root object of the path: context item '$' or path
    1927             :  * variable '$var', literals can't produce objects for now.  But if the path
    1928             :  * contains generated objects (.keyvalue() itself, for example), then they
    1929             :  * become base object for the subsequent .keyvalue().
    1930             :  *
    1931             :  * Id of '$' is 0. Id of '$var' is its ordinal (positive) number in the list
    1932             :  * of variables (see getJsonPathVariable()).  Ids for generated objects
    1933             :  * are assigned using global counter JsonPathExecContext.lastGeneratedObjectId.
    1934             :  */
    1935             : static JsonPathExecResult
    1936          56 : executeKeyValueMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
    1937             :                       JsonbValue *jb, JsonValueList *found)
    1938             : {
    1939          56 :     JsonPathExecResult res = jperNotFound;
    1940             :     JsonPathItem next;
    1941             :     JsonbContainer *jbc;
    1942             :     JsonbValue  key;
    1943             :     JsonbValue  val;
    1944             :     JsonbValue  idval;
    1945             :     JsonbValue  keystr;
    1946             :     JsonbValue  valstr;
    1947             :     JsonbValue  idstr;
    1948             :     JsonbIterator *it;
    1949             :     JsonbIteratorToken tok;
    1950             :     int64       id;
    1951             :     bool        hasNext;
    1952             : 
    1953          56 :     if (JsonbType(jb) != jbvObject || jb->type != jbvBinary)
    1954          16 :         RETURN_ERROR(ereport(ERROR,
    1955             :                              (errcode(ERRCODE_SQL_JSON_OBJECT_NOT_FOUND),
    1956             :                               errmsg("jsonpath item method .%s() can only be applied to an object",
    1957             :                                      jspOperationName(jsp->type)))));
    1958             : 
    1959          40 :     jbc = jb->val.binary.data;
    1960             : 
    1961          40 :     if (!JsonContainerSize(jbc))
    1962          12 :         return jperNotFound;    /* no key-value pairs */
    1963             : 
    1964          28 :     hasNext = jspGetNext(jsp, &next);
    1965             : 
    1966          28 :     keystr.type = jbvString;
    1967          28 :     keystr.val.string.val = "key";
    1968          28 :     keystr.val.string.len = 3;
    1969             : 
    1970          28 :     valstr.type = jbvString;
    1971          28 :     valstr.val.string.val = "value";
    1972          28 :     valstr.val.string.len = 5;
    1973             : 
    1974          28 :     idstr.type = jbvString;
    1975          28 :     idstr.val.string.val = "id";
    1976          28 :     idstr.val.string.len = 2;
    1977             : 
    1978             :     /* construct object id from its base object and offset inside that */
    1979          28 :     id = jb->type != jbvBinary ? 0 :
    1980          28 :         (int64) ((char *) jbc - (char *) cxt->baseObject.jbc);
    1981          28 :     id += (int64) cxt->baseObject.id * INT64CONST(10000000000);
    1982             : 
    1983          28 :     idval.type = jbvNumeric;
    1984          28 :     idval.val.numeric = int64_to_numeric(id);
    1985             : 
    1986          28 :     it = JsonbIteratorInit(jbc);
    1987             : 
    1988         112 :     while ((tok = JsonbIteratorNext(&it, &key, true)) != WJB_DONE)
    1989             :     {
    1990             :         JsonBaseObjectInfo baseObject;
    1991             :         JsonbValue  obj;
    1992             :         JsonbParseState *ps;
    1993             :         JsonbValue *keyval;
    1994             :         Jsonb      *jsonb;
    1995             : 
    1996          92 :         if (tok != WJB_KEY)
    1997          48 :             continue;
    1998             : 
    1999          44 :         res = jperOk;
    2000             : 
    2001          44 :         if (!hasNext && !found)
    2002           8 :             break;
    2003             : 
    2004          40 :         tok = JsonbIteratorNext(&it, &val, true);
    2005             :         Assert(tok == WJB_VALUE);
    2006             : 
    2007          40 :         ps = NULL;
    2008          40 :         pushJsonbValue(&ps, WJB_BEGIN_OBJECT, NULL);
    2009             : 
    2010          40 :         pushJsonbValue(&ps, WJB_KEY, &keystr);
    2011          40 :         pushJsonbValue(&ps, WJB_VALUE, &key);
    2012             : 
    2013          40 :         pushJsonbValue(&ps, WJB_KEY, &valstr);
    2014          40 :         pushJsonbValue(&ps, WJB_VALUE, &val);
    2015             : 
    2016          40 :         pushJsonbValue(&ps, WJB_KEY, &idstr);
    2017          40 :         pushJsonbValue(&ps, WJB_VALUE, &idval);
    2018             : 
    2019          40 :         keyval = pushJsonbValue(&ps, WJB_END_OBJECT, NULL);
    2020             : 
    2021          40 :         jsonb = JsonbValueToJsonb(keyval);
    2022             : 
    2023          40 :         JsonbInitBinary(&obj, jsonb);
    2024             : 
    2025          40 :         baseObject = setBaseObject(cxt, &obj, cxt->lastGeneratedObjectId++);
    2026             : 
    2027          40 :         res = executeNextItem(cxt, jsp, &next, &obj, found, true);
    2028             : 
    2029          40 :         cxt->baseObject = baseObject;
    2030             : 
    2031          40 :         if (jperIsError(res))
    2032           0 :             return res;
    2033             : 
    2034          40 :         if (res == jperOk && !found)
    2035           4 :             break;
    2036             :     }
    2037             : 
    2038          28 :     return res;
    2039             : }
    2040             : 
    2041             : /*
    2042             :  * Convert boolean execution status 'res' to a boolean JSON item and execute
    2043             :  * next jsonpath.
    2044             :  */
    2045             : static JsonPathExecResult
    2046       84672 : appendBoolResult(JsonPathExecContext *cxt, JsonPathItem *jsp,
    2047             :                  JsonValueList *found, JsonPathBool res)
    2048             : {
    2049             :     JsonPathItem next;
    2050             :     JsonbValue  jbv;
    2051             : 
    2052       84672 :     if (!jspGetNext(jsp, &next) && !found)
    2053           4 :         return jperOk;          /* found singleton boolean value */
    2054             : 
    2055       84668 :     if (res == jpbUnknown)
    2056             :     {
    2057          20 :         jbv.type = jbvNull;
    2058             :     }
    2059             :     else
    2060             :     {
    2061       84648 :         jbv.type = jbvBool;
    2062       84648 :         jbv.val.boolean = res == jpbTrue;
    2063             :     }
    2064             : 
    2065       84668 :     return executeNextItem(cxt, jsp, &next, &jbv, found, true);
    2066             : }
    2067             : 
    2068             : /*
    2069             :  * Convert jsonpath's scalar or variable node to actual jsonb value.
    2070             :  *
    2071             :  * If node is a variable then its id returned, otherwise 0 returned.
    2072             :  */
    2073             : static void
    2074       50560 : getJsonPathItem(JsonPathExecContext *cxt, JsonPathItem *item,
    2075             :                 JsonbValue *value)
    2076             : {
    2077       50560 :     switch (item->type)
    2078             :     {
    2079        7880 :         case jpiNull:
    2080        7880 :             value->type = jbvNull;
    2081        7880 :             break;
    2082         960 :         case jpiBool:
    2083         960 :             value->type = jbvBool;
    2084         960 :             value->val.boolean = jspGetBool(item);
    2085         960 :             break;
    2086       16552 :         case jpiNumeric:
    2087       16552 :             value->type = jbvNumeric;
    2088       16552 :             value->val.numeric = jspGetNumeric(item);
    2089       16552 :             break;
    2090       21684 :         case jpiString:
    2091       21684 :             value->type = jbvString;
    2092       43368 :             value->val.string.val = jspGetString(item,
    2093       21684 :                                                  &value->val.string.len);
    2094       21684 :             break;
    2095        3484 :         case jpiVariable:
    2096        3484 :             getJsonPathVariable(cxt, item, cxt->vars, value);
    2097        3480 :             return;
    2098           0 :         default:
    2099           0 :             elog(ERROR, "unexpected jsonpath item type");
    2100             :     }
    2101             : }
    2102             : 
    2103             : /*
    2104             :  * Get the value of variable passed to jsonpath executor
    2105             :  */
    2106             : static void
    2107        3484 : getJsonPathVariable(JsonPathExecContext *cxt, JsonPathItem *variable,
    2108             :                     Jsonb *vars, JsonbValue *value)
    2109             : {
    2110             :     char       *varName;
    2111             :     int         varNameLength;
    2112             :     JsonbValue  tmp;
    2113             :     JsonbValue *v;
    2114             : 
    2115        3484 :     if (!vars)
    2116             :     {
    2117           0 :         value->type = jbvNull;
    2118           0 :         return;
    2119             :     }
    2120             : 
    2121             :     Assert(variable->type == jpiVariable);
    2122        3484 :     varName = jspGetString(variable, &varNameLength);
    2123        3484 :     tmp.type = jbvString;
    2124        3484 :     tmp.val.string.val = varName;
    2125        3484 :     tmp.val.string.len = varNameLength;
    2126             : 
    2127        3484 :     v = findJsonbValueFromContainer(&vars->root, JB_FOBJECT, &tmp);
    2128             : 
    2129        3484 :     if (v)
    2130             :     {
    2131        3480 :         *value = *v;
    2132        3480 :         pfree(v);
    2133             :     }
    2134             :     else
    2135             :     {
    2136           4 :         ereport(ERROR,
    2137             :                 (errcode(ERRCODE_UNDEFINED_OBJECT),
    2138             :                  errmsg("could not find jsonpath variable \"%s\"",
    2139             :                         pnstrdup(varName, varNameLength))));
    2140             :     }
    2141             : 
    2142        3480 :     JsonbInitBinary(&tmp, vars);
    2143        3480 :     setBaseObject(cxt, &tmp, 1);
    2144             : }
    2145             : 
    2146             : /**************** Support functions for JsonPath execution *****************/
    2147             : 
    2148             : /*
    2149             :  * Returns the size of an array item, or -1 if item is not an array.
    2150             :  */
    2151             : static int
    2152         232 : JsonbArraySize(JsonbValue *jb)
    2153             : {
    2154             :     Assert(jb->type != jbvArray);
    2155             : 
    2156         232 :     if (jb->type == jbvBinary)
    2157             :     {
    2158         204 :         JsonbContainer *jbc = jb->val.binary.data;
    2159             : 
    2160         204 :         if (JsonContainerIsArray(jbc) && !JsonContainerIsScalar(jbc))
    2161         196 :             return JsonContainerSize(jbc);
    2162             :     }
    2163             : 
    2164          36 :     return -1;
    2165             : }
    2166             : 
    2167             : /* Comparison predicate callback. */
    2168             : static JsonPathBool
    2169       12612 : executeComparison(JsonPathItem *cmp, JsonbValue *lv, JsonbValue *rv, void *p)
    2170             : {
    2171       12612 :     JsonPathExecContext *cxt = (JsonPathExecContext *) p;
    2172             : 
    2173       12612 :     return compareItems(cmp->type, lv, rv, cxt->useTz);
    2174             : }
    2175             : 
    2176             : /*
    2177             :  * Perform per-byte comparison of two strings.
    2178             :  */
    2179             : static int
    2180        2304 : binaryCompareStrings(const char *s1, int len1,
    2181             :                      const char *s2, int len2)
    2182             : {
    2183             :     int         cmp;
    2184             : 
    2185        2304 :     cmp = memcmp(s1, s2, Min(len1, len2));
    2186             : 
    2187        2304 :     if (cmp != 0)
    2188        1312 :         return cmp;
    2189             : 
    2190         992 :     if (len1 == len2)
    2191         192 :         return 0;
    2192             : 
    2193         800 :     return len1 < len2 ? -1 : 1;
    2194             : }
    2195             : 
    2196             : /*
    2197             :  * Compare two strings in the current server encoding using Unicode codepoint
    2198             :  * collation.
    2199             :  */
    2200             : static int
    2201        2304 : compareStrings(const char *mbstr1, int mblen1,
    2202             :                const char *mbstr2, int mblen2)
    2203             : {
    2204        4608 :     if (GetDatabaseEncoding() == PG_SQL_ASCII ||
    2205        2304 :         GetDatabaseEncoding() == PG_UTF8)
    2206             :     {
    2207             :         /*
    2208             :          * It's known property of UTF-8 strings that their per-byte comparison
    2209             :          * result matches codepoints comparison result.  ASCII can be
    2210             :          * considered as special case of UTF-8.
    2211             :          */
    2212        2304 :         return binaryCompareStrings(mbstr1, mblen1, mbstr2, mblen2);
    2213             :     }
    2214             :     else
    2215             :     {
    2216             :         char       *utf8str1,
    2217             :                    *utf8str2;
    2218             :         int         cmp,
    2219             :                     utf8len1,
    2220             :                     utf8len2;
    2221             : 
    2222             :         /*
    2223             :          * We have to convert other encodings to UTF-8 first, then compare.
    2224             :          * Input strings may be not null-terminated and pg_server_to_any() may
    2225             :          * return them "as is".  So, use strlen() only if there is real
    2226             :          * conversion.
    2227             :          */
    2228           0 :         utf8str1 = pg_server_to_any(mbstr1, mblen1, PG_UTF8);
    2229           0 :         utf8str2 = pg_server_to_any(mbstr2, mblen2, PG_UTF8);
    2230           0 :         utf8len1 = (mbstr1 == utf8str1) ? mblen1 : strlen(utf8str1);
    2231           0 :         utf8len2 = (mbstr2 == utf8str2) ? mblen2 : strlen(utf8str2);
    2232             : 
    2233           0 :         cmp = binaryCompareStrings(utf8str1, utf8len1, utf8str2, utf8len2);
    2234             : 
    2235             :         /*
    2236             :          * If pg_server_to_any() did no real conversion, then we actually
    2237             :          * compared original strings.  So, we already done.
    2238             :          */
    2239           0 :         if (mbstr1 == utf8str1 && mbstr2 == utf8str2)
    2240           0 :             return cmp;
    2241             : 
    2242             :         /* Free memory if needed */
    2243           0 :         if (mbstr1 != utf8str1)
    2244           0 :             pfree(utf8str1);
    2245           0 :         if (mbstr2 != utf8str2)
    2246           0 :             pfree(utf8str2);
    2247             : 
    2248             :         /*
    2249             :          * When all Unicode codepoints are equal, return result of binary
    2250             :          * comparison.  In some edge cases, same characters may have different
    2251             :          * representations in encoding.  Then our behavior could diverge from
    2252             :          * standard.  However, that allow us to do simple binary comparison
    2253             :          * for "==" operator, which is performance critical in typical cases.
    2254             :          * In future to implement strict standard conformance, we can do
    2255             :          * normalization of input JSON strings.
    2256             :          */
    2257           0 :         if (cmp == 0)
    2258           0 :             return binaryCompareStrings(mbstr1, mblen1, mbstr2, mblen2);
    2259             :         else
    2260           0 :             return cmp;
    2261             :     }
    2262             : }
    2263             : 
    2264             : /*
    2265             :  * Compare two SQL/JSON items using comparison operation 'op'.
    2266             :  */
    2267             : static JsonPathBool
    2268       12612 : compareItems(int32 op, JsonbValue *jb1, JsonbValue *jb2, bool useTz)
    2269             : {
    2270             :     int         cmp;
    2271             :     bool        res;
    2272             : 
    2273       12612 :     if (jb1->type != jb2->type)
    2274             :     {
    2275        2760 :         if (jb1->type == jbvNull || jb2->type == jbvNull)
    2276             : 
    2277             :             /*
    2278             :              * Equality and order comparison of nulls to non-nulls returns
    2279             :              * always false, but inequality comparison returns true.
    2280             :              */
    2281        2596 :             return op == jpiNotEqual ? jpbTrue : jpbFalse;
    2282             : 
    2283             :         /* Non-null items of different types are not comparable. */
    2284         164 :         return jpbUnknown;
    2285             :     }
    2286             : 
    2287        9852 :     switch (jb1->type)
    2288             :     {
    2289         124 :         case jbvNull:
    2290         124 :             cmp = 0;
    2291         124 :             break;
    2292         604 :         case jbvBool:
    2293         868 :             cmp = jb1->val.boolean == jb2->val.boolean ? 0 :
    2294         264 :                 jb1->val.boolean ? 1 : -1;
    2295         604 :             break;
    2296         824 :         case jbvNumeric:
    2297         824 :             cmp = compareNumeric(jb1->val.numeric, jb2->val.numeric);
    2298         824 :             break;
    2299        7340 :         case jbvString:
    2300        7340 :             if (op == jpiEqual)
    2301        5036 :                 return jb1->val.string.len != jb2->val.string.len ||
    2302        5736 :                     memcmp(jb1->val.string.val,
    2303        2868 :                            jb2->val.string.val,
    2304        5036 :                            jb1->val.string.len) ? jpbFalse : jpbTrue;
    2305             : 
    2306        4608 :             cmp = compareStrings(jb1->val.string.val, jb1->val.string.len,
    2307        2304 :                                  jb2->val.string.val, jb2->val.string.len);
    2308        2304 :             break;
    2309         952 :         case jbvDatetime:
    2310         724 :             {
    2311             :                 bool        cast_error;
    2312             : 
    2313         952 :                 cmp = compareDatetime(jb1->val.datetime.value,
    2314             :                                       jb1->val.datetime.typid,
    2315             :                                       jb2->val.datetime.value,
    2316             :                                       jb2->val.datetime.typid,
    2317             :                                       useTz,
    2318             :                                       &cast_error);
    2319             : 
    2320         892 :                 if (cast_error)
    2321         168 :                     return jpbUnknown;
    2322             :             }
    2323         724 :             break;
    2324             : 
    2325           8 :         case jbvBinary:
    2326             :         case jbvArray:
    2327             :         case jbvObject:
    2328           8 :             return jpbUnknown;  /* non-scalars are not comparable */
    2329             : 
    2330           0 :         default:
    2331           0 :             elog(ERROR, "invalid jsonb value type %d", jb1->type);
    2332             :     }
    2333             : 
    2334        4580 :     switch (op)
    2335             :     {
    2336        1196 :         case jpiEqual:
    2337        1196 :             res = (cmp == 0);
    2338        1196 :             break;
    2339           4 :         case jpiNotEqual:
    2340           4 :             res = (cmp != 0);
    2341           4 :             break;
    2342         944 :         case jpiLess:
    2343         944 :             res = (cmp < 0);
    2344         944 :             break;
    2345         956 :         case jpiGreater:
    2346         956 :             res = (cmp > 0);
    2347         956 :             break;
    2348         584 :         case jpiLessOrEqual:
    2349         584 :             res = (cmp <= 0);
    2350         584 :             break;
    2351         896 :         case jpiGreaterOrEqual:
    2352         896 :             res = (cmp >= 0);
    2353         896 :             break;
    2354           0 :         default:
    2355           0 :             elog(ERROR, "unrecognized jsonpath operation: %d", op);
    2356             :             return jpbUnknown;
    2357             :     }
    2358             : 
    2359        4580 :     return res ? jpbTrue : jpbFalse;
    2360             : }
    2361             : 
    2362             : /* Compare two numerics */
    2363             : static int
    2364         824 : compareNumeric(Numeric a, Numeric b)
    2365             : {
    2366         824 :     return DatumGetInt32(DirectFunctionCall2(numeric_cmp,
    2367             :                                              NumericGetDatum(a),
    2368             :                                              NumericGetDatum(b)));
    2369             : }
    2370             : 
    2371             : static JsonbValue *
    2372       91020 : copyJsonbValue(JsonbValue *src)
    2373             : {
    2374       91020 :     JsonbValue *dst = palloc(sizeof(*dst));
    2375             : 
    2376       91020 :     *dst = *src;
    2377             : 
    2378       91020 :     return dst;
    2379             : }
    2380             : 
    2381             : /*
    2382             :  * Execute array subscript expression and convert resulting numeric item to
    2383             :  * the integer type with truncation.
    2384             :  */
    2385             : static JsonPathExecResult
    2386         212 : getArrayIndex(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb,
    2387             :               int32 *index)
    2388             : {
    2389             :     JsonbValue *jbv;
    2390         212 :     JsonValueList found = {0};
    2391         212 :     JsonPathExecResult res = executeItem(cxt, jsp, jb, &found);
    2392             :     Datum       numeric_index;
    2393         208 :     bool        have_error = false;
    2394             : 
    2395         208 :     if (jperIsError(res))
    2396           0 :         return res;
    2397             : 
    2398         408 :     if (JsonValueListLength(&found) != 1 ||
    2399         200 :         !(jbv = getScalar(JsonValueListHead(&found), jbvNumeric)))
    2400          16 :         RETURN_ERROR(ereport(ERROR,
    2401             :                              (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
    2402             :                               errmsg("jsonpath array subscript is not a single numeric value"))));
    2403             : 
    2404         192 :     numeric_index = DirectFunctionCall2(numeric_trunc,
    2405             :                                         NumericGetDatum(jbv->val.numeric),
    2406             :                                         Int32GetDatum(0));
    2407             : 
    2408         192 :     *index = numeric_int4_opt_error(DatumGetNumeric(numeric_index),
    2409             :                                     &have_error);
    2410             : 
    2411         192 :     if (have_error)
    2412          16 :         RETURN_ERROR(ereport(ERROR,
    2413             :                              (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
    2414             :                               errmsg("jsonpath array subscript is out of integer range"))));
    2415             : 
    2416         176 :     return jperOk;
    2417             : }
    2418             : 
    2419             : /* Save base object and its id needed for the execution of .keyvalue(). */
    2420             : static JsonBaseObjectInfo
    2421      168764 : setBaseObject(JsonPathExecContext *cxt, JsonbValue *jbv, int32 id)
    2422             : {
    2423      168764 :     JsonBaseObjectInfo baseObject = cxt->baseObject;
    2424             : 
    2425      168764 :     cxt->baseObject.jbc = jbv->type != jbvBinary ? NULL :
    2426             :         (JsonbContainer *) jbv->val.binary.data;
    2427      168764 :     cxt->baseObject.id = id;
    2428             : 
    2429      168764 :     return baseObject;
    2430             : }
    2431             : 
    2432             : static void
    2433      213128 : JsonValueListAppend(JsonValueList *jvl, JsonbValue *jbv)
    2434             : {
    2435      213128 :     if (jvl->singleton)
    2436             :     {
    2437         656 :         jvl->list = list_make2(jvl->singleton, jbv);
    2438         656 :         jvl->singleton = NULL;
    2439             :     }
    2440      212472 :     else if (!jvl->list)
    2441      211872 :         jvl->singleton = jbv;
    2442             :     else
    2443         600 :         jvl->list = lappend(jvl->list, jbv);
    2444      213128 : }
    2445             : 
    2446             : static int
    2447       85336 : JsonValueListLength(const JsonValueList *jvl)
    2448             : {
    2449       85336 :     return jvl->singleton ? 1 : list_length(jvl->list);
    2450             : }
    2451             : 
    2452             : static bool
    2453          12 : JsonValueListIsEmpty(JsonValueList *jvl)
    2454             : {
    2455          12 :     return !jvl->singleton && list_length(jvl->list) <= 0;
    2456             : }
    2457             : 
    2458             : static JsonbValue *
    2459       85236 : JsonValueListHead(JsonValueList *jvl)
    2460             : {
    2461       85236 :     return jvl->singleton ? jvl->singleton : linitial(jvl->list);
    2462             : }
    2463             : 
    2464             : static List *
    2465         940 : JsonValueListGetList(JsonValueList *jvl)
    2466             : {
    2467         940 :     if (jvl->singleton)
    2468         552 :         return list_make1(jvl->singleton);
    2469             : 
    2470         388 :     return jvl->list;
    2471             : }
    2472             : 
    2473             : static void
    2474      168116 : JsonValueListInitIterator(const JsonValueList *jvl, JsonValueListIterator *it)
    2475             : {
    2476      168116 :     if (jvl->singleton)
    2477             :     {
    2478       92492 :         it->value = jvl->singleton;
    2479       92492 :         it->list = NIL;
    2480       92492 :         it->next = NULL;
    2481             :     }
    2482       75624 :     else if (jvl->list != NIL)
    2483             :     {
    2484         412 :         it->value = (JsonbValue *) linitial(jvl->list);
    2485         412 :         it->list = jvl->list;
    2486         412 :         it->next = list_second_cell(jvl->list);
    2487             :     }
    2488             :     else
    2489             :     {
    2490       75212 :         it->value = NULL;
    2491       75212 :         it->list = NIL;
    2492       75212 :         it->next = NULL;
    2493             :     }
    2494      168116 : }
    2495             : 
    2496             : /*
    2497             :  * Get the next item from the sequence advancing iterator.
    2498             :  */
    2499             : static JsonbValue *
    2500      254588 : JsonValueListNext(const JsonValueList *jvl, JsonValueListIterator *it)
    2501             : {
    2502      254588 :     JsonbValue *result = it->value;
    2503             : 
    2504      254588 :     if (it->next)
    2505             :     {
    2506         712 :         it->value = lfirst(it->next);
    2507         712 :         it->next = lnext(it->list, it->next);
    2508             :     }
    2509             :     else
    2510             :     {
    2511      253876 :         it->value = NULL;
    2512             :     }
    2513             : 
    2514      254588 :     return result;
    2515             : }
    2516             : 
    2517             : /*
    2518             :  * Initialize a binary JsonbValue with the given jsonb container.
    2519             :  */
    2520             : static JsonbValue *
    2521      159320 : JsonbInitBinary(JsonbValue *jbv, Jsonb *jb)
    2522             : {
    2523      159320 :     jbv->type = jbvBinary;
    2524      159320 :     jbv->val.binary.data = &jb->root;
    2525      159320 :     jbv->val.binary.len = VARSIZE_ANY_EXHDR(jb);
    2526             : 
    2527      159320 :     return jbv;
    2528             : }
    2529             : 
    2530             : /*
    2531             :  * Returns jbv* type of JsonbValue. Note, it never returns jbvBinary as is.
    2532             :  */
    2533             : static int
    2534      222716 : JsonbType(JsonbValue *jb)
    2535             : {
    2536      222716 :     int         type = jb->type;
    2537             : 
    2538      222716 :     if (jb->type == jbvBinary)
    2539             :     {
    2540      152372 :         JsonbContainer *jbc = (void *) jb->val.binary.data;
    2541             : 
    2542             :         /* Scalars should be always extracted during jsonpath execution. */
    2543             :         Assert(!JsonContainerIsScalar(jbc));
    2544             : 
    2545      152372 :         if (JsonContainerIsObject(jbc))
    2546      151284 :             type = jbvObject;
    2547        1088 :         else if (JsonContainerIsArray(jbc))
    2548        1088 :             type = jbvArray;
    2549             :         else
    2550           0 :             elog(ERROR, "invalid jsonb container type: 0x%08x", jbc->header);
    2551             :     }
    2552             : 
    2553      222716 :     return type;
    2554             : }
    2555             : 
    2556             : /* Get scalar of given type or NULL on type mismatch */
    2557             : static JsonbValue *
    2558        3440 : getScalar(JsonbValue *scalar, enum jbvType type)
    2559             : {
    2560             :     /* Scalars should be always extracted during jsonpath execution. */
    2561             :     Assert(scalar->type != jbvBinary ||
    2562             :            !JsonContainerIsScalar(scalar->val.binary.data));
    2563             : 
    2564        3440 :     return scalar->type == type ? scalar : NULL;
    2565             : }
    2566             : 
    2567             : /* Construct a JSON array from the item list */
    2568             : static JsonbValue *
    2569          20 : wrapItemsInArray(const JsonValueList *items)
    2570             : {
    2571          20 :     JsonbParseState *ps = NULL;
    2572             :     JsonValueListIterator it;
    2573             :     JsonbValue *jbv;
    2574             : 
    2575          20 :     pushJsonbValue(&ps, WJB_BEGIN_ARRAY, NULL);
    2576             : 
    2577          20 :     JsonValueListInitIterator(items, &it);
    2578          40 :     while ((jbv = JsonValueListNext(items, &it)))
    2579          20 :         pushJsonbValue(&ps, WJB_ELEM, jbv);
    2580             : 
    2581          20 :     return pushJsonbValue(&ps, WJB_END_ARRAY, NULL);
    2582             : }
    2583             : 
    2584             : /* Check if the timezone required for casting from type1 to type2 is used */
    2585             : static void
    2586         252 : checkTimezoneIsUsedForCast(bool useTz, const char *type1, const char *type2)
    2587             : {
    2588         252 :     if (!useTz)
    2589          60 :         ereport(ERROR,
    2590             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    2591             :                  errmsg("cannot convert value from %s to %s without time zone usage",
    2592             :                         type1, type2),
    2593             :                  errhint("Use *_tz() function for time zone support.")));
    2594         192 : }
    2595             : 
    2596             : /* Convert time datum to timetz datum */
    2597             : static Datum
    2598          96 : castTimeToTimeTz(Datum time, bool useTz)
    2599             : {
    2600          96 :     checkTimezoneIsUsedForCast(useTz, "time", "timetz");
    2601             : 
    2602          72 :     return DirectFunctionCall1(time_timetz, time);
    2603             : }
    2604             : 
    2605             : /*
    2606             :  * Compare date to timestamp.
    2607             :  * Note that this doesn't involve any timezone considerations.
    2608             :  */
    2609             : static int
    2610          76 : cmpDateToTimestamp(DateADT date1, Timestamp ts2, bool useTz)
    2611             : {
    2612          76 :     return date_cmp_timestamp_internal(date1, ts2);
    2613             : }
    2614             : 
    2615             : /*
    2616             :  * Compare date to timestamptz.
    2617             :  */
    2618             : static int
    2619          60 : cmpDateToTimestampTz(DateADT date1, TimestampTz tstz2, bool useTz)
    2620             : {
    2621          60 :     checkTimezoneIsUsedForCast(useTz, "date", "timestamptz");
    2622             : 
    2623          48 :     return date_cmp_timestamptz_internal(date1, tstz2);
    2624             : }
    2625             : 
    2626             : /*
    2627             :  * Compare timestamp to timestamptz.
    2628             :  */
    2629             : static int
    2630          96 : cmpTimestampToTimestampTz(Timestamp ts1, TimestampTz tstz2, bool useTz)
    2631             : {
    2632          96 :     checkTimezoneIsUsedForCast(useTz, "timestamp", "timestamptz");
    2633             : 
    2634          72 :     return timestamp_cmp_timestamptz_internal(ts1, tstz2);
    2635             : }
    2636             : 
    2637             : /*
    2638             :  * Cross-type comparison of two datetime SQL/JSON items.  If items are
    2639             :  * uncomparable *cast_error flag is set, otherwise *cast_error is unset.
    2640             :  * If the cast requires timezone and it is not used, then explicit error is thrown.
    2641             :  */
    2642             : static int
    2643         952 : compareDatetime(Datum val1, Oid typid1, Datum val2, Oid typid2,
    2644             :                 bool useTz, bool *cast_error)
    2645             : {
    2646             :     PGFunction cmpfunc;
    2647             : 
    2648         952 :     *cast_error = false;
    2649             : 
    2650         952 :     switch (typid1)
    2651             :     {
    2652         148 :         case DATEOID:
    2653             :             switch (typid2)
    2654             :             {
    2655          72 :                 case DATEOID:
    2656          72 :                     cmpfunc = date_cmp;
    2657             : 
    2658          72 :                     break;
    2659             : 
    2660          28 :                 case TIMESTAMPOID:
    2661          28 :                     return cmpDateToTimestamp(DatumGetDateADT(val1),
    2662             :                                               DatumGetTimestamp(val2),
    2663             :                                               useTz);
    2664             : 
    2665          24 :                 case TIMESTAMPTZOID:
    2666          24 :                     return cmpDateToTimestampTz(DatumGetDateADT(val1),
    2667             :                                                 DatumGetTimestampTz(val2),
    2668             :                                                 useTz);
    2669             : 
    2670          24 :                 case TIMEOID:
    2671             :                 case TIMETZOID:
    2672          24 :                     *cast_error = true; /* uncomparable types */
    2673          24 :                     return 0;
    2674             : 
    2675           0 :                 default:
    2676           0 :                     elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
    2677             :                          typid2);
    2678             :             }
    2679          72 :             break;
    2680             : 
    2681         168 :         case TIMEOID:
    2682             :             switch (typid2)
    2683             :             {
    2684          72 :                 case TIMEOID:
    2685          72 :                     cmpfunc = time_cmp;
    2686             : 
    2687          72 :                     break;
    2688             : 
    2689          48 :                 case TIMETZOID:
    2690          48 :                     val1 = castTimeToTimeTz(val1, useTz);
    2691          36 :                     cmpfunc = timetz_cmp;
    2692             : 
    2693          36 :                     break;
    2694             : 
    2695          48 :                 case DATEOID:
    2696             :                 case TIMESTAMPOID:
    2697             :                 case TIMESTAMPTZOID:
    2698          48 :                     *cast_error = true; /* uncomparable types */
    2699          48 :                     return 0;
    2700             : 
    2701           0 :                 default:
    2702           0 :                     elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
    2703             :                          typid2);
    2704             :             }
    2705         108 :             break;
    2706             : 
    2707         216 :         case TIMETZOID:
    2708             :             switch (typid2)
    2709             :             {
    2710          48 :                 case TIMEOID:
    2711          48 :                     val2 = castTimeToTimeTz(val2, useTz);
    2712          36 :                     cmpfunc = timetz_cmp;
    2713             : 
    2714          36 :                     break;
    2715             : 
    2716         120 :                 case TIMETZOID:
    2717         120 :                     cmpfunc = timetz_cmp;
    2718             : 
    2719         120 :                     break;
    2720             : 
    2721          48 :                 case DATEOID:
    2722             :                 case TIMESTAMPOID:
    2723             :                 case TIMESTAMPTZOID:
    2724          48 :                     *cast_error = true; /* uncomparable types */
    2725          48 :                     return 0;
    2726             : 
    2727           0 :                 default:
    2728           0 :                     elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
    2729             :                          typid2);
    2730             :             }
    2731         156 :             break;
    2732             : 
    2733         192 :         case TIMESTAMPOID:
    2734             :             switch (typid2)
    2735             :             {
    2736          48 :                 case DATEOID:
    2737          48 :                     return -cmpDateToTimestamp(DatumGetDateADT(val2),
    2738             :                                                DatumGetTimestamp(val1),
    2739             :                                                useTz);
    2740             : 
    2741          72 :                 case TIMESTAMPOID:
    2742          72 :                     cmpfunc = timestamp_cmp;
    2743             : 
    2744          72 :                     break;
    2745             : 
    2746          48 :                 case TIMESTAMPTZOID:
    2747          48 :                     return cmpTimestampToTimestampTz(DatumGetTimestamp(val1),
    2748             :                                                      DatumGetTimestampTz(val2),
    2749             :                                                      useTz);
    2750             : 
    2751          24 :                 case TIMEOID:
    2752             :                 case TIMETZOID:
    2753          24 :                     *cast_error = true; /* uncomparable types */
    2754          24 :                     return 0;
    2755             : 
    2756           0 :                 default:
    2757           0 :                     elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
    2758             :                          typid2);
    2759             :             }
    2760          72 :             break;
    2761             : 
    2762         228 :         case TIMESTAMPTZOID:
    2763             :             switch (typid2)
    2764             :             {
    2765          36 :                 case DATEOID:
    2766          36 :                     return -cmpDateToTimestampTz(DatumGetDateADT(val2),
    2767             :                                                  DatumGetTimestampTz(val1),
    2768             :                                                  useTz);
    2769             : 
    2770          48 :                 case TIMESTAMPOID:
    2771          48 :                     return -cmpTimestampToTimestampTz(DatumGetTimestamp(val2),
    2772             :                                                       DatumGetTimestampTz(val1),
    2773             :                                                       useTz);
    2774             : 
    2775         120 :                 case TIMESTAMPTZOID:
    2776         120 :                     cmpfunc = timestamp_cmp;
    2777             : 
    2778         120 :                     break;
    2779             : 
    2780          24 :                 case TIMEOID:
    2781             :                 case TIMETZOID:
    2782          24 :                     *cast_error = true; /* uncomparable types */
    2783          24 :                     return 0;
    2784             : 
    2785           0 :                 default:
    2786           0 :                     elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
    2787             :                          typid2);
    2788             :             }
    2789         120 :             break;
    2790             : 
    2791           0 :         default:
    2792           0 :             elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u", typid1);
    2793             :     }
    2794             : 
    2795         528 :     if (*cast_error)
    2796           0 :         return 0;               /* cast error */
    2797             : 
    2798         528 :     return DatumGetInt32(DirectFunctionCall2(cmpfunc, val1, val2));
    2799             : }

Generated by: LCOV version 1.13