PostgreSQL Source Code git master
Loading...
Searching...
No Matches
jsonpath_exec.c
Go to the documentation of this file.
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-2026, 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 "miscadmin.h"
66#include "nodes/miscnodes.h"
67#include "nodes/nodeFuncs.h"
68#include "regex/regex.h"
69#include "utils/builtins.h"
70#include "utils/date.h"
71#include "utils/datetime.h"
72#include "utils/float.h"
73#include "utils/formatting.h"
74#include "utils/json.h"
75#include "utils/jsonpath.h"
76#include "utils/memutils.h"
77#include "utils/timestamp.h"
78
79/*
80 * Represents "base object" and its "id" for .keyvalue() evaluation.
81 */
87
88/* Callbacks for executeJsonPath() */
89typedef JsonbValue *(*JsonPathGetVarCallback) (void *vars, char *varName, int varNameLen,
90 JsonbValue *baseObject, int *baseObjectId);
91typedef int (*JsonPathCountVarsCallback) (void *vars);
92
93/*
94 * Context of jsonpath execution.
95 */
96typedef struct JsonPathExecContext
97{
98 void *vars; /* variables to substitute into jsonpath */
99 JsonPathGetVarCallback getVar; /* callback to extract a given variable
100 * from 'vars' */
101 JsonbValue *root; /* for $ evaluation */
102 JsonbValue *current; /* for @ evaluation */
103 JsonBaseObjectInfo baseObject; /* "base object" for .keyvalue()
104 * evaluation */
105 int lastGeneratedObjectId; /* "id" counter for .keyvalue()
106 * evaluation */
107 int innermostArraySize; /* for LAST array index evaluation */
108 bool laxMode; /* true for "lax" mode, false for "strict"
109 * mode */
110 bool ignoreStructuralErrors; /* with "true" structural errors such
111 * as absence of required json item or
112 * unexpected json item type are
113 * ignored */
114 bool throwErrors; /* with "false" all suppressible errors are
115 * suppressed */
116 bool useTz;
117} JsonPathExecContext;
118
119/* Context for LIKE_REGEX execution. */
125
126/* Result of jsonpath predicate evaluation */
133
134/* Result of jsonpath expression evaluation */
141
142#define jperIsError(jper) ((jper) == jperError)
143
144/*
145 * List (or really array) of JsonbValues. This is the output representation
146 * of jsonpath evaluation.
147 *
148 * The initial or "base" chunk of a list is typically a local variable in
149 * a calling function. If we need more entries than will fit in the base
150 * chunk, we palloc more chunks. For notational simplicity, those are also
151 * treated as being of type JsonValueList, although they will have items[]
152 * arrays that are larger than BASE_JVL_ITEMS.
153 *
154 * Callers *must* initialize the base chunk with JsonValueListInit().
155 * Typically they should free any extra chunks when done, using
156 * JsonValueListClear(), although some top-level functions skip that
157 * on the assumption that the caller's context will be reset soon.
158 *
159 * Note that most types of JsonbValue include pointers to external data, which
160 * will not be managed by the JsonValueList functions. We expect that such
161 * data is part of the input to the jsonpath operation, and the caller will
162 * see to it that it holds still for the duration of the operation.
163 *
164 * Most lists are short, though some can be quite long. So we set
165 * BASE_JVL_ITEMS small to conserve stack space, but grow the extra
166 * chunks aggressively.
167 */
168#define BASE_JVL_ITEMS 2 /* number of items a base chunk holds */
169#define MIN_EXTRA_JVL_ITEMS 16 /* min number of items an extra chunk holds */
170
171typedef struct JsonValueList
172{
173 int nitems; /* number of items stored in this chunk */
174 int maxitems; /* allocated length of items[] */
175 struct JsonValueList *next; /* => next chunk, if any */
176 struct JsonValueList *last; /* => last chunk (only valid in base chunk) */
177 JsonbValue items[BASE_JVL_ITEMS];
178} JsonValueList;
179
180/* State data for iterating through a JsonValueList */
181typedef struct JsonValueListIterator
182{
183 JsonValueList *chunk; /* current chunk of list */
184 int nextitem; /* index of next value to return in chunk */
185} JsonValueListIterator;
186
187/* Structures for JSON_TABLE execution */
188
189/*
190 * Struct holding the result of jsonpath evaluation, to be used as source row
191 * for JsonTableGetValue() which in turn computes the values of individual
192 * JSON_TABLE columns.
193 */
199
200/*
201 * State of evaluation of row pattern derived by applying jsonpath given in
202 * a JsonTablePlan to an input document given in the parent TableFunc.
203 */
204typedef struct JsonTablePlanState
205{
206 /* Original plan */
207 JsonTablePlan *plan;
208
209 /* The following fields are only valid for JsonTablePathScan plans */
210
211 /* jsonpath to evaluate against the input doc to get the row pattern */
212 JsonPath *path;
213
214 /*
215 * Memory context to use when evaluating the row pattern from the jsonpath
216 */
217 MemoryContext mcxt;
218
219 /* PASSING arguments passed to jsonpath executor */
220 List *args;
221
222 /* List and iterator of jsonpath result values */
223 JsonValueList found;
224 JsonValueListIterator iter;
225
226 /* Currently selected row for JsonTableGetValue() to use */
227 JsonTablePlanRowSource current;
228
229 /* Counter for ORDINAL columns */
230 int ordinal;
231
232 /* Nested plan, if any */
233 struct JsonTablePlanState *nested;
234
235 /* Left sibling, if any */
236 struct JsonTablePlanState *left;
237
238 /* Right sibling, if any */
239 struct JsonTablePlanState *right;
240
241 /* Parent plan, if this is a nested plan */
242 struct JsonTablePlanState *parent;
243
244 /* Join type */
245 bool cross;
246 bool outerJoin;
247 /* Planning control fields */
248 bool advanceNested;
249 bool advanceRight;
250 bool reset;
251} JsonTablePlanState;
252
253/* Random number to identify JsonTableExecContext for sanity checking */
254#define JSON_TABLE_EXEC_CONTEXT_MAGIC 418352867
255
256typedef struct JsonTableExecContext
257{
258 int magic;
259
260 /* State of the plan providing a row evaluated from "root" jsonpath */
261 JsonTablePlanState *rootplanstate;
262
263 /*
264 * Per-column JsonTablePlanStates for all columns including the nested
265 * ones.
266 */
267 JsonTablePlanState **colplanstates;
268} JsonTableExecContext;
269
270/* strict/lax flags is decomposed into four [un]wrap/error flags */
271#define jspStrictAbsenceOfErrors(cxt) (!(cxt)->laxMode)
272#define jspAutoUnwrap(cxt) ((cxt)->laxMode)
273#define jspAutoWrap(cxt) ((cxt)->laxMode)
274#define jspIgnoreStructuralErrors(cxt) ((cxt)->ignoreStructuralErrors)
275#define jspThrowErrors(cxt) ((cxt)->throwErrors)
276
277/* Convenience macro: return or throw error depending on context */
278#define RETURN_ERROR(throw_error) \
279do { \
280 if (jspThrowErrors(cxt)) \
281 throw_error; \
282 else \
283 return jperError; \
284} while (0)
285
286typedef JsonPathBool (*JsonPathPredicateCallback) (JsonPathItem *jsp,
287 JsonbValue *larg,
288 JsonbValue *rarg,
289 void *param);
290typedef Numeric (*BinaryArithmFunc) (Numeric num1, Numeric num2,
291 Node *escontext);
292
293static JsonPathExecResult executeJsonPath(JsonPath *path, void *vars,
294 JsonPathGetVarCallback getVar,
295 JsonPathCountVarsCallback countVars,
296 Jsonb *json, bool throwErrors,
297 JsonValueList *result, bool useTz);
298static JsonPathExecResult executeItem(JsonPathExecContext *cxt,
299 JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found);
300static JsonPathExecResult executeItemOptUnwrapTarget(JsonPathExecContext *cxt,
301 JsonPathItem *jsp, JsonbValue *jb,
302 JsonValueList *found, bool unwrap);
303static JsonPathExecResult executeItemUnwrapTargetArray(JsonPathExecContext *cxt,
304 JsonPathItem *jsp, JsonbValue *jb,
305 JsonValueList *found, bool unwrapElements);
306static JsonPathExecResult executeNextItem(JsonPathExecContext *cxt,
307 JsonPathItem *cur, JsonPathItem *next,
308 JsonbValue *v, JsonValueList *found);
309static JsonPathExecResult executeItemOptUnwrapResult(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb,
310 bool unwrap, JsonValueList *found);
311static JsonPathExecResult executeItemOptUnwrapResultNoThrow(JsonPathExecContext *cxt, JsonPathItem *jsp,
312 JsonbValue *jb, bool unwrap, JsonValueList *found);
313static JsonPathBool executeBoolItem(JsonPathExecContext *cxt,
314 JsonPathItem *jsp, JsonbValue *jb, bool canHaveNext);
315static JsonPathBool executeNestedBoolItem(JsonPathExecContext *cxt,
316 JsonPathItem *jsp, JsonbValue *jb);
317static JsonPathExecResult executeAnyItem(JsonPathExecContext *cxt,
318 JsonPathItem *jsp, JsonbContainer *jbc, JsonValueList *found,
319 uint32 level, uint32 first, uint32 last,
320 bool ignoreStructuralErrors, bool unwrapNext);
321static JsonPathBool executePredicate(JsonPathExecContext *cxt,
322 JsonPathItem *pred, JsonPathItem *larg, JsonPathItem *rarg,
323 JsonbValue *jb, bool unwrapRightArg,
324 JsonPathPredicateCallback exec, void *param);
325static JsonPathExecResult executeBinaryArithmExpr(JsonPathExecContext *cxt,
326 JsonPathItem *jsp, JsonbValue *jb,
327 BinaryArithmFunc func, JsonValueList *found);
328static JsonPathExecResult executeUnaryArithmExpr(JsonPathExecContext *cxt,
329 JsonPathItem *jsp, JsonbValue *jb, PGFunction func,
330 JsonValueList *found);
331static JsonPathBool executeStartsWith(JsonPathItem *jsp,
332 JsonbValue *whole, JsonbValue *initial, void *param);
333static JsonPathBool executeLikeRegex(JsonPathItem *jsp, JsonbValue *str,
334 JsonbValue *rarg, void *param);
335static JsonPathExecResult executeNumericItemMethod(JsonPathExecContext *cxt,
336 JsonPathItem *jsp, JsonbValue *jb, bool unwrap, PGFunction func,
337 JsonValueList *found);
338static JsonPathExecResult executeDateTimeMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
339 JsonbValue *jb, JsonValueList *found);
340static JsonPathExecResult executeStringInternalMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
341 JsonbValue *jb, JsonValueList *found);
342static JsonPathExecResult executeKeyValueMethod(JsonPathExecContext *cxt,
343 JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found);
344static JsonPathExecResult appendBoolResult(JsonPathExecContext *cxt,
345 JsonPathItem *jsp, JsonValueList *found, JsonPathBool res);
346static void getJsonPathItem(JsonPathExecContext *cxt, JsonPathItem *item,
347 JsonbValue *value);
348static JsonbValue *GetJsonPathVar(void *cxt, char *varName, int varNameLen,
349 JsonbValue *baseObject, int *baseObjectId);
350static int CountJsonPathVars(void *cxt);
351static void JsonItemFromDatum(Datum val, Oid typid, int32 typmod,
352 JsonbValue *res);
353static void JsonbValueInitNumericDatum(JsonbValue *jbv, Datum num);
354static void getJsonPathVariable(JsonPathExecContext *cxt,
355 JsonPathItem *variable, JsonbValue *value);
356static int countVariablesFromJsonb(void *varsJsonb);
357static JsonbValue *getJsonPathVariableFromJsonb(void *varsJsonb, char *varName,
358 int varNameLength,
359 JsonbValue *baseObject,
360 int *baseObjectId);
361static int JsonbArraySize(JsonbValue *jb);
362static JsonPathBool executeComparison(JsonPathItem *cmp, JsonbValue *lv,
363 JsonbValue *rv, void *p);
364static JsonPathBool compareItems(int32 op, JsonbValue *jb1, JsonbValue *jb2,
365 bool useTz);
366static int compareNumeric(Numeric a, Numeric b);
367static JsonbValue *copyJsonbValue(JsonbValue *src);
368static JsonPathExecResult getArrayIndex(JsonPathExecContext *cxt,
369 JsonPathItem *jsp, JsonbValue *jb, int32 *index);
370static JsonBaseObjectInfo setBaseObject(JsonPathExecContext *cxt,
371 JsonbValue *jbv, int32 id);
372static void JsonValueListInit(JsonValueList *jvl);
373static void JsonValueListClear(JsonValueList *jvl);
374static void JsonValueListAppend(JsonValueList *jvl, const JsonbValue *jbv);
375static bool JsonValueListIsEmpty(const JsonValueList *jvl);
376static bool JsonValueListIsSingleton(const JsonValueList *jvl);
377static bool JsonValueListHasMultipleItems(const JsonValueList *jvl);
378static JsonbValue *JsonValueListHead(JsonValueList *jvl);
379static void JsonValueListInitIterator(JsonValueList *jvl,
380 JsonValueListIterator *it);
381static JsonbValue *JsonValueListNext(JsonValueListIterator *it);
382static JsonbValue *JsonbInitBinary(JsonbValue *jbv, Jsonb *jb);
383static int JsonbType(JsonbValue *jb);
384static JsonbValue *getScalar(JsonbValue *scalar, enum jbvType type);
385static JsonbValue *wrapItemsInArray(JsonValueList *items);
386static int compareDatetime(Datum val1, Oid typid1, Datum val2, Oid typid2,
387 bool useTz, bool *cast_error);
388static void checkTimezoneIsUsedForCast(bool useTz, const char *type1,
389 const char *type2);
390
391static void JsonTableInitOpaque(TableFuncScanState *state, int natts);
392static JsonTablePlanState *JsonTableInitPlan(JsonTableExecContext *cxt,
393 JsonTablePlan *plan,
394 JsonTablePlanState *parentstate,
395 List *args,
396 MemoryContext mcxt);
397static void JsonTableSetDocument(TableFuncScanState *state, Datum value);
398static void JsonTableResetRowPattern(JsonTablePlanState *planstate, Datum item);
399static void JsonTableRescan(JsonTablePlanState *planstate);
400static bool JsonTableFetchRow(TableFuncScanState *state);
401static Datum JsonTableGetValue(TableFuncScanState *state, int colnum,
402 Oid typid, int32 typmod, bool *isnull);
403static void JsonTableDestroyOpaque(TableFuncScanState *state);
404static bool JsonTablePlanScanNextRow(JsonTablePlanState *planstate);
405static void JsonTableResetNestedPlan(JsonTablePlanState *planstate);
406static bool JsonTablePlanNextRow(JsonTablePlanState *planstate);
407
408const TableFuncRoutine JsonbTableRoutine =
409{
410 .InitOpaque = JsonTableInitOpaque,
411 .SetDocument = JsonTableSetDocument,
412 .SetNamespace = NULL,
413 .SetRowFilter = NULL,
414 .SetColumnFilter = NULL,
415 .FetchRow = JsonTableFetchRow,
416 .GetValue = JsonTableGetValue,
417 .DestroyOpaque = JsonTableDestroyOpaque
418};
419
420/****************** User interface to JsonPath executor ********************/
421
422/*
423 * jsonb_path_exists
424 * Returns true if jsonpath returns at least one item for the specified
425 * jsonb value. This function and jsonb_path_match() are used to
426 * implement @? and @@ operators, which in turn are intended to have an
427 * index support. Thus, it's desirable to make it easier to achieve
428 * consistency between index scan results and sequential scan results.
429 * So, we throw as few errors as possible. Regarding this function,
430 * such behavior also matches behavior of JSON_EXISTS() clause of
431 * SQL/JSON. Regarding jsonb_path_match(), this function doesn't have
432 * an analogy in SQL/JSON, so we define its behavior on our own.
433 */
434static Datum
435jsonb_path_exists_internal(FunctionCallInfo fcinfo, bool tz)
436{
437 Jsonb *jb = PG_GETARG_JSONB_P(0);
438 JsonPath *jp = PG_GETARG_JSONPATH_P(1);
439 JsonPathExecResult res;
440 Jsonb *vars = NULL;
441 bool silent = true;
442
443 if (PG_NARGS() == 4)
444 {
445 vars = PG_GETARG_JSONB_P(2);
446 silent = PG_GETARG_BOOL(3);
447 }
448
449 res = executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
450 countVariablesFromJsonb,
451 jb, !silent, NULL, tz);
452
453 PG_FREE_IF_COPY(jb, 0);
454 PG_FREE_IF_COPY(jp, 1);
455
456 if (jperIsError(res))
457 PG_RETURN_NULL();
458
459 PG_RETURN_BOOL(res == jperOk);
460}
461
462Datum
467
468Datum
473
474/*
475 * jsonb_path_exists_opr
476 * Implementation of operator "jsonb @? jsonpath" (2-argument version of
477 * jsonb_path_exists()).
478 */
479Datum
480jsonb_path_exists_opr(PG_FUNCTION_ARGS)
481{
482 /* just call the other one -- it can handle both cases */
483 return jsonb_path_exists_internal(fcinfo, false);
484}
485
486/*
487 * jsonb_path_match
488 * Returns jsonpath predicate result item for the specified jsonb value.
489 * See jsonb_path_exists() comment for details regarding error handling.
490 */
491static Datum
492jsonb_path_match_internal(FunctionCallInfo fcinfo, bool tz)
493{
494 Jsonb *jb = PG_GETARG_JSONB_P(0);
495 JsonPath *jp = PG_GETARG_JSONPATH_P(1);
496 Jsonb *vars = NULL;
497 bool silent = true;
498 JsonValueList found;
499
500 if (PG_NARGS() == 4)
501 {
502 vars = PG_GETARG_JSONB_P(2);
503 silent = PG_GETARG_BOOL(3);
504 }
505
506 JsonValueListInit(&found);
507
508 (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
509 countVariablesFromJsonb,
510 jb, !silent, &found, tz);
511
512 PG_FREE_IF_COPY(jb, 0);
513 PG_FREE_IF_COPY(jp, 1);
514
515 if (JsonValueListIsSingleton(&found))
516 {
517 JsonbValue *jbv = JsonValueListHead(&found);
518
519 if (jbv->type == jbvBool)
520 PG_RETURN_BOOL(jbv->val.boolean);
521
522 if (jbv->type == jbvNull)
523 PG_RETURN_NULL();
524 }
525
526 if (!silent)
527 ereport(ERROR,
528 (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
529 errmsg("single boolean result is expected")));
530
531 PG_RETURN_NULL();
532}
533
534Datum
535jsonb_path_match(PG_FUNCTION_ARGS)
536{
537 return jsonb_path_match_internal(fcinfo, false);
538}
539
540Datum
545
546/*
547 * jsonb_path_match_opr
548 * Implementation of operator "jsonb @@ jsonpath" (2-argument version of
549 * jsonb_path_match()).
550 */
551Datum
552jsonb_path_match_opr(PG_FUNCTION_ARGS)
553{
554 /* just call the other one -- it can handle both cases */
555 return jsonb_path_match_internal(fcinfo, false);
556}
557
558/*
559 * jsonb_path_query
560 * Executes jsonpath for given jsonb document and returns result as
561 * rowset.
562 */
563static Datum
564jsonb_path_query_internal(FunctionCallInfo fcinfo, bool tz)
565{
566 FuncCallContext *funcctx;
567 JsonValueListIterator *iter;
568 JsonbValue *v;
569
570 if (SRF_IS_FIRSTCALL())
571 {
572 JsonPath *jp;
573 Jsonb *jb;
574 Jsonb *vars;
575 bool silent;
576 MemoryContext oldcontext;
577 JsonValueList *found;
578
579 funcctx = SRF_FIRSTCALL_INIT();
580 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
581
582 jb = PG_GETARG_JSONB_P_COPY(0);
583 jp = PG_GETARG_JSONPATH_P_COPY(1);
584 vars = PG_GETARG_JSONB_P_COPY(2);
585 silent = PG_GETARG_BOOL(3);
586
587 found = palloc_object(JsonValueList);
588 JsonValueListInit(found);
589
590 (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
591 countVariablesFromJsonb,
592 jb, !silent, found, tz);
593
594 iter = palloc_object(JsonValueListIterator);
595 JsonValueListInitIterator(found, iter);
596
597 funcctx->user_fctx = iter;
598
599 MemoryContextSwitchTo(oldcontext);
600 }
601
602 funcctx = SRF_PERCALL_SETUP();
603 iter = funcctx->user_fctx;
604
605 v = JsonValueListNext(iter);
606
607 if (v == NULL)
608 SRF_RETURN_DONE(funcctx);
609
610 SRF_RETURN_NEXT(funcctx, JsonbPGetDatum(JsonbValueToJsonb(v)));
611}
612
613Datum
614jsonb_path_query(PG_FUNCTION_ARGS)
615{
616 return jsonb_path_query_internal(fcinfo, false);
617}
618
619Datum
624
625/*
626 * jsonb_path_query_array
627 * Executes jsonpath for given jsonb document and returns result as
628 * jsonb array.
629 */
630static Datum
647
648Datum
653
654Datum
659
660/*
661 * jsonb_path_query_first
662 * Executes jsonpath for given jsonb document and returns first result
663 * item. If there are no items, NULL returned.
664 */
665static Datum
685
686Datum
691
692Datum
697
698/********************Execute functions for JsonPath**************************/
699
700/*
701 * Interface to jsonpath executor
702 *
703 * 'path' - jsonpath to be executed
704 * 'vars' - variables to be substituted to jsonpath
705 * 'getVar' - callback used by getJsonPathVariable() to extract variables from
706 * 'vars'
707 * 'countVars' - callback to count the number of jsonpath variables in 'vars'
708 * 'json' - target document for jsonpath evaluation
709 * 'throwErrors' - whether we should throw suppressible errors
710 * 'result' - list to store result items into
711 *
712 * Returns an error if a recoverable error happens during processing, or NULL
713 * on no error.
714 *
715 * Note, jsonb and jsonpath values should be available and untoasted during
716 * work because JsonPathItem, JsonbValue and result item could have pointers
717 * into input values. If caller needs to just check if document matches
718 * jsonpath, then it doesn't provide a result arg. In this case executor
719 * works till first positive result and does not check the rest if possible.
720 * In other case it tries to find all the satisfied result items.
721 */
722static JsonPathExecResult
723executeJsonPath(JsonPath *path, void *vars, JsonPathGetVarCallback getVar,
724 JsonPathCountVarsCallback countVars,
725 Jsonb *json, bool throwErrors, JsonValueList *result,
726 bool useTz)
727{
728 JsonPathExecContext cxt;
729 JsonPathExecResult res;
730 JsonPathItem jsp;
731 JsonbValue jbv;
732
733 jspInit(&jsp, path);
734
735 if (!JsonbExtractScalar(&json->root, &jbv))
736 JsonbInitBinary(&jbv, json);
737
738 cxt.vars = vars;
739 cxt.getVar = getVar;
740 cxt.laxMode = (path->header & JSONPATH_LAX) != 0;
741 cxt.ignoreStructuralErrors = cxt.laxMode;
742 cxt.root = &jbv;
743 cxt.current = &jbv;
744 cxt.baseObject.jbc = NULL;
745 cxt.baseObject.id = 0;
746 /* 1 + number of base objects in vars */
747 cxt.lastGeneratedObjectId = 1 + countVars(vars);
748 cxt.innermostArraySize = -1;
749 cxt.throwErrors = throwErrors;
750 cxt.useTz = useTz;
751
752 if (jspStrictAbsenceOfErrors(&cxt) && !result)
753 {
754 /*
755 * In strict mode we must get a complete list of values to check that
756 * there are no errors at all.
757 */
758 JsonValueList vals;
759 bool isempty;
760
761 JsonValueListInit(&vals);
762
763 res = executeItem(&cxt, &jsp, &jbv, &vals);
764
765 isempty = JsonValueListIsEmpty(&vals);
766 JsonValueListClear(&vals);
767
768 if (jperIsError(res))
769 return res;
770
771 return isempty ? jperNotFound : jperOk;
772 }
773
774 res = executeItem(&cxt, &jsp, &jbv, result);
775
776 Assert(!throwErrors || !jperIsError(res));
777
778 return res;
779}
780
781/*
782 * Execute jsonpath with automatic unwrapping of current item in lax mode.
783 */
784static JsonPathExecResult
790
791/*
792 * Main jsonpath executor function: walks on jsonpath structure, finds
793 * relevant parts of jsonb and evaluates expressions over them.
794 * When 'unwrap' is true current SQL/JSON item is unwrapped if it is an array.
795 */
796static JsonPathExecResult
797executeItemOptUnwrapTarget(JsonPathExecContext *cxt, JsonPathItem *jsp,
798 JsonbValue *jb, JsonValueList *found, bool unwrap)
799{
800 JsonPathItem elem;
801 JsonPathExecResult res = jperNotFound;
802 JsonBaseObjectInfo baseObject;
803
804 check_stack_depth();
805 CHECK_FOR_INTERRUPTS();
806
807 switch (jsp->type)
808 {
809 case jpiNull:
810 case jpiBool:
811 case jpiNumeric:
812 case jpiString:
813 case jpiVariable:
814 {
815 JsonbValue v;
816 bool hasNext = jspGetNext(jsp, &elem);
817
818 if (!hasNext && !found && jsp->type != jpiVariable)
819 {
820 /*
821 * Skip evaluation, but not for variables. We must
822 * trigger an error for the missing variable.
823 */
824 res = jperOk;
825 break;
826 }
827
828 baseObject = cxt->baseObject;
829 getJsonPathItem(cxt, jsp, &v);
830
831 res = executeNextItem(cxt, jsp, &elem,
832 &v, found);
833 cxt->baseObject = baseObject;
834 }
835 break;
836
837 /* all boolean item types: */
838 case jpiAnd:
839 case jpiOr:
840 case jpiNot:
841 case jpiIsUnknown:
842 case jpiEqual:
843 case jpiNotEqual:
844 case jpiLess:
845 case jpiGreater:
846 case jpiLessOrEqual:
847 case jpiGreaterOrEqual:
848 case jpiExists:
849 case jpiStartsWith:
850 case jpiLikeRegex:
851 {
852 JsonPathBool st = executeBoolItem(cxt, jsp, jb, true);
853
854 res = appendBoolResult(cxt, jsp, found, st);
855 break;
856 }
857
858 case jpiAdd:
859 return executeBinaryArithmExpr(cxt, jsp, jb,
860 numeric_add_safe, found);
861
862 case jpiSub:
863 return executeBinaryArithmExpr(cxt, jsp, jb,
864 numeric_sub_safe, found);
865
866 case jpiMul:
867 return executeBinaryArithmExpr(cxt, jsp, jb,
868 numeric_mul_safe, found);
869
870 case jpiDiv:
871 return executeBinaryArithmExpr(cxt, jsp, jb,
872 numeric_div_safe, found);
873
874 case jpiMod:
875 return executeBinaryArithmExpr(cxt, jsp, jb,
876 numeric_mod_safe, found);
877
878 case jpiPlus:
879 return executeUnaryArithmExpr(cxt, jsp, jb, NULL, found);
880
881 case jpiMinus:
882 return executeUnaryArithmExpr(cxt, jsp, jb, numeric_uminus,
883 found);
884
885 case jpiAnyArray:
886 if (JsonbType(jb) == jbvArray)
887 {
888 bool hasNext = jspGetNext(jsp, &elem);
889
890 res = executeItemUnwrapTargetArray(cxt, hasNext ? &elem : NULL,
891 jb, found, jspAutoUnwrap(cxt));
892 }
893 else if (jspAutoWrap(cxt))
894 res = executeNextItem(cxt, jsp, NULL, jb, found);
895 else if (!jspIgnoreStructuralErrors(cxt))
896 RETURN_ERROR(ereport(ERROR,
897 (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),
898 errmsg("jsonpath wildcard array accessor can only be applied to an array"))));
899 break;
900
901 case jpiAnyKey:
902 if (JsonbType(jb) == jbvObject)
903 {
904 bool hasNext = jspGetNext(jsp, &elem);
905
906 if (jb->type != jbvBinary)
907 elog(ERROR, "invalid jsonb object type: %d", jb->type);
908
909 return executeAnyItem
910 (cxt, hasNext ? &elem : NULL,
911 jb->val.binary.data, found, 1, 1, 1,
912 false, jspAutoUnwrap(cxt));
913 }
914 else if (unwrap && JsonbType(jb) == jbvArray)
915 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
916 else if (!jspIgnoreStructuralErrors(cxt))
917 {
918 Assert(found);
919 RETURN_ERROR(ereport(ERROR,
920 (errcode(ERRCODE_SQL_JSON_OBJECT_NOT_FOUND),
921 errmsg("jsonpath wildcard member accessor can only be applied to an object"))));
922 }
923 break;
924
925 case jpiIndexArray:
926 if (JsonbType(jb) == jbvArray || jspAutoWrap(cxt))
927 {
928 int innermostArraySize = cxt->innermostArraySize;
929 int i;
930 int size = JsonbArraySize(jb);
931 bool singleton = size < 0;
932 bool hasNext = jspGetNext(jsp, &elem);
933
934 if (singleton)
935 size = 1;
936
937 cxt->innermostArraySize = size; /* for LAST evaluation */
938
939 for (i = 0; i < jsp->content.array.nelems; i++)
940 {
941 JsonPathItem from;
942 JsonPathItem to;
943 int32 index;
944 int32 index_from;
945 int32 index_to;
946 bool range = jspGetArraySubscript(jsp, &from,
947 &to, i);
948
949 res = getArrayIndex(cxt, &from, jb, &index_from);
950
951 if (jperIsError(res))
952 break;
953
954 if (range)
955 {
956 res = getArrayIndex(cxt, &to, jb, &index_to);
957
958 if (jperIsError(res))
959 break;
960 }
961 else
962 index_to = index_from;
963
964 if (!jspIgnoreStructuralErrors(cxt) &&
965 (index_from < 0 ||
966 index_from > index_to ||
967 index_to >= size))
968 RETURN_ERROR(ereport(ERROR,
969 (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
970 errmsg("jsonpath array subscript is out of bounds"))));
971
972 if (index_from < 0)
973 index_from = 0;
974
975 if (index_to >= size)
976 index_to = size - 1;
977
978 res = jperNotFound;
979
980 for (index = index_from; index <= index_to; index++)
981 {
982 JsonbValue *v;
983
984 if (singleton)
985 {
986 v = jb;
987 }
988 else
989 {
990 v = getIthJsonbValueFromContainer(jb->val.binary.data,
991 (uint32) index);
992
993 if (v == NULL)
994 continue;
995 }
996
997 if (!hasNext && !found)
998 return jperOk;
999
1000 res = executeNextItem(cxt, jsp, &elem, v, found);
1001
1002 if (jperIsError(res))
1003 break;
1004
1005 if (res == jperOk && !found)
1006 break;
1007 }
1008
1009 if (jperIsError(res))
1010 break;
1011
1012 if (res == jperOk && !found)
1013 break;
1014 }
1015
1016 cxt->innermostArraySize = innermostArraySize;
1017 }
1018 else if (!jspIgnoreStructuralErrors(cxt))
1019 {
1020 RETURN_ERROR(ereport(ERROR,
1021 (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),
1022 errmsg("jsonpath array accessor can only be applied to an array"))));
1023 }
1024 break;
1025
1026 case jpiAny:
1027 {
1028 bool hasNext = jspGetNext(jsp, &elem);
1029
1030 /* first try without any intermediate steps */
1031 if (jsp->content.anybounds.first == 0)
1032 {
1033 bool savedIgnoreStructuralErrors;
1034
1035 savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors;
1036 cxt->ignoreStructuralErrors = true;
1037 res = executeNextItem(cxt, jsp, &elem,
1038 jb, found);
1039 cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors;
1040
1041 if (res == jperOk && !found)
1042 break;
1043 }
1044
1045 if (jb->type == jbvBinary)
1046 res = executeAnyItem
1047 (cxt, hasNext ? &elem : NULL,
1048 jb->val.binary.data, found,
1049 1,
1050 jsp->content.anybounds.first,
1051 jsp->content.anybounds.last,
1052 true, jspAutoUnwrap(cxt));
1053 break;
1054 }
1055
1056 case jpiKey:
1057 if (JsonbType(jb) == jbvObject)
1058 {
1059 JsonbValue *v;
1060 JsonbValue key;
1061
1062 key.type = jbvString;
1063 key.val.string.val = jspGetString(jsp, &key.val.string.len);
1064
1065 v = findJsonbValueFromContainer(jb->val.binary.data,
1066 JB_FOBJECT, &key);
1067
1068 if (v != NULL)
1069 {
1070 res = executeNextItem(cxt, jsp, NULL,
1071 v, found);
1072 pfree(v);
1073 }
1074 else if (!jspIgnoreStructuralErrors(cxt))
1075 {
1076 Assert(found);
1077
1078 if (!jspThrowErrors(cxt))
1079 return jperError;
1080
1081 ereport(ERROR,
1082 (errcode(ERRCODE_SQL_JSON_MEMBER_NOT_FOUND), \
1083 errmsg("JSON object does not contain key \"%s\"",
1084 pnstrdup(key.val.string.val,
1085 key.val.string.len))));
1086 }
1087 }
1088 else if (unwrap && JsonbType(jb) == jbvArray)
1089 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
1090 else if (!jspIgnoreStructuralErrors(cxt))
1091 {
1092 Assert(found);
1093 RETURN_ERROR(ereport(ERROR,
1094 (errcode(ERRCODE_SQL_JSON_MEMBER_NOT_FOUND),
1095 errmsg("jsonpath member accessor can only be applied to an object"))));
1096 }
1097 break;
1098
1099 case jpiCurrent:
1100 res = executeNextItem(cxt, jsp, NULL, cxt->current, found);
1101 break;
1102
1103 case jpiRoot:
1104 jb = cxt->root;
1105 baseObject = setBaseObject(cxt, jb, 0);
1106 res = executeNextItem(cxt, jsp, NULL, jb, found);
1107 cxt->baseObject = baseObject;
1108 break;
1109
1110 case jpiFilter:
1111 {
1112 JsonPathBool st;
1113
1114 if (unwrap && JsonbType(jb) == jbvArray)
1115 return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1116 false);
1117
1118 jspGetArg(jsp, &elem);
1119 st = executeNestedBoolItem(cxt, &elem, jb);
1120 if (st != jpbTrue)
1121 res = jperNotFound;
1122 else
1123 res = executeNextItem(cxt, jsp, NULL,
1124 jb, found);
1125 break;
1126 }
1127
1128 case jpiType:
1129 {
1130 JsonbValue jbv;
1131
1132 jbv.type = jbvString;
1133 jbv.val.string.val = pstrdup(JsonbTypeName(jb));
1134 jbv.val.string.len = strlen(jbv.val.string.val);
1135
1136 res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1137 }
1138 break;
1139
1140 case jpiSize:
1141 {
1142 int size = JsonbArraySize(jb);
1143 JsonbValue jbv;
1144
1145 if (size < 0)
1146 {
1147 if (!jspAutoWrap(cxt))
1148 {
1149 if (!jspIgnoreStructuralErrors(cxt))
1150 RETURN_ERROR(ereport(ERROR,
1151 (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND),
1152 errmsg("jsonpath item method .%s() can only be applied to an array",
1153 jspOperationName(jsp->type)))));
1154 break;
1155 }
1156
1157 size = 1;
1158 }
1159
1160 jbv.type = jbvNumeric;
1161 jbv.val.numeric = int64_to_numeric(size);
1162
1163 res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1164 }
1165 break;
1166
1167 case jpiAbs:
1168 return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_abs,
1169 found);
1170
1171 case jpiFloor:
1172 return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_floor,
1173 found);
1174
1175 case jpiCeiling:
1176 return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_ceil,
1177 found);
1178
1179 case jpiDouble:
1180 {
1181 JsonbValue jbv;
1182
1183 if (unwrap && JsonbType(jb) == jbvArray)
1184 return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1185 false);
1186
1187 if (jb->type == jbvNumeric)
1188 {
1189 char *tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
1190 NumericGetDatum(jb->val.numeric)));
1191 double val;
1192 ErrorSaveContext escontext = {T_ErrorSaveContext};
1193
1194 val = float8in_internal(tmp,
1195 NULL,
1196 "double precision",
1197 tmp,
1198 (Node *) &escontext);
1199
1200 if (escontext.error_occurred)
1201 RETURN_ERROR(ereport(ERROR,
1202 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1203 errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
1204 tmp, jspOperationName(jsp->type), "double precision"))));
1205 if (isinf(val) || isnan(val))
1206 RETURN_ERROR(ereport(ERROR,
1207 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1208 errmsg("NaN or Infinity is not allowed for jsonpath item method .%s()",
1209 jspOperationName(jsp->type)))));
1210 res = jperOk;
1211 }
1212 else if (jb->type == jbvString)
1213 {
1214 /* cast string as double */
1215 double val;
1216 char *tmp = pnstrdup(jb->val.string.val,
1217 jb->val.string.len);
1218 ErrorSaveContext escontext = {T_ErrorSaveContext};
1219
1220 val = float8in_internal(tmp,
1221 NULL,
1222 "double precision",
1223 tmp,
1224 (Node *) &escontext);
1225
1226 if (escontext.error_occurred)
1227 RETURN_ERROR(ereport(ERROR,
1228 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1229 errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
1230 tmp, jspOperationName(jsp->type), "double precision"))));
1231 if (isinf(val) || isnan(val))
1232 RETURN_ERROR(ereport(ERROR,
1233 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1234 errmsg("NaN or Infinity is not allowed for jsonpath item method .%s()",
1235 jspOperationName(jsp->type)))));
1236
1237 jb = &jbv;
1238 jb->type = jbvNumeric;
1239 jb->val.numeric = DatumGetNumeric(DirectFunctionCall1(float8_numeric,
1240 Float8GetDatum(val)));
1241 res = jperOk;
1242 }
1243
1244 if (res == jperNotFound)
1245 RETURN_ERROR(ereport(ERROR,
1246 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1247 errmsg("jsonpath item method .%s() can only be applied to a string or numeric value",
1248 jspOperationName(jsp->type)))));
1249
1250 res = executeNextItem(cxt, jsp, NULL, jb, found);
1251 }
1252 break;
1253
1254 case jpiDatetime:
1255 case jpiDate:
1256 case jpiTime:
1257 case jpiTimeTz:
1258 case jpiTimestamp:
1259 case jpiTimestampTz:
1260 if (unwrap && JsonbType(jb) == jbvArray)
1261 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
1262
1263 return executeDateTimeMethod(cxt, jsp, jb, found);
1264
1265 case jpiKeyValue:
1266 if (unwrap && JsonbType(jb) == jbvArray)
1267 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
1268
1269 return executeKeyValueMethod(cxt, jsp, jb, found);
1270
1271 case jpiLast:
1272 {
1273 JsonbValue jbv;
1274 int last;
1275 bool hasNext = jspGetNext(jsp, &elem);
1276
1277 if (cxt->innermostArraySize < 0)
1278 elog(ERROR, "evaluating jsonpath LAST outside of array subscript");
1279
1280 if (!hasNext && !found)
1281 {
1282 res = jperOk;
1283 break;
1284 }
1285
1286 last = cxt->innermostArraySize - 1;
1287
1288 jbv.type = jbvNumeric;
1289 jbv.val.numeric = int64_to_numeric(last);
1290
1291 res = executeNextItem(cxt, jsp, &elem,
1292 &jbv, found);
1293 }
1294 break;
1295
1296 case jpiBigint:
1297 {
1298 JsonbValue jbv;
1299 Datum datum;
1300
1301 if (unwrap && JsonbType(jb) == jbvArray)
1302 return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1303 false);
1304
1305 if (jb->type == jbvNumeric)
1306 {
1307 ErrorSaveContext escontext = {T_ErrorSaveContext};
1308 int64 val;
1309
1310 val = numeric_int8_safe(jb->val.numeric,
1311 (Node *) &escontext);
1312 if (escontext.error_occurred)
1313 RETURN_ERROR(ereport(ERROR,
1314 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1315 errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
1316 DatumGetCString(DirectFunctionCall1(numeric_out,
1317 NumericGetDatum(jb->val.numeric))),
1318 jspOperationName(jsp->type),
1319 "bigint"))));
1320
1321 datum = Int64GetDatum(val);
1322 res = jperOk;
1323 }
1324 else if (jb->type == jbvString)
1325 {
1326 /* cast string as bigint */
1327 char *tmp = pnstrdup(jb->val.string.val,
1328 jb->val.string.len);
1329 ErrorSaveContext escontext = {T_ErrorSaveContext};
1330 bool noerr;
1331
1332 noerr = DirectInputFunctionCallSafe(int8in, tmp,
1333 InvalidOid, -1,
1334 (Node *) &escontext,
1335 &datum);
1336
1337 if (!noerr || escontext.error_occurred)
1338 RETURN_ERROR(ereport(ERROR,
1339 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1340 errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
1341 tmp, jspOperationName(jsp->type), "bigint"))));
1342 res = jperOk;
1343 }
1344
1345 if (res == jperNotFound)
1346 RETURN_ERROR(ereport(ERROR,
1347 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1348 errmsg("jsonpath item method .%s() can only be applied to a string or numeric value",
1349 jspOperationName(jsp->type)))));
1350
1351 jbv.type = jbvNumeric;
1352 jbv.val.numeric = DatumGetNumeric(DirectFunctionCall1(int8_numeric,
1353 datum));
1354
1355 res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1356 }
1357 break;
1358
1359 case jpiBoolean:
1360 {
1361 JsonbValue jbv;
1362 bool bval;
1363
1364 if (unwrap && JsonbType(jb) == jbvArray)
1365 return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1366 false);
1367
1368 if (jb->type == jbvBool)
1369 {
1370 bval = jb->val.boolean;
1371
1372 res = jperOk;
1373 }
1374 else if (jb->type == jbvNumeric)
1375 {
1376 int ival;
1377 Datum datum;
1378 bool noerr;
1379 char *tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
1380 NumericGetDatum(jb->val.numeric)));
1381 ErrorSaveContext escontext = {T_ErrorSaveContext};
1382
1383 noerr = DirectInputFunctionCallSafe(int4in, tmp,
1384 InvalidOid, -1,
1385 (Node *) &escontext,
1386 &datum);
1387
1388 if (!noerr || escontext.error_occurred)
1389 RETURN_ERROR(ereport(ERROR,
1390 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1391 errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
1392 tmp, jspOperationName(jsp->type), "boolean"))));
1393
1394 ival = DatumGetInt32(datum);
1395 if (ival == 0)
1396 bval = false;
1397 else
1398 bval = true;
1399
1400 res = jperOk;
1401 }
1402 else if (jb->type == jbvString)
1403 {
1404 /* cast string as boolean */
1405 char *tmp = pnstrdup(jb->val.string.val,
1406 jb->val.string.len);
1407
1408 if (!parse_bool(tmp, &bval))
1409 RETURN_ERROR(ereport(ERROR,
1410 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1411 errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
1412 tmp, jspOperationName(jsp->type), "boolean"))));
1413
1414 res = jperOk;
1415 }
1416
1417 if (res == jperNotFound)
1418 RETURN_ERROR(ereport(ERROR,
1419 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1420 errmsg("jsonpath item method .%s() can only be applied to a boolean, string, or numeric value",
1421 jspOperationName(jsp->type)))));
1422
1423 jbv.type = jbvBool;
1424 jbv.val.boolean = bval;
1425
1426 res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1427 }
1428 break;
1429
1430 case jpiDecimal:
1431 case jpiNumber:
1432 {
1433 JsonbValue jbv;
1434 Numeric num;
1435 char *numstr = NULL;
1436
1437 if (unwrap && JsonbType(jb) == jbvArray)
1438 return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1439 false);
1440
1441 if (jb->type == jbvNumeric)
1442 {
1443 num = jb->val.numeric;
1444 if (numeric_is_nan(num) || numeric_is_inf(num))
1445 RETURN_ERROR(ereport(ERROR,
1446 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1447 errmsg("NaN or Infinity is not allowed for jsonpath item method .%s()",
1448 jspOperationName(jsp->type)))));
1449
1450 if (jsp->type == jpiDecimal)
1451 numstr = DatumGetCString(DirectFunctionCall1(numeric_out,
1452 NumericGetDatum(num)));
1453 res = jperOk;
1454 }
1455 else if (jb->type == jbvString)
1456 {
1457 /* cast string as number */
1458 Datum datum;
1459 bool noerr;
1460 ErrorSaveContext escontext = {T_ErrorSaveContext};
1461
1462 numstr = pnstrdup(jb->val.string.val, jb->val.string.len);
1463
1464 noerr = DirectInputFunctionCallSafe(numeric_in, numstr,
1465 InvalidOid, -1,
1466 (Node *) &escontext,
1467 &datum);
1468
1469 if (!noerr || escontext.error_occurred)
1470 RETURN_ERROR(ereport(ERROR,
1471 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1472 errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
1473 numstr, jspOperationName(jsp->type), "numeric"))));
1474
1475 num = DatumGetNumeric(datum);
1476 if (numeric_is_nan(num) || numeric_is_inf(num))
1477 RETURN_ERROR(ereport(ERROR,
1478 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1479 errmsg("NaN or Infinity is not allowed for jsonpath item method .%s()",
1480 jspOperationName(jsp->type)))));
1481
1482 res = jperOk;
1483 }
1484
1485 if (res == jperNotFound)
1486 RETURN_ERROR(ereport(ERROR,
1487 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1488 errmsg("jsonpath item method .%s() can only be applied to a string or numeric value",
1489 jspOperationName(jsp->type)))));
1490
1491 /*
1492 * If we have arguments, then they must be the precision and
1493 * optional scale used in .decimal(). Convert them to the
1494 * typmod equivalent and then truncate the numeric value per
1495 * this typmod details.
1496 */
1497 if (jsp->type == jpiDecimal && jsp->content.args.left)
1498 {
1499 Datum numdatum;
1500 int32 dtypmod;
1501 int32 precision;
1502 int32 scale = 0;
1503 bool noerr;
1504 ErrorSaveContext escontext = {T_ErrorSaveContext};
1505
1506 jspGetLeftArg(jsp, &elem);
1507 if (elem.type != jpiNumeric)
1508 elog(ERROR, "invalid jsonpath item type for .decimal() precision");
1509
1510 precision = numeric_int4_safe(jspGetNumeric(&elem),
1511 (Node *) &escontext);
1512 if (escontext.error_occurred)
1513 RETURN_ERROR(ereport(ERROR,
1514 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1515 errmsg("precision of jsonpath item method .%s() is out of range for type integer",
1516 jspOperationName(jsp->type)))));
1517
1518 if (jsp->content.args.right)
1519 {
1520 jspGetRightArg(jsp, &elem);
1521 if (elem.type != jpiNumeric)
1522 elog(ERROR, "invalid jsonpath item type for .decimal() scale");
1523
1524 scale = numeric_int4_safe(jspGetNumeric(&elem),
1525 (Node *) &escontext);
1526 if (escontext.error_occurred)
1527 RETURN_ERROR(ereport(ERROR,
1528 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1529 errmsg("scale of jsonpath item method .%s() is out of range for type integer",
1530 jspOperationName(jsp->type)))));
1531 }
1532
1533 /* Pack the precision and scale into a numeric typmod */
1534 dtypmod = make_numeric_typmod_safe(precision, scale,
1535 jspThrowErrors(cxt) ? NULL : (Node *) &escontext);
1536 if (escontext.error_occurred)
1537 return jperError;
1538
1539 /* Convert numstr to Numeric with typmod */
1540 Assert(numstr != NULL);
1541 noerr = DirectInputFunctionCallSafe(numeric_in, numstr,
1542 InvalidOid, dtypmod,
1543 (Node *) &escontext,
1544 &numdatum);
1545
1546 if (!noerr || escontext.error_occurred)
1547 RETURN_ERROR(ereport(ERROR,
1548 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1549 errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
1550 numstr, jspOperationName(jsp->type), "numeric"))));
1551
1552 num = DatumGetNumeric(numdatum);
1553 }
1554
1555 jbv.type = jbvNumeric;
1556 jbv.val.numeric = num;
1557
1558 res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1559 }
1560 break;
1561
1562 case jpiInteger:
1563 {
1564 JsonbValue jbv;
1565 Datum datum;
1566
1567 if (unwrap && JsonbType(jb) == jbvArray)
1568 return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1569 false);
1570
1571 if (jb->type == jbvNumeric)
1572 {
1573 int32 val;
1574 ErrorSaveContext escontext = {T_ErrorSaveContext};
1575
1576 val = numeric_int4_safe(jb->val.numeric,
1577 (Node *) &escontext);
1578 if (escontext.error_occurred)
1579 RETURN_ERROR(ereport(ERROR,
1580 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1581 errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
1582 DatumGetCString(DirectFunctionCall1(numeric_out,
1583 NumericGetDatum(jb->val.numeric))),
1584 jspOperationName(jsp->type), "integer"))));
1585
1586 datum = Int32GetDatum(val);
1587 res = jperOk;
1588 }
1589 else if (jb->type == jbvString)
1590 {
1591 /* cast string as integer */
1592 char *tmp = pnstrdup(jb->val.string.val,
1593 jb->val.string.len);
1594 ErrorSaveContext escontext = {T_ErrorSaveContext};
1595 bool noerr;
1596
1597 noerr = DirectInputFunctionCallSafe(int4in, tmp,
1598 InvalidOid, -1,
1599 (Node *) &escontext,
1600 &datum);
1601
1602 if (!noerr || escontext.error_occurred)
1603 RETURN_ERROR(ereport(ERROR,
1604 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1605 errmsg("argument \"%s\" of jsonpath item method .%s() is invalid for type %s",
1606 tmp, jspOperationName(jsp->type), "integer"))));
1607 res = jperOk;
1608 }
1609
1610 if (res == jperNotFound)
1611 RETURN_ERROR(ereport(ERROR,
1612 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1613 errmsg("jsonpath item method .%s() can only be applied to a string or numeric value",
1614 jspOperationName(jsp->type)))));
1615
1616 jbv.type = jbvNumeric;
1617 jbv.val.numeric = DatumGetNumeric(DirectFunctionCall1(int4_numeric,
1618 datum));
1619
1620 res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1621 }
1622 break;
1623
1624 case jpiStringFunc:
1625 {
1626 JsonbValue jbv;
1627 char *tmp = NULL;
1628
1629 if (unwrap && JsonbType(jb) == jbvArray)
1630 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
1631
1632 switch (JsonbType(jb))
1633 {
1634 case jbvString:
1635
1636 /*
1637 * Value is not necessarily null-terminated, so we do
1638 * pnstrdup() here.
1639 */
1640 tmp = pnstrdup(jb->val.string.val,
1641 jb->val.string.len);
1642 break;
1643 case jbvNumeric:
1644 tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
1645 NumericGetDatum(jb->val.numeric)));
1646 break;
1647 case jbvBool:
1648 tmp = (jb->val.boolean) ? "true" : "false";
1649 break;
1650 case jbvDatetime:
1651 {
1652 char buf[MAXDATELEN + 1];
1653
1654 JsonEncodeDateTime(buf,
1655 jb->val.datetime.value,
1656 jb->val.datetime.typid,
1657 &jb->val.datetime.tz);
1658 tmp = pstrdup(buf);
1659 }
1660 break;
1661 case jbvNull:
1662 case jbvArray:
1663 case jbvObject:
1664 case jbvBinary:
1665 RETURN_ERROR(ereport(ERROR,
1666 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
1667 errmsg("jsonpath item method .%s() can only be applied to a boolean, string, numeric, or datetime value",
1668 jspOperationName(jsp->type)))));
1669 break;
1670 }
1671
1672 Assert(tmp != NULL); /* We must have set tmp above */
1673 jbv.val.string.val = tmp;
1674 jbv.val.string.len = strlen(jbv.val.string.val);
1675 jbv.type = jbvString;
1676
1677 res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1678 }
1679 break;
1680
1681 case jpiStrReplace:
1682 case jpiStrLower:
1683 case jpiStrUpper:
1684 case jpiStrLtrim:
1685 case jpiStrRtrim:
1686 case jpiStrBtrim:
1687 case jpiStrInitcap:
1688 case jpiStrSplitPart:
1689 {
1690 if (unwrap && JsonbType(jb) == jbvArray)
1691 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
1692
1693 return executeStringInternalMethod(cxt, jsp, jb, found);
1694 }
1695 break;
1696
1697 default:
1698 elog(ERROR, "unrecognized jsonpath item type: %d", jsp->type);
1699 }
1700
1701 return res;
1702}
1703
1704/*
1705 * Unwrap current array item and execute jsonpath for each of its elements.
1706 */
1707static JsonPathExecResult
1708executeItemUnwrapTargetArray(JsonPathExecContext *cxt, JsonPathItem *jsp,
1709 JsonbValue *jb, JsonValueList *found,
1710 bool unwrapElements)
1711{
1712 if (jb->type != jbvBinary)
1713 {
1714 Assert(jb->type != jbvArray);
1715 elog(ERROR, "invalid jsonb array value type: %d", jb->type);
1716 }
1717
1718 return executeAnyItem
1719 (cxt, jsp, jb->val.binary.data, found, 1, 1, 1,
1720 false, unwrapElements);
1721}
1722
1723/*
1724 * Execute next jsonpath item if exists. Otherwise put "v" to the "found"
1725 * list if provided.
1726 */
1727static JsonPathExecResult
1728executeNextItem(JsonPathExecContext *cxt,
1729 JsonPathItem *cur, JsonPathItem *next,
1730 JsonbValue *v, JsonValueList *found)
1731{
1732 JsonPathItem elem;
1733 bool hasNext;
1734
1735 if (!cur)
1736 hasNext = next != NULL;
1737 else if (next)
1738 hasNext = jspHasNext(cur);
1739 else
1740 {
1741 next = &elem;
1742 hasNext = jspGetNext(cur, next);
1743 }
1744
1745 if (hasNext)
1746 return executeItem(cxt, next, v, found);
1747
1748 if (found)
1749 JsonValueListAppend(found, v);
1750
1751 return jperOk;
1752}
1753
1754/*
1755 * Same as executeItem(), but when "unwrap == true" automatically unwraps
1756 * each array item from the resulting sequence in lax mode.
1757 */
1758static JsonPathExecResult
1759executeItemOptUnwrapResult(JsonPathExecContext *cxt, JsonPathItem *jsp,
1760 JsonbValue *jb, bool unwrap,
1761 JsonValueList *found)
1762{
1763 if (unwrap && jspAutoUnwrap(cxt))
1764 {
1765 JsonValueList seq;
1766 JsonValueListIterator it;
1767 JsonPathExecResult res;
1768 JsonbValue *item;
1769
1770 JsonValueListInit(&seq);
1771
1772 res = executeItem(cxt, jsp, jb, &seq);
1773
1774 if (jperIsError(res))
1775 {
1776 JsonValueListClear(&seq);
1777 return res;
1778 }
1779
1780 JsonValueListInitIterator(&seq, &it);
1781 while ((item = JsonValueListNext(&it)))
1782 {
1783 Assert(item->type != jbvArray);
1784
1785 if (JsonbType(item) == jbvArray)
1786 executeItemUnwrapTargetArray(cxt, NULL, item, found, false);
1787 else
1788 JsonValueListAppend(found, item);
1789 }
1790
1791 JsonValueListClear(&seq);
1792
1793 return jperOk;
1794 }
1795
1796 return executeItem(cxt, jsp, jb, found);
1797}
1798
1799/*
1800 * Same as executeItemOptUnwrapResult(), but with error suppression.
1801 */
1802static JsonPathExecResult
1803executeItemOptUnwrapResultNoThrow(JsonPathExecContext *cxt,
1804 JsonPathItem *jsp,
1805 JsonbValue *jb, bool unwrap,
1806 JsonValueList *found)
1807{
1808 JsonPathExecResult res;
1809 bool throwErrors = cxt->throwErrors;
1810
1811 cxt->throwErrors = false;
1812 res = executeItemOptUnwrapResult(cxt, jsp, jb, unwrap, found);
1813 cxt->throwErrors = throwErrors;
1814
1815 return res;
1816}
1817
1818/* Execute boolean-valued jsonpath expression. */
1819static JsonPathBool
1820executeBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp,
1821 JsonbValue *jb, bool canHaveNext)
1822{
1823 JsonPathItem larg;
1824 JsonPathItem rarg;
1825 JsonPathBool res;
1826 JsonPathBool res2;
1827
1828 /* since this function recurses, it could be driven to stack overflow */
1829 check_stack_depth();
1830
1831 if (!canHaveNext && jspHasNext(jsp))
1832 elog(ERROR, "boolean jsonpath item cannot have next item");
1833
1834 switch (jsp->type)
1835 {
1836 case jpiAnd:
1837 jspGetLeftArg(jsp, &larg);
1838 res = executeBoolItem(cxt, &larg, jb, false);
1839
1840 if (res == jpbFalse)
1841 return jpbFalse;
1842
1843 /*
1844 * SQL/JSON says that we should check second arg in case of
1845 * jperError
1846 */
1847
1848 jspGetRightArg(jsp, &rarg);
1849 res2 = executeBoolItem(cxt, &rarg, jb, false);
1850
1851 return res2 == jpbTrue ? res : res2;
1852
1853 case jpiOr:
1854 jspGetLeftArg(jsp, &larg);
1855 res = executeBoolItem(cxt, &larg, jb, false);
1856
1857 if (res == jpbTrue)
1858 return jpbTrue;
1859
1860 jspGetRightArg(jsp, &rarg);
1861 res2 = executeBoolItem(cxt, &rarg, jb, false);
1862
1863 return res2 == jpbFalse ? res : res2;
1864
1865 case jpiNot:
1866 jspGetArg(jsp, &larg);
1867
1868 res = executeBoolItem(cxt, &larg, jb, false);
1869
1870 if (res == jpbUnknown)
1871 return jpbUnknown;
1872
1873 return res == jpbTrue ? jpbFalse : jpbTrue;
1874
1875 case jpiIsUnknown:
1876 jspGetArg(jsp, &larg);
1877 res = executeBoolItem(cxt, &larg, jb, false);
1878 return res == jpbUnknown ? jpbTrue : jpbFalse;
1879
1880 case jpiEqual:
1881 case jpiNotEqual:
1882 case jpiLess:
1883 case jpiGreater:
1884 case jpiLessOrEqual:
1885 case jpiGreaterOrEqual:
1886 jspGetLeftArg(jsp, &larg);
1887 jspGetRightArg(jsp, &rarg);
1888 return executePredicate(cxt, jsp, &larg, &rarg, jb, true,
1889 executeComparison, cxt);
1890
1891 case jpiStartsWith: /* 'whole STARTS WITH initial' */
1892 jspGetLeftArg(jsp, &larg); /* 'whole' */
1893 jspGetRightArg(jsp, &rarg); /* 'initial' */
1894 return executePredicate(cxt, jsp, &larg, &rarg, jb, false,
1895 executeStartsWith, NULL);
1896
1897 case jpiLikeRegex: /* 'expr LIKE_REGEX pattern FLAGS flags' */
1898 {
1899 /*
1900 * 'expr' is a sequence-returning expression. 'pattern' is a
1901 * regex string literal. SQL/JSON standard requires XQuery
1902 * regexes, but we use Postgres regexes here. 'flags' is a
1903 * string literal converted to integer flags at compile-time.
1904 */
1905 JsonLikeRegexContext lrcxt = {0};
1906
1907 jspInitByBuffer(&larg, jsp->base,
1908 jsp->content.like_regex.expr);
1909
1910 return executePredicate(cxt, jsp, &larg, NULL, jb, false,
1911 executeLikeRegex, &lrcxt);
1912 }
1913
1914 case jpiExists:
1915 jspGetArg(jsp, &larg);
1916
1917 if (jspStrictAbsenceOfErrors(cxt))
1918 {
1919 /*
1920 * In strict mode we must get a complete list of values to
1921 * check that there are no errors at all.
1922 */
1923 JsonValueList vals;
1924 JsonPathExecResult res;
1925 bool isempty;
1926
1927 JsonValueListInit(&vals);
1928
1929 res = executeItemOptUnwrapResultNoThrow(cxt, &larg, jb,
1930 false, &vals);
1931
1932 isempty = JsonValueListIsEmpty(&vals);
1933 JsonValueListClear(&vals);
1934
1935 if (jperIsError(res))
1936 return jpbUnknown;
1937
1938 return isempty ? jpbFalse : jpbTrue;
1939 }
1940 else
1941 {
1942 JsonPathExecResult res =
1943 executeItemOptUnwrapResultNoThrow(cxt, &larg, jb,
1944 false, NULL);
1945
1946 if (jperIsError(res))
1947 return jpbUnknown;
1948
1949 return res == jperOk ? jpbTrue : jpbFalse;
1950 }
1951
1952 default:
1953 elog(ERROR, "invalid boolean jsonpath item type: %d", jsp->type);
1954 return jpbUnknown;
1955 }
1956}
1957
1958/*
1959 * Execute nested (filters etc.) boolean expression pushing current SQL/JSON
1960 * item onto the stack.
1961 */
1962static JsonPathBool
1963executeNestedBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp,
1964 JsonbValue *jb)
1965{
1966 JsonbValue *prev;
1967 JsonPathBool res;
1968
1969 prev = cxt->current;
1970 cxt->current = jb;
1971 res = executeBoolItem(cxt, jsp, jb, false);
1972 cxt->current = prev;
1973
1974 return res;
1975}
1976
1977/*
1978 * Implementation of several jsonpath nodes:
1979 * - jpiAny (.** accessor),
1980 * - jpiAnyKey (.* accessor),
1981 * - jpiAnyArray ([*] accessor)
1982 */
1983static JsonPathExecResult
1984executeAnyItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbContainer *jbc,
1985 JsonValueList *found, uint32 level, uint32 first, uint32 last,
1986 bool ignoreStructuralErrors, bool unwrapNext)
1987{
1988 JsonPathExecResult res = jperNotFound;
1989 JsonbIterator *it;
1990 int32 r;
1991 JsonbValue v;
1992
1993 check_stack_depth();
1994
1995 if (level > last)
1996 return res;
1997
1998 it = JsonbIteratorInit(jbc);
1999
2000 /*
2001 * Recursively iterate over jsonb objects/arrays
2002 */
2003 while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE)
2004 {
2005 if (r == WJB_KEY)
2006 {
2007 r = JsonbIteratorNext(&it, &v, true);
2008 Assert(r == WJB_VALUE);
2009 }
2010
2011 if (r == WJB_VALUE || r == WJB_ELEM)
2012 {
2013
2014 if (level >= first ||
2015 (first == PG_UINT32_MAX && last == PG_UINT32_MAX &&
2016 v.type != jbvBinary)) /* leaves only requested */
2017 {
2018 /* check expression */
2019 if (jsp)
2020 {
2021 if (ignoreStructuralErrors)
2022 {
2023 bool savedIgnoreStructuralErrors;
2024
2025 savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors;
2026 cxt->ignoreStructuralErrors = true;
2027 res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext);
2028 cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors;
2029 }
2030 else
2031 res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext);
2032
2033 if (jperIsError(res))
2034 break;
2035
2036 if (res == jperOk && !found)
2037 break;
2038 }
2039 else if (found)
2040 JsonValueListAppend(found, &v);
2041 else
2042 return jperOk;
2043 }
2044
2045 if (level < last && v.type == jbvBinary)
2046 {
2047 res = executeAnyItem
2048 (cxt, jsp, v.val.binary.data, found,
2049 level + 1, first, last,
2050 ignoreStructuralErrors, unwrapNext);
2051
2052 if (jperIsError(res))
2053 break;
2054
2055 if (res == jperOk && found == NULL)
2056 break;
2057 }
2058 }
2059 }
2060
2061 return res;
2062}
2063
2064/*
2065 * Execute unary or binary predicate.
2066 *
2067 * Predicates have existence semantics, because their operands are item
2068 * sequences. Pairs of items from the left and right operand's sequences are
2069 * checked. TRUE returned only if any pair satisfying the condition is found.
2070 * In strict mode, even if the desired pair has already been found, all pairs
2071 * still need to be examined to check the absence of errors. If any error
2072 * occurs, UNKNOWN (analogous to SQL NULL) is returned.
2073 */
2074static JsonPathBool
2075executePredicate(JsonPathExecContext *cxt, JsonPathItem *pred,
2076 JsonPathItem *larg, JsonPathItem *rarg, JsonbValue *jb,
2077 bool unwrapRightArg, JsonPathPredicateCallback exec,
2078 void *param)
2079{
2080 JsonPathExecResult res;
2081 JsonValueListIterator lseqit;
2082 JsonValueList lseq;
2083 JsonValueList rseq;
2084 JsonbValue *lval;
2085 bool error = false;
2086 bool found = false;
2087
2088 JsonValueListInit(&lseq);
2089 JsonValueListInit(&rseq);
2090
2091 /* Left argument is always auto-unwrapped. */
2092 res = executeItemOptUnwrapResultNoThrow(cxt, larg, jb, true, &lseq);
2093 if (jperIsError(res))
2094 {
2095 error = true;
2096 goto exit;
2097 }
2098
2099 if (rarg)
2100 {
2101 /* Right argument is conditionally auto-unwrapped. */
2102 res = executeItemOptUnwrapResultNoThrow(cxt, rarg, jb,
2103 unwrapRightArg, &rseq);
2104 if (jperIsError(res))
2105 {
2106 error = true;
2107 goto exit;
2108 }
2109 }
2110
2111 JsonValueListInitIterator(&lseq, &lseqit);
2112 while ((lval = JsonValueListNext(&lseqit)))
2113 {
2114 JsonValueListIterator rseqit;
2115 JsonbValue *rval;
2116 bool first = true;
2117
2118 JsonValueListInitIterator(&rseq, &rseqit);
2119 if (rarg)
2120 rval = JsonValueListNext(&rseqit);
2121 else
2122 rval = NULL;
2123
2124 /* Loop over right arg sequence or do single pass otherwise */
2125 while (rarg ? (rval != NULL) : first)
2126 {
2127 JsonPathBool res = exec(pred, lval, rval, param);
2128
2129 if (res == jpbUnknown)
2130 {
2131 error = true;
2132 if (jspStrictAbsenceOfErrors(cxt))
2133 {
2134 found = false; /* return unknown, not success */
2135 goto exit;
2136 }
2137 }
2138 else if (res == jpbTrue)
2139 {
2140 found = true;
2141 if (!jspStrictAbsenceOfErrors(cxt))
2142 goto exit;
2143 }
2144
2145 first = false;
2146 if (rarg)
2147 rval = JsonValueListNext(&rseqit);
2148 }
2149 }
2150
2151exit:
2152 JsonValueListClear(&lseq);
2153 JsonValueListClear(&rseq);
2154
2155 if (found) /* possible only in strict mode */
2156 return jpbTrue;
2157
2158 if (error) /* possible only in lax mode */
2159 return jpbUnknown;
2160
2161 return jpbFalse;
2162}
2163
2164/*
2165 * Execute binary arithmetic expression on singleton numeric operands.
2166 * Array operands are automatically unwrapped in lax mode.
2167 */
2168static JsonPathExecResult
2169executeBinaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp,
2170 JsonbValue *jb, BinaryArithmFunc func,
2171 JsonValueList *found)
2172{
2173 JsonPathExecResult jper;
2174 JsonPathItem elem;
2175 JsonValueList lseq;
2176 JsonValueList rseq;
2177 JsonbValue *lval;
2178 JsonbValue *rval;
2179 JsonbValue resval;
2180 Numeric res;
2181
2182 JsonValueListInit(&lseq);
2183 JsonValueListInit(&rseq);
2184
2185 jspGetLeftArg(jsp, &elem);
2186
2187 /*
2188 * XXX: By standard only operands of multiplicative expressions are
2189 * unwrapped. We extend it to other binary arithmetic expressions too.
2190 */
2191 jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &lseq);
2192 if (jperIsError(jper))
2193 {
2194 JsonValueListClear(&lseq);
2195 JsonValueListClear(&rseq);
2196 return jper;
2197 }
2198
2199 jspGetRightArg(jsp, &elem);
2200
2201 jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &rseq);
2202 if (jperIsError(jper))
2203 {
2204 JsonValueListClear(&lseq);
2205 JsonValueListClear(&rseq);
2206 return jper;
2207 }
2208
2209 if (!JsonValueListIsSingleton(&lseq) ||
2210 !(lval = getScalar(JsonValueListHead(&lseq), jbvNumeric)))
2211 {
2212 JsonValueListClear(&lseq);
2213 JsonValueListClear(&rseq);
2214 RETURN_ERROR(ereport(ERROR,
2215 (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
2216 errmsg("left operand of jsonpath operator %s is not a single numeric value",
2217 jspOperationName(jsp->type)))));
2218 }
2219
2220 if (!JsonValueListIsSingleton(&rseq) ||
2221 !(rval = getScalar(JsonValueListHead(&rseq), jbvNumeric)))
2222 {
2223 JsonValueListClear(&lseq);
2224 JsonValueListClear(&rseq);
2225 RETURN_ERROR(ereport(ERROR,
2226 (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
2227 errmsg("right operand of jsonpath operator %s is not a single numeric value",
2228 jspOperationName(jsp->type)))));
2229 }
2230
2231 if (jspThrowErrors(cxt))
2232 {
2233 res = func(lval->val.numeric, rval->val.numeric, NULL);
2234 }
2235 else
2236 {
2237 ErrorSaveContext escontext = {T_ErrorSaveContext};
2238
2239 res = func(lval->val.numeric, rval->val.numeric, (Node *) &escontext);
2240
2241 if (escontext.error_occurred)
2242 {
2243 JsonValueListClear(&lseq);
2244 JsonValueListClear(&rseq);
2245 return jperError;
2246 }
2247 }
2248
2249 JsonValueListClear(&lseq);
2250 JsonValueListClear(&rseq);
2251
2252 if (!jspGetNext(jsp, &elem) && !found)
2253 return jperOk;
2254
2255 resval.type = jbvNumeric;
2256 resval.val.numeric = res;
2257
2258 return executeNextItem(cxt, jsp, &elem, &resval, found);
2259}
2260
2261/*
2262 * Execute unary arithmetic expression for each numeric item in its operand's
2263 * sequence. Array operand is automatically unwrapped in lax mode.
2264 */
2265static JsonPathExecResult
2266executeUnaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp,
2267 JsonbValue *jb, PGFunction func, JsonValueList *found)
2268{
2269 JsonPathExecResult jper;
2270 JsonPathExecResult jper2;
2271 JsonPathItem elem;
2272 JsonValueList seq;
2273 JsonValueListIterator it;
2274 JsonbValue *val;
2275 bool hasNext;
2276
2277 JsonValueListInit(&seq);
2278
2279 jspGetArg(jsp, &elem);
2280 jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &seq);
2281
2282 if (jperIsError(jper))
2283 goto exit;
2284
2285 jper = jperNotFound;
2286
2287 hasNext = jspGetNext(jsp, &elem);
2288
2289 JsonValueListInitIterator(&seq, &it);
2290 while ((val = JsonValueListNext(&it)))
2291 {
2292 if ((val = getScalar(val, jbvNumeric)))
2293 {
2294 if (!found && !hasNext)
2295 {
2296 jper = jperOk;
2297 goto exit;
2298 }
2299 }
2300 else
2301 {
2302 if (!found && !hasNext)
2303 continue; /* skip non-numerics processing */
2304
2305 JsonValueListClear(&seq);
2306 RETURN_ERROR(ereport(ERROR,
2307 (errcode(ERRCODE_SQL_JSON_NUMBER_NOT_FOUND),
2308 errmsg("operand of unary jsonpath operator %s is not a numeric value",
2309 jspOperationName(jsp->type)))));
2310 }
2311
2312 if (func)
2313 val->val.numeric =
2314 DatumGetNumeric(DirectFunctionCall1(func,
2315 NumericGetDatum(val->val.numeric)));
2316
2317 jper2 = executeNextItem(cxt, jsp, &elem, val, found);
2318
2319 if (jperIsError(jper2))
2320 {
2321 jper = jper2;
2322 goto exit;
2323 }
2324
2325 if (jper2 == jperOk)
2326 {
2327 jper = jperOk;
2328 if (!found)
2329 goto exit;
2330 }
2331 }
2332
2333exit:
2334 JsonValueListClear(&seq);
2335
2336 return jper;
2337}
2338
2339/*
2340 * STARTS_WITH predicate callback.
2341 *
2342 * Check if the 'whole' string starts from 'initial' string.
2343 */
2344static JsonPathBool
2345executeStartsWith(JsonPathItem *jsp, JsonbValue *whole, JsonbValue *initial,
2346 void *param)
2347{
2348 if (!(whole = getScalar(whole, jbvString)))
2349 return jpbUnknown; /* error */
2350
2351 if (!(initial = getScalar(initial, jbvString)))
2352 return jpbUnknown; /* error */
2353
2354 if (whole->val.string.len >= initial->val.string.len &&
2355 !memcmp(whole->val.string.val,
2356 initial->val.string.val,
2357 initial->val.string.len))
2358 return jpbTrue;
2359
2360 return jpbFalse;
2361}
2362
2363/*
2364 * LIKE_REGEX predicate callback.
2365 *
2366 * Check if the string matches regex pattern.
2367 */
2368static JsonPathBool
2369executeLikeRegex(JsonPathItem *jsp, JsonbValue *str, JsonbValue *rarg,
2370 void *param)
2371{
2372 JsonLikeRegexContext *cxt = param;
2373
2374 if (!(str = getScalar(str, jbvString)))
2375 return jpbUnknown;
2376
2377 /* Cache regex text and converted flags. */
2378 if (!cxt->regex)
2379 {
2380 cxt->regex =
2381 cstring_to_text_with_len(jsp->content.like_regex.pattern,
2382 jsp->content.like_regex.patternlen);
2383 (void) jspConvertRegexFlags(jsp->content.like_regex.flags,
2384 &(cxt->cflags), NULL);
2385 }
2386
2387 if (RE_compile_and_execute(cxt->regex, str->val.string.val,
2388 str->val.string.len,
2389 cxt->cflags, DEFAULT_COLLATION_OID, 0, NULL))
2390 return jpbTrue;
2391
2392 return jpbFalse;
2393}
2394
2395/*
2396 * Execute numeric item methods (.abs(), .floor(), .ceil()) using the specified
2397 * user function 'func'.
2398 */
2399static JsonPathExecResult
2400executeNumericItemMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
2401 JsonbValue *jb, bool unwrap, PGFunction func,
2402 JsonValueList *found)
2403{
2404 JsonPathItem next;
2405 Datum datum;
2406 JsonbValue jbv;
2407
2408 if (unwrap && JsonbType(jb) == jbvArray)
2409 return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
2410
2411 if (!(jb = getScalar(jb, jbvNumeric)))
2412 RETURN_ERROR(ereport(ERROR,
2413 (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM),
2414 errmsg("jsonpath item method .%s() can only be applied to a numeric value",
2415 jspOperationName(jsp->type)))));
2416
2417 datum = DirectFunctionCall1(func, NumericGetDatum(jb->val.numeric));
2418
2419 if (!jspGetNext(jsp, &next) && !found)
2420 return jperOk;
2421
2422 jbv.type = jbvNumeric;
2423 jbv.val.numeric = DatumGetNumeric(datum);
2424
2425 return executeNextItem(cxt, jsp, &next, &jbv, found);
2426}
2427
2428/*
2429 * Implementation of the .datetime() and related methods.
2430 *
2431 * Converts a string into a date/time value. The actual type is determined at
2432 * run time.
2433 * If an argument is provided, this argument is used as a template string.
2434 * Otherwise, the first fitting ISO format is selected.
2435 *
2436 * .date(), .time(), .time_tz(), .timestamp(), .timestamp_tz() methods don't
2437 * have a format, so ISO format is used. However, except for .date(), they all
2438 * take an optional time precision.
2439 */
2440static JsonPathExecResult
2441executeDateTimeMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
2442 JsonbValue *jb, JsonValueList *found)
2443{
2444 JsonbValue jbv;
2445 Datum value;
2446 text *datetime;
2447 Oid collid;
2448 Oid typid;
2449 int32 typmod = -1;
2450 int tz = 0;
2451 bool hasNext;
2452 JsonPathExecResult res = jperNotFound;
2453 JsonPathItem elem;
2454 int32 time_precision = -1;
2455
2456 if (!(jb = getScalar(jb, jbvString)))
2457 RETURN_ERROR(ereport(ERROR,
2458 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
2459 errmsg("jsonpath item method .%s() can only be applied to a string",
2460 jspOperationName(jsp->type)))));
2461
2462 datetime = cstring_to_text_with_len(jb->val.string.val,
2463 jb->val.string.len);
2464
2465 /*
2466 * At some point we might wish to have callers supply the collation to
2467 * use, but right now it's unclear that they'd be able to do better than
2468 * DEFAULT_COLLATION_OID anyway.
2469 */
2470 collid = DEFAULT_COLLATION_OID;
2471
2472 /*
2473 * .datetime(template) has an argument, the rest of the methods don't have
2474 * an argument. So we handle that separately.
2475 */
2476 if (jsp->type == jpiDatetime && jsp->content.arg)
2477 {
2478 text *template;
2479 char *template_str;
2480 int template_len;
2481 ErrorSaveContext escontext = {T_ErrorSaveContext};
2482
2483 jspGetArg(jsp, &elem);
2484
2485 if (elem.type != jpiString)
2486 elog(ERROR, "invalid jsonpath item type for .datetime() argument");
2487
2488 template_str = jspGetString(&elem, &template_len);
2489
2490 template = cstring_to_text_with_len(template_str,
2491 template_len);
2492
2493 value = parse_datetime(datetime, template, collid, true,
2494 &typid, &typmod, &tz,
2495 jspThrowErrors(cxt) ? NULL : (Node *) &escontext);
2496
2497 if (escontext.error_occurred)
2498 res = jperError;
2499 else
2500 res = jperOk;
2501 }
2502 else
2503 {
2504 /*
2505 * According to SQL/JSON standard enumerate ISO formats for: date,
2506 * timetz, time, timestamptz, timestamp.
2507 *
2508 * We also support ISO 8601 format (with "T") for timestamps, because
2509 * to_json[b]() functions use this format.
2510 */
2511 static const char *fmt_str[] =
2512 {
2513 "yyyy-mm-dd", /* date */
2514 "HH24:MI:SS.USTZ", /* timetz */
2515 "HH24:MI:SSTZ",
2516 "HH24:MI:SS.US", /* time without tz */
2517 "HH24:MI:SS",
2518 "yyyy-mm-dd HH24:MI:SS.USTZ", /* timestamptz */
2519 "yyyy-mm-dd HH24:MI:SSTZ",
2520 "yyyy-mm-dd\"T\"HH24:MI:SS.USTZ",
2521 "yyyy-mm-dd\"T\"HH24:MI:SSTZ",
2522 "yyyy-mm-dd HH24:MI:SS.US", /* timestamp without tz */
2523 "yyyy-mm-dd HH24:MI:SS",
2524 "yyyy-mm-dd\"T\"HH24:MI:SS.US",
2525 "yyyy-mm-dd\"T\"HH24:MI:SS"
2526 };
2527
2528 /* cache for format texts */
2529 static text *fmt_txt[lengthof(fmt_str)] = {0};
2530
2531 /*
2532 * Check for optional precision for methods other than .datetime() and
2533 * .date()
2534 */
2535 if (jsp->type != jpiDatetime && jsp->type != jpiDate &&
2536 jsp->content.arg)
2537 {
2538 ErrorSaveContext escontext = {T_ErrorSaveContext};
2539
2540 jspGetArg(jsp, &elem);
2541
2542 if (elem.type != jpiNumeric)
2543 elog(ERROR, "invalid jsonpath item type for %s argument",
2544 jspOperationName(jsp->type));
2545
2546 time_precision = numeric_int4_safe(jspGetNumeric(&elem),
2547 (Node *) &escontext);
2548 if (escontext.error_occurred)
2549 RETURN_ERROR(ereport(ERROR,
2550 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
2551 errmsg("time precision of jsonpath item method .%s() is out of range for type integer",
2552 jspOperationName(jsp->type)))));
2553 }
2554
2555 /* loop until datetime format fits */
2556 for (size_t i = 0; i < lengthof(fmt_str); i++)
2557 {
2558 ErrorSaveContext escontext = {T_ErrorSaveContext};
2559
2560 if (!fmt_txt[i])
2561 {
2562 MemoryContext oldcxt =
2563 MemoryContextSwitchTo(TopMemoryContext);
2564
2565 fmt_txt[i] = cstring_to_text(fmt_str[i]);
2566 MemoryContextSwitchTo(oldcxt);
2567 }
2568
2569 value = parse_datetime(datetime, fmt_txt[i], collid, true,
2570 &typid, &typmod, &tz,
2571 (Node *) &escontext);
2572
2573 if (!escontext.error_occurred)
2574 {
2575 res = jperOk;
2576 break;
2577 }
2578 }
2579
2580 if (res == jperNotFound)
2581 {
2582 if (jsp->type == jpiDatetime)
2583 RETURN_ERROR(ereport(ERROR,
2584 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
2585 errmsg("%s format is not recognized: \"%s\"",
2586 "datetime", text_to_cstring(datetime)),
2587 errhint("Use a datetime template argument to specify the input data format."))));
2588 else
2589 RETURN_ERROR(ereport(ERROR,
2590 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
2591 errmsg("%s format is not recognized: \"%s\"",
2592 jspOperationName(jsp->type), text_to_cstring(datetime)))));
2593
2594 }
2595 }
2596
2597 /*
2598 * parse_datetime() processes the entire input string per the template or
2599 * ISO format and returns the Datum in best fitted datetime type. So, if
2600 * this call is for a specific datatype, then we do the conversion here.
2601 * Throw an error for incompatible types.
2602 */
2603 switch (jsp->type)
2604 {
2605 case jpiDatetime: /* Nothing to do for DATETIME */
2606 break;
2607 case jpiDate:
2608 {
2609 /* Convert result type to date */
2610 switch (typid)
2611 {
2612 case DATEOID: /* Nothing to do for DATE */
2613 break;
2614 case TIMEOID:
2615 case TIMETZOID:
2616 RETURN_ERROR(ereport(ERROR,
2617 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
2618 errmsg("%s format is not recognized: \"%s\"",
2619 "date", text_to_cstring(datetime)))));
2620 break;
2621 case TIMESTAMPOID:
2622 value = DirectFunctionCall1(timestamp_date,
2623 value);
2624 break;
2625 case TIMESTAMPTZOID:
2626 checkTimezoneIsUsedForCast(cxt->useTz,
2627 "timestamptz", "date");
2628 value = DirectFunctionCall1(timestamptz_date,
2629 value);
2630 break;
2631 default:
2632 elog(ERROR, "type with oid %u not supported", typid);
2633 }
2634
2635 typid = DATEOID;
2636 }
2637 break;
2638 case jpiTime:
2639 {
2640 /* Convert result type to time without time zone */
2641 switch (typid)
2642 {
2643 case DATEOID:
2644 RETURN_ERROR(ereport(ERROR,
2645 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
2646 errmsg("%s format is not recognized: \"%s\"",
2647 "time", text_to_cstring(datetime)))));
2648 break;
2649 case TIMEOID: /* Nothing to do for TIME */
2650 break;
2651 case TIMETZOID:
2652 checkTimezoneIsUsedForCast(cxt->useTz,
2653 "timetz", "time");
2654 value = DirectFunctionCall1(timetz_time,
2655 value);
2656 break;
2657 case TIMESTAMPOID:
2658 value = DirectFunctionCall1(timestamp_time,
2659 value);
2660 break;
2661 case TIMESTAMPTZOID:
2662 checkTimezoneIsUsedForCast(cxt->useTz,
2663 "timestamptz", "time");
2664 value = DirectFunctionCall1(timestamptz_time,
2665 value);
2666 break;
2667 default:
2668 elog(ERROR, "type with oid %u not supported", typid);
2669 }
2670
2671 /* Force the user-given time precision, if any */
2672 if (time_precision != -1)
2673 {
2674 TimeADT result;
2675
2676 /* Get a warning when precision is reduced */
2677 time_precision = anytime_typmod_check(false,
2678 time_precision);
2679 result = DatumGetTimeADT(value);
2680 AdjustTimeForTypmod(&result, time_precision);
2681 value = TimeADTGetDatum(result);
2682
2683 /* Update the typmod value with the user-given precision */
2684 typmod = time_precision;
2685 }
2686
2687 typid = TIMEOID;
2688 }
2689 break;
2690 case jpiTimeTz:
2691 {
2692 /* Convert result type to time with time zone */
2693 switch (typid)
2694 {
2695 case DATEOID:
2696 case TIMESTAMPOID:
2697 RETURN_ERROR(ereport(ERROR,
2698 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
2699 errmsg("%s format is not recognized: \"%s\"",
2700 "time_tz", text_to_cstring(datetime)))));
2701 break;
2702 case TIMEOID:
2703 checkTimezoneIsUsedForCast(cxt->useTz,
2704 "time", "timetz");
2705 value = DirectFunctionCall1(time_timetz,
2706 value);
2707 break;
2708 case TIMETZOID: /* Nothing to do for TIMETZ */
2709 break;
2710 case TIMESTAMPTZOID:
2711 value = DirectFunctionCall1(timestamptz_timetz,
2712 value);
2713 break;
2714 default:
2715 elog(ERROR, "type with oid %u not supported", typid);
2716 }
2717
2718 /* Force the user-given time precision, if any */
2719 if (time_precision != -1)
2720 {
2721 TimeTzADT *result;
2722
2723 /* Get a warning when precision is reduced */
2724 time_precision = anytime_typmod_check(true,
2725 time_precision);
2726 result = DatumGetTimeTzADTP(value);
2727 AdjustTimeForTypmod(&result->time, time_precision);
2728 value = TimeTzADTPGetDatum(result);
2729
2730 /* Update the typmod value with the user-given precision */
2731 typmod = time_precision;
2732 }
2733
2734 typid = TIMETZOID;
2735 }
2736 break;
2737 case jpiTimestamp:
2738 {
2739 /* Convert result type to timestamp without time zone */
2740 switch (typid)
2741 {
2742 case DATEOID:
2743 value = DirectFunctionCall1(date_timestamp,
2744 value);
2745 break;
2746 case TIMEOID:
2747 case TIMETZOID:
2748 RETURN_ERROR(ereport(ERROR,
2749 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
2750 errmsg("%s format is not recognized: \"%s\"",
2751 "timestamp", text_to_cstring(datetime)))));
2752 break;
2753 case TIMESTAMPOID: /* Nothing to do for TIMESTAMP */
2754 break;
2755 case TIMESTAMPTZOID:
2756 checkTimezoneIsUsedForCast(cxt->useTz,
2757 "timestamptz", "timestamp");
2758 value = DirectFunctionCall1(timestamptz_timestamp,
2759 value);
2760 break;
2761 default:
2762 elog(ERROR, "type with oid %u not supported", typid);
2763 }
2764
2765 /* Force the user-given time precision, if any */
2766 if (time_precision != -1)
2767 {
2768 Timestamp result;
2769 ErrorSaveContext escontext = {T_ErrorSaveContext};
2770
2771 /* Get a warning when precision is reduced */
2772 time_precision = anytimestamp_typmod_check(false,
2773 time_precision);
2774 result = DatumGetTimestamp(value);
2775 AdjustTimestampForTypmod(&result, time_precision,
2776 (Node *) &escontext);
2777 if (escontext.error_occurred) /* should not happen */
2778 RETURN_ERROR(ereport(ERROR,
2779 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
2780 errmsg("time precision of jsonpath item method .%s() is invalid",
2781 jspOperationName(jsp->type)))));
2782 value = TimestampGetDatum(result);
2783
2784 /* Update the typmod value with the user-given precision */
2785 typmod = time_precision;
2786 }
2787
2788 typid = TIMESTAMPOID;
2789 }
2790 break;
2791 case jpiTimestampTz:
2792 {
2793 struct pg_tm tm;
2794 fsec_t fsec;
2795
2796 /* Convert result type to timestamp with time zone */
2797 switch (typid)
2798 {
2799 case DATEOID:
2800 checkTimezoneIsUsedForCast(cxt->useTz,
2801 "date", "timestamptz");
2802
2803 /*
2804 * Get the timezone value explicitly since JsonbValue
2805 * keeps that separate.
2806 */
2807 j2date(DatumGetDateADT(value) + POSTGRES_EPOCH_JDATE,
2808 &(tm.tm_year), &(tm.tm_mon), &(tm.tm_mday));
2809 tm.tm_hour = 0;
2810 tm.tm_min = 0;
2811 tm.tm_sec = 0;
2812 tz = DetermineTimeZoneOffset(&tm, session_timezone);
2813
2814 value = DirectFunctionCall1(date_timestamptz,
2815 value);
2816 break;
2817 case TIMEOID:
2818 case TIMETZOID:
2819 RETURN_ERROR(ereport(ERROR,
2820 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
2821 errmsg("%s format is not recognized: \"%s\"",
2822 "timestamp_tz", text_to_cstring(datetime)))));
2823 break;
2824 case TIMESTAMPOID:
2825 checkTimezoneIsUsedForCast(cxt->useTz,
2826 "timestamp", "timestamptz");
2827
2828 /*
2829 * Get the timezone value explicitly since JsonbValue
2830 * keeps that separate.
2831 */
2832 if (timestamp2tm(DatumGetTimestamp(value), NULL, &tm,
2833 &fsec, NULL, NULL) == 0)
2834 tz = DetermineTimeZoneOffset(&tm,
2835 session_timezone);
2836
2837 value = DirectFunctionCall1(timestamp_timestamptz,
2838 value);
2839 break;
2840 case TIMESTAMPTZOID: /* Nothing to do for TIMESTAMPTZ */
2841 break;
2842 default:
2843 elog(ERROR, "type with oid %u not supported", typid);
2844 }
2845
2846 /* Force the user-given time precision, if any */
2847 if (time_precision != -1)
2848 {
2849 Timestamp result;
2850 ErrorSaveContext escontext = {T_ErrorSaveContext};
2851
2852 /* Get a warning when precision is reduced */
2853 time_precision = anytimestamp_typmod_check(true,
2854 time_precision);
2855 result = DatumGetTimestampTz(value);
2856 AdjustTimestampForTypmod(&result, time_precision,
2857 (Node *) &escontext);
2858 if (escontext.error_occurred) /* should not happen */
2859 RETURN_ERROR(ereport(ERROR,
2860 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION),
2861 errmsg("time precision of jsonpath item method .%s() is invalid",
2862 jspOperationName(jsp->type)))));
2863 value = TimestampTzGetDatum(result);
2864
2865 /* Update the typmod value with the user-given precision */
2866 typmod = time_precision;
2867 }
2868
2869 typid = TIMESTAMPTZOID;
2870 }
2871 break;
2872 default:
2873 elog(ERROR, "unrecognized jsonpath item type: %d", jsp->type);
2874 }
2875
2876 pfree(datetime);
2877
2878 if (jperIsError(res))
2879 return res;
2880
2881 hasNext = jspGetNext(jsp, &elem);
2882
2883 if (!hasNext && !found)
2884 return res;
2885
2886 jbv.type = jbvDatetime;
2887 jbv.val.datetime.value = value;
2888 jbv.val.datetime.typid = typid;
2889 jbv.val.datetime.typmod = typmod;
2890 jbv.val.datetime.tz = tz;
2891
2892 return executeNextItem(cxt, jsp, &elem, &jbv, found);
2893}
2894
2895/*
2896 * Implementation of .upper(), .lower() et al. string methods,
2897 * that forward their actual implementation to internal functions.
2898 */
2899static JsonPathExecResult
2900executeStringInternalMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
2901 JsonbValue *jb, JsonValueList *found)
2902{
2903 JsonbValue jbv;
2904 bool hasNext;
2905 JsonPathExecResult res = jperNotFound;
2906 JsonPathItem elem;
2907 Datum str; /* Datum representation for the current string
2908 * value. The first argument to internal
2909 * functions */
2910 char *resStr = NULL;
2911
2912 Assert(jsp->type == jpiStrReplace ||
2913 jsp->type == jpiStrLower ||
2914 jsp->type == jpiStrUpper ||
2915 jsp->type == jpiStrLtrim ||
2916 jsp->type == jpiStrRtrim ||
2917 jsp->type == jpiStrBtrim ||
2918 jsp->type == jpiStrInitcap ||
2919 jsp->type == jpiStrSplitPart);
2920
2921 if (!(jb = getScalar(jb, jbvString)))
2922 RETURN_ERROR(ereport(ERROR,
2923 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2924 errmsg("jsonpath item method .%s() can only be applied to a string",
2925 jspOperationName(jsp->type)))));
2926
2927 str = PointerGetDatum(cstring_to_text_with_len(jb->val.string.val, jb->val.string.len));
2928
2929 /* Dispatch to the appropriate internal string function */
2930 switch (jsp->type)
2931 {
2932 case jpiStrReplace:
2933 {
2934 char *from_str,
2935 *to_str;
2936
2937 jspGetLeftArg(jsp, &elem);
2938 if (elem.type != jpiString)
2939 elog(ERROR, "invalid jsonpath item type for .replace() from");
2940
2941 from_str = jspGetString(&elem, NULL);
2942
2943 jspGetRightArg(jsp, &elem);
2944 if (elem.type != jpiString)
2945 elog(ERROR, "invalid jsonpath item type for .replace() to");
2946
2947 to_str = jspGetString(&elem, NULL);
2948
2949 resStr = TextDatumGetCString(DirectFunctionCall3Coll(replace_text,
2950 DEFAULT_COLLATION_OID,
2951 str,
2952 CStringGetTextDatum(from_str),
2953 CStringGetTextDatum(to_str)));
2954 break;
2955 }
2956 case jpiStrLower:
2957 resStr = TextDatumGetCString(DirectFunctionCall1Coll(lower, DEFAULT_COLLATION_OID, str));
2958 break;
2959 case jpiStrUpper:
2960 resStr = TextDatumGetCString(DirectFunctionCall1Coll(upper, DEFAULT_COLLATION_OID, str));
2961 break;
2962 case jpiStrLtrim:
2963 case jpiStrRtrim:
2964 case jpiStrBtrim:
2965 {
2966 PGFunction func1 = NULL;
2967 PGFunction func2 = NULL;
2968
2969 switch (jsp->type)
2970 {
2971 case jpiStrLtrim:
2972 func1 = ltrim1;
2973 func2 = ltrim;
2974 break;
2975 case jpiStrRtrim:
2976 func1 = rtrim1;
2977 func2 = rtrim;
2978 break;
2979 case jpiStrBtrim:
2980 func1 = btrim1;
2981 func2 = btrim;
2982 break;
2983 default:
2984 break;
2985 }
2986
2987 if (jsp->content.arg)
2988 {
2989 char *characters_str;
2990
2991 jspGetArg(jsp, &elem);
2992 if (elem.type != jpiString)
2993 elog(ERROR, "invalid jsonpath item type for .%s() argument",
2994 jspOperationName(jsp->type));
2995
2996 characters_str = jspGetString(&elem, NULL);
2997 resStr = TextDatumGetCString(DirectFunctionCall2Coll(func2,
2998 DEFAULT_COLLATION_OID, str,
2999 CStringGetTextDatum(characters_str)));
3000 }
3001 else
3002 {
3003 resStr = TextDatumGetCString(DirectFunctionCall1Coll(func1,
3004 DEFAULT_COLLATION_OID, str));
3005 }
3006 break;
3007 }
3008
3009 case jpiStrInitcap:
3010 resStr = TextDatumGetCString(DirectFunctionCall1Coll(initcap, DEFAULT_COLLATION_OID, str));
3011 break;
3012 case jpiStrSplitPart:
3013 {
3014 char *from_str;
3015 int32 n;
3016 ErrorSaveContext escontext = {T_ErrorSaveContext};
3017
3018 jspGetLeftArg(jsp, &elem);
3019 if (elem.type != jpiString)
3020 elog(ERROR, "invalid jsonpath item type for .split_part()");
3021
3022 from_str = jspGetString(&elem, NULL);
3023
3024 jspGetRightArg(jsp, &elem);
3025 if (elem.type != jpiNumeric)
3026 elog(ERROR, "invalid jsonpath item type for .split_part()");
3027
3028 n = numeric_int4_safe(jspGetNumeric(&elem),
3029 (Node *) &escontext);
3030 if (escontext.error_occurred)
3031 RETURN_ERROR(ereport(ERROR,
3032 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3033 errmsg("field position of jsonpath item method .%s() is out of range for type integer",
3034 jspOperationName(jsp->type))));
3035
3036 if (n == 0)
3037 RETURN_ERROR(ereport(ERROR,
3038 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3039 errmsg("field position of jsonpath item method .%s() must not be zero",
3040 jspOperationName(jsp->type))));
3041
3042 resStr = TextDatumGetCString(DirectFunctionCall3Coll(split_part,
3043 DEFAULT_COLLATION_OID,
3044 str,
3045 CStringGetTextDatum(from_str),
3046 Int32GetDatum(n)));
3047 break;
3048 }
3049 default:
3050 elog(ERROR, "unsupported jsonpath item type: %d", jsp->type);
3051 }
3052
3053 if (resStr)
3054 res = jperOk;
3055
3056 hasNext = jspGetNext(jsp, &elem);
3057
3058 if (!hasNext && !found)
3059 return res;
3060
3061 jbv.type = jbvString;
3062 jbv.val.string.val = resStr;
3063 jbv.val.string.len = strlen(resStr);
3064
3065 return executeNextItem(cxt, jsp, &elem, &jbv, found);
3066}
3067
3068/*
3069 * Implementation of .keyvalue() method.
3070 *
3071 * .keyvalue() method returns a sequence of object's key-value pairs in the
3072 * following format: '{ "key": key, "value": value, "id": id }'.
3073 *
3074 * "id" field is an object identifier which is constructed from the two parts:
3075 * base object id and its binary offset in base object's jsonb:
3076 * id = 10000000000 * base_object_id + obj_offset_in_base_object
3077 *
3078 * 10000000000 (10^10) -- is a first round decimal number greater than 2^32
3079 * (maximal offset in jsonb). Decimal multiplier is used here to improve the
3080 * readability of identifiers.
3081 *
3082 * Base object is usually a root object of the path: context item '$' or path
3083 * variable '$var', literals can't produce objects for now. But if the path
3084 * contains generated objects (.keyvalue() itself, for example), then they
3085 * become base object for the subsequent .keyvalue().
3086 *
3087 * Id of '$' is 0. Id of '$var' is its ordinal (positive) number in the list
3088 * of variables (see getJsonPathVariable()). Ids for generated objects
3089 * are assigned using global counter JsonPathExecContext.lastGeneratedObjectId.
3090 */
3091static JsonPathExecResult
3092executeKeyValueMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
3093 JsonbValue *jb, JsonValueList *found)
3094{
3095 JsonPathExecResult res = jperNotFound;
3096 JsonPathItem next;
3097 JsonbContainer *jbc;
3098 JsonbValue key;
3099 JsonbValue val;
3100 JsonbValue idval;
3101 JsonbValue keystr;
3102 JsonbValue valstr;
3103 JsonbValue idstr;
3104 JsonbIterator *it;
3105 JsonbIteratorToken tok;
3106 int64 id;
3107 bool hasNext;
3108
3109 if (JsonbType(jb) != jbvObject || jb->type != jbvBinary)
3110 RETURN_ERROR(ereport(ERROR,
3111 (errcode(ERRCODE_SQL_JSON_OBJECT_NOT_FOUND),
3112 errmsg("jsonpath item method .%s() can only be applied to an object",
3113 jspOperationName(jsp->type)))));
3114
3115 jbc = jb->val.binary.data;
3116
3117 if (!JsonContainerSize(jbc))
3118 return jperNotFound; /* no key-value pairs */
3119
3120 hasNext = jspGetNext(jsp, &next);
3121
3122 keystr.type = jbvString;
3123 keystr.val.string.val = "key";
3124 keystr.val.string.len = 3;
3125
3126 valstr.type = jbvString;
3127 valstr.val.string.val = "value";
3128 valstr.val.string.len = 5;
3129
3130 idstr.type = jbvString;
3131 idstr.val.string.val = "id";
3132 idstr.val.string.len = 2;
3133
3134 /* construct object id from its base object and offset inside that */
3135 id = jb->type != jbvBinary ? 0 :
3136 (int64) ((char *) jbc - (char *) cxt->baseObject.jbc);
3137 id += (int64) cxt->baseObject.id * INT64CONST(10000000000);
3138
3139 idval.type = jbvNumeric;
3140 idval.val.numeric = int64_to_numeric(id);
3141
3142 it = JsonbIteratorInit(jbc);
3143
3144 while ((tok = JsonbIteratorNext(&it, &key, true)) != WJB_DONE)
3145 {
3146 JsonBaseObjectInfo baseObject;
3147 JsonbValue obj;
3148 JsonbInState ps;
3149 Jsonb *jsonb;
3150
3151 if (tok != WJB_KEY)
3152 continue;
3153
3154 res = jperOk;
3155
3156 if (!hasNext && !found)
3157 break;
3158
3159 tok = JsonbIteratorNext(&it, &val, true);
3160 Assert(tok == WJB_VALUE);
3161
3162 memset(&ps, 0, sizeof(ps));
3163
3164 pushJsonbValue(&ps, WJB_BEGIN_OBJECT, NULL);
3165
3166 pushJsonbValue(&ps, WJB_KEY, &keystr);
3167 pushJsonbValue(&ps, WJB_VALUE, &key);
3168
3169 pushJsonbValue(&ps, WJB_KEY, &valstr);
3170 pushJsonbValue(&ps, WJB_VALUE, &val);
3171
3172 pushJsonbValue(&ps, WJB_KEY, &idstr);
3173 pushJsonbValue(&ps, WJB_VALUE, &idval);
3174
3175 pushJsonbValue(&ps, WJB_END_OBJECT, NULL);
3176
3177 jsonb = JsonbValueToJsonb(ps.result);
3178
3179 JsonbInitBinary(&obj, jsonb);
3180
3181 baseObject = setBaseObject(cxt, &obj, cxt->lastGeneratedObjectId++);
3182
3183 res = executeNextItem(cxt, jsp, &next, &obj, found);
3184
3185 cxt->baseObject = baseObject;
3186
3187 if (jperIsError(res))
3188 return res;
3189
3190 if (res == jperOk && !found)
3191 break;
3192 }
3193
3194 return res;
3195}
3196
3197/*
3198 * Convert boolean execution status 'res' to a boolean JSON item and execute
3199 * next jsonpath.
3200 */
3201static JsonPathExecResult
3202appendBoolResult(JsonPathExecContext *cxt, JsonPathItem *jsp,
3203 JsonValueList *found, JsonPathBool res)
3204{
3205 JsonPathItem next;
3206 JsonbValue jbv;
3207
3208 if (!jspGetNext(jsp, &next) && !found)
3209 return jperOk; /* found singleton boolean value */
3210
3211 if (res == jpbUnknown)
3212 {
3213 jbv.type = jbvNull;
3214 }
3215 else
3216 {
3217 jbv.type = jbvBool;
3218 jbv.val.boolean = res == jpbTrue;
3219 }
3220
3221 return executeNextItem(cxt, jsp, &next, &jbv, found);
3222}
3223
3224/*
3225 * Convert jsonpath's scalar or variable node to actual jsonb value.
3226 *
3227 * If node is a variable then its id returned, otherwise 0 returned.
3228 */
3229static void
3230getJsonPathItem(JsonPathExecContext *cxt, JsonPathItem *item,
3231 JsonbValue *value)
3232{
3233 switch (item->type)
3234 {
3235 case jpiNull:
3236 value->type = jbvNull;
3237 break;
3238 case jpiBool:
3239 value->type = jbvBool;
3240 value->val.boolean = jspGetBool(item);
3241 break;
3242 case jpiNumeric:
3243 value->type = jbvNumeric;
3244 value->val.numeric = jspGetNumeric(item);
3245 break;
3246 case jpiString:
3247 value->type = jbvString;
3248 value->val.string.val = jspGetString(item,
3249 &value->val.string.len);
3250 break;
3251 case jpiVariable:
3252 getJsonPathVariable(cxt, item, value);
3253 return;
3254 default:
3255 elog(ERROR, "unexpected jsonpath item type");
3256 }
3257}
3258
3259/*
3260 * Returns the computed value of a JSON path variable with given name.
3261 */
3262static JsonbValue *
3263GetJsonPathVar(void *cxt, char *varName, int varNameLen,
3264 JsonbValue *baseObject, int *baseObjectId)
3265{
3266 JsonPathVariable *var = NULL;
3267 List *vars = cxt;
3268 ListCell *lc;
3269 JsonbValue *result;
3270 int id = 1;
3271
3272 foreach(lc, vars)
3273 {
3274 JsonPathVariable *curvar = lfirst(lc);
3275
3276 if (curvar->namelen == varNameLen &&
3277 strncmp(curvar->name, varName, varNameLen) == 0)
3278 {
3279 var = curvar;
3280 break;
3281 }
3282
3283 id++;
3284 }
3285
3286 if (var == NULL)
3287 {
3288 *baseObjectId = -1;
3289 return NULL;
3290 }
3291
3292 result = palloc_object(JsonbValue);
3293 if (var->isnull)
3294 {
3295 *baseObjectId = 0;
3296 result->type = jbvNull;
3297 }
3298 else
3299 JsonItemFromDatum(var->value, var->typid, var->typmod, result);
3300
3301 *baseObject = *result;
3302 *baseObjectId = id;
3303
3304 return result;
3305}
3306
3307static int
3308CountJsonPathVars(void *cxt)
3309{
3310 List *vars = (List *) cxt;
3311
3312 return list_length(vars);
3313}
3314
3315
3316/*
3317 * Initialize JsonbValue to pass to jsonpath executor from given
3318 * datum value of the specified type.
3319 */
3320static void
3321JsonItemFromDatum(Datum val, Oid typid, int32 typmod, JsonbValue *res)
3322{
3323 switch (typid)
3324 {
3325 case BOOLOID:
3326 res->type = jbvBool;
3327 res->val.boolean = DatumGetBool(val);
3328 break;
3329 case NUMERICOID:
3330 JsonbValueInitNumericDatum(res, val);
3331 break;
3332 case INT2OID:
3333 JsonbValueInitNumericDatum(res, DirectFunctionCall1(int2_numeric, val));
3334 break;
3335 case INT4OID:
3336 JsonbValueInitNumericDatum(res, DirectFunctionCall1(int4_numeric, val));
3337 break;
3338 case INT8OID:
3339 JsonbValueInitNumericDatum(res, DirectFunctionCall1(int8_numeric, val));
3340 break;
3341 case FLOAT4OID:
3342 JsonbValueInitNumericDatum(res, DirectFunctionCall1(float4_numeric, val));
3343 break;
3344 case FLOAT8OID:
3345 JsonbValueInitNumericDatum(res, DirectFunctionCall1(float8_numeric, val));
3346 break;
3347 case TEXTOID:
3348 case VARCHAROID:
3349 res->type = jbvString;
3350 res->val.string.val = VARDATA_ANY(DatumGetPointer(val));
3351 res->val.string.len = VARSIZE_ANY_EXHDR(DatumGetPointer(val));
3352 break;
3353 case DATEOID:
3354 case TIMEOID:
3355 case TIMETZOID:
3356 case TIMESTAMPOID:
3357 case TIMESTAMPTZOID:
3358 res->type = jbvDatetime;
3359 res->val.datetime.value = val;
3360 res->val.datetime.typid = typid;
3361 res->val.datetime.typmod = typmod;
3362 res->val.datetime.tz = 0;
3363 break;
3364 case JSONBOID:
3365 {
3366 JsonbValue *jbv = res;
3367 Jsonb *jb = DatumGetJsonbP(val);
3368
3369 if (JsonContainerIsScalar(&jb->root))
3370 {
3371 bool result PG_USED_FOR_ASSERTS_ONLY;
3372
3373 result = JsonbExtractScalar(&jb->root, jbv);
3374 Assert(result);
3375 }
3376 else
3377 JsonbInitBinary(jbv, jb);
3378 break;
3379 }
3380 case JSONOID:
3381 {
3382 text *txt = DatumGetTextP(val);
3383 char *str = text_to_cstring(txt);
3384 Jsonb *jb;
3385
3386 jb = DatumGetJsonbP(DirectFunctionCall1(jsonb_in,
3387 CStringGetDatum(str)));
3388 pfree(str);
3389
3390 JsonItemFromDatum(JsonbPGetDatum(jb), JSONBOID, -1, res);
3391 break;
3392 }
3393 default:
3394 ereport(ERROR,
3395 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3396 errmsg("could not convert value of type %s to jsonpath",
3397 format_type_be(typid)));
3398 }
3399}
3400
3401/* Initialize numeric value from the given datum */
3402static void
3403JsonbValueInitNumericDatum(JsonbValue *jbv, Datum num)
3404{
3405 jbv->type = jbvNumeric;
3406 jbv->val.numeric = DatumGetNumeric(num);
3407}
3408
3409/*
3410 * Get the value of variable passed to jsonpath executor
3411 */
3412static void
3413getJsonPathVariable(JsonPathExecContext *cxt, JsonPathItem *variable,
3414 JsonbValue *value)
3415{
3416 char *varName;
3417 int varNameLength;
3418 JsonbValue baseObject;
3419 int baseObjectId;
3420 JsonbValue *v;
3421
3422 Assert(variable->type == jpiVariable);
3423 varName = jspGetString(variable, &varNameLength);
3424
3425 if (cxt->vars == NULL ||
3426 (v = cxt->getVar(cxt->vars, varName, varNameLength,
3427 &baseObject, &baseObjectId)) == NULL)
3428 ereport(ERROR,
3429 (errcode(ERRCODE_UNDEFINED_OBJECT),
3430 errmsg("could not find jsonpath variable \"%s\"",
3431 pnstrdup(varName, varNameLength))));
3432
3433 if (baseObjectId > 0)
3434 {
3435 *value = *v;
3436 setBaseObject(cxt, &baseObject, baseObjectId);
3437 }
3438}
3439
3440/*
3441 * Definition of JsonPathGetVarCallback for when JsonPathExecContext.vars
3442 * is specified as a jsonb value.
3443 */
3444static JsonbValue *
3445getJsonPathVariableFromJsonb(void *varsJsonb, char *varName, int varNameLength,
3446 JsonbValue *baseObject, int *baseObjectId)
3447{
3448 Jsonb *vars = varsJsonb;
3449 JsonbValue tmp;
3450 JsonbValue *result;
3451
3452 tmp.type = jbvString;
3453 tmp.val.string.val = varName;
3454 tmp.val.string.len = varNameLength;
3455
3456 result = findJsonbValueFromContainer(&vars->root, JB_FOBJECT, &tmp);
3457
3458 if (result == NULL)
3459 {
3460 *baseObjectId = -1;
3461 return NULL;
3462 }
3463
3464 *baseObjectId = 1;
3465 JsonbInitBinary(baseObject, vars);
3466
3467 return result;
3468}
3469
3470/*
3471 * Definition of JsonPathCountVarsCallback for when JsonPathExecContext.vars
3472 * is specified as a jsonb value.
3473 */
3474static int
3475countVariablesFromJsonb(void *varsJsonb)
3476{
3477 Jsonb *vars = varsJsonb;
3478
3479 if (vars && !JsonContainerIsObject(&vars->root))
3480 {
3481 ereport(ERROR,
3482 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3483 errmsg("\"vars\" argument is not an object"),
3484 errdetail("Jsonpath parameters should be encoded as key-value pairs of \"vars\" object."));
3485 }
3486
3487 /* count of base objects */
3488 return vars != NULL ? 1 : 0;
3489}
3490
3491/**************** Support functions for JsonPath execution *****************/
3492
3493/*
3494 * Returns the size of an array item, or -1 if item is not an array.
3495 */
3496static int
3497JsonbArraySize(JsonbValue *jb)
3498{
3499 Assert(jb->type != jbvArray);
3500
3501 if (jb->type == jbvBinary)
3502 {
3503 JsonbContainer *jbc = jb->val.binary.data;
3504
3505 if (JsonContainerIsArray(jbc) && !JsonContainerIsScalar(jbc))
3506 return JsonContainerSize(jbc);
3507 }
3508
3509 return -1;
3510}
3511
3512/* Comparison predicate callback. */
3513static JsonPathBool
3514executeComparison(JsonPathItem *cmp, JsonbValue *lv, JsonbValue *rv, void *p)
3515{
3516 JsonPathExecContext *cxt = (JsonPathExecContext *) p;
3517
3518 return compareItems(cmp->type, lv, rv, cxt->useTz);
3519}
3520
3521/*
3522 * Perform per-byte comparison of two strings.
3523 */
3524static int
3525binaryCompareStrings(const char *s1, int len1,
3526 const char *s2, int len2)
3527{
3528 int cmp;
3529
3530 cmp = memcmp(s1, s2, Min(len1, len2));
3531
3532 if (cmp != 0)
3533 return cmp;
3534
3535 if (len1 == len2)
3536 return 0;
3537
3538 return len1 < len2 ? -1 : 1;
3539}
3540
3541/*
3542 * Compare two strings in the current server encoding using Unicode codepoint
3543 * collation.
3544 */
3545static int
3546compareStrings(const char *mbstr1, int mblen1,
3547 const char *mbstr2, int mblen2)
3548{
3549 if (GetDatabaseEncoding() == PG_SQL_ASCII ||
3550 GetDatabaseEncoding() == PG_UTF8)
3551 {
3552 /*
3553 * It's known property of UTF-8 strings that their per-byte comparison
3554 * result matches codepoints comparison result. ASCII can be
3555 * considered as special case of UTF-8.
3556 */
3557 return binaryCompareStrings(mbstr1, mblen1, mbstr2, mblen2);
3558 }
3559 else
3560 {
3561 char *utf8str1,
3562 *utf8str2;
3563 int cmp,
3564 utf8len1,
3565 utf8len2;
3566
3567 /*
3568 * We have to convert other encodings to UTF-8 first, then compare.
3569 * Input strings may be not null-terminated and pg_server_to_any() may
3570 * return them "as is". So, use strlen() only if there is real
3571 * conversion.
3572 */
3573 utf8str1 = pg_server_to_any(mbstr1, mblen1, PG_UTF8);
3574 utf8str2 = pg_server_to_any(mbstr2, mblen2, PG_UTF8);
3575 utf8len1 = (mbstr1 == utf8str1) ? mblen1 : strlen(utf8str1);
3576 utf8len2 = (mbstr2 == utf8str2) ? mblen2 : strlen(utf8str2);
3577
3578 cmp = binaryCompareStrings(utf8str1, utf8len1, utf8str2, utf8len2);
3579
3580 /*
3581 * If pg_server_to_any() did no real conversion, then we actually
3582 * compared original strings. So, we already done.
3583 */
3584 if (mbstr1 == utf8str1 && mbstr2 == utf8str2)
3585 return cmp;
3586
3587 /* Free memory if needed */
3588 if (mbstr1 != utf8str1)
3589 pfree(utf8str1);
3590 if (mbstr2 != utf8str2)
3591 pfree(utf8str2);
3592
3593 /*
3594 * When all Unicode codepoints are equal, return result of binary
3595 * comparison. In some edge cases, same characters may have different
3596 * representations in encoding. Then our behavior could diverge from
3597 * standard. However, that allow us to do simple binary comparison
3598 * for "==" operator, which is performance critical in typical cases.
3599 * In future to implement strict standard conformance, we can do
3600 * normalization of input JSON strings.
3601 */
3602 if (cmp == 0)
3603 return binaryCompareStrings(mbstr1, mblen1, mbstr2, mblen2);
3604 else
3605 return cmp;
3606 }
3607}
3608
3609/*
3610 * Compare two SQL/JSON items using comparison operation 'op'.
3611 */
3612static JsonPathBool
3613compareItems(int32 op, JsonbValue *jb1, JsonbValue *jb2, bool useTz)
3614{
3615 int cmp;
3616 bool res;
3617
3618 if (jb1->type != jb2->type)
3619 {
3620 if (jb1->type == jbvNull || jb2->type == jbvNull)
3621
3622 /*
3623 * Equality and order comparison of nulls to non-nulls returns
3624 * always false, but inequality comparison returns true.
3625 */
3626 return op == jpiNotEqual ? jpbTrue : jpbFalse;
3627
3628 /* Non-null items of different types are not comparable. */
3629 return jpbUnknown;
3630 }
3631
3632 switch (jb1->type)
3633 {
3634 case jbvNull:
3635 cmp = 0;
3636 break;
3637 case jbvBool:
3638 cmp = jb1->val.boolean == jb2->val.boolean ? 0 :
3639 jb1->val.boolean ? 1 : -1;
3640 break;
3641 case jbvNumeric:
3642 cmp = compareNumeric(jb1->val.numeric, jb2->val.numeric);
3643 break;
3644 case jbvString:
3645 if (op == jpiEqual)
3646 return jb1->val.string.len != jb2->val.string.len ||
3647 memcmp(jb1->val.string.val,
3648 jb2->val.string.val,
3649 jb1->val.string.len) ? jpbFalse : jpbTrue;
3650
3651 cmp = compareStrings(jb1->val.string.val, jb1->val.string.len,
3652 jb2->val.string.val, jb2->val.string.len);
3653 break;
3654 case jbvDatetime:
3655 {
3656 bool cast_error;
3657
3658 cmp = compareDatetime(jb1->val.datetime.value,
3659 jb1->val.datetime.typid,
3660 jb2->val.datetime.value,
3661 jb2->val.datetime.typid,
3662 useTz,
3663 &cast_error);
3664
3665 if (cast_error)
3666 return jpbUnknown;
3667 }
3668 break;
3669
3670 case jbvBinary:
3671 case jbvArray:
3672 case jbvObject:
3673 return jpbUnknown; /* non-scalars are not comparable */
3674
3675 default:
3676 elog(ERROR, "invalid jsonb value type %d", jb1->type);
3677 }
3678
3679 switch (op)
3680 {
3681 case jpiEqual:
3682 res = (cmp == 0);
3683 break;
3684 case jpiNotEqual:
3685 res = (cmp != 0);
3686 break;
3687 case jpiLess:
3688 res = (cmp < 0);
3689 break;
3690 case jpiGreater:
3691 res = (cmp > 0);
3692 break;
3693 case jpiLessOrEqual:
3694 res = (cmp <= 0);
3695 break;
3696 case jpiGreaterOrEqual:
3697 res = (cmp >= 0);
3698 break;
3699 default:
3700 elog(ERROR, "unrecognized jsonpath operation: %d", op);
3701 return jpbUnknown;
3702 }
3703
3704 return res ? jpbTrue : jpbFalse;
3705}
3706
3707/* Compare two numerics */
3708static int
3715
3716static JsonbValue *
3717copyJsonbValue(JsonbValue *src)
3718{
3719 JsonbValue *dst = palloc_object(JsonbValue);
3720
3721 *dst = *src;
3722
3723 return dst;
3724}
3725
3726/*
3727 * Execute array subscript expression and convert resulting numeric item to
3728 * the integer type with truncation.
3729 */
3730static JsonPathExecResult
3731getArrayIndex(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb,
3732 int32 *index)
3733{
3734 JsonbValue *jbv;
3735 JsonValueList found;
3736 JsonPathExecResult res;
3737 Datum numeric_index;
3738 ErrorSaveContext escontext = {T_ErrorSaveContext};
3739
3740 JsonValueListInit(&found);
3741
3742 res = executeItem(cxt, jsp, jb, &found);
3743
3744 if (jperIsError(res))
3745 {
3746 JsonValueListClear(&found);
3747 return res;
3748 }
3749
3750 if (!JsonValueListIsSingleton(&found) ||
3751 !(jbv = getScalar(JsonValueListHead(&found), jbvNumeric)))
3752 {
3753 JsonValueListClear(&found);
3754 RETURN_ERROR(ereport(ERROR,
3755 (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
3756 errmsg("jsonpath array subscript is not a single numeric value"))));
3757 }
3758
3759 numeric_index = DirectFunctionCall2(numeric_trunc,
3760 NumericGetDatum(jbv->val.numeric),
3761 Int32GetDatum(0));
3762
3763 *index = numeric_int4_safe(DatumGetNumeric(numeric_index),
3764 (Node *) &escontext);
3765
3766 JsonValueListClear(&found);
3767
3768 if (escontext.error_occurred)
3769 RETURN_ERROR(ereport(ERROR,
3770 (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
3771 errmsg("jsonpath array subscript is out of integer range"))));
3772
3773 return jperOk;
3774}
3775
3776/* Save base object and its id needed for the execution of .keyvalue(). */
3777static JsonBaseObjectInfo
3778setBaseObject(JsonPathExecContext *cxt, JsonbValue *jbv, int32 id)
3779{
3780 JsonBaseObjectInfo baseObject = cxt->baseObject;
3781
3782 cxt->baseObject.jbc = jbv->type != jbvBinary ? NULL :
3783 (JsonbContainer *) jbv->val.binary.data;
3784 cxt->baseObject.id = id;
3785
3786 return baseObject;
3787}
3788
3789/*
3790 * JsonValueList support functions
3791 */
3792
3793static void
3794JsonValueListInit(JsonValueList *jvl)
3795{
3796 jvl->nitems = 0;
3797 jvl->maxitems = BASE_JVL_ITEMS;
3798 jvl->next = NULL;
3799 jvl->last = jvl;
3800}
3801
3802static void
3803JsonValueListClear(JsonValueList *jvl)
3804{
3805 JsonValueList *nxt;
3806
3807 /* Release any extra chunks */
3808 for (JsonValueList *chunk = jvl->next; chunk != NULL; chunk = nxt)
3809 {
3810 nxt = chunk->next;
3811 pfree(chunk);
3812 }
3813 /* ... and reset to empty */
3814 jvl->nitems = 0;
3815 Assert(jvl->maxitems == BASE_JVL_ITEMS);
3816 jvl->next = NULL;
3817 jvl->last = jvl;
3818}
3819
3820static void
3821JsonValueListAppend(JsonValueList *jvl, const JsonbValue *jbv)
3822{
3823 JsonValueList *last = jvl->last;
3824
3825 if (last->nitems < last->maxitems)
3826 {
3827 /* there's still room in the last existing chunk */
3828 last->items[last->nitems] = *jbv;
3829 last->nitems++;
3830 }
3831 else
3832 {
3833 /* need a new last chunk */
3834 JsonValueList *nxt;
3835 int nxtsize;
3836
3837 nxtsize = last->maxitems * 2; /* double the size with each chunk */
3838 nxtsize = Max(nxtsize, MIN_EXTRA_JVL_ITEMS); /* but at least this */
3839 nxt = palloc(offsetof(JsonValueList, items) +
3840 nxtsize * sizeof(JsonbValue));
3841 nxt->nitems = 1;
3842 nxt->maxitems = nxtsize;
3843 nxt->next = NULL;
3844 nxt->items[0] = *jbv;
3845 last->next = nxt;
3846 jvl->last = nxt;
3847 }
3848}
3849
3850static bool
3851JsonValueListIsEmpty(const JsonValueList *jvl)
3852{
3853 /* We need not examine extra chunks for this */
3854 return (jvl->nitems == 0);
3855}
3856
3857static bool
3858JsonValueListIsSingleton(const JsonValueList *jvl)
3859{
3860#if BASE_JVL_ITEMS > 1
3861 /* We need not examine extra chunks in this case */
3862 return (jvl->nitems == 1);
3863#else
3864 return (jvl->nitems == 1 && jvl->next == NULL);
3865#endif
3866}
3867
3868static bool
3869JsonValueListHasMultipleItems(const JsonValueList *jvl)
3870{
3871#if BASE_JVL_ITEMS > 1
3872 /* We need not examine extra chunks in this case */
3873 return (jvl->nitems > 1);
3874#else
3875 return (jvl->nitems == 1 && jvl->next != NULL);
3876#endif
3877}
3878
3879static JsonbValue *
3880JsonValueListHead(JsonValueList *jvl)
3881{
3882 Assert(jvl->nitems > 0);
3883 return &jvl->items[0];
3884}
3885
3886/*
3887 * JsonValueListIterator functions
3888 */
3889
3890static void
3891JsonValueListInitIterator(JsonValueList *jvl, JsonValueListIterator *it)
3892{
3893 it->chunk = jvl;
3894 it->nextitem = 0;
3895}
3896
3897/*
3898 * Get the next item from the sequence advancing iterator.
3899 * Returns NULL if no more items.
3900 */
3901static JsonbValue *
3902JsonValueListNext(JsonValueListIterator *it)
3903{
3904 if (it->chunk == NULL)
3905 return NULL;
3906 if (it->nextitem >= it->chunk->nitems)
3907 {
3908 it->chunk = it->chunk->next;
3909 if (it->chunk == NULL)
3910 return NULL;
3911 it->nextitem = 0;
3912 Assert(it->chunk->nitems > 0);
3913 }
3914 return &it->chunk->items[it->nextitem++];
3915}
3916
3917/*
3918 * Initialize a binary JsonbValue with the given jsonb container.
3919 */
3920static JsonbValue *
3921JsonbInitBinary(JsonbValue *jbv, Jsonb *jb)
3922{
3923 jbv->type = jbvBinary;
3924 jbv->val.binary.data = &jb->root;
3925 jbv->val.binary.len = VARSIZE_ANY_EXHDR(jb);
3926
3927 return jbv;
3928}
3929
3930/*
3931 * Returns jbv* type of JsonbValue. Note, it never returns jbvBinary as is.
3932 */
3933static int
3934JsonbType(JsonbValue *jb)
3935{
3936 int type = jb->type;
3937
3938 if (jb->type == jbvBinary)
3939 {
3940 JsonbContainer *jbc = jb->val.binary.data;
3941
3942 /* Scalars should be always extracted during jsonpath execution. */
3943 Assert(!JsonContainerIsScalar(jbc));
3944
3945 if (JsonContainerIsObject(jbc))
3946 type = jbvObject;
3947 else if (JsonContainerIsArray(jbc))
3948 type = jbvArray;
3949 else
3950 elog(ERROR, "invalid jsonb container type: 0x%08x", jbc->header);
3951 }
3952
3953 return type;
3954}
3955
3956/* Get scalar of given type or NULL on type mismatch */
3957static JsonbValue *
3958getScalar(JsonbValue *scalar, enum jbvType type)
3959{
3960 /* Scalars should be always extracted during jsonpath execution. */
3961 Assert(scalar->type != jbvBinary ||
3962 !JsonContainerIsScalar(scalar->val.binary.data));
3963
3964 return scalar->type == type ? scalar : NULL;
3965}
3966
3967/* Construct a JSON array from the item list */
3968static JsonbValue *
3969wrapItemsInArray(JsonValueList *items)
3970{
3971 JsonbInState ps = {0};
3972 JsonValueListIterator it;
3973 JsonbValue *jbv;
3974
3975 pushJsonbValue(&ps, WJB_BEGIN_ARRAY, NULL);
3976
3977 JsonValueListInitIterator(items, &it);
3978 while ((jbv = JsonValueListNext(&it)))
3979 pushJsonbValue(&ps, WJB_ELEM, jbv);
3980
3981 pushJsonbValue(&ps, WJB_END_ARRAY, NULL);
3982
3983 return ps.result;
3984}
3985
3986/* Check if the timezone required for casting from type1 to type2 is used */
3987static void
3988checkTimezoneIsUsedForCast(bool useTz, const char *type1, const char *type2)
3989{
3990 if (!useTz)
3991 ereport(ERROR,
3992 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3993 errmsg("cannot convert value from %s to %s without time zone usage",
3994 type1, type2),
3995 errhint("Use *_tz() function for time zone support.")));
3996}
3997
3998/* Convert time datum to timetz datum */
3999static Datum
4000castTimeToTimeTz(Datum time, bool useTz)
4001{
4002 checkTimezoneIsUsedForCast(useTz, "time", "timetz");
4003
4004 return DirectFunctionCall1(time_timetz, time);
4005}
4006
4007/*
4008 * Compare date to timestamp.
4009 * Note that this doesn't involve any timezone considerations.
4010 */
4011static int
4016
4017/*
4018 * Compare date to timestamptz.
4019 */
4020static int
4021cmpDateToTimestampTz(DateADT date1, TimestampTz tstz2, bool useTz)
4022{
4023 checkTimezoneIsUsedForCast(useTz, "date", "timestamptz");
4024
4025 return date_cmp_timestamptz_internal(date1, tstz2);
4026}
4027
4028/*
4029 * Compare timestamp to timestamptz.
4030 */
4031static int
4032cmpTimestampToTimestampTz(Timestamp ts1, TimestampTz tstz2, bool useTz)
4033{
4034 checkTimezoneIsUsedForCast(useTz, "timestamp", "timestamptz");
4035
4036 return timestamp_cmp_timestamptz_internal(ts1, tstz2);
4037}
4038
4039/*
4040 * Cross-type comparison of two datetime SQL/JSON items. If items are
4041 * uncomparable *cast_error flag is set, otherwise *cast_error is unset.
4042 * If the cast requires timezone and it is not used, then explicit error is thrown.
4043 */
4044static int
4045compareDatetime(Datum val1, Oid typid1, Datum val2, Oid typid2,
4046 bool useTz, bool *cast_error)
4047{
4048 PGFunction cmpfunc;
4049
4050 *cast_error = false;
4051
4052 switch (typid1)
4053 {
4054 case DATEOID:
4055 switch (typid2)
4056 {
4057 case DATEOID:
4058 cmpfunc = date_cmp;
4059
4060 break;
4061
4062 case TIMESTAMPOID:
4063 return cmpDateToTimestamp(DatumGetDateADT(val1),
4064 DatumGetTimestamp(val2),
4065 useTz);
4066
4067 case TIMESTAMPTZOID:
4068 return cmpDateToTimestampTz(DatumGetDateADT(val1),
4069 DatumGetTimestampTz(val2),
4070 useTz);
4071
4072 case TIMEOID:
4073 case TIMETZOID:
4074 *cast_error = true; /* uncomparable types */
4075 return 0;
4076
4077 default:
4078 elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
4079 typid2);
4080 }
4081 break;
4082
4083 case TIMEOID:
4084 switch (typid2)
4085 {
4086 case TIMEOID:
4087 cmpfunc = time_cmp;
4088
4089 break;
4090
4091 case TIMETZOID:
4092 val1 = castTimeToTimeTz(val1, useTz);
4093 cmpfunc = timetz_cmp;
4094
4095 break;
4096
4097 case DATEOID:
4098 case TIMESTAMPOID:
4099 case TIMESTAMPTZOID:
4100 *cast_error = true; /* uncomparable types */
4101 return 0;
4102
4103 default:
4104 elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
4105 typid2);
4106 }
4107 break;
4108
4109 case TIMETZOID:
4110 switch (typid2)
4111 {
4112 case TIMEOID:
4113 val2 = castTimeToTimeTz(val2, useTz);
4114 cmpfunc = timetz_cmp;
4115
4116 break;
4117
4118 case TIMETZOID:
4119 cmpfunc = timetz_cmp;
4120
4121 break;
4122
4123 case DATEOID:
4124 case TIMESTAMPOID:
4125 case TIMESTAMPTZOID:
4126 *cast_error = true; /* uncomparable types */
4127 return 0;
4128
4129 default:
4130 elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
4131 typid2);
4132 }
4133 break;
4134
4135 case TIMESTAMPOID:
4136 switch (typid2)
4137 {
4138 case DATEOID:
4139 return -cmpDateToTimestamp(DatumGetDateADT(val2),
4140 DatumGetTimestamp(val1),
4141 useTz);
4142
4143 case TIMESTAMPOID:
4144 cmpfunc = timestamp_cmp;
4145
4146 break;
4147
4148 case TIMESTAMPTZOID:
4149 return cmpTimestampToTimestampTz(DatumGetTimestamp(val1),
4150 DatumGetTimestampTz(val2),
4151 useTz);
4152
4153 case TIMEOID:
4154 case TIMETZOID:
4155 *cast_error = true; /* uncomparable types */
4156 return 0;
4157
4158 default:
4159 elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
4160 typid2);
4161 }
4162 break;
4163
4164 case TIMESTAMPTZOID:
4165 switch (typid2)
4166 {
4167 case DATEOID:
4168 return -cmpDateToTimestampTz(DatumGetDateADT(val2),
4169 DatumGetTimestampTz(val1),
4170 useTz);
4171
4172 case TIMESTAMPOID:
4173 return -cmpTimestampToTimestampTz(DatumGetTimestamp(val2),
4174 DatumGetTimestampTz(val1),
4175 useTz);
4176
4177 case TIMESTAMPTZOID:
4178 cmpfunc = timestamp_cmp;
4179
4180 break;
4181
4182 case TIMEOID:
4183 case TIMETZOID:
4184 *cast_error = true; /* uncomparable types */
4185 return 0;
4186
4187 default:
4188 elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
4189 typid2);
4190 }
4191 break;
4192
4193 default:
4194 elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u", typid1);
4195 }
4196
4197 if (*cast_error)
4198 return 0; /* cast error */
4199
4200 return DatumGetInt32(DirectFunctionCall2(cmpfunc, val1, val2));
4201}
4202
4203/*
4204 * Executor-callable JSON_EXISTS implementation
4205 *
4206 * Returns NULL instead of throwing errors if 'error' is not NULL, setting
4207 * *error to true.
4208 */
4209bool
4210JsonPathExists(Datum jb, JsonPath *jp, bool *error, List *vars)
4211{
4212 JsonPathExecResult res;
4213
4214 res = executeJsonPath(jp, vars,
4215 GetJsonPathVar, CountJsonPathVars,
4216 DatumGetJsonbP(jb), !error, NULL, true);
4217
4218 Assert(error || !jperIsError(res));
4219
4220 if (error && jperIsError(res))
4221 *error = true;
4222
4223 return res == jperOk;
4224}
4225
4226/*
4227 * Executor-callable JSON_QUERY implementation
4228 *
4229 * Returns NULL instead of throwing errors if 'error' is not NULL, setting
4230 * *error to true. *empty is set to true if no match is found.
4231 */
4232Datum
4233JsonPathQuery(Datum jb, JsonPath *jp, JsonWrapper wrapper, bool *empty,
4234 bool *error, List *vars,
4235 const char *column_name)
4236{
4237 bool wrap;
4238 JsonValueList found;
4239 JsonPathExecResult res;
4240
4241 JsonValueListInit(&found);
4242
4243 res = executeJsonPath(jp, vars,
4244 GetJsonPathVar, CountJsonPathVars,
4245 DatumGetJsonbP(jb), !error, &found, true);
4246 Assert(error || !jperIsError(res));
4247 if (error && jperIsError(res))
4248 {
4249 *error = true;
4250 *empty = false;
4251 return (Datum) 0;
4252 }
4253
4254 /*
4255 * Determine whether to wrap the result in a JSON array or not.
4256 *
4257 * If the returned JsonValueList is empty, no wrapping is necessary.
4258 *
4259 * If the wrapper mode is JSW_NONE or JSW_UNSPEC, wrapping is explicitly
4260 * disabled. This enforces a WITHOUT WRAPPER clause, which is also the
4261 * default when no WRAPPER clause is specified.
4262 *
4263 * If the mode is JSW_UNCONDITIONAL, wrapping is enforced regardless of
4264 * the number of SQL/JSON items, enforcing a WITH WRAPPER or WITH
4265 * UNCONDITIONAL WRAPPER clause.
4266 *
4267 * For JSW_CONDITIONAL, wrapping occurs only if there is more than one
4268 * SQL/JSON item in the list, enforcing a WITH CONDITIONAL WRAPPER clause.
4269 */
4270 if (JsonValueListIsEmpty(&found))
4271 wrap = false;
4272 else if (wrapper == JSW_NONE || wrapper == JSW_UNSPEC)
4273 wrap = false;
4274 else if (wrapper == JSW_UNCONDITIONAL)
4275 wrap = true;
4276 else if (wrapper == JSW_CONDITIONAL)
4277 wrap = JsonValueListHasMultipleItems(&found);
4278 else
4279 {
4280 elog(ERROR, "unrecognized json wrapper %d", (int) wrapper);
4281 wrap = false;
4282 }
4283
4284 if (wrap)
4285 return JsonbPGetDatum(JsonbValueToJsonb(wrapItemsInArray(&found)));
4286
4287 /* No wrapping means at most one item is expected. */
4288 if (JsonValueListHasMultipleItems(&found))
4289 {
4290 if (error)
4291 {
4292 *error = true;
4293 return (Datum) 0;
4294 }
4295
4296 if (column_name)
4297 ereport(ERROR,
4298 (errcode(ERRCODE_MORE_THAN_ONE_SQL_JSON_ITEM),
4299 errmsg("JSON path expression for column \"%s\" must return single item when no wrapper is requested",
4300 column_name),
4301 errhint("Use the WITH WRAPPER clause to wrap SQL/JSON items into an array.")));
4302 else
4303 ereport(ERROR,
4304 (errcode(ERRCODE_MORE_THAN_ONE_SQL_JSON_ITEM),
4305 errmsg("JSON path expression in JSON_QUERY must return single item when no wrapper is requested"),
4306 errhint("Use the WITH WRAPPER clause to wrap SQL/JSON items into an array.")));
4307 }
4308
4309 if (!JsonValueListIsEmpty(&found))
4310 return JsonbPGetDatum(JsonbValueToJsonb(JsonValueListHead(&found)));
4311
4312 *empty = true;
4313 return PointerGetDatum(NULL);
4314}
4315
4316/*
4317 * Executor-callable JSON_VALUE implementation
4318 *
4319 * Returns NULL instead of throwing errors if 'error' is not NULL, setting
4320 * *error to true. *empty is set to true if no match is found.
4321 */
4322JsonbValue *
4323JsonPathValue(Datum jb, JsonPath *jp, bool *empty, bool *error, List *vars,
4324 const char *column_name)
4325{
4326 JsonbValue *res;
4327 JsonValueList found;
4328 JsonPathExecResult jper PG_USED_FOR_ASSERTS_ONLY;
4329
4330 JsonValueListInit(&found);
4331
4332 jper = executeJsonPath(jp, vars, GetJsonPathVar, CountJsonPathVars,
4333 DatumGetJsonbP(jb),
4334 !error, &found, true);
4335
4336 Assert(error || !jperIsError(jper));
4337
4338 if (error && jperIsError(jper))
4339 {
4340 *error = true;
4341 *empty = false;
4342 return NULL;
4343 }
4344
4345 *empty = JsonValueListIsEmpty(&found);
4346
4347 if (*empty)
4348 return NULL;
4349
4350 /* JSON_VALUE expects to get only singletons. */
4351 if (JsonValueListHasMultipleItems(&found))
4352 {
4353 if (error)
4354 {
4355 *error = true;
4356 return NULL;
4357 }
4358
4359 if (column_name)
4360 ereport(ERROR,
4361 (errcode(ERRCODE_MORE_THAN_ONE_SQL_JSON_ITEM),
4362 errmsg("JSON path expression for column \"%s\" must return single scalar item",
4363 column_name)));
4364 else
4365 ereport(ERROR,
4366 (errcode(ERRCODE_MORE_THAN_ONE_SQL_JSON_ITEM),
4367 errmsg("JSON path expression in JSON_VALUE must return single scalar item")));
4368 }
4369
4370 res = copyJsonbValue(JsonValueListHead(&found));
4371 if (res->type == jbvBinary && JsonContainerIsScalar(res->val.binary.data))
4372 JsonbExtractScalar(res->val.binary.data, res);
4373
4374 /* JSON_VALUE expects to get only scalars. */
4375 if (!IsAJsonbScalar(res))
4376 {
4377 if (error)
4378 {
4379 *error = true;
4380 return NULL;
4381 }
4382
4383 if (column_name)
4384 ereport(ERROR,
4385 (errcode(ERRCODE_SQL_JSON_SCALAR_REQUIRED),
4386 errmsg("JSON path expression for column \"%s\" must return single scalar item",
4387 column_name)));
4388 else
4389 ereport(ERROR,
4390 (errcode(ERRCODE_SQL_JSON_SCALAR_REQUIRED),
4391 errmsg("JSON path expression in JSON_VALUE must return single scalar item")));
4392 }
4393
4394 if (res->type == jbvNull)
4395 return NULL;
4396
4397 return res;
4398}
4399
4400/************************ JSON_TABLE functions ***************************/
4401
4402/*
4403 * Sanity-checks and returns the opaque JsonTableExecContext from the
4404 * given executor state struct.
4405 */
4406static inline JsonTableExecContext *
4407GetJsonTableExecContext(TableFuncScanState *state, const char *fname)
4408{
4409 JsonTableExecContext *result;
4410
4411 if (!IsA(state, TableFuncScanState))
4412 elog(ERROR, "%s called with invalid TableFuncScanState", fname);
4413 result = (JsonTableExecContext *) state->opaque;
4414 if (result->magic != JSON_TABLE_EXEC_CONTEXT_MAGIC)
4415 elog(ERROR, "%s called with invalid TableFuncScanState", fname);
4416
4417 return result;
4418}
4419
4420/*
4421 * JsonTableInitOpaque
4422 * Fill in TableFuncScanState->opaque for processing JSON_TABLE
4423 *
4424 * This initializes the PASSING arguments and the JsonTablePlanState for
4425 * JsonTablePlan given in TableFunc.
4426 */
4427static void
4428JsonTableInitOpaque(TableFuncScanState *state, int natts)
4429{
4430 JsonTableExecContext *cxt;
4431 PlanState *ps = &state->ss.ps;
4432 TableFuncScan *tfs = castNode(TableFuncScan, ps->plan);
4433 TableFunc *tf = tfs->tablefunc;
4434 JsonTablePlan *rootplan = (JsonTablePlan *) tf->plan;
4435 JsonExpr *je = castNode(JsonExpr, tf->docexpr);
4436 List *args = NIL;
4437
4438 cxt = palloc0_object(JsonTableExecContext);
4439 cxt->magic = JSON_TABLE_EXEC_CONTEXT_MAGIC;
4440
4441 /*
4442 * Evaluate JSON_TABLE() PASSING arguments to be passed to the jsonpath
4443 * executor via JsonPathVariables.
4444 */
4445 if (state->passingvalexprs)
4446 {
4447 ListCell *exprlc;
4448 ListCell *namelc;
4449
4450 Assert(list_length(state->passingvalexprs) ==
4451 list_length(je->passing_names));
4452 forboth(exprlc, state->passingvalexprs,
4453 namelc, je->passing_names)
4454 {
4455 ExprState *state = lfirst_node(ExprState, exprlc);
4456 String *name = lfirst_node(String, namelc);
4457 JsonPathVariable *var = palloc_object(JsonPathVariable);
4458
4459 var->name = pstrdup(name->sval);
4460 var->namelen = strlen(var->name);
4461 var->typid = exprType((Node *) state->expr);
4462 var->typmod = exprTypmod((Node *) state->expr);
4463
4464 /*
4465 * Evaluate the expression and save the value to be returned by
4466 * GetJsonPathVar().
4467 */
4468 var->value = ExecEvalExpr(state, ps->ps_ExprContext,
4469 &var->isnull);
4470
4471 args = lappend(args, var);
4472 }
4473 }
4474
4475 cxt->colplanstates = palloc_array(JsonTablePlanState *, list_length(tf->colvalexprs));
4476
4477 /*
4478 * Initialize plan for the root path and, recursively, also any child
4479 * plans that compute the NESTED paths.
4480 */
4481 cxt->rootplanstate = JsonTableInitPlan(cxt, rootplan, NULL, args,
4482 CurrentMemoryContext);
4483
4484 state->opaque = cxt;
4485}
4486
4487/*
4488 * JsonTableDestroyOpaque
4489 * Resets state->opaque
4490 */
4491static void
4492JsonTableDestroyOpaque(TableFuncScanState *state)
4493{
4494 JsonTableExecContext *cxt =
4495 GetJsonTableExecContext(state, "JsonTableDestroyOpaque");
4496
4497 /* not valid anymore */
4498 cxt->magic = 0;
4499
4500 state->opaque = NULL;
4501}
4502
4503/*
4504 * JsonTableInitPlan
4505 * Initialize information for evaluating jsonpath in the given
4506 * JsonTablePlan and, recursively, in any child plans
4507 */
4508static JsonTablePlanState *
4509JsonTableInitPlan(JsonTableExecContext *cxt, JsonTablePlan *plan,
4510 JsonTablePlanState *parentstate,
4511 List *args, MemoryContext mcxt)
4512{
4513 JsonTablePlanState *planstate = palloc0_object(JsonTablePlanState);
4514
4515 planstate->plan = plan;
4516 planstate->parent = parentstate;
4517 JsonValueListInit(&planstate->found);
4518
4519 if (IsA(plan, JsonTablePathScan))
4520 {
4521 JsonTablePathScan *scan = (JsonTablePathScan *) plan;
4522 int i;
4523
4524 planstate->outerJoin = scan->outerJoin;
4525 planstate->path = DatumGetJsonPathP(scan->path->value->constvalue);
4526 planstate->args = args;
4527 planstate->mcxt = AllocSetContextCreate(mcxt, "JsonTableExecContext",
4528 ALLOCSET_DEFAULT_SIZES);
4529
4530 /* No row pattern evaluated yet. */
4531 planstate->current.value = PointerGetDatum(NULL);
4532 planstate->current.isnull = true;
4533
4534 for (i = scan->colMin; i >= 0 && i <= scan->colMax; i++)
4535 cxt->colplanstates[i] = planstate;
4536
4537 planstate->nested = scan->child ?
4538 JsonTableInitPlan(cxt, scan->child, planstate, args, mcxt) : NULL;
4539 }
4540 else if (IsA(plan, JsonTableSiblingJoin))
4541 {
4542 JsonTableSiblingJoin *join = (JsonTableSiblingJoin *) plan;
4543
4544 planstate->cross = join->cross;
4545
4546 planstate->left = JsonTableInitPlan(cxt, join->lplan, parentstate,
4547 args, mcxt);
4548 planstate->right = JsonTableInitPlan(cxt, join->rplan, parentstate,
4549 args, mcxt);
4550 }
4551
4552 return planstate;
4553}
4554
4555/*
4556 * JsonTableSetDocument
4557 * Install the input document and evaluate the row pattern
4558 */
4559static void
4567
4568/*
4569 * Evaluate a JsonTablePlan's jsonpath to get a new row pattern from
4570 * the given context item
4571 */
4572static void
4573JsonTableResetRowPattern(JsonTablePlanState *planstate, Datum item)
4574{
4575 JsonTablePathScan *scan = castNode(JsonTablePathScan, planstate->plan);
4576 MemoryContext oldcxt;
4577 JsonPathExecResult res;
4578 Jsonb *js = (Jsonb *) DatumGetJsonbP(item);
4579
4580 JsonValueListClear(&planstate->found);
4581
4582 MemoryContextResetOnly(planstate->mcxt);
4583
4584 oldcxt = MemoryContextSwitchTo(planstate->mcxt);
4585
4586 res = executeJsonPath(planstate->path, planstate->args,
4587 GetJsonPathVar, CountJsonPathVars,
4588 js, scan->errorOnError,
4589 &planstate->found,
4590 true);
4591
4592 MemoryContextSwitchTo(oldcxt);
4593
4594 if (jperIsError(res))
4595 {
4596 Assert(!scan->errorOnError);
4597 JsonValueListClear(&planstate->found);
4598 }
4599
4600 JsonTableRescan(planstate);
4601}
4602
4603/*
4604 * Fetch next row from a JsonTablePlan.
4605 *
4606 * Returns false if the plan has run out of rows, true otherwise.
4607 */
4608static bool
4609JsonTablePlanNextRow(JsonTablePlanState *planstate)
4610{
4611 if (IsA(planstate->plan, JsonTableSiblingJoin))
4612 {
4613 if (planstate->advanceRight)
4614 {
4615 /* fetch next inner row */
4616 if (JsonTablePlanNextRow(planstate->right))
4617 return true;
4618
4619 /* inner rows are exhausted */
4620 if (planstate->cross)
4621 planstate->advanceRight = false; /* next outer row */
4622 else
4623 return false; /* end of scan */
4624 }
4625
4626 while (!planstate->advanceRight)
4627 {
4628 /* fetch next outer row */
4629 bool more = JsonTablePlanNextRow(planstate->left);
4630
4631 if (planstate->cross)
4632 {
4633 if (!more)
4634 return false; /* end of scan */
4635
4636 JsonTableRescan(planstate->right);
4637
4638 if (!JsonTablePlanNextRow(planstate->right))
4639 continue; /* next outer row */
4640
4641 planstate->advanceRight = true; /* next inner row */
4642 }
4643 else if (!more)
4644 {
4645 if (!JsonTablePlanNextRow(planstate->right))
4646 return false; /* end of scan */
4647
4648 planstate->advanceRight = true; /* next inner row */
4649 }
4650
4651 break;
4652 }
4653 }
4654 else
4655 {
4656 /* reset context item if requested */
4657 if (planstate->reset)
4658 {
4659 JsonTablePlanState *parent = planstate->parent;
4660
4661 Assert(parent != NULL && !parent->current.isnull);
4662 JsonTableResetRowPattern(planstate, parent->current.value);
4663 planstate->reset = false;
4664 }
4665
4666 if (planstate->advanceNested)
4667 {
4668 /* fetch next nested row */
4669 planstate->advanceNested = JsonTablePlanNextRow(planstate->nested);
4670 if (planstate->advanceNested)
4671 return true;
4672 }
4673
4674 for (;;)
4675 {
4676 if (!JsonTablePlanScanNextRow(planstate))
4677 return false;
4678
4679 if (planstate->nested == NULL)
4680 break;
4681
4682 JsonTableResetNestedPlan(planstate->nested);
4683 planstate->advanceNested = JsonTablePlanNextRow(planstate->nested);
4684
4685 if (!planstate->advanceNested && !planstate->outerJoin)
4686 continue;
4687
4688 /*
4689 * We have a row to return: either the nested plan produced one,
4690 * or this is an outer join and we emit the parent row with the
4691 * nested columns set to NULL.
4692 */
4693 break;
4694 }
4695 }
4696
4697 return true;
4698}
4699
4700/*
4701 * Advance a JsonTablePlan's path scan to its next row pattern match.
4702 *
4703 * This only moves this plan's own row pattern iterator forward and makes the
4704 * matched item the current row; driving and joining of any nested plan is the
4705 * responsibility of JsonTablePlanNextRow(). Returns false when this scan's
4706 * row pattern matches are exhausted.
4707 */
4708static bool
4709JsonTablePlanScanNextRow(JsonTablePlanState *planstate)
4710{
4711 JsonbValue *jbv;
4712 MemoryContext oldcxt;
4713
4714 /* Fetch new row from the list of found values to set as active. */
4715 jbv = JsonValueListNext(&planstate->iter);
4716
4717 /* End of list? */
4718 if (jbv == NULL)
4719 {
4720 planstate->current.value = PointerGetDatum(NULL);
4721 planstate->current.isnull = true;
4722 return false;
4723 }
4724
4725 /*
4726 * Set current row item for subsequent JsonTableGetValue() calls for
4727 * evaluating individual columns.
4728 */
4729 oldcxt = MemoryContextSwitchTo(planstate->mcxt);
4730 planstate->current.value = JsonbPGetDatum(JsonbValueToJsonb(jbv));
4731 planstate->current.isnull = false;
4732 MemoryContextSwitchTo(oldcxt);
4733
4734 /* Next row! */
4735 planstate->ordinal++;
4736
4737 /* There are more rows. */
4738 return true;
4739}
4740
4741/*
4742 * Re-evaluate the row pattern of a nested plan using the new parent row
4743 * pattern.
4744 */
4745static void
4746JsonTableResetNestedPlan(JsonTablePlanState *planstate)
4747{
4748 /* This better be a child plan. */
4749 Assert(planstate->parent != NULL);
4750 if (IsA(planstate->plan, JsonTablePathScan))
4751 {
4752 JsonTablePlanState *parent = planstate->parent;
4753
4754 planstate->reset = true;
4755 planstate->advanceNested = false;
4756
4757 if (planstate->nested)
4758 JsonTableResetNestedPlan(planstate->nested);
4759
4760 /*
4761 * Reset this plan's transient scan state so that its columns read as
4762 * NULL until it is actually advanced. Re-evaluating the path against
4763 * the new parent row is deferred (see the reset flag) until the plan
4764 * is advanced by JsonTablePlanNextRow(), so that the path is not
4765 * evaluated more than once per parent row.
4766 */
4767 if (!parent->current.isnull)
4768 JsonTableRescan(planstate);
4769 }
4770 else if (IsA(planstate->plan, JsonTableSiblingJoin))
4771 {
4772 JsonTableResetNestedPlan(planstate->left);
4773 JsonTableResetNestedPlan(planstate->right);
4774 planstate->advanceRight = false;
4775 }
4776}
4777
4778/*
4779 * JsonTableFetchRow
4780 * Prepare the next "current" row for upcoming GetValue calls.
4781 *
4782 * Returns false if no more rows can be returned.
4783 */
4784static bool
4785JsonTableFetchRow(TableFuncScanState *state)
4786{
4787 JsonTableExecContext *cxt =
4788 GetJsonTableExecContext(state, "JsonTableFetchRow");
4789
4790 return JsonTablePlanNextRow(cxt->rootplanstate);
4791}
4792
4793/*
4794 * JsonTableGetValue
4795 * Return the value for column number 'colnum' for the current row.
4796 *
4797 * This leaks memory, so be sure to reset often the context in which it's
4798 * called.
4799 */
4800static Datum
4801JsonTableGetValue(TableFuncScanState *state, int colnum,
4802 Oid typid, int32 typmod, bool *isnull)
4803{
4804 JsonTableExecContext *cxt =
4805 GetJsonTableExecContext(state, "JsonTableGetValue");
4806 ExprContext *econtext = state->ss.ps.ps_ExprContext;
4807 ExprState *estate = list_nth(state->colvalexprs, colnum);
4808 JsonTablePlanState *planstate = cxt->colplanstates[colnum];
4809 JsonTablePlanRowSource *current = &planstate->current;
4810 Datum result;
4811
4812 /* Row pattern value is NULL */
4813 if (current->isnull)
4814 {
4815 result = (Datum) 0;
4816 *isnull = true;
4817 }
4818 /* Evaluate JsonExpr. */
4819 else if (estate)
4820 {
4821 Datum saved_caseValue = econtext->caseValue_datum;
4822 bool saved_caseIsNull = econtext->caseValue_isNull;
4823
4824 /* Pass the row pattern value via CaseTestExpr. */
4825 econtext->caseValue_datum = current->value;
4826 econtext->caseValue_isNull = false;
4827
4828 result = ExecEvalExpr(estate, econtext, isnull);
4829
4830 econtext->caseValue_datum = saved_caseValue;
4831 econtext->caseValue_isNull = saved_caseIsNull;
4832 }
4833 /* ORDINAL column */
4834 else
4835 {
4836 result = Int32GetDatum(planstate->ordinal);
4837 *isnull = false;
4838 }
4839
4840 return result;
4841}
4842
4843/* Recursively reset planstate and its child nodes */
4844static void
4845JsonTableRescan(JsonTablePlanState *planstate)
4846{
4847 if (IsA(planstate->plan, JsonTablePathScan))
4848 {
4849 /* Reset plan iterator to the beginning of the item list */
4850 JsonValueListInitIterator(&planstate->found, &planstate->iter);
4851 planstate->current.value = PointerGetDatum(NULL);
4852 planstate->current.isnull = true;
4853 planstate->ordinal = 0;
4854
4855 if (planstate->nested)
4856 JsonTableRescan(planstate->nested);
4857 }
4858 else if (IsA(planstate->plan, JsonTableSiblingJoin))
4859 {
4860 JsonTableRescan(planstate->left);
4861 JsonTableRescan(planstate->right);
4862 planstate->advanceRight = false;
4863 }
4864}
DetermineTimeZoneOffset
int DetermineTimeZoneOffset(struct pg_tm *tm, pg_tz *tzp)
Definition datetime.c:1608
j2date
void j2date(int jd, int *year, int *month, int *day)
Definition datetime.c:322
make_numeric_typmod_safe
int32 make_numeric_typmod_safe(int32 precision, int32 scale, Node *escontext)
Definition numeric.c:1315
float8_numeric
Datum float8_numeric(PG_FUNCTION_ARGS)
Definition numeric.c:4544
numeric_cmp
Datum numeric_cmp(PG_FUNCTION_ARGS)
Definition numeric.c:2423
int64_to_numeric
Numeric int64_to_numeric(int64 val)
Definition numeric.c:4270
float4_numeric
Datum float4_numeric(PG_FUNCTION_ARGS)
Definition numeric.c:4643
int4_numeric
Datum int4_numeric(PG_FUNCTION_ARGS)
Definition numeric.c:4364
numeric_uminus
Datum numeric_uminus(PG_FUNCTION_ARGS)
Definition numeric.c:1411
numeric_mod_safe
Numeric numeric_mod_safe(Numeric num1, Numeric num2, Node *escontext)
Definition numeric.c:3366
numeric_ceil
Datum numeric_ceil(PG_FUNCTION_ARGS)
Definition numeric.c:1638
numeric_int4_safe
int32 numeric_int4_safe(Numeric num, Node *escontext)
Definition numeric.c:4375
numeric_add_safe
Numeric numeric_add_safe(Numeric num1, Numeric num2, Node *escontext)
Definition numeric.c:2889
numeric_int8_safe
int64 numeric_int8_safe(Numeric num, Node *escontext)
Definition numeric.c:4451
numeric_div_safe
Numeric numeric_div_safe(Numeric num1, Numeric num2, Node *escontext)
Definition numeric.c:3163
numeric_sub_safe
Numeric numeric_sub_safe(Numeric num1, Numeric num2, Node *escontext)
Definition numeric.c:2965
numeric_out
Datum numeric_out(PG_FUNCTION_ARGS)
Definition numeric.c:799
numeric_trunc
Datum numeric_trunc(PG_FUNCTION_ARGS)
Definition numeric.c:1588
numeric_in
Datum numeric_in(PG_FUNCTION_ARGS)
Definition numeric.c:626
numeric_is_nan
bool numeric_is_nan(Numeric num)
Definition numeric.c:834
int2_numeric
Datum int2_numeric(PG_FUNCTION_ARGS)
Definition numeric.c:4495
numeric_mul_safe
Numeric numeric_mul_safe(Numeric num1, Numeric num2, Node *escontext)
Definition numeric.c:3044
numeric_abs
Datum numeric_abs(PG_FUNCTION_ARGS)
Definition numeric.c:1384
int8_numeric
Datum int8_numeric(PG_FUNCTION_ARGS)
Definition numeric.c:4440
numeric_is_inf
bool numeric_is_inf(Numeric num)
Definition numeric.c:845
numeric_floor
Datum numeric_floor(PG_FUNCTION_ARGS)
Definition numeric.c:1666
timestamp_cmp
Datum timestamp_cmp(PG_FUNCTION_ARGS)
Definition timestamp.c:2282
AdjustTimestampForTypmod
bool AdjustTimestampForTypmod(Timestamp *time, int32 typmod, Node *escontext)
Definition timestamp.c:363
timestamp_timestamptz
Datum timestamp_timestamptz(PG_FUNCTION_ARGS)
Definition timestamp.c:6470
timestamp_cmp_timestamptz_internal
int32 timestamp_cmp_timestamptz_internal(Timestamp timestampVal, TimestampTz dt2)
Definition timestamp.c:2375
timestamp2tm
int timestamp2tm(Timestamp dt, int *tzp, struct pg_tm *tm, fsec_t *fsec, const char **tzn, pg_tz *attimezone)
Definition timestamp.c:1918
anytimestamp_typmod_check
int32 anytimestamp_typmod_check(bool istz, int32 typmod)
Definition timestamp.c:116
timestamptz_timestamp
Datum timestamptz_timestamp(PG_FUNCTION_ARGS)
Definition timestamp.c:6539
next
static int32 next
Definition blutils.c:225
parse_bool
bool parse_bool(const char *value, bool *result)
Definition bool.c:31
CStringGetTextDatum
#define CStringGetTextDatum(s)
Definition builtins.h:98
TextDatumGetCString
#define TextDatumGetCString(d)
Definition builtins.h:99
INT64CONST
#define INT64CONST(x)
Definition c.h:689
Min
#define Min(x, y)
Definition c.h:1131
PG_UINT32_MAX
#define PG_UINT32_MAX
Definition c.h:733
PG_USED_FOR_ASSERTS_ONLY
#define PG_USED_FOR_ASSERTS_ONLY
Definition c.h:308
Max
#define Max(x, y)
Definition c.h:1125
Assert
#define Assert(condition)
Definition c.h:1002
int64
int64_t int64
Definition c.h:680
int32
int32_t int32
Definition c.h:679
uint32
uint32_t uint32
Definition c.h:683
lengthof
#define lengthof(array)
Definition c.h:932
result
uint32 result
Definition checksum_block_internal.h:18
collid
Oid collid
Definition collationcmds.c:705
Timestamp
int64 Timestamp
Definition timestamp.h:38
TimestampTz
int64 TimestampTz
Definition timestamp.h:39
fsec_t
int32 fsec_t
Definition timestamp.h:41
POSTGRES_EPOCH_JDATE
#define POSTGRES_EPOCH_JDATE
Definition timestamp.h:235
date_cmp_timestamp_internal
int32 date_cmp_timestamp_internal(DateADT dateVal, Timestamp dt2)
Definition date.c:764
date_cmp
Datum date_cmp(PG_FUNCTION_ARGS)
Definition date.c:440
time_cmp
Datum time_cmp(PG_FUNCTION_ARGS)
Definition date.c:1842
timestamp_time
Datum timestamp_time(PG_FUNCTION_ARGS)
Definition date.c:2015
anytime_typmod_check
int32 anytime_typmod_check(bool istz, int32 typmod)
Definition date.c:65
date_timestamptz
Datum date_timestamptz(PG_FUNCTION_ARGS)
Definition date.c:1393
timetz_cmp
Datum timetz_cmp(PG_FUNCTION_ARGS)
Definition date.c:2645
timetz_time
Datum timetz_time(PG_FUNCTION_ARGS)
Definition date.c:2939
time_timetz
Datum time_timetz(PG_FUNCTION_ARGS)
Definition date.c:2952
timestamptz_timetz
Datum timestamptz_timetz(PG_FUNCTION_ARGS)
Definition date.c:2979
AdjustTimeForTypmod
void AdjustTimeForTypmod(TimeADT *time, int32 typmod)
Definition date.c:1753
timestamptz_date
Datum timestamptz_date(PG_FUNCTION_ARGS)
Definition date.c:1411
timestamp_date
Datum timestamp_date(PG_FUNCTION_ARGS)
Definition date.c:1330
date_cmp_timestamptz_internal
int32 date_cmp_timestamptz_internal(DateADT dateVal, TimestampTz dt2)
Definition date.c:845
timestamptz_time
Datum timestamptz_time(PG_FUNCTION_ARGS)
Definition date.c:2046
date_timestamp
Datum date_timestamp(PG_FUNCTION_ARGS)
Definition date.c:1313
DatumGetTimeTzADTP
static TimeTzADT * DatumGetTimeTzADTP(Datum X)
Definition date.h:72
DateADT
int32 DateADT
Definition date.h:21
DatumGetDateADT
static DateADT DatumGetDateADT(Datum X)
Definition date.h:60
DatumGetTimeADT
static TimeADT DatumGetTimeADT(Datum X)
Definition date.h:66
TimeTzADTPGetDatum
static Datum TimeTzADTPGetDatum(const TimeTzADT *X)
Definition date.h:90
TimeADT
int64 TimeADT
Definition date.h:23
TimeADTGetDatum
static Datum TimeADTGetDatum(TimeADT X)
Definition date.h:84
cur
struct cursor * cur
Definition ecpg.c:29
errcode
int errcode(int sqlerrcode)
Definition elog.c:875
errhint
int errhint(const char *fmt,...) pg_attribute_printf(1
errdetail
int errdetail(const char *fmt,...) pg_attribute_printf(1
ERROR
#define ERROR
Definition elog.h:40
elog
#define elog(elevel,...)
Definition elog.h:228
ereport
#define ereport(elevel,...)
Definition elog.h:152
ExecEvalExpr
static Datum ExecEvalExpr(ExprState *state, ExprContext *econtext, bool *isNull)
Definition executor.h:401
palloc_object
#define palloc_object(type)
Definition fe_memutils.h:89
palloc_array
#define palloc_array(type, count)
Definition fe_memutils.h:91
palloc0_object
#define palloc0_object(type)
Definition fe_memutils.h:90
float8in_internal
float8 float8in_internal(char *num, char **endptr_p, const char *type_name, const char *orig_string, struct Node *escontext)
Definition float.c:436
DirectFunctionCall2Coll
Datum DirectFunctionCall2Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2)
Definition fmgr.c:814
DirectInputFunctionCallSafe
bool DirectInputFunctionCallSafe(PGFunction func, char *str, Oid typioparam, int32 typmod, Node *escontext, Datum *result)
Definition fmgr.c:1641
DirectFunctionCall1Coll
Datum DirectFunctionCall1Coll(PGFunction func, Oid collation, Datum arg1)
Definition fmgr.c:794
DirectFunctionCall3Coll
Datum DirectFunctionCall3Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum arg3)
Definition fmgr.c:836
PG_FREE_IF_COPY
#define PG_FREE_IF_COPY(ptr, n)
Definition fmgr.h:260
DirectFunctionCall2
#define DirectFunctionCall2(func, arg1, arg2)
Definition fmgr.h:690
DirectFunctionCall1
#define DirectFunctionCall1(func, arg1)
Definition fmgr.h:688
PG_NARGS
#define PG_NARGS()
Definition fmgr.h:203
PG_RETURN_NULL
#define PG_RETURN_NULL()
Definition fmgr.h:346
PG_GETARG_BOOL
#define PG_GETARG_BOOL(n)
Definition fmgr.h:274
PGFunction
Datum(* PGFunction)(FunctionCallInfo fcinfo)
Definition fmgr.h:40
DatumGetTextP
#define DatumGetTextP(X)
Definition fmgr.h:333
PG_FUNCTION_ARGS
#define PG_FUNCTION_ARGS
Definition fmgr.h:193
PG_RETURN_BOOL
#define PG_RETURN_BOOL(x)
Definition fmgr.h:360
format_type_be
char * format_type_be(Oid type_oid)
Definition format_type.c:343
parse_datetime
Datum parse_datetime(text *date_txt, text *fmt, Oid collid, bool strict, Oid *typid, int32 *typmod, int *tz, Node *escontext)
Definition formatting.c:4157
SRF_IS_FIRSTCALL
#define SRF_IS_FIRSTCALL()
Definition funcapi.h:304
SRF_PERCALL_SETUP
#define SRF_PERCALL_SETUP()
Definition funcapi.h:308
SRF_RETURN_NEXT
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition funcapi.h:310
SRF_FIRSTCALL_INIT
#define SRF_FIRSTCALL_INIT()
Definition funcapi.h:306
SRF_RETURN_DONE
#define SRF_RETURN_DONE(_funcctx)
Definition funcapi.h:328
str
const char * str
Definition hashfn_unstable.h:262
MAXDATELEN
#define MAXDATELEN
Definition datetime.h:200
ps
struct parser_state ps
val
long val
Definition informix.c:689
value
static struct @175 value
int8in
Datum int8in(PG_FUNCTION_ARGS)
Definition int8.c:51
int4in
Datum int4in(PG_FUNCTION_ARGS)
Definition int.c:316
b
int b
Definition isn.c:74
a
int a
Definition isn.c:73
i
int i
Definition isn.c:77
JsonEncodeDateTime
char * JsonEncodeDateTime(char *buf, Datum value, Oid typid, const int *tzp)
Definition json.c:309
jsonb_in
Datum jsonb_in(PG_FUNCTION_ARGS)
Definition jsonb.c:64
JsonbTypeName
const char * JsonbTypeName(JsonbValue *val)
Definition jsonb.c:172
JsonbExtractScalar
bool JsonbExtractScalar(JsonbContainer *jbc, JsonbValue *res)
Definition jsonb.c:1749
jbvType
jbvType
Definition jsonb.h:228
jbvObject
@ jbvObject
Definition jsonb.h:236
jbvNumeric
@ jbvNumeric
Definition jsonb.h:232
jbvBool
@ jbvBool
Definition jsonb.h:233
jbvArray
@ jbvArray
Definition jsonb.h:235
jbvBinary
@ jbvBinary
Definition jsonb.h:238
jbvNull
@ jbvNull
Definition jsonb.h:230
jbvDatetime
@ jbvDatetime
Definition jsonb.h:246
jbvString
@ jbvString
Definition jsonb.h:231
JsonContainerIsScalar
#define JsonContainerIsScalar(jc)
Definition jsonb.h:209
JsonContainerIsArray
#define JsonContainerIsArray(jc)
Definition jsonb.h:211
JsonContainerSize
#define JsonContainerSize(jc)
Definition jsonb.h:208
PG_GETARG_JSONB_P_COPY
#define PG_GETARG_JSONB_P_COPY(x)
Definition jsonb.h:419
JsonbPGetDatum
static Datum JsonbPGetDatum(const Jsonb *p)
Definition jsonb.h:413
IsAJsonbScalar
#define IsAJsonbScalar(jsonbval)
Definition jsonb.h:299
PG_RETURN_JSONB_P
#define PG_RETURN_JSONB_P(x)
Definition jsonb.h:420
PG_GETARG_JSONB_P
#define PG_GETARG_JSONB_P(x)
Definition jsonb.h:418
JsonContainerIsObject
#define JsonContainerIsObject(jc)
Definition jsonb.h:210
DatumGetJsonbP
static Jsonb * DatumGetJsonbP(Datum d)
Definition jsonb.h:401
JsonbIteratorToken
JsonbIteratorToken
Definition jsonb.h:21
WJB_KEY
@ WJB_KEY
Definition jsonb.h:23
WJB_DONE
@ WJB_DONE
Definition jsonb.h:22
WJB_END_ARRAY
@ WJB_END_ARRAY
Definition jsonb.h:27
WJB_VALUE
@ WJB_VALUE
Definition jsonb.h:24
WJB_END_OBJECT
@ WJB_END_OBJECT
Definition jsonb.h:29
WJB_ELEM
@ WJB_ELEM
Definition jsonb.h:25
WJB_BEGIN_OBJECT
@ WJB_BEGIN_OBJECT
Definition jsonb.h:28
WJB_BEGIN_ARRAY
@ WJB_BEGIN_ARRAY
Definition jsonb.h:26
JB_FOBJECT
#define JB_FOBJECT
Definition jsonb.h:204
pushJsonbValue
void pushJsonbValue(JsonbInState *pstate, JsonbIteratorToken seq, JsonbValue *jbval)
Definition jsonb_util.c:583
JsonbIteratorInit
JsonbIterator * JsonbIteratorInit(JsonbContainer *container)
Definition jsonb_util.c:935
findJsonbValueFromContainer
JsonbValue * findJsonbValueFromContainer(JsonbContainer *container, uint32 flags, JsonbValue *key)
Definition jsonb_util.c:348
JsonbIteratorNext
JsonbIteratorToken JsonbIteratorNext(JsonbIterator **it, JsonbValue *val, bool skipNested)
Definition jsonb_util.c:973
getIthJsonbValueFromContainer
JsonbValue * getIthJsonbValueFromContainer(JsonbContainer *container, uint32 i)
Definition jsonb_util.c:472
JsonbValueToJsonb
Jsonb * JsonbValueToJsonb(JsonbValue *val)
Definition jsonb_util.c:96
jspGetLeftArg
void jspGetLeftArg(JsonPathItem *v, JsonPathItem *a)
Definition jsonpath.c:1263
jspGetArg
void jspGetArg(JsonPathItem *v, JsonPathItem *a)
Definition jsonpath.c:1167
jspInitByBuffer
void jspInitByBuffer(JsonPathItem *v, char *base, int32 pos)
Definition jsonpath.c:1068
jspGetBool
bool jspGetBool(JsonPathItem *v)
Definition jsonpath.c:1311
jspInit
void jspInit(JsonPathItem *v, JsonPath *js)
Definition jsonpath.c:1058
jspGetString
char * jspGetString(JsonPathItem *v, int32 *len)
Definition jsonpath.c:1327
jspGetNumeric
Numeric jspGetNumeric(JsonPathItem *v)
Definition jsonpath.c:1319
jspGetArraySubscript
bool jspGetArraySubscript(JsonPathItem *v, JsonPathItem *from, JsonPathItem *to, int i)
Definition jsonpath.c:1339
jspOperationName
const char * jspOperationName(JsonPathItemType type)
Definition jsonpath.c:905
jspGetNext
bool jspGetNext(JsonPathItem *v, JsonPathItem *a)
Definition jsonpath.c:1188
jspGetRightArg
void jspGetRightArg(JsonPathItem *v, JsonPathItem *a)
Definition jsonpath.c:1287
jspConvertRegexFlags
bool jspConvertRegexFlags(uint32 xflags, int *result, struct Node *escontext)
jspHasNext
#define jspHasNext(jsp)
Definition jsonpath.h:202
PG_GETARG_JSONPATH_P
#define PG_GETARG_JSONPATH_P(x)
Definition jsonpath.h:46
PG_GETARG_JSONPATH_P_COPY
#define PG_GETARG_JSONPATH_P_COPY(x)
Definition jsonpath.h:47
DatumGetJsonPathP
static JsonPath * DatumGetJsonPathP(Datum d)
Definition jsonpath.h:35
jpiAdd
@ jpiAdd
Definition jsonpath.h:78
jpiString
@ jpiString
Definition jsonpath.h:65
jpiAbs
@ jpiAbs
Definition jsonpath.h:97
jpiIndexArray
@ jpiIndexArray
Definition jsonpath.h:87
jpiAny
@ jpiAny
Definition jsonpath.h:88
jpiDatetime
@ jpiDatetime
Definition jsonpath.h:101
jpiStrRtrim
@ jpiStrRtrim
Definition jsonpath.h:122
jpiBigint
@ jpiBigint
Definition jsonpath.h:107
jpiBool
@ jpiBool
Definition jsonpath.h:67
jpiType
@ jpiType
Definition jsonpath.h:95
jpiStrUpper
@ jpiStrUpper
Definition jsonpath.h:120
jpiFloor
@ jpiFloor
Definition jsonpath.h:98
jpiStrBtrim
@ jpiStrBtrim
Definition jsonpath.h:123
jpiAnyArray
@ jpiAnyArray
Definition jsonpath.h:85
jpiExists
@ jpiExists
Definition jsonpath.h:94
jpiSize
@ jpiSize
Definition jsonpath.h:96
jpiStrReplace
@ jpiStrReplace
Definition jsonpath.h:118
jpiSub
@ jpiSub
Definition jsonpath.h:79
jpiNotEqual
@ jpiNotEqual
Definition jsonpath.h:73
jpiMul
@ jpiMul
Definition jsonpath.h:80
jpiVariable
@ jpiVariable
Definition jsonpath.h:92
jpiTimeTz
@ jpiTimeTz
Definition jsonpath.h:115
jpiNot
@ jpiNot
Definition jsonpath.h:70
jpiDate
@ jpiDate
Definition jsonpath.h:109
jpiGreaterOrEqual
@ jpiGreaterOrEqual
Definition jsonpath.h:77
jpiPlus
@ jpiPlus
Definition jsonpath.h:83
jpiStrInitcap
@ jpiStrInitcap
Definition jsonpath.h:124
jpiDouble
@ jpiDouble
Definition jsonpath.h:100
jpiGreater
@ jpiGreater
Definition jsonpath.h:75
jpiNumber
@ jpiNumber
Definition jsonpath.h:112
jpiStrLtrim
@ jpiStrLtrim
Definition jsonpath.h:121
jpiAnd
@ jpiAnd
Definition jsonpath.h:68
jpiStartsWith
@ jpiStartsWith
Definition jsonpath.h:105
jpiOr
@ jpiOr
Definition jsonpath.h:69
jpiMod
@ jpiMod
Definition jsonpath.h:82
jpiTimestamp
@ jpiTimestamp
Definition jsonpath.h:116
jpiStrSplitPart
@ jpiStrSplitPart
Definition jsonpath.h:125
jpiLikeRegex
@ jpiLikeRegex
Definition jsonpath.h:106
jpiTimestampTz
@ jpiTimestampTz
Definition jsonpath.h:117
jpiInteger
@ jpiInteger
Definition jsonpath.h:111
jpiRoot
@ jpiRoot
Definition jsonpath.h:91
jpiFilter
@ jpiFilter
Definition jsonpath.h:93
jpiNull
@ jpiNull
Definition jsonpath.h:64
jpiLess
@ jpiLess
Definition jsonpath.h:74
jpiCurrent
@ jpiCurrent
Definition jsonpath.h:90
jpiEqual
@ jpiEqual
Definition jsonpath.h:72
jpiKey
@ jpiKey
Definition jsonpath.h:89
jpiDiv
@ jpiDiv
Definition jsonpath.h:81
jpiTime
@ jpiTime
Definition jsonpath.h:114
jpiLast
@ jpiLast
Definition jsonpath.h:104
jpiMinus
@ jpiMinus
Definition jsonpath.h:84
jpiLessOrEqual
@ jpiLessOrEqual
Definition jsonpath.h:76
jpiCeiling
@ jpiCeiling
Definition jsonpath.h:99
jpiIsUnknown
@ jpiIsUnknown
Definition jsonpath.h:71
jpiKeyValue
@ jpiKeyValue
Definition jsonpath.h:102
jpiNumeric
@ jpiNumeric
Definition jsonpath.h:66
jpiStrLower
@ jpiStrLower
Definition jsonpath.h:119
jpiBoolean
@ jpiBoolean
Definition jsonpath.h:108
jpiStringFunc
@ jpiStringFunc
Definition jsonpath.h:113
jpiDecimal
@ jpiDecimal
Definition jsonpath.h:110
jpiAnyKey
@ jpiAnyKey
Definition jsonpath.h:86
JSONPATH_LAX
#define JSONPATH_LAX
Definition jsonpath.h:31
executeComparison
static JsonPathBool executeComparison(JsonPathItem *cmp, JsonbValue *lv, JsonbValue *rv, void *p)
Definition jsonpath_exec.c:3514
JsonPathExists
bool JsonPathExists(Datum jb, JsonPath *jp, bool *error, List *vars)
Definition jsonpath_exec.c:4210
jsonb_path_query_first_internal
static Datum jsonb_path_query_first_internal(FunctionCallInfo fcinfo, bool tz)
Definition jsonpath_exec.c:666
executeItemOptUnwrapTarget
static JsonPathExecResult executeItemOptUnwrapTarget(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found, bool unwrap)
Definition jsonpath_exec.c:797
jsonb_path_query_tz
Datum jsonb_path_query_tz(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:620
jspAutoUnwrap
#define jspAutoUnwrap(cxt)
Definition jsonpath_exec.c:272
jsonb_path_exists_opr
Datum jsonb_path_exists_opr(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:480
cmpDateToTimestamp
static int cmpDateToTimestamp(DateADT date1, Timestamp ts2, bool useTz)
Definition jsonpath_exec.c:4012
executeBoolItem
static JsonPathBool executeBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool canHaveNext)
Definition jsonpath_exec.c:1820
JsonbArraySize
static int JsonbArraySize(JsonbValue *jb)
Definition jsonpath_exec.c:3497
JsonValueListNext
static JsonbValue * JsonValueListNext(JsonValueListIterator *it)
Definition jsonpath_exec.c:3902
JsonTableResetRowPattern
static void JsonTableResetRowPattern(JsonTablePlanState *planstate, Datum item)
Definition jsonpath_exec.c:4573
compareStrings
static int compareStrings(const char *mbstr1, int mblen1, const char *mbstr2, int mblen2)
Definition jsonpath_exec.c:3546
appendBoolResult
static JsonPathExecResult appendBoolResult(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonValueList *found, JsonPathBool res)
Definition jsonpath_exec.c:3202
BASE_JVL_ITEMS
#define BASE_JVL_ITEMS
Definition jsonpath_exec.c:168
jsonb_path_query_first
Datum jsonb_path_query_first(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:687
JsonTableSetDocument
static void JsonTableSetDocument(TableFuncScanState *state, Datum value)
Definition jsonpath_exec.c:4560
JsonValueListIsEmpty
static bool JsonValueListIsEmpty(const JsonValueList *jvl)
Definition jsonpath_exec.c:3851
jsonb_path_query_array_internal
static Datum jsonb_path_query_array_internal(FunctionCallInfo fcinfo, bool tz)
Definition jsonpath_exec.c:631
executeBinaryArithmExpr
static JsonPathExecResult executeBinaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, BinaryArithmFunc func, JsonValueList *found)
Definition jsonpath_exec.c:2169
countVariablesFromJsonb
static int countVariablesFromJsonb(void *varsJsonb)
Definition jsonpath_exec.c:3475
GetJsonTableExecContext
static JsonTableExecContext * GetJsonTableExecContext(TableFuncScanState *state, const char *fname)
Definition jsonpath_exec.c:4407
jsonb_path_query_internal
static Datum jsonb_path_query_internal(FunctionCallInfo fcinfo, bool tz)
Definition jsonpath_exec.c:564
RETURN_ERROR
#define RETURN_ERROR(throw_error)
Definition jsonpath_exec.c:278
JsonTableRescan
static void JsonTableRescan(JsonTablePlanState *planstate)
Definition jsonpath_exec.c:4845
JSON_TABLE_EXEC_CONTEXT_MAGIC
#define JSON_TABLE_EXEC_CONTEXT_MAGIC
Definition jsonpath_exec.c:254
executeItemOptUnwrapResultNoThrow
static JsonPathExecResult executeItemOptUnwrapResultNoThrow(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, JsonValueList *found)
Definition jsonpath_exec.c:1803
executeAnyItem
static JsonPathExecResult executeAnyItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbContainer *jbc, JsonValueList *found, uint32 level, uint32 first, uint32 last, bool ignoreStructuralErrors, bool unwrapNext)
Definition jsonpath_exec.c:1984
jspAutoWrap
#define jspAutoWrap(cxt)
Definition jsonpath_exec.c:273
executeKeyValueMethod
static JsonPathExecResult executeKeyValueMethod(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found)
Definition jsonpath_exec.c:3092
executeStartsWith
static JsonPathBool executeStartsWith(JsonPathItem *jsp, JsonbValue *whole, JsonbValue *initial, void *param)
Definition jsonpath_exec.c:2345
jsonb_path_match_internal
static Datum jsonb_path_match_internal(FunctionCallInfo fcinfo, bool tz)
Definition jsonpath_exec.c:492
BinaryArithmFunc
Numeric(* BinaryArithmFunc)(Numeric num1, Numeric num2, Node *escontext)
Definition jsonpath_exec.c:290
setBaseObject
static JsonBaseObjectInfo setBaseObject(JsonPathExecContext *cxt, JsonbValue *jbv, int32 id)
Definition jsonpath_exec.c:3778
castTimeToTimeTz
static Datum castTimeToTimeTz(Datum time, bool useTz)
Definition jsonpath_exec.c:4000
executeUnaryArithmExpr
static JsonPathExecResult executeUnaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, PGFunction func, JsonValueList *found)
Definition jsonpath_exec.c:2266
JsonPathQuery
Datum JsonPathQuery(Datum jb, JsonPath *jp, JsonWrapper wrapper, bool *empty, bool *error, List *vars, const char *column_name)
Definition jsonpath_exec.c:4233
JsonbType
static int JsonbType(JsonbValue *jb)
Definition jsonpath_exec.c:3934
JsonTableResetNestedPlan
static void JsonTableResetNestedPlan(JsonTablePlanState *planstate)
Definition jsonpath_exec.c:4746
executeDateTimeMethod
static JsonPathExecResult executeDateTimeMethod(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found)
Definition jsonpath_exec.c:2441
getScalar
static JsonbValue * getScalar(JsonbValue *scalar, enum jbvType type)
Definition jsonpath_exec.c:3958
JsonItemFromDatum
static void JsonItemFromDatum(Datum val, Oid typid, int32 typmod, JsonbValue *res)
Definition jsonpath_exec.c:3321
JsonPathGetVarCallback
JsonbValue *(* JsonPathGetVarCallback)(void *vars, char *varName, int varNameLen, JsonbValue *baseObject, int *baseObjectId)
Definition jsonpath_exec.c:89
jsonb_path_match_tz
Datum jsonb_path_match_tz(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:541
executeItem
static JsonPathExecResult executeItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found)
Definition jsonpath_exec.c:785
JsonValueListInit
static void JsonValueListInit(JsonValueList *jvl)
Definition jsonpath_exec.c:3794
jsonb_path_query
Datum jsonb_path_query(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:614
JsonTablePlanScanNextRow
static bool JsonTablePlanScanNextRow(JsonTablePlanState *planstate)
Definition jsonpath_exec.c:4709
jsonb_path_match_opr
Datum jsonb_path_match_opr(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:552
JsonPathPredicateCallback
JsonPathBool(* JsonPathPredicateCallback)(JsonPathItem *jsp, JsonbValue *larg, JsonbValue *rarg, void *param)
Definition jsonpath_exec.c:286
getJsonPathVariableFromJsonb
static JsonbValue * getJsonPathVariableFromJsonb(void *varsJsonb, char *varName, int varNameLength, JsonbValue *baseObject, int *baseObjectId)
Definition jsonpath_exec.c:3445
GetJsonPathVar
static JsonbValue * GetJsonPathVar(void *cxt, char *varName, int varNameLen, JsonbValue *baseObject, int *baseObjectId)
Definition jsonpath_exec.c:3263
JsonValueListIsSingleton
static bool JsonValueListIsSingleton(const JsonValueList *jvl)
Definition jsonpath_exec.c:3858
executeNestedBoolItem
static JsonPathBool executeNestedBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb)
Definition jsonpath_exec.c:1963
compareDatetime
static int compareDatetime(Datum val1, Oid typid1, Datum val2, Oid typid2, bool useTz, bool *cast_error)
Definition jsonpath_exec.c:4045
cmpDateToTimestampTz
static int cmpDateToTimestampTz(DateADT date1, TimestampTz tstz2, bool useTz)
Definition jsonpath_exec.c:4021
executeStringInternalMethod
static JsonPathExecResult executeStringInternalMethod(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found)
Definition jsonpath_exec.c:2900
jsonb_path_match
Datum jsonb_path_match(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:535
jspStrictAbsenceOfErrors
#define jspStrictAbsenceOfErrors(cxt)
Definition jsonpath_exec.c:271
JsonTableDestroyOpaque
static void JsonTableDestroyOpaque(TableFuncScanState *state)
Definition jsonpath_exec.c:4492
JsonValueListClear
static void JsonValueListClear(JsonValueList *jvl)
Definition jsonpath_exec.c:3803
JsonTableInitOpaque
static void JsonTableInitOpaque(TableFuncScanState *state, int natts)
Definition jsonpath_exec.c:4428
jsonb_path_exists
Datum jsonb_path_exists(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:463
jperIsError
#define jperIsError(jper)
Definition jsonpath_exec.c:142
jsonb_path_exists_internal
static Datum jsonb_path_exists_internal(FunctionCallInfo fcinfo, bool tz)
Definition jsonpath_exec.c:435
JsonPathValue
JsonbValue * JsonPathValue(Datum jb, JsonPath *jp, bool *empty, bool *error, List *vars, const char *column_name)
Definition jsonpath_exec.c:4323
JsonTablePlanNextRow
static bool JsonTablePlanNextRow(JsonTablePlanState *planstate)
Definition jsonpath_exec.c:4609
jsonb_path_query_array_tz
Datum jsonb_path_query_array_tz(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:655
JsonTableInitPlan
static JsonTablePlanState * JsonTableInitPlan(JsonTableExecContext *cxt, JsonTablePlan *plan, JsonTablePlanState *parentstate, List *args, MemoryContext mcxt)
Definition jsonpath_exec.c:4509
executeItemUnwrapTargetArray
static JsonPathExecResult executeItemUnwrapTargetArray(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found, bool unwrapElements)
Definition jsonpath_exec.c:1708
cmpTimestampToTimestampTz
static int cmpTimestampToTimestampTz(Timestamp ts1, TimestampTz tstz2, bool useTz)
Definition jsonpath_exec.c:4032
executeLikeRegex
static JsonPathBool executeLikeRegex(JsonPathItem *jsp, JsonbValue *str, JsonbValue *rarg, void *param)
Definition jsonpath_exec.c:2369
jspIgnoreStructuralErrors
#define jspIgnoreStructuralErrors(cxt)
Definition jsonpath_exec.c:274
JsonPathExecResult
JsonPathExecResult
Definition jsonpath_exec.c:136
jperError
@ jperError
Definition jsonpath_exec.c:139
jperNotFound
@ jperNotFound
Definition jsonpath_exec.c:138
jperOk
@ jperOk
Definition jsonpath_exec.c:137
JsonbValueInitNumericDatum
static void JsonbValueInitNumericDatum(JsonbValue *jbv, Datum num)
Definition jsonpath_exec.c:3403
CountJsonPathVars
static int CountJsonPathVars(void *cxt)
Definition jsonpath_exec.c:3308
compareNumeric
static int compareNumeric(Numeric a, Numeric b)
Definition jsonpath_exec.c:3709
JsonTableGetValue
static Datum JsonTableGetValue(TableFuncScanState *state, int colnum, Oid typid, int32 typmod, bool *isnull)
Definition jsonpath_exec.c:4801
compareItems
static JsonPathBool compareItems(int32 op, JsonbValue *jb1, JsonbValue *jb2, bool useTz)
Definition jsonpath_exec.c:3613
getArrayIndex
static JsonPathExecResult getArrayIndex(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, int32 *index)
Definition jsonpath_exec.c:3731
jsonb_path_query_first_tz
Datum jsonb_path_query_first_tz(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:693
MIN_EXTRA_JVL_ITEMS
#define MIN_EXTRA_JVL_ITEMS
Definition jsonpath_exec.c:169
jsonb_path_query_array
Datum jsonb_path_query_array(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:649
executeItemOptUnwrapResult
static JsonPathExecResult executeItemOptUnwrapResult(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, JsonValueList *found)
Definition jsonpath_exec.c:1759
executeNumericItemMethod
static JsonPathExecResult executeNumericItemMethod(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, PGFunction func, JsonValueList *found)
Definition jsonpath_exec.c:2400
getJsonPathVariable
static void getJsonPathVariable(JsonPathExecContext *cxt, JsonPathItem *variable, JsonbValue *value)
Definition jsonpath_exec.c:3413
JsonValueListHead
static JsonbValue * JsonValueListHead(JsonValueList *jvl)
Definition jsonpath_exec.c:3880
JsonValueListInitIterator
static void JsonValueListInitIterator(JsonValueList *jvl, JsonValueListIterator *it)
Definition jsonpath_exec.c:3891
jsonb_path_exists_tz
Datum jsonb_path_exists_tz(PG_FUNCTION_ARGS)
Definition jsonpath_exec.c:469
JsonTableFetchRow
static bool JsonTableFetchRow(TableFuncScanState *state)
Definition jsonpath_exec.c:4785
getJsonPathItem
static void getJsonPathItem(JsonPathExecContext *cxt, JsonPathItem *item, JsonbValue *value)
Definition jsonpath_exec.c:3230
executeNextItem
static JsonPathExecResult executeNextItem(JsonPathExecContext *cxt, JsonPathItem *cur, JsonPathItem *next, JsonbValue *v, JsonValueList *found)
Definition jsonpath_exec.c:1728
executePredicate
static JsonPathBool executePredicate(JsonPathExecContext *cxt, JsonPathItem *pred, JsonPathItem *larg, JsonPathItem *rarg, JsonbValue *jb, bool unwrapRightArg, JsonPathPredicateCallback exec, void *param)
Definition jsonpath_exec.c:2075
binaryCompareStrings
static int binaryCompareStrings(const char *s1, int len1, const char *s2, int len2)
Definition jsonpath_exec.c:3525
JsonValueListHasMultipleItems
static bool JsonValueListHasMultipleItems(const JsonValueList *jvl)
Definition jsonpath_exec.c:3869
JsonbTableRoutine
const TableFuncRoutine JsonbTableRoutine
Definition jsonpath_exec.c:408
JsonValueListAppend
static void JsonValueListAppend(JsonValueList *jvl, const JsonbValue *jbv)
Definition jsonpath_exec.c:3821
wrapItemsInArray
static JsonbValue * wrapItemsInArray(JsonValueList *items)
Definition jsonpath_exec.c:3969
JsonPathCountVarsCallback
int(* JsonPathCountVarsCallback)(void *vars)
Definition jsonpath_exec.c:91
JsonbInitBinary
static JsonbValue * JsonbInitBinary(JsonbValue *jbv, Jsonb *jb)
Definition jsonpath_exec.c:3921
checkTimezoneIsUsedForCast
static void checkTimezoneIsUsedForCast(bool useTz, const char *type1, const char *type2)
Definition jsonpath_exec.c:3988
executeJsonPath
static JsonPathExecResult executeJsonPath(JsonPath *path, void *vars, JsonPathGetVarCallback getVar, JsonPathCountVarsCallback countVars, Jsonb *json, bool throwErrors, JsonValueList *result, bool useTz)
Definition jsonpath_exec.c:723
JsonPathBool
JsonPathBool
Definition jsonpath_exec.c:128
jpbUnknown
@ jpbUnknown
Definition jsonpath_exec.c:131
jpbFalse
@ jpbFalse
Definition jsonpath_exec.c:129
jpbTrue
@ jpbTrue
Definition jsonpath_exec.c:130
jspThrowErrors
#define jspThrowErrors(cxt)
Definition jsonpath_exec.c:275
copyJsonbValue
static JsonbValue * copyJsonbValue(JsonbValue *src)
Definition jsonpath_exec.c:3717
lappend
List * lappend(List *list, void *datum)
Definition list.c:339
tm
static struct pg_tm tm
Definition localtime.c:148
PG_UTF8
#define PG_UTF8
Definition mbprint.c:43
GetDatabaseEncoding
int GetDatabaseEncoding(void)
Definition mbutils.c:1389
pg_server_to_any
char * pg_server_to_any(const char *s, int len, int encoding)
Definition mbutils.c:760
pstrdup
char * pstrdup(const char *in)
Definition mcxt.c:1910
pfree
void pfree(void *pointer)
Definition mcxt.c:1619
TopMemoryContext
MemoryContext TopMemoryContext
Definition mcxt.c:167
palloc
void * palloc(Size size)
Definition mcxt.c:1390
CurrentMemoryContext
MemoryContext CurrentMemoryContext
Definition mcxt.c:161
pnstrdup
char * pnstrdup(const char *in, Size len)
Definition mcxt.c:1921
MemoryContextResetOnly
void MemoryContextResetOnly(MemoryContext context)
Definition mcxt.c:425
AllocSetContextCreate
#define AllocSetContextCreate
Definition memutils.h:129
ALLOCSET_DEFAULT_SIZES
#define ALLOCSET_DEFAULT_SIZES
Definition memutils.h:160
CHECK_FOR_INTERRUPTS
#define CHECK_FOR_INTERRUPTS()
Definition miscadmin.h:125
exprType
Oid exprType(const Node *expr)
Definition nodeFuncs.c:42
exprTypmod
int32 exprTypmod(const Node *expr)
Definition nodeFuncs.c:304
IsA
#define IsA(nodeptr, _type_)
Definition nodes.h:162
castNode
#define castNode(_type_, nodeptr)
Definition nodes.h:180
DatumGetNumeric
static Numeric DatumGetNumeric(Datum X)
Definition numeric.h:64
Numeric
struct NumericData * Numeric
Definition numeric.h:57
NumericGetDatum
static Datum NumericGetDatum(Numeric X)
Definition numeric.h:76
errmsg
static char * errmsg
Definition oauth_hook_client.c:61
ltrim
Datum ltrim(PG_FUNCTION_ARGS)
Definition oracle_compat.c:719
lower
Datum lower(PG_FUNCTION_ARGS)
Definition oracle_compat.c:49
initcap
Datum initcap(PG_FUNCTION_ARGS)
Definition oracle_compat.c:114
upper
Datum upper(PG_FUNCTION_ARGS)
Definition oracle_compat.c:80
rtrim
Datum rtrim(PG_FUNCTION_ARGS)
Definition oracle_compat.c:767
ltrim1
Datum ltrim1(PG_FUNCTION_ARGS)
Definition oracle_compat.c:739
btrim1
Datum btrim1(PG_FUNCTION_ARGS)
Definition oracle_compat.c:379
rtrim1
Datum rtrim1(PG_FUNCTION_ARGS)
Definition oracle_compat.c:787
btrim
Datum btrim(PG_FUNCTION_ARGS)
Definition oracle_compat.c:359
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:138
pg_collation.h
lfirst
#define lfirst(lc)
Definition pg_list.h:172
lfirst_node
#define lfirst_node(type, lc)
Definition pg_list.h:176
list_length
static int list_length(const List *l)
Definition pg_list.h:152
NIL
#define NIL
Definition pg_list.h:68
forboth
#define forboth(cell1, list1, cell2, list2)
Definition pg_list.h:550
list_nth
static void * list_nth(const List *list, int n)
Definition pg_list.h:331
plan
#define plan(x)
Definition pg_regress.c:164
buf
static char buf[DEFAULT_XLOG_SEG_SIZE]
Definition pg_test_fsync.c:71
pg_type.h
PG_SQL_ASCII
@ PG_SQL_ASCII
Definition pg_wchar.h:76
scale
static int scale
Definition pgbench.c:182
session_timezone
PGDLLIMPORT pg_tz * session_timezone
Definition pgtz.c:28
Int64GetDatum
static Datum Int64GetDatum(int64 X)
Definition postgres.h:426
DatumGetBool
static bool DatumGetBool(Datum X)
Definition postgres.h:100
DatumGetCString
static char * DatumGetCString(Datum X)
Definition postgres.h:365
Datum
uint64_t Datum
Definition postgres.h:70
DatumGetPointer
static Pointer DatumGetPointer(Datum X)
Definition postgres.h:332
Float8GetDatum
static Datum Float8GetDatum(float8 X)
Definition postgres.h:515
CStringGetDatum
static Datum CStringGetDatum(const char *X)
Definition postgres.h:383
Int32GetDatum
static Datum Int32GetDatum(int32 X)
Definition postgres.h:212
DatumGetInt32
static int32 DatumGetInt32(Datum X)
Definition postgres.h:202
PointerGetDatum
#define PointerGetDatum(X)
Definition postgres.h:354
InvalidOid
#define InvalidOid
Definition postgres_ext.h:37
Oid
unsigned int Oid
Definition postgres_ext.h:32
fb
static int fb(int x)
Definition preproc-init.c:92
s1
char * s1
Definition preproc-strings.c:46
s2
char * s2
Definition preproc-strings.c:43
JsonWrapper
JsonWrapper
Definition primnodes.h:1770
JSW_UNCONDITIONAL
@ JSW_UNCONDITIONAL
Definition primnodes.h:1774
JSW_CONDITIONAL
@ JSW_CONDITIONAL
Definition primnodes.h:1773
JSW_UNSPEC
@ JSW_UNSPEC
Definition primnodes.h:1771
JSW_NONE
@ JSW_NONE
Definition primnodes.h:1772
cmp
static int cmp(const chr *x, const chr *y, size_t len)
Definition regc_locale.c:743
range
static struct cvec * range(struct vars *v, chr a, chr b, int cases)
Definition regc_locale.c:412
RE_compile_and_execute
bool RE_compile_and_execute(text *text_re, char *dat, int dat_len, int cflags, Oid collation, int nmatch, regmatch_t *pmatch)
Definition regexp.c:358
error
static void error(void)
Definition sql-dyntest.c:147
check_stack_depth
void check_stack_depth(void)
Definition stack_depth.c:96
ExprContext::caseValue_isNull
bool caseValue_isNull
Definition execnodes.h:314
ExprContext::caseValue_datum
Datum caseValue_datum
Definition execnodes.h:312
JsonBaseObjectInfo::jbc
JsonbContainer * jbc
Definition jsonpath_exec.c:84
JsonPathExecContext::getVar
JsonPathGetVarCallback getVar
Definition jsonpath_exec.c:99
JsonPathExecContext::baseObject
JsonBaseObjectInfo baseObject
Definition jsonpath_exec.c:103
JsonPathItem::base
char * base
Definition jsonpath.h:154
JsonPathItem::type
JsonPathItemType type
Definition jsonpath.h:145
JsonPath::header
uint32 header
Definition jsonpath.h:26
JsonTableExecContext::rootplanstate
JsonTablePlanState * rootplanstate
Definition jsonpath_exec.c:261
JsonTableExecContext::colplanstates
JsonTablePlanState ** colplanstates
Definition jsonpath_exec.c:267
JsonTablePathScan::path
JsonTablePath * path
Definition primnodes.h:1919
JsonTablePathScan::child
JsonTablePlan * child
Definition primnodes.h:1928
JsonTablePath::value
Const * value
Definition primnodes.h:1892
JsonTablePlanState::left
struct JsonTablePlanState * left
Definition jsonpath_exec.c:236
JsonTablePlanState::found
JsonValueList found
Definition jsonpath_exec.c:223
JsonTablePlanState::nested
struct JsonTablePlanState * nested
Definition jsonpath_exec.c:233
JsonTablePlanState::mcxt
MemoryContext mcxt
Definition jsonpath_exec.c:217
JsonTablePlanState::parent
struct JsonTablePlanState * parent
Definition jsonpath_exec.c:242
JsonTablePlanState::plan
JsonTablePlan * plan
Definition jsonpath_exec.c:207
JsonTablePlanState::right
struct JsonTablePlanState * right
Definition jsonpath_exec.c:239
JsonTablePlanState::current
JsonTablePlanRowSource current
Definition jsonpath_exec.c:227
JsonTablePlanState::iter
JsonValueListIterator iter
Definition jsonpath_exec.c:224
JsonTableSiblingJoin::rplan
JsonTablePlan * rplan
Definition primnodes.h:1950
JsonTableSiblingJoin::lplan
JsonTablePlan * lplan
Definition primnodes.h:1949
JsonValueListIterator::chunk
JsonValueList * chunk
Definition jsonpath_exec.c:183
JsonValueList::last
struct JsonValueList * last
Definition jsonpath_exec.c:176
JsonValueList::items
JsonbValue items[BASE_JVL_ITEMS]
Definition jsonpath_exec.c:177
JsonValueList::next
struct JsonValueList * next
Definition jsonpath_exec.c:175
JsonbContainer::header
uint32 header
Definition jsonb.h:194
JsonbValue::type
enum jbvType type
Definition jsonb.h:257
JsonbValue::val
char * val
Definition jsonb.h:266
Jsonb
Definition jsonb.h:215
Jsonb::root
JsonbContainer root
Definition jsonb.h:217
List
Definition pg_list.h:54
Node
Definition nodes.h:133
String
Definition value.h:64
TableFuncRoutine::InitOpaque
void(* InitOpaque)(TableFuncScanState *state, int natts)
Definition tablefunc.h:54
TableFunc::docexpr
Node * docexpr
Definition primnodes.h:121
exec
Definition type.h:117
index
Definition type.h:97
pg_tm
Definition pgtime.h:35
pg_tm::tm_hour
int tm_hour
Definition pgtime.h:38
pg_tm::tm_mday
int tm_mday
Definition pgtime.h:39
pg_tm::tm_mon
int tm_mon
Definition pgtime.h:40
pg_tm::tm_min
int tm_min
Definition pgtime.h:37
pg_tm::tm_sec
int tm_sec
Definition pgtime.h:36
pg_tm::tm_year
int tm_year
Definition pgtime.h:41
variable::type
enum ECPGttype type
Definition ecpglib_extern.h:137
varlena
Definition c.h:835
items
static ItemArray items
Definition test_tidstore.c:48
TimestampTzGetDatum
static Datum TimestampTzGetDatum(TimestampTz X)
Definition timestamp.h:52
TimestampGetDatum
static Datum TimestampGetDatum(Timestamp X)
Definition timestamp.h:46
DatumGetTimestamp
static Timestamp DatumGetTimestamp(Datum X)
Definition timestamp.h:28
DatumGetTimestampTz
static TimestampTz DatumGetTimestampTz(Datum X)
Definition timestamp.h:34
VARSIZE_ANY_EXHDR
static Size VARSIZE_ANY_EXHDR(const void *PTR)
Definition varatt.h:472
VARDATA_ANY
static char * VARDATA_ANY(const void *PTR)
Definition varatt.h:486
cstring_to_text_with_len
text * cstring_to_text_with_len(const char *s, int len)
Definition varlena.c:196
split_part
Datum split_part(PG_FUNCTION_ARGS)
Definition varlena.c:3509
cstring_to_text
text * cstring_to_text(const char *s)
Definition varlena.c:184
text_to_cstring
char * text_to_cstring(const text *t)
Definition varlena.c:217
replace_text
Datum replace_text(PG_FUNCTION_ARGS)
Definition varlena.c:3137
type
const char * type
Definition wait_event_funcs.c:28
name
const char * name
Definition wait_event_funcs.c:29