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