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, 2025 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : /*
14 : * author N.J. Nes
15 : */
16 :
17 : #include "monetdb_config.h"
18 : #include "sql_result.h"
19 : #include "str.h"
20 : #include "tablet.h"
21 : #include "gdk_time.h"
22 : #include "bat/res_table.h"
23 : #include "bat/bat_storage.h"
24 : #include "rel_exp.h"
25 : #include "sql_bincopyconvert.h"
26 :
27 : #ifndef HAVE_LLABS
28 : #define llabs(x) ((x) < 0 ? -(x) : (x))
29 : #endif
30 :
31 : #ifdef _MSC_VER
32 : /* use intrinsic functions on Windows */
33 : #define short_int_SWAP(s) ((short) _byteswap_ushort((unsigned short) (s)))
34 : /* on Windows, long is the same size as int */
35 : #define normal_int_SWAP(s) ((int) _byteswap_ulong((unsigned long) (s)))
36 : #define long_long_SWAP(s) ((lng) _byteswap_uint64((unsigned __int64) (s)))
37 : #else
38 : #define short_int_SWAP(s) ((short)(((0x00ff&(s))<<8) | ((0xff00&(s))>>8)))
39 :
40 : #define normal_int_SWAP(i) (((0x000000ff&(i))<<24) | ((0x0000ff00&(i))<<8) | \
41 : ((0x00ff0000&(i))>>8) | ((0xff000000&(i))>>24))
42 : #define long_long_SWAP(l) \
43 : ((((lng)normal_int_SWAP(l))<<32) | \
44 : (0xffffffff&normal_int_SWAP(l>>32)))
45 : #endif
46 :
47 : #ifdef HAVE_HGE
48 : #define huge_int_SWAP(h) \
49 : ((((hge)long_long_SWAP(h))<<64) | \
50 : (0xffffffffffffffff&long_long_SWAP(h>>64)))
51 : #endif
52 : #define DEC_TOSTR(TYPE) \
53 : do { \
54 : char buf[64]; \
55 : TYPE v = *(const TYPE *) a; \
56 : int scale = (int) (ptrdiff_t) extra; \
57 : int cur = 63, i, done = 0; \
58 : int neg = v < 0; \
59 : ssize_t l; \
60 : if (is_##TYPE##_nil(v)) { \
61 : if (*Buf == NULL || *len < 5){ \
62 : GDKfree(*Buf); \
63 : *len = 5; \
64 : *Buf = GDKzalloc(*len); \
65 : if (*Buf == NULL) { \
66 : return -1; \
67 : } \
68 : } \
69 : strcpy(*Buf, "NULL"); \
70 : return 4; \
71 : } \
72 : if (v<0) \
73 : v = -v; \
74 : buf[cur--] = 0; \
75 : if (scale){ \
76 : for (i=0; i<scale; i++) { \
77 : buf[cur--] = (char) (v%10 + '0'); \
78 : v /= 10; \
79 : } \
80 : buf[cur--] = '.'; \
81 : } \
82 : while (v) { \
83 : buf[cur--] = (char ) (v%10 + '0'); \
84 : v /= 10; \
85 : done = 1; \
86 : } \
87 : if (!done) \
88 : buf[cur--] = '0'; \
89 : if (neg) \
90 : buf[cur--] = '-'; \
91 : l = (64-cur-1); \
92 : if (*Buf == NULL || (ssize_t) *len < l) { \
93 : GDKfree(*Buf); \
94 : *len = (size_t) l+1; \
95 : *Buf = GDKzalloc(*len); \
96 : if (*Buf == NULL) { \
97 : return -1; \
98 : } \
99 : } \
100 : strcpy(*Buf, buf+cur+1); \
101 : return l-1; \
102 : } while (0)
103 :
104 : static ssize_t
105 21533 : dec_tostr(void *extra, char **Buf, size_t *len, int type, const void *a)
106 : {
107 : /* support dec map to bte, sht, int and lng */
108 21533 : if (type == TYPE_bte) {
109 377 : DEC_TOSTR(bte);
110 : } else if (type == TYPE_sht) {
111 1348 : DEC_TOSTR(sht);
112 : } else if (type == TYPE_int) {
113 20548 : DEC_TOSTR(int);
114 : } else if (type == TYPE_lng) {
115 50772 : DEC_TOSTR(lng);
116 : #ifdef HAVE_HGE
117 : } else if (type == TYPE_hge) {
118 93782 : DEC_TOSTR(hge);
119 : #endif
120 : } else {
121 0 : GDKerror("Decimal cannot be mapped to %s\n", ATOMname(type));
122 : }
123 0 : return -1;
124 : }
125 :
126 : struct time_res {
127 : int fraction;
128 : int has_tz;
129 : lng timezone;
130 : };
131 :
132 : static ssize_t
133 2641 : sql_time_tostr(void *TS_RES, char **buf, size_t *len, int type, const void *A)
134 : {
135 2641 : struct time_res *ts_res = TS_RES;
136 2641 : ssize_t len1;
137 2641 : size_t big = 128;
138 2641 : char buf1[128], *s1 = buf1, *s;
139 2641 : daytime tmp;
140 :
141 2641 : (void) type;
142 2641 : tmp = *(const daytime *) A;
143 2641 : if (ts_res->has_tz)
144 212 : tmp = daytime_add_usec_modulo(tmp, ts_res->timezone * 1000);
145 :
146 2641 : len1 = daytime_precision_tostr(&s1, &big, tmp, ts_res->fraction, true);
147 2641 : if (len1 < 0)
148 : return -1;
149 2641 : if (len1 == 3 && strcmp(s1, "nil") == 0) {
150 0 : if (*len < 4 || *buf == NULL) {
151 0 : GDKfree(*buf);
152 0 : *buf = GDKzalloc(*len = 4);
153 0 : if (*buf == NULL)
154 : return -1;
155 : }
156 0 : strcpy(*buf, "nil");
157 0 : return len1;
158 : }
159 :
160 2641 : if (*buf == NULL || *len < (size_t) len1 + 8) {
161 0 : GDKfree(*buf);
162 0 : *buf = (str) GDKzalloc(*len = len1 + 8);
163 0 : if (*buf == NULL) {
164 : return -1;
165 : }
166 : }
167 2641 : s = *buf;
168 2641 : strcpy(s, buf1);
169 2641 : s += len1;
170 :
171 2641 : if (ts_res->has_tz) {
172 212 : lng timezone = llabs(ts_res->timezone / 60000);
173 212 : s += sprintf(s, "%c%02d:%02d",
174 : (ts_res->timezone >= 0) ? '+' : '-',
175 212 : (int) (timezone / 60), (int) (timezone % 60));
176 : }
177 2641 : return (ssize_t) (s - *buf);
178 : }
179 :
180 : static ssize_t
181 1744 : sql_timestamp_tostr(void *TS_RES, char **buf, size_t *len, int type, const void *A)
182 : {
183 1744 : struct time_res *ts_res = TS_RES;
184 1744 : ssize_t len1, len2;
185 1744 : size_t big = 128;
186 1744 : char buf1[128], buf2[128], *s, *s1 = buf1, *s2 = buf2;
187 1744 : timestamp tmp;
188 1744 : lng timezone = ts_res->timezone;
189 1744 : date days;
190 1744 : daytime usecs;
191 :
192 1744 : (void) type;
193 1744 : tmp = *(const timestamp *)A;
194 1744 : if (ts_res->has_tz) {
195 541 : tmp = timestamp_add_usec(tmp, timezone * 1000);
196 : }
197 1744 : days = timestamp_date(tmp);
198 1744 : usecs = timestamp_daytime(tmp);
199 1744 : len1 = date_tostr(&s1, &big, &days, true);
200 1744 : len2 = daytime_precision_tostr(&s2, &big, usecs, ts_res->fraction, true);
201 1744 : if (len1 < 0 || len2 < 0) {
202 0 : GDKfree(s1);
203 0 : GDKfree(s2);
204 0 : return -1;
205 : }
206 :
207 1744 : if ((len1 == 3 && strcmp(s1, "nil") == 0) ||
208 0 : (len2 == 3 && strcmp(s2, "nil") == 0)) {
209 0 : if (*len < 4 || *buf == NULL) {
210 0 : GDKfree(*buf);
211 0 : *buf = GDKzalloc(*len = 4);
212 0 : if (*buf == NULL)
213 : return -1;
214 : }
215 0 : strcpy(*buf, "nil");
216 0 : return len1;
217 : }
218 :
219 1744 : if (*buf == NULL || *len < (size_t) len1 + (size_t) len2 + 8) {
220 0 : GDKfree(*buf);
221 0 : *buf = (str) GDKzalloc(*len = (size_t) (len1 + len2 + 8));
222 0 : if (*buf == NULL) {
223 : return -1;
224 : }
225 : }
226 1744 : s = *buf;
227 1744 : strcpy(s, buf1);
228 1744 : s += len1;
229 1744 : *s++ = ' ';
230 1744 : strcpy(s, buf2);
231 1744 : s += len2;
232 1744 : s[0] = 0;
233 :
234 1744 : if (ts_res->has_tz) {
235 541 : timezone = ts_res->timezone / 60000;
236 541 : *s++ = (ts_res->timezone >= 0) ? '+' : '-';
237 541 : sprintf(s, "%02d:%02d", (int) (llabs(timezone) / 60), (int) (llabs(timezone) % 60));
238 541 : s += 5;
239 : }
240 1744 : return (ssize_t) (s - *buf);
241 : }
242 :
243 : static int
244 102368 : bat_max_strlength(BAT *b)
245 : {
246 102368 : BUN p, q;
247 102368 : int l = 0;
248 102368 : int max = 0;
249 102368 : BATiter bi = bat_iterator(b);
250 :
251 4767101 : BATloop(b, p, q) {
252 4664733 : l = UTF8_strwidth((const char *) BUNtvar(bi, p));
253 :
254 4664733 : if (is_int_nil(l))
255 508340 : l = 0;
256 4664733 : if (l > max)
257 : max = l;
258 : }
259 102368 : bat_iterator_end(&bi);
260 102368 : return max;
261 : }
262 :
263 : #define bat_max_length(TPE, HIGH) \
264 : static size_t \
265 : bat_max_##TPE##length(BAT *b) \
266 : { \
267 : BUN p, q; \
268 : HIGH max = 0, min = 0; \
269 : size_t ret = 0; \
270 : BATiter bi = bat_iterator(b); \
271 : const TPE *restrict vals = (const TPE *) bi.base; \
272 : \
273 : BATloop(b, p, q) { \
274 : HIGH m = 0; \
275 : TPE l = vals[p]; \
276 : \
277 : if (!is_##TPE##_nil(l)) \
278 : m = l; \
279 : if (m > max) \
280 : max = m; \
281 : if (m < min) \
282 : min = m; \
283 : } \
284 : bat_iterator_end(&bi); \
285 : if (-min > max / 10) { \
286 : max = -min; \
287 : ret++; /* '-' */ \
288 : } \
289 : while (max /= 10) \
290 : ret++; \
291 : ret++; \
292 : return ret; \
293 : }
294 :
295 1425971 : bat_max_length(bte, lng)
296 1202604 : bat_max_length(sht, lng)
297 5992871 : bat_max_length(int, lng)
298 849174 : bat_max_length(lng, lng)
299 : #ifdef HAVE_HGE
300 6121 : bat_max_length(hge, hge)
301 : #endif
302 :
303 : #define DEC_FRSTR(X) \
304 : do { \
305 : sql_subtype *t = c->extra; \
306 : unsigned int scale = t->scale; \
307 : unsigned int i; \
308 : bool neg = false; \
309 : X *r; \
310 : X res = 0; \
311 : while(isspace((unsigned char) *s)) \
312 : s++; \
313 : if (*s == '-'){ \
314 : neg = true; \
315 : s++; \
316 : } else if (*s == '+'){ \
317 : s++; \
318 : } \
319 : for (i = 0; *s && *s != c->decsep && ((res == 0 && *s == '0') || i < t->digits - t->scale); s++) { \
320 : if (c->decskip && *s == c->decskip) \
321 : continue; \
322 : if (!isdigit((unsigned char) *s)) \
323 : break; \
324 : res *= 10; \
325 : res += (*s-'0'); \
326 : if (res) \
327 : i++; \
328 : } \
329 : if (*s == c->decsep) { \
330 : s++; \
331 : while (*s && scale > 0) { \
332 : if (isdigit((unsigned char) *s)) { \
333 : res *= 10; \
334 : res += *s++ - '0'; \
335 : scale--; \
336 : } else if (c->decskip && *s == c->decskip) { \
337 : s++; \
338 : } else { \
339 : break; \
340 : } \
341 : } \
342 : } \
343 : while(*s && isspace((unsigned char) *s)) \
344 : s++; \
345 : while (scale > 0) { \
346 : res *= 10; \
347 : scale--; \
348 : } \
349 : if (*s) \
350 : return NULL; \
351 : r = c->data; \
352 : if (r == NULL && \
353 : (r = GDKzalloc(sizeof(X))) == NULL) \
354 : return NULL; \
355 : c->data = r; \
356 : if (neg) \
357 : *r = -res; \
358 : else \
359 : *r = res; \
360 : return (void *) r; \
361 : } while (0)
362 :
363 : static void *
364 64184858 : dec_frstr(Column *c, int type, const char *s)
365 : {
366 64184858 : assert(c->decsep != '\0');
367 :
368 : /* support dec map to bte, sht, int and lng */
369 64184858 : if( strcmp(s,"nil")== 0)
370 : return NULL;
371 64184858 : if (type == TYPE_bte) {
372 8369 : DEC_FRSTR(bte);
373 : } else if (type == TYPE_sht) {
374 21228 : DEC_FRSTR(sht);
375 : } else if (type == TYPE_int) {
376 477834771 : DEC_FRSTR(int);
377 : } else if (type == TYPE_lng) {
378 4292472 : DEC_FRSTR(lng);
379 : #ifdef HAVE_HGE
380 : } else if (type == TYPE_hge) {
381 0 : DEC_FRSTR(hge);
382 : #endif
383 : }
384 : return NULL;
385 : }
386 :
387 : static void *
388 183 : sec_frstr(Column *c, int type, const char *s)
389 : {
390 : /* read a sec_interval value
391 : * this knows that the stored scale is always 3 */
392 183 : unsigned int i, neg = 0;
393 183 : lng *r;
394 183 : lng res = 0;
395 :
396 183 : (void) c;
397 183 : (void) type;
398 183 : assert(type == TYPE_lng);
399 :
400 183 : if (*s == '-') {
401 10 : neg = 1;
402 10 : s++;
403 173 : } else if (*s == '+') {
404 0 : neg = 0;
405 0 : s++;
406 : }
407 1359 : for (i = 0; i < (19 - 3) && *s && *s != c->decsep; i++, s++) {
408 1176 : if (c->decskip && *s == c->decskip) {
409 4 : i--;
410 4 : continue;
411 : }
412 1172 : if (!isdigit((unsigned char) *s))
413 : return NULL;
414 1172 : res *= 10;
415 1172 : res += (*s - '0');
416 : }
417 183 : i = 0;
418 183 : if (*s) {
419 151 : if (*s != c->decsep)
420 : return NULL;
421 151 : s++;
422 604 : for (; *s && i < 3; i++, s++) {
423 453 : if (c->decskip && *s == c->decskip) {
424 2 : i--;
425 2 : continue;
426 : }
427 451 : if (!isdigit((unsigned char) *s))
428 : return NULL;
429 451 : res *= 10;
430 451 : res += (*s - '0');
431 : }
432 : }
433 183 : if (*s)
434 : return NULL;
435 281 : for (; i < 3; i++) {
436 98 : res *= 10;
437 : }
438 183 : r = c->data;
439 183 : if (r == NULL && (r = (lng *) GDKzalloc(sizeof(lng))) == NULL)
440 : return NULL;
441 183 : c->data = r;
442 183 : if (neg)
443 10 : *r = -res;
444 : else
445 173 : *r = res;
446 : return (void *) r;
447 : }
448 :
449 : static void *
450 1916238 : fltdbl_frStr(Column *c, int type, const char *s)
451 : {
452 : // The regular fltFromStr/dblFromStr functions do not take decimal commas
453 : // and thousands separators into account. When these are in use, this
454 : // function first converts them to decimal dots and empty strings,
455 : // respectively. We use a fixed size buffer so abnormally long floats such
456 : // as
457 : // +00000000000000000000000000000000000000000000000000000000000000000000001.5e1
458 : // will be rejected.
459 :
460 : // According to Stack Overflow https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value
461 : // 24 bytes is a reasonable buffer but we'll make it a bit larger.
462 1916238 : char tmp[120];
463 1916238 : if (c->decskip || c->decsep != '.') {
464 12 : char *p = &tmp[0];
465 :
466 12 : while (GDKisspace(*s))
467 8 : s++;
468 102 : while (*s != '\0') {
469 98 : if (p >= tmp + sizeof(tmp) - 1) {
470 : // If the input is this big it's probably an error.
471 : // Exception: only whitespace remains.
472 0 : while (GDKisspace(*s))
473 0 : s++;
474 0 : if (*s == '\0') {
475 : // there was only trailing whitespace
476 : break;
477 : } else {
478 : // not just trailing whitespace, abort!
479 : return NULL;
480 : }
481 : }
482 98 : char ch = *s++;
483 98 : if (ch == c->decskip) {
484 6 : continue;
485 92 : } else if (ch == c->decsep) {
486 : ch = '.';
487 88 : } else if (ch == '.') {
488 : // We're mapping c->decsep to '.', if there are already
489 : // periods in the input we're losing information
490 : return NULL;
491 : }
492 92 : *p++ = ch;
493 : }
494 : // If we're here either we either encountered the end of s or the buffer is
495 : // full. In the latter case we still need to write the NUL.
496 : // We left room for it.
497 4 : *p = '\0';
498 :
499 : // now process the converted text rather than the original
500 4 : s = &tmp[0];
501 : }
502 :
503 1916238 : ssize_t len = (*BATatoms[type].atomFromStr) (s, &c->len, &c->data, false);
504 1916255 : return (len > 0) ? c->data : NULL;
505 : }
506 :
507 : /* Literal parsing for SQL all pass through this routine */
508 : static void *
509 255836734 : _ASCIIadt_frStr(Column *c, int type, const char *s)
510 : {
511 255836734 : ssize_t len;
512 :
513 255836734 : len = (*BATatoms[type].atomFromStr) (s, &c->len, &c->data, false);
514 264118882 : if (len < 0)
515 : return NULL;
516 264118758 : switch (type) {
517 234300969 : case TYPE_bte:
518 : case TYPE_int:
519 : case TYPE_lng:
520 : case TYPE_sht:
521 : #ifdef HAVE_HGE
522 : case TYPE_hge:
523 : #endif
524 234300969 : if (len == 0 || s[len]) {
525 : /* decimals can be converted to integers when *.000 */
526 8 : if (s[len++] == '.') {
527 22 : while (s[len] == '0')
528 14 : len++;
529 8 : if (s[len] == 0)
530 4 : return c->data;
531 : }
532 : return NULL;
533 : }
534 : break;
535 29037433 : case TYPE_str: {
536 29037433 : sql_subtype *t = c->extra;
537 :
538 29037433 : s = c->data;
539 50781780 : if (t->digits > 0 && len > 0 && !strNil(s) && UTF8_strlen(s) > (int) t->digits) {
540 : return NULL;
541 : }
542 : break;
543 : }
544 : default:
545 : break;
546 : }
547 264097156 : return c->data;
548 : }
549 :
550 :
551 : static ssize_t
552 14639944 : _ASCIIadt_toStr(void *extra, char **buf, size_t *len, int type, const void *a)
553 : {
554 14639944 : if (type == TYPE_str) {
555 8509525 : Column *c = extra;
556 8509525 : char *dst;
557 8509525 : const char *src = a;
558 8509525 : size_t l = escapedStrlen(src, c->sep, c->rsep, c->quote), l2 = 0;
559 :
560 8509525 : if (c->quote)
561 8509525 : l = escapedStrlen(src, NULL, NULL, c->quote);
562 : else
563 0 : l = escapedStrlen(src, c->sep, c->rsep, 0);
564 8509525 : if (l + 3 > *len) {
565 52 : GDKfree(*buf);
566 52 : *len = 2 * l + 3;
567 52 : *buf = GDKzalloc(*len);
568 52 : if (*buf == NULL) {
569 : return -1;
570 : }
571 : }
572 8509525 : dst = *buf;
573 8509525 : if (c->quote) {
574 8509525 : dst[0] = c->quote;
575 8509525 : l2 = 1;
576 8509525 : l = escapedStr(dst + l2, src, *len - l2, NULL, NULL, c->quote);
577 : } else {
578 0 : l = escapedStr(dst + l2, src, *len - l2, c->sep, c->rsep, 0);
579 : }
580 0 : if (l2) {
581 8509525 : dst[l + l2] = c->quote;
582 8509525 : l2++;
583 : }
584 8509525 : dst[l + l2] = 0;
585 8509525 : return l + l2;
586 : } else {
587 6130419 : return (*BATatoms[type].atomToStr) (buf, len, a, true);
588 : }
589 : }
590 :
591 :
592 : static int
593 10373 : has_whitespace(const char *s)
594 : {
595 10373 : if (*s == ' ' || *s == '\t')
596 : return 1;
597 7774 : while (*s)
598 3898 : s++;
599 3876 : s--;
600 3876 : if (*s == ' ' || *s == '\t')
601 0 : return 1;
602 : return 0;
603 : }
604 :
605 : str
606 1127 : mvc_import_table(Client cntxt, BAT ***bats, mvc *m, bstream *bs, sql_table *t, const char *sep, const char *rsep, const char *ssep, const char *ns, lng sz, lng offset, int best, bool from_stdin, bool escape, const char *decsep, const char *decskip)
607 : {
608 1127 : int i = 0, j;
609 1127 : node *n;
610 1127 : Tablet as;
611 1127 : Column *fmt;
612 1127 : str msg = MAL_SUCCEED;
613 :
614 1127 : *bats =0; // initialize the receiver
615 :
616 1127 : if (!bs)
617 0 : throw(IO, "sql.copy_from", SQLSTATE(42000) "No stream (pointer) provided");
618 1127 : if (mnstr_errnr(bs->s) != MNSTR_NO__ERROR) {
619 0 : mnstr_error_kind errnr = mnstr_errnr(bs->s);
620 0 : const char *stream_msg = mnstr_peek_error(bs->s);
621 0 : msg = createException(IO, "sql.copy_from", SQLSTATE(42000) "Stream not open %s: %s", mnstr_error_kind_name(errnr), stream_msg ? stream_msg : "unknown error");
622 0 : return msg;
623 : }
624 1127 : if (offset < 0 || offset > (lng) BUN_MAX)
625 0 : throw(IO, "sql.copy_from", SQLSTATE(42000) "Offset out of range");
626 :
627 1127 : if (offset > 0)
628 30 : offset--;
629 1127 : if (ol_first_node(t->columns)) {
630 1127 : stream *out = m->scanner.ws;
631 :
632 2254 : as = (Tablet) {
633 1127 : .nr_attrs = ol_length(t->columns),
634 1127 : .nr = (sz < 1) ? BUN_NONE : (BUN) sz,
635 1127 : .offset = (BUN) offset,
636 : .error = NULL,
637 : .tryall = 0,
638 : .complaints = NULL,
639 1127 : .filename = m->scanner.rs == bs ? NULL : "",
640 : };
641 1127 : fmt = GDKzalloc(sizeof(Column) * (as.nr_attrs + 1));
642 1127 : if (fmt == NULL)
643 0 : throw(IO, "sql.copy_from", SQLSTATE(HY013) MAL_MALLOC_FAIL);
644 1127 : as.format = fmt;
645 1127 : if (!isa_block_stream(bs->s))
646 568 : out = NULL;
647 :
648 11500 : for (n = ol_first_node(t->columns), i = 0; n; n = n->next, i++) {
649 10373 : sql_column *col = n->data;
650 :
651 10373 : fmt[i].name = col->base.name;
652 10373 : fmt[i].sep = (n->next) ? sep : rsep;
653 10373 : fmt[i].rsep = rsep;
654 10373 : fmt[i].seplen = _strlen(fmt[i].sep);
655 10373 : fmt[i].decsep = decsep[0],
656 10373 : fmt[i].decskip = decskip != NULL ? decskip[0] : '\0',
657 10373 : fmt[i].type = sql_subtype_string(m->ta, &col->type);
658 : /* TODO handle output of composite types ! */
659 10373 : fmt[i].adt = ATOMindex(col->type.type->d.impl);
660 10373 : fmt[i].tostr = &_ASCIIadt_toStr;
661 10373 : fmt[i].frstr = &_ASCIIadt_frStr;
662 10373 : fmt[i].extra = &col->type;
663 10373 : fmt[i].len = ATOMlen(fmt[i].adt, ATOMnilptr(fmt[i].adt));
664 10373 : fmt[i].data = GDKzalloc(fmt[i].len);
665 10373 : if(fmt[i].data == NULL || fmt[i].type == NULL) {
666 0 : for (j = 0; j < i; j++) {
667 0 : GDKfree(fmt[j].data);
668 0 : BBPunfix(fmt[j].c->batCacheid);
669 : }
670 0 : GDKfree(fmt[i].data);
671 0 : GDKfree(fmt);
672 0 : throw(IO, "sql.copy_from", SQLSTATE(HY013) MAL_MALLOC_FAIL);
673 : }
674 10373 : fmt[i].c = NULL;
675 10373 : fmt[i].ws = !has_whitespace(fmt[i].sep);
676 10373 : fmt[i].quote = ssep ? ssep[0] : 0;
677 10373 : fmt[i].nullstr = ns;
678 10373 : fmt[i].null_length = strlen(ns);
679 10373 : fmt[i].nildata = ATOMnilptr(fmt[i].adt);
680 10373 : fmt[i].skip = (col->base.name[0] == '%');
681 10373 : if (col->type.type->eclass == EC_DEC) {
682 357 : fmt[i].tostr = &dec_tostr;
683 357 : fmt[i].frstr = &dec_frstr;
684 10016 : } else if (col->type.type->eclass == EC_SEC) {
685 87 : fmt[i].tostr = &dec_tostr;
686 87 : fmt[i].frstr = &sec_frstr;
687 9929 : } else if (col->type.type->eclass == EC_FLT) {
688 : // no need to override .tostr, only .frstr
689 3959 : fmt[i].frstr = &fltdbl_frStr;
690 : }
691 10373 : fmt[i].size = ATOMsize(fmt[i].adt);
692 : }
693 2172 : if ((msg = TABLETcreate_bats(&as, (BUN) (sz < 0 ? 1000 : sz))) == MAL_SUCCEED){
694 1127 : if (!sz || (SQLload_file(cntxt, &as, bs, out, sep, rsep, ssep ? ssep[0] : 0, offset, sz, best, from_stdin, t->base.name, escape) != BUN_NONE &&
695 1086 : (best || !as.error))) {
696 1099 : *bats = (BAT**) GDKzalloc(sizeof(BAT *) * as.nr_attrs);
697 1099 : if ( *bats == NULL){
698 0 : TABLETdestroy_format(&as);
699 0 : throw(IO, "sql.copy_from", SQLSTATE(HY013) MAL_MALLOC_FAIL);
700 : }
701 1099 : msg = TABLETcollect(*bats,&as);
702 : }
703 : }
704 1127 : if (as.error) {
705 34 : if( !best) msg = createException(SQL, "sql.copy_from", SQLSTATE(42000) "Failed to import table '%s', %s", t->base.name, getExceptionMessage(as.error));
706 34 : freeException(as.error);
707 34 : as.error = NULL;
708 : }
709 11500 : for (n = ol_first_node(t->columns), i = 0; n; n = n->next, i++) {
710 10373 : fmt[i].sep = NULL;
711 10373 : fmt[i].rsep = NULL;
712 10373 : fmt[i].nullstr = NULL;
713 : }
714 1127 : TABLETdestroy_format(&as);
715 : }
716 : return msg;
717 : }
718 :
719 : /*
720 : * mvc_export_result dumps the sql header information and the
721 : * first part (reply_size) of the result set. It should be produced in Monet format to
722 : * enable mapi to work with it.
723 : */
724 :
725 : static int
726 110904 : mvc_export_warning(stream *s, str w)
727 : {
728 110904 : str tmp = NULL;
729 110855 : while (w != NULL && *w != '\0') {
730 0 : if ((tmp = strchr(w, (int) '\n')) != NULL)
731 0 : *tmp++ = '\0';
732 0 : if (mnstr_printf(s, "#%s", w) < 0)
733 : return -4;
734 : w = tmp;
735 : }
736 : return 1;
737 : }
738 :
739 : static int
740 2 : mvc_export_binary_bat(stream *s, BAT* bn, bstream *in)
741 : {
742 2 : BATiter bni = bat_iterator(bn);
743 2 : bool sendtheap = bni.type != TYPE_void, sendtvheap = sendtheap && bni.vh;
744 :
745 4 : if (mnstr_printf(s, /*JSON*/"{"
746 : "\"version\":1,"
747 : "\"ttype\":%d,"
748 : "\"hseqbase\":" OIDFMT ","
749 : "\"tseqbase\":" OIDFMT ","
750 : "\"tsorted\":%d,"
751 : "\"trevsorted\":%d,"
752 : "\"tkey\":%d,"
753 : "\"tnonil\":%d,"
754 : "\"tdense\":%d,"
755 : "\"size\":" BUNFMT ","
756 : "\"tailsize\":%zu,"
757 : "\"theapsize\":%zu"
758 : "}\n",
759 : bni.type,
760 : bn->hseqbase, bn->tseqbase,
761 2 : bni.sorted, bni.revsorted,
762 2 : bni.key,
763 2 : bni.nonil,
764 2 : BATtdensebi(&bni),
765 : bn->batCount,
766 2 : sendtheap ? (size_t)bni.count << bni.shift : 0,
767 1 : sendtvheap && bni.count > 0 ? bni.vhfree : 0) < 0) {
768 0 : bat_iterator_end(&bni);
769 0 : return -4;
770 : }
771 :
772 2 : if (sendtheap && bni.count > 0) {
773 2 : if (mnstr_write(s, /* tail */ bni.base, bni.count * bni.width, 1) < 1) {
774 0 : bat_iterator_end(&bni);
775 0 : return -4;
776 : }
777 2 : if (sendtvheap && mnstr_write(s, /* tvheap */ bni.vh->base, bni.vhfree, 1) < 1) {
778 0 : bat_iterator_end(&bni);
779 0 : return -4;
780 : }
781 : }
782 2 : bat_iterator_end(&bni);
783 2 : if (bstream_getoob(in))
784 0 : return -5;
785 : return 0;
786 : }
787 :
788 : static int
789 333 : create_prepare_result(backend *b, cq *q, int nrows)
790 : {
791 333 : int error = 0;
792 :
793 333 : BAT* btype = COLnew(0, TYPE_str, nrows, TRANSIENT);
794 333 : BAT* bimpl = COLnew(0, TYPE_str, nrows, TRANSIENT);
795 333 : BAT* bdigits = COLnew(0, TYPE_int, nrows, TRANSIENT);
796 333 : BAT* bscale = COLnew(0, TYPE_int, nrows, TRANSIENT);
797 333 : BAT* bschema = COLnew(0, TYPE_str, nrows, TRANSIENT);
798 333 : BAT* btable = COLnew(0, TYPE_str, nrows, TRANSIENT);
799 333 : BAT* bcolumn = COLnew(0, TYPE_str, nrows, TRANSIENT);
800 333 : node *n;
801 :
802 333 : const int nr_columns = (b->client->protocol == PROTOCOL_COLUMNAR || GDKembedded()) ? 7 : 6;
803 :
804 333 : int len1 = 0, len4 = 0, len5 = 0, len6 = 0, len7 =0; /* column widths */
805 333 : int len2 = 1, len3 = 1;
806 333 : sql_arg *a;
807 333 : sql_subtype *t;
808 333 : sql_rel *r = q->rel;
809 :
810 333 : if (!btype || !bimpl || !bdigits || !bscale || !bschema || !btable || !bcolumn) {
811 0 : error = -1;
812 0 : goto wrapup;
813 : }
814 :
815 333 : if (r && (is_topn(r->op) || is_sample(r->op)))
816 2 : r = r->l;
817 333 : if (r && is_project(r->op) && r->exps) {
818 286 : unsigned int max2 = 10, max3 = 10; /* to help calculate widths */
819 286 : nrows += list_length(r->exps);
820 :
821 1796 : for (n = r->exps->h; n; n = n->next) {
822 1510 : const char *name = NULL, *rname = NULL, *schema = NULL;
823 1510 : sql_alias *ra = NULL;
824 1510 : sql_exp *e = n->data;
825 1510 : int slen;
826 :
827 1510 : t = exp_subtype(e);
828 1510 : slen = (int) strlen(t->type->base.name);
829 1510 : if (slen > len1)
830 : len1 = slen;
831 1596 : while (t->digits >= max2) {
832 86 : len2++;
833 86 : max2 *= 10;
834 : }
835 1510 : while (t->scale >= max3) {
836 0 : len3++;
837 0 : max3 *= 10;
838 : }
839 1510 : ra = exp_relname(e);
840 1510 : if (!ra && e->type == e_column && e->l)
841 1510 : ra = e->l;
842 1510 : slen = name ? (int) strlen(name) : 0;
843 1510 : if (slen > len5)
844 : len5 = slen;
845 1510 : name = exp_name(e);
846 1510 : if (!name && e->type == e_column && e->r)
847 0 : name = e->r;
848 1510 : slen = name ? (int) strlen(name) : 0;
849 1510 : if (slen > len6)
850 : len6 = slen;
851 1510 : slen = (int) strlen(t->type->d.impl);
852 1510 : if (slen > len7)
853 : len7 = slen;
854 :
855 1510 : if (ra) {
856 1503 : rname = ra->name;
857 1503 : if (ra->parent)
858 1111 : schema = ra->parent->name;
859 : }
860 1111 : if (!schema)
861 : schema = "";
862 :
863 1510 : if (!rname)
864 7 : rname = "";
865 :
866 1510 : if (!name)
867 0 : name = "";
868 :
869 3020 : if ( BUNappend(btype, t->type->base.name , false) != GDK_SUCCEED ||
870 3020 : BUNappend(bimpl, t->type->d.impl , false) != GDK_SUCCEED ||
871 3020 : BUNappend(bdigits, &t->digits , false) != GDK_SUCCEED ||
872 3020 : BUNappend(bscale, &t->scale , false) != GDK_SUCCEED ||
873 3020 : BUNappend(bschema, schema , false) != GDK_SUCCEED ||
874 3020 : BUNappend(btable, rname , false) != GDK_SUCCEED ||
875 1510 : BUNappend(bcolumn, name , false) != GDK_SUCCEED) {
876 0 : error = -3;
877 0 : goto wrapup;
878 : }
879 : }
880 : }
881 :
882 333 : if (q->f->ops) {
883 242 : int i;
884 :
885 1794 : for (n = q->f->ops->h, i = 0; n; n = n->next, i++) {
886 1552 : a = n->data;
887 1552 : t = &a->type;
888 :
889 3104 : if ( BUNappend(btype, t->type->base.name , false) != GDK_SUCCEED ||
890 3104 : BUNappend(bimpl, t->type->d.impl , false) != GDK_SUCCEED ||
891 3104 : BUNappend(bdigits, &t->digits , false) != GDK_SUCCEED ||
892 3104 : BUNappend(bscale, &t->scale , false) != GDK_SUCCEED ||
893 3104 : BUNappend(bschema, str_nil , false) != GDK_SUCCEED ||
894 3104 : BUNappend(btable, str_nil , false) != GDK_SUCCEED ||
895 1552 : BUNappend(bcolumn, str_nil , false) != GDK_SUCCEED) {
896 0 : error = -3;
897 0 : goto wrapup;
898 : }
899 : }
900 : }
901 :
902 : // A little hack to inform the result receiver of the name of the compiled mal program.
903 333 : if (b->client->protocol == PROTOCOL_COLUMNAR) {
904 0 : if ( BUNappend(btype, str_nil , false) != GDK_SUCCEED ||
905 0 : BUNappend(bimpl, str_nil , false) != GDK_SUCCEED ||
906 0 : BUNappend(bdigits, &int_nil , false) != GDK_SUCCEED ||
907 0 : BUNappend(bscale, &int_nil , false) != GDK_SUCCEED ||
908 0 : BUNappend(bschema, str_nil , false) != GDK_SUCCEED ||
909 0 : BUNappend(btable, q->f->imp , false) != GDK_SUCCEED ||
910 0 : BUNappend(bcolumn, str_nil , false) != GDK_SUCCEED) {
911 0 : error = -3;
912 0 : goto wrapup;
913 : }
914 : }
915 :
916 148 : b->results = res_table_create(
917 333 : b->mvc->session->tr,
918 333 : b->result_id++,
919 333 : b->mb? b->mb->tag: 0 /*TODO check if this is sensible*/,
920 : nr_columns,
921 : Q_PREPARE,
922 : b->results);
923 333 : if (!b->results) {
924 0 : error = -1;
925 0 : goto wrapup;
926 : }
927 :
928 666 : if ( mvc_result_column(b, ".prepare", "type" , "varchar", len1, 0, MS_VALUE, btype ) ||
929 666 : mvc_result_column(b, ".prepare", "digits" , "int", len2, 0, MS_VALUE, bdigits) ||
930 666 : mvc_result_column(b, ".prepare", "scale" , "int", len3, 0, MS_VALUE, bscale ) ||
931 666 : mvc_result_column(b, ".prepare", "schema" , "varchar", len4, 0, MS_VALUE, bschema) ||
932 666 : mvc_result_column(b, ".prepare", "table" , "varchar", len5, 0, MS_VALUE, btable ) ||
933 333 : mvc_result_column(b, ".prepare", "column" , "varchar", len6, 0, MS_VALUE, bcolumn)) {
934 0 : error = -1;
935 0 : goto wrapup;
936 : }
937 :
938 333 : if ((b->client->protocol == PROTOCOL_COLUMNAR || GDKembedded()) && mvc_result_column(b, "prepare", "impl" , "varchar", len7, 0, MS_VALUE, bimpl))
939 0 : error = -1;
940 :
941 333 : wrapup:
942 333 : BBPreclaim(btype);
943 333 : BBPreclaim(bdigits);
944 333 : BBPreclaim(bimpl);
945 333 : BBPreclaim(bscale);
946 333 : BBPreclaim(bschema);
947 333 : BBPreclaim(btable);
948 333 : BBPreclaim(bcolumn);
949 333 : if (error < 0 && b->results) {
950 0 : res_table_destroy(b->results);
951 0 : b->results = NULL;
952 : }
953 333 : return error;
954 : }
955 :
956 : int
957 333 : mvc_export_prepare(backend *b, stream *out)
958 : {
959 333 : cq *q = b->q;
960 333 : int nparam = q->f->ops ? list_length(q->f->ops) : 0;
961 333 : int nrows = nparam, res;
962 :
963 333 : if ((res = create_prepare_result(b, q, nrows)) < 0)
964 : return res;
965 :
966 333 : return mvc_export_result(b, out, b->results->id /*TODO is this right?*/, true, 0 /*TODO*/, 0 /*TODO*/);
967 : }
968 :
969 : /*
970 : * improved formatting of positive integers
971 : */
972 :
973 : static ssize_t
974 0 : mvc_send_bte(stream *s, bte cnt)
975 : {
976 0 : char buf[50], *b;
977 0 : int neg = cnt < 0;
978 0 : if (neg)
979 0 : cnt = -cnt;
980 : b = buf + 49;
981 0 : do {
982 0 : *b-- = (char) ('0' + (cnt % 10));
983 0 : cnt /= 10;
984 0 : } while (cnt > 0);
985 0 : if (neg)
986 0 : *b = '-';
987 : else
988 : b++;
989 0 : return mnstr_write(s, b, 50 - (b - buf), 1);
990 : }
991 :
992 : static ssize_t
993 0 : mvc_send_sht(stream *s, sht cnt)
994 : {
995 0 : char buf[50], *b;
996 0 : int neg = cnt < 0;
997 0 : if (neg)
998 0 : cnt = -cnt;
999 : b = buf + 49;
1000 0 : do {
1001 0 : *b-- = (char) ('0' + (cnt % 10));
1002 0 : cnt /= 10;
1003 0 : } while (cnt > 0);
1004 0 : if (neg)
1005 0 : *b = '-';
1006 : else
1007 : b++;
1008 0 : return mnstr_write(s, b, 50 - (b - buf), 1);
1009 : }
1010 :
1011 : static ssize_t
1012 508136 : mvc_send_int(stream *s, int cnt)
1013 : {
1014 508136 : char buf[50], *b;
1015 508136 : int neg = cnt < 0;
1016 508136 : if (neg)
1017 : cnt = -cnt;
1018 : b = buf + 49;
1019 678563 : do {
1020 678563 : *b-- = (char) ('0' + (cnt % 10));
1021 678563 : cnt /= 10;
1022 678563 : } while (cnt > 0);
1023 508136 : if (neg)
1024 0 : *b = '-';
1025 : else
1026 : b++;
1027 508136 : return mnstr_write(s, b, 50 - (b - buf), 1);
1028 : }
1029 :
1030 : static ssize_t
1031 1529023 : mvc_send_lng(stream *s, lng cnt)
1032 : {
1033 1529023 : char buf[50], *b;
1034 1529023 : int neg = cnt < 0;
1035 1529023 : if (neg)
1036 : cnt = -cnt;
1037 : b = buf + 49;
1038 3215828 : do {
1039 3215828 : *b-- = (char) ('0' + (cnt % 10));
1040 3215828 : cnt /= 10;
1041 3215828 : } while (cnt > 0);
1042 1529023 : if (neg)
1043 83699 : *b = '-';
1044 : else
1045 : b++;
1046 1529023 : return mnstr_write(s, b, 50 - (b - buf), 1);
1047 : }
1048 :
1049 : #ifdef HAVE_HGE
1050 : static ssize_t
1051 0 : mvc_send_hge(stream *s, hge cnt)
1052 : {
1053 0 : char buf[50], *b;
1054 0 : int neg = cnt <0;
1055 0 : if(neg) cnt = -cnt;
1056 : b= buf+49;
1057 0 : do{
1058 0 : *b--= (char) ('0'+ (cnt % 10));
1059 0 : cnt /=10;
1060 0 : } while(cnt>0);
1061 0 : if( neg)
1062 0 : *b = '-';
1063 : else b++;
1064 0 : return mnstr_write(s, b, 50 - (b - buf), 1);
1065 : }
1066 : #endif
1067 :
1068 : ssize_t
1069 11612553 : convert2str(mvc *m, sql_class eclass, int d, int sc, int has_tz, const void *p, int mtype, char **buf, size_t *len)
1070 : {
1071 11612553 : ssize_t l = 0;
1072 :
1073 11612553 : if (!p || ATOMcmp(mtype, ATOMnilptr(mtype), p) == 0) {
1074 21530 : (*buf)[0] = '\200';
1075 21530 : (*buf)[1] = 0;
1076 11620374 : } else if (eclass == EC_DEC) {
1077 267 : l = dec_tostr((void *) (ptrdiff_t) sc, buf, len, mtype, p);
1078 : } else if (eclass == EC_TIME || eclass == EC_TIME_TZ) {
1079 54 : struct time_res ts_res;
1080 54 : ts_res.has_tz = has_tz;
1081 54 : ts_res.fraction = d ? d - 1 : 0;
1082 54 : ts_res.timezone = m->timezone;
1083 54 : l = sql_time_tostr((void *) &ts_res, buf, len, mtype, p);
1084 : } else if (eclass == EC_TIMESTAMP || eclass == EC_TIMESTAMP_TZ) {
1085 97 : struct time_res ts_res;
1086 97 : ts_res.has_tz = has_tz;
1087 97 : ts_res.fraction = d ? d - 1 : 0;
1088 97 : ts_res.timezone = m->timezone;
1089 97 : l = sql_timestamp_tostr((void *) &ts_res, buf, len, mtype, p);
1090 : } else if (eclass == EC_SEC) {
1091 24 : l = dec_tostr((void *) (ptrdiff_t) 3, buf, len, mtype, p);
1092 : } else if (eclass == EC_BIT) {
1093 2375 : bit b = *(bit *) p;
1094 2375 : if (*len == 0 || *len > 5) {
1095 2360 : if (b) {
1096 2252 : strcpy(*buf, "true");
1097 2252 : l = 4;
1098 : } else {
1099 108 : strcpy(*buf, "false");
1100 108 : l = 5;
1101 : }
1102 : } else {
1103 15 : (*buf)[0] = b?'t':'f';
1104 15 : (*buf)[1] = 0;
1105 15 : l = 1;
1106 : }
1107 : } else {
1108 11617557 : l = (*BATatoms[mtype].atomToStr) (buf, len, p, false);
1109 : }
1110 11385922 : return l;
1111 : }
1112 :
1113 : static int
1114 0 : export_value(mvc *m, stream *s, sql_class eclass, const char *sqlname, int d, int sc, ptr p, int mtype, char **buf, size_t *len, const char *ns)
1115 : {
1116 0 : int ok = 0;
1117 0 : ssize_t l = 0;
1118 :
1119 0 : if (!p || ATOMcmp(mtype, ATOMnilptr(mtype), p) == 0) {
1120 0 : if (mnstr_write(s, ns, strlen(ns), 1) < 1)
1121 0 : ok = -4;
1122 0 : } else if (eclass == EC_DEC) {
1123 0 : l = dec_tostr((void *) (ptrdiff_t) sc, buf, len, mtype, p);
1124 0 : if (l > 0 && mnstr_write(s, *buf, l, 1) < 1)
1125 0 : ok = -4;
1126 0 : } else if (eclass == EC_TIME || eclass == EC_TIME_TZ) {
1127 0 : struct time_res ts_res;
1128 0 : ts_res.has_tz = (strcmp(sqlname, "timetz") == 0);
1129 0 : ts_res.fraction = d ? d - 1 : 0;
1130 0 : ts_res.timezone = m->timezone;
1131 0 : l = sql_time_tostr((void *) &ts_res, buf, len, mtype, p);
1132 0 : if (l >= 0 && mnstr_write(s, *buf, l, 1) < 1)
1133 0 : ok = -4;
1134 0 : } else if (eclass == EC_TIMESTAMP || eclass == EC_TIMESTAMP_TZ) {
1135 0 : struct time_res ts_res;
1136 0 : ts_res.has_tz = (strcmp(sqlname, "timestamptz") == 0);
1137 0 : ts_res.fraction = d ? d - 1 : 0;
1138 0 : ts_res.timezone = m->timezone;
1139 0 : l = sql_timestamp_tostr((void *) &ts_res, buf, len, mtype, p);
1140 0 : if (l >= 0 && mnstr_write(s, *buf, l, 1) < 1)
1141 0 : ok = -4;
1142 0 : } else if (eclass == EC_SEC) {
1143 0 : l = dec_tostr((void *) (ptrdiff_t) 3, buf, len, mtype, p);
1144 0 : if (l >= 0 && mnstr_write(s, *buf, l, 1) < 1)
1145 0 : ok = -4;
1146 : } else {
1147 0 : switch (mtype) {
1148 0 : case TYPE_bte:
1149 0 : if (mvc_send_bte(s, *(bte *) p) < 1)
1150 0 : ok = -4;
1151 : break;
1152 0 : case TYPE_sht:
1153 0 : if (mvc_send_sht(s, *(sht *) p) < 1)
1154 0 : ok = -4;
1155 : break;
1156 0 : case TYPE_int:
1157 0 : if (mvc_send_int(s, *(int *) p) < 1)
1158 0 : ok = -4;
1159 : break;
1160 0 : case TYPE_lng:
1161 0 : if (mvc_send_lng(s, *(lng *) p) < 1)
1162 0 : ok = -4;
1163 : break;
1164 : #ifdef HAVE_HGE
1165 0 : case TYPE_hge:
1166 0 : if (mvc_send_hge(s, *(hge *) p) < 1)
1167 0 : ok = -4;
1168 : break;
1169 : #endif
1170 0 : default:
1171 0 : l = (*BATatoms[mtype].atomToStr) (buf, len, p, true);
1172 0 : if (l >= 0 && mnstr_write(s, *buf, l, 1) < 1)
1173 0 : ok = -4;
1174 : }
1175 : }
1176 0 : return ok;
1177 : }
1178 :
1179 : static int
1180 0 : mvc_export_row(backend *b, stream *s, res_table *t, const char *btag, const char *sep, const char *rsep, const char *ssep, const char *ns)
1181 : {
1182 0 : mvc *m = b->mvc;
1183 0 : size_t seplen = strlen(sep);
1184 0 : size_t rseplen = strlen(rsep);
1185 0 : char *buf = NULL;
1186 0 : size_t len = 0;
1187 0 : int i, ok = 1;
1188 0 : int csv = (b->output_format == OFMT_CSV);
1189 0 : int json = (b->output_format == OFMT_JSON);
1190 :
1191 0 : if (!s || !t)
1192 : return 0;
1193 :
1194 0 : (void) ssep;
1195 0 : if (csv && btag[0] && mnstr_write(s, btag, strlen(btag), 1) < 1)
1196 0 : ok = -4;
1197 0 : if (json) {
1198 0 : sep = ", ";
1199 0 : seplen = strlen(sep);
1200 : }
1201 0 : for (i = 0; i < t->nr_cols && ok > -1; i++) {
1202 0 : res_col *c = t->cols + i;
1203 :
1204 0 : if (i != 0 && mnstr_write(s, sep, seplen, 1) < 1) {
1205 : ok = -4;
1206 : break;
1207 : }
1208 0 : if (json && (mnstr_write(s, c->name, strlen(c->name), 1) < 1 || mnstr_write(s, ": ", 2, 1) < 1)) {
1209 : ok = -4;
1210 : break;
1211 : }
1212 0 : ok = export_value(m, s, c->type.type->eclass, c->type.type->base.name, c->type.digits, c->type.scale, c->p, c->mtype, &buf, &len, ns);
1213 : }
1214 0 : _DELETE(buf);
1215 0 : if (ok > -1 && mnstr_write(s, rsep, rseplen, 1) < 1)
1216 0 : ok = -4;
1217 0 : b->results = res_tables_remove(b->results, t);
1218 0 : return ok;
1219 : }
1220 :
1221 : static int
1222 1 : mvc_export_table_columnar(stream *s, res_table *t, bstream *in)
1223 : {
1224 1 : int i, res = 0;
1225 :
1226 1 : if (!s || !t)
1227 : return 0;
1228 :
1229 3 : for (i = 1; i <= t->nr_cols; i++) {
1230 2 : res_col *c = t->cols + (i - 1);
1231 :
1232 2 : if (!c->b)
1233 : break;
1234 :
1235 2 : BAT *b = BATdescriptor(c->b);
1236 2 : if (b == NULL)
1237 : return -2;
1238 :
1239 2 : res = mvc_export_binary_bat(s, b, in);
1240 2 : BBPunfix(b->batCacheid);
1241 2 : if (res < 0)
1242 0 : return res;
1243 : }
1244 :
1245 : return res;
1246 : }
1247 :
1248 : static int
1249 13 : output_complex_type(res_col *cols, Column *fmt, int nr_cols, bool ms, bool composite)
1250 : {
1251 13 : int j = 0;
1252 28 : for(int i = 0; i < nr_cols; i++) {
1253 15 : res_col *c = cols + j;
1254 :
1255 15 : if (c->multiset) {
1256 : /* c rowid */
1257 0 : j += output_complex_type(cols + j + 1, fmt + j + 1, c->composite?list_length(c->type.type->d.fields):1, true, composite);
1258 0 : j++;
1259 0 : if (c->multiset == MS_ARRAY)
1260 0 : j++;
1261 0 : j++;
1262 15 : } else if (c->composite) {
1263 0 : j += output_complex_type(cols + j+ 1, fmt + j + 1, list_length(c->type.type->d.fields), ms, true);
1264 0 : if (c->virt)
1265 0 : j++;
1266 : } else {
1267 15 : j++;
1268 15 : if (ms) {
1269 11 : fmt[i].sep = NULL;
1270 11 : fmt[i].seplen = 0;
1271 : }
1272 15 : if (ms || composite)
1273 15 : fmt[j].quote = '"';
1274 : }
1275 : }
1276 13 : return j;
1277 : }
1278 :
1279 : static int
1280 127021 : mvc_export_table_(mvc *m, int output_format, stream *s, res_table *t, BUN offset, BUN nr, const char *btag, const char *sep, const char *rsep, const char *ssep, const char *ns)
1281 : {
1282 127021 : Tablet as;
1283 127021 : Column *fmt;
1284 127021 : int i, ok = 0;
1285 127021 : struct time_res *tres;
1286 127021 : int csv = (output_format == OFMT_CSV);
1287 127021 : int json = (output_format == OFMT_JSON);
1288 127021 : char *bj;
1289 :
1290 127021 : if (!s || !t)
1291 : return 0;
1292 :
1293 127014 : as.nr_attrs = t->nr_cols + 1; /* for the leader */
1294 127014 : as.nr = nr;
1295 127014 : as.offset = offset;
1296 127014 : fmt = as.format = (Column *) GDKzalloc(sizeof(Column) * (as.nr_attrs + 1));
1297 127088 : tres = GDKzalloc(sizeof(struct time_res) * (as.nr_attrs));
1298 127084 : if (fmt == NULL || tres == NULL) {
1299 0 : GDKfree(fmt);
1300 0 : GDKfree(tres);
1301 0 : return -4;
1302 : }
1303 :
1304 127084 : fmt[0].c = NULL;
1305 127084 : fmt[0].sep = (csv) ? btag : "";
1306 127084 : fmt[0].rsep = rsep;
1307 127084 : fmt[0].seplen = _strlen(fmt[0].sep);
1308 127084 : fmt[0].ws = 0;
1309 127084 : fmt[0].nullstr = NULL;
1310 127084 : fmt[0].nrfields = (int)as.nr_attrs;
1311 :
1312 473434 : for (i = 1; i <= t->nr_cols; i++) {
1313 346399 : res_col *c = t->cols + (i - 1);
1314 :
1315 346399 : if (!c->b)
1316 : break;
1317 :
1318 346399 : fmt[i].c = BATdescriptor(c->b);
1319 346404 : if (fmt[i].c == NULL) {
1320 0 : while (--i >= 1) {
1321 0 : bat_iterator_end(&fmt[i].ci);
1322 0 : BBPunfix(fmt[i].c->batCacheid);
1323 : }
1324 0 : GDKfree(fmt);
1325 0 : GDKfree(tres);
1326 0 : return -2;
1327 : }
1328 346404 : fmt[i].ci = bat_iterator(fmt[i].c);
1329 346406 : fmt[i].name = NULL;
1330 346406 : fmt[i].nrfields = c->nrfields;
1331 346406 : if (csv) {
1332 346385 : fmt[i].sep = ((i - 1) < (t->nr_cols - 1)) ? sep : rsep;
1333 346385 : fmt[i].seplen = _strlen(fmt[i].sep);
1334 346385 : fmt[i].rsep = rsep;
1335 : }
1336 346406 : fmt[i].multiset = c->type.multiset;
1337 346406 : fmt[i].composite = c->type.type->composite?list_length(c->type.type->d.fields):0;
1338 346406 : fmt[i].virt = c->virt;
1339 :
1340 346406 : if (json) {
1341 0 : res_col *p = t->cols + (i - 1);
1342 :
1343 : /*
1344 : * We define the "proper" way of returning
1345 : * a relational table in json format as a
1346 : * json array of objects, where each row is
1347 : * represented as a json object.
1348 : */
1349 0 : if (i == 1) {
1350 0 : bj = SA_NEW_ARRAY(m->sa, char, strlen(p->name) + strlen(btag));
1351 0 : snprintf(bj, strlen(p->name) + strlen(btag), "%s%s", btag, p->name);
1352 0 : fmt[i - 1].sep = bj;
1353 0 : fmt[i - 1].seplen = _strlen(fmt[i - 1].sep);
1354 0 : fmt[i - 1].rsep = NULL;
1355 0 : } else if (i <= t->nr_cols) {
1356 0 : bj = SA_NEW_ARRAY(m->sa, char, strlen(p->name) + strlen(sep));
1357 0 : snprintf(bj, strlen(p->name) + 10, "%s%s", sep, p->name);
1358 0 : fmt[i - 1].sep = bj;
1359 0 : fmt[i - 1].seplen = _strlen(fmt[i - 1].sep);
1360 0 : fmt[i - 1].rsep = NULL;
1361 : }
1362 0 : if (i == t->nr_cols) {
1363 0 : fmt[i].sep = rsep;
1364 0 : fmt[i].seplen = _strlen(fmt[i].sep);
1365 0 : fmt[i].rsep = NULL;
1366 : }
1367 : }
1368 346406 : fmt[i].type = ATOMname(fmt[i].c->ttype);
1369 346350 : fmt[i].adt = fmt[i].c->ttype;
1370 346350 : fmt[i].tostr = &_ASCIIadt_toStr;
1371 346350 : fmt[i].frstr = &_ASCIIadt_frStr;
1372 346350 : fmt[i].extra = fmt + i;
1373 346350 : fmt[i].data = NULL;
1374 346350 : fmt[i].len = 0;
1375 346350 : fmt[i].ws = 0;
1376 346350 : fmt[i].quote = ssep ? ssep[0] : 0;
1377 346350 : fmt[i].nullstr = ns;
1378 346350 : if (c->type.type->eclass == EC_DEC) {
1379 1291 : fmt[i].tostr = &dec_tostr;
1380 1291 : fmt[i].frstr = &dec_frstr;
1381 1291 : fmt[i].extra = (void *) (ptrdiff_t) c->type.scale;
1382 345059 : } else if (c->type.type->eclass == EC_TIMESTAMP || c->type.type->eclass == EC_TIMESTAMP_TZ) {
1383 825 : struct time_res *ts_res = tres + (i - 1);
1384 825 : ts_res->has_tz = EC_TEMP_TZ(c->type.type->eclass);
1385 825 : ts_res->fraction = c->type.digits ? c->type.digits - 1 : 0;
1386 825 : ts_res->timezone = m->timezone;
1387 :
1388 825 : fmt[i].tostr = &sql_timestamp_tostr;
1389 825 : fmt[i].frstr = NULL;
1390 825 : fmt[i].extra = ts_res;
1391 344234 : } else if (c->type.type->eclass == EC_TIME || c->type.type->eclass == EC_TIME_TZ) {
1392 307 : struct time_res *ts_res = tres + (i - 1);
1393 307 : ts_res->has_tz = (strcmp(c->type.type->base.name, "timetz") == 0);
1394 307 : ts_res->fraction = c->type.digits ? c->type.digits - 1 : 0;
1395 307 : ts_res->timezone = m->timezone;
1396 :
1397 307 : fmt[i].tostr = &sql_time_tostr;
1398 307 : fmt[i].frstr = NULL;
1399 307 : fmt[i].extra = ts_res;
1400 343927 : } else if (c->type.type->eclass == EC_SEC) {
1401 646 : fmt[i].tostr = &dec_tostr;
1402 646 : fmt[i].frstr = &sec_frstr;
1403 646 : fmt[i].extra = (void *) (ptrdiff_t) 3;
1404 : } else {
1405 : fmt[i].extra = fmt + i;
1406 : }
1407 : }
1408 :
1409 127035 : if (t->complex_type) {
1410 34 : for(int i = 0; i < t->nr_cols; ) {
1411 21 : res_col *c = t->cols + i;
1412 :
1413 21 : if (c->multiset) {
1414 : /* c rowid */
1415 11 : i++;
1416 11 : i += output_complex_type(t->cols + i, fmt + i + 1, c->composite?list_length(c->type.type->d.fields):1, true, false);
1417 11 : i++;
1418 11 : if (c->multiset == MS_ARRAY)
1419 11 : i++;
1420 11 : i++;
1421 10 : } else if (c->composite) {
1422 2 : i += output_complex_type(t->cols + i + 1, fmt + i + 2, list_length(c->type.type->d.fields), false, true);
1423 2 : if (c->virt)
1424 2 : i++;
1425 : } else {
1426 8 : i++;
1427 : }
1428 : }
1429 : }
1430 :
1431 127035 : if (i == t->nr_cols + 1)
1432 127027 : ok = TABLEToutput_file(&as, NULL, s, m->scanner.rs);
1433 600519 : for (i = 0; i <= t->nr_cols; i++) {
1434 473423 : fmt[i].sep = NULL;
1435 473423 : fmt[i].rsep = NULL;
1436 473423 : fmt[i].type = NULL;
1437 473423 : fmt[i].nullstr = NULL;
1438 : }
1439 473476 : for (i = 1; i <= t->nr_cols; i++)
1440 346398 : bat_iterator_end(&fmt[i].ci);
1441 127078 : TABLETdestroy_format(&as);
1442 127091 : GDKfree(tres);
1443 127080 : if (ok < 0)
1444 : return ok;
1445 127080 : if (mnstr_errnr(s) != MNSTR_NO__ERROR)
1446 : return -4;
1447 : return 0;
1448 : }
1449 :
1450 : static int
1451 127029 : mvc_export_table(backend *b, stream *s, res_table *t, BUN offset, BUN nr, const char *btag, const char *sep, const char *rsep, const char *ssep, const char *ns)
1452 : {
1453 127029 : return mvc_export_table_(b->mvc, b->output_format, s, t, offset, nr, btag, sep, rsep, ssep, ns);
1454 : }
1455 :
1456 : int
1457 0 : mvc_export(mvc *m, stream *s, res_table *t, BUN nr)
1458 : {
1459 0 : backend b = {0};
1460 0 : b.mvc = m;
1461 0 : b.results = t;
1462 0 : b.reloptimizer = 0;
1463 0 : t->nr_rows = nr;
1464 0 : if (mvc_export_head(&b, s, t->id, TRUE, TRUE, 0/*starttime*/, 0/*maloptimizer*/) < 0)
1465 : return -1;
1466 0 : return mvc_export_table_(m, OFMT_CSV, s, t, 0, nr, "[ ", ",\t", "\t]\n", "\"", "NULL");
1467 : }
1468 :
1469 :
1470 : static lng
1471 345147 : get_print_width(int mtype, sql_class eclass, int digits, int scale, int tz, bat bid, ptr p)
1472 : {
1473 345147 : size_t count = 0, incr = 0;
1474 :
1475 345147 : if (eclass == EC_SEC)
1476 : incr = 1;
1477 344527 : else if (mtype == TYPE_oid)
1478 133 : incr = 2;
1479 345147 : mtype = ATOMbasetype(mtype);
1480 345147 : if (mtype == TYPE_str) {
1481 103746 : if (eclass == EC_CHAR && digits) {
1482 1378 : return digits;
1483 : } else {
1484 102368 : int l = 0;
1485 102368 : if (bid) {
1486 102368 : BAT *b = BATdescriptor(bid);
1487 :
1488 102368 : if (b) {
1489 : /* in practice, b can be a
1490 : * void(nil) bat, an oid bat
1491 : * with all nil values, or an
1492 : * empty void/oid bat */
1493 102368 : if (ATOMstorage(b->ttype) == TYPE_str)
1494 102368 : l = bat_max_strlength(b);
1495 : else
1496 : l = 0;
1497 102368 : BBPunfix(b->batCacheid);
1498 : } else {
1499 : return -2;
1500 : }
1501 0 : } else if (p) {
1502 0 : l = UTF8_strwidth((const char *) p);
1503 0 : if (is_int_nil(l))
1504 0 : l = 0;
1505 : }
1506 102368 : return l;
1507 : }
1508 241401 : } else if (eclass == EC_NUM || eclass == EC_POS || eclass == EC_MONTH || eclass == EC_SEC) {
1509 228464 : count = 0;
1510 228464 : if (bid) {
1511 228464 : BAT *b = BATdescriptor(bid);
1512 :
1513 228495 : if (b) {
1514 228495 : if (mtype == TYPE_bte) {
1515 38408 : count = bat_max_btelength(b);
1516 : } else if (mtype == TYPE_sht) {
1517 29993 : count = bat_max_shtlength(b);
1518 : } else if (mtype == TYPE_int) {
1519 140498 : count = bat_max_intlength(b);
1520 : } else if (mtype == TYPE_lng) {
1521 19334 : count = bat_max_lnglength(b);
1522 : #ifdef HAVE_HGE
1523 : } else if (mtype == TYPE_hge) {
1524 262 : count = bat_max_hgelength(b);
1525 : #endif
1526 : } else if (mtype == TYPE_void) {
1527 : count = 4;
1528 : } else {
1529 0 : assert(0);
1530 : }
1531 228504 : count += incr;
1532 228504 : BBPunfix(b->batCacheid);
1533 : } else {
1534 : return -2;
1535 : }
1536 : } else {
1537 0 : if (p) {
1538 : #ifdef HAVE_HGE
1539 0 : hge val = 0;
1540 : #else
1541 : lng val = 0;
1542 : #endif
1543 0 : if (mtype == TYPE_bte) {
1544 0 : val = *((bte *) p);
1545 : } else if (mtype == TYPE_sht) {
1546 0 : val = *((sht *) p);
1547 : } else if (mtype == TYPE_int) {
1548 0 : val = *((int *) p);
1549 : } else if (mtype == TYPE_lng) {
1550 0 : val = *((lng *) p);
1551 : #ifdef HAVE_HGE
1552 : } else if (mtype == TYPE_hge) {
1553 0 : val = *((hge *) p);
1554 : #endif
1555 : } else {
1556 0 : assert(0);
1557 : }
1558 :
1559 0 : if (val < 0)
1560 0 : count++;
1561 0 : while (val /= 10)
1562 0 : count++;
1563 0 : count++;
1564 0 : count += incr;
1565 : } else {
1566 : count = 0;
1567 : }
1568 : }
1569 228513 : if (eclass == EC_SEC && count < 5)
1570 126 : count = 5;
1571 228513 : return count;
1572 : /* the following two could be done once by taking the
1573 : max value and calculating the number of digits from that
1574 : value, instead of the maximum values taken now, which
1575 : include the optional sign */
1576 : } else if (eclass == EC_FLT) {
1577 : /* floats are printed using "%.9g":
1578 : * [sign]+digit+period+[max 8 digits]+E+[sign]+[max 2 digits] */
1579 2309 : if (mtype == TYPE_flt) {
1580 : return 15;
1581 : /* doubles are printed using "%.17g":
1582 : * [sign]+digit+period+[max 16 digits]+E+[sign]+[max 3 digits] */
1583 : } else { /* TYPE_dbl */
1584 1998 : return 24;
1585 : }
1586 : } else if (eclass == EC_DEC) {
1587 1291 : count = 1 + digits;
1588 1291 : if (scale > 0)
1589 1047 : count += 1;
1590 1291 : if (scale == digits) // for preceding 0, e.g. 0.
1591 15 : count += 1;
1592 1291 : return count;
1593 : } else if (eclass == EC_DATE) {
1594 : return 10;
1595 : } else if (eclass == EC_TIME || eclass == EC_TIME_TZ) {
1596 298 : count = 8;
1597 298 : if (tz) /* time zone */
1598 98 : count += 6; /* +03:30 */
1599 298 : if (digits > 1) /* fractional seconds precision (including dot) */
1600 100 : count += digits;
1601 298 : return count;
1602 : } else if (eclass == EC_TIMESTAMP || eclass == EC_TIMESTAMP_TZ) {
1603 825 : count = 10 + 1 + 8;
1604 825 : if (tz) /* time zone */
1605 159 : count += 6; /* +03:30 */
1606 825 : if (digits) /* fractional seconds precision */
1607 825 : count += digits;
1608 825 : return count;
1609 : } else if (eclass == EC_BIT) {
1610 7166 : return 5; /* max(strlen("true"), strlen("false")) */
1611 645 : } else if (strcmp(ATOMname(mtype), "uuid") == 0) {
1612 : return 36; /* xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx */
1613 : } else {
1614 548 : return 0;
1615 : }
1616 : }
1617 :
1618 : static int
1619 345175 : export_length(stream *s, int mtype, sql_class eclass, int digits, int scale, int tz, bat bid, ptr p)
1620 : {
1621 345175 : lng length = get_print_width(mtype, eclass, digits, scale, tz, bid, p);
1622 345180 : if (length < 0)
1623 : return -2;
1624 345180 : if (mvc_send_lng(s, length) != 1)
1625 0 : return -4;
1626 : return 0;
1627 : }
1628 :
1629 : int
1630 19539 : mvc_export_operation(backend *b, stream *s, str w, lng starttime, lng mal_optimizer)
1631 : {
1632 19539 : mvc *m = b->mvc;
1633 :
1634 19539 : assert(m->type == Q_SCHEMA || m->type == Q_TRANS);
1635 19539 : if (m->type == Q_SCHEMA) {
1636 16460 : if (!s)
1637 : return 0;
1638 16460 : if (mnstr_printf(s, "&3 " LLFMT " " LLFMT "\n", starttime > 0 ? GDKusec() - starttime : 0, mal_optimizer) < 0)
1639 : return -4;
1640 : } else {
1641 3079 : if (m->session->auto_commit) {
1642 1430 : if (mnstr_write(s, "&4 t\n", 5, 1) != 1)
1643 : return -4;
1644 : } else {
1645 1649 : if (mnstr_write(s, "&4 f\n", 5, 1) != 1)
1646 : return -4;
1647 : }
1648 : }
1649 :
1650 19539 : if (mvc_export_warning(s, w) != 1)
1651 : return -4;
1652 : return 0;
1653 : }
1654 :
1655 :
1656 : int
1657 137868 : mvc_affrows(mvc *m, stream *s, lng val, str w, oid query_id, lng last_id, lng starttime, lng maloptimizer, lng reloptimizer)
1658 : {
1659 137868 : sqlvar_set_number(find_global_var(m, mvc_bind_schema(m, "sys"), "rowcnt"), val);
1660 :
1661 : /* if we don't have a stream, nothing can go wrong, so we return
1662 : * success. This is especially vital for execution of internal SQL
1663 : * commands, since they don't get a stream to suppress their output.
1664 : * If we would fail on having no stream here, those internal commands
1665 : * fail too.
1666 : */
1667 138342 : if (!s || GDKembedded())
1668 46723 : return 0;
1669 183128 : if (mnstr_write(s, "&2 ", 3, 1) != 1 ||
1670 183020 : mvc_send_lng(s, val) != 1 ||
1671 183380 : mnstr_write(s, " ", 1, 1) != 1 ||
1672 183014 : mvc_send_lng(s, last_id) != 1 ||
1673 183436 : mnstr_write(s, " ", 1, 1) != 1 ||
1674 183143 : mvc_send_lng(s, (lng) query_id) != 1 ||
1675 183055 : mnstr_write(s, " ", 1, 1) != 1 ||
1676 183208 : mvc_send_lng(s, starttime > 0 ? GDKusec() - starttime : 0) != 1 ||
1677 183029 : mnstr_write(s, " ", 1, 1) != 1 ||
1678 183185 : mvc_send_lng(s, maloptimizer) != 1 ||
1679 183401 : mnstr_write(s, " ", 1, 1) != 1 ||
1680 183174 : mvc_send_lng(s, reloptimizer) != 1 ||
1681 91714 : mnstr_write(s, "\n", 1, 1) != 1)
1682 0 : return -4;
1683 91488 : if (mvc_export_warning(s, w) != 1)
1684 : return -4;
1685 :
1686 : return 0;
1687 : }
1688 :
1689 : int
1690 137922 : mvc_export_affrows(backend *b, stream *s, lng val, str w, oid query_id, lng starttime, lng maloptimizer)
1691 : {
1692 137922 : b->rowcnt = val;
1693 137922 : return mvc_affrows(b->mvc, s, val, w, query_id, b->last_id, starttime, maloptimizer, b->reloptimizer);
1694 : }
1695 :
1696 : static inline int
1697 25 : next_col(res_col *c)
1698 : {
1699 25 : int res = (c->type.multiset==MS_VALUE)?0:(c->type.multiset==MS_ARRAY)?3:2;
1700 25 : if (c->virt)
1701 13 : res++;
1702 25 : if (c->type.type && c->type.type->composite) {
1703 2 : int nr = list_length(c->type.type->d.fields);
1704 : /* needs fix ie needs to jump id,nr cols etc */
1705 2 : int o = 0;
1706 6 : for(int i = 0; i < nr; i++) {
1707 4 : int j = next_col(c+o+1);
1708 4 : res += j;
1709 4 : o += j;
1710 : }
1711 : } else {
1712 23 : res++;
1713 : }
1714 25 : c->nrfields = res;
1715 25 : return res;
1716 : }
1717 :
1718 : static int
1719 13 : count_cols(res_table *t)
1720 : {
1721 13 : int res = 0;
1722 :
1723 34 : for(int i = 0; i < t->nr_cols; ) {
1724 21 : res_col *c = t->cols + i;
1725 : //if (!c->virt || !c->multiset)
1726 21 : res++;
1727 :
1728 21 : i += next_col(c);
1729 : }
1730 13 : return res;
1731 : }
1732 :
1733 : static BUN
1734 13 : count_rows(res_table *t) /* find real output column size */
1735 : {
1736 13 : int res = 0;
1737 13 : res_col *c = t->cols;
1738 :
1739 13 : if (c->virt) {
1740 11 : if (c->multiset)
1741 11 : res = c->nrfields - 1;
1742 : else
1743 : res++;
1744 : }
1745 13 : c = t->cols + res;
1746 13 : if (c->cached)
1747 0 : return BATcount((BAT*)c->p);
1748 : else
1749 13 : return BATcount(BBPquickdesc(c->b));
1750 : }
1751 :
1752 : int
1753 126973 : mvc_export_head(backend *b, stream *s, int res_id, int only_header, int compute_lengths, lng starttime, lng maloptimizer)
1754 : {
1755 126973 : mvc *m = b->mvc;
1756 126973 : int i, res = 0;
1757 126973 : BUN count = 0;
1758 126973 : res_table *t = res_tables_find(b->results, res_id);
1759 :
1760 126993 : if (!s || !t)
1761 : return 0;
1762 :
1763 : /* needed at the start as it fills in the nrfields */
1764 126993 : if (t->complex_type) {
1765 13 : t->nr_output_cols = count_cols(t);
1766 13 : t->nr_rows = count_rows(t);
1767 : }
1768 : /* query type: Q_TABLE || Q_PREPARE */
1769 126993 : assert(t->query_type == Q_TABLE || t->query_type == Q_PREPARE);
1770 126993 : if (mnstr_write(s, "&", 1, 1) != 1 || mvc_send_int(s, (int) t->query_type) != 1 || mnstr_write(s, " ", 1, 1) != 1)
1771 0 : return -4;
1772 :
1773 : /* id */
1774 127005 : int result_id = t->query_type == Q_PREPARE?b->q->id:t->id;
1775 127005 : if (mvc_send_int(s, result_id) != 1 || mnstr_write(s, " ", 1, 1) != 1)
1776 0 : return -4;
1777 :
1778 : /* tuple count */
1779 126995 : if (only_header) {
1780 127000 : if (t->cols[0].b) {
1781 127007 : count = t->nr_rows;
1782 : } else {
1783 : count = 1;
1784 : }
1785 : }
1786 126995 : b->rowcnt = count;
1787 126995 : sqlvar_set_number(find_global_var(m, mvc_bind_schema(m, "sys"), "rowcnt"), b->rowcnt);
1788 127010 : if (mvc_send_lng(s, (lng) count) != 1 || mnstr_write(s, " ", 1, 1) != 1)
1789 0 : return -4;
1790 :
1791 : /* column count */
1792 127008 : if (mvc_send_int(s, t->nr_output_cols) != 1 || mnstr_write(s, " ", 1, 1) != 1)
1793 0 : return -4;
1794 :
1795 : /* row count, min(count, reply_size) */
1796 : /* the columnar protocol ignores the reply size by fetching the
1797 : * entire resultset at once, so don't set it; also, the MAPI
1798 : * protocol doesn't allow for retrieving rows using the Xexport*
1799 : * commands for Q_PREPARE results (due to an oversight), so we send
1800 : * it all in the first response */
1801 127007 : if (mvc_send_int(s, (b->client && b->client->protocol != PROTOCOL_COLUMNAR && m->reply_size >= 0 && (BUN) m->reply_size < count && t->query_type != Q_PREPARE) ? m->reply_size : (int) count) != 1)
1802 : return -4;
1803 :
1804 : // export query id
1805 127007 : if (mnstr_write(s, " ", 1, 1) != 1 || mvc_send_lng(s, (lng) t->query_id) != 1)
1806 0 : return -4;
1807 :
1808 : // export query time
1809 127002 : if (mnstr_write(s, " ", 1, 1) != 1 || mvc_send_lng(s, starttime > 0 ? GDKusec() - starttime : 0) != 1)
1810 0 : return -4;
1811 :
1812 : // export MAL optimizer time
1813 127010 : if (mnstr_write(s, " ", 1, 1) != 1 || mvc_send_lng(s, maloptimizer) != 1)
1814 0 : return -4;
1815 :
1816 127007 : if (mnstr_write(s, " ", 1, 1) != 1 || mvc_send_lng(s, b->reloptimizer) != 1)
1817 0 : return -4;
1818 :
1819 127010 : if (mnstr_write(s, "\n% ", 3, 1) != 1)
1820 : return -4;
1821 472179 : for (i = 0; i < t->nr_cols; ) {
1822 345182 : res_col *c = t->cols + i;
1823 345182 : size_t len = strlen(c->tn);
1824 :
1825 345182 : if (len && mnstr_write(s, c->tn, len, 1) != 1)
1826 : return -4;
1827 345191 : i += c->nrfields;
1828 345191 : if (i < t->nr_cols && mnstr_write(s, ",\t", 2, 1) != 1)
1829 : return -4;
1830 : }
1831 126997 : if (mnstr_write(s, " # table_name\n% ", 16, 1) != 1)
1832 : return -4;
1833 :
1834 472157 : for (i = 0; i < t->nr_cols; ) {
1835 345167 : res_col *c = t->cols + i;
1836 :
1837 345167 : if (strpbrk(c->name, ", \t#\"\\")) {
1838 196 : char *p;
1839 196 : if (mnstr_write(s, "\"", 1, 1) != 1)
1840 : return -4;
1841 2611 : for (p = c->name; *p; p++) {
1842 2415 : if (*p == '"' || *p == '\\') {
1843 27 : if (mnstr_write(s, "\\", 1, 1) != 1)
1844 : return -4;
1845 : }
1846 2415 : if (mnstr_write(s, p, 1, 1) != 1)
1847 : return -4;
1848 : }
1849 196 : if (mnstr_write(s, "\"", 1, 1) != 1)
1850 : return -4;
1851 : } else {
1852 344971 : if (mnstr_write(s, c->name, strlen(c->name), 1) != 1)
1853 : return -4;
1854 : }
1855 345150 : i += c->nrfields;
1856 :
1857 345150 : if (i < t->nr_cols && mnstr_write(s, ",\t", 2, 1) != 1)
1858 : return -4;
1859 : }
1860 126990 : if (mnstr_write(s, " # name\n% ", 10, 1) != 1)
1861 : return -4;
1862 :
1863 472201 : for (i = 0; i < t->nr_cols; ) {
1864 345196 : res_col *c = t->cols + i;
1865 :
1866 345196 : if (c->type.multiset || c->type.type->composite) {
1867 34 : if (mnstr_write(s, "varchar", 7, 1) != 1)
1868 : return -4;
1869 345162 : } else if (mnstr_write(s, c->type.type->base.name, strlen(c->type.type->base.name), 1) != 1)
1870 : return -4;
1871 : //if (c->type.multiset && mnstr_write(s, "[]", 2, 1) != 1)
1872 : //return -4;
1873 345202 : i += c->nrfields;
1874 345202 : if (i < t->nr_cols && mnstr_write(s, ",\t", 2, 1) != 1)
1875 : return -4;
1876 : }
1877 127005 : if (mnstr_write(s, " # type\n% ", 10, 1) != 1)
1878 : return -4;
1879 126979 : if (compute_lengths) {
1880 472201 : for (i = 0; i < t->nr_cols; ) {
1881 345212 : res_col *c = t->cols + i;
1882 345212 : int mtype = c->type.type->localtype;
1883 345212 : sql_class eclass = c->type.type->eclass;
1884 :
1885 345212 : if (c->type.multiset || c->type.type->composite) {
1886 13 : if (mvc_send_lng(s, 16) != 1)
1887 : return -4;
1888 345199 : } else if ((res = export_length(s, mtype, eclass, c->type.digits, c->type.scale, type_has_tz(&c->type), c->b, c->p)) < 0)
1889 0 : return res;
1890 345212 : i += c->nrfields;
1891 345212 : if (i < t->nr_cols && mnstr_write(s, ",\t", 2, 1) != 1)
1892 : return -4;
1893 : }
1894 126989 : if (mnstr_write(s, " # length\n", 10, 1) != 1)
1895 : return -4;
1896 : }
1897 126983 : if (b->sizeheader) {
1898 96871 : if (mnstr_write(s, "% ", 2, 1) != 1)
1899 : return -4;
1900 366016 : for (i = 0; i < t->nr_cols; ) {
1901 269130 : res_col *c = t->cols + i;
1902 :
1903 269130 : if (mnstr_printf(s, "%u %u", c->type.digits, c->type.scale) < 0)
1904 : return -4;
1905 269127 : i += c->nrfields;
1906 269127 : if (i < t->nr_cols && mnstr_write(s, ",\t", 2, 1) != 1)
1907 : return -4;
1908 : }
1909 96886 : if (mnstr_write(s, " # typesizes\n", 13, 1) != 1)
1910 : return -4;
1911 : }
1912 : return res;
1913 : }
1914 :
1915 : static int
1916 25 : mvc_export_file(backend *b, stream *s, res_table *t)
1917 : {
1918 25 : int res = 0;
1919 25 : BUN count;
1920 :
1921 25 : if (!t->cols[0].b) {
1922 0 : res = mvc_export_row(b, s, t, "", t->tsep, t->rsep, t->ssep, t->ns);
1923 : } else {
1924 25 : count = t->nr_rows;
1925 :
1926 25 : res = mvc_export_table(b, s, t, 0, count, "", t->tsep, t->rsep, t->ssep, t->ns);
1927 25 : b->results = res_tables_remove(b->results, t);
1928 : }
1929 25 : return res;
1930 : }
1931 :
1932 : int
1933 128862 : mvc_export_result(backend *b, stream *s, int res_id, bool header, lng starttime, lng maloptimizer)
1934 : {
1935 128862 : mvc *m = b->mvc;
1936 128862 : int clean = 0, res = 0;
1937 128862 : BUN count;
1938 128862 : res_table *t = res_tables_find(b->results, res_id);
1939 128824 : int json = (b->output_format == OFMT_JSON);
1940 :
1941 128824 : if (!s || !t)
1942 : return 0;
1943 :
1944 : /* Proudly supporting SQLstatementIntern's output flag */
1945 128824 : if (b->output_format == OFMT_NONE)
1946 : return 0;
1947 :
1948 126966 : assert(t->query_type == Q_TABLE || t->query_type == Q_PREPARE);
1949 126966 : if (t->tsep) {
1950 : /* need header */
1951 25 : if (header && (res = mvc_export_head(b, s, res_id, TRUE, TRUE, starttime, maloptimizer)) < 0)
1952 : return res;
1953 25 : return mvc_export_file(b, s, t);
1954 : }
1955 :
1956 126941 : if (!json && (res = mvc_export_head(b, s, res_id, TRUE, TRUE, starttime, maloptimizer)) < 0)
1957 : return res;
1958 :
1959 126940 : assert(t->cols[0].b);
1960 :
1961 126940 : if (b->client->protocol == PROTOCOL_COLUMNAR) {
1962 1 : if (mnstr_flush(s, MNSTR_FLUSH_DATA) < 0)
1963 : return -4;
1964 1 : return mvc_export_table_columnar(s, t, m->scanner.rs);
1965 : }
1966 :
1967 : /* for Q_PREPARE results, send everything */
1968 126939 : count = t->query_type == Q_PREPARE ? t->nr_rows : (BUN) m->reply_size;
1969 126939 : if (m->reply_size != -2 && (count <= 0 || count >= t->nr_rows)) {
1970 126293 : count = t->nr_rows;
1971 126293 : clean = 1;
1972 : }
1973 126939 : if (json) {
1974 0 : switch(count) {
1975 : case 0:
1976 0 : res = mvc_export_table(b, s, t, 0, count, "{\t", "", "}\n", "\"", "null");
1977 0 : break;
1978 : case 1:
1979 0 : res = mvc_export_table(b, s, t, 0, count, "{\n\t\"%s\" : ", ",\n\t\"%s\" : ", "\n}\n", "\"", "null");
1980 0 : break;
1981 : case 2:
1982 0 : res = mvc_export_table(b, s, t, 0, 1, "[\n\t{\n\t\t\"%s\" : ", ",\n\t\t\"%s\" : ", "\n\t},\n", "\"", "null");
1983 0 : res = mvc_export_table(b, s, t, 1, count - 1, "\t{\n\t\t\"%s\" : ", ",\n\t\t\"%s\" : ", "\n\t}\n]\n", "\"", "null");
1984 0 : break;
1985 : default:
1986 0 : res = mvc_export_table(b, s, t, 0, 1, "[\n\t{\n\t\t\"%s\" : ", ",\n\t\t\"%s\" : ", "\n\t},\n", "\"", "null");
1987 0 : res = mvc_export_table(b, s, t, 1, count - 2, "\t{\n\t\t\"%s\" : ", ",\n\t\t\"%s\" : ", "\n\t},\n", "\"", "null");
1988 0 : res = mvc_export_table(b, s, t, count - 1, 1, "\t{\n\t\t\"%s\" : ", ",\n\t\t\"%s\" : ", "\n\t}\n]\n", "\"", "null");
1989 : }
1990 : } else {
1991 126939 : res = mvc_export_table(b, s, t, 0, count, "[ ", ",\t", "\t]\n", "\"", "NULL");
1992 : }
1993 126935 : if (clean)
1994 126302 : b->results = res_tables_remove(b->results, t);
1995 :
1996 126964 : if (res > -1)
1997 126964 : res = 1;
1998 : return res;
1999 : }
2000 :
2001 : int
2002 77 : mvc_export_chunk(backend *b, stream *s, int res_id, BUN offset, BUN nr)
2003 : {
2004 77 : int res = 0;
2005 77 : res_table *t = res_tables_find(b->results, res_id);
2006 77 : BUN cnt;
2007 :
2008 77 : if (!s || !t)
2009 : return 0;
2010 :
2011 65 : cnt = nr;
2012 65 : if (cnt == 0)
2013 0 : cnt = t->nr_rows;
2014 65 : if (offset >= t->nr_rows)
2015 : cnt = 0;
2016 65 : if (cnt == BUN_NONE || offset + cnt > t->nr_rows)
2017 19 : cnt = t->nr_rows - offset;
2018 :
2019 : /* query type: Q_BLOCK */
2020 65 : if (mnstr_write(s, "&6 ", 3, 1) != 1)
2021 : return -4;
2022 :
2023 : /* result id */
2024 65 : if (mvc_send_int(s, res_id) != 1 || mnstr_write(s, " ", 1, 1) != 1)
2025 0 : return -4;
2026 :
2027 : /* column count */
2028 65 : if (mvc_send_int(s, t->nr_output_cols) != 1 || mnstr_write(s, " ", 1, 1) != 1)
2029 0 : return -4;
2030 :
2031 : /* row count */
2032 65 : if (mvc_send_lng(s, (lng) cnt) != 1 || mnstr_write(s, " ", 1, 1) != 1)
2033 0 : return -4;
2034 :
2035 : /* block offset */
2036 65 : if (mvc_send_lng(s, (lng) offset) != 1)
2037 : return -4;
2038 :
2039 65 : if (mnstr_write(s, "\n", 1, 1) != 1)
2040 : return -4;
2041 :
2042 65 : res = mvc_export_table(b, s, t, offset, cnt, "[ ", ",\t", "\t]\n", "\"", "NULL");
2043 65 : return res;
2044 : }
2045 :
2046 : int
2047 128561 : mvc_result_table(backend *be, oid query_id, int nr_cols, mapi_query_t type)
2048 : {
2049 128561 : res_table *t = res_table_create(be->mvc->session->tr, be->result_id++, query_id, nr_cols, type, be->results);
2050 128561 : be->results = t;
2051 128561 : return t ? t->id : -1;
2052 : }
2053 :
2054 : int
2055 285322 : mvc_result_column(backend *be, const char *tn, const char *name, const char *typename, int digits, int scale, int multiset, BAT *b)
2056 : {
2057 : /* return 0 on success, non-zero on failure */
2058 285322 : return res_col_create(be->mvc->session->tr, be->results, tn, name, typename, digits, scale, multiset, true, b->ttype, b, false) ? 0 : -1;
2059 : }
2060 :
2061 : int
2062 63093 : mvc_result_value(backend *be, const char *tn, const char *name, const char *typename, int digits, int scale, int multiset, ptr *p, int mtype)
2063 : {
2064 : /* return 0 on success, non-zero on failure */
2065 63093 : return res_col_create(be->mvc->session->tr, be->results, tn, name, typename, digits, scale, multiset, false, mtype, p, false) ? 0 : -1;
2066 : }
2067 :
2068 : /* Translate error code from export function to error string */
2069 : const char *
2070 0 : mvc_export_error(backend *be, stream *s, int err_code)
2071 : {
2072 0 : (void) be;
2073 0 : switch (err_code) {
2074 : case -1: /* Allocation failure */
2075 : return MAL_MALLOC_FAIL;
2076 0 : case -2: /* BAT descriptor error */
2077 0 : return RUNTIME_OBJECT_MISSING;
2078 0 : case -3: /* GDK error */
2079 0 : return GDKerrbuf;
2080 0 : case -4: /* Stream error */
2081 0 : return mnstr_peek_error(s);
2082 0 : case -5:
2083 0 : return "Query aborted";
2084 0 : default: /* Unknown, must be a bug */
2085 0 : return "Unknown internal error";
2086 : }
2087 : }
2088 :
2089 : static ssize_t
2090 3865 : align_dump(stream *s, uint64_t pos, unsigned int alignment)
2091 : {
2092 3865 : uint64_t a = (uint64_t)alignment;
2093 : // must be a power of two
2094 3865 : assert(a > 0);
2095 3865 : assert((a & (a-1)) == 0);
2096 :
2097 3865 : static char zeroes[32] = { 0 };
2098 : #ifdef _MSC_VER
2099 : #pragma warning(suppress:4146)
2100 : #endif
2101 3865 : uint64_t gap = (~pos + 1) % a;
2102 3865 : return mnstr_write(s, zeroes, 1, (size_t)gap);
2103 : }
2104 :
2105 :
2106 : struct bindump_record {
2107 : BAT *bat;
2108 : type_record_t *type_rec;
2109 : int64_t start;
2110 : int64_t length;
2111 : };
2112 :
2113 : int
2114 606 : mvc_export_bin_chunk(backend *b, stream *s, int res_id, BUN offset, BUN nr)
2115 : {
2116 606 : int ret = -42;
2117 606 : struct bindump_record *colinfo;
2118 606 : stream *countstream = NULL;
2119 606 : uint64_t byte_count = 0;
2120 606 : uint64_t toc_pos = 0;
2121 606 : BUN end_row = offset + nr;
2122 :
2123 606 : res_table *res = res_tables_find(b->results, res_id);
2124 606 : if (res == NULL)
2125 : return 0;
2126 :
2127 606 : colinfo = GDKzalloc(res->nr_cols * sizeof(*colinfo));
2128 606 : if (!colinfo) {
2129 0 : ret = -1;
2130 0 : goto end;
2131 : }
2132 3865 : for (int i = 0; i < res->nr_cols; i++)
2133 3259 : colinfo[i].bat = NULL;
2134 3865 : for (int i = 0; i < res->nr_cols; i++) {
2135 3259 : bat bat_id = res->cols[i].b;
2136 3259 : BAT *b = BATdescriptor(bat_id);
2137 3259 : if (!b) {
2138 0 : ret = -1;
2139 0 : goto end;
2140 : }
2141 3259 : colinfo[i].bat = b;
2142 :
2143 3259 : if (BATcount(b) < end_row)
2144 : end_row = BATcount(b);
2145 :
2146 3259 : int tpe = BATttype(b);
2147 3259 : const char *gdk_name = ATOMname(tpe);
2148 3259 : type_record_t *rec = find_type_rec(gdk_name);
2149 3259 : if (!rec || !can_dump_binary_column(rec)) {
2150 0 : GDKerror("column %d: don't know how to dump data type '%s'", i, gdk_name);
2151 0 : ret = -3;
2152 0 : goto end;
2153 : }
2154 3259 : colinfo[i].type_rec = rec;
2155 : }
2156 :
2157 : // The byte_counting_stream keeps track of the byte offsets
2158 606 : countstream = byte_counting_stream(s, &byte_count);
2159 :
2160 : // Make sure the message starts with a & and not with a !
2161 606 : mnstr_printf(countstream, "&6 %d %d " BUNFMT " " BUNFMT "\n", res_id, res->nr_cols, end_row - offset, offset);
2162 :
2163 3865 : for (int i = 0; i < res->nr_cols; i++) {
2164 3259 : align_dump(countstream, byte_count, 32); // 32 looks nice in tcpflow
2165 3259 : struct bindump_record *info = &colinfo[i];
2166 3259 : info->start = byte_count;
2167 3259 : str msg = dump_binary_column(info->type_rec, info->bat, offset, end_row - offset, false, countstream);
2168 3259 : if (msg != MAL_SUCCEED) {
2169 0 : GDKerror("%s", msg);
2170 0 : GDKfree(msg);
2171 0 : ret = -3;
2172 0 : goto end;
2173 : }
2174 3259 : info->length = byte_count - info->start;
2175 : }
2176 :
2177 606 : assert(byte_count > 0);
2178 :
2179 606 : align_dump(countstream, byte_count, 32);
2180 606 : toc_pos = byte_count;
2181 3865 : for (int i = 0; i < res->nr_cols; i++) {
2182 3259 : struct bindump_record *info = &colinfo[i];
2183 3259 : lng start = info->start;
2184 3259 : lng length = info->length;
2185 3259 : mnstr_writeLng(countstream, start);
2186 3259 : mnstr_writeLng(countstream, length);
2187 : }
2188 :
2189 606 : mnstr_writeLng(countstream, toc_pos);
2190 606 : ret = 0;
2191 :
2192 606 : end:
2193 606 : if (colinfo) {
2194 3865 : for (int i = 0; i < res->nr_cols; i++) {
2195 3259 : if (colinfo[i].bat)
2196 3259 : BBPunfix(colinfo[i].bat->batCacheid);
2197 : }
2198 606 : GDKfree(colinfo);
2199 : }
2200 606 : mnstr_destroy(countstream);
2201 606 : return ret;
2202 : }
2203 :
2204 : #define skipspace(s) while(*s && isspace(*s)) s++;
2205 : static char *
2206 68 : FINDsep(char *s, char tsep, char rsep)
2207 : {
2208 135 : for (; *s; s++) {
2209 135 : if (s[0] == tsep || s[0] == rsep) {
2210 : break;
2211 : }
2212 : }
2213 68 : if (!*s)
2214 : return NULL;
2215 : return s;
2216 : }
2217 :
2218 : static str
2219 68 : VALUEparser(char **S, Column *cols, int elm, sql_subtype *t, char tsep, char rsep)
2220 : {
2221 : /* handle literals */
2222 68 : char *s = *S;
2223 68 : char *ns = s;
2224 68 : if (t->type->localtype == TYPE_str) {
2225 : /* todo improve properly skip "" strings. */
2226 37 : if (*s != '"')
2227 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "missing \" at start of string value");
2228 37 : s++;
2229 37 : ns = s;
2230 167 : while(*ns && *ns != '"')
2231 130 : ns++;
2232 37 : if (*ns != '"')
2233 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "missing \" at end of string value");
2234 37 : *ns = 0;
2235 37 : ns++;
2236 : }
2237 68 : ns = FINDsep(ns, tsep, rsep);
2238 68 : char sep = 0;
2239 68 : if (!ns)
2240 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "missing '%c' at end of value", rsep?rsep:tsep);
2241 : else {
2242 68 : sep = *ns;
2243 68 : *ns = 0;
2244 : }
2245 68 : void *d = cols[elm].frstr(cols+elm, cols[elm].adt, s);
2246 68 : if (elm >= 0 && d && BUNappend(cols[elm].c, d, false) != GDK_SUCCEED)
2247 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "append failed");
2248 68 : *ns = sep;
2249 68 : *S = ns;
2250 68 : return NULL;
2251 : }
2252 :
2253 : static str ARRAYparser(char **s, Column *cols, int nr, int *elm, sql_subtype *t);
2254 :
2255 : static str
2256 23 : TUPLEparser(char **S, Column *cols, int nr, int *elm, sql_subtype *t)
2257 : {
2258 23 : char *s = *S;
2259 23 : str msg = NULL;
2260 23 : int i = *elm;
2261 :
2262 23 : skipspace(s);
2263 23 : if (!s && *s && s[0] != '(')
2264 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "missing ( at start of composite value");
2265 23 : s++;
2266 : /* handle composite */
2267 69 : for (node *n = t->type->d.fields->h; n && !msg; n = n->next) {
2268 46 : sql_arg *f = n->data;
2269 :
2270 46 : if (f->type.multiset) {
2271 12 : msg = ARRAYparser(&s, cols, nr, &i, &f->type);
2272 34 : } else if (f->type.type->composite) {
2273 0 : msg = TUPLEparser(&s, cols, nr, &i, &f->type);
2274 : } else {
2275 34 : msg = VALUEparser(&s, cols, i, &f->type, ',', ')');
2276 34 : i++;
2277 : }
2278 46 : if (!msg && n->next) {
2279 23 : skipspace(s);
2280 23 : if (!s && *s && s[0] != ',')
2281 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "missing , within composite value");
2282 23 : s++;
2283 69 : skipspace(s);
2284 : }
2285 : }
2286 23 : if (msg)
2287 : return msg;
2288 23 : skipspace(s);
2289 23 : if (!s && *s && s[0] != ')')
2290 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "missing ) at end of composite value");
2291 23 : s++;
2292 23 : *S = s;
2293 23 : *elm = i;
2294 23 : return msg;
2295 : }
2296 :
2297 : static str
2298 25 : ARRAYparser(char **S, Column *cols, int nr, int *elm, sql_subtype *t)
2299 : {
2300 25 : char *s = *S;
2301 25 : str msg = NULL;
2302 25 : if (!s && s[0] != '{')
2303 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "missing { at start of array value");
2304 25 : s++;
2305 25 : skipspace(s);
2306 25 : int i = *elm;
2307 25 : int oelm = i;
2308 25 : int anr = 1, id = 0;
2309 50 : while (*s && s[0] != '}' && !msg) {
2310 50 : i = oelm;
2311 : /* insert values */
2312 50 : if (t->type->composite) {
2313 16 : msg = TUPLEparser(&s, cols, nr, &i, t);
2314 : } else {
2315 34 : msg = VALUEparser(&s, cols, i, t, ',', '}');
2316 34 : i++;
2317 : }
2318 : /* insert msid */
2319 50 : if (t->multiset) {
2320 50 : id = (int)BATcount(cols[i + (t->multiset == MS_ARRAY?2:1)].c);
2321 50 : if (i < 0 || BUNappend(cols[i].c, &id, false) != GDK_SUCCEED)
2322 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "append failed");
2323 50 : i++;
2324 : }
2325 50 : if (t->multiset == MS_ARRAY) {
2326 : /* insert msnr */
2327 50 : if (i < 0 || BUNappend(cols[i].c, &anr, false) != GDK_SUCCEED)
2328 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "append failed");
2329 50 : i++;
2330 : }
2331 :
2332 50 : skipspace(s);
2333 : /* handle optinal ',' */
2334 50 : if (*s && s[0] != ',')
2335 : break;
2336 25 : s++;
2337 50 : skipspace(s);
2338 25 : anr++;
2339 : }
2340 : /* insert row-id */
2341 25 : if (t->multiset) {
2342 25 : if (i < 0 || BUNappend(cols[i].c, &id, false) != GDK_SUCCEED)
2343 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "append failed");
2344 25 : i++;
2345 : }
2346 25 : if (!s || s[0] != '}')
2347 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "missing } at end of array value");
2348 25 : *elm = i;
2349 25 : *S = ++s;
2350 25 : return msg;
2351 : }
2352 :
2353 : static int
2354 28 : from_string_cols(Column *fmt, BAT **bats, int nr, int cur, sql_subtype *t)
2355 : {
2356 28 : int i = cur;
2357 :
2358 28 : if (t->type->composite) {
2359 45 : for(node *n = t->type->d.fields->h; n; n = n->next) {
2360 30 : if (i < 0 || i >= nr)
2361 : return -10;
2362 30 : sql_arg *f = n->data;
2363 30 : if (f->type.multiset || f->type.type->composite) {
2364 8 : i = from_string_cols(fmt, bats, nr, i, &f->type);
2365 : } else {
2366 22 : fmt[i].frstr = &_ASCIIadt_frStr;
2367 22 : fmt[i].extra = &f->type;
2368 22 : fmt[i].adt = f->type.type->localtype;
2369 22 : fmt[i].len = ATOMlen(fmt[i].adt, ATOMnilptr(fmt[i].adt));
2370 22 : fmt[i].c = bats[i];
2371 22 : i++;
2372 : }
2373 : }
2374 : } else {
2375 13 : if (i < 0 || i >= nr)
2376 : return -10;
2377 13 : fmt[i].frstr = &_ASCIIadt_frStr;
2378 13 : fmt[i].extra = t;
2379 13 : fmt[i].adt = t->type->localtype;
2380 13 : fmt[i].len = ATOMlen(fmt[i].adt, ATOMnilptr(fmt[i].adt));
2381 13 : fmt[i].c = bats[i];
2382 13 : i++;
2383 : }
2384 28 : if (t->multiset) {
2385 : /* msid */
2386 21 : if (i < 0 || i >= nr)
2387 : return -10;
2388 21 : fmt[i].frstr = &_ASCIIadt_frStr;
2389 21 : fmt[i].extra = sql_bind_localtype("int");
2390 21 : fmt[i].adt = TYPE_int;
2391 21 : fmt[i].len = ATOMlen(fmt[i].adt, ATOMnilptr(fmt[i].adt));
2392 21 : fmt[i].c = bats[i];
2393 21 : i++;
2394 : /* msnr */
2395 21 : if (t->multiset == MS_ARRAY) {
2396 21 : if (i < 0 || i >= nr)
2397 : return -10;
2398 21 : fmt[i].frstr = &_ASCIIadt_frStr;
2399 21 : fmt[i].extra = sql_bind_localtype("int");
2400 21 : fmt[i].adt = TYPE_int;
2401 21 : fmt[i].len = ATOMlen(fmt[i].adt, ATOMnilptr(fmt[i].adt));
2402 21 : fmt[i].c = bats[i];
2403 21 : i++;
2404 : }
2405 21 : if (i < 0 || i >= nr)
2406 : return -10;
2407 21 : fmt[i].frstr = &_ASCIIadt_frStr;
2408 21 : fmt[i].extra = sql_bind_localtype("int");
2409 21 : fmt[i].adt = TYPE_int;
2410 21 : fmt[i].len = ATOMlen(fmt[i].adt, ATOMnilptr(fmt[i].adt));
2411 21 : fmt[i].c = bats[i];
2412 21 : i++;
2413 : }
2414 : return i;
2415 : }
2416 :
2417 : str
2418 20 : mvc_from_string(mvc *m, BAT **bats, int nr, char *s, sql_subtype *t)
2419 : {
2420 20 : str msg = MAL_SUCCEED;
2421 :
2422 20 : if (!t || (!t->multiset && !t->type->composite))
2423 0 : throw(SQL, "sql.from_varchar", SQLSTATE(HY013) "Multiset and/or composite type expected");
2424 20 : Column *fmt = (Column *) GDKzalloc(sizeof(Column) * nr);
2425 20 : if (!fmt)
2426 0 : throw(SQL, "sql.from_varchar", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2427 20 : (void)m;
2428 :
2429 :
2430 20 : if (from_string_cols(fmt, bats, nr, 0, t) < 0) {
2431 0 : GDKfree(fmt);
2432 0 : throw(SQL, "sql.from_varchar", SQLSTATE(HY013) "Multiset and/or composite type expected");
2433 : }
2434 :
2435 : /* this should parse { 1, 2,3 } and { (1,"string"), (2,"str2") } */
2436 20 : int elm = 0;
2437 20 : if (t->multiset)
2438 13 : msg = ARRAYparser(&s, fmt, nr, &elm, t);
2439 : else
2440 7 : msg = TUPLEparser(&s, fmt, nr, &elm, t);
2441 20 : GDKfree(fmt);
2442 20 : return msg;
2443 : }
2444 :
|
