Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * jsonpath_exec.c
4 : : * Routines for SQL/JSON path execution.
5 : : *
6 : : * Jsonpath is executed in the global context stored in JsonPathExecContext,
7 : : * which is passed to almost every function involved into execution. Entry
8 : : * point for jsonpath execution is executeJsonPath() function, which
9 : : * initializes execution context including initial JsonPathItem and JsonbValue,
10 : : * flags, stack for calculation of @ in filters.
11 : : *
12 : : * The result of jsonpath query execution is enum JsonPathExecResult and
13 : : * if succeeded sequence of JsonbValue, written to JsonValueList *found, which
14 : : * is passed through the jsonpath items. When found == NULL, we're inside
15 : : * exists-query and we're interested only in whether result is empty. In this
16 : : * case execution is stopped once first result item is found, and the only
17 : : * execution result is JsonPathExecResult. The values of JsonPathExecResult
18 : : * are following:
19 : : * - jperOk -- result sequence is not empty
20 : : * - jperNotFound -- result sequence is empty
21 : : * - jperError -- error occurred during execution
22 : : *
23 : : * Jsonpath is executed recursively (see executeItem()) starting form the
24 : : * first path item (which in turn might be, for instance, an arithmetic
25 : : * expression evaluated separately). On each step single JsonbValue obtained
26 : : * from previous path item is processed. The result of processing is a
27 : : * sequence of JsonbValue (probably empty), which is passed to the next path
28 : : * item one by one. When there is no next path item, then JsonbValue is added
29 : : * to the 'found' list. When found == NULL, then execution functions just
30 : : * return jperOk (see executeNextItem()).
31 : : *
32 : : * Many of jsonpath operations require automatic unwrapping of arrays in lax
33 : : * mode. So, if input value is array, then corresponding operation is
34 : : * processed not on array itself, but on all of its members one by one.
35 : : * executeItemOptUnwrapTarget() function have 'unwrap' argument, which indicates
36 : : * whether unwrapping of array is needed. When unwrap == true, each of array
37 : : * members is passed to executeItemOptUnwrapTarget() again but with unwrap == false
38 : : * in order to avoid subsequent array unwrapping.
39 : : *
40 : : * All boolean expressions (predicates) are evaluated by executeBoolItem()
41 : : * function, which returns tri-state JsonPathBool. When error is occurred
42 : : * during predicate execution, it returns jpbUnknown. According to standard
43 : : * predicates can be only inside filters. But we support their usage as
44 : : * jsonpath expression. This helps us to implement @@ operator. In this case
45 : : * resulting JsonPathBool is transformed into jsonb bool or null.
46 : : *
47 : : * Arithmetic and boolean expression are evaluated recursively from expression
48 : : * tree top down to the leaves. Therefore, for binary arithmetic expressions
49 : : * we calculate operands first. Then we check that results are numeric
50 : : * singleton lists, calculate the result and pass it to the next path item.
51 : : *
52 : : * Copyright (c) 2019-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 : : */
82 : : typedef struct JsonBaseObjectInfo
83 : : {
84 : : JsonbContainer *jbc;
85 : : int id;
86 : : } JsonBaseObjectInfo;
87 : :
88 : : /* Callbacks for executeJsonPath() */
89 : : typedef JsonbValue *(*JsonPathGetVarCallback) (void *vars, char *varName, int varNameLen,
90 : : JsonbValue *baseObject, int *baseObjectId);
91 : : typedef int (*JsonPathCountVarsCallback) (void *vars);
92 : :
93 : : /*
94 : : * Context of jsonpath execution.
95 : : */
96 : : typedef 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. */
120 : : typedef struct JsonLikeRegexContext
121 : : {
122 : : text *regex;
123 : : int cflags;
124 : : } JsonLikeRegexContext;
125 : :
126 : : /* Result of jsonpath predicate evaluation */
127 : : typedef enum JsonPathBool
128 : : {
129 : : jpbFalse = 0,
130 : : jpbTrue = 1,
131 : : jpbUnknown = 2
132 : : } JsonPathBool;
133 : :
134 : : /* Result of jsonpath expression evaluation */
135 : : typedef enum JsonPathExecResult
136 : : {
137 : : jperOk = 0,
138 : : jperNotFound = 1,
139 : : jperError = 2
140 : : } JsonPathExecResult;
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 : :
171 : : typedef 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 */
181 : : typedef 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 : : */
194 : : typedef struct JsonTablePlanRowSource
195 : : {
196 : : Datum value;
197 : : bool isnull;
198 : : } JsonTablePlanRowSource;
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 : : */
204 : : typedef 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 : :
256 : : typedef 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) \
279 : : do { \
280 : : if (jspThrowErrors(cxt)) \
281 : : throw_error; \
282 : : else \
283 : : return jperError; \
284 : : } while (0)
285 : :
286 : : typedef JsonPathBool (*JsonPathPredicateCallback) (JsonPathItem *jsp,
287 : : JsonbValue *larg,
288 : : JsonbValue *rarg,
289 : : void *param);
290 : : typedef Numeric (*BinaryArithmFunc) (Numeric num1, Numeric num2,
291 : : Node *escontext);
292 : :
293 : : static JsonPathExecResult executeJsonPath(JsonPath *path, void *vars,
294 : : JsonPathGetVarCallback getVar,
295 : : JsonPathCountVarsCallback countVars,
296 : : Jsonb *json, bool throwErrors,
297 : : JsonValueList *result, bool useTz);
298 : : static JsonPathExecResult executeItem(JsonPathExecContext *cxt,
299 : : JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found);
300 : : static JsonPathExecResult executeItemOptUnwrapTarget(JsonPathExecContext *cxt,
301 : : JsonPathItem *jsp, JsonbValue *jb,
302 : : JsonValueList *found, bool unwrap);
303 : : static JsonPathExecResult executeItemUnwrapTargetArray(JsonPathExecContext *cxt,
304 : : JsonPathItem *jsp, JsonbValue *jb,
305 : : JsonValueList *found, bool unwrapElements);
306 : : static JsonPathExecResult executeNextItem(JsonPathExecContext *cxt,
307 : : JsonPathItem *cur, JsonPathItem *next,
308 : : JsonbValue *v, JsonValueList *found);
309 : : static JsonPathExecResult executeItemOptUnwrapResult(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb,
310 : : bool unwrap, JsonValueList *found);
311 : : static JsonPathExecResult executeItemOptUnwrapResultNoThrow(JsonPathExecContext *cxt, JsonPathItem *jsp,
312 : : JsonbValue *jb, bool unwrap, JsonValueList *found);
313 : : static JsonPathBool executeBoolItem(JsonPathExecContext *cxt,
314 : : JsonPathItem *jsp, JsonbValue *jb, bool canHaveNext);
315 : : static JsonPathBool executeNestedBoolItem(JsonPathExecContext *cxt,
316 : : JsonPathItem *jsp, JsonbValue *jb);
317 : : static JsonPathExecResult executeAnyItem(JsonPathExecContext *cxt,
318 : : JsonPathItem *jsp, JsonbContainer *jbc, JsonValueList *found,
319 : : uint32 level, uint32 first, uint32 last,
320 : : bool ignoreStructuralErrors, bool unwrapNext);
321 : : static JsonPathBool executePredicate(JsonPathExecContext *cxt,
322 : : JsonPathItem *pred, JsonPathItem *larg, JsonPathItem *rarg,
323 : : JsonbValue *jb, bool unwrapRightArg,
324 : : JsonPathPredicateCallback exec, void *param);
325 : : static JsonPathExecResult executeBinaryArithmExpr(JsonPathExecContext *cxt,
326 : : JsonPathItem *jsp, JsonbValue *jb,
327 : : BinaryArithmFunc func, JsonValueList *found);
328 : : static JsonPathExecResult executeUnaryArithmExpr(JsonPathExecContext *cxt,
329 : : JsonPathItem *jsp, JsonbValue *jb, PGFunction func,
330 : : JsonValueList *found);
331 : : static JsonPathBool executeStartsWith(JsonPathItem *jsp,
332 : : JsonbValue *whole, JsonbValue *initial, void *param);
333 : : static JsonPathBool executeLikeRegex(JsonPathItem *jsp, JsonbValue *str,
334 : : JsonbValue *rarg, void *param);
335 : : static JsonPathExecResult executeNumericItemMethod(JsonPathExecContext *cxt,
336 : : JsonPathItem *jsp, JsonbValue *jb, bool unwrap, PGFunction func,
337 : : JsonValueList *found);
338 : : static JsonPathExecResult executeDateTimeMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
339 : : JsonbValue *jb, JsonValueList *found);
340 : : static JsonPathExecResult executeStringInternalMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
341 : : JsonbValue *jb, JsonValueList *found);
342 : : static JsonPathExecResult executeKeyValueMethod(JsonPathExecContext *cxt,
343 : : JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found);
344 : : static JsonPathExecResult appendBoolResult(JsonPathExecContext *cxt,
345 : : JsonPathItem *jsp, JsonValueList *found, JsonPathBool res);
346 : : static void getJsonPathItem(JsonPathExecContext *cxt, JsonPathItem *item,
347 : : JsonbValue *value);
348 : : static JsonbValue *GetJsonPathVar(void *cxt, char *varName, int varNameLen,
349 : : JsonbValue *baseObject, int *baseObjectId);
350 : : static int CountJsonPathVars(void *cxt);
351 : : static void JsonItemFromDatum(Datum val, Oid typid, int32 typmod,
352 : : JsonbValue *res);
353 : : static void JsonbValueInitNumericDatum(JsonbValue *jbv, Datum num);
354 : : static void getJsonPathVariable(JsonPathExecContext *cxt,
355 : : JsonPathItem *variable, JsonbValue *value);
356 : : static int countVariablesFromJsonb(void *varsJsonb);
357 : : static JsonbValue *getJsonPathVariableFromJsonb(void *varsJsonb, char *varName,
358 : : int varNameLength,
359 : : JsonbValue *baseObject,
360 : : int *baseObjectId);
361 : : static int JsonbArraySize(JsonbValue *jb);
362 : : static JsonPathBool executeComparison(JsonPathItem *cmp, JsonbValue *lv,
363 : : JsonbValue *rv, void *p);
364 : : static JsonPathBool compareItems(int32 op, JsonbValue *jb1, JsonbValue *jb2,
365 : : bool useTz);
366 : : static int compareNumeric(Numeric a, Numeric b);
367 : : static JsonbValue *copyJsonbValue(JsonbValue *src);
368 : : static JsonPathExecResult getArrayIndex(JsonPathExecContext *cxt,
369 : : JsonPathItem *jsp, JsonbValue *jb, int32 *index);
370 : : static JsonBaseObjectInfo setBaseObject(JsonPathExecContext *cxt,
371 : : JsonbValue *jbv, int32 id);
372 : : static void JsonValueListInit(JsonValueList *jvl);
373 : : static void JsonValueListClear(JsonValueList *jvl);
374 : : static void JsonValueListAppend(JsonValueList *jvl, const JsonbValue *jbv);
375 : : static bool JsonValueListIsEmpty(const JsonValueList *jvl);
376 : : static bool JsonValueListIsSingleton(const JsonValueList *jvl);
377 : : static bool JsonValueListHasMultipleItems(const JsonValueList *jvl);
378 : : static JsonbValue *JsonValueListHead(JsonValueList *jvl);
379 : : static void JsonValueListInitIterator(JsonValueList *jvl,
380 : : JsonValueListIterator *it);
381 : : static JsonbValue *JsonValueListNext(JsonValueListIterator *it);
382 : : static JsonbValue *JsonbInitBinary(JsonbValue *jbv, Jsonb *jb);
383 : : static int JsonbType(JsonbValue *jb);
384 : : static JsonbValue *getScalar(JsonbValue *scalar, enum jbvType type);
385 : : static JsonbValue *wrapItemsInArray(JsonValueList *items);
386 : : static int compareDatetime(Datum val1, Oid typid1, Datum val2, Oid typid2,
387 : : bool useTz, bool *cast_error);
388 : : static void checkTimezoneIsUsedForCast(bool useTz, const char *type1,
389 : : const char *type2);
390 : :
391 : : static void JsonTableInitOpaque(TableFuncScanState *state, int natts);
392 : : static JsonTablePlanState *JsonTableInitPlan(JsonTableExecContext *cxt,
393 : : JsonTablePlan *plan,
394 : : JsonTablePlanState *parentstate,
395 : : List *args,
396 : : MemoryContext mcxt);
397 : : static void JsonTableSetDocument(TableFuncScanState *state, Datum value);
398 : : static void JsonTableResetRowPattern(JsonTablePlanState *planstate, Datum item);
399 : : static void JsonTableRescan(JsonTablePlanState *planstate);
400 : : static bool JsonTableFetchRow(TableFuncScanState *state);
401 : : static Datum JsonTableGetValue(TableFuncScanState *state, int colnum,
402 : : Oid typid, int32 typmod, bool *isnull);
403 : : static void JsonTableDestroyOpaque(TableFuncScanState *state);
404 : : static bool JsonTablePlanScanNextRow(JsonTablePlanState *planstate);
405 : : static void JsonTableResetNestedPlan(JsonTablePlanState *planstate);
406 : : static bool JsonTablePlanNextRow(JsonTablePlanState *planstate);
407 : :
408 : : const 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 : : */
434 : : static Datum
2495 akorotkov@postgresql 435 :CBC 59899 : jsonb_path_exists_internal(FunctionCallInfo fcinfo, bool tz)
436 : : {
2688 437 : 59899 : Jsonb *jb = PG_GETARG_JSONB_P(0);
438 : 59899 : JsonPath *jp = PG_GETARG_JSONPATH_P(1);
439 : : JsonPathExecResult res;
440 : 59899 : Jsonb *vars = NULL;
441 : 59899 : bool silent = true;
442 : :
443 [ + + ]: 59899 : if (PG_NARGS() == 4)
444 : : {
445 : 43 : vars = PG_GETARG_JSONB_P(2);
446 : 43 : silent = PG_GETARG_BOOL(3);
447 : : }
448 : :
913 amitlan@postgresql.o 449 : 59899 : res = executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
450 : : countVariablesFromJsonb,
451 : 59899 : jb, !silent, NULL, tz);
452 : :
2688 akorotkov@postgresql 453 [ + + ]: 59891 : PG_FREE_IF_COPY(jb, 0);
454 [ - + ]: 59891 : PG_FREE_IF_COPY(jp, 1);
455 : :
456 [ + + ]: 59891 : if (jperIsError(res))
457 : 55 : PG_RETURN_NULL();
458 : :
459 : 59836 : PG_RETURN_BOOL(res == jperOk);
460 : : }
461 : :
462 : : Datum
2495 463 : 43 : jsonb_path_exists(PG_FUNCTION_ARGS)
464 : : {
465 : 43 : return jsonb_path_exists_internal(fcinfo, false);
466 : : }
467 : :
468 : : Datum
2495 akorotkov@postgresql 469 :UBC 0 : jsonb_path_exists_tz(PG_FUNCTION_ARGS)
470 : : {
471 : 0 : return jsonb_path_exists_internal(fcinfo, true);
472 : : }
473 : :
474 : : /*
475 : : * jsonb_path_exists_opr
476 : : * Implementation of operator "jsonb @? jsonpath" (2-argument version of
477 : : * jsonb_path_exists()).
478 : : */
479 : : Datum
2688 akorotkov@postgresql 480 :CBC 59856 : jsonb_path_exists_opr(PG_FUNCTION_ARGS)
481 : : {
482 : : /* just call the other one -- it can handle both cases */
2495 483 : 59856 : 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 : : */
491 : : static Datum
492 : 68430 : jsonb_path_match_internal(FunctionCallInfo fcinfo, bool tz)
493 : : {
2688 494 : 68430 : Jsonb *jb = PG_GETARG_JSONB_P(0);
495 : 68430 : JsonPath *jp = PG_GETARG_JSONPATH_P(1);
496 : 68430 : Jsonb *vars = NULL;
497 : 68430 : bool silent = true;
498 : : JsonValueList found;
499 : :
500 [ + + ]: 68430 : if (PG_NARGS() == 4)
501 : : {
502 : 97 : vars = PG_GETARG_JSONB_P(2);
503 : 97 : silent = PG_GETARG_BOOL(3);
504 : : }
505 : :
128 tgl@sss.pgh.pa.us 506 : 68430 : JsonValueListInit(&found);
507 : :
913 amitlan@postgresql.o 508 : 68430 : (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
509 : : countVariablesFromJsonb,
510 : 68430 : jb, !silent, &found, tz);
511 : :
2688 akorotkov@postgresql 512 [ + + ]: 68422 : PG_FREE_IF_COPY(jb, 0);
513 [ - + ]: 68422 : PG_FREE_IF_COPY(jp, 1);
514 : :
128 tgl@sss.pgh.pa.us 515 [ + + ]: 68422 : if (JsonValueListIsSingleton(&found))
516 : : {
2672 akorotkov@postgresql 517 : 68399 : JsonbValue *jbv = JsonValueListHead(&found);
518 : :
519 [ + + ]: 68399 : if (jbv->type == jbvBool)
520 : 68343 : PG_RETURN_BOOL(jbv->val.boolean);
521 : :
522 [ + + ]: 56 : if (jbv->type == jbvNull)
523 : 20 : PG_RETURN_NULL();
524 : : }
525 : :
526 [ + + ]: 59 : if (!silent)
527 [ + - ]: 24 : ereport(ERROR,
528 : : (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED),
529 : : errmsg("single boolean result is expected")));
530 : :
531 : 35 : PG_RETURN_NULL();
532 : : }
533 : :
534 : : Datum
2495 535 : 97 : jsonb_path_match(PG_FUNCTION_ARGS)
536 : : {
537 : 97 : return jsonb_path_match_internal(fcinfo, false);
538 : : }
539 : :
540 : : Datum
2495 akorotkov@postgresql 541 :UBC 0 : jsonb_path_match_tz(PG_FUNCTION_ARGS)
542 : : {
543 : 0 : return jsonb_path_match_internal(fcinfo, true);
544 : : }
545 : :
546 : : /*
547 : : * jsonb_path_match_opr
548 : : * Implementation of operator "jsonb @@ jsonpath" (2-argument version of
549 : : * jsonb_path_match()).
550 : : */
551 : : Datum
2688 akorotkov@postgresql 552 :CBC 68333 : jsonb_path_match_opr(PG_FUNCTION_ARGS)
553 : : {
554 : : /* just call the other one -- it can handle both cases */
2495 555 : 68333 : 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 : : */
563 : : static Datum
564 : 5432 : jsonb_path_query_internal(FunctionCallInfo fcinfo, bool tz)
565 : : {
566 : : FuncCallContext *funcctx;
567 : : JsonValueListIterator *iter;
568 : : JsonbValue *v;
569 : :
2688 570 [ + + ]: 5432 : 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 : 3076 : funcctx = SRF_FIRSTCALL_INIT();
580 : 3076 : oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
581 : :
582 : 3076 : jb = PG_GETARG_JSONB_P_COPY(0);
583 : 3076 : jp = PG_GETARG_JSONPATH_P_COPY(1);
584 : 3076 : vars = PG_GETARG_JSONB_P_COPY(2);
585 : 3076 : silent = PG_GETARG_BOOL(3);
586 : :
128 tgl@sss.pgh.pa.us 587 : 3076 : found = palloc_object(JsonValueList);
588 : 3076 : JsonValueListInit(found);
589 : :
913 amitlan@postgresql.o 590 : 3076 : (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
591 : : countVariablesFromJsonb,
128 tgl@sss.pgh.pa.us 592 : 3076 : jb, !silent, found, tz);
593 : :
594 : 2040 : iter = palloc_object(JsonValueListIterator);
595 : 2040 : JsonValueListInitIterator(found, iter);
596 : :
597 : 2040 : funcctx->user_fctx = iter;
598 : :
2688 akorotkov@postgresql 599 : 2040 : MemoryContextSwitchTo(oldcontext);
600 : : }
601 : :
602 : 4396 : funcctx = SRF_PERCALL_SETUP();
128 tgl@sss.pgh.pa.us 603 : 4396 : iter = funcctx->user_fctx;
604 : :
605 : 4396 : v = JsonValueListNext(iter);
606 : :
607 [ + + ]: 4396 : if (v == NULL)
2688 akorotkov@postgresql 608 : 2040 : SRF_RETURN_DONE(funcctx);
609 : :
610 : 2356 : SRF_RETURN_NEXT(funcctx, JsonbPGetDatum(JsonbValueToJsonb(v)));
611 : : }
612 : :
613 : : Datum
2495 614 : 4428 : jsonb_path_query(PG_FUNCTION_ARGS)
615 : : {
616 : 4428 : return jsonb_path_query_internal(fcinfo, false);
617 : : }
618 : :
619 : : Datum
620 : 1004 : jsonb_path_query_tz(PG_FUNCTION_ARGS)
621 : : {
622 : 1004 : return jsonb_path_query_internal(fcinfo, true);
623 : : }
624 : :
625 : : /*
626 : : * jsonb_path_query_array
627 : : * Executes jsonpath for given jsonb document and returns result as
628 : : * jsonb array.
629 : : */
630 : : static Datum
631 : 82 : jsonb_path_query_array_internal(FunctionCallInfo fcinfo, bool tz)
632 : : {
2688 633 : 82 : Jsonb *jb = PG_GETARG_JSONB_P(0);
634 : 82 : JsonPath *jp = PG_GETARG_JSONPATH_P(1);
635 : 82 : Jsonb *vars = PG_GETARG_JSONB_P(2);
636 : 82 : bool silent = PG_GETARG_BOOL(3);
637 : : JsonValueList found;
638 : :
128 tgl@sss.pgh.pa.us 639 : 82 : JsonValueListInit(&found);
640 : :
913 amitlan@postgresql.o 641 : 82 : (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
642 : : countVariablesFromJsonb,
643 : 82 : jb, !silent, &found, tz);
644 : :
2688 akorotkov@postgresql 645 : 78 : PG_RETURN_JSONB_P(JsonbValueToJsonb(wrapItemsInArray(&found)));
646 : : }
647 : :
648 : : Datum
2495 649 : 82 : jsonb_path_query_array(PG_FUNCTION_ARGS)
650 : : {
651 : 82 : return jsonb_path_query_array_internal(fcinfo, false);
652 : : }
653 : :
654 : : Datum
2495 akorotkov@postgresql 655 :UBC 0 : jsonb_path_query_array_tz(PG_FUNCTION_ARGS)
656 : : {
657 : 0 : return jsonb_path_query_array_internal(fcinfo, true);
658 : : }
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 : : */
665 : : static Datum
2495 akorotkov@postgresql 666 :CBC 2923 : jsonb_path_query_first_internal(FunctionCallInfo fcinfo, bool tz)
667 : : {
2688 668 : 2923 : Jsonb *jb = PG_GETARG_JSONB_P(0);
669 : 2923 : JsonPath *jp = PG_GETARG_JSONPATH_P(1);
670 : 2923 : Jsonb *vars = PG_GETARG_JSONB_P(2);
671 : 2923 : bool silent = PG_GETARG_BOOL(3);
672 : : JsonValueList found;
673 : :
128 tgl@sss.pgh.pa.us 674 : 2923 : JsonValueListInit(&found);
675 : :
913 amitlan@postgresql.o 676 : 2923 : (void) executeJsonPath(jp, vars, getJsonPathVariableFromJsonb,
677 : : countVariablesFromJsonb,
678 : 2923 : jb, !silent, &found, tz);
679 : :
128 tgl@sss.pgh.pa.us 680 [ + + ]: 2915 : if (!JsonValueListIsEmpty(&found))
2688 akorotkov@postgresql 681 : 2905 : PG_RETURN_JSONB_P(JsonbValueToJsonb(JsonValueListHead(&found)));
682 : : else
683 : 10 : PG_RETURN_NULL();
684 : : }
685 : :
686 : : Datum
2495 687 : 2923 : jsonb_path_query_first(PG_FUNCTION_ARGS)
688 : : {
689 : 2923 : return jsonb_path_query_first_internal(fcinfo, false);
690 : : }
691 : :
692 : : Datum
2495 akorotkov@postgresql 693 :UBC 0 : jsonb_path_query_first_tz(PG_FUNCTION_ARGS)
694 : : {
695 : 0 : return jsonb_path_query_first_internal(fcinfo, true);
696 : : }
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 : : */
722 : : static JsonPathExecResult
913 amitlan@postgresql.o 723 :CBC 140264 : executeJsonPath(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 : :
2688 akorotkov@postgresql 733 : 140264 : jspInit(&jsp, path);
734 : :
735 [ + + ]: 140264 : if (!JsonbExtractScalar(&json->root, &jbv))
736 : 135421 : JsonbInitBinary(&jbv, json);
737 : :
738 : 140264 : cxt.vars = vars;
913 amitlan@postgresql.o 739 : 140264 : cxt.getVar = getVar;
2688 akorotkov@postgresql 740 : 140264 : cxt.laxMode = (path->header & JSONPATH_LAX) != 0;
741 : 140264 : cxt.ignoreStructuralErrors = cxt.laxMode;
742 : 140264 : cxt.root = &jbv;
743 : 140264 : cxt.current = &jbv;
744 : 140264 : cxt.baseObject.jbc = NULL;
745 : 140264 : cxt.baseObject.id = 0;
746 : : /* 1 + number of base objects in vars */
913 amitlan@postgresql.o 747 : 140264 : cxt.lastGeneratedObjectId = 1 + countVars(vars);
2688 akorotkov@postgresql 748 : 140256 : cxt.innermostArraySize = -1;
749 : 140256 : cxt.throwErrors = throwErrors;
2495 750 : 140256 : cxt.useTz = useTz;
751 : :
935 rhaas@postgresql.org 752 [ + + + + ]: 140256 : 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 : :
128 tgl@sss.pgh.pa.us 761 : 165 : JsonValueListInit(&vals);
762 : :
2688 akorotkov@postgresql 763 : 165 : res = executeItem(&cxt, &jsp, &jbv, &vals);
764 : :
128 tgl@sss.pgh.pa.us 765 : 157 : isempty = JsonValueListIsEmpty(&vals);
766 : 157 : JsonValueListClear(&vals);
767 : :
2688 akorotkov@postgresql 768 [ + + ]: 157 : if (jperIsError(res))
769 : 144 : return res;
770 : :
128 tgl@sss.pgh.pa.us 771 : 13 : return isempty ? jperNotFound : jperOk;
772 : : }
773 : :
2688 akorotkov@postgresql 774 : 140091 : res = executeItem(&cxt, &jsp, &jbv, result);
775 : :
776 [ + + - + ]: 139015 : Assert(!throwErrors || !jperIsError(res));
777 : :
778 : 139015 : return res;
779 : : }
780 : :
781 : : /*
782 : : * Execute jsonpath with automatic unwrapping of current item in lax mode.
783 : : */
784 : : static JsonPathExecResult
785 : 420277 : executeItem(JsonPathExecContext *cxt, JsonPathItem *jsp,
786 : : JsonbValue *jb, JsonValueList *found)
787 : : {
788 : 420277 : return executeItemOptUnwrapTarget(cxt, jsp, jb, found, jspAutoUnwrap(cxt));
789 : : }
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 : : */
796 : : static JsonPathExecResult
797 : 425981 : executeItemOptUnwrapTarget(JsonPathExecContext *cxt, JsonPathItem *jsp,
798 : : JsonbValue *jb, JsonValueList *found, bool unwrap)
799 : : {
800 : : JsonPathItem elem;
801 : 425981 : JsonPathExecResult res = jperNotFound;
802 : : JsonBaseObjectInfo baseObject;
803 : :
804 : 425981 : check_stack_depth();
805 [ - + ]: 425981 : CHECK_FOR_INTERRUPTS();
806 : :
807 [ + + + + : 425981 : switch (jsp->type)
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + - ]
808 : : {
934 peter@eisentraut.org 809 : 43366 : case jpiNull:
810 : : case jpiBool:
811 : : case jpiNumeric:
812 : : case jpiString:
813 : : case jpiVariable:
814 : : {
815 : : JsonbValue v;
816 : 43366 : bool hasNext = jspGetNext(jsp, &elem);
817 : :
818 [ + + + + : 43366 : 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 : 10 : res = jperOk;
825 : 10 : break;
826 : : }
827 : :
828 : 43356 : baseObject = cxt->baseObject;
128 tgl@sss.pgh.pa.us 829 : 43356 : getJsonPathItem(cxt, jsp, &v);
830 : :
934 peter@eisentraut.org 831 : 43324 : res = executeNextItem(cxt, jsp, &elem,
832 : : &v, found);
833 : 43324 : cxt->baseObject = baseObject;
834 : : }
835 : 43324 : break;
836 : :
837 : : /* all boolean item types: */
2688 akorotkov@postgresql 838 : 71270 : 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 : 71270 : JsonPathBool st = executeBoolItem(cxt, jsp, jb, true);
853 : :
854 : 71270 : res = appendBoolResult(cxt, jsp, found, st);
855 : 71270 : break;
856 : : }
857 : :
934 peter@eisentraut.org 858 : 242 : case jpiAdd:
859 : 242 : return executeBinaryArithmExpr(cxt, jsp, jb,
860 : : numeric_add_safe, found);
861 : :
862 : 110 : case jpiSub:
863 : 110 : return executeBinaryArithmExpr(cxt, jsp, jb,
864 : : numeric_sub_safe, found);
865 : :
866 : 40 : case jpiMul:
867 : 40 : return executeBinaryArithmExpr(cxt, jsp, jb,
868 : : numeric_mul_safe, found);
869 : :
870 : 44 : case jpiDiv:
871 : 44 : return executeBinaryArithmExpr(cxt, jsp, jb,
872 : : numeric_div_safe, found);
873 : :
874 : 8 : case jpiMod:
875 : 8 : return executeBinaryArithmExpr(cxt, jsp, jb,
876 : : numeric_mod_safe, found);
877 : :
878 : 48 : case jpiPlus:
879 : 48 : return executeUnaryArithmExpr(cxt, jsp, jb, NULL, found);
880 : :
881 : 100 : case jpiMinus:
882 : 100 : return executeUnaryArithmExpr(cxt, jsp, jb, numeric_uminus,
883 : : found);
884 : :
2688 akorotkov@postgresql 885 : 2517 : case jpiAnyArray:
886 [ + + ]: 2517 : if (JsonbType(jb) == jbvArray)
887 : : {
888 : 2177 : bool hasNext = jspGetNext(jsp, &elem);
889 : :
890 : 2177 : res = executeItemUnwrapTargetArray(cxt, hasNext ? &elem : NULL,
891 [ + + ]: 2177 : jb, found, jspAutoUnwrap(cxt));
892 : : }
893 [ + + ]: 340 : else if (jspAutoWrap(cxt))
128 tgl@sss.pgh.pa.us 894 : 172 : res = executeNextItem(cxt, jsp, NULL, jb, found);
2688 akorotkov@postgresql 895 [ + - ]: 168 : else if (!jspIgnoreStructuralErrors(cxt))
896 [ + + + - ]: 168 : 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 : 2189 : break;
900 : :
934 peter@eisentraut.org 901 : 194 : case jpiAnyKey:
902 [ + + ]: 194 : if (JsonbType(jb) == jbvObject)
903 : : {
904 : 97 : bool hasNext = jspGetNext(jsp, &elem);
905 : :
906 [ - + ]: 97 : if (jb->type != jbvBinary)
934 peter@eisentraut.org 907 [ # # ]:UBC 0 : elog(ERROR, "invalid jsonb object type: %d", jb->type);
908 : :
934 peter@eisentraut.org 909 :CBC 97 : return executeAnyItem
910 : : (cxt, hasNext ? &elem : NULL,
911 : : jb->val.binary.data, found, 1, 1, 1,
912 [ + + ]: 97 : false, jspAutoUnwrap(cxt));
913 : : }
914 [ + + + + ]: 97 : else if (unwrap && JsonbType(jb) == jbvArray)
915 : 18 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
916 [ + + ]: 79 : else if (!jspIgnoreStructuralErrors(cxt))
917 : : {
918 [ - + ]: 21 : Assert(found);
919 [ + + + - ]: 21 : 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 : 58 : break;
924 : :
2688 akorotkov@postgresql 925 : 341 : case jpiIndexArray:
926 [ + + + + ]: 341 : if (JsonbType(jb) == jbvArray || jspAutoWrap(cxt))
927 : 259 : {
928 : 333 : int innermostArraySize = cxt->innermostArraySize;
929 : : int i;
930 : 333 : int size = JsonbArraySize(jb);
931 : 333 : bool singleton = size < 0;
932 : 333 : bool hasNext = jspGetNext(jsp, &elem);
933 : :
934 [ + + ]: 333 : if (singleton)
935 : 4 : size = 1;
936 : :
937 : 333 : cxt->innermostArraySize = size; /* for LAST evaluation */
938 : :
939 [ + + ]: 577 : 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 : 341 : bool range = jspGetArraySubscript(jsp, &from,
947 : : &to, i);
948 : :
949 : 341 : res = getArrayIndex(cxt, &from, jb, &index_from);
950 : :
951 [ + + ]: 325 : if (jperIsError(res))
952 : 23 : break;
953 : :
954 [ + + ]: 307 : if (range)
955 : : {
956 : 21 : res = getArrayIndex(cxt, &to, jb, &index_to);
957 : :
958 [ - + ]: 17 : if (jperIsError(res))
2688 akorotkov@postgresql 959 :UBC 0 : break;
960 : : }
961 : : else
2688 akorotkov@postgresql 962 :CBC 286 : index_to = index_from;
963 : :
964 [ + + ]: 303 : if (!jspIgnoreStructuralErrors(cxt) &&
965 [ + + ]: 64 : (index_from < 0 ||
966 [ + - ]: 56 : index_from > index_to ||
967 [ + + ]: 56 : index_to >= size))
968 [ + + + - ]: 54 : RETURN_ERROR(ereport(ERROR,
969 : : (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
970 : : errmsg("jsonpath array subscript is out of bounds"))));
971 : :
972 [ + + ]: 269 : if (index_from < 0)
973 : 8 : index_from = 0;
974 : :
975 [ + + ]: 269 : if (index_to >= size)
976 : 22 : index_to = size - 1;
977 : :
978 : 269 : res = jperNotFound;
979 : :
980 [ + + ]: 516 : for (index = index_from; index <= index_to; index++)
981 : : {
982 : : JsonbValue *v;
983 : :
984 [ + + ]: 272 : if (singleton)
985 : : {
986 : 4 : v = jb;
987 : : }
988 : : else
989 : : {
990 : 268 : v = getIthJsonbValueFromContainer(jb->val.binary.data,
991 : : (uint32) index);
992 : :
993 [ - + ]: 268 : if (v == NULL)
2688 akorotkov@postgresql 994 :UBC 0 : continue;
995 : : }
996 : :
2688 akorotkov@postgresql 997 [ + + + + ]:CBC 272 : if (!hasNext && !found)
998 : 20 : return jperOk;
999 : :
128 tgl@sss.pgh.pa.us 1000 : 252 : res = executeNextItem(cxt, jsp, &elem, v, found);
1001 : :
2688 akorotkov@postgresql 1002 [ - + ]: 252 : if (jperIsError(res))
2688 akorotkov@postgresql 1003 :UBC 0 : break;
1004 : :
2688 akorotkov@postgresql 1005 [ + + + + ]:CBC 252 : if (res == jperOk && !found)
1006 : 5 : break;
1007 : : }
1008 : :
1009 [ - + ]: 249 : if (jperIsError(res))
2688 akorotkov@postgresql 1010 :UBC 0 : break;
1011 : :
2688 akorotkov@postgresql 1012 [ + + + + ]:CBC 249 : if (res == jperOk && !found)
1013 : 5 : break;
1014 : : }
1015 : :
1016 : 259 : cxt->innermostArraySize = innermostArraySize;
1017 : : }
1018 [ + - ]: 8 : else if (!jspIgnoreStructuralErrors(cxt))
1019 : : {
1020 [ + + + - ]: 8 : 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 : 259 : break;
1025 : :
934 peter@eisentraut.org 1026 : 229 : case jpiAny:
1027 : : {
2688 akorotkov@postgresql 1028 : 229 : bool hasNext = jspGetNext(jsp, &elem);
1029 : :
1030 : : /* first try without any intermediate steps */
934 peter@eisentraut.org 1031 [ + + ]: 229 : if (jsp->content.anybounds.first == 0)
1032 : : {
1033 : : bool savedIgnoreStructuralErrors;
1034 : :
1035 : 127 : savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors;
1036 : 127 : cxt->ignoreStructuralErrors = true;
1037 : 127 : res = executeNextItem(cxt, jsp, &elem,
1038 : : jb, found);
1039 : 127 : cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors;
1040 : :
1041 [ + + + + ]: 127 : if (res == jperOk && !found)
1042 : 5 : break;
1043 : : }
1044 : :
1045 [ + - ]: 224 : if (jb->type == jbvBinary)
1046 : 224 : 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 [ + + ]: 224 : true, jspAutoUnwrap(cxt));
1053 : 224 : break;
1054 : : }
1055 : :
1056 : 117739 : case jpiKey:
2688 akorotkov@postgresql 1057 [ + + ]: 117739 : if (JsonbType(jb) == jbvObject)
1058 : : {
1059 : : JsonbValue *v;
1060 : : JsonbValue key;
1061 : :
934 peter@eisentraut.org 1062 : 117107 : key.type = jbvString;
1063 : 117107 : key.val.string.val = jspGetString(jsp, &key.val.string.len);
1064 : :
1065 : 117107 : v = findJsonbValueFromContainer(jb->val.binary.data,
1066 : : JB_FOBJECT, &key);
1067 : :
1068 [ + + ]: 117107 : if (v != NULL)
1069 : : {
1070 : 19512 : res = executeNextItem(cxt, jsp, NULL,
1071 : : v, found);
128 tgl@sss.pgh.pa.us 1072 : 19512 : pfree(v);
1073 : : }
934 peter@eisentraut.org 1074 [ + + ]: 97595 : else if (!jspIgnoreStructuralErrors(cxt))
1075 : : {
1076 [ - + ]: 59 : Assert(found);
1077 : :
1078 [ + + ]: 59 : if (!jspThrowErrors(cxt))
1079 : 43 : return jperError;
1080 : :
1081 [ + - ]: 16 : 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 : : }
2688 akorotkov@postgresql 1088 [ + + + + ]: 632 : else if (unwrap && JsonbType(jb) == jbvArray)
1089 : 24 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
1090 [ + + ]: 608 : else if (!jspIgnoreStructuralErrors(cxt))
1091 : : {
1092 [ - + ]: 175 : Assert(found);
1093 [ + + + - ]: 175 : 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 : 117481 : break;
1098 : :
934 peter@eisentraut.org 1099 : 17283 : case jpiCurrent:
128 tgl@sss.pgh.pa.us 1100 : 17283 : res = executeNextItem(cxt, jsp, NULL, cxt->current, found);
934 peter@eisentraut.org 1101 : 17283 : break;
1102 : :
1103 : 148408 : case jpiRoot:
1104 : 148408 : jb = cxt->root;
1105 : 148408 : baseObject = setBaseObject(cxt, jb, 0);
128 tgl@sss.pgh.pa.us 1106 : 148408 : res = executeNextItem(cxt, jsp, NULL, jb, found);
934 peter@eisentraut.org 1107 : 147384 : cxt->baseObject = baseObject;
1108 : 147384 : break;
1109 : :
2688 akorotkov@postgresql 1110 : 16346 : case jpiFilter:
1111 : : {
1112 : : JsonPathBool st;
1113 : :
1114 [ + + + + ]: 16346 : if (unwrap && JsonbType(jb) == jbvArray)
1115 : 88 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1116 : : false);
1117 : :
1118 : 16258 : jspGetArg(jsp, &elem);
1119 : 16258 : st = executeNestedBoolItem(cxt, &elem, jb);
1120 [ + + ]: 16194 : if (st != jpbTrue)
1121 : 13784 : res = jperNotFound;
1122 : : else
1123 : 2410 : res = executeNextItem(cxt, jsp, NULL,
1124 : : jb, found);
1125 : 16194 : break;
1126 : : }
1127 : :
1128 : 236 : case jpiType:
1129 : : {
1130 : : JsonbValue jbv;
1131 : :
128 tgl@sss.pgh.pa.us 1132 : 236 : jbv.type = jbvString;
1133 : 236 : jbv.val.string.val = pstrdup(JsonbTypeName(jb));
1134 : 236 : jbv.val.string.len = strlen(jbv.val.string.val);
1135 : :
1136 : 236 : res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1137 : : }
2688 akorotkov@postgresql 1138 : 236 : break;
1139 : :
1140 : 48 : case jpiSize:
1141 : : {
1142 : 48 : int size = JsonbArraySize(jb);
1143 : : JsonbValue jbv;
1144 : :
1145 [ + + ]: 48 : if (size < 0)
1146 : : {
1147 [ + + ]: 32 : if (!jspAutoWrap(cxt))
1148 : : {
1149 [ + - ]: 8 : if (!jspIgnoreStructuralErrors(cxt))
1150 [ + + + - ]: 8 : 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)))));
2688 akorotkov@postgresql 1154 :UBC 0 : break;
1155 : : }
1156 : :
2688 akorotkov@postgresql 1157 :CBC 24 : size = 1;
1158 : : }
1159 : :
128 tgl@sss.pgh.pa.us 1160 : 40 : jbv.type = jbvNumeric;
1161 : 40 : jbv.val.numeric = int64_to_numeric(size);
1162 : :
1163 : 40 : res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1164 : : }
2688 akorotkov@postgresql 1165 : 40 : break;
1166 : :
934 peter@eisentraut.org 1167 : 72 : case jpiAbs:
1168 : 72 : return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_abs,
1169 : : found);
1170 : :
1171 : 32 : case jpiFloor:
1172 : 32 : return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_floor,
1173 : : found);
1174 : :
1175 : 68 : case jpiCeiling:
1176 : 68 : return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_ceil,
1177 : : found);
1178 : :
2688 akorotkov@postgresql 1179 : 76 : case jpiDouble:
1180 : : {
1181 : : JsonbValue jbv;
1182 : :
1183 [ + + + + ]: 76 : if (unwrap && JsonbType(jb) == jbvArray)
1184 : 28 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1185 : : false);
1186 : :
1187 [ + + ]: 72 : if (jb->type == jbvNumeric)
1188 : : {
1189 : 8 : char *tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
1190 : : NumericGetDatum(jb->val.numeric)));
1191 : : double val;
1324 tgl@sss.pgh.pa.us 1192 : 8 : ErrorSaveContext escontext = {T_ErrorSaveContext};
1193 : :
1194 : 8 : val = float8in_internal(tmp,
1195 : : NULL,
1196 : : "double precision",
1197 : : tmp,
1198 : : (Node *) &escontext);
1199 : :
879 andrew@dunslane.net 1200 [ + + ]: 8 : if (escontext.error_occurred)
1201 [ + - + - ]: 4 : 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 [ + - - + ]: 4 : if (isinf(val) || isnan(val))
2688 akorotkov@postgresql 1206 [ # # # # ]:UBC 0 : 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)))));
2688 akorotkov@postgresql 1210 :CBC 4 : res = jperOk;
1211 : : }
1212 [ + + ]: 64 : else if (jb->type == jbvString)
1213 : : {
1214 : : /* cast string as double */
1215 : : double val;
1216 : 32 : char *tmp = pnstrdup(jb->val.string.val,
1217 : 32 : jb->val.string.len);
1324 tgl@sss.pgh.pa.us 1218 : 32 : ErrorSaveContext escontext = {T_ErrorSaveContext};
1219 : :
1220 : 32 : val = float8in_internal(tmp,
1221 : : NULL,
1222 : : "double precision",
1223 : : tmp,
1224 : : (Node *) &escontext);
1225 : :
879 andrew@dunslane.net 1226 [ + + ]: 32 : if (escontext.error_occurred)
2688 akorotkov@postgresql 1227 [ + - + - ]: 12 : 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"))));
879 andrew@dunslane.net 1231 [ + + + + ]: 28 : if (isinf(val) || isnan(val))
1232 [ + + + - ]: 24 : 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 : :
2688 akorotkov@postgresql 1237 : 4 : jb = &jbv;
1238 : 4 : jb->type = jbvNumeric;
1239 : 4 : jb->val.numeric = DatumGetNumeric(DirectFunctionCall1(float8_numeric,
1240 : : Float8GetDatum(val)));
1241 : 4 : res = jperOk;
1242 : : }
1243 : :
1244 [ + + ]: 40 : if (res == jperNotFound)
1245 [ + + + - ]: 32 : 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 : :
128 tgl@sss.pgh.pa.us 1250 : 8 : res = executeNextItem(cxt, jsp, NULL, jb, found);
1251 : : }
2688 akorotkov@postgresql 1252 : 8 : break;
1253 : :
2495 1254 : 5686 : case jpiDatetime:
1255 : : case jpiDate:
1256 : : case jpiTime:
1257 : : case jpiTimeTz:
1258 : : case jpiTimestamp:
1259 : : case jpiTimestampTz:
1260 [ + + + + ]: 5686 : if (unwrap && JsonbType(jb) == jbvArray)
1261 : 24 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
1262 : :
1263 : 5662 : return executeDateTimeMethod(cxt, jsp, jb, found);
1264 : :
2688 1265 : 62 : case jpiKeyValue:
1266 [ + + + + ]: 62 : if (unwrap && JsonbType(jb) == jbvArray)
1267 : 4 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
1268 : :
1269 : 58 : return executeKeyValueMethod(cxt, jsp, jb, found);
1270 : :
934 peter@eisentraut.org 1271 : 44 : case jpiLast:
1272 : : {
1273 : : JsonbValue jbv;
1274 : : int last;
1275 : 44 : bool hasNext = jspGetNext(jsp, &elem);
1276 : :
1277 [ - + ]: 44 : if (cxt->innermostArraySize < 0)
934 peter@eisentraut.org 1278 [ # # ]:UBC 0 : elog(ERROR, "evaluating jsonpath LAST outside of array subscript");
1279 : :
934 peter@eisentraut.org 1280 [ + + + + ]:CBC 44 : if (!hasNext && !found)
1281 : : {
1282 : 4 : res = jperOk;
1283 : 4 : break;
1284 : : }
1285 : :
1286 : 40 : last = cxt->innermostArraySize - 1;
1287 : :
128 tgl@sss.pgh.pa.us 1288 : 40 : jbv.type = jbvNumeric;
1289 : 40 : jbv.val.numeric = int64_to_numeric(last);
1290 : :
934 peter@eisentraut.org 1291 : 40 : res = executeNextItem(cxt, jsp, &elem,
1292 : : &jbv, found);
1293 : : }
1294 : 40 : break;
1295 : :
912 andrew@dunslane.net 1296 : 120 : case jpiBigint:
1297 : : {
1298 : : JsonbValue jbv;
1299 : : Datum datum;
1300 : :
1301 [ + + + + ]: 120 : if (unwrap && JsonbType(jb) == jbvArray)
1302 : 28 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1303 : : false);
1304 : :
1305 [ + + ]: 116 : if (jb->type == jbvNumeric)
1306 : : {
323 michael@paquier.xyz 1307 : 32 : ErrorSaveContext escontext = {T_ErrorSaveContext};
1308 : : int64 val;
1309 : :
1310 : 32 : val = numeric_int8_safe(jb->val.numeric,
1311 : : (Node *) &escontext);
1312 [ + + ]: 32 : if (escontext.error_occurred)
912 andrew@dunslane.net 1313 [ + - + - ]: 8 : 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 : 24 : datum = Int64GetDatum(val);
1322 : 24 : res = jperOk;
1323 : : }
1324 [ + + ]: 84 : else if (jb->type == jbvString)
1325 : : {
1326 : : /* cast string as bigint */
1327 : 52 : char *tmp = pnstrdup(jb->val.string.val,
1328 : 52 : jb->val.string.len);
1329 : 52 : ErrorSaveContext escontext = {T_ErrorSaveContext};
1330 : : bool noerr;
1331 : :
1332 : 52 : noerr = DirectInputFunctionCallSafe(int8in, tmp,
1333 : : InvalidOid, -1,
1334 : : (Node *) &escontext,
1335 : : &datum);
1336 : :
1337 [ + + - + ]: 52 : if (!noerr || escontext.error_occurred)
1338 [ + + + - ]: 36 : 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 : 16 : res = jperOk;
1343 : : }
1344 : :
1345 [ + + ]: 72 : if (res == jperNotFound)
1346 [ + + + - ]: 32 : 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 : :
128 tgl@sss.pgh.pa.us 1351 : 40 : jbv.type = jbvNumeric;
1352 : 40 : jbv.val.numeric = DatumGetNumeric(DirectFunctionCall1(int8_numeric,
1353 : : datum));
1354 : :
1355 : 40 : res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1356 : : }
912 andrew@dunslane.net 1357 : 40 : break;
1358 : :
1359 : 171 : case jpiBoolean:
1360 : : {
1361 : : JsonbValue jbv;
1362 : : bool bval;
1363 : :
1364 [ + + + + ]: 171 : if (unwrap && JsonbType(jb) == jbvArray)
1365 : 24 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1366 : : false);
1367 : :
1368 [ + + ]: 167 : if (jb->type == jbvBool)
1369 : : {
1370 : 17 : bval = jb->val.boolean;
1371 : :
1372 : 17 : res = jperOk;
1373 : : }
1374 [ + + ]: 150 : else if (jb->type == jbvNumeric)
1375 : : {
1376 : : int ival;
1377 : : Datum datum;
1378 : : bool noerr;
1379 : 33 : char *tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
1380 : : NumericGetDatum(jb->val.numeric)));
1381 : 33 : ErrorSaveContext escontext = {T_ErrorSaveContext};
1382 : :
1383 : 33 : noerr = DirectInputFunctionCallSafe(int4in, tmp,
1384 : : InvalidOid, -1,
1385 : : (Node *) &escontext,
1386 : : &datum);
1387 : :
1388 [ + + - + ]: 33 : if (!noerr || escontext.error_occurred)
1389 [ + - + - ]: 8 : 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 : 25 : ival = DatumGetInt32(datum);
1395 [ + + ]: 25 : if (ival == 0)
1396 : 4 : bval = false;
1397 : : else
1398 : 21 : bval = true;
1399 : :
1400 : 25 : res = jperOk;
1401 : : }
1402 [ + + ]: 117 : else if (jb->type == jbvString)
1403 : : {
1404 : : /* cast string as boolean */
1405 : 93 : char *tmp = pnstrdup(jb->val.string.val,
1406 : 93 : jb->val.string.len);
1407 : :
1408 [ + + ]: 93 : if (!parse_bool(tmp, &bval))
1409 [ + + + - ]: 36 : 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 : 57 : res = jperOk;
1415 : : }
1416 : :
1417 [ + + ]: 123 : if (res == jperNotFound)
1418 [ + + + - ]: 24 : 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 : :
128 tgl@sss.pgh.pa.us 1423 : 99 : jbv.type = jbvBool;
1424 : 99 : jbv.val.boolean = bval;
1425 : :
1426 : 99 : res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1427 : : }
912 andrew@dunslane.net 1428 : 99 : break;
1429 : :
1430 : 309 : case jpiDecimal:
1431 : : case jpiNumber:
1432 : : {
1433 : : JsonbValue jbv;
1434 : : Numeric num;
1435 : 309 : char *numstr = NULL;
1436 : :
1437 [ + + + + ]: 309 : if (unwrap && JsonbType(jb) == jbvArray)
1438 : 81 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1439 : : false);
1440 : :
1441 [ + + ]: 301 : if (jb->type == jbvNumeric)
1442 : : {
1443 : 141 : num = jb->val.numeric;
1444 [ + - - + ]: 141 : if (numeric_is_nan(num) || numeric_is_inf(num))
912 andrew@dunslane.net 1445 [ # # # # ]:UBC 0 : 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 : :
912 andrew@dunslane.net 1450 [ + + ]:CBC 141 : if (jsp->type == jpiDecimal)
1451 : 117 : numstr = DatumGetCString(DirectFunctionCall1(numeric_out,
1452 : : NumericGetDatum(num)));
1453 : 141 : res = jperOk;
1454 : : }
1455 [ + + ]: 160 : else if (jb->type == jbvString)
1456 : : {
1457 : : /* cast string as number */
1458 : : Datum datum;
1459 : : bool noerr;
1460 : 96 : ErrorSaveContext escontext = {T_ErrorSaveContext};
1461 : :
1462 : 96 : numstr = pnstrdup(jb->val.string.val, jb->val.string.len);
1463 : :
1464 : 96 : noerr = DirectInputFunctionCallSafe(numeric_in, numstr,
1465 : : InvalidOid, -1,
1466 : : (Node *) &escontext,
1467 : : &datum);
1468 : :
1469 [ + + - + ]: 96 : if (!noerr || escontext.error_occurred)
1470 [ + - + - ]: 24 : 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 : 88 : num = DatumGetNumeric(datum);
1476 [ + + + + ]: 88 : if (numeric_is_nan(num) || numeric_is_inf(num))
1477 [ + + + - ]: 48 : 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 : 40 : res = jperOk;
1483 : : }
1484 : :
1485 [ + + ]: 245 : if (res == jperNotFound)
1486 [ + + + - ]: 64 : 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 [ + + + + ]: 181 : if (jsp->type == jpiDecimal && jsp->content.args.left)
1498 : : {
1499 : : Datum numdatum;
1500 : : int32 dtypmod;
1501 : : int32 precision;
1502 : 93 : int32 scale = 0;
1503 : : bool noerr;
1504 : 93 : ErrorSaveContext escontext = {T_ErrorSaveContext};
1505 : :
1506 : 93 : jspGetLeftArg(jsp, &elem);
1507 [ - + ]: 93 : if (elem.type != jpiNumeric)
912 andrew@dunslane.net 1508 [ # # ]:UBC 0 : elog(ERROR, "invalid jsonpath item type for .decimal() precision");
1509 : :
323 michael@paquier.xyz 1510 :CBC 93 : precision = numeric_int4_safe(jspGetNumeric(&elem),
1511 : : (Node *) &escontext);
1512 [ + + ]: 93 : if (escontext.error_occurred)
912 andrew@dunslane.net 1513 [ + - + - ]: 29 : 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 [ + + ]: 89 : if (jsp->content.args.right)
1519 : : {
1520 : 84 : jspGetRightArg(jsp, &elem);
1521 [ - + ]: 84 : if (elem.type != jpiNumeric)
912 andrew@dunslane.net 1522 [ # # ]:UBC 0 : elog(ERROR, "invalid jsonpath item type for .decimal() scale");
1523 : :
323 michael@paquier.xyz 1524 :CBC 84 : scale = numeric_int4_safe(jspGetNumeric(&elem),
1525 : : (Node *) &escontext);
1526 [ + + ]: 84 : if (escontext.error_occurred)
912 andrew@dunslane.net 1527 [ + - + - ]: 4 : 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 */
23 michael@paquier.xyz 1534 : 85 : dtypmod = make_numeric_typmod_safe(precision, scale,
1535 [ + + ]: 85 : jspThrowErrors(cxt) ? NULL : (Node *) &escontext);
1536 [ + + ]: 65 : if (escontext.error_occurred)
1537 : 25 : return jperError;
1538 : :
1539 : : /* Convert numstr to Numeric with typmod */
912 andrew@dunslane.net 1540 [ - + ]: 40 : Assert(numstr != NULL);
1541 : 40 : noerr = DirectInputFunctionCallSafe(numeric_in, numstr,
1542 : : InvalidOid, dtypmod,
1543 : : (Node *) &escontext,
1544 : : &numdatum);
1545 : :
1546 [ + + - + ]: 40 : if (!noerr || escontext.error_occurred)
1547 [ + - + - ]: 8 : 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 : 32 : num = DatumGetNumeric(numdatum);
1553 : : }
1554 : :
128 tgl@sss.pgh.pa.us 1555 : 120 : jbv.type = jbvNumeric;
1556 : 120 : jbv.val.numeric = num;
1557 : :
1558 : 120 : res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1559 : : }
912 andrew@dunslane.net 1560 : 120 : break;
1561 : :
1562 : 112 : case jpiInteger:
1563 : : {
1564 : : JsonbValue jbv;
1565 : : Datum datum;
1566 : :
1567 [ + + + + ]: 112 : if (unwrap && JsonbType(jb) == jbvArray)
1568 : 28 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found,
1569 : : false);
1570 : :
1571 [ + + ]: 108 : if (jb->type == jbvNumeric)
1572 : : {
1573 : : int32 val;
323 michael@paquier.xyz 1574 : 28 : ErrorSaveContext escontext = {T_ErrorSaveContext};
1575 : :
1576 : 28 : val = numeric_int4_safe(jb->val.numeric,
1577 : : (Node *) &escontext);
1578 [ + + ]: 28 : if (escontext.error_occurred)
912 andrew@dunslane.net 1579 [ + - + - ]: 8 : 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 : 20 : datum = Int32GetDatum(val);
1587 : 20 : res = jperOk;
1588 : : }
1589 [ + + ]: 80 : else if (jb->type == jbvString)
1590 : : {
1591 : : /* cast string as integer */
1592 : 48 : char *tmp = pnstrdup(jb->val.string.val,
1593 : 48 : jb->val.string.len);
1594 : 48 : ErrorSaveContext escontext = {T_ErrorSaveContext};
1595 : : bool noerr;
1596 : :
1597 : 48 : noerr = DirectInputFunctionCallSafe(int4in, tmp,
1598 : : InvalidOid, -1,
1599 : : (Node *) &escontext,
1600 : : &datum);
1601 : :
1602 [ + + - + ]: 48 : if (!noerr || escontext.error_occurred)
1603 [ + + + - ]: 36 : 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 : 12 : res = jperOk;
1608 : : }
1609 : :
1610 [ + + ]: 64 : if (res == jperNotFound)
1611 [ + + + - ]: 32 : 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 : :
128 tgl@sss.pgh.pa.us 1616 : 32 : jbv.type = jbvNumeric;
1617 : 32 : jbv.val.numeric = DatumGetNumeric(DirectFunctionCall1(int4_numeric,
1618 : : datum));
1619 : :
1620 : 32 : res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1621 : : }
912 andrew@dunslane.net 1622 : 32 : break;
1623 : :
1624 : 134 : case jpiStringFunc:
1625 : : {
1626 : : JsonbValue jbv;
1627 : 134 : char *tmp = NULL;
1628 : :
768 1629 [ + + + + ]: 134 : if (unwrap && JsonbType(jb) == jbvArray)
1630 : 20 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
1631 : :
912 1632 [ + + + + : 126 : switch (JsonbType(jb))
+ - ]
1633 : : {
1634 : 18 : case jbvString:
1635 : :
1636 : : /*
1637 : : * Value is not necessarily null-terminated, so we do
1638 : : * pnstrdup() here.
1639 : : */
1640 : 18 : tmp = pnstrdup(jb->val.string.val,
1641 : 18 : jb->val.string.len);
1642 : 18 : break;
1643 : 26 : case jbvNumeric:
1644 : 26 : tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
1645 : : NumericGetDatum(jb->val.numeric)));
1646 : 26 : break;
1647 : 18 : case jbvBool:
1648 [ + + ]: 18 : tmp = (jb->val.boolean) ? "true" : "false";
1649 : 18 : break;
1650 : 40 : case jbvDatetime:
1651 : : {
1652 : : char buf[MAXDATELEN + 1];
1653 : :
681 tgl@sss.pgh.pa.us 1654 : 40 : JsonEncodeDateTime(buf,
1655 : : jb->val.datetime.value,
1656 : : jb->val.datetime.typid,
1657 : 40 : &jb->val.datetime.tz);
1658 : 40 : tmp = pstrdup(buf);
1659 : : }
912 andrew@dunslane.net 1660 : 40 : break;
1661 : 24 : case jbvNull:
1662 : : case jbvArray:
1663 : : case jbvObject:
1664 : : case jbvBinary:
1665 [ + + + - ]: 24 : 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 [ - + ]: 102 : Assert(tmp != NULL); /* We must have set tmp above */
128 tgl@sss.pgh.pa.us 1673 : 102 : jbv.val.string.val = tmp;
1674 : 102 : jbv.val.string.len = strlen(jbv.val.string.val);
1675 : 102 : jbv.type = jbvString;
1676 : :
1677 : 102 : res = executeNextItem(cxt, jsp, NULL, &jbv, found);
1678 : : }
912 andrew@dunslane.net 1679 : 102 : break;
1680 : :
114 1681 : 526 : 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 [ + + + + ]: 526 : if (unwrap && JsonbType(jb) == jbvArray)
1691 : 40 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
1692 : :
1693 : 486 : return executeStringInternalMethod(cxt, jsp, jb, found);
1694 : : }
1695 : : break;
1696 : :
2688 akorotkov@postgresql 1697 :UBC 0 : default:
1698 [ # # ]: 0 : elog(ERROR, "unrecognized jsonpath item type: %d", jsp->type);
1699 : : }
1700 : :
2688 akorotkov@postgresql 1701 :CBC 416402 : return res;
1702 : : }
1703 : :
1704 : : /*
1705 : : * Unwrap current array item and execute jsonpath for each of its elements.
1706 : : */
1707 : : static JsonPathExecResult
1708 : 2443 : executeItemUnwrapTargetArray(JsonPathExecContext *cxt, JsonPathItem *jsp,
1709 : : JsonbValue *jb, JsonValueList *found,
1710 : : bool unwrapElements)
1711 : : {
1712 [ - + ]: 2443 : if (jb->type != jbvBinary)
1713 : : {
2688 akorotkov@postgresql 1714 [ # # ]:UBC 0 : Assert(jb->type != jbvArray);
1715 [ # # ]: 0 : elog(ERROR, "invalid jsonb array value type: %d", jb->type);
1716 : : }
1717 : :
2688 akorotkov@postgresql 1718 :CBC 2443 : 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 : : */
1727 : : static JsonPathExecResult
1728 : 309609 : executeNextItem(JsonPathExecContext *cxt,
1729 : : JsonPathItem *cur, JsonPathItem *next,
1730 : : JsonbValue *v, JsonValueList *found)
1731 : : {
1732 : : JsonPathItem elem;
1733 : : bool hasNext;
1734 : :
1735 [ - + ]: 309609 : if (!cur)
2688 akorotkov@postgresql 1736 :UBC 0 : hasNext = next != NULL;
2688 akorotkov@postgresql 1737 [ + + ]:CBC 309609 : else if (next)
1738 : 121147 : hasNext = jspHasNext(cur);
1739 : : else
1740 : : {
1741 : 188462 : next = &elem;
1742 : 188462 : hasNext = jspGetNext(cur, next);
1743 : : }
1744 : :
1745 [ + + ]: 309609 : if (hasNext)
1746 : 139314 : return executeItem(cxt, next, v, found);
1747 : :
1748 [ + + ]: 170295 : if (found)
128 tgl@sss.pgh.pa.us 1749 : 136291 : JsonValueListAppend(found, v);
1750 : :
2688 akorotkov@postgresql 1751 : 170295 : 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 : : */
1758 : : static JsonPathExecResult
1759 : 140345 : executeItemOptUnwrapResult(JsonPathExecContext *cxt, JsonPathItem *jsp,
1760 : : JsonbValue *jb, bool unwrap,
1761 : : JsonValueList *found)
1762 : : {
1763 [ + + + + ]: 140345 : if (unwrap && jspAutoUnwrap(cxt))
1764 : : {
1765 : : JsonValueList seq;
1766 : : JsonValueListIterator it;
1767 : : JsonPathExecResult res;
1768 : : JsonbValue *item;
1769 : :
128 tgl@sss.pgh.pa.us 1770 : 84956 : JsonValueListInit(&seq);
1771 : :
1772 : 84956 : res = executeItem(cxt, jsp, jb, &seq);
1773 : :
2688 akorotkov@postgresql 1774 [ + + ]: 84940 : if (jperIsError(res))
1775 : : {
128 tgl@sss.pgh.pa.us 1776 : 47 : JsonValueListClear(&seq);
2688 akorotkov@postgresql 1777 : 47 : return res;
1778 : : }
1779 : :
1780 : 84893 : JsonValueListInitIterator(&seq, &it);
128 tgl@sss.pgh.pa.us 1781 [ + + ]: 142236 : while ((item = JsonValueListNext(&it)))
1782 : : {
2688 akorotkov@postgresql 1783 [ - + ]: 57343 : Assert(item->type != jbvArray);
1784 : :
1785 [ + + ]: 57343 : if (JsonbType(item) == jbvArray)
1786 : 36 : executeItemUnwrapTargetArray(cxt, NULL, item, found, false);
1787 : : else
1788 : 57307 : JsonValueListAppend(found, item);
1789 : : }
1790 : :
128 tgl@sss.pgh.pa.us 1791 : 84893 : JsonValueListClear(&seq);
1792 : :
2688 akorotkov@postgresql 1793 : 84893 : return jperOk;
1794 : : }
1795 : :
1796 : 55389 : return executeItem(cxt, jsp, jb, found);
1797 : : }
1798 : :
1799 : : /*
1800 : : * Same as executeItemOptUnwrapResult(), but with error suppression.
1801 : : */
1802 : : static JsonPathExecResult
1803 : 139313 : executeItemOptUnwrapResultNoThrow(JsonPathExecContext *cxt,
1804 : : JsonPathItem *jsp,
1805 : : JsonbValue *jb, bool unwrap,
1806 : : JsonValueList *found)
1807 : : {
1808 : : JsonPathExecResult res;
1809 : 139313 : bool throwErrors = cxt->throwErrors;
1810 : :
1811 : 139313 : cxt->throwErrors = false;
1812 : 139313 : res = executeItemOptUnwrapResult(cxt, jsp, jb, unwrap, found);
1813 : 139309 : cxt->throwErrors = throwErrors;
1814 : :
1815 : 139309 : return res;
1816 : : }
1817 : :
1818 : : /* Execute boolean-valued jsonpath expression. */
1819 : : static JsonPathBool
1820 : 124161 : executeBoolItem(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 */
890 1829 : 124161 : check_stack_depth();
1830 : :
2688 1831 [ + + - + ]: 124161 : if (!canHaveNext && jspHasNext(jsp))
2688 akorotkov@postgresql 1832 [ # # ]:UBC 0 : elog(ERROR, "boolean jsonpath item cannot have next item");
1833 : :
2688 akorotkov@postgresql 1834 [ + + + + :CBC 124161 : switch (jsp->type)
+ + + +
- ]
1835 : : {
1836 : 18159 : case jpiAnd:
1837 : 18159 : jspGetLeftArg(jsp, &larg);
1838 : 18159 : res = executeBoolItem(cxt, &larg, jb, false);
1839 : :
1840 [ + + ]: 18159 : if (res == jpbFalse)
1841 : 15693 : return jpbFalse;
1842 : :
1843 : : /*
1844 : : * SQL/JSON says that we should check second arg in case of
1845 : : * jperError
1846 : : */
1847 : :
1848 : 2466 : jspGetRightArg(jsp, &rarg);
1849 : 2466 : res2 = executeBoolItem(cxt, &rarg, jb, false);
1850 : :
1851 [ + + ]: 2466 : return res2 == jpbTrue ? res : res2;
1852 : :
1853 : 8737 : case jpiOr:
1854 : 8737 : jspGetLeftArg(jsp, &larg);
1855 : 8737 : res = executeBoolItem(cxt, &larg, jb, false);
1856 : :
1857 [ + + ]: 8737 : if (res == jpbTrue)
1858 : 1680 : return jpbTrue;
1859 : :
1860 : 7057 : jspGetRightArg(jsp, &rarg);
1861 : 7057 : res2 = executeBoolItem(cxt, &rarg, jb, false);
1862 : :
1863 [ + + ]: 7057 : return res2 == jpbFalse ? res : res2;
1864 : :
1865 : 72 : case jpiNot:
1866 : 72 : jspGetArg(jsp, &larg);
1867 : :
1868 : 72 : res = executeBoolItem(cxt, &larg, jb, false);
1869 : :
1870 [ + + ]: 72 : if (res == jpbUnknown)
1871 : 24 : return jpbUnknown;
1872 : :
1873 : 48 : return res == jpbTrue ? jpbFalse : jpbTrue;
1874 : :
1875 : 142 : case jpiIsUnknown:
1876 : 142 : jspGetArg(jsp, &larg);
1877 : 142 : res = executeBoolItem(cxt, &larg, jb, false);
1878 : 142 : return res == jpbUnknown ? jpbTrue : jpbFalse;
1879 : :
1880 : 42206 : case jpiEqual:
1881 : : case jpiNotEqual:
1882 : : case jpiLess:
1883 : : case jpiGreater:
1884 : : case jpiLessOrEqual:
1885 : : case jpiGreaterOrEqual:
1886 : 42206 : jspGetLeftArg(jsp, &larg);
1887 : 42206 : jspGetRightArg(jsp, &rarg);
1888 : 42206 : return executePredicate(cxt, jsp, &larg, &rarg, jb, true,
1889 : : executeComparison, cxt);
1890 : :
1891 : 68 : case jpiStartsWith: /* 'whole STARTS WITH initial' */
1892 : 68 : jspGetLeftArg(jsp, &larg); /* 'whole' */
1893 : 68 : jspGetRightArg(jsp, &rarg); /* 'initial' */
1894 : 68 : return executePredicate(cxt, jsp, &larg, &rarg, jb, false,
1895 : : executeStartsWith, NULL);
1896 : :
1897 : 264 : 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 : : */
2686 1905 : 264 : JsonLikeRegexContext lrcxt = {0};
1906 : :
2688 1907 : 264 : jspInitByBuffer(&larg, jsp->base,
1908 : : jsp->content.like_regex.expr);
1909 : :
1910 : 264 : return executePredicate(cxt, jsp, &larg, NULL, jb, false,
1911 : : executeLikeRegex, &lrcxt);
1912 : : }
1913 : :
1914 : 54513 : case jpiExists:
1915 : 54513 : jspGetArg(jsp, &larg);
1916 : :
935 rhaas@postgresql.org 1917 [ + + ]: 54513 : 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 : :
128 tgl@sss.pgh.pa.us 1927 : 34 : JsonValueListInit(&vals);
1928 : :
1929 : 34 : res = executeItemOptUnwrapResultNoThrow(cxt, &larg, jb,
1930 : : false, &vals);
1931 : :
1932 : 34 : isempty = JsonValueListIsEmpty(&vals);
1933 : 34 : JsonValueListClear(&vals);
1934 : :
2688 akorotkov@postgresql 1935 [ + + ]: 34 : if (jperIsError(res))
1936 : 26 : return jpbUnknown;
1937 : :
128 tgl@sss.pgh.pa.us 1938 : 8 : return isempty ? jpbFalse : jpbTrue;
1939 : : }
1940 : : else
1941 : : {
1942 : : JsonPathExecResult res =
1163 1943 : 54479 : executeItemOptUnwrapResultNoThrow(cxt, &larg, jb,
1944 : : false, NULL);
1945 : :
2688 akorotkov@postgresql 1946 [ + + ]: 54479 : if (jperIsError(res))
1947 : 16 : return jpbUnknown;
1948 : :
1949 : 54463 : return res == jperOk ? jpbTrue : jpbFalse;
1950 : : }
1951 : :
2688 akorotkov@postgresql 1952 :UBC 0 : default:
1953 [ # # ]: 0 : 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 : : */
1962 : : static JsonPathBool
2688 akorotkov@postgresql 1963 :CBC 16258 : executeNestedBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp,
1964 : : JsonbValue *jb)
1965 : : {
1966 : : JsonbValue *prev;
1967 : : JsonPathBool res;
1968 : :
1969 : 16258 : prev = cxt->current;
1970 : 16258 : cxt->current = jb;
1971 : 16258 : res = executeBoolItem(cxt, jsp, jb, false);
1972 : 16194 : cxt->current = prev;
1973 : :
1974 : 16194 : return res;
1975 : : }
1976 : :
1977 : : /*
1978 : : * Implementation of several jsonpath nodes:
1979 : : * - jpiAny (.** accessor),
1980 : : * - jpiAnyKey (.* accessor),
1981 : : * - jpiAnyArray ([*] accessor)
1982 : : */
1983 : : static JsonPathExecResult
1984 : 2895 : executeAnyItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbContainer *jbc,
1985 : : JsonValueList *found, uint32 level, uint32 first, uint32 last,
1986 : : bool ignoreStructuralErrors, bool unwrapNext)
1987 : : {
1988 : 2895 : JsonPathExecResult res = jperNotFound;
1989 : : JsonbIterator *it;
1990 : : int32 r;
1991 : : JsonbValue v;
1992 : :
1993 : 2895 : check_stack_depth();
1994 : :
1995 [ + + ]: 2895 : if (level > last)
1996 : 22 : return res;
1997 : :
1998 : 2873 : it = JsonbIteratorInit(jbc);
1999 : :
2000 : : /*
2001 : : * Recursively iterate over jsonb objects/arrays
2002 : : */
2003 [ + + ]: 15900 : while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE)
2004 : : {
2005 [ + + ]: 13575 : if (r == WJB_KEY)
2006 : : {
2007 : 477 : r = JsonbIteratorNext(&it, &v, true);
2008 [ - + ]: 477 : Assert(r == WJB_VALUE);
2009 : : }
2010 : :
2011 [ + + + + ]: 13575 : if (r == WJB_VALUE || r == WJB_ELEM)
2012 : : {
2013 : :
2014 [ + + + + ]: 8377 : if (level >= first ||
2015 [ + - ]: 8 : (first == PG_UINT32_MAX && last == PG_UINT32_MAX &&
2016 [ + + ]: 8 : v.type != jbvBinary)) /* leaves only requested */
2017 : : {
2018 : : /* check expression */
2019 [ + + ]: 8333 : if (jsp)
2020 : : {
2021 [ + + ]: 5704 : if (ignoreStructuralErrors)
2022 : : {
2023 : : bool savedIgnoreStructuralErrors;
2024 : :
2025 : 255 : savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors;
2026 : 255 : cxt->ignoreStructuralErrors = true;
2027 : 255 : res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext);
2028 : 255 : cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors;
2029 : : }
2030 : : else
2031 : 5449 : res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext);
2032 : :
2033 [ + + ]: 5528 : if (jperIsError(res))
2034 : 49 : break;
2035 : :
2036 [ + + + + ]: 5479 : if (res == jperOk && !found)
2037 : 263 : break;
2038 : : }
2039 [ + + ]: 2629 : else if (found)
128 tgl@sss.pgh.pa.us 2040 : 2599 : JsonValueListAppend(found, &v);
2041 : : else
2688 akorotkov@postgresql 2042 : 30 : return jperOk;
2043 : : }
2044 : :
2045 [ + + + + ]: 7859 : if (level < last && v.type == jbvBinary)
2046 : : {
2047 : 131 : res = executeAnyItem
2048 : : (cxt, jsp, v.val.binary.data, found,
2049 : : level + 1, first, last,
2050 : : ignoreStructuralErrors, unwrapNext);
2051 : :
2052 [ - + ]: 131 : if (jperIsError(res))
2688 akorotkov@postgresql 2053 :UBC 0 : break;
2054 : :
2688 akorotkov@postgresql 2055 [ + + + + ]:CBC 131 : if (res == jperOk && found == NULL)
2056 : 30 : break;
2057 : : }
2058 : : }
2059 : : }
2060 : :
2061 : 2667 : 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 : : */
2074 : : static JsonPathBool
2075 : 42538 : executePredicate(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 : 42538 : bool error = false;
2086 : 42538 : bool found = false;
2087 : :
128 tgl@sss.pgh.pa.us 2088 : 42538 : JsonValueListInit(&lseq);
2089 : 42538 : JsonValueListInit(&rseq);
2090 : :
2091 : : /* Left argument is always auto-unwrapped. */
2688 akorotkov@postgresql 2092 : 42538 : res = executeItemOptUnwrapResultNoThrow(cxt, larg, jb, true, &lseq);
2093 [ + + ]: 42538 : if (jperIsError(res))
2094 : : {
128 tgl@sss.pgh.pa.us 2095 : 12 : error = true;
2096 : 12 : goto exit;
2097 : : }
2098 : :
2688 akorotkov@postgresql 2099 [ + + ]: 42526 : if (rarg)
2100 : : {
2101 : : /* Right argument is conditionally auto-unwrapped. */
2102 : 42262 : res = executeItemOptUnwrapResultNoThrow(cxt, rarg, jb,
2103 : : unwrapRightArg, &rseq);
2104 [ + + ]: 42258 : if (jperIsError(res))
2105 : : {
128 tgl@sss.pgh.pa.us 2106 : 39 : error = true;
2107 : 39 : goto exit;
2108 : : }
2109 : : }
2110 : :
2688 akorotkov@postgresql 2111 : 42483 : JsonValueListInitIterator(&lseq, &lseqit);
128 tgl@sss.pgh.pa.us 2112 [ + + ]: 56483 : while ((lval = JsonValueListNext(&lseqit)))
2113 : : {
2114 : : JsonValueListIterator rseqit;
2115 : : JsonbValue *rval;
2688 akorotkov@postgresql 2116 : 18730 : bool first = true;
2117 : :
2687 2118 : 18730 : JsonValueListInitIterator(&rseq, &rseqit);
2688 2119 [ + + ]: 18730 : if (rarg)
128 tgl@sss.pgh.pa.us 2120 : 18466 : rval = JsonValueListNext(&rseqit);
2121 : : else
2688 akorotkov@postgresql 2122 : 264 : rval = NULL;
2123 : :
2124 : : /* Loop over right arg sequence or do single pass otherwise */
2125 [ + + + + ]: 29282 : while (rarg ? (rval != NULL) : first)
2126 : : {
2127 : 15282 : JsonPathBool res = exec(pred, lval, rval, param);
2128 : :
2129 [ + + ]: 15222 : if (res == jpbUnknown)
2130 : : {
2131 : 502 : error = true;
128 tgl@sss.pgh.pa.us 2132 [ + + ]: 502 : if (jspStrictAbsenceOfErrors(cxt))
2133 : : {
2134 : 17 : found = false; /* return unknown, not success */
2135 : 4670 : goto exit;
2136 : : }
2137 : : }
2688 akorotkov@postgresql 2138 [ + + ]: 14720 : else if (res == jpbTrue)
2139 : : {
2140 : 4863 : found = true;
128 tgl@sss.pgh.pa.us 2141 [ + + ]: 4863 : if (!jspStrictAbsenceOfErrors(cxt))
2142 : 4653 : goto exit;
2143 : : }
2144 : :
2688 akorotkov@postgresql 2145 : 10552 : first = false;
2146 [ + + ]: 10552 : if (rarg)
128 tgl@sss.pgh.pa.us 2147 : 10356 : rval = JsonValueListNext(&rseqit);
2148 : : }
2149 : : }
2150 : :
2151 : 37753 : exit:
2152 : 42474 : JsonValueListClear(&lseq);
2153 : 42474 : JsonValueListClear(&rseq);
2154 : :
2688 akorotkov@postgresql 2155 [ + + ]: 42474 : if (found) /* possible only in strict mode */
2156 : 4795 : return jpbTrue;
2157 : :
2158 [ + + ]: 37679 : if (error) /* possible only in lax mode */
2159 : 531 : return jpbUnknown;
2160 : :
2161 : 37148 : return jpbFalse;
2162 : : }
2163 : :
2164 : : /*
2165 : : * Execute binary arithmetic expression on singleton numeric operands.
2166 : : * Array operands are automatically unwrapped in lax mode.
2167 : : */
2168 : : static JsonPathExecResult
2169 : 444 : executeBinaryArithmExpr(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 : :
128 tgl@sss.pgh.pa.us 2182 : 444 : JsonValueListInit(&lseq);
2183 : 444 : JsonValueListInit(&rseq);
2184 : :
2688 akorotkov@postgresql 2185 : 444 : 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 : 444 : jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &lseq);
2192 [ - + ]: 440 : if (jperIsError(jper))
2193 : : {
128 tgl@sss.pgh.pa.us 2194 :UBC 0 : JsonValueListClear(&lseq);
2195 : 0 : JsonValueListClear(&rseq);
2688 akorotkov@postgresql 2196 : 0 : return jper;
2197 : : }
2198 : :
2688 akorotkov@postgresql 2199 :CBC 440 : jspGetRightArg(jsp, &elem);
2200 : :
2201 : 440 : jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &rseq);
2202 [ - + ]: 436 : if (jperIsError(jper))
2203 : : {
128 tgl@sss.pgh.pa.us 2204 :UBC 0 : JsonValueListClear(&lseq);
2205 : 0 : JsonValueListClear(&rseq);
2688 akorotkov@postgresql 2206 : 0 : return jper;
2207 : : }
2208 : :
128 tgl@sss.pgh.pa.us 2209 [ + + - + ]:CBC 827 : if (!JsonValueListIsSingleton(&lseq) ||
2688 akorotkov@postgresql 2210 : 391 : !(lval = getScalar(JsonValueListHead(&lseq), jbvNumeric)))
2211 : : {
128 tgl@sss.pgh.pa.us 2212 : 45 : JsonValueListClear(&lseq);
2213 : 45 : JsonValueListClear(&rseq);
2688 akorotkov@postgresql 2214 [ + + + - ]: 45 : 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 : :
128 tgl@sss.pgh.pa.us 2220 [ + + + + ]: 759 : if (!JsonValueListIsSingleton(&rseq) ||
2688 akorotkov@postgresql 2221 : 368 : !(rval = getScalar(JsonValueListHead(&rseq), jbvNumeric)))
2222 : : {
128 tgl@sss.pgh.pa.us 2223 : 39 : JsonValueListClear(&lseq);
2224 : 39 : JsonValueListClear(&rseq);
2688 akorotkov@postgresql 2225 [ + + + - ]: 39 : 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 [ + + ]: 352 : if (jspThrowErrors(cxt))
2232 : : {
2233 : 68 : res = func(lval->val.numeric, rval->val.numeric, NULL);
2234 : : }
2235 : : else
2236 : : {
323 michael@paquier.xyz 2237 : 284 : ErrorSaveContext escontext = {T_ErrorSaveContext};
2238 : :
2239 : 284 : res = func(lval->val.numeric, rval->val.numeric, (Node *) &escontext);
2240 : :
2241 [ + + ]: 284 : if (escontext.error_occurred)
2242 : : {
128 tgl@sss.pgh.pa.us 2243 : 8 : JsonValueListClear(&lseq);
2244 : 8 : JsonValueListClear(&rseq);
2688 akorotkov@postgresql 2245 : 8 : return jperError;
2246 : : }
2247 : : }
2248 : :
128 tgl@sss.pgh.pa.us 2249 : 328 : JsonValueListClear(&lseq);
2250 : 328 : JsonValueListClear(&rseq);
2251 : :
2688 akorotkov@postgresql 2252 [ + + + + ]: 328 : if (!jspGetNext(jsp, &elem) && !found)
2253 : 5 : return jperOk;
2254 : :
128 tgl@sss.pgh.pa.us 2255 : 323 : resval.type = jbvNumeric;
2256 : 323 : resval.val.numeric = res;
2257 : :
2258 : 323 : 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 : : */
2265 : : static JsonPathExecResult
2688 akorotkov@postgresql 2266 : 148 : executeUnaryArithmExpr(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 : :
128 tgl@sss.pgh.pa.us 2277 : 148 : JsonValueListInit(&seq);
2278 : :
2688 akorotkov@postgresql 2279 : 148 : jspGetArg(jsp, &elem);
2280 : 148 : jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &seq);
2281 : :
2282 [ - + ]: 144 : if (jperIsError(jper))
128 tgl@sss.pgh.pa.us 2283 :UBC 0 : goto exit;
2284 : :
2688 akorotkov@postgresql 2285 :CBC 144 : jper = jperNotFound;
2286 : :
2287 : 144 : hasNext = jspGetNext(jsp, &elem);
2288 : :
2289 : 144 : JsonValueListInitIterator(&seq, &it);
128 tgl@sss.pgh.pa.us 2290 [ + + ]: 258 : while ((val = JsonValueListNext(&it)))
2291 : : {
2688 akorotkov@postgresql 2292 [ + + ]: 150 : if ((val = getScalar(val, jbvNumeric)))
2293 : : {
2294 [ + + + - ]: 119 : if (!found && !hasNext)
2295 : : {
128 tgl@sss.pgh.pa.us 2296 : 10 : jper = jperOk;
2297 : 10 : goto exit;
2298 : : }
2299 : : }
2300 : : else
2301 : : {
2688 akorotkov@postgresql 2302 [ + + + - ]: 31 : if (!found && !hasNext)
2303 : 5 : continue; /* skip non-numerics processing */
2304 : :
128 tgl@sss.pgh.pa.us 2305 : 26 : JsonValueListClear(&seq);
2688 akorotkov@postgresql 2306 [ + + + - ]: 26 : 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 [ + + ]: 109 : if (func)
2313 : 66 : val->val.numeric =
2314 : 66 : DatumGetNumeric(DirectFunctionCall1(func,
2315 : : NumericGetDatum(val->val.numeric)));
2316 : :
128 tgl@sss.pgh.pa.us 2317 : 109 : jper2 = executeNextItem(cxt, jsp, &elem, val, found);
2318 : :
2688 akorotkov@postgresql 2319 [ - + ]: 109 : if (jperIsError(jper2))
2320 : : {
128 tgl@sss.pgh.pa.us 2321 :UBC 0 : jper = jper2;
2322 : 0 : goto exit;
2323 : : }
2324 : :
2688 akorotkov@postgresql 2325 [ + - ]:CBC 109 : if (jper2 == jperOk)
2326 : : {
2327 : 109 : jper = jperOk;
128 tgl@sss.pgh.pa.us 2328 [ - + ]: 109 : if (!found)
128 tgl@sss.pgh.pa.us 2329 :UBC 0 : goto exit;
2330 : : }
2331 : : }
2332 : :
128 tgl@sss.pgh.pa.us 2333 :CBC 108 : exit:
2334 : 118 : JsonValueListClear(&seq);
2335 : :
2688 akorotkov@postgresql 2336 : 118 : return jper;
2337 : : }
2338 : :
2339 : : /*
2340 : : * STARTS_WITH predicate callback.
2341 : : *
2342 : : * Check if the 'whole' string starts from 'initial' string.
2343 : : */
2344 : : static JsonPathBool
2345 : 128 : executeStartsWith(JsonPathItem *jsp, JsonbValue *whole, JsonbValue *initial,
2346 : : void *param)
2347 : : {
2348 [ + + ]: 128 : if (!(whole = getScalar(whole, jbvString)))
2349 : 32 : return jpbUnknown; /* error */
2350 : :
2351 [ - + ]: 96 : if (!(initial = getScalar(initial, jbvString)))
2688 akorotkov@postgresql 2352 :UBC 0 : return jpbUnknown; /* error */
2353 : :
2688 akorotkov@postgresql 2354 [ + + ]:CBC 96 : if (whole->val.string.len >= initial->val.string.len &&
2355 : 72 : !memcmp(whole->val.string.val,
2356 : 72 : initial->val.string.val,
2357 [ + + ]: 72 : initial->val.string.len))
2358 : 48 : return jpbTrue;
2359 : :
2360 : 48 : return jpbFalse;
2361 : : }
2362 : :
2363 : : /*
2364 : : * LIKE_REGEX predicate callback.
2365 : : *
2366 : : * Check if the string matches regex pattern.
2367 : : */
2368 : : static JsonPathBool
2369 : 264 : executeLikeRegex(JsonPathItem *jsp, JsonbValue *str, JsonbValue *rarg,
2370 : : void *param)
2371 : : {
2372 : 264 : JsonLikeRegexContext *cxt = param;
2373 : :
2374 [ + + ]: 264 : if (!(str = getScalar(str, jbvString)))
2375 : 80 : return jpbUnknown;
2376 : :
2377 : : /* Cache regex text and converted flags. */
2378 [ + - ]: 184 : if (!cxt->regex)
2379 : : {
2380 : 184 : cxt->regex =
2381 : 184 : cstring_to_text_with_len(jsp->content.like_regex.pattern,
2382 : : jsp->content.like_regex.patternlen);
1309 andrew@dunslane.net 2383 : 184 : (void) jspConvertRegexFlags(jsp->content.like_regex.flags,
2384 : : &(cxt->cflags), NULL);
2385 : : }
2386 : :
2688 akorotkov@postgresql 2387 [ + + ]: 184 : 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 : 68 : return jpbTrue;
2391 : :
2392 : 116 : return jpbFalse;
2393 : : }
2394 : :
2395 : : /*
2396 : : * Execute numeric item methods (.abs(), .floor(), .ceil()) using the specified
2397 : : * user function 'func'.
2398 : : */
2399 : : static JsonPathExecResult
2400 : 172 : executeNumericItemMethod(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 [ + - - + ]: 172 : if (unwrap && JsonbType(jb) == jbvArray)
2688 akorotkov@postgresql 2409 :UBC 0 : return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false);
2410 : :
2688 akorotkov@postgresql 2411 [ + + ]:CBC 172 : if (!(jb = getScalar(jb, jbvNumeric)))
2412 [ + + + - ]: 24 : 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 : :
2645 tgl@sss.pgh.pa.us 2417 : 148 : datum = DirectFunctionCall1(func, NumericGetDatum(jb->val.numeric));
2418 : :
2688 akorotkov@postgresql 2419 [ + + - + ]: 148 : if (!jspGetNext(jsp, &next) && !found)
2688 akorotkov@postgresql 2420 :UBC 0 : return jperOk;
2421 : :
128 tgl@sss.pgh.pa.us 2422 :CBC 148 : jbv.type = jbvNumeric;
2423 : 148 : jbv.val.numeric = DatumGetNumeric(datum);
2424 : :
2425 : 148 : 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 : : */
2440 : : static JsonPathExecResult
2495 akorotkov@postgresql 2441 : 5662 : executeDateTimeMethod(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 : 5662 : int32 typmod = -1;
2450 : 5662 : int tz = 0;
2451 : : bool hasNext;
2452 : 5662 : JsonPathExecResult res = jperNotFound;
2453 : : JsonPathItem elem;
912 andrew@dunslane.net 2454 : 5662 : int32 time_precision = -1;
2455 : :
2495 akorotkov@postgresql 2456 [ + + ]: 5662 : if (!(jb = getScalar(jb, jbvString)))
2457 [ + - + - ]: 120 : 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 : 5542 : 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 : : */
2335 tgl@sss.pgh.pa.us 2470 : 5542 : 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 : : */
912 andrew@dunslane.net 2476 [ + + + + ]: 5542 : if (jsp->type == jpiDatetime && jsp->content.arg)
2495 akorotkov@postgresql 2477 : 1061 : {
2478 : : text *template;
2479 : : char *template_str;
2480 : : int template_len;
1324 tgl@sss.pgh.pa.us 2481 : 1101 : ErrorSaveContext escontext = {T_ErrorSaveContext};
2482 : :
2495 akorotkov@postgresql 2483 : 1101 : jspGetArg(jsp, &elem);
2484 : :
2485 [ - + ]: 1101 : if (elem.type != jpiString)
2495 akorotkov@postgresql 2486 [ # # ]:UBC 0 : elog(ERROR, "invalid jsonpath item type for .datetime() argument");
2487 : :
2495 akorotkov@postgresql 2488 :CBC 1101 : template_str = jspGetString(&elem, &template_len);
2489 : :
2490 : 1101 : template = cstring_to_text_with_len(template_str,
2491 : : template_len);
2492 : :
2335 tgl@sss.pgh.pa.us 2493 : 1101 : value = parse_datetime(datetime, template, collid, true,
2494 : : &typid, &typmod, &tz,
1324 2495 [ + + ]: 1101 : jspThrowErrors(cxt) ? NULL : (Node *) &escontext);
2496 : :
2497 [ - + ]: 1061 : if (escontext.error_occurred)
2495 akorotkov@postgresql 2498 :UBC 0 : res = jperError;
2499 : : else
2495 akorotkov@postgresql 2500 :CBC 1061 : 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 : : */
912 andrew@dunslane.net 2535 [ + + + + ]: 4441 : if (jsp->type != jpiDatetime && jsp->type != jpiDate &&
2536 [ + + ]: 2468 : jsp->content.arg)
2537 : : {
323 michael@paquier.xyz 2538 : 520 : ErrorSaveContext escontext = {T_ErrorSaveContext};
2539 : :
912 andrew@dunslane.net 2540 : 520 : jspGetArg(jsp, &elem);
2541 : :
2542 [ - + ]: 520 : if (elem.type != jpiNumeric)
912 andrew@dunslane.net 2543 [ # # ]:UBC 0 : elog(ERROR, "invalid jsonpath item type for %s argument",
2544 : : jspOperationName(jsp->type));
2545 : :
323 michael@paquier.xyz 2546 :CBC 520 : time_precision = numeric_int4_safe(jspGetNumeric(&elem),
2547 : : (Node *) &escontext);
2548 [ + + ]: 520 : if (escontext.error_occurred)
912 andrew@dunslane.net 2549 [ + - + - ]: 16 : 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 */
14 peter@eisentraut.org 2556 [ + + ]:GNC 25175 : for (size_t i = 0; i < lengthof(fmt_str); i++)
2557 : : {
1324 tgl@sss.pgh.pa.us 2558 :CBC 25143 : ErrorSaveContext escontext = {T_ErrorSaveContext};
2559 : :
2495 akorotkov@postgresql 2560 [ + + ]: 25143 : if (!fmt_txt[i])
2561 : : {
2562 : : MemoryContext oldcxt =
1163 tgl@sss.pgh.pa.us 2563 : 52 : MemoryContextSwitchTo(TopMemoryContext);
2564 : :
2495 akorotkov@postgresql 2565 : 52 : fmt_txt[i] = cstring_to_text(fmt_str[i]);
2566 : 52 : MemoryContextSwitchTo(oldcxt);
2567 : : }
2568 : :
2335 tgl@sss.pgh.pa.us 2569 : 25143 : value = parse_datetime(datetime, fmt_txt[i], collid, true,
2570 : : &typid, &typmod, &tz,
2571 : : (Node *) &escontext);
2572 : :
1324 2573 [ + + ]: 25143 : if (!escontext.error_occurred)
2574 : : {
2495 akorotkov@postgresql 2575 : 4393 : res = jperOk;
2576 : 4393 : break;
2577 : : }
2578 : : }
2579 : :
2580 [ + + ]: 4425 : if (res == jperNotFound)
2581 : : {
912 andrew@dunslane.net 2582 [ + + ]: 32 : if (jsp->type == jpiDatetime)
2583 [ + - + - ]: 12 : 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 [ + - + - ]: 20 : 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 [ + + + + : 5454 : switch (jsp->type)
+ + - ]
2604 : : {
2605 : 2597 : case jpiDatetime: /* Nothing to do for DATETIME */
2606 : 2597 : break;
2607 : 421 : case jpiDate:
2608 : : {
2609 : : /* Convert result type to date */
2610 [ + + + + : 421 : switch (typid)
- ]
2611 : : {
2612 : 317 : case DATEOID: /* Nothing to do for DATE */
2613 : 317 : break;
2614 : 8 : case TIMEOID:
2615 : : case TIMETZOID:
2616 [ + - + - ]: 8 : 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 : 52 : case TIMESTAMPOID:
2622 : 52 : value = DirectFunctionCall1(timestamp_date,
2623 : : value);
2624 : 52 : break;
2625 : 44 : case TIMESTAMPTZOID:
896 2626 : 44 : checkTimezoneIsUsedForCast(cxt->useTz,
2627 : : "timestamptz", "date");
912 2628 : 28 : value = DirectFunctionCall1(timestamptz_date,
2629 : : value);
2630 : 28 : break;
912 andrew@dunslane.net 2631 :UBC 0 : default:
907 peter@eisentraut.org 2632 [ # # ]: 0 : elog(ERROR, "type with oid %u not supported", typid);
2633 : : }
2634 : :
912 andrew@dunslane.net 2635 :CBC 397 : typid = DATEOID;
2636 : : }
2637 : 397 : break;
2638 : 541 : case jpiTime:
2639 : : {
2640 : : /* Convert result type to time without time zone */
2641 [ + + + + : 541 : switch (typid)
+ - ]
2642 : : {
2643 : 4 : case DATEOID:
2644 [ + - + - ]: 4 : 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 : 405 : case TIMEOID: /* Nothing to do for TIME */
2650 : 405 : break;
2651 : 72 : case TIMETZOID:
896 2652 : 72 : checkTimezoneIsUsedForCast(cxt->useTz,
2653 : : "timetz", "time");
912 2654 : 52 : value = DirectFunctionCall1(timetz_time,
2655 : : value);
2656 : 52 : break;
2657 : 20 : case TIMESTAMPOID:
2658 : 20 : value = DirectFunctionCall1(timestamp_time,
2659 : : value);
2660 : 20 : break;
2661 : 40 : case TIMESTAMPTZOID:
896 2662 : 40 : checkTimezoneIsUsedForCast(cxt->useTz,
2663 : : "timestamptz", "time");
912 2664 : 28 : value = DirectFunctionCall1(timestamptz_time,
2665 : : value);
2666 : 28 : break;
912 andrew@dunslane.net 2667 :UBC 0 : default:
907 peter@eisentraut.org 2668 [ # # ]: 0 : elog(ERROR, "type with oid %u not supported", typid);
2669 : : }
2670 : :
2671 : : /* Force the user-given time precision, if any */
912 andrew@dunslane.net 2672 [ + + ]:CBC 505 : if (time_precision != -1)
2673 : : {
2674 : : TimeADT result;
2675 : :
2676 : : /* Get a warning when precision is reduced */
2677 : 108 : time_precision = anytime_typmod_check(false,
2678 : : time_precision);
2679 : 108 : result = DatumGetTimeADT(value);
2680 : 108 : AdjustTimeForTypmod(&result, time_precision);
2681 : 108 : value = TimeADTGetDatum(result);
2682 : :
2683 : : /* Update the typmod value with the user-given precision */
2684 : 108 : typmod = time_precision;
2685 : : }
2686 : :
2687 : 505 : typid = TIMEOID;
2688 : : }
2689 : 505 : break;
2690 : 641 : case jpiTimeTz:
2691 : : {
2692 : : /* Convert result type to time with time zone */
2693 [ + + + + : 641 : switch (typid)
- ]
2694 : : {
2695 : 8 : case DATEOID:
2696 : : case TIMESTAMPOID:
2697 [ + - + - ]: 8 : 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 : 76 : case TIMEOID:
896 2703 : 76 : checkTimezoneIsUsedForCast(cxt->useTz,
2704 : : "time", "timetz");
912 2705 : 56 : value = DirectFunctionCall1(time_timetz,
2706 : : value);
2707 : 56 : break;
2708 : 529 : case TIMETZOID: /* Nothing to do for TIMETZ */
2709 : 529 : break;
2710 : 28 : case TIMESTAMPTZOID:
2711 : 28 : value = DirectFunctionCall1(timestamptz_timetz,
2712 : : value);
2713 : 28 : break;
912 andrew@dunslane.net 2714 :UBC 0 : default:
907 peter@eisentraut.org 2715 [ # # ]: 0 : elog(ERROR, "type with oid %u not supported", typid);
2716 : : }
2717 : :
2718 : : /* Force the user-given time precision, if any */
912 andrew@dunslane.net 2719 [ + + ]:CBC 613 : if (time_precision != -1)
2720 : : {
2721 : : TimeTzADT *result;
2722 : :
2723 : : /* Get a warning when precision is reduced */
2724 : 132 : time_precision = anytime_typmod_check(true,
2725 : : time_precision);
2726 : 132 : result = DatumGetTimeTzADTP(value);
2727 : 132 : AdjustTimeForTypmod(&result->time, time_precision);
2728 : 132 : value = TimeTzADTPGetDatum(result);
2729 : :
2730 : : /* Update the typmod value with the user-given precision */
2731 : 132 : typmod = time_precision;
2732 : : }
2733 : :
2734 : 613 : typid = TIMETZOID;
2735 : : }
2736 : 613 : break;
2737 : 549 : case jpiTimestamp:
2738 : : {
2739 : : /* Convert result type to timestamp without time zone */
2740 [ + + + + : 549 : switch (typid)
- ]
2741 : : {
2742 : 36 : case DATEOID:
2743 : 36 : value = DirectFunctionCall1(date_timestamp,
2744 : : value);
2745 : 36 : break;
2746 : 8 : case TIMEOID:
2747 : : case TIMETZOID:
2748 [ + - + - ]: 8 : 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 : 409 : case TIMESTAMPOID: /* Nothing to do for TIMESTAMP */
2754 : 409 : break;
2755 : 96 : case TIMESTAMPTZOID:
896 2756 : 96 : checkTimezoneIsUsedForCast(cxt->useTz,
2757 : : "timestamptz", "timestamp");
912 2758 : 64 : value = DirectFunctionCall1(timestamptz_timestamp,
2759 : : value);
2760 : 64 : break;
912 andrew@dunslane.net 2761 :UBC 0 : default:
907 peter@eisentraut.org 2762 [ # # ]: 0 : elog(ERROR, "type with oid %u not supported", typid);
2763 : : }
2764 : :
2765 : : /* Force the user-given time precision, if any */
912 andrew@dunslane.net 2766 [ + + ]:CBC 509 : if (time_precision != -1)
2767 : : {
2768 : : Timestamp result;
2769 : 108 : ErrorSaveContext escontext = {T_ErrorSaveContext};
2770 : :
2771 : : /* Get a warning when precision is reduced */
2772 : 108 : time_precision = anytimestamp_typmod_check(false,
2773 : : time_precision);
2774 : 108 : result = DatumGetTimestamp(value);
2775 : 108 : AdjustTimestampForTypmod(&result, time_precision,
2776 : : (Node *) &escontext);
879 2777 [ - + ]: 108 : if (escontext.error_occurred) /* should not happen */
912 andrew@dunslane.net 2778 [ # # # # ]:UBC 0 : 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)))));
912 andrew@dunslane.net 2782 :CBC 108 : value = TimestampGetDatum(result);
2783 : :
2784 : : /* Update the typmod value with the user-given precision */
2785 : 108 : typmod = time_precision;
2786 : : }
2787 : :
2788 : 509 : typid = TIMESTAMPOID;
2789 : : }
2790 : 509 : break;
2791 : 705 : case jpiTimestampTz:
2792 : : {
2793 : : struct pg_tm tm;
2794 : : fsec_t fsec;
2795 : :
2796 : : /* Convert result type to timestamp with time zone */
2797 [ + + + + : 705 : switch (typid)
- ]
2798 : : {
2799 : 40 : case DATEOID:
896 2800 : 40 : checkTimezoneIsUsedForCast(cxt->useTz,
2801 : : "date", "timestamptz");
2802 : :
2803 : : /*
2804 : : * Get the timezone value explicitly since JsonbValue
2805 : : * keeps that separate.
2806 : : */
725 2807 : 36 : j2date(DatumGetDateADT(value) + POSTGRES_EPOCH_JDATE,
2808 : : &(tm.tm_year), &(tm.tm_mon), &(tm.tm_mday));
2809 : 36 : tm.tm_hour = 0;
2810 : 36 : tm.tm_min = 0;
2811 : 36 : tm.tm_sec = 0;
2812 : 36 : tz = DetermineTimeZoneOffset(&tm, session_timezone);
2813 : :
912 2814 : 36 : value = DirectFunctionCall1(date_timestamptz,
2815 : : value);
2816 : 36 : break;
2817 : 8 : case TIMEOID:
2818 : : case TIMETZOID:
2819 [ + - + - ]: 8 : 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 : 88 : case TIMESTAMPOID:
896 2825 : 88 : checkTimezoneIsUsedForCast(cxt->useTz,
2826 : : "timestamp", "timestamptz");
2827 : :
2828 : : /*
2829 : : * Get the timezone value explicitly since JsonbValue
2830 : : * keeps that separate.
2831 : : */
725 2832 [ + - ]: 60 : if (timestamp2tm(DatumGetTimestamp(value), NULL, &tm,
2833 : : &fsec, NULL, NULL) == 0)
2834 : 60 : tz = DetermineTimeZoneOffset(&tm,
2835 : : session_timezone);
2836 : :
912 2837 : 60 : value = DirectFunctionCall1(timestamp_timestamptz,
2838 : : value);
2839 : 60 : break;
2840 : 569 : case TIMESTAMPTZOID: /* Nothing to do for TIMESTAMPTZ */
2841 : 569 : break;
912 andrew@dunslane.net 2842 :UBC 0 : default:
907 peter@eisentraut.org 2843 [ # # ]: 0 : elog(ERROR, "type with oid %u not supported", typid);
2844 : : }
2845 : :
2846 : : /* Force the user-given time precision, if any */
912 andrew@dunslane.net 2847 [ + + ]:CBC 665 : if (time_precision != -1)
2848 : : {
2849 : : Timestamp result;
2850 : 140 : ErrorSaveContext escontext = {T_ErrorSaveContext};
2851 : :
2852 : : /* Get a warning when precision is reduced */
2853 : 140 : time_precision = anytimestamp_typmod_check(true,
2854 : : time_precision);
2855 : 140 : result = DatumGetTimestampTz(value);
2856 : 140 : AdjustTimestampForTypmod(&result, time_precision,
2857 : : (Node *) &escontext);
879 2858 [ - + ]: 140 : if (escontext.error_occurred) /* should not happen */
912 andrew@dunslane.net 2859 [ # # # # ]:UBC 0 : 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)))));
912 andrew@dunslane.net 2863 :CBC 140 : value = TimestampTzGetDatum(result);
2864 : :
2865 : : /* Update the typmod value with the user-given precision */
2866 : 140 : typmod = time_precision;
2867 : : }
2868 : :
2869 : 665 : typid = TIMESTAMPTZOID;
2870 : : }
2871 : 665 : break;
912 andrew@dunslane.net 2872 :UBC 0 : default:
2873 [ # # ]: 0 : elog(ERROR, "unrecognized jsonpath item type: %d", jsp->type);
2874 : : }
2875 : :
2495 akorotkov@postgresql 2876 :CBC 5286 : pfree(datetime);
2877 : :
2878 [ - + ]: 5286 : if (jperIsError(res))
2495 akorotkov@postgresql 2879 :UBC 0 : return res;
2880 : :
2495 akorotkov@postgresql 2881 :CBC 5286 : hasNext = jspGetNext(jsp, &elem);
2882 : :
2883 [ + + + + ]: 5286 : if (!hasNext && !found)
2884 : 30 : return res;
2885 : :
128 tgl@sss.pgh.pa.us 2886 : 5256 : jbv.type = jbvDatetime;
2887 : 5256 : jbv.val.datetime.value = value;
2888 : 5256 : jbv.val.datetime.typid = typid;
2889 : 5256 : jbv.val.datetime.typmod = typmod;
2890 : 5256 : jbv.val.datetime.tz = tz;
2891 : :
2892 : 5256 : 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 : : */
2899 : : static JsonPathExecResult
114 andrew@dunslane.net 2900 : 486 : executeStringInternalMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
2901 : : JsonbValue *jb, JsonValueList *found)
2902 : : {
2903 : : JsonbValue jbv;
2904 : : bool hasNext;
2905 : 486 : 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 : 486 : char *resStr = NULL;
2911 : :
2912 [ + + + + : 486 : 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 [ + + ]: 486 : if (!(jb = getScalar(jb, jbvString)))
2922 [ + + + - ]: 200 : 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 : 286 : 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 [ + + + + : 286 : switch (jsp->type)
+ + - ]
2931 : : {
2932 : 40 : case jpiStrReplace:
2933 : : {
2934 : : char *from_str,
2935 : : *to_str;
2936 : :
2937 : 40 : jspGetLeftArg(jsp, &elem);
2938 [ - + ]: 40 : if (elem.type != jpiString)
114 andrew@dunslane.net 2939 [ # # ]:UBC 0 : elog(ERROR, "invalid jsonpath item type for .replace() from");
2940 : :
114 andrew@dunslane.net 2941 :CBC 40 : from_str = jspGetString(&elem, NULL);
2942 : :
2943 : 40 : jspGetRightArg(jsp, &elem);
2944 [ - + ]: 40 : if (elem.type != jpiString)
114 andrew@dunslane.net 2945 [ # # ]:UBC 0 : elog(ERROR, "invalid jsonpath item type for .replace() to");
2946 : :
114 andrew@dunslane.net 2947 :CBC 40 : to_str = jspGetString(&elem, NULL);
2948 : :
2949 : 40 : resStr = TextDatumGetCString(DirectFunctionCall3Coll(replace_text,
2950 : : DEFAULT_COLLATION_OID,
2951 : : str,
2952 : : CStringGetTextDatum(from_str),
2953 : : CStringGetTextDatum(to_str)));
2954 : 40 : break;
2955 : : }
2956 : 66 : case jpiStrLower:
2957 : 66 : resStr = TextDatumGetCString(DirectFunctionCall1Coll(lower, DEFAULT_COLLATION_OID, str));
2958 : 66 : break;
2959 : 62 : case jpiStrUpper:
2960 : 62 : resStr = TextDatumGetCString(DirectFunctionCall1Coll(upper, DEFAULT_COLLATION_OID, str));
2961 : 62 : break;
2962 : 78 : case jpiStrLtrim:
2963 : : case jpiStrRtrim:
2964 : : case jpiStrBtrim:
2965 : : {
2966 : 78 : PGFunction func1 = NULL;
2967 : 78 : PGFunction func2 = NULL;
2968 : :
2969 [ + + + - ]: 78 : switch (jsp->type)
2970 : : {
2971 : 50 : case jpiStrLtrim:
2972 : 50 : func1 = ltrim1;
2973 : 50 : func2 = ltrim;
2974 : 50 : break;
2975 : 12 : case jpiStrRtrim:
2976 : 12 : func1 = rtrim1;
2977 : 12 : func2 = rtrim;
2978 : 12 : break;
2979 : 16 : case jpiStrBtrim:
2980 : 16 : func1 = btrim1;
2981 : 16 : func2 = btrim;
2982 : 16 : break;
114 andrew@dunslane.net 2983 :UBC 0 : default:
2984 : 0 : break;
2985 : : }
2986 : :
114 andrew@dunslane.net 2987 [ + + ]:CBC 78 : if (jsp->content.arg)
2988 : : {
2989 : : char *characters_str;
2990 : :
2991 : 24 : jspGetArg(jsp, &elem);
2992 [ - + ]: 24 : if (elem.type != jpiString)
114 andrew@dunslane.net 2993 [ # # ]:UBC 0 : elog(ERROR, "invalid jsonpath item type for .%s() argument",
2994 : : jspOperationName(jsp->type));
2995 : :
114 andrew@dunslane.net 2996 :CBC 24 : characters_str = jspGetString(&elem, NULL);
2997 : 24 : resStr = TextDatumGetCString(DirectFunctionCall2Coll(func2,
2998 : : DEFAULT_COLLATION_OID, str,
2999 : : CStringGetTextDatum(characters_str)));
3000 : : }
3001 : : else
3002 : : {
3003 : 54 : resStr = TextDatumGetCString(DirectFunctionCall1Coll(func1,
3004 : : DEFAULT_COLLATION_OID, str));
3005 : : }
3006 : 78 : break;
3007 : : }
3008 : :
3009 : 16 : case jpiStrInitcap:
3010 : 16 : resStr = TextDatumGetCString(DirectFunctionCall1Coll(initcap, DEFAULT_COLLATION_OID, str));
3011 : 16 : break;
3012 : 24 : case jpiStrSplitPart:
3013 : : {
3014 : : char *from_str;
3015 : : int32 n;
72 michael@paquier.xyz 3016 : 24 : ErrorSaveContext escontext = {T_ErrorSaveContext};
3017 : :
114 andrew@dunslane.net 3018 : 24 : jspGetLeftArg(jsp, &elem);
3019 [ - + ]: 24 : if (elem.type != jpiString)
114 andrew@dunslane.net 3020 [ # # ]:UBC 0 : elog(ERROR, "invalid jsonpath item type for .split_part()");
3021 : :
114 andrew@dunslane.net 3022 :CBC 24 : from_str = jspGetString(&elem, NULL);
3023 : :
3024 : 24 : jspGetRightArg(jsp, &elem);
3025 [ - + ]: 24 : if (elem.type != jpiNumeric)
114 andrew@dunslane.net 3026 [ # # ]:UBC 0 : elog(ERROR, "invalid jsonpath item type for .split_part()");
3027 : :
72 michael@paquier.xyz 3028 :CBC 24 : n = numeric_int4_safe(jspGetNumeric(&elem),
3029 : : (Node *) &escontext);
3030 [ + + ]: 24 : if (escontext.error_occurred)
3031 [ + + + - ]: 12 : 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 [ + + ]: 16 : if (n == 0)
3037 [ + + + - ]: 8 : 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 : :
114 andrew@dunslane.net 3042 : 8 : resStr = TextDatumGetCString(DirectFunctionCall3Coll(split_part,
3043 : : DEFAULT_COLLATION_OID,
3044 : : str,
3045 : : CStringGetTextDatum(from_str),
3046 : : Int32GetDatum(n)));
3047 : 8 : break;
3048 : : }
114 andrew@dunslane.net 3049 :UBC 0 : default:
3050 [ # # ]: 0 : elog(ERROR, "unsupported jsonpath item type: %d", jsp->type);
3051 : : }
3052 : :
114 andrew@dunslane.net 3053 [ + - ]:CBC 270 : if (resStr)
3054 : 270 : res = jperOk;
3055 : :
3056 : 270 : hasNext = jspGetNext(jsp, &elem);
3057 : :
3058 [ + + - + ]: 270 : if (!hasNext && !found)
114 andrew@dunslane.net 3059 :UBC 0 : return res;
3060 : :
114 andrew@dunslane.net 3061 :CBC 270 : jbv.type = jbvString;
3062 : 270 : jbv.val.string.val = resStr;
3063 : 270 : jbv.val.string.len = strlen(resStr);
3064 : :
3065 : 270 : 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 : : */
3091 : : static JsonPathExecResult
2688 akorotkov@postgresql 3092 : 58 : executeKeyValueMethod(JsonPathExecContext *cxt, JsonPathItem *jsp,
3093 : : JsonbValue *jb, JsonValueList *found)
3094 : : {
3095 : 58 : 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 [ + + - + ]: 58 : if (JsonbType(jb) != jbvObject || jb->type != jbvBinary)
3110 [ + + + - ]: 16 : 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 : 42 : jbc = jb->val.binary.data;
3116 : :
3117 [ + + ]: 42 : if (!JsonContainerSize(jbc))
3118 : 12 : return jperNotFound; /* no key-value pairs */
3119 : :
3120 : 30 : hasNext = jspGetNext(jsp, &next);
3121 : :
3122 : 30 : keystr.type = jbvString;
3123 : 30 : keystr.val.string.val = "key";
3124 : 30 : keystr.val.string.len = 3;
3125 : :
3126 : 30 : valstr.type = jbvString;
3127 : 30 : valstr.val.string.val = "value";
3128 : 30 : valstr.val.string.len = 5;
3129 : :
3130 : 30 : idstr.type = jbvString;
3131 : 30 : idstr.val.string.val = "id";
3132 : 30 : idstr.val.string.len = 2;
3133 : :
3134 : : /* construct object id from its base object and offset inside that */
3135 [ + - ]: 30 : id = jb->type != jbvBinary ? 0 :
3136 : 30 : (int64) ((char *) jbc - (char *) cxt->baseObject.jbc);
3137 : 30 : id += (int64) cxt->baseObject.id * INT64CONST(10000000000);
3138 : :
3139 : 30 : idval.type = jbvNumeric;
2145 peter@eisentraut.org 3140 : 30 : idval.val.numeric = int64_to_numeric(id);
3141 : :
2688 akorotkov@postgresql 3142 : 30 : it = JsonbIteratorInit(jbc);
3143 : :
3144 [ + + ]: 116 : while ((tok = JsonbIteratorNext(&it, &key, true)) != WJB_DONE)
3145 : : {
3146 : : JsonBaseObjectInfo baseObject;
3147 : : JsonbValue obj;
3148 : : JsonbInState ps;
3149 : : Jsonb *jsonb;
3150 : :
3151 [ + + ]: 96 : if (tok != WJB_KEY)
3152 : 50 : continue;
3153 : :
3154 : 46 : res = jperOk;
3155 : :
3156 [ + + + + ]: 46 : if (!hasNext && !found)
3157 : 10 : break;
3158 : :
3159 : 41 : tok = JsonbIteratorNext(&it, &val, true);
3160 [ - + ]: 41 : Assert(tok == WJB_VALUE);
3161 : :
230 tgl@sss.pgh.pa.us 3162 : 41 : memset(&ps, 0, sizeof(ps));
3163 : :
2688 akorotkov@postgresql 3164 : 41 : pushJsonbValue(&ps, WJB_BEGIN_OBJECT, NULL);
3165 : :
3166 : 41 : pushJsonbValue(&ps, WJB_KEY, &keystr);
3167 : 41 : pushJsonbValue(&ps, WJB_VALUE, &key);
3168 : :
3169 : 41 : pushJsonbValue(&ps, WJB_KEY, &valstr);
3170 : 41 : pushJsonbValue(&ps, WJB_VALUE, &val);
3171 : :
3172 : 41 : pushJsonbValue(&ps, WJB_KEY, &idstr);
3173 : 41 : pushJsonbValue(&ps, WJB_VALUE, &idval);
3174 : :
230 tgl@sss.pgh.pa.us 3175 : 41 : pushJsonbValue(&ps, WJB_END_OBJECT, NULL);
3176 : :
3177 : 41 : jsonb = JsonbValueToJsonb(ps.result);
3178 : :
2688 akorotkov@postgresql 3179 : 41 : JsonbInitBinary(&obj, jsonb);
3180 : :
3181 : 41 : baseObject = setBaseObject(cxt, &obj, cxt->lastGeneratedObjectId++);
3182 : :
128 tgl@sss.pgh.pa.us 3183 : 41 : res = executeNextItem(cxt, jsp, &next, &obj, found);
3184 : :
2688 akorotkov@postgresql 3185 : 41 : cxt->baseObject = baseObject;
3186 : :
3187 [ - + ]: 41 : if (jperIsError(res))
2688 akorotkov@postgresql 3188 :UBC 0 : return res;
3189 : :
2688 akorotkov@postgresql 3190 [ + - + + ]:CBC 41 : if (res == jperOk && !found)
3191 : 5 : break;
3192 : : }
3193 : :
3194 : 30 : return res;
3195 : : }
3196 : :
3197 : : /*
3198 : : * Convert boolean execution status 'res' to a boolean JSON item and execute
3199 : : * next jsonpath.
3200 : : */
3201 : : static JsonPathExecResult
3202 : 71270 : appendBoolResult(JsonPathExecContext *cxt, JsonPathItem *jsp,
3203 : : JsonValueList *found, JsonPathBool res)
3204 : : {
3205 : : JsonPathItem next;
3206 : : JsonbValue jbv;
3207 : :
3208 [ + + + + ]: 71270 : if (!jspGetNext(jsp, &next) && !found)
3209 : 13 : return jperOk; /* found singleton boolean value */
3210 : :
3211 [ + + ]: 71257 : if (res == jpbUnknown)
3212 : : {
3213 : 23 : jbv.type = jbvNull;
3214 : : }
3215 : : else
3216 : : {
3217 : 71234 : jbv.type = jbvBool;
3218 : 71234 : jbv.val.boolean = res == jpbTrue;
3219 : : }
3220 : :
128 tgl@sss.pgh.pa.us 3221 : 71257 : 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 : : */
3229 : : static void
2688 akorotkov@postgresql 3230 : 43356 : getJsonPathItem(JsonPathExecContext *cxt, JsonPathItem *item,
3231 : : JsonbValue *value)
3232 : : {
3233 [ + + + + : 43356 : switch (item->type)
+ - ]
3234 : : {
3235 : 5631 : case jpiNull:
3236 : 5631 : value->type = jbvNull;
3237 : 5631 : break;
3238 : 954 : case jpiBool:
3239 : 954 : value->type = jbvBool;
3240 : 954 : value->val.boolean = jspGetBool(item);
3241 : 954 : break;
3242 : 13936 : case jpiNumeric:
3243 : 13936 : value->type = jbvNumeric;
3244 : 13936 : value->val.numeric = jspGetNumeric(item);
3245 : 13936 : break;
3246 : 17559 : case jpiString:
3247 : 17559 : value->type = jbvString;
3248 : 35118 : value->val.string.val = jspGetString(item,
3249 : 17559 : &value->val.string.len);
3250 : 17559 : break;
3251 : 5276 : case jpiVariable:
913 amitlan@postgresql.o 3252 : 5276 : getJsonPathVariable(cxt, item, value);
2688 akorotkov@postgresql 3253 : 5244 : return;
2688 akorotkov@postgresql 3254 :UBC 0 : default:
3255 [ # # ]: 0 : elog(ERROR, "unexpected jsonpath item type");
3256 : : }
3257 : : }
3258 : :
3259 : : /*
3260 : : * Returns the computed value of a JSON path variable with given name.
3261 : : */
3262 : : static JsonbValue *
856 amitlan@postgresql.o 3263 :CBC 1740 : GetJsonPathVar(void *cxt, char *varName, int varNameLen,
3264 : : JsonbValue *baseObject, int *baseObjectId)
3265 : : {
3266 : 1740 : JsonPathVariable *var = NULL;
3267 : 1740 : List *vars = cxt;
3268 : : ListCell *lc;
3269 : : JsonbValue *result;
3270 : 1740 : int id = 1;
3271 : :
3272 [ + - + + : 2504 : foreach(lc, vars)
+ + ]
3273 : : {
3274 : 2492 : JsonPathVariable *curvar = lfirst(lc);
3275 : :
766 3276 [ + + ]: 2492 : if (curvar->namelen == varNameLen &&
3277 [ + + ]: 2484 : strncmp(curvar->name, varName, varNameLen) == 0)
3278 : : {
856 3279 : 1728 : var = curvar;
3280 : 1728 : break;
3281 : : }
3282 : :
3283 : 764 : id++;
3284 : : }
3285 : :
3286 [ + + ]: 1740 : if (var == NULL)
3287 : : {
3288 : 12 : *baseObjectId = -1;
3289 : 12 : return NULL;
3290 : : }
3291 : :
227 michael@paquier.xyz 3292 : 1728 : result = palloc_object(JsonbValue);
856 amitlan@postgresql.o 3293 [ - + ]: 1728 : if (var->isnull)
3294 : : {
856 amitlan@postgresql.o 3295 :UBC 0 : *baseObjectId = 0;
3296 : 0 : result->type = jbvNull;
3297 : : }
3298 : : else
856 amitlan@postgresql.o 3299 :CBC 1728 : JsonItemFromDatum(var->value, var->typid, var->typmod, result);
3300 : :
3301 : 1728 : *baseObject = *result;
3302 : 1728 : *baseObjectId = id;
3303 : :
3304 : 1728 : return result;
3305 : : }
3306 : :
3307 : : static int
3308 : 5854 : CountJsonPathVars(void *cxt)
3309 : : {
3310 : 5854 : List *vars = (List *) cxt;
3311 : :
3312 : 5854 : 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 : : */
3320 : : static void
3321 : 1728 : JsonItemFromDatum(Datum val, Oid typid, int32 typmod, JsonbValue *res)
3322 : : {
3323 [ - - - + : 1728 : switch (typid)
- - - + +
+ - - ]
3324 : : {
856 amitlan@postgresql.o 3325 :UBC 0 : case BOOLOID:
3326 : 0 : res->type = jbvBool;
3327 : 0 : res->val.boolean = DatumGetBool(val);
3328 : 0 : break;
3329 : 0 : case NUMERICOID:
3330 : 0 : JsonbValueInitNumericDatum(res, val);
3331 : 0 : break;
3332 : 0 : case INT2OID:
3333 : 0 : JsonbValueInitNumericDatum(res, DirectFunctionCall1(int2_numeric, val));
3334 : 0 : break;
856 amitlan@postgresql.o 3335 :CBC 1660 : case INT4OID:
3336 : 1660 : JsonbValueInitNumericDatum(res, DirectFunctionCall1(int4_numeric, val));
3337 : 1660 : break;
856 amitlan@postgresql.o 3338 :UBC 0 : case INT8OID:
3339 : 0 : JsonbValueInitNumericDatum(res, DirectFunctionCall1(int8_numeric, val));
3340 : 0 : break;
3341 : 0 : case FLOAT4OID:
3342 : 0 : JsonbValueInitNumericDatum(res, DirectFunctionCall1(float4_numeric, val));
3343 : 0 : break;
3344 : 0 : case FLOAT8OID:
3345 : 0 : JsonbValueInitNumericDatum(res, DirectFunctionCall1(float8_numeric, val));
3346 : 0 : break;
856 amitlan@postgresql.o 3347 :CBC 8 : case TEXTOID:
3348 : : case VARCHAROID:
3349 : 8 : res->type = jbvString;
354 peter@eisentraut.org 3350 : 8 : res->val.string.val = VARDATA_ANY(DatumGetPointer(val));
3351 : 8 : res->val.string.len = VARSIZE_ANY_EXHDR(DatumGetPointer(val));
856 amitlan@postgresql.o 3352 : 8 : break;
3353 : 48 : case DATEOID:
3354 : : case TIMEOID:
3355 : : case TIMETZOID:
3356 : : case TIMESTAMPOID:
3357 : : case TIMESTAMPTZOID:
3358 : 48 : res->type = jbvDatetime;
3359 : 48 : res->val.datetime.value = val;
3360 : 48 : res->val.datetime.typid = typid;
3361 : 48 : res->val.datetime.typmod = typmod;
3362 : 48 : res->val.datetime.tz = 0;
3363 : 48 : break;
3364 : 12 : case JSONBOID:
3365 : : {
3366 : 12 : JsonbValue *jbv = res;
3367 : 12 : Jsonb *jb = DatumGetJsonbP(val);
3368 : :
3369 [ + - ]: 12 : if (JsonContainerIsScalar(&jb->root))
3370 : : {
3371 : : bool result PG_USED_FOR_ASSERTS_ONLY;
3372 : :
3373 : 12 : result = JsonbExtractScalar(&jb->root, jbv);
3374 [ - + ]: 12 : Assert(result);
3375 : : }
3376 : : else
856 amitlan@postgresql.o 3377 :UBC 0 : JsonbInitBinary(jbv, jb);
856 amitlan@postgresql.o 3378 :CBC 12 : break;
3379 : : }
856 amitlan@postgresql.o 3380 :UBC 0 : case JSONOID:
3381 : : {
3382 : 0 : text *txt = DatumGetTextP(val);
3383 : 0 : char *str = text_to_cstring(txt);
3384 : : Jsonb *jb;
3385 : :
3386 : 0 : jb = DatumGetJsonbP(DirectFunctionCall1(jsonb_in,
3387 : : CStringGetDatum(str)));
3388 : 0 : pfree(str);
3389 : :
3390 : 0 : JsonItemFromDatum(JsonbPGetDatum(jb), JSONBOID, -1, res);
3391 : 0 : break;
3392 : : }
3393 : 0 : default:
3394 [ # # ]: 0 : 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 : : }
856 amitlan@postgresql.o 3399 :CBC 1728 : }
3400 : :
3401 : : /* Initialize numeric value from the given datum */
3402 : : static void
3403 : 1660 : JsonbValueInitNumericDatum(JsonbValue *jbv, Datum num)
3404 : : {
3405 : 1660 : jbv->type = jbvNumeric;
3406 : 1660 : jbv->val.numeric = DatumGetNumeric(num);
3407 : 1660 : }
3408 : :
3409 : : /*
3410 : : * Get the value of variable passed to jsonpath executor
3411 : : */
3412 : : static void
2688 akorotkov@postgresql 3413 : 5276 : getJsonPathVariable(JsonPathExecContext *cxt, JsonPathItem *variable,
3414 : : JsonbValue *value)
3415 : : {
3416 : : char *varName;
3417 : : int varNameLength;
3418 : : JsonbValue baseObject;
3419 : : int baseObjectId;
3420 : : JsonbValue *v;
3421 : :
913 amitlan@postgresql.o 3422 [ - + ]: 5276 : Assert(variable->type == jpiVariable);
3423 : 5276 : varName = jspGetString(variable, &varNameLength);
3424 : :
3425 [ + - + + ]: 10552 : if (cxt->vars == NULL ||
3426 : 5276 : (v = cxt->getVar(cxt->vars, varName, varNameLength,
3427 : : &baseObject, &baseObjectId)) == NULL)
3428 [ + - ]: 32 : ereport(ERROR,
3429 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
3430 : : errmsg("could not find jsonpath variable \"%s\"",
3431 : : pnstrdup(varName, varNameLength))));
3432 : :
3433 [ + - ]: 5244 : if (baseObjectId > 0)
3434 : : {
3435 : 5244 : *value = *v;
3436 : 5244 : setBaseObject(cxt, &baseObject, baseObjectId);
3437 : : }
3438 : 5244 : }
3439 : :
3440 : : /*
3441 : : * Definition of JsonPathGetVarCallback for when JsonPathExecContext.vars
3442 : : * is specified as a jsonb value.
3443 : : */
3444 : : static JsonbValue *
3445 : 3536 : getJsonPathVariableFromJsonb(void *varsJsonb, char *varName, int varNameLength,
3446 : : JsonbValue *baseObject, int *baseObjectId)
3447 : : {
3448 : 3536 : Jsonb *vars = varsJsonb;
3449 : : JsonbValue tmp;
3450 : : JsonbValue *result;
3451 : :
2688 akorotkov@postgresql 3452 : 3536 : tmp.type = jbvString;
3453 : 3536 : tmp.val.string.val = varName;
3454 : 3536 : tmp.val.string.len = varNameLength;
3455 : :
913 amitlan@postgresql.o 3456 : 3536 : result = findJsonbValueFromContainer(&vars->root, JB_FOBJECT, &tmp);
3457 : :
3458 [ + + ]: 3536 : if (result == NULL)
3459 : : {
3460 : 20 : *baseObjectId = -1;
3461 : 20 : return NULL;
3462 : : }
3463 : :
3464 : 3516 : *baseObjectId = 1;
3465 : 3516 : JsonbInitBinary(baseObject, vars);
3466 : :
3467 : 3516 : return result;
3468 : : }
3469 : :
3470 : : /*
3471 : : * Definition of JsonPathCountVarsCallback for when JsonPathExecContext.vars
3472 : : * is specified as a jsonb value.
3473 : : */
3474 : : static int
3475 : 134410 : countVariablesFromJsonb(void *varsJsonb)
3476 : : {
3477 : 134410 : Jsonb *vars = varsJsonb;
3478 : :
3479 [ + + + + ]: 134410 : if (vars && !JsonContainerIsObject(&vars->root))
3480 : : {
1423 andrew@dunslane.net 3481 [ + - ]: 8 : 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 */
913 amitlan@postgresql.o 3488 : 134402 : 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 : : */
3496 : : static int
2688 akorotkov@postgresql 3497 : 381 : JsonbArraySize(JsonbValue *jb)
3498 : : {
3499 [ - + ]: 381 : Assert(jb->type != jbvArray);
3500 : :
3501 [ + + ]: 381 : if (jb->type == jbvBinary)
3502 : : {
3503 : 353 : JsonbContainer *jbc = jb->val.binary.data;
3504 : :
3505 [ + + + - ]: 353 : if (JsonContainerIsArray(jbc) && !JsonContainerIsScalar(jbc))
3506 : 345 : return JsonContainerSize(jbc);
3507 : : }
3508 : :
3509 : 36 : return -1;
3510 : : }
3511 : :
3512 : : /* Comparison predicate callback. */
3513 : : static JsonPathBool
3514 : 14890 : executeComparison(JsonPathItem *cmp, JsonbValue *lv, JsonbValue *rv, void *p)
3515 : : {
2495 3516 : 14890 : JsonPathExecContext *cxt = (JsonPathExecContext *) p;
3517 : :
3518 : 14890 : return compareItems(cmp->type, lv, rv, cxt->useTz);
3519 : : }
3520 : :
3521 : : /*
3522 : : * Perform per-byte comparison of two strings.
3523 : : */
3524 : : static int
2540 3525 : 2304 : binaryCompareStrings(const char *s1, int len1,
3526 : : const char *s2, int len2)
3527 : : {
3528 : : int cmp;
3529 : :
3530 : 2304 : cmp = memcmp(s1, s2, Min(len1, len2));
3531 : :
3532 [ + + ]: 2304 : if (cmp != 0)
3533 : 1312 : return cmp;
3534 : :
3535 [ + + ]: 992 : if (len1 == len2)
3536 : 192 : return 0;
3537 : :
3538 [ + + ]: 800 : return len1 < len2 ? -1 : 1;
3539 : : }
3540 : :
3541 : : /*
3542 : : * Compare two strings in the current server encoding using Unicode codepoint
3543 : : * collation.
3544 : : */
3545 : : static int
3546 : 2304 : compareStrings(const char *mbstr1, int mblen1,
3547 : : const char *mbstr2, int mblen2)
3548 : : {
3549 [ + - + - ]: 4608 : if (GetDatabaseEncoding() == PG_SQL_ASCII ||
3550 : 2304 : 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 : 2304 : 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 : : */
2539 akorotkov@postgresql 3573 :UBC 0 : utf8str1 = pg_server_to_any(mbstr1, mblen1, PG_UTF8);
3574 : 0 : utf8str2 = pg_server_to_any(mbstr2, mblen2, PG_UTF8);
3575 [ # # ]: 0 : utf8len1 = (mbstr1 == utf8str1) ? mblen1 : strlen(utf8str1);
3576 [ # # ]: 0 : utf8len2 = (mbstr2 == utf8str2) ? mblen2 : strlen(utf8str2);
3577 : :
3578 : 0 : 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 [ # # # # ]: 0 : if (mbstr1 == utf8str1 && mbstr2 == utf8str2)
3585 : 0 : return cmp;
3586 : :
3587 : : /* Free memory if needed */
3588 [ # # ]: 0 : if (mbstr1 != utf8str1)
3589 : 0 : pfree(utf8str1);
3590 [ # # ]: 0 : if (mbstr2 != utf8str2)
3591 : 0 : 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 : : */
2540 3602 [ # # ]: 0 : if (cmp == 0)
3603 : 0 : return binaryCompareStrings(mbstr1, mblen1, mbstr2, mblen2);
3604 : : else
3605 : 0 : return cmp;
3606 : : }
3607 : : }
3608 : :
3609 : : /*
3610 : : * Compare two SQL/JSON items using comparison operation 'op'.
3611 : : */
3612 : : static JsonPathBool
2495 akorotkov@postgresql 3613 :CBC 14890 : compareItems(int32 op, JsonbValue *jb1, JsonbValue *jb2, bool useTz)
3614 : : {
3615 : : int cmp;
3616 : : bool res;
3617 : :
2688 3618 [ + + ]: 14890 : if (jb1->type != jb2->type)
3619 : : {
3620 [ + + + + ]: 2261 : 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 : 2083 : return op == jpiNotEqual ? jpbTrue : jpbFalse;
3627 : :
3628 : : /* Non-null items of different types are not comparable. */
3629 : 178 : return jpbUnknown;
3630 : : }
3631 : :
3632 [ + + + + : 12629 : switch (jb1->type)
+ + - ]
3633 : : {
3634 : 124 : case jbvNull:
3635 : 124 : cmp = 0;
3636 : 124 : break;
3637 : 584 : case jbvBool:
3638 [ + + ]: 848 : cmp = jb1->val.boolean == jb2->val.boolean ? 0 :
3639 [ + + ]: 264 : jb1->val.boolean ? 1 : -1;
3640 : 584 : break;
3641 : 2757 : case jbvNumeric:
3642 : 2757 : cmp = compareNumeric(jb1->val.numeric, jb2->val.numeric);
3643 : 2757 : break;
3644 : 6740 : case jbvString:
3645 [ + + ]: 6740 : if (op == jpiEqual)
3646 : 4436 : return jb1->val.string.len != jb2->val.string.len ||
3647 : 2468 : memcmp(jb1->val.string.val,
3648 : 2468 : jb2->val.string.val,
3649 [ + + + + ]: 4436 : jb1->val.string.len) ? jpbFalse : jpbTrue;
3650 : :
2540 3651 : 2304 : cmp = compareStrings(jb1->val.string.val, jb1->val.string.len,
3652 : 2304 : jb2->val.string.val, jb2->val.string.len);
2688 3653 : 2304 : break;
2495 3654 : 2416 : case jbvDatetime:
3655 : : {
3656 : : bool cast_error;
3657 : :
3658 : 2416 : 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 : :
2469 3665 [ + + ]: 2356 : if (cast_error)
2495 3666 : 204 : return jpbUnknown;
3667 : : }
3668 : 2152 : break;
3669 : :
2688 3670 : 8 : case jbvBinary:
3671 : : case jbvArray:
3672 : : case jbvObject:
3673 : 8 : return jpbUnknown; /* non-scalars are not comparable */
3674 : :
2688 akorotkov@postgresql 3675 :UBC 0 : default:
3676 [ # # ]: 0 : elog(ERROR, "invalid jsonb value type %d", jb1->type);
3677 : : }
3678 : :
2688 akorotkov@postgresql 3679 [ + + + + :CBC 7921 : switch (op)
+ + - ]
3680 : : {
3681 : 1830 : case jpiEqual:
3682 : 1830 : res = (cmp == 0);
3683 : 1830 : break;
3684 : 4 : case jpiNotEqual:
3685 : 4 : res = (cmp != 0);
3686 : 4 : break;
3687 : 1418 : case jpiLess:
3688 : 1418 : res = (cmp < 0);
3689 : 1418 : break;
3690 : 1105 : case jpiGreater:
3691 : 1105 : res = (cmp > 0);
3692 : 1105 : break;
3693 : 1361 : case jpiLessOrEqual:
3694 : 1361 : res = (cmp <= 0);
3695 : 1361 : break;
3696 : 2203 : case jpiGreaterOrEqual:
3697 : 2203 : res = (cmp >= 0);
3698 : 2203 : break;
2688 akorotkov@postgresql 3699 :UBC 0 : default:
3700 [ # # ]: 0 : elog(ERROR, "unrecognized jsonpath operation: %d", op);
3701 : : return jpbUnknown;
3702 : : }
3703 : :
2688 akorotkov@postgresql 3704 :CBC 7921 : return res ? jpbTrue : jpbFalse;
3705 : : }
3706 : :
3707 : : /* Compare two numerics */
3708 : : static int
3709 : 2757 : compareNumeric(Numeric a, Numeric b)
3710 : : {
3711 : 2757 : return DatumGetInt32(DirectFunctionCall2(numeric_cmp,
3712 : : NumericGetDatum(a),
3713 : : NumericGetDatum(b)));
3714 : : }
3715 : :
3716 : : static JsonbValue *
3717 : 2230 : copyJsonbValue(JsonbValue *src)
3718 : : {
227 michael@paquier.xyz 3719 : 2230 : JsonbValue *dst = palloc_object(JsonbValue);
3720 : :
2688 akorotkov@postgresql 3721 : 2230 : *dst = *src;
3722 : :
3723 : 2230 : return dst;
3724 : : }
3725 : :
3726 : : /*
3727 : : * Execute array subscript expression and convert resulting numeric item to
3728 : : * the integer type with truncation.
3729 : : */
3730 : : static JsonPathExecResult
3731 : 362 : getArrayIndex(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb,
3732 : : int32 *index)
3733 : : {
3734 : : JsonbValue *jbv;
3735 : : JsonValueList found;
3736 : : JsonPathExecResult res;
3737 : : Datum numeric_index;
323 michael@paquier.xyz 3738 : 362 : ErrorSaveContext escontext = {T_ErrorSaveContext};
3739 : :
128 tgl@sss.pgh.pa.us 3740 : 362 : JsonValueListInit(&found);
3741 : :
3742 : 362 : res = executeItem(cxt, jsp, jb, &found);
3743 : :
2688 akorotkov@postgresql 3744 [ - + ]: 358 : if (jperIsError(res))
3745 : : {
128 tgl@sss.pgh.pa.us 3746 :UBC 0 : JsonValueListClear(&found);
2688 akorotkov@postgresql 3747 : 0 : return res;
3748 : : }
3749 : :
128 tgl@sss.pgh.pa.us 3750 [ + + + + ]:CBC 708 : if (!JsonValueListIsSingleton(&found) ||
2688 akorotkov@postgresql 3751 : 350 : !(jbv = getScalar(JsonValueListHead(&found), jbvNumeric)))
3752 : : {
128 tgl@sss.pgh.pa.us 3753 : 16 : JsonValueListClear(&found);
2688 akorotkov@postgresql 3754 [ + + + - ]: 16 : 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 : 342 : numeric_index = DirectFunctionCall2(numeric_trunc,
3760 : : NumericGetDatum(jbv->val.numeric),
3761 : : Int32GetDatum(0));
3762 : :
323 michael@paquier.xyz 3763 : 342 : *index = numeric_int4_safe(DatumGetNumeric(numeric_index),
3764 : : (Node *) &escontext);
3765 : :
128 tgl@sss.pgh.pa.us 3766 : 342 : JsonValueListClear(&found);
3767 : :
323 michael@paquier.xyz 3768 [ + + ]: 342 : if (escontext.error_occurred)
2688 akorotkov@postgresql 3769 [ + + + - ]: 18 : RETURN_ERROR(ereport(ERROR,
3770 : : (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT),
3771 : : errmsg("jsonpath array subscript is out of integer range"))));
3772 : :
3773 : 324 : return jperOk;
3774 : : }
3775 : :
3776 : : /* Save base object and its id needed for the execution of .keyvalue(). */
3777 : : static JsonBaseObjectInfo
3778 : 153693 : setBaseObject(JsonPathExecContext *cxt, JsonbValue *jbv, int32 id)
3779 : : {
3780 : 153693 : JsonBaseObjectInfo baseObject = cxt->baseObject;
3781 : :
3782 [ + + ]: 153693 : cxt->baseObject.jbc = jbv->type != jbvBinary ? NULL :
3783 : : (JsonbContainer *) jbv->val.binary.data;
3784 : 153693 : cxt->baseObject.id = id;
3785 : :
3786 : 153693 : return baseObject;
3787 : : }
3788 : :
3789 : : /*
3790 : : * JsonValueList support functions
3791 : : */
3792 : :
3793 : : static void
128 tgl@sss.pgh.pa.us 3794 : 251386 : JsonValueListInit(JsonValueList *jvl)
3795 : : {
3796 : 251386 : jvl->nitems = 0;
3797 : 251386 : jvl->maxitems = BASE_JVL_ITEMS;
3798 : 251386 : jvl->next = NULL;
3799 : 251386 : jvl->last = jvl;
3800 : 251386 : }
3801 : :
3802 : : static void
842 amitlan@postgresql.o 3803 : 172697 : JsonValueListClear(JsonValueList *jvl)
3804 : : {
3805 : : JsonValueList *nxt;
3806 : :
3807 : : /* Release any extra chunks */
128 tgl@sss.pgh.pa.us 3808 [ + + ]: 173233 : for (JsonValueList *chunk = jvl->next; chunk != NULL; chunk = nxt)
3809 : : {
3810 : 536 : nxt = chunk->next;
3811 : 536 : pfree(chunk);
3812 : : }
3813 : : /* ... and reset to empty */
3814 : 172697 : jvl->nitems = 0;
3815 [ - + ]: 172697 : Assert(jvl->maxitems == BASE_JVL_ITEMS);
3816 : 172697 : jvl->next = NULL;
3817 : 172697 : jvl->last = jvl;
842 amitlan@postgresql.o 3818 : 172697 : }
3819 : :
3820 : : static void
128 tgl@sss.pgh.pa.us 3821 : 196197 : JsonValueListAppend(JsonValueList *jvl, const JsonbValue *jbv)
3822 : : {
3823 : 196197 : JsonValueList *last = jvl->last;
3824 : :
3825 [ + + ]: 196197 : if (last->nitems < last->maxitems)
3826 : : {
3827 : : /* there's still room in the last existing chunk */
3828 : 195175 : last->items[last->nitems] = *jbv;
3829 : 195175 : last->nitems++;
3830 : : }
3831 : : else
3832 : : {
3833 : : /* need a new last chunk */
3834 : : JsonValueList *nxt;
3835 : : int nxtsize;
3836 : :
3837 : 1022 : nxtsize = last->maxitems * 2; /* double the size with each chunk */
3838 : 1022 : nxtsize = Max(nxtsize, MIN_EXTRA_JVL_ITEMS); /* but at least this */
3839 : 1022 : nxt = palloc(offsetof(JsonValueList, items) +
3840 : 1022 : nxtsize * sizeof(JsonbValue));
3841 : 1022 : nxt->nitems = 1;
3842 : 1022 : nxt->maxitems = nxtsize;
3843 : 1022 : nxt->next = NULL;
3844 : 1022 : nxt->items[0] = *jbv;
3845 : 1022 : last->next = nxt;
3846 : 1022 : jvl->last = nxt;
3847 : : }
2688 akorotkov@postgresql 3848 : 196197 : }
3849 : :
3850 : : static bool
128 tgl@sss.pgh.pa.us 3851 : 8852 : JsonValueListIsEmpty(const JsonValueList *jvl)
3852 : : {
3853 : : /* We need not examine extra chunks for this */
3854 : 8852 : return (jvl->nitems == 0);
3855 : : }
3856 : :
3857 : : static bool
3858 : 69607 : JsonValueListIsSingleton(const JsonValueList *jvl)
3859 : : {
3860 : : #if BASE_JVL_ITEMS > 1
3861 : : /* We need not examine extra chunks in this case */
3862 : 69607 : return (jvl->nitems == 1);
3863 : : #else
3864 : : return (jvl->nitems == 1 && jvl->next == NULL);
3865 : : #endif
3866 : : }
3867 : :
3868 : : static bool
3869 : 3858 : JsonValueListHasMultipleItems(const JsonValueList *jvl)
3870 : : {
3871 : : #if BASE_JVL_ITEMS > 1
3872 : : /* We need not examine extra chunks in this case */
3873 : 3858 : return (jvl->nitems > 1);
3874 : : #else
3875 : : return (jvl->nitems == 1 && jvl->next != NULL);
3876 : : #endif
3877 : : }
3878 : :
3879 : : static JsonbValue *
3880 : 75963 : JsonValueListHead(JsonValueList *jvl)
3881 : : {
3882 [ - + ]: 75963 : Assert(jvl->nitems > 0);
3883 : 75963 : return &jvl->items[0];
3884 : : }
3885 : :
3886 : : /*
3887 : : * JsonValueListIterator functions
3888 : : */
3889 : :
3890 : : static void
3891 : 151250 : JsonValueListInitIterator(JsonValueList *jvl, JsonValueListIterator *it)
3892 : : {
3893 : 151250 : it->chunk = jvl;
3894 : 151250 : it->nextitem = 0;
2688 akorotkov@postgresql 3895 : 151250 : }
3896 : :
3897 : : /*
3898 : : * Get the next item from the sequence advancing iterator.
3899 : : * Returns NULL if no more items.
3900 : : */
3901 : : static JsonbValue *
128 tgl@sss.pgh.pa.us 3902 : 235977 : JsonValueListNext(JsonValueListIterator *it)
3903 : : {
3904 [ - + ]: 235977 : if (it->chunk == NULL)
128 tgl@sss.pgh.pa.us 3905 :LBC (300) : return NULL;
128 tgl@sss.pgh.pa.us 3906 [ + + ]:CBC 235977 : if (it->nextitem >= it->chunk->nitems)
3907 : : {
3908 : 141025 : it->chunk = it->chunk->next;
3909 [ + + ]: 141025 : if (it->chunk == NULL)
3910 : 140076 : return NULL;
3911 : 949 : it->nextitem = 0;
3912 [ - + ]: 949 : Assert(it->chunk->nitems > 0);
3913 : : }
3914 : 95901 : return &it->chunk->items[it->nextitem++];
3915 : : }
3916 : :
3917 : : /*
3918 : : * Initialize a binary JsonbValue with the given jsonb container.
3919 : : */
3920 : : static JsonbValue *
2688 akorotkov@postgresql 3921 : 138978 : JsonbInitBinary(JsonbValue *jbv, Jsonb *jb)
3922 : : {
3923 : 138978 : jbv->type = jbvBinary;
3924 : 138978 : jbv->val.binary.data = &jb->root;
3925 : 138978 : jbv->val.binary.len = VARSIZE_ANY_EXHDR(jb);
3926 : :
3927 : 138978 : return jbv;
3928 : : }
3929 : :
3930 : : /*
3931 : : * Returns jbv* type of JsonbValue. Note, it never returns jbvBinary as is.
3932 : : */
3933 : : static int
3934 : 201742 : JsonbType(JsonbValue *jb)
3935 : : {
3936 : 201742 : int type = jb->type;
3937 : :
3938 [ + + ]: 201742 : if (jb->type == jbvBinary)
3939 : : {
604 peter@eisentraut.org 3940 : 129769 : JsonbContainer *jbc = jb->val.binary.data;
3941 : :
3942 : : /* Scalars should be always extracted during jsonpath execution. */
2688 akorotkov@postgresql 3943 [ - + ]: 129769 : Assert(!JsonContainerIsScalar(jbc));
3944 : :
3945 [ + + ]: 129769 : if (JsonContainerIsObject(jbc))
3946 : 126910 : type = jbvObject;
3947 [ + - ]: 2859 : else if (JsonContainerIsArray(jbc))
3948 : 2859 : type = jbvArray;
3949 : : else
2688 akorotkov@postgresql 3950 [ # # ]:UBC 0 : elog(ERROR, "invalid jsonb container type: 0x%08x", jbc->header);
3951 : : }
3952 : :
2688 akorotkov@postgresql 3953 :CBC 201742 : return type;
3954 : : }
3955 : :
3956 : : /* Get scalar of given type or NULL on type mismatch */
3957 : : static JsonbValue *
3958 : 8067 : getScalar(JsonbValue *scalar, enum jbvType type)
3959 : : {
3960 : : /* Scalars should be always extracted during jsonpath execution. */
3961 [ + + - + ]: 8067 : Assert(scalar->type != jbvBinary ||
3962 : : !JsonContainerIsScalar(scalar->val.binary.data));
3963 : :
3964 [ + + ]: 8067 : return scalar->type == type ? scalar : NULL;
3965 : : }
3966 : :
3967 : : /* Construct a JSON array from the item list */
3968 : : static JsonbValue *
128 tgl@sss.pgh.pa.us 3969 : 330 : wrapItemsInArray(JsonValueList *items)
3970 : : {
230 3971 : 330 : JsonbInState ps = {0};
3972 : : JsonValueListIterator it;
3973 : : JsonbValue *jbv;
3974 : :
2688 akorotkov@postgresql 3975 : 330 : pushJsonbValue(&ps, WJB_BEGIN_ARRAY, NULL);
3976 : :
3977 : 330 : JsonValueListInitIterator(items, &it);
128 tgl@sss.pgh.pa.us 3978 [ + + ]: 910 : while ((jbv = JsonValueListNext(&it)))
2688 akorotkov@postgresql 3979 : 580 : pushJsonbValue(&ps, WJB_ELEM, jbv);
3980 : :
230 tgl@sss.pgh.pa.us 3981 : 330 : pushJsonbValue(&ps, WJB_END_ARRAY, NULL);
3982 : :
3983 : 330 : return ps.result;
3984 : : }
3985 : :
3986 : : /* Check if the timezone required for casting from type1 to type2 is used */
3987 : : static void
2469 akorotkov@postgresql 3988 : 900 : checkTimezoneIsUsedForCast(bool useTz, const char *type1, const char *type2)
3989 : : {
3990 [ + + ]: 900 : if (!useTz)
3991 [ + - ]: 192 : 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 : 708 : }
3997 : :
3998 : : /* Convert time datum to timetz datum */
3999 : : static Datum
4000 : 168 : castTimeToTimeTz(Datum time, bool useTz)
4001 : : {
4002 : 168 : checkTimezoneIsUsedForCast(useTz, "time", "timetz");
4003 : :
4004 : 144 : return DirectFunctionCall1(time_timetz, time);
4005 : : }
4006 : :
4007 : : /*
4008 : : * Compare date to timestamp.
4009 : : * Note that this doesn't involve any timezone considerations.
4010 : : */
4011 : : static int
4012 : 124 : cmpDateToTimestamp(DateADT date1, Timestamp ts2, bool useTz)
4013 : : {
2117 tgl@sss.pgh.pa.us 4014 : 124 : return date_cmp_timestamp_internal(date1, ts2);
4015 : : }
4016 : :
4017 : : /*
4018 : : * Compare date to timestamptz.
4019 : : */
4020 : : static int
2469 akorotkov@postgresql 4021 : 108 : cmpDateToTimestampTz(DateADT date1, TimestampTz tstz2, bool useTz)
4022 : : {
4023 : 108 : checkTimezoneIsUsedForCast(useTz, "date", "timestamptz");
4024 : :
2117 tgl@sss.pgh.pa.us 4025 : 96 : return date_cmp_timestamptz_internal(date1, tstz2);
4026 : : }
4027 : :
4028 : : /*
4029 : : * Compare timestamp to timestamptz.
4030 : : */
4031 : : static int
2469 akorotkov@postgresql 4032 : 168 : cmpTimestampToTimestampTz(Timestamp ts1, TimestampTz tstz2, bool useTz)
4033 : : {
4034 : 168 : checkTimezoneIsUsedForCast(useTz, "timestamp", "timestamptz");
4035 : :
2117 tgl@sss.pgh.pa.us 4036 : 144 : 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 : : */
4044 : : static int
2495 akorotkov@postgresql 4045 : 2416 : compareDatetime(Datum val1, Oid typid1, Datum val2, Oid typid2,
4046 : : bool useTz, bool *cast_error)
4047 : : {
4048 : : PGFunction cmpfunc;
4049 : :
2469 4050 : 2416 : *cast_error = false;
4051 : :
2495 4052 [ + + + + : 2416 : switch (typid1)
+ - ]
4053 : : {
4054 : 376 : case DATEOID:
4055 [ + + + + : 376 : switch (typid2)
- ]
4056 : : {
4057 : 252 : case DATEOID:
4058 : 252 : cmpfunc = date_cmp;
4059 : :
4060 : 252 : break;
4061 : :
4062 : 52 : case TIMESTAMPOID:
2469 4063 : 52 : return cmpDateToTimestamp(DatumGetDateADT(val1),
4064 : : DatumGetTimestamp(val2),
4065 : : useTz);
4066 : :
2495 4067 : 48 : case TIMESTAMPTZOID:
2469 4068 : 48 : return cmpDateToTimestampTz(DatumGetDateADT(val1),
4069 : : DatumGetTimestampTz(val2),
4070 : : useTz);
4071 : :
2495 4072 : 24 : case TIMEOID:
4073 : : case TIMETZOID:
2469 4074 : 24 : *cast_error = true; /* uncomparable types */
2495 4075 : 24 : return 0;
4076 : :
2469 akorotkov@postgresql 4077 :UBC 0 : default:
4078 [ # # ]: 0 : elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
4079 : : typid2);
4080 : : }
2495 akorotkov@postgresql 4081 :CBC 252 : break;
4082 : :
4083 : 416 : case TIMEOID:
4084 [ + + + - ]: 416 : switch (typid2)
4085 : : {
4086 : 284 : case TIMEOID:
4087 : 284 : cmpfunc = time_cmp;
4088 : :
4089 : 284 : break;
4090 : :
4091 : 84 : case TIMETZOID:
2469 4092 : 84 : val1 = castTimeToTimeTz(val1, useTz);
2495 4093 : 72 : cmpfunc = timetz_cmp;
4094 : :
4095 : 72 : break;
4096 : :
4097 : 48 : case DATEOID:
4098 : : case TIMESTAMPOID:
4099 : : case TIMESTAMPTZOID:
2469 4100 : 48 : *cast_error = true; /* uncomparable types */
2495 4101 : 48 : return 0;
4102 : :
2469 akorotkov@postgresql 4103 :UBC 0 : default:
4104 [ # # ]: 0 : elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
4105 : : typid2);
4106 : : }
2495 akorotkov@postgresql 4107 :CBC 356 : break;
4108 : :
4109 : 536 : case TIMETZOID:
4110 [ + + + - ]: 536 : switch (typid2)
4111 : : {
4112 : 84 : case TIMEOID:
2469 4113 : 84 : val2 = castTimeToTimeTz(val2, useTz);
2495 4114 : 72 : cmpfunc = timetz_cmp;
4115 : :
4116 : 72 : break;
4117 : :
4118 : 404 : case TIMETZOID:
4119 : 404 : cmpfunc = timetz_cmp;
4120 : :
4121 : 404 : break;
4122 : :
4123 : 48 : case DATEOID:
4124 : : case TIMESTAMPOID:
4125 : : case TIMESTAMPTZOID:
2469 4126 : 48 : *cast_error = true; /* uncomparable types */
2495 4127 : 48 : return 0;
4128 : :
2469 akorotkov@postgresql 4129 :UBC 0 : default:
4130 [ # # ]: 0 : elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
4131 : : typid2);
4132 : : }
2495 akorotkov@postgresql 4133 :CBC 476 : break;
4134 : :
4135 : 476 : case TIMESTAMPOID:
4136 [ + + + + : 476 : switch (typid2)
- ]
4137 : : {
4138 : 72 : case DATEOID:
2469 4139 : 72 : return -cmpDateToTimestamp(DatumGetDateADT(val2),
4140 : : DatumGetTimestamp(val1),
4141 : : useTz);
4142 : :
2495 4143 : 284 : case TIMESTAMPOID:
4144 : 284 : cmpfunc = timestamp_cmp;
4145 : :
4146 : 284 : break;
4147 : :
4148 : 84 : case TIMESTAMPTZOID:
2469 4149 : 84 : return cmpTimestampToTimestampTz(DatumGetTimestamp(val1),
4150 : : DatumGetTimestampTz(val2),
4151 : : useTz);
4152 : :
2495 4153 : 36 : case TIMEOID:
4154 : : case TIMETZOID:
2469 4155 : 36 : *cast_error = true; /* uncomparable types */
2495 4156 : 36 : return 0;
4157 : :
2469 akorotkov@postgresql 4158 :UBC 0 : default:
4159 [ # # ]: 0 : elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
4160 : : typid2);
4161 : : }
2495 akorotkov@postgresql 4162 :CBC 284 : break;
4163 : :
4164 : 612 : case TIMESTAMPTZOID:
4165 [ + + + + : 612 : switch (typid2)
- ]
4166 : : {
4167 : 60 : case DATEOID:
2469 4168 : 60 : return -cmpDateToTimestampTz(DatumGetDateADT(val2),
4169 : : DatumGetTimestampTz(val1),
4170 : : useTz);
4171 : :
2495 4172 : 84 : case TIMESTAMPOID:
2469 4173 : 84 : return -cmpTimestampToTimestampTz(DatumGetTimestamp(val2),
4174 : : DatumGetTimestampTz(val1),
4175 : : useTz);
4176 : :
2495 4177 : 420 : case TIMESTAMPTZOID:
4178 : 420 : cmpfunc = timestamp_cmp;
4179 : :
4180 : 420 : break;
4181 : :
4182 : 48 : case TIMEOID:
4183 : : case TIMETZOID:
2469 4184 : 48 : *cast_error = true; /* uncomparable types */
2495 4185 : 48 : return 0;
4186 : :
2469 akorotkov@postgresql 4187 :UBC 0 : default:
4188 [ # # ]: 0 : elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u",
4189 : : typid2);
4190 : : }
2495 akorotkov@postgresql 4191 :CBC 420 : break;
4192 : :
2495 akorotkov@postgresql 4193 :UBC 0 : default:
2469 4194 [ # # ]: 0 : elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u", typid1);
4195 : : }
4196 : :
2469 akorotkov@postgresql 4197 [ - + ]:CBC 1788 : if (*cast_error)
2469 akorotkov@postgresql 4198 :UBC 0 : return 0; /* cast error */
4199 : :
2495 akorotkov@postgresql 4200 :CBC 1788 : 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 : : */
4209 : : bool
856 amitlan@postgresql.o 4210 : 388 : JsonPathExists(Datum jb, JsonPath *jp, bool *error, List *vars)
4211 : : {
4212 : : JsonPathExecResult res;
4213 : :
4214 : 388 : res = executeJsonPath(jp, vars,
4215 : : GetJsonPathVar, CountJsonPathVars,
4216 : : DatumGetJsonbP(jb), !error, NULL, true);
4217 : :
4218 [ + + - + ]: 384 : Assert(error || !jperIsError(res));
4219 : :
4220 [ + + + + ]: 384 : if (error && jperIsError(res))
4221 : 104 : *error = true;
4222 : :
4223 : 384 : 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 : : */
4232 : : Datum
4233 : 1784 : JsonPathQuery(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 : :
128 tgl@sss.pgh.pa.us 4241 : 1784 : JsonValueListInit(&found);
4242 : :
856 amitlan@postgresql.o 4243 : 1784 : res = executeJsonPath(jp, vars,
4244 : : GetJsonPathVar, CountJsonPathVars,
4245 : : DatumGetJsonbP(jb), !error, &found, true);
4246 [ + + - + ]: 1772 : Assert(error || !jperIsError(res));
4247 [ + + + + ]: 1772 : if (error && jperIsError(res))
4248 : : {
4249 : 20 : *error = true;
4250 : 20 : *empty = false;
4251 : 20 : 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 : : */
128 tgl@sss.pgh.pa.us 4270 [ + + ]: 1752 : if (JsonValueListIsEmpty(&found))
856 amitlan@postgresql.o 4271 : 140 : wrap = false;
4272 [ + + + + ]: 1612 : else if (wrapper == JSW_NONE || wrapper == JSW_UNSPEC)
4273 : 1284 : wrap = false;
4274 [ + + ]: 328 : else if (wrapper == JSW_UNCONDITIONAL)
4275 : 212 : wrap = true;
4276 [ + - ]: 116 : else if (wrapper == JSW_CONDITIONAL)
128 tgl@sss.pgh.pa.us 4277 : 116 : wrap = JsonValueListHasMultipleItems(&found);
4278 : : else
4279 : : {
828 amitlan@postgresql.o 4280 [ # # ]:UBC 0 : elog(ERROR, "unrecognized json wrapper %d", (int) wrapper);
4281 : : wrap = false;
4282 : : }
4283 : :
856 amitlan@postgresql.o 4284 [ + + ]:CBC 1752 : if (wrap)
4285 : 252 : return JsonbPGetDatum(JsonbValueToJsonb(wrapItemsInArray(&found)));
4286 : :
4287 : : /* No wrapping means at most one item is expected. */
128 tgl@sss.pgh.pa.us 4288 [ + + ]: 1500 : if (JsonValueListHasMultipleItems(&found))
4289 : : {
856 amitlan@postgresql.o 4290 [ + + ]: 40 : if (error)
4291 : : {
4292 : 32 : *error = true;
4293 : 32 : return (Datum) 0;
4294 : : }
4295 : :
828 4296 [ + + ]: 8 : if (column_name)
4297 [ + - ]: 4 : 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 [ + - ]: 4 : 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 : :
128 tgl@sss.pgh.pa.us 4309 [ + + ]: 1460 : if (!JsonValueListIsEmpty(&found))
4310 : 1320 : return JsonbPGetDatum(JsonbValueToJsonb(JsonValueListHead(&found)));
4311 : :
856 amitlan@postgresql.o 4312 : 140 : *empty = true;
4313 : 140 : 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 : : */
4322 : : JsonbValue *
828 4323 : 2554 : JsonPathValue(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 : :
128 tgl@sss.pgh.pa.us 4330 : 2554 : JsonValueListInit(&found);
4331 : :
856 amitlan@postgresql.o 4332 : 2554 : jper = executeJsonPath(jp, vars, GetJsonPathVar, CountJsonPathVars,
4333 : : DatumGetJsonbP(jb),
4334 : : !error, &found, true);
4335 : :
4336 [ + + - + ]: 2546 : Assert(error || !jperIsError(jper));
4337 : :
4338 [ + + + + ]: 2546 : if (error && jperIsError(jper))
4339 : : {
4340 : 12 : *error = true;
4341 : 12 : *empty = false;
4342 : 12 : return NULL;
4343 : : }
4344 : :
128 tgl@sss.pgh.pa.us 4345 : 2534 : *empty = JsonValueListIsEmpty(&found);
4346 : :
856 amitlan@postgresql.o 4347 [ + + ]: 2534 : if (*empty)
4348 : 292 : return NULL;
4349 : :
4350 : : /* JSON_VALUE expects to get only singletons. */
128 tgl@sss.pgh.pa.us 4351 [ + + ]: 2242 : if (JsonValueListHasMultipleItems(&found))
4352 : : {
856 amitlan@postgresql.o 4353 [ + + ]: 12 : if (error)
4354 : : {
4355 : 8 : *error = true;
4356 : 8 : return NULL;
4357 : : }
4358 : :
828 4359 [ - + ]: 4 : if (column_name)
828 amitlan@postgresql.o 4360 [ # # ]:UBC 0 : 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
828 amitlan@postgresql.o 4365 [ + - ]:CBC 4 : 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 : :
128 tgl@sss.pgh.pa.us 4370 : 2230 : res = copyJsonbValue(JsonValueListHead(&found));
856 amitlan@postgresql.o 4371 [ + + - + ]: 2230 : if (res->type == jbvBinary && JsonContainerIsScalar(res->val.binary.data))
856 amitlan@postgresql.o 4372 :UBC 0 : JsonbExtractScalar(res->val.binary.data, res);
4373 : :
4374 : : /* JSON_VALUE expects to get only scalars. */
856 amitlan@postgresql.o 4375 [ + + + + ]:CBC 2230 : if (!IsAJsonbScalar(res))
4376 : : {
4377 [ + + ]: 72 : if (error)
4378 : : {
4379 : 64 : *error = true;
4380 : 64 : return NULL;
4381 : : }
4382 : :
828 4383 [ - + ]: 8 : if (column_name)
828 amitlan@postgresql.o 4384 [ # # ]:UBC 0 : 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
828 amitlan@postgresql.o 4389 [ + - ]:CBC 8 : ereport(ERROR,
4390 : : (errcode(ERRCODE_SQL_JSON_SCALAR_REQUIRED),
4391 : : errmsg("JSON path expression in JSON_VALUE must return single scalar item")));
4392 : : }
4393 : :
856 4394 [ + + ]: 2158 : if (res->type == jbvNull)
4395 : 116 : return NULL;
4396 : :
4397 : 2042 : 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 : : */
4406 : : static inline JsonTableExecContext *
842 4407 : 7542 : GetJsonTableExecContext(TableFuncScanState *state, const char *fname)
4408 : : {
4409 : : JsonTableExecContext *result;
4410 : :
4411 [ - + ]: 7542 : if (!IsA(state, TableFuncScanState))
842 amitlan@postgresql.o 4412 [ # # ]:UBC 0 : elog(ERROR, "%s called with invalid TableFuncScanState", fname);
842 amitlan@postgresql.o 4413 :CBC 7542 : result = (JsonTableExecContext *) state->opaque;
4414 [ - + ]: 7542 : if (result->magic != JSON_TABLE_EXEC_CONTEXT_MAGIC)
842 amitlan@postgresql.o 4415 [ # # ]:UBC 0 : elog(ERROR, "%s called with invalid TableFuncScanState", fname);
4416 : :
842 amitlan@postgresql.o 4417 :CBC 7542 : 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 : : */
4427 : : static void
4428 : 414 : JsonTableInitOpaque(TableFuncScanState *state, int natts)
4429 : : {
4430 : : JsonTableExecContext *cxt;
4431 : 414 : PlanState *ps = &state->ss.ps;
4432 : 414 : TableFuncScan *tfs = castNode(TableFuncScan, ps->plan);
4433 : 414 : TableFunc *tf = tfs->tablefunc;
4434 : 414 : JsonTablePlan *rootplan = (JsonTablePlan *) tf->plan;
4435 : 414 : JsonExpr *je = castNode(JsonExpr, tf->docexpr);
4436 : 414 : List *args = NIL;
4437 : :
227 michael@paquier.xyz 4438 : 414 : cxt = palloc0_object(JsonTableExecContext);
842 amitlan@postgresql.o 4439 : 414 : 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 [ + + ]: 414 : if (state->passingvalexprs)
4446 : : {
4447 : : ListCell *exprlc;
4448 : : ListCell *namelc;
4449 : :
4450 [ - + ]: 84 : Assert(list_length(state->passingvalexprs) ==
4451 : : list_length(je->passing_names));
4452 [ + - + + : 248 : forboth(exprlc, state->passingvalexprs,
+ - + + +
+ + - +
+ ]
4453 : : namelc, je->passing_names)
4454 : : {
4455 : 164 : ExprState *state = lfirst_node(ExprState, exprlc);
4456 : 164 : String *name = lfirst_node(String, namelc);
227 michael@paquier.xyz 4457 : 164 : JsonPathVariable *var = palloc_object(JsonPathVariable);
4458 : :
842 amitlan@postgresql.o 4459 : 164 : var->name = pstrdup(name->sval);
766 4460 : 164 : var->namelen = strlen(var->name);
842 4461 : 164 : var->typid = exprType((Node *) state->expr);
4462 : 164 : var->typmod = exprTypmod((Node *) state->expr);
4463 : :
4464 : : /*
4465 : : * Evaluate the expression and save the value to be returned by
4466 : : * GetJsonPathVar().
4467 : : */
4468 : 164 : var->value = ExecEvalExpr(state, ps->ps_ExprContext,
4469 : : &var->isnull);
4470 : :
4471 : 164 : args = lappend(args, var);
4472 : : }
4473 : : }
4474 : :
227 michael@paquier.xyz 4475 : 414 : 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 : : */
838 amitlan@postgresql.o 4481 : 414 : cxt->rootplanstate = JsonTableInitPlan(cxt, rootplan, NULL, args,
4482 : : CurrentMemoryContext);
4483 : :
842 4484 : 414 : state->opaque = cxt;
4485 : 414 : }
4486 : :
4487 : : /*
4488 : : * JsonTableDestroyOpaque
4489 : : * Resets state->opaque
4490 : : */
4491 : : static void
4492 : 414 : JsonTableDestroyOpaque(TableFuncScanState *state)
4493 : : {
4494 : : JsonTableExecContext *cxt =
4495 : 414 : GetJsonTableExecContext(state, "JsonTableDestroyOpaque");
4496 : :
4497 : : /* not valid anymore */
4498 : 414 : cxt->magic = 0;
4499 : :
4500 : 414 : state->opaque = NULL;
4501 : 414 : }
4502 : :
4503 : : /*
4504 : : * JsonTableInitPlan
4505 : : * Initialize information for evaluating jsonpath in the given
4506 : : * JsonTablePlan and, recursively, in any child plans
4507 : : */
4508 : : static JsonTablePlanState *
4509 : 908 : JsonTableInitPlan(JsonTableExecContext *cxt, JsonTablePlan *plan,
4510 : : JsonTablePlanState *parentstate,
4511 : : List *args, MemoryContext mcxt)
4512 : : {
227 michael@paquier.xyz 4513 : 908 : JsonTablePlanState *planstate = palloc0_object(JsonTablePlanState);
4514 : :
842 amitlan@postgresql.o 4515 : 908 : planstate->plan = plan;
838 4516 : 908 : planstate->parent = parentstate;
128 tgl@sss.pgh.pa.us 4517 : 908 : JsonValueListInit(&planstate->found);
4518 : :
842 amitlan@postgresql.o 4519 [ + + ]: 908 : if (IsA(plan, JsonTablePathScan))
4520 : : {
4521 : 784 : JsonTablePathScan *scan = (JsonTablePathScan *) plan;
4522 : : int i;
4523 : :
16 akorotkov@postgresql 4524 :GNC 784 : planstate->outerJoin = scan->outerJoin;
842 amitlan@postgresql.o 4525 :CBC 784 : planstate->path = DatumGetJsonPathP(scan->path->value->constvalue);
4526 : 784 : planstate->args = args;
4527 : 784 : planstate->mcxt = AllocSetContextCreate(mcxt, "JsonTableExecContext",
4528 : : ALLOCSET_DEFAULT_SIZES);
4529 : :
4530 : : /* No row pattern evaluated yet. */
4531 : 784 : planstate->current.value = PointerGetDatum(NULL);
4532 : 784 : planstate->current.isnull = true;
4533 : :
838 4534 [ + + + + ]: 1926 : for (i = scan->colMin; i >= 0 && i <= scan->colMax; i++)
4535 : 1142 : cxt->colplanstates[i] = planstate;
4536 : :
4537 : 784 : planstate->nested = scan->child ?
4538 [ + + ]: 784 : JsonTableInitPlan(cxt, scan->child, planstate, args, mcxt) : NULL;
4539 : : }
4540 [ + - ]: 124 : else if (IsA(plan, JsonTableSiblingJoin))
4541 : : {
4542 : 124 : JsonTableSiblingJoin *join = (JsonTableSiblingJoin *) plan;
4543 : :
16 akorotkov@postgresql 4544 :GNC 124 : planstate->cross = join->cross;
4545 : :
838 amitlan@postgresql.o 4546 :CBC 124 : planstate->left = JsonTableInitPlan(cxt, join->lplan, parentstate,
4547 : : args, mcxt);
4548 : 124 : planstate->right = JsonTableInitPlan(cxt, join->rplan, parentstate,
4549 : : args, mcxt);
4550 : : }
4551 : :
842 4552 : 908 : return planstate;
4553 : : }
4554 : :
4555 : : /*
4556 : : * JsonTableSetDocument
4557 : : * Install the input document and evaluate the row pattern
4558 : : */
4559 : : static void
4560 : 410 : JsonTableSetDocument(TableFuncScanState *state, Datum value)
4561 : : {
4562 : : JsonTableExecContext *cxt =
4563 : 410 : GetJsonTableExecContext(state, "JsonTableSetDocument");
4564 : :
4565 : 410 : JsonTableResetRowPattern(cxt->rootplanstate, value);
4566 : 406 : }
4567 : :
4568 : : /*
4569 : : * Evaluate a JsonTablePlan's jsonpath to get a new row pattern from
4570 : : * the given context item
4571 : : */
4572 : : static void
4573 : 1128 : JsonTableResetRowPattern(JsonTablePlanState *planstate, Datum item)
4574 : : {
4575 : 1128 : JsonTablePathScan *scan = castNode(JsonTablePathScan, planstate->plan);
4576 : : MemoryContext oldcxt;
4577 : : JsonPathExecResult res;
4578 : 1128 : Jsonb *js = (Jsonb *) DatumGetJsonbP(item);
4579 : :
4580 : 1128 : JsonValueListClear(&planstate->found);
4581 : :
4582 : 1128 : MemoryContextResetOnly(planstate->mcxt);
4583 : :
4584 : 1128 : oldcxt = MemoryContextSwitchTo(planstate->mcxt);
4585 : :
4586 : 1128 : res = executeJsonPath(planstate->path, planstate->args,
4587 : : GetJsonPathVar, CountJsonPathVars,
4588 : 1128 : js, scan->errorOnError,
4589 : : &planstate->found,
4590 : : true);
4591 : :
4592 : 1124 : MemoryContextSwitchTo(oldcxt);
4593 : :
4594 [ + + ]: 1124 : if (jperIsError(res))
4595 : : {
4596 [ - + ]: 148 : Assert(!scan->errorOnError);
4597 : 148 : JsonValueListClear(&planstate->found);
4598 : : }
4599 : :
16 akorotkov@postgresql 4600 :GNC 1124 : JsonTableRescan(planstate);
842 amitlan@postgresql.o 4601 :CBC 1124 : }
4602 : :
4603 : : /*
4604 : : * Fetch next row from a JsonTablePlan.
4605 : : *
4606 : : * Returns false if the plan has run out of rows, true otherwise.
4607 : : */
4608 : : static bool
4609 : 4544 : JsonTablePlanNextRow(JsonTablePlanState *planstate)
4610 : : {
16 akorotkov@postgresql 4611 [ + + ]:GNC 4544 : if (IsA(planstate->plan, JsonTableSiblingJoin))
4612 : : {
4613 [ + + ]: 1056 : if (planstate->advanceRight)
4614 : : {
4615 : : /* fetch next inner row */
4616 [ + + ]: 440 : if (JsonTablePlanNextRow(planstate->right))
4617 : 264 : return true;
4618 : :
4619 : : /* inner rows are exhausted */
4620 [ + + ]: 176 : if (planstate->cross)
4621 : 72 : planstate->advanceRight = false; /* next outer row */
4622 : : else
4623 : 104 : return false; /* end of scan */
4624 : : }
4625 : :
4626 [ + - ]: 752 : while (!planstate->advanceRight)
4627 : : {
4628 : : /* fetch next outer row */
4629 : 752 : bool more = JsonTablePlanNextRow(planstate->left);
4630 : :
4631 [ + + ]: 752 : if (planstate->cross)
4632 : : {
4633 [ + + ]: 212 : if (!more)
4634 : 76 : return false; /* end of scan */
4635 : :
4636 : 136 : JsonTableRescan(planstate->right);
4637 : :
4638 [ + + ]: 136 : if (!JsonTablePlanNextRow(planstate->right))
4639 : 64 : continue; /* next outer row */
4640 : :
4641 : 72 : planstate->advanceRight = true; /* next inner row */
4642 : : }
4643 [ + + ]: 540 : else if (!more)
4644 : : {
4645 [ + + ]: 168 : if (!JsonTablePlanNextRow(planstate->right))
4646 : 64 : return false; /* end of scan */
4647 : :
4648 : 104 : planstate->advanceRight = true; /* next inner row */
4649 : : }
4650 : :
4651 : 548 : break;
4652 : : }
4653 : : }
4654 : : else
4655 : : {
4656 : : /* reset context item if requested */
4657 [ + + ]: 3488 : if (planstate->reset)
4658 : : {
4659 : 718 : JsonTablePlanState *parent = planstate->parent;
4660 : :
4661 [ + - - + ]: 718 : Assert(parent != NULL && !parent->current.isnull);
4662 : 718 : JsonTableResetRowPattern(planstate, parent->current.value);
4663 : 718 : planstate->reset = false;
4664 : : }
4665 : :
4666 [ + + ]: 3488 : if (planstate->advanceNested)
4667 : : {
4668 : : /* fetch next nested row */
4669 : 974 : planstate->advanceNested = JsonTablePlanNextRow(planstate->nested);
4670 [ + + ]: 974 : if (planstate->advanceNested)
4671 : 672 : return true;
4672 : : }
4673 : :
4674 : : for (;;)
4675 : : {
4676 [ + + ]: 2872 : if (!JsonTablePlanScanNextRow(planstate))
4677 : 1148 : return false;
4678 : :
4679 [ + + ]: 1724 : if (planstate->nested == NULL)
4680 : 1226 : break;
4681 : :
4682 : 498 : JsonTableResetNestedPlan(planstate->nested);
4683 : 498 : planstate->advanceNested = JsonTablePlanNextRow(planstate->nested);
4684 : :
4685 [ + + + + ]: 498 : if (!planstate->advanceNested && !planstate->outerJoin)
4686 : 56 : 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 : 442 : break;
4694 : : }
4695 : : }
4696 : :
4697 : 2216 : 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 : : */
4708 : : static bool
838 amitlan@postgresql.o 4709 :CBC 2872 : JsonTablePlanScanNextRow(JsonTablePlanState *planstate)
4710 : : {
4711 : : JsonbValue *jbv;
4712 : : MemoryContext oldcxt;
4713 : :
4714 : : /* Fetch new row from the list of found values to set as active. */
128 tgl@sss.pgh.pa.us 4715 : 2872 : jbv = JsonValueListNext(&planstate->iter);
4716 : :
4717 : : /* End of list? */
842 amitlan@postgresql.o 4718 [ + + ]: 2872 : if (jbv == NULL)
4719 : : {
4720 : 1148 : planstate->current.value = PointerGetDatum(NULL);
4721 : 1148 : planstate->current.isnull = true;
4722 : 1148 : return false;
4723 : : }
4724 : :
4725 : : /*
4726 : : * Set current row item for subsequent JsonTableGetValue() calls for
4727 : : * evaluating individual columns.
4728 : : */
4729 : 1724 : oldcxt = MemoryContextSwitchTo(planstate->mcxt);
4730 : 1724 : planstate->current.value = JsonbPGetDatum(JsonbValueToJsonb(jbv));
4731 : 1724 : planstate->current.isnull = false;
4732 : 1724 : MemoryContextSwitchTo(oldcxt);
4733 : :
4734 : : /* Next row! */
4735 : 1724 : planstate->ordinal++;
4736 : :
4737 : : /* There are more rows. */
838 4738 : 1724 : return true;
4739 : : }
4740 : :
4741 : : /*
4742 : : * Re-evaluate the row pattern of a nested plan using the new parent row
4743 : : * pattern.
4744 : : */
4745 : : static void
4746 : 1107 : JsonTableResetNestedPlan(JsonTablePlanState *planstate)
4747 : : {
4748 : : /* This better be a child plan. */
4749 [ - + ]: 1107 : Assert(planstate->parent != NULL);
4750 [ + + ]: 1107 : if (IsA(planstate->plan, JsonTablePathScan))
4751 : : {
4752 : 863 : JsonTablePlanState *parent = planstate->parent;
4753 : :
16 akorotkov@postgresql 4754 :GNC 863 : planstate->reset = true;
4755 : 863 : planstate->advanceNested = false;
4756 : :
4757 [ + + ]: 863 : if (planstate->nested)
4758 : 121 : 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 [ + + ]: 863 : if (!parent->current.isnull)
10 4768 : 742 : JsonTableRescan(planstate);
4769 : : }
838 amitlan@postgresql.o 4770 [ + - ]:CBC 244 : else if (IsA(planstate->plan, JsonTableSiblingJoin))
4771 : : {
4772 : 244 : JsonTableResetNestedPlan(planstate->left);
4773 : 244 : JsonTableResetNestedPlan(planstate->right);
16 akorotkov@postgresql 4774 :GNC 244 : planstate->advanceRight = false;
4775 : : }
838 amitlan@postgresql.o 4776 :CBC 1107 : }
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 : : */
4784 : : static bool
842 4785 : 1576 : JsonTableFetchRow(TableFuncScanState *state)
4786 : : {
4787 : : JsonTableExecContext *cxt =
4788 : 1576 : GetJsonTableExecContext(state, "JsonTableFetchRow");
4789 : :
4790 : 1576 : 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 : : */
4800 : : static Datum
4801 : 5142 : JsonTableGetValue(TableFuncScanState *state, int colnum,
4802 : : Oid typid, int32 typmod, bool *isnull)
4803 : : {
4804 : : JsonTableExecContext *cxt =
4805 : 5142 : GetJsonTableExecContext(state, "JsonTableGetValue");
4806 : 5142 : ExprContext *econtext = state->ss.ps.ps_ExprContext;
4807 : 5142 : ExprState *estate = list_nth(state->colvalexprs, colnum);
838 4808 : 5142 : JsonTablePlanState *planstate = cxt->colplanstates[colnum];
842 4809 : 5142 : JsonTablePlanRowSource *current = &planstate->current;
4810 : : Datum result;
4811 : :
4812 : : /* Row pattern value is NULL */
4813 [ + + ]: 5142 : if (current->isnull)
4814 : : {
4815 : 972 : result = (Datum) 0;
4816 : 972 : *isnull = true;
4817 : : }
4818 : : /* Evaluate JsonExpr. */
4819 [ + + ]: 4170 : else if (estate)
4820 : : {
4821 : 3410 : Datum saved_caseValue = econtext->caseValue_datum;
4822 : 3410 : bool saved_caseIsNull = econtext->caseValue_isNull;
4823 : :
4824 : : /* Pass the row pattern value via CaseTestExpr. */
4825 : 3410 : econtext->caseValue_datum = current->value;
4826 : 3410 : econtext->caseValue_isNull = false;
4827 : :
4828 : 3410 : result = ExecEvalExpr(estate, econtext, isnull);
4829 : :
4830 : 3350 : econtext->caseValue_datum = saved_caseValue;
4831 : 3350 : econtext->caseValue_isNull = saved_caseIsNull;
4832 : : }
4833 : : /* ORDINAL column */
4834 : : else
4835 : : {
4836 : 760 : result = Int32GetDatum(planstate->ordinal);
4837 : 760 : *isnull = false;
4838 : : }
4839 : :
4840 : 5082 : return result;
4841 : : }
4842 : :
4843 : : /* Recursively reset planstate and its child nodes */
4844 : : static void
16 akorotkov@postgresql 4845 :GNC 2754 : JsonTableRescan(JsonTablePlanState *planstate)
4846 : : {
4847 [ + + ]: 2754 : if (IsA(planstate->plan, JsonTablePathScan))
4848 : : {
4849 : : /* Reset plan iterator to the beginning of the item list */
4850 : 2630 : JsonValueListInitIterator(&planstate->found, &planstate->iter);
4851 : 2630 : planstate->current.value = PointerGetDatum(NULL);
4852 : 2630 : planstate->current.isnull = true;
4853 : 2630 : planstate->ordinal = 0;
4854 : :
4855 [ + + ]: 2630 : if (planstate->nested)
4856 : 504 : JsonTableRescan(planstate->nested);
4857 : : }
4858 [ + - ]: 124 : else if (IsA(planstate->plan, JsonTableSiblingJoin))
4859 : : {
4860 : 124 : JsonTableRescan(planstate->left);
4861 : 124 : JsonTableRescan(planstate->right);
4862 : 124 : planstate->advanceRight = false;
4863 : : }
4864 : 2754 : }
|
