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