Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * jsonpath.c
4 : * Input/output and supporting routines for jsonpath
5 : *
6 : * jsonpath expression is a chain of path items. First path item is $, $var,
7 : * literal or arithmetic expression. Subsequent path items are accessors
8 : * (.key, .*, [subscripts], [*]), filters (? (predicate)) and methods (.type(),
9 : * .size() etc).
10 : *
11 : * For instance, structure of path items for simple expression:
12 : *
13 : * $.a[*].type()
14 : *
15 : * is pretty evident:
16 : *
17 : * $ => .a => [*] => .type()
18 : *
19 : * Some path items such as arithmetic operations, predicates or array
20 : * subscripts may comprise subtrees. For instance, more complex expression
21 : *
22 : * ($.a + $[1 to 5, 7] ? (@ > 3).double()).type()
23 : *
24 : * have following structure of path items:
25 : *
26 : * + => .type()
27 : * ___/ \___
28 : * / \
29 : * $ => .a $ => [] => ? => .double()
30 : * _||_ |
31 : * / \ >
32 : * to to / \
33 : * / \ / @ 3
34 : * 1 5 7
35 : *
36 : * Binary encoding of jsonpath constitutes a sequence of 4-bytes aligned
37 : * variable-length path items connected by links. Every item has a header
38 : * consisting of item type (enum JsonPathItemType) and offset of next item
39 : * (zero means no next item). After the header, item may have payload
40 : * depending on item type. For instance, payload of '.key' accessor item is
41 : * length of key name and key name itself. Payload of '>' arithmetic operator
42 : * item is offsets of right and left operands.
43 : *
44 : * So, binary representation of sample expression above is:
45 : * (bottom arrows are next links, top lines are argument links)
46 : *
47 : * _____
48 : * _____ ___/____ \ __
49 : * _ /_ \ _____/__/____ \ \ __ _ /_ \
50 : * / / \ \ / / / \ \ \ / \ / / \ \
51 : * +(LR) $ .a $ [](* to *, * to *) 1 5 7 ?(A) >(LR) @ 3 .double() .type()
52 : * | | ^ | ^| ^| ^ ^
53 : * | |__| |__||________________________||___________________| |
54 : * |_______________________________________________________________________|
55 : *
56 : * Copyright (c) 2019, PostgreSQL Global Development Group
57 : *
58 : * IDENTIFICATION
59 : * src/backend/utils/adt/jsonpath.c
60 : *
61 : *-------------------------------------------------------------------------
62 : */
63 :
64 : #include "postgres.h"
65 :
66 : #include "funcapi.h"
67 : #include "lib/stringinfo.h"
68 : #include "libpq/pqformat.h"
69 : #include "miscadmin.h"
70 : #include "utils/builtins.h"
71 : #include "utils/json.h"
72 : #include "utils/jsonpath.h"
73 :
74 :
75 : static Datum jsonPathFromCstring(char *in, int len);
76 : static char *jsonPathToCstring(StringInfo out, JsonPath *in,
77 : int estimated_len);
78 : static int flattenJsonPathParseItem(StringInfo buf, JsonPathParseItem *item,
79 : int nestingLevel, bool insideArraySubscript);
80 : static void alignStringInfoInt(StringInfo buf);
81 : static int32 reserveSpaceForItemPointer(StringInfo buf);
82 : static void printJsonPathItem(StringInfo buf, JsonPathItem *v, bool inKey,
83 : bool printBracketes);
84 : static int operationPriority(JsonPathItemType op);
85 :
86 :
87 : /**************************** INPUT/OUTPUT ********************************/
88 :
89 : /*
90 : * jsonpath type input function
91 : */
92 : Datum
93 2384 : jsonpath_in(PG_FUNCTION_ARGS)
94 : {
95 2384 : char *in = PG_GETARG_CSTRING(0);
96 2384 : int len = strlen(in);
97 :
98 2384 : return jsonPathFromCstring(in, len);
99 : }
100 :
101 : /*
102 : * jsonpath type recv function
103 : *
104 : * The type is sent as text in binary mode, so this is almost the same
105 : * as the input function, but it's prefixed with a version number so we
106 : * can change the binary format sent in future if necessary. For now,
107 : * only version 1 is supported.
108 : */
109 : Datum
110 0 : jsonpath_recv(PG_FUNCTION_ARGS)
111 : {
112 0 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
113 0 : int version = pq_getmsgint(buf, 1);
114 : char *str;
115 : int nbytes;
116 :
117 0 : if (version == JSONPATH_VERSION)
118 0 : str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
119 : else
120 0 : elog(ERROR, "unsupported jsonpath version number: %d", version);
121 :
122 0 : return jsonPathFromCstring(str, nbytes);
123 : }
124 :
125 : /*
126 : * jsonpath type output function
127 : */
128 : Datum
129 652 : jsonpath_out(PG_FUNCTION_ARGS)
130 : {
131 652 : JsonPath *in = PG_GETARG_JSONPATH_P(0);
132 :
133 652 : PG_RETURN_CSTRING(jsonPathToCstring(NULL, in, VARSIZE(in)));
134 : }
135 :
136 : /*
137 : * jsonpath type send function
138 : *
139 : * Just send jsonpath as a version number, then a string of text
140 : */
141 : Datum
142 0 : jsonpath_send(PG_FUNCTION_ARGS)
143 : {
144 0 : JsonPath *in = PG_GETARG_JSONPATH_P(0);
145 : StringInfoData buf;
146 : StringInfoData jtext;
147 0 : int version = JSONPATH_VERSION;
148 :
149 0 : initStringInfo(&jtext);
150 0 : (void) jsonPathToCstring(&jtext, in, VARSIZE(in));
151 :
152 0 : pq_begintypsend(&buf);
153 0 : pq_sendint8(&buf, version);
154 0 : pq_sendtext(&buf, jtext.data, jtext.len);
155 0 : pfree(jtext.data);
156 :
157 0 : PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
158 : }
159 :
160 : /*
161 : * Converts C-string to a jsonpath value.
162 : *
163 : * Uses jsonpath parser to turn string into an AST, then
164 : * flattenJsonPathParseItem() does second pass turning AST into binary
165 : * representation of jsonpath.
166 : */
167 : static Datum
168 2384 : jsonPathFromCstring(char *in, int len)
169 : {
170 2384 : JsonPathParseResult *jsonpath = parsejsonpath(in, len);
171 : JsonPath *res;
172 : StringInfoData buf;
173 :
174 2224 : initStringInfo(&buf);
175 2224 : enlargeStringInfo(&buf, 4 * len /* estimation */ );
176 :
177 2224 : appendStringInfoSpaces(&buf, JSONPATH_HDRSZ);
178 :
179 2224 : if (!jsonpath)
180 4 : ereport(ERROR,
181 : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
182 : errmsg("invalid input syntax for type %s: \"%s\"", "jsonpath",
183 : in)));
184 :
185 2220 : flattenJsonPathParseItem(&buf, jsonpath->expr, 0, false);
186 :
187 2208 : res = (JsonPath *) buf.data;
188 2208 : SET_VARSIZE(res, buf.len);
189 2208 : res->header = JSONPATH_VERSION;
190 2208 : if (jsonpath->lax)
191 1976 : res->header |= JSONPATH_LAX;
192 :
193 2208 : PG_RETURN_JSONPATH_P(res);
194 : }
195 :
196 : /*
197 : * Converts jsonpath value to a C-string.
198 : *
199 : * If 'out' argument is non-null, the resulting C-string is stored inside the
200 : * StringBuffer. The resulting string is always returned.
201 : */
202 : static char *
203 652 : jsonPathToCstring(StringInfo out, JsonPath *in, int estimated_len)
204 : {
205 : StringInfoData buf;
206 : JsonPathItem v;
207 :
208 652 : if (!out)
209 : {
210 652 : out = &buf;
211 652 : initStringInfo(out);
212 : }
213 652 : enlargeStringInfo(out, estimated_len);
214 :
215 652 : if (!(in->header & JSONPATH_LAX))
216 4 : appendBinaryStringInfo(out, "strict ", 7);
217 :
218 652 : jspInit(&v, in);
219 652 : printJsonPathItem(out, &v, false, true);
220 :
221 652 : return out->data;
222 : }
223 :
224 : /*
225 : * Recursive function converting given jsonpath parse item and all its
226 : * children into a binary representation.
227 : */
228 : static int
229 10596 : flattenJsonPathParseItem(StringInfo buf, JsonPathParseItem *item,
230 : int nestingLevel, bool insideArraySubscript)
231 : {
232 : /* position from beginning of jsonpath data */
233 10596 : int32 pos = buf->len - JSONPATH_HDRSZ;
234 : int32 chld;
235 : int32 next;
236 10596 : int argNestingLevel = 0;
237 :
238 10596 : check_stack_depth();
239 10596 : CHECK_FOR_INTERRUPTS();
240 :
241 10596 : appendStringInfoChar(buf, (char) (item->type));
242 :
243 : /*
244 : * We align buffer to int32 because a series of int32 values often goes
245 : * after the header, and we want to read them directly by dereferencing
246 : * int32 pointer (see jspInitByBuffer()).
247 : */
248 10596 : alignStringInfoInt(buf);
249 :
250 : /*
251 : * Reserve space for next item pointer. Actual value will be recorded
252 : * later, after next and children items processing.
253 : */
254 10596 : next = reserveSpaceForItemPointer(buf);
255 :
256 10596 : switch (item->type)
257 : {
258 : case jpiString:
259 : case jpiVariable:
260 : case jpiKey:
261 2112 : appendBinaryStringInfo(buf, (char *) &item->value.string.len,
262 : sizeof(item->value.string.len));
263 2112 : appendBinaryStringInfo(buf, item->value.string.val,
264 2112 : item->value.string.len);
265 2112 : appendStringInfoChar(buf, '\0');
266 2112 : break;
267 : case jpiNumeric:
268 1024 : appendBinaryStringInfo(buf, (char *) item->value.numeric,
269 1024 : VARSIZE(item->value.numeric));
270 1024 : break;
271 : case jpiBool:
272 104 : appendBinaryStringInfo(buf, (char *) &item->value.boolean,
273 : sizeof(item->value.boolean));
274 104 : break;
275 : case jpiAnd:
276 : case jpiOr:
277 : case jpiEqual:
278 : case jpiNotEqual:
279 : case jpiLess:
280 : case jpiGreater:
281 : case jpiLessOrEqual:
282 : case jpiGreaterOrEqual:
283 : case jpiAdd:
284 : case jpiSub:
285 : case jpiMul:
286 : case jpiDiv:
287 : case jpiMod:
288 : case jpiStartsWith:
289 : {
290 : /*
291 : * First, reserve place for left/right arg's positions, then
292 : * record both args and sets actual position in reserved
293 : * places.
294 : */
295 1488 : int32 left = reserveSpaceForItemPointer(buf);
296 1488 : int32 right = reserveSpaceForItemPointer(buf);
297 :
298 2976 : chld = !item->value.args.left ? pos :
299 1488 : flattenJsonPathParseItem(buf, item->value.args.left,
300 : nestingLevel + argNestingLevel,
301 : insideArraySubscript);
302 1480 : *(int32 *) (buf->data + left) = chld - pos;
303 :
304 2960 : chld = !item->value.args.right ? pos :
305 1480 : flattenJsonPathParseItem(buf, item->value.args.right,
306 : nestingLevel + argNestingLevel,
307 : insideArraySubscript);
308 1480 : *(int32 *) (buf->data + right) = chld - pos;
309 : }
310 1480 : break;
311 : case jpiLikeRegex:
312 : {
313 : int32 offs;
314 :
315 40 : appendBinaryStringInfo(buf,
316 40 : (char *) &item->value.like_regex.flags,
317 : sizeof(item->value.like_regex.flags));
318 40 : offs = reserveSpaceForItemPointer(buf);
319 40 : appendBinaryStringInfo(buf,
320 40 : (char *) &item->value.like_regex.patternlen,
321 : sizeof(item->value.like_regex.patternlen));
322 40 : appendBinaryStringInfo(buf, item->value.like_regex.pattern,
323 40 : item->value.like_regex.patternlen);
324 40 : appendStringInfoChar(buf, '\0');
325 :
326 40 : chld = flattenJsonPathParseItem(buf, item->value.like_regex.expr,
327 : nestingLevel,
328 : insideArraySubscript);
329 40 : *(int32 *) (buf->data + offs) = chld - pos;
330 : }
331 40 : break;
332 : case jpiFilter:
333 876 : argNestingLevel++;
334 : /* FALLTHROUGH */
335 : case jpiIsUnknown:
336 : case jpiNot:
337 : case jpiPlus:
338 : case jpiMinus:
339 : case jpiExists:
340 : {
341 1224 : int32 arg = reserveSpaceForItemPointer(buf);
342 :
343 1224 : chld = flattenJsonPathParseItem(buf, item->value.arg,
344 : nestingLevel + argNestingLevel,
345 : insideArraySubscript);
346 1220 : *(int32 *) (buf->data + arg) = chld - pos;
347 : }
348 1220 : break;
349 : case jpiNull:
350 76 : break;
351 : case jpiRoot:
352 2072 : break;
353 : case jpiAnyArray:
354 : case jpiAnyKey:
355 592 : break;
356 : case jpiCurrent:
357 1052 : if (nestingLevel <= 0)
358 4 : ereport(ERROR,
359 : (errcode(ERRCODE_SYNTAX_ERROR),
360 : errmsg("@ is not allowed in root expressions")));
361 1048 : break;
362 : case jpiLast:
363 60 : if (!insideArraySubscript)
364 8 : ereport(ERROR,
365 : (errcode(ERRCODE_SYNTAX_ERROR),
366 : errmsg("LAST is allowed only in array subscripts")));
367 52 : break;
368 : case jpiIndexArray:
369 : {
370 224 : int32 nelems = item->value.array.nelems;
371 : int offset;
372 : int i;
373 :
374 224 : appendBinaryStringInfo(buf, (char *) &nelems, sizeof(nelems));
375 :
376 224 : offset = buf->len;
377 :
378 224 : appendStringInfoSpaces(buf, sizeof(int32) * 2 * nelems);
379 :
380 468 : for (i = 0; i < nelems; i++)
381 : {
382 : int32 *ppos;
383 : int32 topos;
384 244 : int32 frompos =
385 244 : flattenJsonPathParseItem(buf,
386 244 : item->value.array.elems[i].from,
387 : nestingLevel, true) - pos;
388 :
389 244 : if (item->value.array.elems[i].to)
390 28 : topos = flattenJsonPathParseItem(buf,
391 28 : item->value.array.elems[i].to,
392 : nestingLevel, true) - pos;
393 : else
394 216 : topos = 0;
395 :
396 244 : ppos = (int32 *) &buf->data[offset + i * 2 * sizeof(int32)];
397 :
398 244 : ppos[0] = frompos;
399 244 : ppos[1] = topos;
400 : }
401 : }
402 224 : break;
403 : case jpiAny:
404 236 : appendBinaryStringInfo(buf,
405 236 : (char *) &item->value.anybounds.first,
406 : sizeof(item->value.anybounds.first));
407 236 : appendBinaryStringInfo(buf,
408 236 : (char *) &item->value.anybounds.last,
409 : sizeof(item->value.anybounds.last));
410 236 : break;
411 : case jpiType:
412 : case jpiSize:
413 : case jpiAbs:
414 : case jpiFloor:
415 : case jpiCeiling:
416 : case jpiDouble:
417 : case jpiKeyValue:
418 292 : break;
419 : default:
420 0 : elog(ERROR, "unrecognized jsonpath item type: %d", item->type);
421 : }
422 :
423 10572 : if (item->next)
424 : {
425 3872 : chld = flattenJsonPathParseItem(buf, item->next, nestingLevel,
426 : insideArraySubscript) - pos;
427 3868 : *(int32 *) (buf->data + next) = chld;
428 : }
429 :
430 10568 : return pos;
431 : }
432 :
433 : /*
434 : * Align StringInfo to int by adding zero padding bytes
435 : */
436 : static void
437 10596 : alignStringInfoInt(StringInfo buf)
438 : {
439 10596 : switch (INTALIGN(buf->len) - buf->len)
440 : {
441 : case 3:
442 9208 : appendStringInfoCharMacro(buf, 0);
443 : /* FALLTHROUGH */
444 : case 2:
445 9384 : appendStringInfoCharMacro(buf, 0);
446 : /* FALLTHROUGH */
447 : case 1:
448 10512 : appendStringInfoCharMacro(buf, 0);
449 : /* FALLTHROUGH */
450 : default:
451 10596 : break;
452 : }
453 10596 : }
454 :
455 : /*
456 : * Reserve space for int32 JsonPathItem pointer. Now zero pointer is written,
457 : * actual value will be recorded at '(int32 *) &buf->data[pos]' later.
458 : */
459 : static int32
460 14836 : reserveSpaceForItemPointer(StringInfo buf)
461 : {
462 14836 : int32 pos = buf->len;
463 14836 : int32 ptr = 0;
464 :
465 14836 : appendBinaryStringInfo(buf, (char *) &ptr, sizeof(ptr));
466 :
467 14836 : return pos;
468 : }
469 :
470 : /*
471 : * Prints text representation of given jsonpath item and all its children.
472 : */
473 : static void
474 3040 : printJsonPathItem(StringInfo buf, JsonPathItem *v, bool inKey,
475 : bool printBracketes)
476 : {
477 : JsonPathItem elem;
478 : int i;
479 :
480 3040 : check_stack_depth();
481 3040 : CHECK_FOR_INTERRUPTS();
482 :
483 3040 : switch (v->type)
484 : {
485 : case jpiNull:
486 28 : appendStringInfoString(buf, "null");
487 28 : break;
488 : case jpiKey:
489 656 : if (inKey)
490 656 : appendStringInfoChar(buf, '.');
491 656 : escape_json(buf, jspGetString(v, NULL));
492 656 : break;
493 : case jpiString:
494 76 : escape_json(buf, jspGetString(v, NULL));
495 76 : break;
496 : case jpiVariable:
497 32 : appendStringInfoChar(buf, '$');
498 32 : escape_json(buf, jspGetString(v, NULL));
499 32 : break;
500 : case jpiNumeric:
501 452 : appendStringInfoString(buf,
502 452 : DatumGetCString(DirectFunctionCall1(numeric_out,
503 : NumericGetDatum(jspGetNumeric(v)))));
504 452 : break;
505 : case jpiBool:
506 8 : if (jspGetBool(v))
507 4 : appendBinaryStringInfo(buf, "true", 4);
508 : else
509 4 : appendBinaryStringInfo(buf, "false", 5);
510 8 : break;
511 : case jpiAnd:
512 : case jpiOr:
513 : case jpiEqual:
514 : case jpiNotEqual:
515 : case jpiLess:
516 : case jpiGreater:
517 : case jpiLessOrEqual:
518 : case jpiGreaterOrEqual:
519 : case jpiAdd:
520 : case jpiSub:
521 : case jpiMul:
522 : case jpiDiv:
523 : case jpiMod:
524 : case jpiStartsWith:
525 436 : if (printBracketes)
526 76 : appendStringInfoChar(buf, '(');
527 436 : jspGetLeftArg(v, &elem);
528 436 : printJsonPathItem(buf, &elem, false,
529 436 : operationPriority(elem.type) <=
530 436 : operationPriority(v->type));
531 436 : appendStringInfoChar(buf, ' ');
532 436 : appendStringInfoString(buf, jspOperationName(v->type));
533 436 : appendStringInfoChar(buf, ' ');
534 436 : jspGetRightArg(v, &elem);
535 436 : printJsonPathItem(buf, &elem, false,
536 436 : operationPriority(elem.type) <=
537 436 : operationPriority(v->type));
538 436 : if (printBracketes)
539 76 : appendStringInfoChar(buf, ')');
540 436 : break;
541 : case jpiLikeRegex:
542 24 : if (printBracketes)
543 0 : appendStringInfoChar(buf, '(');
544 :
545 24 : jspInitByBuffer(&elem, v->base, v->content.like_regex.expr);
546 24 : printJsonPathItem(buf, &elem, false,
547 24 : operationPriority(elem.type) <=
548 24 : operationPriority(v->type));
549 :
550 24 : appendBinaryStringInfo(buf, " like_regex ", 12);
551 :
552 24 : escape_json(buf, v->content.like_regex.pattern);
553 :
554 24 : if (v->content.like_regex.flags)
555 : {
556 16 : appendBinaryStringInfo(buf, " flag \"", 7);
557 :
558 16 : if (v->content.like_regex.flags & JSP_REGEX_ICASE)
559 12 : appendStringInfoChar(buf, 'i');
560 16 : if (v->content.like_regex.flags & JSP_REGEX_SLINE)
561 8 : appendStringInfoChar(buf, 's');
562 16 : if (v->content.like_regex.flags & JSP_REGEX_MLINE)
563 4 : appendStringInfoChar(buf, 'm');
564 16 : if (v->content.like_regex.flags & JSP_REGEX_WSPACE)
565 4 : appendStringInfoChar(buf, 'x');
566 :
567 16 : appendStringInfoChar(buf, '"');
568 : }
569 :
570 24 : if (printBracketes)
571 0 : appendStringInfoChar(buf, ')');
572 24 : break;
573 : case jpiPlus:
574 : case jpiMinus:
575 32 : if (printBracketes)
576 12 : appendStringInfoChar(buf, '(');
577 32 : appendStringInfoChar(buf, v->type == jpiPlus ? '+' : '-');
578 32 : jspGetArg(v, &elem);
579 32 : printJsonPathItem(buf, &elem, false,
580 32 : operationPriority(elem.type) <=
581 32 : operationPriority(v->type));
582 32 : if (printBracketes)
583 12 : appendStringInfoChar(buf, ')');
584 32 : break;
585 : case jpiFilter:
586 272 : appendBinaryStringInfo(buf, "?(", 2);
587 272 : jspGetArg(v, &elem);
588 272 : printJsonPathItem(buf, &elem, false, false);
589 272 : appendStringInfoChar(buf, ')');
590 272 : break;
591 : case jpiNot:
592 8 : appendBinaryStringInfo(buf, "!(", 2);
593 8 : jspGetArg(v, &elem);
594 8 : printJsonPathItem(buf, &elem, false, false);
595 8 : appendStringInfoChar(buf, ')');
596 8 : break;
597 : case jpiIsUnknown:
598 4 : appendStringInfoChar(buf, '(');
599 4 : jspGetArg(v, &elem);
600 4 : printJsonPathItem(buf, &elem, false, false);
601 4 : appendBinaryStringInfo(buf, ") is unknown", 12);
602 4 : break;
603 : case jpiExists:
604 16 : appendBinaryStringInfo(buf, "exists (", 8);
605 16 : jspGetArg(v, &elem);
606 16 : printJsonPathItem(buf, &elem, false, false);
607 16 : appendStringInfoChar(buf, ')');
608 16 : break;
609 : case jpiCurrent:
610 : Assert(!inKey);
611 324 : appendStringInfoChar(buf, '@');
612 324 : break;
613 : case jpiRoot:
614 : Assert(!inKey);
615 492 : appendStringInfoChar(buf, '$');
616 492 : break;
617 : case jpiLast:
618 8 : appendBinaryStringInfo(buf, "last", 4);
619 8 : break;
620 : case jpiAnyArray:
621 44 : appendBinaryStringInfo(buf, "[*]", 3);
622 44 : break;
623 : case jpiAnyKey:
624 8 : if (inKey)
625 8 : appendStringInfoChar(buf, '.');
626 8 : appendStringInfoChar(buf, '*');
627 8 : break;
628 : case jpiIndexArray:
629 40 : appendStringInfoChar(buf, '[');
630 92 : for (i = 0; i < v->content.array.nelems; i++)
631 : {
632 : JsonPathItem from;
633 : JsonPathItem to;
634 52 : bool range = jspGetArraySubscript(v, &from, &to, i);
635 :
636 52 : if (i)
637 12 : appendStringInfoChar(buf, ',');
638 :
639 52 : printJsonPathItem(buf, &from, false, false);
640 :
641 52 : if (range)
642 : {
643 8 : appendBinaryStringInfo(buf, " to ", 4);
644 8 : printJsonPathItem(buf, &to, false, false);
645 : }
646 : }
647 40 : appendStringInfoChar(buf, ']');
648 40 : break;
649 : case jpiAny:
650 32 : if (inKey)
651 32 : appendStringInfoChar(buf, '.');
652 :
653 40 : if (v->content.anybounds.first == 0 &&
654 8 : v->content.anybounds.last == PG_UINT32_MAX)
655 4 : appendBinaryStringInfo(buf, "**", 2);
656 28 : else if (v->content.anybounds.first == v->content.anybounds.last)
657 : {
658 12 : if (v->content.anybounds.first == PG_UINT32_MAX)
659 4 : appendStringInfo(buf, "**{last}");
660 : else
661 8 : appendStringInfo(buf, "**{%u}",
662 : v->content.anybounds.first);
663 : }
664 16 : else if (v->content.anybounds.first == PG_UINT32_MAX)
665 4 : appendStringInfo(buf, "**{last to %u}",
666 : v->content.anybounds.last);
667 12 : else if (v->content.anybounds.last == PG_UINT32_MAX)
668 4 : appendStringInfo(buf, "**{%u to last}",
669 : v->content.anybounds.first);
670 : else
671 8 : appendStringInfo(buf, "**{%u to %u}",
672 : v->content.anybounds.first,
673 : v->content.anybounds.last);
674 32 : break;
675 : case jpiType:
676 24 : appendBinaryStringInfo(buf, ".type()", 7);
677 24 : break;
678 : case jpiSize:
679 4 : appendBinaryStringInfo(buf, ".size()", 7);
680 4 : break;
681 : case jpiAbs:
682 4 : appendBinaryStringInfo(buf, ".abs()", 6);
683 4 : break;
684 : case jpiFloor:
685 4 : appendBinaryStringInfo(buf, ".floor()", 8);
686 4 : break;
687 : case jpiCeiling:
688 4 : appendBinaryStringInfo(buf, ".ceiling()", 10);
689 4 : break;
690 : case jpiDouble:
691 4 : appendBinaryStringInfo(buf, ".double()", 9);
692 4 : break;
693 : case jpiKeyValue:
694 4 : appendBinaryStringInfo(buf, ".keyvalue()", 11);
695 4 : break;
696 : default:
697 0 : elog(ERROR, "unrecognized jsonpath item type: %d", v->type);
698 : }
699 :
700 3040 : if (jspGetNext(v, &elem))
701 1100 : printJsonPathItem(buf, &elem, true, true);
702 3040 : }
703 :
704 : const char *
705 512 : jspOperationName(JsonPathItemType type)
706 : {
707 512 : switch (type)
708 : {
709 : case jpiAnd:
710 20 : return "&&";
711 : case jpiOr:
712 36 : return "||";
713 : case jpiEqual:
714 108 : return "==";
715 : case jpiNotEqual:
716 4 : return "!=";
717 : case jpiLess:
718 152 : return "<";
719 : case jpiGreater:
720 16 : return ">";
721 : case jpiLessOrEqual:
722 4 : return "<=";
723 : case jpiGreaterOrEqual:
724 20 : return ">=";
725 : case jpiPlus:
726 : case jpiAdd:
727 48 : return "+";
728 : case jpiMinus:
729 : case jpiSub:
730 16 : return "-";
731 : case jpiMul:
732 16 : return "*";
733 : case jpiDiv:
734 4 : return "/";
735 : case jpiMod:
736 4 : return "%";
737 : case jpiStartsWith:
738 8 : return "starts with";
739 : case jpiLikeRegex:
740 0 : return "like_regex";
741 : case jpiType:
742 0 : return "type";
743 : case jpiSize:
744 4 : return "size";
745 : case jpiKeyValue:
746 12 : return "keyvalue";
747 : case jpiDouble:
748 28 : return "double";
749 : case jpiAbs:
750 4 : return "abs";
751 : case jpiFloor:
752 4 : return "floor";
753 : case jpiCeiling:
754 4 : return "ceiling";
755 : default:
756 0 : elog(ERROR, "unrecognized jsonpath item type: %d", type);
757 : return NULL;
758 : }
759 : }
760 :
761 : static int
762 1856 : operationPriority(JsonPathItemType op)
763 : {
764 1856 : switch (op)
765 : {
766 : case jpiOr:
767 76 : return 0;
768 : case jpiAnd:
769 52 : return 1;
770 : case jpiEqual:
771 : case jpiNotEqual:
772 : case jpiLess:
773 : case jpiGreater:
774 : case jpiLessOrEqual:
775 : case jpiGreaterOrEqual:
776 : case jpiStartsWith:
777 708 : return 2;
778 : case jpiAdd:
779 : case jpiSub:
780 120 : return 3;
781 : case jpiMul:
782 : case jpiDiv:
783 : case jpiMod:
784 44 : return 4;
785 : case jpiPlus:
786 : case jpiMinus:
787 56 : return 5;
788 : default:
789 800 : return 6;
790 : }
791 : }
792 :
793 : /******************* Support functions for JsonPath *************************/
794 :
795 : /*
796 : * Support macros to read stored values
797 : */
798 :
799 : #define read_byte(v, b, p) do { \
800 : (v) = *(uint8*)((b) + (p)); \
801 : (p) += 1; \
802 : } while(0) \
803 :
804 : #define read_int32(v, b, p) do { \
805 : (v) = *(uint32*)((b) + (p)); \
806 : (p) += sizeof(int32); \
807 : } while(0) \
808 :
809 : #define read_int32_n(v, b, p, n) do { \
810 : (v) = (void *)((b) + (p)); \
811 : (p) += sizeof(int32) * (n); \
812 : } while(0) \
813 :
814 : /*
815 : * Read root node and fill root node representation
816 : */
817 : void
818 124576 : jspInit(JsonPathItem *v, JsonPath *js)
819 : {
820 : Assert((js->header & ~JSONPATH_LAX) == JSONPATH_VERSION);
821 124576 : jspInitByBuffer(v, js->data, 0);
822 124576 : }
823 :
824 : /*
825 : * Read node from buffer and fill its representation
826 : */
827 : void
828 412908 : jspInitByBuffer(JsonPathItem *v, char *base, int32 pos)
829 : {
830 412908 : v->base = base + pos;
831 :
832 412908 : read_byte(v->type, base, pos);
833 412908 : pos = INTALIGN((uintptr_t) (base + pos)) - (uintptr_t) base;
834 412908 : read_int32(v->nextPos, base, pos);
835 :
836 412908 : switch (v->type)
837 : {
838 : case jpiNull:
839 : case jpiRoot:
840 : case jpiCurrent:
841 : case jpiAnyArray:
842 : case jpiAnyKey:
843 : case jpiType:
844 : case jpiSize:
845 : case jpiAbs:
846 : case jpiFloor:
847 : case jpiCeiling:
848 : case jpiDouble:
849 : case jpiKeyValue:
850 : case jpiLast:
851 151484 : break;
852 : case jpiKey:
853 : case jpiString:
854 : case jpiVariable:
855 122680 : read_int32(v->content.value.datalen, base, pos);
856 : /* FALLTHROUGH */
857 : case jpiNumeric:
858 : case jpiBool:
859 137092 : v->content.value.data = base + pos;
860 137092 : break;
861 : case jpiAnd:
862 : case jpiOr:
863 : case jpiAdd:
864 : case jpiSub:
865 : case jpiMul:
866 : case jpiDiv:
867 : case jpiMod:
868 : case jpiEqual:
869 : case jpiNotEqual:
870 : case jpiLess:
871 : case jpiGreater:
872 : case jpiLessOrEqual:
873 : case jpiGreaterOrEqual:
874 : case jpiStartsWith:
875 59272 : read_int32(v->content.args.left, base, pos);
876 59272 : read_int32(v->content.args.right, base, pos);
877 59272 : break;
878 : case jpiLikeRegex:
879 152 : read_int32(v->content.like_regex.flags, base, pos);
880 152 : read_int32(v->content.like_regex.expr, base, pos);
881 152 : read_int32(v->content.like_regex.patternlen, base, pos);
882 152 : v->content.like_regex.pattern = base + pos;
883 152 : break;
884 : case jpiNot:
885 : case jpiExists:
886 : case jpiIsUnknown:
887 : case jpiPlus:
888 : case jpiMinus:
889 : case jpiFilter:
890 64440 : read_int32(v->content.arg, base, pos);
891 64440 : break;
892 : case jpiIndexArray:
893 232 : read_int32(v->content.array.nelems, base, pos);
894 232 : read_int32_n(v->content.array.elems, base, pos,
895 : v->content.array.nelems * 2);
896 232 : break;
897 : case jpiAny:
898 236 : read_int32(v->content.anybounds.first, base, pos);
899 236 : read_int32(v->content.anybounds.last, base, pos);
900 236 : break;
901 : default:
902 0 : elog(ERROR, "unrecognized jsonpath item type: %d", v->type);
903 : }
904 412908 : }
905 :
906 : void
907 65040 : jspGetArg(JsonPathItem *v, JsonPathItem *a)
908 : {
909 : Assert(v->type == jpiFilter ||
910 : v->type == jpiNot ||
911 : v->type == jpiIsUnknown ||
912 : v->type == jpiExists ||
913 : v->type == jpiPlus ||
914 : v->type == jpiMinus);
915 :
916 65040 : jspInitByBuffer(a, v->base, v->content.arg);
917 65040 : }
918 :
919 : bool
920 263620 : jspGetNext(JsonPathItem *v, JsonPathItem *a)
921 : {
922 263620 : if (jspHasNext(v))
923 : {
924 : Assert(v->type == jpiString ||
925 : v->type == jpiNumeric ||
926 : v->type == jpiBool ||
927 : v->type == jpiNull ||
928 : v->type == jpiKey ||
929 : v->type == jpiAny ||
930 : v->type == jpiAnyArray ||
931 : v->type == jpiAnyKey ||
932 : v->type == jpiIndexArray ||
933 : v->type == jpiFilter ||
934 : v->type == jpiCurrent ||
935 : v->type == jpiExists ||
936 : v->type == jpiRoot ||
937 : v->type == jpiVariable ||
938 : v->type == jpiLast ||
939 : v->type == jpiAdd ||
940 : v->type == jpiSub ||
941 : v->type == jpiMul ||
942 : v->type == jpiDiv ||
943 : v->type == jpiMod ||
944 : v->type == jpiPlus ||
945 : v->type == jpiMinus ||
946 : v->type == jpiEqual ||
947 : v->type == jpiNotEqual ||
948 : v->type == jpiGreater ||
949 : v->type == jpiGreaterOrEqual ||
950 : v->type == jpiLess ||
951 : v->type == jpiLessOrEqual ||
952 : v->type == jpiAnd ||
953 : v->type == jpiOr ||
954 : v->type == jpiNot ||
955 : v->type == jpiIsUnknown ||
956 : v->type == jpiType ||
957 : v->type == jpiSize ||
958 : v->type == jpiAbs ||
959 : v->type == jpiFloor ||
960 : v->type == jpiCeiling ||
961 : v->type == jpiDouble ||
962 : v->type == jpiKeyValue ||
963 : v->type == jpiStartsWith);
964 :
965 120968 : if (a)
966 120968 : jspInitByBuffer(a, v->base, v->nextPos);
967 120968 : return true;
968 : }
969 :
970 142652 : return false;
971 : }
972 :
973 : void
974 59272 : jspGetLeftArg(JsonPathItem *v, JsonPathItem *a)
975 : {
976 : Assert(v->type == jpiAnd ||
977 : v->type == jpiOr ||
978 : v->type == jpiEqual ||
979 : v->type == jpiNotEqual ||
980 : v->type == jpiLess ||
981 : v->type == jpiGreater ||
982 : v->type == jpiLessOrEqual ||
983 : v->type == jpiGreaterOrEqual ||
984 : v->type == jpiAdd ||
985 : v->type == jpiSub ||
986 : v->type == jpiMul ||
987 : v->type == jpiDiv ||
988 : v->type == jpiMod ||
989 : v->type == jpiStartsWith);
990 :
991 59272 : jspInitByBuffer(a, v->base, v->content.args.left);
992 59272 : }
993 :
994 : void
995 42628 : jspGetRightArg(JsonPathItem *v, JsonPathItem *a)
996 : {
997 : Assert(v->type == jpiAnd ||
998 : v->type == jpiOr ||
999 : v->type == jpiEqual ||
1000 : v->type == jpiNotEqual ||
1001 : v->type == jpiLess ||
1002 : v->type == jpiGreater ||
1003 : v->type == jpiLessOrEqual ||
1004 : v->type == jpiGreaterOrEqual ||
1005 : v->type == jpiAdd ||
1006 : v->type == jpiSub ||
1007 : v->type == jpiMul ||
1008 : v->type == jpiDiv ||
1009 : v->type == jpiMod ||
1010 : v->type == jpiStartsWith);
1011 :
1012 42628 : jspInitByBuffer(a, v->base, v->content.args.right);
1013 42628 : }
1014 :
1015 : bool
1016 944 : jspGetBool(JsonPathItem *v)
1017 : {
1018 : Assert(v->type == jpiBool);
1019 :
1020 944 : return (bool) *v->content.value.data;
1021 : }
1022 :
1023 : Numeric
1024 13356 : jspGetNumeric(JsonPathItem *v)
1025 : {
1026 : Assert(v->type == jpiNumeric);
1027 :
1028 13356 : return (Numeric) v->content.value.data;
1029 : }
1030 :
1031 : char *
1032 122600 : jspGetString(JsonPathItem *v, int32 *len)
1033 : {
1034 : Assert(v->type == jpiKey ||
1035 : v->type == jpiString ||
1036 : v->type == jpiVariable);
1037 :
1038 122600 : if (len)
1039 121836 : *len = v->content.value.datalen;
1040 122600 : return v->content.value.data;
1041 : }
1042 :
1043 : bool
1044 244 : jspGetArraySubscript(JsonPathItem *v, JsonPathItem *from, JsonPathItem *to,
1045 : int i)
1046 : {
1047 : Assert(v->type == jpiIndexArray);
1048 :
1049 244 : jspInitByBuffer(from, v->base, v->content.array.elems[i].from);
1050 :
1051 244 : if (!v->content.array.elems[i].to)
1052 216 : return false;
1053 :
1054 28 : jspInitByBuffer(to, v->base, v->content.array.elems[i].to);
1055 :
1056 28 : return true;
1057 : }
|
