Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : /*
14 : * (c) 2013 Martin Kersten
15 : */
16 : #include "monetdb_config.h"
17 : #include "gdk.h"
18 : #include "mal.h"
19 : #include "mal_client.h"
20 : #include "mal_instruction.h"
21 : #include "mal_exception.h"
22 : #include "mal_interpreter.h"
23 :
24 : typedef enum JSONkind {
25 : JSON_OBJECT = 1,
26 : JSON_ARRAY,
27 : JSON_ELEMENT,
28 : JSON_VALUE,
29 : JSON_STRING,
30 : JSON_NUMBER,
31 : JSON_BOOL,
32 : JSON_NULL
33 : } JSONkind;
34 :
35 : /* The JSON index structure is meant for short lived versions */
36 : typedef struct JSONterm {
37 : JSONkind kind;
38 : char *name; /* exclude the quotes */
39 : size_t namelen;
40 : const char *value; /* start of string rep */
41 : size_t valuelen;
42 : int child, next, tail; /* next offsets allow you to walk array/object chains
43 : and append quickly */
44 : /* An array or object item has a number of components */
45 : } JSONterm;
46 :
47 : typedef struct JSON {
48 : JSONterm *elm;
49 : str error;
50 : int size;
51 : int free;
52 : } JSON;
53 :
54 : typedef str json;
55 :
56 : // just validate the string according to www.json.org
57 : // A straightforward recursive solution
58 : #define skipblancs(J) \
59 : do { \
60 : for(; *(J); (J)++) \
61 : if (*(J) != ' ' && \
62 : *(J) != '\n' && \
63 : *(J) != '\t' && \
64 : *(J) != '\r') \
65 : break; \
66 : } while (0)
67 :
68 : #define CHECK_JSON(jt) \
69 : do { \
70 : if (jt == NULL || jt->error) { \
71 : char *msg; \
72 : if (jt) { \
73 : msg = jt->error; \
74 : jt->error = NULL; \
75 : JSONfree(jt); \
76 : } else { \
77 : msg = createException(MAL, "json.new", SQLSTATE(HY013) MAL_MALLOC_FAIL); \
78 : } \
79 : return msg; \
80 : } \
81 : } while (0)
82 :
83 : int TYPE_json;
84 :
85 : /* Internal constructors. */
86 : static int jsonhint = 8;
87 : static JSON *JSONparse(const char *j);
88 :
89 : static JSON *
90 2181312 : JSONnewtree(void)
91 : {
92 2181312 : JSON *js;
93 :
94 2181312 : js = GDKzalloc(sizeof(JSON));
95 2181315 : if (js == NULL)
96 : return NULL;
97 2181315 : js->elm = GDKzalloc(sizeof(JSONterm) * jsonhint);
98 2181315 : if (js->elm == NULL) {
99 0 : GDKfree(js);
100 0 : return NULL;
101 : }
102 2181315 : js->size = jsonhint;
103 2181315 : return js;
104 : }
105 :
106 : static int
107 48060540 : JSONnew(JSON *js)
108 : {
109 48060540 : JSONterm *term;
110 :
111 48060540 : if (js->free == js->size) {
112 3200 : term = GDKrealloc(js->elm, sizeof(JSONterm) * (js->size + 8));
113 3200 : if (term == NULL) {
114 0 : js->error = createException(MAL, "json.new",
115 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
116 0 : return js->free - 1;
117 : }
118 3200 : js->elm = term;
119 3200 : memset(term + js->size, 0, 8 * sizeof(JSONterm));
120 3200 : js->size += 8;
121 3200 : if (jsonhint < js->size)
122 3200 : jsonhint = js->size;
123 : }
124 48060540 : return js->free++;
125 : }
126 :
127 : /* Delete a JSON structure. */
128 : static void
129 2181317 : JSONfree(JSON *c)
130 : {
131 2181317 : if (c == 0)
132 : return;
133 2181314 : freeException(c->error);
134 2181314 : GDKfree(c->elm);
135 2181315 : GDKfree(c);
136 : }
137 :
138 : static str
139 48005077 : JSONtoStorageString(JSON *jt, int idx, json *ret, size_t *out_size)
140 : {
141 48005077 : char *p = *ret;
142 48005077 : size_t sz = 0;
143 48005077 : str msg = MAL_SUCCEED;
144 :
145 48005077 : if (THRhighwater()) {
146 0 : msg = createException(MAL, "json.new",
147 : SQLSTATE(42000)
148 : "JSON object too complex to render into string.");
149 0 : return msg;
150 : }
151 :
152 :
153 48005077 : switch(jt->elm[idx].kind) {
154 3304275 : case JSON_OBJECT:
155 3304275 : *p++ = '{';
156 3304275 : *out_size += 1;
157 25525929 : for(int i = jt->elm[idx].next; i != 0; i = jt->elm[i].next) {
158 22221654 : sz = 0;
159 22221654 : if (i != jt->elm[idx].next) {
160 18924522 : *p++ = ',';
161 18924522 : *out_size += 1;
162 : }
163 22221654 : msg = JSONtoStorageString(jt, i, &p, &sz);
164 22221654 : if (msg != MAL_SUCCEED) {
165 0 : return msg;
166 : }
167 22221654 : *out_size += sz;
168 22221654 : p += sz;
169 : }
170 3304275 : *p++ = '}';
171 3304275 : *out_size += 1;
172 3304275 : break;
173 1582080 : case JSON_ARRAY:
174 1582080 : *p++ = '[';
175 1582080 : *out_size += 1;
176 2621040 : for(int i = jt->elm[idx].next; i != 0; i = jt->elm[i].next) {
177 1038960 : sz = 0;
178 1038960 : if (i != jt->elm[idx].next) {
179 437786 : *p++ = ',';
180 437786 : *out_size += 1;
181 : }
182 1038960 : msg = JSONtoStorageString(jt, i, &p, &sz);
183 1038960 : if (msg != MAL_SUCCEED) {
184 0 : return msg;
185 : }
186 1038960 : *out_size += sz;
187 1038960 : p += sz;
188 : }
189 1582080 : *p++ = ']';
190 1582080 : *out_size += 1;
191 1582080 : break;
192 22221654 : case JSON_ELEMENT:
193 22221654 : *p++ = '"';
194 22221654 : strncpy(p, jt->elm[idx].value, jt->elm[idx].valuelen);
195 22221654 : p += jt->elm[idx].valuelen;
196 22221654 : *p++ = '"';
197 22221654 : *p++ = ':';
198 22221654 : *out_size = jt->elm[idx].valuelen + 3;
199 22221654 : msg = JSONtoStorageString(jt, jt->elm[idx].child, &p, &sz);
200 22221654 : if (msg != MAL_SUCCEED) {
201 : return msg;
202 : }
203 22221654 : *out_size += sz;
204 22221654 : p += sz;
205 22221654 : break;
206 17589968 : case JSON_NUMBER:
207 : /* fall through */
208 : case JSON_STRING:
209 17589968 : strncpy(p, jt->elm[idx].value, jt->elm[idx].valuelen);
210 17589968 : *out_size += jt->elm[idx].valuelen;
211 17589968 : p += *out_size;
212 17589968 : break;
213 342565 : case JSON_VALUE:
214 342565 : msg = JSONtoStorageString(jt, jt->elm[idx].child, &p, &sz);
215 342565 : if (msg != MAL_SUCCEED) {
216 : return msg;
217 : }
218 342565 : *out_size += sz;
219 342565 : p += sz;
220 342565 : break;
221 2964535 : case JSON_NULL:
222 2964535 : strncpy(p, "null", 5);
223 2964535 : *out_size += 4;
224 2964535 : p += *out_size;
225 2964535 : break;
226 0 : default:
227 0 : msg = createException(MAL, "json.new", SQLSTATE(HY013) MAL_MALLOC_FAIL);
228 0 : break;
229 : }
230 :
231 48005077 : *p = 0;
232 :
233 48005077 : return msg;
234 : }
235 :
236 : static str JSONstr2json(json *ret, const char **j);
237 :
238 : static ssize_t
239 2200091 : JSONfromString(const char *src, size_t *len, void **J, bool external)
240 : {
241 2200091 : json *buf = (json *) J;
242 2200091 : if(*buf) {
243 2200036 : GDKfree(*buf);
244 2200036 : *buf = NULL;
245 : }
246 4380182 : if (strNil(src) || (external && strncmp(src, "nil", 3) == 0)) {
247 20000 : *buf = GDKstrdup(str_nil);
248 20000 : if (*buf == NULL)
249 : return -1;
250 20000 : *len = 2;
251 40000 : return strNil(src) ? 1 : 3;
252 : } else {
253 2180091 : str msg = JSONstr2json(buf, &src);
254 2180091 : if (msg != MAL_SUCCEED) {
255 2 : GDKerror("%s", getExceptionMessageAndState(msg));
256 2 : freeException(msg);
257 2 : return -1;
258 : }
259 : }
260 2180089 : *len = strlen(*buf) + 1;
261 2180089 : return (ssize_t) *len - 1;
262 : }
263 :
264 : static ssize_t
265 552 : JSONtoString(str *s, size_t *len, const void *SRC, bool external)
266 : {
267 552 : const char *src = SRC;
268 552 : size_t cnt;
269 552 : const char *c;
270 552 : char *dst;
271 :
272 552 : if (strNil(src)) {
273 1 : if (*s == NULL || *len < 4) {
274 1 : GDKfree(*s);
275 1 : *len = 4;
276 1 : *s = GDKmalloc(4);
277 1 : if (*s == NULL)
278 : return -1;
279 : }
280 1 : if (external) {
281 1 : assert(*len >= strlen("nil") + 1);
282 1 : strcpy(*s, "nil");
283 1 : return 3;
284 : }
285 0 : assert(*len >= strlen(str_nil) + 1);
286 0 : strcpy(*s, str_nil);
287 0 : return 1;
288 : }
289 : /* count how much space we need for the output string */
290 551 : if (external) {
291 : cnt = 3; /* two times " plus \0 */
292 23990 : for (c = src; *c; c++)
293 23454 : switch (*c) {
294 3953 : case '"':
295 : case '\\':
296 : case '\n':
297 3953 : cnt++;
298 : /* fall through */
299 23454 : default:
300 23454 : cnt++;
301 23454 : break;
302 : }
303 : } else {
304 15 : cnt = strlen(src) + 1; /* just the \0 */
305 : }
306 :
307 551 : if (cnt > (size_t) *len) {
308 95 : GDKfree(*s);
309 95 : *s = GDKmalloc(cnt);
310 95 : if (*s == NULL)
311 : return -1;
312 95 : *len = cnt;
313 : }
314 551 : dst = *s;
315 551 : if (external) {
316 536 : *dst++ = '"';
317 23990 : for (c = src; *c; c++) {
318 23454 : switch (*c) {
319 3953 : case '"':
320 : case '\\':
321 3953 : *dst++ = '\\';
322 : /* fall through */
323 23454 : default:
324 23454 : *dst++ = *c;
325 23454 : break;
326 0 : case '\n':
327 0 : *dst++ = '\\';
328 0 : *dst++ = 'n';
329 0 : break;
330 : }
331 : }
332 536 : *dst++ = '"';
333 536 : *dst = 0;
334 : } else {
335 15 : dst += snprintf(dst, cnt, "%s", src);
336 : }
337 551 : return (ssize_t) (dst - *s);
338 : }
339 :
340 : static BAT *
341 1 : JSONdumpInternal(JSON *jt, int depth)
342 : {
343 1 : int i, idx;
344 1 : JSONterm *je;
345 1 : size_t buflen = 1024;
346 1 : char *buffer = GDKmalloc(buflen);
347 1 : BAT *bn = COLnew(0, TYPE_str, 0, TRANSIENT);
348 :
349 1 : if (!buffer || !bn) {
350 0 : GDKfree(buffer);
351 0 : BBPreclaim(bn);
352 0 : return NULL;
353 : }
354 :
355 56 : for (idx = 0; idx < jt->free; idx++) {
356 55 : size_t datlen = 0;
357 55 : je = jt->elm + idx;
358 :
359 55 : if (datlen + depth * 4 + 512 > buflen) {
360 0 : do {
361 0 : buflen += 1024;
362 0 : } while (datlen + depth * 4 + 512 > buflen);
363 0 : char *newbuf = GDKrealloc(buffer, buflen);
364 0 : if (newbuf == NULL) {
365 0 : GDKfree(buffer);
366 0 : BBPreclaim(bn);
367 0 : return NULL;
368 : }
369 : buffer = newbuf;
370 : }
371 55 : datlen += snprintf(buffer + datlen, buflen - datlen, "%*s", depth * 4,
372 : "");
373 55 : datlen += snprintf(buffer + datlen, buflen - datlen, "[%d] ", idx);
374 55 : switch (je->kind) {
375 7 : case JSON_OBJECT:
376 7 : datlen += snprintf(buffer + datlen, buflen - datlen, "object ");
377 7 : break;
378 1 : case JSON_ARRAY:
379 1 : datlen += snprintf(buffer + datlen, buflen - datlen, "array ");
380 1 : break;
381 23 : case JSON_ELEMENT:
382 23 : datlen += snprintf(buffer + datlen, buflen - datlen, "element ");
383 23 : break;
384 4 : case JSON_VALUE:
385 4 : datlen += snprintf(buffer + datlen, buflen - datlen, "value ");
386 4 : break;
387 15 : case JSON_STRING:
388 15 : datlen += snprintf(buffer + datlen, buflen - datlen, "string ");
389 15 : break;
390 5 : case JSON_NUMBER:
391 5 : datlen += snprintf(buffer + datlen, buflen - datlen, "number ");
392 5 : break;
393 0 : case JSON_BOOL:
394 0 : datlen += snprintf(buffer + datlen, buflen - datlen, "bool ");
395 0 : break;
396 0 : case JSON_NULL:
397 0 : datlen += snprintf(buffer + datlen, buflen - datlen, "null ");
398 0 : break;
399 0 : default:
400 0 : datlen += snprintf(buffer + datlen, buflen - datlen, "unknown %d ",
401 : (int) je->kind);
402 : }
403 55 : datlen += snprintf(buffer + datlen, buflen - datlen, "child %d list ",
404 : je->child);
405 122 : for (i = je->next; i; i = jt->elm[i].next) {
406 67 : if (datlen + 10 > buflen) {
407 0 : buflen += 1024;
408 0 : char *newbuf = GDKrealloc(buffer, buflen);
409 0 : if (newbuf == NULL) {
410 0 : GDKfree(buffer);
411 0 : BBPreclaim(bn);
412 0 : return NULL;
413 : }
414 : buffer = newbuf;
415 : }
416 67 : datlen += snprintf(buffer + datlen, buflen - datlen, "%d ", i);
417 : }
418 55 : if (je->name) {
419 0 : if (datlen + 10 + je->namelen > buflen) {
420 0 : do {
421 0 : buflen += 1024;
422 0 : } while (datlen + 10 + je->namelen > buflen);
423 0 : char *newbuf = GDKrealloc(buffer, buflen);
424 0 : if (newbuf == NULL) {
425 0 : GDKfree(buffer);
426 0 : BBPreclaim(bn);
427 0 : return NULL;
428 : }
429 : buffer = newbuf;
430 : }
431 0 : datlen += snprintf(buffer + datlen, buflen - datlen, "%.*s : ",
432 0 : (int) je->namelen, je->name);
433 : }
434 55 : if (je->value) {
435 51 : if (datlen + 10 + je->valuelen > buflen) {
436 0 : do {
437 0 : buflen += 1024;
438 0 : } while (datlen + 10 + je->valuelen > buflen);
439 0 : char *newbuf = GDKrealloc(buffer, buflen);
440 0 : if (newbuf == NULL) {
441 0 : GDKfree(buffer);
442 0 : BBPreclaim(bn);
443 0 : return NULL;
444 : }
445 : buffer = newbuf;
446 : }
447 51 : datlen += snprintf(buffer + datlen, buflen - datlen, "%.*s",
448 51 : (int) je->valuelen, je->value);
449 : }
450 55 : if (BUNappend(bn, buffer, false) != GDK_SUCCEED) {
451 0 : BBPreclaim(bn);
452 0 : GDKfree(buffer);
453 0 : return NULL;
454 : }
455 : }
456 1 : GDKfree(buffer);
457 1 : return bn;
458 : }
459 :
460 : static str
461 1 : JSONdump(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
462 : {
463 1 : (void) mb;
464 1 : (void) cntxt;
465 :
466 1 : bat *ret = getArgReference_bat(stk, pci, 0);
467 1 : json *val = (json *) getArgReference(stk, pci, 1);
468 1 : JSON *jt = JSONparse(*val);
469 :
470 1 : CHECK_JSON(jt);
471 1 : BAT *bn = JSONdumpInternal(jt, 0);
472 1 : JSONfree(jt);
473 1 : if (bn == NULL)
474 0 : throw(MAL, "json.dump", SQLSTATE(HY013) MAL_MALLOC_FAIL);
475 1 : *ret = bn->batCacheid;
476 1 : BBPkeepref(bn);
477 1 : return MAL_SUCCEED;
478 : }
479 :
480 : static str
481 0 : JSONjson2str(str *ret, json *j)
482 : {
483 0 : char *s = *j, *c;
484 :
485 0 : if (*s == '"')
486 0 : s++;
487 0 : if ((s = GDKstrdup(s)) == NULL)
488 0 : throw(MAL, "json.str", SQLSTATE(HY013) MAL_MALLOC_FAIL);
489 0 : c = s + strlen(s) - 1;
490 0 : if (*c == '"')
491 0 : *c = 0;
492 0 : *ret = s;
493 0 : return MAL_SUCCEED;
494 : }
495 :
496 : static str
497 0 : JSON2json(json *ret, const json *j)
498 : {
499 0 : *ret = GDKstrdup(*j);
500 0 : if (*ret == NULL)
501 0 : throw(MAL, "json.json", SQLSTATE(HY013) MAL_MALLOC_FAIL);
502 : return MAL_SUCCEED;
503 : }
504 :
505 : static str
506 2180269 : JSONstr2json(json *ret, const char **j)
507 : {
508 2180269 : str msg = MAL_SUCCEED;
509 2180269 : json buf = NULL;
510 2180269 : size_t ln = strlen(*j)+1;
511 2180269 : size_t out_size = 0;
512 :
513 2180269 : JSON *jt = NULL;
514 :
515 2180269 : if (strNil(*j)) {
516 3 : buf = GDKstrdup(*j);
517 : } else {
518 2180266 : jt = JSONparse(*j);
519 2180266 : CHECK_JSON(jt);
520 :
521 2180244 : buf = (json)GDKmalloc(ln);
522 : }
523 2180247 : if (buf == NULL) {
524 0 : msg = createException(MAL, "json.new", SQLSTATE(HY013) MAL_MALLOC_FAIL);
525 0 : goto bailout;
526 : }
527 :
528 2180247 : if (jt != NULL) {
529 2180244 : msg = JSONtoStorageString(jt, 0, &buf, &out_size);
530 2180244 : if (msg != MAL_SUCCEED) {
531 0 : GDKfree(buf);
532 0 : goto bailout;
533 : }
534 : }
535 :
536 2180247 : *ret = buf;
537 :
538 2180247 : bailout:
539 2180247 : JSONfree(jt);
540 2180247 : return msg;
541 : }
542 :
543 : static str
544 370 : JSONisvalid(bit *ret, str *j)
545 : {
546 370 : if (strNil(*j)) {
547 0 : *ret = bit_nil;
548 : } else {
549 370 : JSON *jt = JSONparse(*j);
550 370 : if (jt == NULL)
551 0 : throw(MAL, "json.isvalid", SQLSTATE(HY013) MAL_MALLOC_FAIL);
552 370 : *ret = jt->error == MAL_SUCCEED;
553 370 : JSONfree(jt);
554 : }
555 : return MAL_SUCCEED;
556 : }
557 :
558 : static str
559 15 : JSONisobject(bit *ret, json *js)
560 : {
561 15 : if (strNil(*js)) {
562 0 : *ret = bit_nil;
563 : } else {
564 : char *j = *js;
565 :
566 15 : skipblancs(j);
567 15 : *ret = *j == '{';
568 : }
569 15 : return MAL_SUCCEED;
570 : }
571 :
572 : static str
573 16 : JSONisarray(bit *ret, json *js)
574 : {
575 16 : if (strNil(*js)) {
576 0 : *ret = bit_nil;
577 : } else {
578 : char *j = *js;
579 :
580 16 : skipblancs(j);
581 16 : *ret = *j == '[';
582 : }
583 16 : return MAL_SUCCEED;
584 : }
585 :
586 : #ifdef GDKLIBRARY_JSON
587 : static gdk_return
588 4 : upgradeJSONStorage(char **out, const char **in)
589 : {
590 4 : str msg;
591 4 : if ((msg = JSONstr2json(out, in)) != MAL_SUCCEED) {
592 0 : freeException(msg);
593 0 : return GDK_FAIL;
594 : }
595 : return GDK_SUCCEED;
596 : }
597 :
598 : static str
599 0 : jsonRead(str a, size_t *dstlen, stream *s, size_t cnt)
600 : {
601 0 : str out = NULL;
602 0 : str msg;
603 :
604 0 : if ((a = BATatoms[TYPE_str].atomRead(a, dstlen, s, cnt)) == NULL)
605 : return NULL;
606 :
607 0 : if ((msg = JSONstr2json(&out, (const char **) &a)) != MAL_SUCCEED) {
608 0 : freeException(msg);
609 0 : GDKfree(a);
610 0 : return NULL;
611 : }
612 0 : *dstlen = strlen(out) + 1;
613 0 : GDKfree(a);
614 :
615 0 : a = out;
616 :
617 0 : return a;
618 : }
619 :
620 : #endif
621 :
622 :
623 : static str
624 341 : JSONprelude(void)
625 : {
626 341 : TYPE_json = ATOMindex("json");
627 : #ifdef GDKLIBRARY_JSON
628 : /* Run the gdk upgrade libary function with a callback that
629 : * performs the actual upgrade.
630 : */
631 341 : char *jsonupgrade;
632 341 : struct stat st;
633 341 : if ((jsonupgrade = GDKfilepath(0, BATDIR, "jsonupgradeneeded", NULL)) == NULL) {
634 0 : throw(MAL, "json.prelude", "cannot allocate filename for json upgrade signal file");
635 : }
636 341 : int r = stat(jsonupgrade, &st);
637 341 : GDKfree(jsonupgrade);
638 341 : if (r == 0) {
639 : /* The file exists so we need to run the upgrade code */
640 8 : if (BBPjson_upgrade(upgradeJSONStorage) != GDK_SUCCEED) {
641 0 : throw(MAL, "json.prelude", "JSON storage upgrade failed");
642 : }
643 : /* Change the read function of the json atom so that any values in the WAL
644 : * will also be upgraded.
645 : */
646 8 : BATatoms[TYPE_json].atomRead = (void *(*)(void *, size_t *, stream *, size_t)) jsonRead;
647 : }
648 : #endif
649 : return MAL_SUCCEED;
650 : }
651 :
652 : static void
653 23268706 : JSONappend(JSON *jt, int idx, int nxt)
654 : {
655 23268706 : int chld;
656 :
657 23268706 : if (jt->elm[nxt].kind == JSON_OBJECT || jt->elm[nxt].kind == JSON_ARRAY) {
658 0 : chld = JSONnew(jt);
659 0 : if (jt->error)
660 : return;
661 0 : jt->elm[chld].kind = jt->elm[nxt].kind;
662 0 : jt->elm[chld].name = jt->elm[nxt].name;
663 0 : jt->elm[chld].namelen = jt->elm[nxt].namelen;
664 0 : jt->elm[chld].value = jt->elm[nxt].value;
665 0 : jt->elm[chld].valuelen = jt->elm[nxt].valuelen;
666 0 : jt->elm[chld].child = jt->elm[nxt].child;
667 0 : jt->elm[chld].next = jt->elm[nxt].next;
668 0 : jt->elm[chld].tail = jt->elm[nxt].tail;
669 0 : jt->elm[chld].child = nxt;
670 :
671 0 : jt->elm[nxt].child = 0;
672 0 : jt->elm[nxt].next = 0;
673 0 : jt->elm[nxt].tail = 0;
674 0 : nxt = chld;
675 : }
676 23268706 : if (jt->elm[idx].next == 0)
677 3900396 : jt->elm[idx].next = jt->elm[idx].tail = nxt;
678 : else {
679 19368310 : jt->elm[jt->elm[idx].tail].next = nxt;
680 19368310 : jt->elm[idx].tail = nxt;
681 : }
682 : }
683 :
684 : /*
685 : * The JSON filter operation takes a path expression which is
686 : * purposely kept simple, It provides step (.), multistep (..) and
687 : * indexed ([nr]) access to the JSON elements. A wildcard * can be
688 : * used as placeholder for a step identifier.
689 : *
690 : * A path expression is always validated upfront and can only be
691 : * applied to valid json strings.
692 : * Path samples:
693 : * .store.book
694 : * .store.book[0]
695 : * .store.book.author
696 : * ..author
697 : */
698 : #define MAXTERMS 256
699 :
700 : typedef enum path_token {
701 : ROOT_STEP, /* $ */
702 : CHILD_STEP, /* . */
703 : INDEX_STEP, /* [n] */
704 : ANY_STEP, /* .. */
705 : END_STEP /* end of expression */
706 : } path_token;
707 :
708 : typedef struct {
709 : path_token token; /* Token kind */
710 : char *name; /* specific key */
711 : size_t namelen; /* the size of the key */
712 : int index; /* if index == INT_MAX we got [*] */
713 : int first, last;
714 : } pattern;
715 :
716 : static str
717 422 : JSONcompile(char *expr, pattern terms[])
718 : {
719 422 : int t = 0;
720 422 : char *s, *beg;
721 :
722 609 : for (s = expr; *s; s++) {
723 552 : terms[t].token = CHILD_STEP;
724 552 : terms[t].index = INT_MAX;
725 552 : terms[t].first = INT_MAX;
726 552 : terms[t].last = INT_MAX;
727 552 : if (*s == '$') {
728 55 : if (t && terms[t - 1].token != END_STEP)
729 0 : throw(MAL, "json.compile", "Root node must be first");
730 55 : if (!(*(s + 1) == '.' || *(s + 1) == '[' || *(s + 1) == 0))
731 2 : throw(MAL, "json.compile", "Root node must be first");
732 53 : s++;
733 53 : if (*s == 0)
734 1 : terms[t].token = ROOT_STEP;
735 : }
736 550 : if (*s == '.' && *(s + 1) == '.') {
737 123 : terms[t].token = ANY_STEP;
738 123 : s += 2;
739 123 : if (*s == '.')
740 2 : throw(MAL, "json.compile", "Step identifier expected");
741 427 : } else if (*s == '.')
742 137 : s++;
743 :
744 : // child step
745 548 : if (*s != '[') {
746 2909 : for (beg = s; *s; s++)
747 2553 : if (*s == '.' || *s == '[' || *s == ',')
748 : break;
749 499 : terms[t].name = GDKzalloc(s - beg + 1);
750 498 : if (terms[t].name == NULL)
751 0 : throw(MAL, "json.compile", SQLSTATE(HY013) MAL_MALLOC_FAIL);
752 498 : terms[t].namelen = s - beg;
753 498 : strncpy(terms[t].name, beg, s - beg);
754 498 : if (*s == '.')
755 68 : s--;
756 498 : if (*s == 0) {
757 355 : t++;
758 355 : break;
759 : }
760 : }
761 192 : if (*s == '[') {
762 : // array step
763 82 : bool closed = false;
764 82 : s++;
765 82 : skipblancs(s);
766 82 : if (*s != '*') {
767 : /* TODO: Implement [start:step:end] indexing */
768 75 : if (isdigit((unsigned char) *s)) {
769 71 : terms[t].index = atoi(s);
770 71 : terms[t].first = terms[t].last = atoi(s);
771 : } else
772 4 : throw(MAL, "json.path", "'*' or digit expected");
773 : }
774 156 : for (; *s; s++)
775 155 : if (*s == ']') {
776 : closed = true;
777 : break;
778 : }
779 78 : if (*s == 0) {
780 1 : if (!closed) {
781 1 : throw(MAL, "json.path", "] expected");
782 : }
783 0 : t++;
784 0 : break;
785 : }
786 : if (*s != ']')
787 : throw(MAL, "json.path", "] expected");
788 : }
789 187 : if (*s == ',') {
790 42 : if (++t == MAXTERMS)
791 0 : throw(MAL, "json.path", "too many terms");
792 42 : terms[t].token = END_STEP;
793 : }
794 187 : if (++t == MAXTERMS)
795 0 : throw(MAL, "json.path", "too many terms");
796 : }
797 412 : if (t >= MAXTERMS - 1)
798 0 : throw(MAL, "json.path", "too many terms");
799 412 : terms[t].token = END_STEP;
800 412 : return MAL_SUCCEED;
801 : }
802 :
803 : static str
804 516 : JSONgetValue(JSON *jt, int idx)
805 : {
806 516 : str s;
807 :
808 516 : if (jt->elm[idx].valuelen == 0)
809 0 : return GDKstrdup(str_nil);
810 516 : s = GDKzalloc(jt->elm[idx].valuelen + 1);
811 516 : if (s)
812 516 : strncpy(s, jt->elm[idx].value, jt->elm[idx].valuelen);
813 : return s;
814 : }
815 :
816 : /* eats res and r */
817 : static str
818 2286 : JSONglue(str res, str r, char sep)
819 : {
820 2286 : size_t len, l;
821 2286 : str n;
822 :
823 2286 : if (r == 0 || *r == 0) {
824 0 : GDKfree(r);
825 1890 : return res;
826 : }
827 396 : len = strlen(r);
828 396 : if (res == 0)
829 : return r;
830 128 : l = strlen(res);
831 128 : n = GDKzalloc(l + len + 3);
832 128 : if (n == NULL) {
833 0 : GDKfree(res);
834 0 : GDKfree(r);
835 0 : return NULL;
836 : }
837 128 : snprintf(n, l + len + 3, "%s%s%s", res, sep ? "," : "", r);
838 128 : GDKfree(res);
839 128 : GDKfree(r);
840 128 : return n;
841 : }
842 :
843 : /* return NULL on no match, return (str) -1 on (malloc) failure, (str) -2 on stack overflow */
844 : static str
845 2283 : JSONmatch(JSON *jt, int ji, pattern *terms, int ti, bool accumulate)
846 : {
847 2283 : str r = NULL, res = NULL;
848 2283 : int i;
849 2283 : int cnt;
850 :
851 2283 : if (THRhighwater())
852 : return (str) -2;
853 2284 : if (ti >= MAXTERMS)
854 : return res;
855 :
856 2284 : if (terms[ti].token == ROOT_STEP) {
857 1 : if (ti + 1 == MAXTERMS)
858 : return NULL;
859 1 : if (terms[ti + 1].token == END_STEP) {
860 1 : res = JSONgetValue(jt, 0);
861 1 : if (res == NULL)
862 0 : res = (str) -1;
863 1 : return res;
864 : }
865 0 : ti++;
866 : }
867 :
868 2283 : switch (jt->elm[ji].kind) {
869 149 : case JSON_ARRAY:
870 149 : if (terms[ti].name != 0 && terms[ti].token != ANY_STEP) {
871 6 : if (terms[ti].token == END_STEP) {
872 0 : res = JSONgetValue(jt, ji);
873 0 : if (res == NULL)
874 0 : res = (str) -1;
875 : }
876 6 : return res;
877 : }
878 143 : cnt = 0;
879 554 : for (i = jt->elm[ji].next; i && cnt >= 0; i = jt->elm[i].next, cnt++) {
880 411 : if (terms[ti].index == INT_MAX
881 131 : || (cnt >= terms[ti].first && cnt <= terms[ti].last)) {
882 321 : if (terms[ti].token == ANY_STEP) {
883 276 : if (jt->elm[i].child)
884 55 : r = JSONmatch(jt, jt->elm[i].child, terms, ti, true);
885 : else
886 : r = 0;
887 45 : } else if (ti + 1 == MAXTERMS) {
888 : return NULL;
889 45 : } else if (terms[ti + 1].token == END_STEP) {
890 24 : if (jt->elm[i].kind == JSON_VALUE)
891 8 : r = JSONgetValue(jt, jt->elm[i].child);
892 : else
893 16 : r = JSONgetValue(jt, i);
894 24 : if (r == NULL)
895 0 : r = (str) -1;
896 : } else {
897 21 : r = JSONmatch(jt, jt->elm[i].child, terms, ti + 1, terms[ti].index == INT_MAX);
898 : }
899 321 : if (r == (str) -1 || r == (str) -2) {
900 0 : GDKfree(res);
901 0 : return r;
902 : }
903 321 : res = JSONglue(res, r, ',');
904 : }
905 : }
906 : break;
907 630 : case JSON_OBJECT:
908 630 : cnt = 0;
909 6520 : for (i = jt->elm[ji].next; i && cnt >= 0; i = jt->elm[i].next) {
910 : // check the element label
911 5890 : if ((terms[ti].name && jt->elm[i].valuelen == terms[ti].namelen
912 2107 : && strncmp(terms[ti].name, jt->elm[i].value,
913 5426 : terms[ti].namelen) == 0) || terms[ti].name == 0
914 5426 : || terms[ti].name[0] == '*') {
915 471 : if (terms[ti].index == INT_MAX
916 24 : || (cnt >= terms[ti].first && cnt <= terms[ti].last)) {
917 463 : if (ti + 1 == MAXTERMS)
918 : return NULL;
919 463 : if (terms[ti + 1].token == END_STEP) {
920 394 : r = JSONgetValue(jt, jt->elm[i].child);
921 394 : if (r == NULL)
922 0 : r = (str) -1;
923 : } else {
924 69 : r = JSONmatch(jt, jt->elm[i].child, terms, ti + 1, terms[ti].index == INT_MAX);
925 : }
926 463 : if (r == (str) -1 || r == (str) -2) {
927 0 : GDKfree(res);
928 0 : return r;
929 : }
930 463 : if (accumulate) {
931 180 : res = JSONglue(res, r, ',');
932 : } else { // Keep the last matching value
933 283 : if (res)
934 0 : GDKfree(res);
935 : res = r;
936 : }
937 : }
938 471 : cnt++;
939 5419 : } else if (terms[ti].token == ANY_STEP && jt->elm[i].child) {
940 1684 : r = JSONmatch(jt, jt->elm[i].child, terms, ti, true);
941 1684 : if (r == (str) -1 || r == (str) -2) {
942 0 : GDKfree(res);
943 0 : return r;
944 : }
945 1684 : res = JSONglue(res, r, ',');
946 1684 : cnt++;
947 : }
948 : }
949 : break;
950 : default:
951 : res = NULL;
952 : }
953 : return res;
954 : }
955 :
956 : static str
957 422 : JSONfilterInternal(json *ret, json *js, str *expr, str other)
958 : {
959 422 : pattern terms[MAXTERMS];
960 422 : int tidx = 0;
961 422 : JSON *jt;
962 422 : str j = *js, msg = MAL_SUCCEED, s;
963 422 : json result = 0;
964 422 : size_t l;
965 :
966 422 : (void) other;
967 422 : if (strNil(j)) {
968 0 : *ret = GDKstrdup(j);
969 0 : if (*ret == NULL)
970 0 : throw(MAL, "JSONfilterInternal", SQLSTATE(HY013) MAL_MALLOC_FAIL);
971 : return MAL_SUCCEED;
972 : }
973 422 : jt = JSONparse(j);
974 422 : CHECK_JSON(jt);
975 422 : memset(terms, 0, sizeof(terms));
976 422 : msg = JSONcompile(*expr, terms);
977 421 : if (msg)
978 9 : goto bailout;
979 :
980 412 : bool accumulate = terms[tidx].token == ANY_STEP || (terms[tidx].name && terms[tidx].name[0] == '*');
981 412 : result = s = JSONmatch(jt, 0, terms, tidx, accumulate);
982 413 : if (s == (char *) -1) {
983 0 : msg = createException(MAL, "JSONfilterInternal",
984 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
985 0 : goto bailout;
986 : }
987 413 : if (s == (char *) -2) {
988 0 : msg = createException(MAL, "JSONfilterInternal",
989 : SQLSTATE(42000)
990 : "Expression too complex to parse");
991 0 : goto bailout;
992 : }
993 : bool return_array = false;
994 : // process all other PATH expression
995 953 : for (tidx++; tidx < MAXTERMS && terms[tidx].token; tidx++)
996 540 : if (terms[tidx].token == END_STEP && tidx + 1 < MAXTERMS
997 455 : && terms[tidx + 1].token) {
998 42 : tidx += 1;
999 42 : accumulate = terms[tidx].token == ANY_STEP || (terms[tidx].name && terms[tidx].name[0] == '*');
1000 42 : s = JSONmatch(jt, 0, terms, tidx, accumulate);
1001 42 : if (s == (char *) -1) {
1002 0 : msg = createException(MAL, "JSONfilterInternal",
1003 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
1004 0 : goto bailout;
1005 : }
1006 42 : if (s == (char *) -2) {
1007 0 : msg = createException(MAL, "JSONfilterInternal",
1008 : SQLSTATE(42000)
1009 : "Expression too complex to parse");
1010 0 : goto bailout;
1011 : }
1012 42 : return_array = true;
1013 42 : result = JSONglue(result, s, ',');
1014 : }
1015 413 : if (result) {
1016 339 : l = strlen(result);
1017 339 : if (result[l - 1] == ',')
1018 0 : result[l - 1] = 0;
1019 : } else
1020 : l = 3;
1021 :
1022 1150 : for (int i = 0; i < MAXTERMS && terms[i].token; i++) {
1023 : // pattern contains the .. operator
1024 831 : if (terms[i].token == ANY_STEP ||
1025 : // pattern contains the [*] operator
1026 742 : (terms[i].token == CHILD_STEP && terms[i].index == INT_MAX && terms[i].name == NULL) ||
1027 410 : (terms[i].token == CHILD_STEP && terms[i].index == INT_MAX && *terms[i].name == '*')) {
1028 :
1029 : return_array = true;
1030 : break;
1031 : }
1032 : }
1033 413 : if (return_array || accumulate) {
1034 105 : s = GDKzalloc(l + 3);
1035 105 : if (s == NULL) {
1036 0 : GDKfree(result);
1037 0 : throw(MAL, "JSONfilterInternal", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1038 : }
1039 176 : snprintf(s, l + 3, "[%s]", (result ? result : ""));
1040 : }
1041 308 : else if (result == NULL || *result == 0) {
1042 40 : s = GDKstrdup("[]");
1043 : }
1044 : else {
1045 268 : s = GDKzalloc(l + 1);
1046 268 : snprintf(s, l + 1, "%s", (result ? result : ""));
1047 : }
1048 413 : GDKfree(result);
1049 413 : *ret = s;
1050 :
1051 422 : bailout:
1052 108177 : for (l = 0; l < MAXTERMS; l++)
1053 107755 : if (terms[l].name)
1054 498 : GDKfree(terms[l].name);
1055 422 : JSONfree(jt);
1056 422 : return msg;
1057 : }
1058 :
1059 :
1060 : static str
1061 31153977 : JSONstringParser(const char *j, const char **next)
1062 : {
1063 31153977 : unsigned int u;
1064 31153977 : bool seensurrogate = false;
1065 :
1066 31153977 : assert(*j == '"');
1067 31153977 : j++;
1068 473679872 : for (; *j; j++) {
1069 473679863 : switch (*j) {
1070 16757407 : case '\\':
1071 : // parse all escapes
1072 16757407 : j++;
1073 16757407 : switch (*j) {
1074 9849170 : case '"':
1075 : case '\\':
1076 : case '/':
1077 : case 'b':
1078 : case 'f':
1079 : case 'n':
1080 : case 'r':
1081 : case 't':
1082 9849170 : if (seensurrogate)
1083 2 : throw(MAL, "json.parser", "illegal escape char");
1084 9849168 : continue;
1085 : case 'u':
1086 : u = 0;
1087 34541124 : for (int i = 0; i < 4; i++) {
1088 27632902 : u <<= 4;
1089 27632902 : j++;
1090 27632902 : if ('0' <= *j && *j <= '9')
1091 22675792 : u |= *j - '0';
1092 4957110 : else if ('a' <= *j && *j <= 'f')
1093 4957030 : u |= *j - 'a' + 10;
1094 80 : else if ('A' <= *j && *j <= 'F')
1095 73 : u |= *j - 'A' + 10;
1096 : else
1097 7 : throw(MAL, "json.parser", "illegal escape char");
1098 : }
1099 6908222 : if (seensurrogate) {
1100 96218 : if ((u & 0xFC00) == 0xDC00)
1101 : seensurrogate = false;
1102 : else
1103 3 : throw(MAL, "json.parser", "illegal escape char");
1104 : } else {
1105 6812004 : if ((u & 0xFC00) == 0xD800)
1106 : seensurrogate = true;
1107 6715777 : else if ((u & 0xFC00) == 0xDC00)
1108 4 : throw(MAL, "json.parser", "illegal escape char");
1109 : }
1110 : break;
1111 8 : default:
1112 8 : *next = j;
1113 8 : throw(MAL, "json.parser", "illegal escape char");
1114 : }
1115 : break;
1116 31153940 : case '"':
1117 31153940 : if (seensurrogate)
1118 2 : throw(MAL, "json.parser", "illegal escape char");
1119 31153938 : j++;
1120 31153938 : *next = j;
1121 31153938 : return MAL_SUCCEED;
1122 425768516 : default:
1123 425768516 : if ((unsigned char) *j < ' ')
1124 3 : throw(MAL, "json.parser", "illegal control char");
1125 425768513 : if (seensurrogate)
1126 1 : throw(MAL, "json.parser", "illegal escape char");
1127 : break;
1128 : }
1129 : }
1130 9 : *next = j;
1131 9 : throw(MAL, "json.parser", "Nonterminated string");
1132 : }
1133 :
1134 : static bool
1135 5613832 : JSONintegerParser(const char *j, const char **next)
1136 : {
1137 5613832 : if (*j == '-')
1138 116377 : j++;
1139 :
1140 : // skipblancs(j);
1141 5613832 : if (!isdigit((unsigned char) *j)) {
1142 6 : *next = j;
1143 6 : return false;
1144 : }
1145 :
1146 5613826 : if (*j == '0') {
1147 544271 : *next = ++j;
1148 544271 : return true;
1149 : }
1150 :
1151 33917582 : for (; *j; j++)
1152 33917475 : if (!(isdigit((unsigned char) *j)))
1153 : break;
1154 5069555 : *next = j;
1155 :
1156 5069555 : return true;
1157 : }
1158 :
1159 : static bool
1160 5613826 : JSONfractionParser(const char *j, const char **next)
1161 : {
1162 5613826 : if (*j != '.')
1163 : return false;
1164 :
1165 : // skip the period character
1166 82787 : j++;
1167 : // must be followed by more digits
1168 82787 : if (!isdigit((unsigned char) *j))
1169 : return false;
1170 633877 : for (; *j; j++)
1171 633862 : if (!isdigit((unsigned char) *j))
1172 : break;
1173 82780 : *next = j;
1174 :
1175 82780 : return true;
1176 : }
1177 :
1178 : static bool
1179 5613827 : JSONexponentParser(const char *j, const char **next)
1180 : {
1181 5613827 : const char *s = j;
1182 5613827 : bool saw_digit = false;
1183 :
1184 5613827 : if (*j != 'e' && *j != 'E') {
1185 : return false;
1186 : }
1187 :
1188 45 : j++;
1189 45 : if (*j == '-' || *j == '+')
1190 20 : j++;
1191 :
1192 248 : for (; *j; j++) {
1193 245 : if (!isdigit((unsigned char) *j))
1194 : break;
1195 203 : saw_digit = true;
1196 : }
1197 :
1198 :
1199 45 : if (!saw_digit) {
1200 5613827 : j = s;
1201 : return false;
1202 : }
1203 :
1204 :
1205 32 : *next = j;
1206 :
1207 32 : return true;
1208 : }
1209 :
1210 : static str
1211 5613831 : JSONnumberParser(const char *j, const char **next)
1212 : {
1213 5613831 : if (!JSONintegerParser(j, next)) {
1214 6 : throw(MAL, "json.parser", "Number expected");
1215 : }
1216 :
1217 5613826 : j = *next;
1218 : // backup = j;
1219 : // skipblancs(j);
1220 :
1221 5613826 : if (!JSONfractionParser(j, next)) {
1222 5531047 : *next = j;
1223 : }
1224 :
1225 5613822 : j = *next;
1226 :
1227 5613822 : if (!JSONexponentParser(j, next)) {
1228 5613795 : *next = j;
1229 : }
1230 : return MAL_SUCCEED;
1231 : }
1232 :
1233 : static int
1234 47717216 : JSONtoken(JSON *jt, const char *j, const char **next)
1235 : {
1236 47717216 : str msg;
1237 47717216 : int nxt, idx = JSONnew(jt);
1238 47717231 : const char *string_start = j;
1239 47717231 : int pidx;
1240 :
1241 47717231 : if (jt->error)
1242 : return idx;
1243 47717237 : if (THRhighwater()) {
1244 2 : jt->error = createException(MAL, "json.parser",
1245 : SQLSTATE(42000)
1246 : "Expression too complex to parse");
1247 2 : return idx;
1248 : }
1249 47717349 : skipblancs(j);
1250 47717349 : switch (*j) {
1251 3313268 : case '{':
1252 3313268 : jt->elm[idx].kind = JSON_OBJECT;
1253 3313268 : jt->elm[idx].value = j;
1254 3313268 : j++;
1255 22243002 : while (*j) {
1256 22243090 : skipblancs(j);
1257 22242996 : if (*j == '}')
1258 : break;
1259 22235823 : nxt = JSONtoken(jt, j, next);
1260 22235846 : if (jt->error)
1261 : return idx;
1262 22235826 : j = *next;
1263 22235837 : skipblancs(j);
1264 22235826 : if (jt->elm[nxt].kind != JSON_STRING || *j != ':') {
1265 22 : jt->error = createException(MAL, "json.parser",
1266 : "JSON syntax error: element expected at offset %td",
1267 11 : jt->elm[nxt].value - string_start);
1268 11 : return idx;
1269 : }
1270 22235815 : j++;
1271 22236472 : skipblancs(j);
1272 22235815 : jt->elm[nxt].kind = JSON_ELEMENT;
1273 : /* do in two steps since JSONtoken may realloc jt->elm */
1274 22235815 : int chld = JSONtoken(jt, j, next);
1275 22235782 : if (jt->error)
1276 : return idx;
1277 :
1278 : /* Search for a duplicate key */
1279 263014809 : for(pidx = jt->elm[idx].next; pidx != 0; pidx = jt->elm[pidx].next) {
1280 240786916 : if (jt->elm[pidx].kind == JSON_ELEMENT &&
1281 240786898 : jt->elm[pidx].valuelen == jt->elm[nxt].valuelen - 2 &&
1282 7094332 : strncmp(jt->elm[pidx].value, jt->elm[nxt].value + 1,
1283 : jt->elm[nxt].valuelen) == 0) {
1284 : break;
1285 : }
1286 : }
1287 :
1288 : /* Duplicate found: Change the value of the previous key. */
1289 22227909 : if (pidx > 0) {
1290 16 : jt->elm[pidx].child = chld;
1291 : /* Note that we do not call JSONappend here.
1292 : *
1293 : * Normally we would de-allocate the old child value and the new key,
1294 : * but since we are using an arena provided by JSONnew, we don't need to.
1295 : * This might get expensive for big objects with lagre values for
1296 : * repeated keys.
1297 : */
1298 :
1299 : } else {
1300 22227893 : jt->elm[nxt].child = chld;
1301 22227893 : jt->elm[nxt].value++;
1302 22227893 : jt->elm[nxt].valuelen -= 2;
1303 22227893 : JSONappend(jt, idx, nxt);
1304 22227904 : if (jt->error)
1305 : return idx;
1306 : }
1307 22227920 : j = *next;
1308 22228035 : skipblancs(j);
1309 22227920 : if (*j == '}')
1310 : break;
1311 18929744 : if (*j != ',') {
1312 8 : jt->error = createException(MAL, "json.parser",
1313 : "JSON syntax error: ',' or '}' expected at offset %td",
1314 : j - string_start);
1315 8 : return idx;
1316 : }
1317 18929736 : j++;
1318 18930497 : skipblancs(j);
1319 18929736 : if (*j == '}') {
1320 2 : jt->error = createException(MAL, "json.parser",
1321 : "JSON syntax error: '}' not expected at offset %td",
1322 : j - string_start);
1323 2 : return idx;
1324 : }
1325 : }
1326 3305355 : if (*j != '}') {
1327 6 : jt->error = createException(MAL, "json.parser",
1328 : "JSON syntax error: '}' expected at offset %td",
1329 : j - string_start);
1330 6 : return idx;
1331 : } else
1332 3305349 : j++;
1333 3305349 : *next = j;
1334 3305349 : jt->elm[idx].valuelen = *next - jt->elm[idx].value;
1335 3305349 : return idx;
1336 1606851 : case '[':
1337 1606851 : jt->elm[idx].kind = JSON_ARRAY;
1338 1606851 : jt->elm[idx].value = j;
1339 1606851 : j++;
1340 2045466 : while (*j) {
1341 2045498 : skipblancs(j);
1342 2045462 : if (*j == ']')
1343 : break;
1344 1064486 : nxt = JSONtoken(jt, j, next);
1345 1064486 : if (jt->error)
1346 : return idx;
1347 1040812 : switch (jt->elm[nxt].kind) {
1348 0 : case JSON_ELEMENT:{
1349 0 : int k = JSONnew(jt);
1350 0 : if (jt->error)
1351 : return idx;
1352 0 : jt->elm[k].kind = JSON_OBJECT;
1353 0 : jt->elm[k].child = nxt;
1354 0 : nxt = k;
1355 : }
1356 : /* fall through */
1357 343310 : case JSON_OBJECT:
1358 : case JSON_ARRAY:
1359 343310 : if (jt->elm[nxt].kind == JSON_OBJECT
1360 343310 : || jt->elm[nxt].kind == JSON_ARRAY) {
1361 343310 : int k = JSONnew(jt);
1362 343310 : if (jt->error)
1363 : return idx;
1364 343310 : JSONappend(jt, idx, k);
1365 343310 : if (jt->error)
1366 : return idx;
1367 343310 : jt->elm[k].kind = JSON_VALUE;
1368 343310 : jt->elm[k].child = nxt;
1369 : }
1370 : break;
1371 697502 : default:
1372 697502 : JSONappend(jt, idx, nxt);
1373 697502 : if (jt->error)
1374 : return idx;
1375 : }
1376 1040812 : j = *next;
1377 1040846 : skipblancs(j);
1378 1040812 : if (*j == ']')
1379 : break;
1380 438666 : if (jt->elm[nxt].kind == JSON_ELEMENT) {
1381 0 : jt->error = createException(MAL, "json.parser",
1382 : "JSON syntax error: Array value expected at offset %td",
1383 : j - string_start);
1384 0 : return idx;
1385 : }
1386 438666 : if (*j != ',') {
1387 98 : jt->error = createException(MAL, "json.parser",
1388 : "JSON syntax error: ',' or ']' expected at offset %td (context: %c%c%c)",
1389 49 : j - string_start, *(j - 1), *j,
1390 49 : *(j + 1));
1391 49 : return idx;
1392 : }
1393 438617 : j++;
1394 438854 : skipblancs(j);
1395 438617 : if (*j == ']') {
1396 2 : jt->error = createException(MAL, "json.parser",
1397 : "JSON syntax error: '}' not expected at offset %td",
1398 : j - string_start);
1399 2 : return idx;
1400 : }
1401 : }
1402 1583126 : if (*j != ']') {
1403 4 : jt->error = createException(MAL, "json.parser",
1404 : "JSON syntax error: ']' expected at offset %td",
1405 : j - string_start);
1406 : } else
1407 1583122 : j++;
1408 1583126 : *next = j;
1409 1583126 : jt->elm[idx].valuelen = *next - jt->elm[idx].value;
1410 1583126 : return idx;
1411 31153937 : case '"':
1412 31153937 : msg = JSONstringParser(j, next);
1413 31153981 : if (msg) {
1414 39 : jt->error = msg;
1415 39 : return idx;
1416 : }
1417 31153942 : jt->elm[idx].kind = JSON_STRING;
1418 31153942 : jt->elm[idx].value = j;
1419 31153942 : jt->elm[idx].valuelen = *next - j;
1420 31153942 : return idx;
1421 2964556 : case 'n':
1422 2964556 : if (strncmp("null", j, 4) == 0) {
1423 2964554 : *next = j + 4;
1424 2964554 : jt->elm[idx].kind = JSON_NULL;
1425 2964554 : jt->elm[idx].value = j;
1426 2964554 : jt->elm[idx].valuelen = 4;
1427 2964554 : return idx;
1428 : }
1429 2 : jt->error = createException(MAL, "json.parser",
1430 : "JSON syntax error: NULL expected at offset %td",
1431 : j - string_start);
1432 2 : return idx;
1433 508579 : case 't':
1434 508579 : if (strncmp("true", j, 4) == 0) {
1435 508576 : *next = j + 4;
1436 508576 : jt->elm[idx].kind = JSON_NUMBER;
1437 508576 : jt->elm[idx].value = j;
1438 508576 : jt->elm[idx].valuelen = 4;
1439 508576 : return idx;
1440 : }
1441 3 : jt->error = createException(MAL, "json.parser",
1442 : "JSON syntax error: True expected at offset %td",
1443 : j - string_start);
1444 3 : return idx;
1445 2556250 : case 'f':
1446 2556250 : if (strncmp("false", j, 5) == 0) {
1447 2556248 : *next = j + 5;
1448 2556248 : jt->elm[idx].kind = JSON_NUMBER;
1449 2556248 : jt->elm[idx].value = j;
1450 2556248 : jt->elm[idx].valuelen = 5;
1451 2556248 : return idx;
1452 : }
1453 2 : jt->error = createException(MAL, "json.parser",
1454 : "JSON syntax error: False expected at offset %td",
1455 : j - string_start);
1456 2 : return idx;
1457 5613908 : default:
1458 5613908 : if (*j == '-' || isdigit((unsigned char) *j)) {
1459 5613832 : jt->elm[idx].value = j;
1460 5613832 : msg = JSONnumberParser(j, next);
1461 5613833 : if (msg)
1462 6 : jt->error = msg;
1463 5613833 : jt->elm[idx].kind = JSON_NUMBER;
1464 5613833 : jt->elm[idx].valuelen = *next - jt->elm[idx].value;
1465 5613833 : return idx;
1466 : }
1467 76 : jt->error = createException(MAL, "json.parser",
1468 : "JSON syntax error: value expected at offset %td",
1469 : j - string_start);
1470 76 : return idx;
1471 : }
1472 : }
1473 :
1474 :
1475 : static JSON *
1476 2181312 : JSONparse(const char *j)
1477 : {
1478 2181312 : JSON *jt = JSONnewtree();
1479 :
1480 2181315 : if (jt == NULL)
1481 : return NULL;
1482 2181323 : skipblancs(j);
1483 2181315 : JSONtoken(jt, j, &j);
1484 2181315 : if (jt->error)
1485 : return jt;
1486 2181125 : skipblancs(j);
1487 2181102 : if (*j)
1488 28 : jt->error = createException(MAL, "json.parser",
1489 : "JSON syntax error: json parse failed");
1490 : return jt;
1491 : }
1492 :
1493 : static str
1494 9 : JSONlength(int *ret, json *j)
1495 : {
1496 9 : int i, cnt = 0;
1497 9 : JSON *jt;
1498 :
1499 9 : if (strNil(*j)) {
1500 0 : *ret = int_nil;
1501 0 : return MAL_SUCCEED;
1502 : }
1503 :
1504 9 : jt = JSONparse(*j);
1505 9 : CHECK_JSON(jt);
1506 26 : for (i = jt->elm[0].next; i; i = jt->elm[i].next)
1507 17 : cnt++;
1508 9 : *ret = cnt;
1509 9 : JSONfree(jt);
1510 9 : return MAL_SUCCEED;
1511 : }
1512 :
1513 : static str
1514 17 : JSONfilterArrayDefault(json *ret, json *js, lng index, str other)
1515 : {
1516 17 : char expr[BUFSIZ], *s = expr;
1517 :
1518 17 : if (index < 0)
1519 0 : throw(MAL, "json.filter",
1520 : SQLSTATE(42000) "Filter index cannot be negative");
1521 17 : snprintf(expr, BUFSIZ, "[" LLFMT "]", index);
1522 17 : return JSONfilterInternal(ret, js, &s, other);
1523 : }
1524 :
1525 : static str
1526 4 : JSONfilterArray_bte(json *ret, json *js, bte *index)
1527 : {
1528 8 : if (strNil(*js) || is_bte_nil(*index)) {
1529 0 : if (!(*ret = GDKstrdup(str_nil)))
1530 0 : throw(MAL, "json.filter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1531 : return MAL_SUCCEED;
1532 : }
1533 4 : return JSONfilterArrayDefault(ret, js, (lng) *index, 0);
1534 : }
1535 :
1536 : static str
1537 0 : JSONfilterArrayDefault_bte(json *ret, json *js, bte *index, str *other)
1538 : {
1539 0 : if (strNil(*js) || is_bte_nil(*index) || strNil(*other)) {
1540 0 : if (!(*ret = GDKstrdup(str_nil)))
1541 0 : throw(MAL, "json.filter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1542 : return MAL_SUCCEED;
1543 : }
1544 0 : return JSONfilterArrayDefault(ret, js, (lng) *index, *other);
1545 : }
1546 :
1547 : static str
1548 0 : JSONfilterArray_sht(json *ret, json *js, sht *index)
1549 : {
1550 0 : if (strNil(*js) || is_sht_nil(*index)) {
1551 0 : if (!(*ret = GDKstrdup(str_nil)))
1552 0 : throw(MAL, "json.filter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1553 : return MAL_SUCCEED;
1554 : }
1555 0 : return JSONfilterArrayDefault(ret, js, (lng) *index, 0);
1556 : }
1557 :
1558 : static str
1559 0 : JSONfilterArrayDefault_sht(json *ret, json *js, sht *index, str *other)
1560 : {
1561 0 : if (strNil(*js) || is_sht_nil(*index) || strNil(*other)) {
1562 0 : if (!(*ret = GDKstrdup(str_nil)))
1563 0 : throw(MAL, "json.filter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1564 : return MAL_SUCCEED;
1565 : }
1566 0 : return JSONfilterArrayDefault(ret, js, (lng) *index, *other);
1567 : }
1568 :
1569 : static str
1570 13 : JSONfilterArray_int(json *ret, json *js, int *index)
1571 : {
1572 26 : if (strNil(*js) || is_int_nil(*index)) {
1573 0 : if (!(*ret = GDKstrdup(str_nil)))
1574 0 : throw(MAL, "json.filter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1575 : return MAL_SUCCEED;
1576 : }
1577 13 : return JSONfilterArrayDefault(ret, js, (lng) *index, 0);
1578 : }
1579 :
1580 : static str
1581 0 : JSONfilterArrayDefault_int(json *ret, json *js, int *index, str *other)
1582 : {
1583 0 : if (strNil(*js) || is_int_nil(*index) || strNil(*other)) {
1584 0 : if (!(*ret = GDKstrdup(str_nil)))
1585 0 : throw(MAL, "json.filter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1586 : return MAL_SUCCEED;
1587 : }
1588 0 : return JSONfilterArrayDefault(ret, js, (lng) *index, *other);
1589 : }
1590 :
1591 : static str
1592 0 : JSONfilterArray_lng(json *ret, json *js, lng *index)
1593 : {
1594 0 : if (strNil(*js) || is_lng_nil(*index)) {
1595 0 : if (!(*ret = GDKstrdup(str_nil)))
1596 0 : throw(MAL, "json.filter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1597 : return MAL_SUCCEED;
1598 : }
1599 0 : return JSONfilterArrayDefault(ret, js, (lng) *index, 0);
1600 : }
1601 :
1602 : static str
1603 0 : JSONfilterArrayDefault_lng(json *ret, json *js, lng *index, str *other)
1604 : {
1605 0 : if (strNil(*js) || is_lng_nil(*index) || strNil(*other)) {
1606 0 : if (!(*ret = GDKstrdup(str_nil)))
1607 0 : throw(MAL, "json.filter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1608 : return MAL_SUCCEED;
1609 : }
1610 0 : return JSONfilterArrayDefault(ret, js, (lng) *index, *other);
1611 : }
1612 :
1613 : #ifdef HAVE_HGE
1614 : static str
1615 0 : JSONfilterArray_hge(json *ret, json *js, hge *index)
1616 : {
1617 0 : if (strNil(*js) || is_hge_nil(*index)) {
1618 0 : if (!(*ret = GDKstrdup(str_nil)))
1619 0 : throw(MAL, "json.filter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1620 : return MAL_SUCCEED;
1621 : }
1622 0 : if (*index < (hge) GDK_lng_min || *index > (hge) GDK_lng_max)
1623 0 : throw(MAL, "json.filter", "index out of range");
1624 0 : return JSONfilterArrayDefault(ret, js, (lng) *index, 0);
1625 : }
1626 :
1627 : static str
1628 0 : JSONfilterArrayDefault_hge(json *ret, json *js, hge *index, str *other)
1629 : {
1630 0 : if (strNil(*js) || is_hge_nil(*index) || strNil(*other)) {
1631 0 : if (!(*ret = GDKstrdup(str_nil)))
1632 0 : throw(MAL, "json.filter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1633 : return MAL_SUCCEED;
1634 : }
1635 0 : if (*index < (hge) GDK_lng_min || *index > (hge) GDK_lng_max)
1636 0 : throw(MAL, "json.filter", "index out of range");
1637 0 : return JSONfilterArrayDefault(ret, js, (lng) *index, *other);
1638 : }
1639 : #endif
1640 :
1641 : static str
1642 405 : JSONfilter(json *ret, json *js, str *expr)
1643 : {
1644 810 : if (strNil(*js) || strNil(*expr)) {
1645 0 : if (!(*ret = GDKstrdup(str_nil)))
1646 0 : throw(MAL, "json.filter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1647 : return MAL_SUCCEED;
1648 : }
1649 405 : return JSONfilterInternal(ret, js, expr, 0);
1650 : }
1651 :
1652 : // glue all values together with an optional separator
1653 : // The json string should be valid
1654 :
1655 : static str
1656 234 : JSONplaintext(char **r, size_t *l, size_t *ilen, JSON *jt, int idx, str sep,
1657 : size_t sep_len)
1658 : {
1659 234 : int i;
1660 234 : size_t j, next_len, next_concat_len;
1661 234 : unsigned int u;
1662 234 : str msg = MAL_SUCCEED;
1663 :
1664 234 : if (THRhighwater()) {
1665 0 : *r = *r - (*ilen - *l);
1666 0 : throw(MAL, "JSONplaintext",
1667 : SQLSTATE(42000) "Expression too complex to parse");
1668 : }
1669 :
1670 233 : switch (jt->elm[idx].kind) {
1671 30 : case JSON_OBJECT:
1672 84 : for (i = jt->elm[idx].next; i; i = jt->elm[i].next)
1673 56 : if (jt->elm[i].child
1674 56 : && (msg = JSONplaintext(r, l, ilen, jt, jt->elm[i].child, sep,
1675 : sep_len)))
1676 0 : return msg;
1677 : break;
1678 35 : case JSON_ARRAY:
1679 106 : for (i = jt->elm[idx].next; i; i = jt->elm[i].next)
1680 71 : if ((msg = JSONplaintext(r, l, ilen, jt, i, sep, sep_len)))
1681 0 : return msg;
1682 : break;
1683 3 : case JSON_ELEMENT:
1684 : case JSON_VALUE:
1685 3 : if (jt->elm[idx].child
1686 3 : && (msg = JSONplaintext(r, l, ilen, jt, jt->elm[idx].child, sep,
1687 : sep_len)))
1688 : return msg;
1689 : break;
1690 90 : case JSON_STRING:
1691 : // Make sure there is enough space for the value plus the separator plus the NULL byte
1692 90 : next_len = jt->elm[idx].valuelen;
1693 90 : next_concat_len = next_len - 2 + sep_len + 1;
1694 90 : if (*l < next_concat_len) {
1695 1 : size_t prev_ilen = *ilen, prev_l = *l;
1696 1 : char *p = *r - (prev_ilen - prev_l), *nr;
1697 :
1698 1 : *ilen = (prev_ilen * 2) + next_concat_len; /* make sure sep_len + 1 is always included */
1699 1 : if (!(nr = GDKrealloc(p, *ilen))) {
1700 0 : *r = p;
1701 0 : throw(MAL, "JSONplaintext", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1702 : }
1703 1 : *r = nr + (prev_ilen - prev_l);
1704 1 : *l = *ilen - prev_ilen + prev_l;
1705 : }
1706 90 : assert(next_len >= 2);
1707 90 : next_len--;
1708 821 : for (j = 1; j < next_len; j++) {
1709 731 : if (jt->elm[idx].value[j] == '\\') {
1710 4 : switch (jt->elm[idx].value[++j]) {
1711 4 : case '"':
1712 : case '\\':
1713 : case '/':
1714 4 : *(*r)++ = jt->elm[idx].value[j];
1715 4 : (*l)--;
1716 4 : break;
1717 0 : case 'b':
1718 0 : *(*r)++ = '\b';
1719 0 : (*l)--;
1720 0 : break;
1721 0 : case 'f':
1722 0 : *(*r)++ = '\f';
1723 0 : (*l)--;
1724 0 : break;
1725 0 : case 'r':
1726 0 : *(*r)++ = '\r';
1727 0 : (*l)--;
1728 0 : break;
1729 0 : case 'n':
1730 0 : *(*r)++ = '\n';
1731 0 : (*l)--;
1732 0 : break;
1733 0 : case 't':
1734 0 : *(*r)++ = '\t';
1735 0 : (*l)--;
1736 0 : break;
1737 : case 'u':
1738 : u = 0;
1739 0 : for (int i = 0; i < 4; i++) {
1740 0 : char c = jt->elm[idx].value[++j];
1741 0 : u <<= 4;
1742 0 : if ('0' <= c && c <= '9')
1743 0 : u |= c - '0';
1744 0 : else if ('a' <= c && c <= 'f')
1745 0 : u |= c - 'a' + 10;
1746 : else /* if ('A' <= c && c <= 'F') */
1747 0 : u |= c - 'A' + 10;
1748 : }
1749 0 : if (u <= 0x7F) {
1750 0 : *(*r)++ = (char) u;
1751 0 : (*l)--;
1752 0 : } else if (u <= 0x7FF) {
1753 0 : *(*r)++ = 0xC0 | (u >> 6);
1754 0 : *(*r)++ = 0x80 | (u & 0x3F);
1755 0 : (*l) -= 2;
1756 0 : } else if ((u & 0xFC00) == 0xD800) {
1757 : /* high surrogate; must be followed by low surrogate */
1758 0 : *(*r)++ = 0xF0 | (((u & 0x03C0) + 0x0040) >> 8);
1759 0 : *(*r)++ = 0x80 | ((((u & 0x03C0) + 0x0040) >> 2) & 0x3F);
1760 0 : **r = 0x80 | ((u & 0x0003) << 4); /* no increment */
1761 0 : (*l) -= 2;
1762 0 : } else if ((u & 0xFC00) == 0xDC00) {
1763 : /* low surrogate; must follow high surrogate */
1764 0 : *(*r)++ |= (u & 0x03C0) >> 6; /* amend last value */
1765 0 : *(*r)++ = 0x80 | (u & 0x3F);
1766 0 : (*l) -= 2;
1767 : } else { /* if (u <= 0xFFFF) */
1768 0 : *(*r)++ = 0xE0 | (u >> 12);
1769 0 : *(*r)++ = 0x80 | ((u >> 6) & 0x3F);
1770 0 : *(*r)++ = 0x80 | (u & 0x3F);
1771 0 : (*l) -= 3;
1772 : }
1773 : }
1774 : } else {
1775 727 : *(*r)++ = jt->elm[idx].value[j];
1776 727 : (*l)--;
1777 : }
1778 : }
1779 90 : memcpy(*r, sep, sep_len);
1780 90 : *l -= sep_len;
1781 90 : *r += sep_len;
1782 90 : break;
1783 75 : default:
1784 75 : next_len = jt->elm[idx].valuelen;
1785 75 : next_concat_len = next_len + sep_len + 1;
1786 75 : if (*l < next_concat_len) {
1787 21 : size_t prev_ilen = *ilen, prev_l = *l;
1788 21 : char *p = *r - (prev_ilen - prev_l), *nr;
1789 :
1790 21 : *ilen = (prev_ilen * 2) + next_concat_len; /* make sure sep_len + 1 is always included */
1791 21 : if (!(nr = GDKrealloc(p, *ilen))) {
1792 0 : *r = p;
1793 0 : throw(MAL, "JSONplaintext", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1794 : }
1795 21 : *r = nr + (prev_ilen - prev_l);
1796 21 : *l = *ilen - prev_ilen + prev_l;
1797 : }
1798 75 : memcpy(*r, jt->elm[idx].value, next_len);
1799 75 : *l -= next_len;
1800 75 : *r += next_len;
1801 75 : memcpy(*r, sep, sep_len);
1802 75 : *l -= sep_len;
1803 75 : *r += sep_len;
1804 : }
1805 231 : assert(*l > 0);
1806 231 : **r = 0;
1807 231 : return MAL_SUCCEED;
1808 : }
1809 :
1810 : static str
1811 104 : JSONjson2textSeparator(str *ret, json *js, str *sep)
1812 : {
1813 104 : size_t l, ilen, sep_len;
1814 104 : str s, msg;
1815 104 : JSON *jt;
1816 :
1817 207 : if (strNil(*js) || strNil(*sep)) {
1818 2 : if (!(*ret = GDKstrdup(str_nil)))
1819 0 : throw(MAL, "json2txt", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1820 : return MAL_SUCCEED;
1821 : }
1822 :
1823 102 : jt = JSONparse(*js);
1824 103 : CHECK_JSON(jt);
1825 103 : sep_len = strlen(*sep);
1826 103 : ilen = l = strlen(*js) + 1;
1827 103 : if (!(s = GDKmalloc(l))) {
1828 0 : JSONfree(jt);
1829 0 : throw(MAL, "json2txt", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1830 : }
1831 104 : msg = JSONplaintext(&s, &l, &ilen, jt, 0, *sep, sep_len);
1832 104 : JSONfree(jt);
1833 104 : if (msg) {
1834 0 : GDKfree(s);
1835 0 : return msg;
1836 : }
1837 104 : s -= ilen - l;
1838 104 : l = strlen(s);
1839 104 : if (l && sep_len)
1840 88 : s[l - sep_len] = 0;
1841 104 : *ret = s;
1842 104 : return MAL_SUCCEED;
1843 : }
1844 :
1845 : static str
1846 87 : JSONjson2text(str *ret, json *js)
1847 : {
1848 87 : char *sep = " ";
1849 87 : return JSONjson2textSeparator(ret, js, &sep);
1850 : }
1851 :
1852 : static str
1853 107 : JSONjson2numberInternal(void **ret, json *js,
1854 : void (*str2num)(void **ret, const char *nptr,
1855 : size_t len))
1856 : {
1857 107 : JSON *jt;
1858 :
1859 107 : jt = JSONparse(*js);
1860 108 : CHECK_JSON(jt);
1861 108 : switch (jt->elm[0].kind) {
1862 90 : case JSON_NUMBER:
1863 90 : str2num(ret, jt->elm[0].value, jt->elm[0].valuelen);
1864 90 : break;
1865 8 : case JSON_ARRAY:
1866 8 : if (jt->free == 2) {
1867 6 : str2num(ret, jt->elm[1].value, jt->elm[1].valuelen);
1868 : } else {
1869 2 : *ret = NULL;
1870 : }
1871 : break;
1872 6 : case JSON_OBJECT:
1873 6 : if (jt->free == 3) {
1874 4 : str2num(ret, jt->elm[2].value, jt->elm[2].valuelen);
1875 : } else {
1876 2 : *ret = NULL;
1877 : }
1878 : break;
1879 4 : default:
1880 4 : *ret = NULL;
1881 : }
1882 107 : JSONfree(jt);
1883 :
1884 107 : return MAL_SUCCEED;
1885 : }
1886 :
1887 : static void
1888 74 : strtod_wrapper(void **ret, const char *nptr, size_t len)
1889 : {
1890 74 : char *rest;
1891 74 : dbl val;
1892 :
1893 74 : val = strtod(nptr, &rest);
1894 74 : if (rest && (size_t) (rest - nptr) != len) {
1895 0 : *ret = NULL;
1896 : } else {
1897 74 : **(dbl **) ret = val;
1898 : }
1899 74 : }
1900 :
1901 : static void
1902 26 : strtol_wrapper(void **ret, const char *nptr, size_t len)
1903 : {
1904 26 : char *rest;
1905 26 : lng val;
1906 :
1907 26 : val = strtol(nptr, &rest, 0);
1908 26 : if (rest && (size_t) (rest - nptr) != len) {
1909 2 : *ret = NULL;
1910 : } else {
1911 24 : **(lng **) ret = val;
1912 : }
1913 26 : }
1914 :
1915 : static str
1916 78 : JSONjson2number(dbl *ret, json *js)
1917 : {
1918 78 : dbl val = 0;
1919 78 : dbl *val_ptr = &val;
1920 78 : str tmp;
1921 :
1922 78 : if (strNil(*js)) {
1923 0 : *ret = dbl_nil;
1924 0 : return MAL_SUCCEED;
1925 : }
1926 :
1927 78 : rethrow(__func__, tmp,
1928 : JSONjson2numberInternal((void **) &val_ptr, js, strtod_wrapper));
1929 79 : if (val_ptr == NULL)
1930 5 : *ret = dbl_nil;
1931 : else
1932 74 : *ret = val;
1933 :
1934 : return MAL_SUCCEED;
1935 : }
1936 :
1937 : static str
1938 29 : JSONjson2integer(lng *ret, json *js)
1939 : {
1940 29 : lng val = 0;
1941 29 : lng *val_ptr = &val;
1942 29 : str tmp;
1943 :
1944 29 : if (strNil(*js)) {
1945 0 : *ret = lng_nil;
1946 0 : return MAL_SUCCEED;
1947 : }
1948 :
1949 29 : rethrow(__func__, tmp,
1950 : JSONjson2numberInternal((void **) &val_ptr, js, strtol_wrapper));
1951 29 : if (val_ptr == NULL)
1952 5 : *ret = lng_nil;
1953 : else
1954 24 : *ret = val;
1955 :
1956 : return MAL_SUCCEED;
1957 : }
1958 :
1959 : static str
1960 8 : JSONunfoldContainer(JSON *jt, int idx, BAT *bo, BAT *bk, BAT *bv, oid *o)
1961 : {
1962 8 : int i, last;
1963 8 : char *r;
1964 :
1965 8 : last = jt->elm[idx].tail;
1966 8 : if (jt->elm[idx].kind == JSON_OBJECT) {
1967 8 : for (i = jt->elm[idx].next; i; i = jt->elm[i].next) {
1968 8 : if ((r = JSONgetValue(jt, i)) == NULL)
1969 0 : goto memfail;
1970 8 : if (BUNappend(bk, r, false) != GDK_SUCCEED) {
1971 0 : GDKfree(r);
1972 0 : goto memfail;
1973 : }
1974 8 : GDKfree(r);
1975 8 : if ((r = JSONgetValue(jt, jt->elm[i].child)) == NULL)
1976 0 : goto memfail;
1977 8 : if (BUNappend(bv, r, false) != GDK_SUCCEED) {
1978 0 : GDKfree(r);
1979 0 : goto memfail;
1980 : }
1981 8 : GDKfree(r);
1982 8 : if (bo) {
1983 4 : if (BUNappend(bo, o, false) != GDK_SUCCEED)
1984 0 : goto memfail;
1985 : }
1986 8 : (*o)++;
1987 8 : if (i == last)
1988 : break;
1989 : }
1990 6 : } else if (jt->elm[idx].kind == JSON_ARRAY) {
1991 26 : for (i = jt->elm[idx].next; i; i = jt->elm[i].next) {
1992 26 : if (BUNappend(bk, str_nil, false) != GDK_SUCCEED)
1993 0 : goto memfail;
1994 26 : if (jt->elm[i].kind == JSON_VALUE)
1995 22 : r = JSONgetValue(jt, jt->elm[i].child);
1996 : else
1997 4 : r = JSONgetValue(jt, i);
1998 26 : if (r == NULL)
1999 0 : goto memfail;
2000 26 : if (BUNappend(bv, r, false) != GDK_SUCCEED) {
2001 0 : GDKfree(r);
2002 0 : goto memfail;
2003 : }
2004 26 : GDKfree(r);
2005 26 : if (bo) {
2006 13 : if (BUNappend(bo, o, false) != GDK_SUCCEED)
2007 0 : goto memfail;
2008 : }
2009 26 : (*o)++;
2010 26 : if (i == last)
2011 : break;
2012 : }
2013 : }
2014 : return MAL_SUCCEED;
2015 :
2016 0 : memfail:
2017 0 : throw(MAL, "json.unfold", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2018 : }
2019 :
2020 : static str
2021 8 : JSONunfoldInternal(bat *od, bat *key, bat *val, json *js)
2022 : {
2023 8 : BAT *bo = NULL, *bk, *bv;
2024 8 : oid o = 0;
2025 8 : str msg = MAL_SUCCEED;
2026 :
2027 8 : JSON *jt = JSONparse(*js);
2028 :
2029 8 : CHECK_JSON(jt);
2030 8 : bk = COLnew(0, TYPE_str, 64, TRANSIENT);
2031 8 : if (bk == NULL) {
2032 0 : JSONfree(jt);
2033 0 : throw(MAL, "json.unfold", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2034 : }
2035 :
2036 8 : if (od) {
2037 4 : bo = COLnew(0, TYPE_oid, 64, TRANSIENT);
2038 4 : if (bo == NULL) {
2039 0 : BBPreclaim(bk);
2040 0 : JSONfree(jt);
2041 0 : throw(MAL, "json.unfold", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2042 : }
2043 : }
2044 :
2045 8 : bv = COLnew(0, TYPE_json, 64, TRANSIENT);
2046 8 : if (bv == NULL) {
2047 0 : JSONfree(jt);
2048 0 : BBPreclaim(bo);
2049 0 : BBPreclaim(bk);
2050 0 : throw(MAL, "json.unfold", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2051 : }
2052 :
2053 8 : if (jt->elm[0].kind == JSON_ARRAY || jt->elm[0].kind == JSON_OBJECT)
2054 12 : msg = JSONunfoldContainer(jt, 0, (od ? bo : 0), bk, bv, &o);
2055 : else
2056 0 : msg = createException(MAL, "json.unfold",
2057 : "JSON object or array expected");
2058 8 : JSONfree(jt);
2059 8 : if (msg) {
2060 0 : BBPreclaim(bk);
2061 0 : BBPreclaim(bo);
2062 0 : BBPreclaim(bv);
2063 : } else {
2064 8 : *key = bk->batCacheid;
2065 8 : BBPkeepref(bk);
2066 8 : *val = bv->batCacheid;
2067 8 : BBPkeepref(bv);
2068 8 : if (od) {
2069 4 : *od = bo->batCacheid;
2070 4 : BBPkeepref(bo);
2071 : }
2072 : }
2073 : return msg;
2074 : }
2075 :
2076 :
2077 :
2078 : static str
2079 6 : JSONkeyTable(bat *ret, json *js)
2080 : {
2081 6 : BAT *bn;
2082 6 : char *r;
2083 6 : int i;
2084 6 : JSON *jt;
2085 :
2086 6 : jt = JSONparse(*js); // already validated
2087 6 : CHECK_JSON(jt);
2088 6 : bn = COLnew(0, TYPE_str, 64, TRANSIENT);
2089 6 : if (bn == NULL) {
2090 0 : JSONfree(jt);
2091 0 : throw(MAL, "json.keys", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2092 : }
2093 :
2094 20 : for (i = jt->elm[0].next; i; i = jt->elm[i].next) {
2095 14 : r = JSONgetValue(jt, i);
2096 14 : if (r == NULL || BUNappend(bn, r, false) != GDK_SUCCEED) {
2097 0 : GDKfree(r);
2098 0 : JSONfree(jt);
2099 0 : BBPreclaim(bn);
2100 0 : throw(MAL, "json.keys", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2101 : }
2102 14 : GDKfree(r);
2103 : }
2104 6 : JSONfree(jt);
2105 6 : *ret = bn->batCacheid;
2106 6 : BBPkeepref(bn);
2107 6 : return MAL_SUCCEED;
2108 : }
2109 :
2110 : static str
2111 7 : JSONkeyArray(json *ret, json *js)
2112 : {
2113 7 : char *result = NULL;
2114 7 : str r;
2115 7 : int i;
2116 7 : JSON *jt;
2117 :
2118 7 : if (strNil(*js)) {
2119 0 : if (!(*ret = GDKstrdup(str_nil)))
2120 0 : throw(MAL, "json.keyarray", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2121 : return MAL_SUCCEED;
2122 : }
2123 :
2124 7 : jt = JSONparse(*js); // already validated
2125 :
2126 7 : CHECK_JSON(jt);
2127 7 : if (jt->elm[0].kind == JSON_OBJECT) {
2128 27 : for (i = jt->elm[0].next; i; i = jt->elm[i].next) {
2129 20 : if (jt->elm[i].valuelen) {
2130 18 : r = GDKzalloc(jt->elm[i].valuelen + 3);
2131 18 : if (r == NULL) {
2132 0 : JSONfree(jt);
2133 0 : goto memfail;
2134 : }
2135 18 : strncpy(r, jt->elm[i].value - 1, jt->elm[i].valuelen + 2);
2136 : } else {
2137 2 : r = GDKstrdup("\"\"");
2138 2 : if (r == NULL) {
2139 0 : JSONfree(jt);
2140 0 : goto memfail;
2141 : }
2142 : }
2143 20 : result = JSONglue(result, r, ',');
2144 20 : if (result == NULL) {
2145 0 : JSONfree(jt);
2146 0 : goto memfail;
2147 : }
2148 : }
2149 7 : JSONfree(jt);
2150 : } else {
2151 0 : JSONfree(jt);
2152 0 : throw(MAL, "json.keyarray", "Object expected");
2153 : }
2154 7 : r = GDKstrdup("[");
2155 7 : if (r == NULL)
2156 0 : goto memfail;
2157 7 : result = JSONglue(r, result, 0);
2158 7 : if (result == NULL)
2159 0 : goto memfail;
2160 7 : r = GDKstrdup("]");
2161 7 : if (r == NULL)
2162 0 : goto memfail;
2163 7 : result = JSONglue(result, r, 0);
2164 7 : if (result == NULL)
2165 0 : goto memfail;
2166 7 : *ret = result;
2167 7 : return MAL_SUCCEED;
2168 :
2169 0 : memfail:
2170 0 : GDKfree(result);
2171 0 : throw(MAL, "json.keyarray", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2172 : }
2173 :
2174 :
2175 : static str
2176 10 : JSONvalueTable(bat *ret, json *js)
2177 : {
2178 10 : BAT *bn;
2179 10 : char *r;
2180 10 : int i;
2181 10 : JSON *jt;
2182 :
2183 10 : jt = JSONparse(*js); // already validated
2184 10 : CHECK_JSON(jt);
2185 10 : bn = COLnew(0, TYPE_json, 64, TRANSIENT);
2186 10 : if (bn == NULL) {
2187 0 : JSONfree(jt);
2188 0 : throw(MAL, "json.values", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2189 : }
2190 :
2191 34 : for (i = jt->elm[0].next; i; i = jt->elm[i].next) {
2192 24 : if (jt->elm[i].kind == JSON_ELEMENT)
2193 14 : r = JSONgetValue(jt, jt->elm[i].child);
2194 : else
2195 10 : r = JSONgetValue(jt, i);
2196 24 : if (r == NULL || BUNappend(bn, r, false) != GDK_SUCCEED) {
2197 0 : GDKfree(r);
2198 0 : BBPreclaim(bn);
2199 0 : JSONfree(jt);
2200 0 : throw(MAL, "json.values", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2201 : }
2202 24 : GDKfree(r);
2203 : }
2204 10 : JSONfree(jt);
2205 10 : *ret = bn->batCacheid;
2206 10 : BBPkeepref(bn);
2207 10 : return MAL_SUCCEED;
2208 : }
2209 :
2210 : static str
2211 4 : JSONvalueArray(json *ret, json *js)
2212 : {
2213 4 : char *result = NULL;
2214 4 : str r;
2215 4 : int i;
2216 4 : JSON *jt;
2217 :
2218 4 : if (strNil(*js)) {
2219 0 : if (!(*ret = GDKstrdup(str_nil)))
2220 0 : throw(MAL, "json.valuearray", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2221 : return MAL_SUCCEED;
2222 : }
2223 :
2224 4 : jt = JSONparse(*js); // already validated
2225 :
2226 4 : CHECK_JSON(jt);
2227 4 : if (jt->elm[0].kind == JSON_OBJECT) {
2228 21 : for (i = jt->elm[0].next; i; i = jt->elm[i].next) {
2229 17 : r = JSONgetValue(jt, jt->elm[i].child);
2230 17 : if (r == NULL) {
2231 0 : JSONfree(jt);
2232 0 : goto memfail;
2233 : }
2234 17 : result = JSONglue(result, r, ',');
2235 17 : if (result == NULL) {
2236 0 : JSONfree(jt);
2237 0 : goto memfail;
2238 : }
2239 : }
2240 4 : JSONfree(jt);
2241 : } else {
2242 0 : JSONfree(jt);
2243 0 : throw(MAL, "json.valuearray", "Object expected");
2244 : }
2245 4 : r = GDKstrdup("[");
2246 4 : if (r == NULL)
2247 0 : goto memfail;
2248 4 : result = JSONglue(r, result, 0);
2249 4 : if (result == NULL)
2250 0 : goto memfail;
2251 4 : r = GDKstrdup("]");
2252 4 : if (r == NULL)
2253 0 : goto memfail;
2254 4 : result = JSONglue(result, r, 0);
2255 4 : if (result == NULL)
2256 0 : goto memfail;
2257 4 : *ret = result;
2258 4 : return MAL_SUCCEED;
2259 :
2260 0 : memfail:
2261 0 : GDKfree(result);
2262 0 : throw(MAL, "json.valuearray", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2263 : }
2264 :
2265 : static BAT **
2266 2 : JSONargumentlist(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2267 : {
2268 2 : int i, error = 0, bats = 0;
2269 2 : BUN cnt = 0;
2270 2 : BAT **bl;
2271 :
2272 2 : bl = GDKzalloc(sizeof(*bl) * pci->argc);
2273 2 : if (bl == NULL)
2274 : return NULL;
2275 11 : for (i = pci->retc; i < pci->argc; i++)
2276 9 : if (isaBatType(getArgType(mb, pci, i))) {
2277 6 : bats++;
2278 6 : bl[i] = BATdescriptor(stk->stk[getArg(pci, i)].val.bval);
2279 6 : if (bl[i] == NULL || (cnt > 0 && BATcount(bl[i]) != cnt)) {
2280 : error = 1;
2281 : break;
2282 : }
2283 6 : cnt = BATcount(bl[i]);
2284 : }
2285 2 : if (error || bats == 0) {
2286 0 : for (i = pci->retc; i < pci->argc; i++)
2287 0 : BBPreclaim(bl[i]);
2288 0 : GDKfree(bl);
2289 0 : return NULL;
2290 : }
2291 : return bl;
2292 : }
2293 :
2294 : static void
2295 2 : JSONfreeArgumentlist(BAT **bl, InstrPtr pci)
2296 : {
2297 2 : int i;
2298 :
2299 11 : for (i = pci->retc; i < pci->argc; i++)
2300 15 : BBPreclaim(bl[i]);
2301 2 : GDKfree(bl);
2302 2 : }
2303 :
2304 : static str
2305 3 : JSONrenderRowObject(BAT **bl, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci,
2306 : BUN idx)
2307 : {
2308 3 : int i, tpe;
2309 3 : char *row, *row2, *name = 0, *val = 0;
2310 3 : size_t len, lim, l;
2311 3 : void *p;
2312 3 : BATiter bi;
2313 :
2314 3 : row = GDKmalloc(lim = BUFSIZ);
2315 3 : if (row == NULL)
2316 : return NULL;
2317 3 : row[0] = '{';
2318 3 : row[1] = 0;
2319 3 : len = 1;
2320 12 : for (i = pci->retc; i < pci->argc; i += 2) {
2321 9 : name = stk->stk[getArg(pci, i)].val.sval;
2322 9 : tpe = getBatType(getArgType(mb, pci, i + 1));
2323 9 : bi = bat_iterator(bl[i + 1]);
2324 9 : p = BUNtail(bi, idx);
2325 9 : val = ATOMformat(tpe, p);
2326 9 : bat_iterator_end(&bi);
2327 9 : if (val == NULL) {
2328 0 : GDKfree(row);
2329 0 : return NULL;
2330 : }
2331 9 : if (strncmp(val, "nil", 3) == 0) {
2332 1 : GDKfree(val);
2333 1 : val = NULL;
2334 1 : l = 4;
2335 : } else {
2336 8 : l = strlen(val);
2337 : }
2338 9 : l += strlen(name) + 4;
2339 9 : while (l > lim - len)
2340 0 : lim += BUFSIZ;
2341 9 : row2 = GDKrealloc(row, lim);
2342 9 : if (row2 == NULL) {
2343 0 : GDKfree(row);
2344 0 : GDKfree(val);
2345 0 : return NULL;
2346 : }
2347 9 : row = row2;
2348 9 : snprintf(row + len, lim - len, "\"%s\":%s,", name, val ? val : "null");
2349 9 : len += l;
2350 9 : GDKfree(val);
2351 : }
2352 3 : if (row[1])
2353 3 : row[len - 1] = '}';
2354 : else {
2355 0 : row[1] = '}';
2356 0 : row[2] = 0;
2357 : }
2358 : return row;
2359 : }
2360 :
2361 : static str
2362 1 : JSONrenderobject(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2363 : {
2364 1 : BAT **bl;
2365 1 : char *result, *row;
2366 1 : int i;
2367 1 : size_t len, lim, l;
2368 1 : json *ret;
2369 1 : BUN j, cnt;
2370 :
2371 1 : (void) cntxt;
2372 1 : bl = JSONargumentlist(mb, stk, pci);
2373 1 : if (bl == 0)
2374 0 : throw(MAL, "json.renderobject", "Non-aligned BAT sizes");
2375 4 : for (i = pci->retc; i < pci->argc; i += 2) {
2376 3 : if (getArgType(mb, pci, i) != TYPE_str) {
2377 0 : JSONfreeArgumentlist(bl, pci);
2378 0 : throw(MAL, "json.renderobject", "Keys missing");
2379 : }
2380 : }
2381 :
2382 1 : cnt = BATcount(bl[pci->retc + 1]);
2383 1 : result = GDKmalloc(lim = BUFSIZ);
2384 1 : if (result == NULL) {
2385 0 : JSONfreeArgumentlist(bl, pci);
2386 0 : throw(MAL, "json.renderobject", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2387 : }
2388 1 : result[0] = '[';
2389 1 : result[1] = 0;
2390 1 : len = 1;
2391 :
2392 4 : for (j = 0; j < cnt; j++) {
2393 3 : char *result2;
2394 3 : row = JSONrenderRowObject(bl, mb, stk, pci, j);
2395 3 : if (row == NULL)
2396 0 : goto memfail;
2397 3 : l = strlen(row);
2398 6 : while (l + 2 > lim - len)
2399 0 : lim = cnt * l <= lim ? cnt * l : lim + BUFSIZ;
2400 3 : result2 = GDKrealloc(result, lim);
2401 3 : if (result2 == NULL)
2402 0 : goto memfail;
2403 3 : result = result2;
2404 3 : strcpy(result + len, row);
2405 3 : GDKfree(row);
2406 3 : len += l;
2407 3 : result[len++] = ',';
2408 3 : result[len] = 0;
2409 : }
2410 1 : result[len - 1] = ']';
2411 1 : ret = getArgReference_TYPE(stk, pci, 0, json);
2412 1 : *ret = result;
2413 1 : JSONfreeArgumentlist(bl, pci);
2414 1 : return MAL_SUCCEED;
2415 :
2416 0 : memfail:
2417 0 : GDKfree(result);
2418 0 : GDKfree(row);
2419 0 : JSONfreeArgumentlist(bl, pci);
2420 0 : throw(MAL, "json.renderobject", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2421 : }
2422 :
2423 : static str
2424 3 : JSONrenderRowArray(BAT **bl, MalBlkPtr mb, InstrPtr pci, BUN idx)
2425 : {
2426 3 : int i, tpe;
2427 3 : char *row, *row2, *val = 0;
2428 3 : size_t len, lim, l;
2429 3 : void *p;
2430 3 : BATiter bi;
2431 :
2432 3 : row = GDKmalloc(lim = BUFSIZ);
2433 3 : if (row == NULL)
2434 : return NULL;
2435 3 : row[0] = '[';
2436 3 : row[1] = 0;
2437 3 : len = 1;
2438 12 : for (i = pci->retc; i < pci->argc; i++) {
2439 9 : tpe = getBatType(getArgType(mb, pci, i));
2440 9 : bi = bat_iterator(bl[i]);
2441 9 : p = BUNtail(bi, idx);
2442 9 : val = ATOMformat(tpe, p);
2443 9 : bat_iterator_end(&bi);
2444 9 : if (val == NULL)
2445 0 : goto memfail;
2446 9 : if (strcmp(val, "nil") == 0) {
2447 1 : GDKfree(val);
2448 1 : val = NULL;
2449 1 : l = 4;
2450 : } else {
2451 8 : l = strlen(val);
2452 : }
2453 9 : while (len + l > lim)
2454 0 : lim += BUFSIZ;
2455 9 : row2 = GDKrealloc(row, lim);
2456 9 : if (row2 == NULL)
2457 0 : goto memfail;
2458 9 : row = row2;
2459 9 : snprintf(row + len, lim - len, "%s,", val ? val : "null");
2460 9 : len += l + 1;
2461 9 : GDKfree(val);
2462 9 : val = NULL;
2463 : }
2464 3 : if (row[1])
2465 3 : row[len - 1] = ']';
2466 : else {
2467 0 : row[1] = '}';
2468 0 : row[2] = 0;
2469 : }
2470 : return row;
2471 :
2472 0 : memfail:
2473 0 : GDKfree(row);
2474 0 : GDKfree(val);
2475 0 : return NULL;
2476 : }
2477 :
2478 : static str
2479 1 : JSONrenderarray(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2480 : {
2481 1 : BAT **bl;
2482 1 : char *result, *row;
2483 1 : size_t len, lim, l;
2484 1 : str *ret;
2485 1 : BUN j, cnt;
2486 :
2487 1 : (void) cntxt;
2488 1 : bl = JSONargumentlist(mb, stk, pci);
2489 1 : if (bl == 0)
2490 0 : throw(MAL, "json.renderrray", "Non-aligned BAT sizes");
2491 :
2492 1 : cnt = BATcount(bl[pci->retc + 1]);
2493 1 : result = GDKmalloc(lim = BUFSIZ);
2494 1 : if (result == NULL) {
2495 0 : goto memfail;
2496 : }
2497 1 : result[0] = '[';
2498 1 : result[1] = 0;
2499 1 : len = 1;
2500 :
2501 4 : for (j = 0; j < cnt; j++) {
2502 3 : char *result2;
2503 3 : row = JSONrenderRowArray(bl, mb, pci, j);
2504 3 : if (row == NULL) {
2505 0 : goto memfail;
2506 : }
2507 3 : l = strlen(row);
2508 6 : while (l + 2 > lim - len)
2509 0 : lim = cnt * l <= lim ? cnt * l : lim + BUFSIZ;
2510 3 : result2 = GDKrealloc(result, lim);
2511 3 : if (result2 == NULL) {
2512 0 : GDKfree(row);
2513 0 : goto memfail;
2514 : }
2515 3 : result = result2;
2516 3 : strcpy(result + len, row);
2517 3 : GDKfree(row);
2518 3 : len += l;
2519 3 : result[len++] = ',';
2520 3 : result[len] = 0;
2521 : }
2522 1 : result[len - 1] = ']';
2523 1 : ret = getArgReference_TYPE(stk, pci, 0, json);
2524 1 : *ret = result;
2525 1 : JSONfreeArgumentlist(bl, pci);
2526 1 : return MAL_SUCCEED;
2527 :
2528 0 : memfail:
2529 0 : GDKfree(result);
2530 0 : JSONfreeArgumentlist(bl, pci);
2531 0 : throw(MAL, "json.renderArray", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2532 : }
2533 :
2534 : static str
2535 7 : JSONfoldKeyValue(str *ret, const bat *id, const bat *key, const bat *values)
2536 : {
2537 7 : BAT *bo = 0, *bk = 0, *bv;
2538 7 : BATiter bki, bvi;
2539 7 : int tpe;
2540 7 : char *row, *val = 0, *nme = 0;
2541 7 : BUN i, cnt;
2542 7 : size_t len, lim, l;
2543 7 : void *p;
2544 7 : oid o = 0;
2545 :
2546 7 : if (key) {
2547 6 : bk = BATdescriptor(*key);
2548 6 : if (bk == NULL) {
2549 0 : throw(MAL, "json.fold", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2550 : }
2551 : }
2552 :
2553 7 : bv = BATdescriptor(*values);
2554 7 : if (bv == NULL) {
2555 0 : BBPreclaim(bk);
2556 0 : throw(MAL, "json.fold", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2557 : }
2558 7 : tpe = bv->ttype;
2559 7 : cnt = BATcount(bv);
2560 7 : if (id) {
2561 3 : bo = BATdescriptor(*id);
2562 3 : if (bo == NULL) {
2563 0 : BBPreclaim(bk);
2564 0 : BBPunfix(bv->batCacheid);
2565 0 : throw(MAL, "json.nest", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2566 : }
2567 : }
2568 :
2569 7 : row = GDKmalloc(lim = BUFSIZ);
2570 7 : if (row == NULL) {
2571 0 : goto memfail;
2572 : }
2573 7 : row[0] = '[';
2574 7 : row[1] = 0;
2575 7 : len = 1;
2576 7 : if (id) {
2577 3 : o = BUNtoid(bo, 0);
2578 : }
2579 :
2580 7 : bki = bat_iterator(bk);
2581 7 : bvi = bat_iterator(bv);
2582 46 : for (i = 0; i < cnt; i++) {
2583 32 : if (id && bk) {
2584 15 : if (BUNtoid(bo, i) != o) {
2585 9 : snprintf(row + len, lim - len, ", ");
2586 9 : len += 2;
2587 9 : o = BUNtoid(bo, i);
2588 : }
2589 : }
2590 :
2591 32 : if (bk) {
2592 29 : nme = (str) BUNtvar(bki, i);
2593 29 : l = strlen(nme);
2594 29 : while (l + 3 > lim - len)
2595 0 : lim = (lim / (i + 1)) * cnt + BUFSIZ + l + 3;
2596 29 : p = GDKrealloc(row, lim);
2597 29 : if (p == NULL) {
2598 0 : bat_iterator_end(&bki);
2599 0 : bat_iterator_end(&bvi);
2600 0 : goto memfail;
2601 : }
2602 29 : row = p;
2603 58 : if (!strNil(nme)) {
2604 14 : snprintf(row + len, lim - len, "\"%s\":", nme);
2605 14 : len += l + 3;
2606 : }
2607 : }
2608 :
2609 32 : p = BUNtail(bvi, i);
2610 32 : if (tpe == TYPE_json)
2611 : val = p;
2612 : else {
2613 9 : if ((val = ATOMformat(tpe, p)) == NULL) {
2614 0 : bat_iterator_end(&bki);
2615 0 : bat_iterator_end(&bvi);
2616 0 : goto memfail;
2617 : }
2618 9 : if (strcmp(val, "nil") == 0) {
2619 0 : GDKfree(val);
2620 0 : val = NULL;
2621 : }
2622 : }
2623 32 : l = val ? strlen(val) : 4;
2624 32 : while (l > lim - len)
2625 0 : lim = (lim / (i + 1)) * cnt + BUFSIZ + l + 3;
2626 32 : p = GDKrealloc(row, lim);
2627 32 : if (p == NULL) {
2628 0 : if (tpe != TYPE_json)
2629 0 : GDKfree(val);
2630 0 : bat_iterator_end(&bki);
2631 0 : bat_iterator_end(&bvi);
2632 0 : goto memfail;
2633 : }
2634 32 : row = p;
2635 32 : strncpy(row + len, val ? val : "null", l);
2636 32 : len += l;
2637 32 : row[len++] = ',';
2638 32 : row[len] = 0;
2639 32 : if (tpe != TYPE_json)
2640 9 : GDKfree(val);
2641 : }
2642 7 : bat_iterator_end(&bki);
2643 7 : bat_iterator_end(&bvi);
2644 7 : if (row[1]) {
2645 7 : row[len - 1] = ']';
2646 7 : row[len] = 0;
2647 : } else {
2648 0 : row[1] = ']';
2649 0 : row[2] = 0;
2650 : }
2651 7 : BBPreclaim(bo);
2652 7 : BBPreclaim(bk);
2653 7 : BBPunfix(bv->batCacheid);
2654 7 : *ret = row;
2655 7 : return MAL_SUCCEED;
2656 :
2657 0 : memfail:
2658 0 : GDKfree(row);
2659 0 : BBPreclaim(bo);
2660 0 : BBPreclaim(bk);
2661 0 : BBPunfix(bv->batCacheid);
2662 0 : throw(MAL, "json.fold", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2663 : }
2664 :
2665 : static str
2666 8 : JSONunfold(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2667 : {
2668 8 : bat *id = 0, *key = 0, *val = 0;
2669 8 : json *js;
2670 :
2671 8 : (void) cntxt;
2672 8 : (void) mb;
2673 :
2674 8 : switch (pci->retc) {
2675 4 : case 2:
2676 4 : key = getArgReference_bat(stk, pci, 0);
2677 4 : val = getArgReference_bat(stk, pci, 1);
2678 4 : break;
2679 4 : case 3:
2680 4 : id = getArgReference_bat(stk, pci, 0);
2681 4 : key = getArgReference_bat(stk, pci, 1);
2682 4 : val = getArgReference_bat(stk, pci, 2);
2683 4 : break;
2684 : default:
2685 0 : assert(0);
2686 : throw(MAL, "json.unfold", ILLEGAL_ARGUMENT);
2687 : }
2688 8 : js = getArgReference_TYPE(stk, pci, pci->retc, json);
2689 8 : return JSONunfoldInternal(id, key, val, js);
2690 : }
2691 :
2692 : static str
2693 7 : JSONfold(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2694 : {
2695 7 : bat *id = 0, *key = 0, *val = 0;
2696 7 : str *ret;
2697 :
2698 7 : (void) cntxt;
2699 7 : (void) mb;
2700 :
2701 7 : assert(pci->retc == 1);
2702 7 : switch (pci->argc - pci->retc) {
2703 1 : case 1:
2704 1 : val = getArgReference_bat(stk, pci, 1);
2705 1 : break;
2706 3 : case 2:
2707 3 : key = getArgReference_bat(stk, pci, 1);
2708 3 : val = getArgReference_bat(stk, pci, 2);
2709 3 : break;
2710 3 : case 3:
2711 3 : id = getArgReference_bat(stk, pci, 1);
2712 3 : key = getArgReference_bat(stk, pci, 2);
2713 3 : val = getArgReference_bat(stk, pci, 3);
2714 3 : break;
2715 : default:
2716 0 : assert(0);
2717 : throw(MAL, "json.fold", ILLEGAL_ARGUMENT);
2718 : }
2719 7 : ret = getArgReference_TYPE(stk, pci, 0, json);
2720 7 : return JSONfoldKeyValue(ret, id, key, val);
2721 : }
2722 :
2723 : #define JSON_STR_CPY \
2724 : do { \
2725 : for (; *v; v++) { \
2726 : switch (*v) { \
2727 : case '"': \
2728 : case '\\': \
2729 : *dst++ = '\\'; \
2730 : /* fall through */ \
2731 : default: \
2732 : *dst++ = *v; \
2733 : break; \
2734 : case '\n': \
2735 : *dst++ = '\\'; \
2736 : *dst++ = 'n'; \
2737 : break; \
2738 : } \
2739 : } \
2740 : } while (0)
2741 :
2742 : #define JSON_AGGR_CHECK_NEXT_LENGTH(CALC) \
2743 : do { \
2744 : len = CALC; \
2745 : if (len >= maxlen - buflen) { \
2746 : maxlen = maxlen + len + BUFSIZ; \
2747 : buf2 = GDKrealloc(buf, maxlen); \
2748 : if (buf2 == NULL) { \
2749 : err = SQLSTATE(HY013) MAL_MALLOC_FAIL; \
2750 : goto bunins_failed; \
2751 : } \
2752 : buf = buf2; \
2753 : } \
2754 : } while (0)
2755 :
2756 : static str
2757 17 : JSONgroupStr(str *ret, const bat *bid)
2758 : {
2759 17 : BAT *b;
2760 17 : BUN p, q;
2761 17 : size_t len, maxlen = BUFSIZ, buflen = 0;
2762 17 : char *buf = GDKmalloc(maxlen), *buf2;
2763 17 : BATiter bi;
2764 17 : const char *err = NULL;
2765 17 : dbl *restrict vals;
2766 :
2767 17 : if (buf == NULL)
2768 0 : throw(MAL, "json.group", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2769 17 : if ((b = BATdescriptor(*bid)) == NULL) {
2770 0 : GDKfree(buf);
2771 0 : throw(MAL, "json.group", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2772 : }
2773 17 : assert(maxlen > 256); /* make sure every floating point fits on the dense case */
2774 17 : assert(b->ttype == TYPE_str || b->ttype == TYPE_dbl);
2775 :
2776 17 : bi = bat_iterator(b);
2777 17 : vals = (dbl *) Tloc(b, 0);
2778 17 : switch (b->ttype) {
2779 8 : case TYPE_str:
2780 23 : for (p = 0, q = BATcount(b); p < q; p++) {
2781 15 : const char *v = (const char *) BUNtvar(bi, p);
2782 :
2783 15 : if (strNil(v))
2784 3 : continue;
2785 : /* '[' or ',' plus space and null terminator and " ]" final string */
2786 12 : JSON_AGGR_CHECK_NEXT_LENGTH(strlen(v) * 2 + 7);
2787 12 : char *dst = buf + buflen, *odst = dst;
2788 12 : if (buflen == 0)
2789 6 : *dst++ = '[';
2790 : else
2791 6 : *dst++ = ',';
2792 12 : *dst++ = ' ';
2793 12 : *dst++ = '"';
2794 64 : JSON_STR_CPY;
2795 12 : *dst++ = '"';
2796 12 : buflen += (dst - odst);
2797 : }
2798 : break;
2799 9 : case TYPE_dbl:
2800 27 : for (p = 0, q = BATcount(b); p < q; p++) {
2801 18 : dbl val = vals[p];
2802 :
2803 18 : if (is_dbl_nil(val))
2804 7 : continue;
2805 : /* '[' or ',' plus space and null terminator and " ]" final string */
2806 11 : JSON_AGGR_CHECK_NEXT_LENGTH(130 + 6);
2807 11 : char *dst = buf + buflen;
2808 11 : if (buflen == 0)
2809 6 : *dst++ = '[';
2810 : else
2811 5 : *dst++ = ',';
2812 11 : *dst++ = ' ';
2813 11 : buflen += 2;
2814 11 : buflen += snprintf(buf + buflen, maxlen - buflen, "%f", val);
2815 : }
2816 : break;
2817 : default:
2818 0 : assert(0);
2819 : }
2820 17 : bat_iterator_end(&bi);
2821 17 : BBPunfix(b->batCacheid);
2822 17 : if (buflen > 0)
2823 12 : strcpy(buf + buflen, " ]");
2824 : else
2825 5 : strcpy(buf, str_nil);
2826 17 : *ret = GDKstrdup(buf);
2827 17 : GDKfree(buf);
2828 17 : if (!*ret) /* Don't return a too large string */
2829 0 : throw(MAL, "json.group", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2830 : return MAL_SUCCEED;
2831 0 : bunins_failed:
2832 0 : bat_iterator_end(&bi);
2833 0 : BBPunfix(b->batCacheid);
2834 0 : GDKfree(buf);
2835 0 : throw(MAL, "json.group", "%s", err);
2836 : }
2837 :
2838 : static const char *
2839 9 : JSONjsonaggr(BAT **bnp, BAT *b, BAT *g, BAT *e, BAT *s, int skip_nils)
2840 : {
2841 9 : BAT *bn = NULL, *t1, *t2 = NULL;
2842 9 : BATiter bi;
2843 9 : oid min, max, mapoff = 0, prev;
2844 9 : BUN ngrp, nils = 0, p, q;
2845 9 : struct canditer ci;
2846 9 : const char *err = NULL;
2847 9 : const oid *grps, *map;
2848 9 : int freeb = 0, freeg = 0, isnil = 0;
2849 9 : char *buf = NULL, *buf2;
2850 9 : size_t buflen, maxlen = BUFSIZ, len;
2851 9 : dbl *restrict vals;
2852 :
2853 9 : assert(maxlen > 256); /* make sure every floating point fits on the dense case */
2854 9 : assert(b->ttype == TYPE_str || b->ttype == TYPE_dbl);
2855 9 : if ((err = BATgroupaggrinit(b, g, e, s, &min, &max, &ngrp, &ci)) != NULL) {
2856 : return err;
2857 : }
2858 9 : if (BATcount(b) == 0 || ngrp == 0) {
2859 0 : bn = BATconstant(ngrp == 0 ? 0 : min, TYPE_str, ATOMnilptr(TYPE_str),
2860 : ngrp, TRANSIENT);
2861 0 : if (bn == NULL)
2862 : return SQLSTATE(HY013) MAL_MALLOC_FAIL;
2863 0 : *bnp = bn;
2864 0 : return NULL;
2865 : }
2866 9 : if (s) {
2867 0 : b = BATproject(s, b);
2868 0 : if (b == NULL) {
2869 0 : err = GDK_EXCEPTION;
2870 0 : goto out;
2871 : }
2872 0 : freeb = 1;
2873 0 : if (g) {
2874 0 : g = BATproject(s, g);
2875 0 : if (g == NULL) {
2876 0 : err = GDK_EXCEPTION;
2877 0 : goto out;
2878 : }
2879 : freeg = 1;
2880 : }
2881 : }
2882 :
2883 9 : if ((buf = GDKmalloc(maxlen)) == NULL) {
2884 0 : err = SQLSTATE(HY013) MAL_MALLOC_FAIL;
2885 0 : goto out;
2886 : }
2887 9 : buflen = 0;
2888 9 : bn = COLnew(min, TYPE_str, ngrp, TRANSIENT);
2889 9 : if (bn == NULL) {
2890 0 : err = SQLSTATE(HY013) MAL_MALLOC_FAIL;
2891 0 : goto out;
2892 : }
2893 9 : bi = bat_iterator(b);
2894 9 : vals = (dbl *) Tloc(b, 0);
2895 9 : if (g) {
2896 : /* stable sort g */
2897 9 : if (BATsort(&t1, &t2, NULL, g, NULL, NULL, false, false, true) != GDK_SUCCEED) {
2898 0 : err = GDK_EXCEPTION;
2899 0 : bat_iterator_end(&bi);
2900 0 : goto out;
2901 : }
2902 9 : if (freeg)
2903 0 : BBPunfix(g->batCacheid);
2904 9 : g = t1;
2905 9 : freeg = 1;
2906 9 : if (t2->ttype == TYPE_void) {
2907 : map = NULL;
2908 : } else {
2909 1 : map = (const oid *) Tloc(t2, 0);
2910 1 : mapoff = t2->tseqbase;
2911 : }
2912 9 : if (g && BATtdense(g)) {
2913 1 : switch (b->ttype) {
2914 0 : case TYPE_str:
2915 0 : for (p = 0, q = BATcount(g); p < q; p++) {
2916 0 : const char *v = (const char *) BUNtvar(bi,
2917 : (map ? (BUN) map[p] -
2918 : mapoff : p));
2919 0 : if (strNil(v)) {
2920 0 : if (skip_nils) {
2921 : /*
2922 : * if q is 1 and the value is
2923 : * null, then we need to fill
2924 : * in a value. Otherwise
2925 : * BATproject will fail.
2926 : */
2927 0 : if (p == 0 && q == 1)
2928 0 : strcpy(buf, "[ null ]");
2929 : else
2930 0 : continue;
2931 : } else {
2932 0 : strcpy(buf, str_nil);
2933 0 : nils = 1;
2934 : }
2935 : } else {
2936 0 : JSON_AGGR_CHECK_NEXT_LENGTH(strlen(v) * 2 + 7);
2937 0 : char *dst = buf;
2938 0 : *dst++ = '[';
2939 0 : *dst++ = ' ';
2940 0 : *dst++ = '"';
2941 0 : JSON_STR_CPY;
2942 0 : *dst++ = '"';
2943 0 : *dst++ = ' ';
2944 0 : *dst++ = ']';
2945 0 : *dst = '\0';
2946 : }
2947 0 : if (bunfastapp_nocheckVAR(bn, buf) != GDK_SUCCEED)
2948 0 : goto bunins_failed;
2949 : }
2950 : break;
2951 1 : case TYPE_dbl:
2952 3 : for (p = 0, q = BATcount(g); p < q; p++) {
2953 2 : dbl val = vals[(map ? (BUN) map[p] - mapoff : p)];
2954 2 : if (is_dbl_nil(val)) {
2955 0 : if (skip_nils) {
2956 0 : if (p == 0 && q == 1)
2957 0 : strcpy(buf, "[ null ]");
2958 : else
2959 0 : continue;
2960 : } else {
2961 0 : strcpy(buf, str_nil);
2962 0 : nils = 1;
2963 : }
2964 : } else {
2965 2 : char *dst = buf;
2966 2 : *dst++ = '[';
2967 2 : *dst++ = ' ';
2968 2 : dst += sprintf(dst, "%f", val);
2969 2 : *dst++ = ' ';
2970 2 : *dst++ = ']';
2971 2 : *dst = '\0';
2972 : }
2973 2 : if (bunfastapp_nocheckVAR(bn, buf) != GDK_SUCCEED)
2974 0 : goto bunins_failed;
2975 : }
2976 : break;
2977 : default:
2978 0 : assert(0);
2979 : }
2980 : } else {
2981 8 : grps = (const oid *) Tloc(g, 0);
2982 8 : prev = grps[0];
2983 2127 : for (p = 0, q = BATcount(g); p <= q; p++) {
2984 2127 : if (p == q || grps[p] != prev) {
2985 15 : if (isnil) {
2986 0 : strcpy(buf, str_nil);
2987 0 : nils = 1;
2988 15 : } else if (buflen == 0) {
2989 1 : strcpy(buf, "[ ]");
2990 : } else {
2991 14 : strcpy(buf + buflen, " ]");
2992 : }
2993 15 : while (BATcount(bn) < prev - min) {
2994 0 : if (bunfastapp_nocheckVAR(bn, str_nil) != GDK_SUCCEED)
2995 0 : goto bunins_failed;
2996 : nils = 1;
2997 : }
2998 15 : if (bunfastapp_nocheckVAR(bn, buf) != GDK_SUCCEED)
2999 0 : goto bunins_failed;
3000 15 : if (p == q)
3001 : break;
3002 7 : buflen = 0;
3003 7 : isnil = 0;
3004 7 : prev = grps[p];
3005 : }
3006 2119 : if (isnil)
3007 0 : continue;
3008 2119 : switch (b->ttype) {
3009 2108 : case TYPE_str:{
3010 2108 : const char *v = (const char *) BUNtvar(bi, p);
3011 2108 : if (strNil(v)) {
3012 1 : if (skip_nils)
3013 1 : continue;
3014 : isnil = 1;
3015 : } else {
3016 : /* '[' or ',' plus space and null terminator and " ]" final string */
3017 2107 : JSON_AGGR_CHECK_NEXT_LENGTH(strlen(v) * 2 + 7);
3018 2107 : char *dst = buf + buflen, *odst = dst;
3019 2107 : if (buflen == 0)
3020 9 : *dst++ = '[';
3021 : else
3022 2098 : *dst++ = ',';
3023 2107 : *dst++ = ' ';
3024 2107 : *dst++ = '"';
3025 4243 : JSON_STR_CPY;
3026 2107 : *dst++ = '"';
3027 2107 : buflen += (dst - odst);
3028 : }
3029 : break;
3030 : }
3031 11 : case TYPE_dbl:{
3032 11 : dbl val = vals[p];
3033 11 : if (is_dbl_nil(val)) {
3034 4 : if (skip_nils)
3035 4 : continue;
3036 : isnil = 1;
3037 : } else {
3038 : /* '[' or ',' plus space and null terminator and " ]" final string */
3039 7 : JSON_AGGR_CHECK_NEXT_LENGTH(130 + 6);
3040 7 : char *dst = buf + buflen;
3041 7 : if (buflen == 0)
3042 5 : *dst++ = '[';
3043 : else
3044 2 : *dst++ = ',';
3045 7 : *dst++ = ' ';
3046 7 : buflen += 2;
3047 7 : buflen += snprintf(buf + buflen, maxlen - buflen, "%f",
3048 : val);
3049 : }
3050 : break;
3051 : }
3052 : default:
3053 0 : assert(0);
3054 : }
3055 : }
3056 8 : BBPunfix(t2->batCacheid);
3057 8 : t2 = NULL;
3058 : }
3059 : } else {
3060 0 : switch (b->ttype) {
3061 0 : case TYPE_str:
3062 0 : for (p = 0, q = p + BATcount(b); p < q; p++) {
3063 0 : const char *v = (const char *) BUNtvar(bi, p);
3064 0 : if (strNil(v)) {
3065 0 : if (skip_nils)
3066 0 : continue;
3067 : nils = 1;
3068 : break;
3069 : }
3070 : /* '[' or ',' plus space and null terminator and " ]" final string */
3071 0 : JSON_AGGR_CHECK_NEXT_LENGTH(strlen(v) * 2 + 7);
3072 0 : char *dst = buf + buflen, *odst = dst;
3073 0 : if (buflen == 0)
3074 0 : *dst++ = '[';
3075 : else
3076 0 : *dst++ = ',';
3077 0 : *dst++ = ' ';
3078 0 : *dst++ = '"';
3079 0 : JSON_STR_CPY;
3080 0 : *dst++ = '"';
3081 0 : buflen += (dst - odst);
3082 : }
3083 : break;
3084 0 : case TYPE_dbl:
3085 0 : for (p = 0, q = p + BATcount(b); p < q; p++) {
3086 0 : dbl val = vals[p];
3087 0 : if (is_dbl_nil(val)) {
3088 0 : if (skip_nils)
3089 0 : continue;
3090 : nils = 1;
3091 : break;
3092 : }
3093 : /* '[' or ',' plus space and null terminator and " ]" final string */
3094 0 : JSON_AGGR_CHECK_NEXT_LENGTH(130 + 6);
3095 0 : char *dst = buf + buflen;
3096 0 : if (buflen == 0)
3097 0 : *dst++ = '[';
3098 : else
3099 0 : *dst++ = ',';
3100 0 : *dst++ = ' ';
3101 0 : buflen += 2;
3102 0 : buflen += snprintf(buf + buflen, maxlen - buflen, "%f", val);
3103 : }
3104 : break;
3105 : default:
3106 0 : assert(0);
3107 : }
3108 0 : if (nils) {
3109 0 : strcpy(buf, str_nil);
3110 0 : } else if (buflen == 0) {
3111 0 : strcpy(buf, "[ ]");
3112 : } else {
3113 0 : strcpy(buf + buflen, " ]");
3114 : }
3115 0 : if (bunfastapp_nocheckVAR(bn, buf) != GDK_SUCCEED)
3116 0 : goto bunins_failed;
3117 : }
3118 9 : bat_iterator_end(&bi);
3119 9 : bn->tnil = nils != 0;
3120 9 : bn->tnonil = nils == 0;
3121 9 : bn->tsorted = BATcount(bn) <= 1;
3122 9 : bn->trevsorted = BATcount(bn) <= 1;
3123 9 : bn->tkey = BATcount(bn) <= 1;
3124 :
3125 9 : out:
3126 9 : if (bn)
3127 9 : bn->theap->dirty |= BATcount(bn) > 0;
3128 9 : BBPreclaim(t2);
3129 9 : if (freeb)
3130 0 : BBPunfix(b->batCacheid);
3131 9 : if (freeg)
3132 9 : BBPunfix(g->batCacheid);
3133 9 : GDKfree(buf);
3134 9 : if (err && bn) {
3135 0 : BBPreclaim(bn);
3136 0 : bn = NULL;
3137 : }
3138 9 : *bnp = bn;
3139 9 : return err;
3140 :
3141 0 : bunins_failed:
3142 0 : bat_iterator_end(&bi);
3143 0 : if (err == NULL)
3144 0 : err = SQLSTATE(HY013) MAL_MALLOC_FAIL; /* insertion into result BAT failed */
3145 0 : goto out;
3146 : }
3147 :
3148 : static str
3149 9 : JSONsubjsoncand(bat *retval, bat *bid, bat *gid, bat *eid, bat *sid,
3150 : bit *skip_nils)
3151 : {
3152 9 : BAT *b, *g, *e, *s, *bn = NULL;
3153 9 : const char *err;
3154 :
3155 9 : b = BATdescriptor(*bid);
3156 9 : g = gid ? BATdescriptor(*gid) : NULL;
3157 9 : e = eid ? BATdescriptor(*eid) : NULL;
3158 9 : s = sid ? BATdescriptor(*sid) : NULL;
3159 9 : if (b == NULL || (gid != NULL && g == NULL) || (eid != NULL && e == NULL)
3160 9 : || (sid != NULL && s == NULL)) {
3161 : err = SQLSTATE(HY002) RUNTIME_OBJECT_MISSING;
3162 : } else {
3163 9 : err = JSONjsonaggr(&bn, b, g, e, s, *skip_nils);
3164 : }
3165 9 : BBPreclaim(b);
3166 9 : BBPreclaim(g);
3167 9 : BBPreclaim(e);
3168 9 : BBPreclaim(s);
3169 9 : if (err != NULL)
3170 0 : throw(MAL, "aggr.subjson", "%s", err);
3171 :
3172 9 : *retval = bn->batCacheid;
3173 9 : BBPkeepref(bn);
3174 9 : return MAL_SUCCEED;
3175 : }
3176 :
3177 : static str
3178 9 : JSONsubjson(bat *retval, bat *bid, bat *gid, bat *eid, bit *skip_nils)
3179 : {
3180 9 : return JSONsubjsoncand(retval, bid, gid, eid, NULL, skip_nils);
3181 : }
3182 :
3183 :
3184 : #include "mel.h"
3185 : static mel_atom json_init_atoms[] = {
3186 : { .name="json", .basetype="str", .fromstr=JSONfromString, .tostr=JSONtoString }, { .cmp=NULL },
3187 : };
3188 : static mel_func json_init_funcs[] = {
3189 : command("json", "new", JSONstr2json, false, "Convert string to its JSON. Dealing with escape characters", args(1,2, arg("",json),arg("j",str))),
3190 : command("calc", "json", JSON2json, false, "Convert JSON to JSON", args(1,2, arg("",json),arg("s",json))),
3191 : command("calc", "json", JSONstr2json, false, "Convert string to its JSON. Dealing with escape characters", args(1,2, arg("",json),arg("j",str))),
3192 : command("json", "str", JSONjson2str, false, "Convert JSON to its string equivalent. Dealing with escape characters", args(1,2, arg("",str),arg("j",json))),
3193 : command("json", "text", JSONjson2text, false, "Convert JSON values to their plain string equivalent.", args(1,2, arg("",str),arg("j",json))),
3194 : command("json", "text", JSONjson2textSeparator, false, "Convert JSON values to their plain string equivalent, injecting a separator.", args(1,3, arg("",str),arg("j",json),arg("s",str))),
3195 : command("json", "number", JSONjson2number, false, "Convert simple JSON values to a double, return nil upon error.", args(1,2, arg("",dbl),arg("j",json))),
3196 : command("json", "integer", JSONjson2integer, false, "Convert simple JSON values to an integer, return nil upon error.", args(1,2, arg("",lng),arg("j",json))),
3197 : pattern("json", "dump", JSONdump, false, "", args(1,2, batarg("",str),arg("j",json))),
3198 : command("json", "filter", JSONfilter, false, "Filter all members of an object by a path expression, returning an array.\nNon-matching elements are skipped.", args(1,3, arg("",json),arg("name",json),arg("pathexpr",str))),
3199 : command("json", "filter", JSONfilterArray_bte, false, "", args(1,3, arg("",json),arg("name",json),arg("idx",bte))),
3200 : command("json", "filter", JSONfilterArrayDefault_bte, false, "", args(1,4, arg("",json),arg("name",json),arg("idx",bte),arg("other",str))),
3201 : command("json", "filter", JSONfilterArray_sht, false, "", args(1,3, arg("",json),arg("name",json),arg("idx",sht))),
3202 : command("json", "filter", JSONfilterArrayDefault_sht, false, "", args(1,4, arg("",json),arg("name",json),arg("idx",sht),arg("other",str))),
3203 : command("json", "filter", JSONfilterArray_int, false, "", args(1,3, arg("",json),arg("name",json),arg("idx",int))),
3204 : command("json", "filter", JSONfilterArrayDefault_int, false, "", args(1,4, arg("",json),arg("name",json),arg("idx",int),arg("other",str))),
3205 : command("json", "filter", JSONfilterArray_lng, false, "", args(1,3, arg("",json),arg("name",json),arg("idx",lng))),
3206 : command("json", "filter", JSONfilterArrayDefault_lng, false, "Extract a single array element", args(1,4, arg("",json),arg("name",json),arg("idx",lng),arg("other",str))),
3207 : #ifdef HAVE_HGE
3208 : command("json", "filter", JSONfilterArray_hge, false, "", args(1,3, arg("",json),arg("name",json),arg("idx",hge))),
3209 : command("json", "filter", JSONfilterArrayDefault_hge, false, "Extract a single array element", args(1,4, arg("",json),arg("name",json),arg("idx",hge),arg("other",str))),
3210 : #endif
3211 : command("json", "isobject", JSONisobject, false, "Validate the string as a valid JSON object", args(1,2, arg("",bit),arg("val",json))),
3212 : command("json", "isarray", JSONisarray, false, "Validate the string as a valid JSON array", args(1,2, arg("",bit),arg("val",json))),
3213 : command("json", "isvalid", JSONisvalid, false, "Validate the string as a valid JSON document", args(1,2, arg("",bit),arg("val",str))),
3214 : command("json", "length", JSONlength, false, "Returns the number of elements in the outermost JSON object.", args(1,2, arg("",int),arg("val",json))),
3215 : pattern("json", "unfold", JSONunfold, false, "Expands the outermost JSON object into key-value pairs.", args(2,3, batarg("k",str),batarg("v",json),arg("val",json))),
3216 : pattern("json", "unfold", JSONunfold, false, "Expands the outermost JSON object into key-value pairs.", args(3,4, batarg("o",oid),batarg("k",str),batarg("v",json),arg("val",json))),
3217 : pattern("json", "fold", JSONfold, false, "Combine the key-value pairs into a single json object list.", args(1,4, arg("",json),batarg("o",oid),batarg("k",str),batargany("v",0))),
3218 : pattern("json", "fold", JSONfold, false, "Combine the key-value pairs into a single json object list.", args(1,3, arg("",json),batarg("k",str),batargany("v",0))),
3219 : pattern("json", "fold", JSONfold, false, "Combine the value list into a single json array object.", args(1,2, arg("",json),batargany("v",0))),
3220 : command("json", "keyarray", JSONkeyArray, false, "Expands the outermost JSON object keys into a JSON value array.", args(1,2, arg("",json),arg("val",json))),
3221 : command("json", "valuearray", JSONvalueArray, false, "Expands the outermost JSON object values into a JSON value array.", args(1,2, arg("",json),arg("val",json))),
3222 : command("json", "keys", JSONkeyTable, false, "Expands the outermost JSON object names.", args(1,2, batarg("",str),arg("val",json))),
3223 : command("json", "values", JSONvalueTable, false, "Expands the outermost JSON values.", args(1,2, batarg("",json),arg("val",json))),
3224 : pattern("json", "renderobject", JSONrenderobject, false, "", args(1,2, arg("",json),varargany("val",0))),
3225 : pattern("json", "renderarray", JSONrenderarray, false, "", args(1,2, arg("",json),varargany("val",0))),
3226 : command("aggr", "jsonaggr", JSONgroupStr, false, "Aggregate the string values to array.", args(1,2, arg("",str),batarg("val",str))),
3227 : command("aggr", "jsonaggr", JSONgroupStr, false, "Aggregate the double values to array.", args(1,2, arg("",str),batarg("val",dbl))),
3228 : command("aggr", "subjsonaggr", JSONsubjson, false, "Grouped aggregation of values.", args(1,5, batarg("",str),batarg("val",str),batarg("g",oid),batargany("e",1),arg("skip_nils",bit))),
3229 : command("aggr", "subjsonaggr", JSONsubjson, false, "Grouped aggregation of values.", args(1,5, batarg("",str),batarg("val",dbl),batarg("g",oid),batargany("e",1),arg("skip_nils",bit))),
3230 : command("aggr", "subjsonaggr", JSONsubjsoncand, false, "Grouped aggregation of values with candidates list.", args(1,6, batarg("",str),batarg("val",str),batarg("g",oid),batargany("e",1),batarg("s",oid),arg("skip_nils",bit))),
3231 : command("aggr", "subjsonaggr", JSONsubjsoncand, false, "Grouped aggregation of values with candidates list.", args(1,6, batarg("",str),batarg("val",dbl),batarg("g",oid),batargany("e",1),batarg("s",oid),arg("skip_nils",bit))),
3232 : { .imp=NULL }
3233 : };
3234 : #include "mal_import.h"
3235 : #ifdef _MSC_VER
3236 : #undef read
3237 : #pragma section(".CRT$XCU",read)
3238 : #endif
3239 334 : LIB_STARTUP_FUNC(init_json_mal)
3240 334 : { mal_module2("json", json_init_atoms, json_init_funcs, JSONprelude, NULL); }
|
