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 : #include "monetdb_config.h"
14 : #include "sql_parser.h"
15 : #include "sql_symbol.h"
16 : #include "sql_semantic.h"
17 : #include "sql_env.h"
18 : #include "sql_privileges.h"
19 : #include "sql_string.h"
20 : #include "sql_atom.h"
21 :
22 : #include <unistd.h>
23 : #include <string.h>
24 : #include <ctype.h>
25 :
26 : #include "rel_semantic.h"
27 :
28 : /*
29 : * For debugging purposes we need to be able to convert sql-tokens to
30 : * a string representation.
31 : *
32 : * !SQL ERROR <sqlerrno> : <details>
33 : * !SQL DEBUG <details>
34 : * !SQL WARNING <details>
35 : * !SQL <informative message, reserved for ...rows affected>
36 : */
37 :
38 : void
39 390399 : sql_add_param(mvc *sql, const char *name, sql_subtype *st)
40 : {
41 390399 : sql_arg *a = SA_ZNEW(sql->sa, sql_arg);
42 :
43 390399 : if (name)
44 388784 : a->name = sa_strdup(sql->sa, name);
45 390399 : if (st && st->type)
46 388773 : a->type = *st;
47 390399 : a->inout = ARG_IN;
48 390399 : if (name && strcmp(name, "*") == 0)
49 4 : a->type = *sql_bind_localtype("int");
50 390399 : if (!sql->params)
51 230319 : sql->params = sa_list(sql->sa);
52 390399 : list_append(sql->params, a);
53 390399 : }
54 :
55 : int
56 98299 : sql_bind_param(mvc *sql, const char *name)
57 : {
58 98299 : node *n;
59 98299 : int nr = 0;
60 :
61 98299 : if (sql->params) {
62 212230 : for (n = sql->params->h; n; n = n->next, nr++) {
63 207805 : sql_arg *a = n->data;
64 :
65 207805 : if (a->name && strcmp(a->name, name) == 0)
66 90141 : return nr;
67 : }
68 : }
69 : return -1;
70 : }
71 :
72 : sql_arg *
73 93316 : sql_bind_paramnr(mvc *sql, int nr)
74 : {
75 93316 : int i=0;
76 93316 : node *n;
77 :
78 93316 : if (sql->params && nr < list_length(sql->params)) {
79 684068 : for (n = sql->params->h, i=0; n && i<nr; n = n->next, i++)
80 : ;
81 :
82 93316 : if (n)
83 93316 : return n->data;
84 : }
85 : return NULL;
86 : }
87 :
88 : sql_arg *
89 6 : sql_find_param(mvc *sql, char *name)
90 : {
91 9 : for (node *n = sql->params->h; n; n = n->next) {
92 8 : sql_arg *a = n->data;
93 8 : if (strcmp(a->name, name) == 0)
94 5 : return a;
95 : }
96 : return NULL;
97 : }
98 :
99 : void
100 785246 : sql_destroy_params(mvc *sql)
101 : {
102 785246 : sql->params = NULL;
103 785246 : }
104 :
105 : sql_schema *
106 1725408 : cur_schema(mvc *sql)
107 : {
108 1725408 : return sql->session->schema;
109 : }
110 :
111 : sql_schema *
112 565550 : tmp_schema(mvc *sql)
113 : {
114 565550 : return mvc_bind_schema(sql, "tmp");
115 : }
116 :
117 : #define DO_NOTHING(x) ;
118 :
119 : /* as we don't have OOP in C, I prefer a single macro with the search path algorithm to passing function pointers */
120 : #define search_object_on_path(CALL, EXTRA_CONDITION, EXTRA, ERROR_CODE, show_error) \
121 : do { \
122 : sql_schema *next = NULL; \
123 : \
124 : if (sname) { /* user has explicitly typed the schema, so either the object is there or we return error */ \
125 : if (!(next = mvc_bind_schema(sql, sname))) \
126 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(3F000) "%s: no such schema '%s'", error, sname); \
127 : EXTRA_CONDITION(EXTRA); /* for functions without schema, 'sys' is a valid schema to bind them */ \
128 : if (!res) { \
129 : CALL; \
130 : } \
131 : } else { \
132 : sql_schema *cur = cur_schema(sql); \
133 : char *session_schema = cur->base.name; \
134 : \
135 : EXTRA; \
136 : if (!res && !sql->schema_path_has_tmp && strcmp(session_schema, "tmp") != 0) { /* if 'tmp' is not in the search path, search it before all others */ \
137 : next = tmp_schema(sql); \
138 : CALL; \
139 : } \
140 : if (!res) { /* then current session's schema */ \
141 : next = cur; \
142 : CALL; \
143 : } \
144 : if (!res) { \
145 : /* object not found yet, look inside search path */ \
146 : for (node *n = sql->schema_path->h ; n && !res ; n = n->next) { \
147 : str p = (str) n->data; \
148 : if (strcmp(session_schema, p) != 0 && (next = mvc_bind_schema(sql, p))) \
149 : CALL; \
150 : } \
151 : } \
152 : if (!res && !sql->schema_path_has_sys && strcmp(session_schema, "sys") != 0) { /* if 'sys' is not in the current path search it next */ \
153 : next = mvc_bind_schema(sql, "sys"); \
154 : CALL; \
155 : } \
156 : } \
157 : if (!res && show_error) \
158 : return sql_error(sql, ERR_NOTFOUND, ERROR_CODE "%s: no such %s %s%s%s'%s'", error, objstr, sname ? "'":"", sname ? sname : "", sname ? "'.":"", name); \
159 : } while (0)
160 :
161 : #define table_extra \
162 : do { \
163 : if (s) { \
164 : next = s; /* there's a default schema to search before all others, e.g. bind a child table from a merge table */ \
165 : res = mvc_bind_table(sql, next, name); \
166 : } \
167 : if (!res && strcmp(objstr, "table") == 0 && (res = stack_find_table(sql, name))) /* for tables, first try a declared table from the stack */ \
168 : return res; \
169 : } while (0)
170 :
171 : sql_table *
172 689976 : find_table_or_view_on_scope(mvc *sql, sql_schema *s, const char *sname, const char *name, const char *error, bool isView)
173 : {
174 689976 : const char *objstr = isView ? "view" : "table";
175 689976 : sql_table *res = NULL;
176 :
177 690541 : search_object_on_path(res = mvc_bind_table(sql, next, name), DO_NOTHING, table_extra, SQLSTATE(42S02), true);
178 : return res;
179 : }
180 :
181 : sql_sequence *
182 1481 : find_sequence_on_scope(mvc *sql, const char *sname, const char *name, const char *error)
183 : {
184 1481 : const char objstr[] = "sequence";
185 1481 : sql_sequence *res = NULL;
186 :
187 1483 : search_object_on_path(res = find_sql_sequence(sql->session->tr, next, name), DO_NOTHING, ;, SQLSTATE(42000), true);
188 : return res;
189 : }
190 :
191 : sql_idx *
192 218 : find_idx_on_scope(mvc *sql, const char *sname, const char *name, const char *error)
193 : {
194 218 : const char objstr[] = "index";
195 218 : sql_idx *res = NULL;
196 :
197 292 : search_object_on_path(res = mvc_bind_idx(sql, next, name), DO_NOTHING, ;, SQLSTATE(42S12), true);
198 : return res;
199 : }
200 :
201 : sql_type *
202 5 : find_type_on_scope(mvc *sql, const char *sname, const char *name, const char *error)
203 : {
204 5 : const char objstr[] = "type";
205 5 : sql_type *res = NULL;
206 :
207 7 : search_object_on_path(res = schema_bind_type(sql, next, name), DO_NOTHING, ;, SQLSTATE(42S01), true);
208 : return res;
209 : }
210 :
211 : sql_trigger *
212 96 : find_trigger_on_scope(mvc *sql, const char *sname, const char *name, const char *error)
213 : {
214 96 : const char objstr[] = "trigger";
215 96 : sql_trigger *res = NULL;
216 :
217 118 : search_object_on_path(res = mvc_bind_trigger(sql, next, name), DO_NOTHING, ;, SQLSTATE(3F000), true);
218 : return res;
219 : }
220 :
221 : /* A variable can be any of the following, from the innermost to the outermost:
222 : - 'parameter of the function' (ie in the param list)
223 : - local variable, declared earlier
224 : - global variable, also declared earlier
225 : */
226 : #define variable_extra \
227 : do { \
228 : if (!res) { \
229 : if ((*var = stack_find_var_frame(sql, name, level))) { /* check if variable is known from the stack */ \
230 : *tpe = &((*var)->var.tpe); \
231 : res = true; \
232 : } else if ((nr = sql_bind_param(sql, name)) >= 0) { /* then if it is a parameter */ \
233 : *a = sql_bind_paramnr(sql, nr); \
234 : *tpe = &((*a)->type); \
235 : *level = 1; \
236 : res = true; \
237 : } \
238 : } \
239 : } while (0)
240 :
241 : #define var_find_on_global \
242 : do { \
243 : if ((*var = find_global_var(sql, next, name))) { /* then if it is a global var */ \
244 : *tpe = &((*var)->var.tpe); \
245 : *level = 0; \
246 : res = true; \
247 : } \
248 : } while (0)
249 :
250 : bool
251 208250 : find_variable_on_scope(mvc *sql, const char *sname, const char *name, sql_var **var, sql_arg **a, sql_subtype **tpe, int *level, const char *error)
252 : {
253 208250 : const char objstr[] = "variable";
254 208250 : bool res = false;
255 208250 : int nr = 0;
256 :
257 208250 : (void)nr;
258 213333 : search_object_on_path(var_find_on_global, DO_NOTHING, variable_extra, SQLSTATE(42000), true);
259 : return res;
260 : }
261 :
262 : static sql_subfunc *
263 999716 : _dup_subaggr(allocator *sa, sql_func *a, sql_subtype *member)
264 : {
265 999716 : node *tn;
266 999716 : unsigned int scale = 0, digits = 0;
267 999716 : sql_subfunc *ares = SA_ZNEW(sa, sql_subfunc);
268 :
269 :
270 999715 : ares->func = a;
271 999715 : if (IS_FILT(a)) {
272 4816 : ares->res = sa_list(sa);
273 4816 : list_append(ares->res, sql_bind_localtype("bit"));
274 994899 : } else if (IS_FUNC(a) || IS_UNION(a) || IS_ANALYTIC(a) || IS_AGGR(a)) { /* not needed for PROC */
275 957273 : if (a->res) {
276 957273 : ares->res = sa_list(sa);
277 2000275 : for(tn = a->res->h; tn; tn = tn->next) {
278 1043001 : sql_arg *rarg = tn->data;
279 1043001 : sql_subtype *res, *r = &rarg->type;
280 :
281 1043001 : if (a->fix_scale == SCALE_EQ && !IS_AGGR(a)) {
282 : res = r;
283 : } else {
284 865313 : digits = r->digits;
285 865313 : scale = r->scale;
286 : /* same scale as the input */
287 865313 : if (member && (member->scale != scale ||
288 179749 : (digits != member->digits && !EC_NUMBER(member->type->eclass)))) {
289 92454 : if (member->digits > digits)
290 : digits = member->digits;
291 : scale = member->scale;
292 : }
293 : /* same type as the input */
294 865313 : if (r->type->eclass == EC_ANY && member) {
295 13309 : r = member;
296 13309 : digits = member->digits;
297 : }
298 865313 : if (!EC_SCALE(r->type->eclass))
299 865313 : scale = 0;
300 865313 : res = sql_create_subtype(sa, r->type, digits, scale);
301 : }
302 1043002 : list_append(ares->res, res);
303 : }
304 : }
305 : }
306 999716 : return ares;
307 : }
308 :
309 :
310 :
311 : static sql_subfunc *
312 135062 : func_cmp(allocator *sa, sql_func *f, const char *name, int nrargs)
313 : {
314 135062 : if (strcmp(f->base.name, name) == 0) {
315 135062 : if (f->vararg)
316 : //return (f->type == F_AGGR) ? _dup_subaggr(sa, f, NULL) : sql_dup_subfunc(sa, f, NULL, NULL);
317 2 : return _dup_subaggr(sa, f, NULL);
318 135060 : if (nrargs < 0 || list_length(f->ops) == nrargs)
319 : //return (f->type == F_AGGR) ? _dup_subaggr(sa, f, NULL) : sql_dup_subfunc(sa, f, NULL, NULL);
320 134270 : return _dup_subaggr(sa, f, NULL);
321 : }
322 : return NULL;
323 : }
324 :
325 : static sql_subfunc *
326 694276 : sql_find_func_internal(mvc *sql, list *ff, const char *fname, int nrargs, sql_ftype type, bool private, sql_subfunc *prev)
327 : {
328 694276 : int key = hash_key(fname);
329 694276 : sql_subfunc *res = NULL;
330 694276 : int found = 0;
331 694276 : sql_ftype filt = (type == F_FUNC)?F_FILT:type;
332 :
333 694276 : if (ff) {
334 694276 : if (ff->ht) {
335 694276 : sql_hash_e *he = ff->ht->buckets[key&(ff->ht->size-1)];
336 694276 : if (prev) {
337 0 : for (; he && !found; he = he->chain)
338 0 : if (he->value == prev->func)
339 0 : found = 1;
340 : }
341 7893936 : for (; he; he = he->chain) {
342 7324206 : sql_func *f = he->value;
343 :
344 7324206 : if ((f->type != type && f->type != filt) || (f->private && !private))
345 7199644 : continue;
346 124562 : if ((res = func_cmp(sql->sa, f, fname, nrargs)) != NULL)
347 124547 : return res;
348 : }
349 : } else {
350 0 : node *n = ff->h;
351 0 : if (prev) {
352 0 : for (; n && !found; n = n->next)
353 0 : if (n->data == prev->func)
354 0 : found = 1;
355 : }
356 0 : for (; n; n = n->next) {
357 0 : sql_func *f = n->data;
358 :
359 0 : if ((f->type != type && f->type != filt) || (f->private && !private))
360 0 : continue;
361 0 : if ((res = func_cmp(sql->sa, f, fname, nrargs)) != NULL)
362 0 : return res;
363 : }
364 : }
365 : }
366 : return res;
367 : }
368 :
369 : static sql_subfunc *
370 820824 : os_find_func_internal(mvc *sql, struct objectset *ff, const char *fname, int nrargs, sql_ftype type, bool private, sql_subfunc *prev)
371 : {
372 820824 : sql_subfunc *res = NULL;
373 820824 : sql_ftype filt = (type == F_FUNC)?F_FILT:type;
374 :
375 820824 : if (ff) {
376 820824 : struct os_iter oi;
377 820824 : os_iterator(&oi, ff, sql->session->tr, fname);
378 984325 : for (sql_base *b = oi_next(&oi); b; b = oi_next(&oi)) {
379 173226 : sql_func *f = (sql_func*)b;
380 173226 : if (prev && prev->func != f) {
381 0 : continue;
382 173226 : } else if (prev) {
383 0 : prev = NULL;
384 0 : continue;
385 : }
386 :
387 173226 : if ((f->type != type && f->type != filt) || (f->private && !private))
388 162726 : continue;
389 10500 : if ((res = func_cmp(sql->sa, f, fname, nrargs)) != NULL)
390 9725 : return res;
391 : }
392 : }
393 : return res;
394 : }
395 :
396 : #define functions_without_schema(X) if (strcmp(sname, "sys") == 0) X
397 :
398 : #define find_func_extra \
399 : do { \
400 : if (!res && (res = sql_find_func_internal(sql, funcs, name, nrargs, type, private, prev))) /* search system wide functions first */ \
401 : return res; \
402 : } while (0)
403 :
404 : sql_subfunc *
405 694977 : sql_find_func(mvc *sql, const char *sname, const char *name, int nrargs, sql_ftype type, bool private, sql_subfunc *prev)
406 : {
407 694977 : char *F = NULL, *objstr = NULL;
408 694977 : const char error[] = "CATALOG";
409 694977 : sql_subfunc *res = NULL;
410 :
411 694977 : FUNC_TYPE_STR(type, F, objstr);
412 694977 : (void) F; /* not used */
413 :
414 694977 : assert(nrargs >= -1);
415 :
416 929120 : search_object_on_path(res = os_find_func_internal(sql, next->funcs, name, nrargs, type, private, prev), functions_without_schema, find_func_extra, "", false); //SQLSTATE(42000), true);
417 : return res;
418 : }
419 :
420 : sql_subfunc *
421 387527 : sql_bind_func(mvc *sql, const char *sname, const char *fname, sql_subtype *tp1, sql_subtype *tp2, sql_ftype type, bool private, bool exact)
422 : {
423 387527 : list *l = sa_list(sql->sa);
424 :
425 387527 : if (tp1)
426 377211 : list_append(l, tp1);
427 387526 : if (tp2)
428 228183 : list_append(l, tp2);
429 387526 : return sql_bind_func_(sql, sname, fname, l, type, private, exact);
430 : }
431 :
432 : sql_subfunc *
433 175 : sql_bind_func3(mvc *sql, const char *sname, const char *fname, sql_subtype *tp1, sql_subtype *tp2, sql_subtype *tp3, sql_ftype type, bool private)
434 : {
435 175 : list *l = sa_list(sql->sa);
436 :
437 175 : if (tp1)
438 175 : list_append(l, tp1);
439 175 : if (tp2)
440 175 : list_append(l, tp2);
441 175 : if (tp3)
442 175 : list_append(l, tp3);
443 175 : return sql_bind_func_(sql, sname, fname, l, type, private, false);
444 : }
445 :
446 : static int /* bind the function version with more identical type matches */
447 784103 : next_cand_points(list *args, list *ops)
448 : {
449 784103 : int res = 0;
450 :
451 784103 : if (!list_empty(args) && !list_empty(ops))
452 2082191 : for (node *n = args->h, *m = ops->h; n && m ; n = n->next, m = m->next) {
453 1319508 : sql_arg *a = n->data;
454 1319508 : sql_subtype *t = m->data;
455 :
456 1319508 : if (a->type.type->eclass == EC_ANY)
457 681304 : res += 100;
458 638204 : else if (t)
459 638204 : res += a->type.type->base.id == t->type->base.id;
460 : }
461 784102 : res += (list_empty(args) && list_empty(ops));
462 784101 : return res;
463 : }
464 :
465 : static int
466 8208011 : score_func( sql_func *f, list *tl, bool exact, bool *downcast)
467 : {
468 8208011 : int score = 0;
469 8208011 : node *n, *m;
470 :
471 8208011 : if (exact)
472 743349 : return next_cand_points(f->ops, tl);
473 7464662 : if (!tl)
474 : return 1;
475 7464662 : if (f->vararg)
476 : return 1;
477 7464280 : unsigned int digits = 0, scale = 0;
478 7464280 : if (f->fix_scale == SCALE_FIX) {
479 3168304 : for (n = f->ops->h, m = tl->h; n && m; n = n->next, m = m->next) {
480 2110634 : sql_subtype *t = m->data;
481 :
482 2110634 : if (!t)
483 51 : continue;
484 2110583 : if (t->type->eclass == EC_DEC) {
485 8142 : if (digits < t->digits)
486 : digits = t->digits;
487 8142 : if (scale < t->scale)
488 : scale = t->scale;
489 : }
490 : }
491 3168304 : for (n = f->ops->h, m = tl->h; n && m; n = n->next, m = m->next) {
492 2110634 : sql_arg *a = n->data;
493 2110634 : sql_subtype *t = m->data;
494 :
495 2110634 : if (!t)
496 51 : continue;
497 2110583 : if (a->type.type->eclass == EC_DEC && t->type->eclass == EC_NUM) {
498 1158375 : if (digits < scale + bits2digits(t->digits))
499 816615 : digits = scale + bits2digits(t->digits);
500 : }
501 : }
502 : }
503 7464280 : int nr_strconverts = 0;
504 16484693 : for (n = f->ops->h, m = tl->h; n && m; n = n->next, m = m->next) {
505 11829848 : sql_arg *a = n->data;
506 11829848 : sql_subtype *t = m->data;
507 :
508 11829848 : if (!t) { /* parameters */
509 501 : int ec = a->type.type->eclass;
510 501 : score++;
511 501 : if (ec == EC_DEC)
512 : return 0;
513 325 : if (a && EC_NUMBER(ec) && !EC_INTERVAL(ec))
514 218 : score += a->type.type->localtype * 10; /* premium on larger types */
515 107 : else if (a) /* all other types */
516 107 : score += 99;
517 325 : continue;
518 : }
519 :
520 11829347 : int nscore = sql_type_convert_preference(t->type->eclass, a->type.type->eclass);
521 : /* EX_EXTERNAL can only convert between equal implementation types */
522 11829344 : if (nscore == 0 &&
523 2606415 : t->type->eclass == a->type.type->eclass &&
524 573 : t->type->eclass == EC_EXTERNAL &&
525 573 : t->type->localtype == a->type.type->localtype)
526 : nscore = 10;
527 9223493 : if (nscore &&
528 9223493 : t->type->eclass == EC_NUM && a->type.type->eclass == EC_DEC &&
529 3441160 : t->type->localtype > a->type.type->localtype)
530 713920 : *downcast = true;
531 9223493 : if (nscore == 0)
532 : return 0;
533 9223493 : nscore *= 100; /* first based on preferred conversions */
534 9223493 : if (nscore < 0) {
535 294972 : *downcast = true;
536 294972 : nscore = -nscore;
537 : }
538 9223493 : score += nscore;
539 9223493 : if (EC_VARCHAR(t->type->eclass) && EC_NUMBER(a->type.type->eclass))
540 1227 : nr_strconverts++;
541 9223493 : if (nr_strconverts > 1)
542 : return 0;
543 :
544 9223457 : if (f->fix_scale == SCALE_FIX && a->type.type->eclass == EC_DEC && digits > a->type.type->digits) /* doesn't fit */
545 : return 0;
546 : /* sql types equal but implementation differences */
547 9020088 : else if (t->type->eclass == EC_BIT && a->type.type->eclass == EC_NUM && t->type->localtype <= a->type.type->localtype) /* convert bits into smallest number */
548 146 : score += (11 + t->type->localtype - a->type.type->localtype) * 8;
549 : /* sql types close but digits/scale diffs */
550 9019942 : else if (t->type->eclass == EC_NUM && a->type.type->eclass == EC_DEC && /*t->type->localtype <= a->type.type->localtype*/ bits2digits(t->digits) < a->type.type->digits)
551 : //score += (10 + t->type->localtype - a->type.type->localtype) * 8;
552 2520139 : score += (38 + bits2digits(t->digits) - a->type.type->digits);
553 : /* same class over converting to other class */
554 6499803 : else if (t->type->eclass == a->type.type->eclass && t->type->localtype <= a->type.type->localtype) {
555 3478797 : score += (11 + t->type->localtype - a->type.type->localtype) * 4;
556 : /* handle intervals (day, hour, minutes, second) mapped
557 : * within same eclass and implementation type. */
558 3478797 : if (t->type->eclass == a->type.type->eclass && t->type->eclass == EC_SEC)
559 3096 : score += ((t->type->digits > 4 && a->type.type->digits > 4) ||
560 3478 : (t->type->digits <= 4 && a->type.type->digits <= 4)) * 4;
561 : }
562 : /* conversion matrix needs check if conversion is possible */
563 3021006 : else if (t->type->eclass == a->type.type->eclass) {
564 1110440 : if (t->type->localtype <= a->type.type->localtype) {
565 0 : int nscore = sql_type_convert_preference(t->type->eclass, a->type.type->eclass);
566 0 : score += (10 + t->type->localtype - a->type.type->localtype) * nscore;
567 1110440 : } else if (t->type->eclass == EC_NUM || t->type->eclass == EC_FLT) { /* down casting */
568 1095507 : *downcast = true;
569 1095507 : score += 10 * (10 - t->type->localtype - a->type.type->localtype);
570 : }
571 : }
572 : }
573 4654845 : score += (list_empty(tl) && list_empty(f->ops));
574 4654843 : return score;
575 : }
576 :
577 :
578 : static sql_subfunc *
579 1643575 : sql_bind_func__(mvc *sql, list *ff, const char *fname, list *ops, sql_ftype type, bool private, bool exact)
580 : {
581 1643575 : sql_ftype filt = (type == F_FUNC)?F_FILT:type;
582 1643575 : sql_subtype *input_type = NULL;
583 1643575 : sql_func *cand = NULL, *dcand = NULL;
584 1643575 : int points = 0, dpoints = 0;
585 :
586 1643575 : if (ops && ops->h)
587 1603690 : input_type = ops->h->data;
588 :
589 1643575 : assert(ff==funcs);
590 1643575 : if (ff) {
591 1643575 : if (ff->ht) {
592 1643575 : int key = hash_key(fname);
593 1643575 : sql_hash_e *he = ff->ht->buckets[key&(ff->ht->size-1)];
594 9948505 : for (; he; he = he->chain) {
595 8304931 : sql_func *f = he->value;
596 8304931 : bool downcast = false;
597 :
598 8304931 : if ((f->type != type && f->type != filt) || (f->private && !private))
599 340832 : continue;
600 7964099 : if (strcmp(f->base.name, fname) == 0 && ((!exact && (list_length(f->ops) == list_length(ops) || (list_length(f->ops) <= list_length(ops) && f->vararg))) || (exact && list_cmp(f->ops, ops, (fcmp) &arg_subtype_cmp) == 0))) {
601 7835779 : int npoints = score_func(f, ops, exact, &downcast);
602 7835778 : if (downcast) {
603 1862820 : if ((!dcand && (npoints || exact)) || (dcand && npoints > dpoints)) {
604 7964098 : dcand = f;
605 7964098 : dpoints = npoints;
606 : }
607 : } else {
608 5972958 : if ((!cand && (npoints || exact)) || (cand && npoints > points)) {
609 7964098 : cand = f;
610 7964098 : points = npoints;
611 : }
612 : }
613 : }
614 : }
615 : } else {
616 0 : node *n;
617 0 : sql_base_loop(ff, n) {
618 0 : sql_func *f = n->data;
619 0 : bool downcast = false;
620 :
621 0 : if ((f->type != type && f->type != filt) || (f->private && !private))
622 0 : continue;
623 0 : if (strcmp(f->base.name, fname) == 0 && ((!exact && (list_length(f->ops) == list_length(ops) || (list_length(f->ops) <= list_length(ops) && f->vararg))) || (exact && list_cmp(f->ops, ops, (fcmp) &arg_subtype_cmp) == 0))) {
624 0 : int npoints = score_func(f, ops, exact, &downcast);
625 0 : if (downcast) {
626 0 : if ((!dcand && (npoints || exact)) || (dcand && npoints > dpoints)) {
627 0 : dcand = f;
628 0 : dpoints = npoints;
629 : }
630 : } else {
631 0 : if ((!cand && (npoints || exact)) || (cand && npoints > points)) {
632 0 : cand = f;
633 0 : points = npoints;
634 : }
635 : }
636 : }
637 : }
638 : }
639 : }
640 1643574 : if (!cand && dcand)
641 20305 : cand = dcand;
642 1643574 : if (cand && exact && type != F_AGGR)
643 418835 : return sql_dup_subfunc(sql->sa, cand, ops, NULL);
644 1224739 : if (cand)
645 : //return (type == F_AGGR) ? _dup_subaggr(sql->sa, cand, input_type) : sql_dup_subfunc(sql->sa, cand, ops, NULL);
646 1226261 : return _dup_subaggr(sql->sa, cand, (type == F_AGGR) ?input_type: NULL);
647 : return NULL;
648 : }
649 :
650 : static sql_subfunc *
651 681433 : os_bind_func__(mvc *sql, struct objectset *ff, const char *fname, list *ops, sql_ftype type, bool private, bool exact)
652 : {
653 681433 : sql_ftype filt = (type == F_FUNC)?F_FILT:type;
654 681433 : sql_subtype *input_type = NULL;
655 681433 : sql_func *cand = NULL, *dcand = NULL;
656 681433 : int points = 0, dpoints = 0;
657 :
658 681433 : if (ops && ops->h)
659 648313 : input_type = ops->h->data;
660 :
661 681433 : if (ff) {
662 681433 : struct os_iter oi;
663 681433 : os_iterator(&oi, ff, sql->session->tr, fname);
664 2269346 : for (sql_base *b = oi_next(&oi); b; b=oi_next(&oi)) {
665 1587916 : sql_func *f = (sql_func*)b;
666 1587916 : bool downcast = false;
667 :
668 1587916 : if ((f->type != type && f->type != filt) || (f->private && !private))
669 481551 : continue;
670 1106365 : if (strcmp(f->base.name, fname) == 0 && ((!exact && (list_length(f->ops) == list_length(ops) || (list_length(f->ops) <= list_length(ops) && f->vararg))) || (exact && list_cmp(f->ops, ops, (fcmp) &arg_subtype_cmp) == 0))) {
671 372231 : int npoints = score_func(f, ops, exact, &downcast);
672 372227 : if (downcast) {
673 2567 : if ((!dcand && (npoints || exact)) || (dcand && npoints > dpoints)) {
674 1106362 : dcand = f;
675 1106362 : dpoints = npoints;
676 : }
677 : } else {
678 369660 : if ((!cand && (npoints || exact)) || (cand && npoints > points)) {
679 1106362 : cand = f;
680 1106362 : points = npoints;
681 : }
682 : }
683 : }
684 : }
685 : }
686 681432 : if (!cand && dcand)
687 302 : cand = dcand;
688 681432 : if (cand && exact && type != F_AGGR)
689 170501 : return sql_dup_subfunc(sql->sa, cand, ops, NULL);
690 510931 : if (cand)
691 : //return (type == F_AGGR) ? _dup_subaggr(sql->sa, cand, input_type) : sql_dup_subfunc(sql->sa, cand, ops, NULL);
692 323918 : return _dup_subaggr(sql->sa, cand, (type == F_AGGR) ?input_type: NULL);
693 : return NULL;
694 : }
695 :
696 : #define sql_bind_func__extra \
697 : do { \
698 : if (!res && (res = sql_bind_func__(sql, funcs, name, ops, type, private, exact))) /* search system wide functions first */ \
699 : return res; \
700 : } while (0)
701 :
702 : sql_subfunc *
703 1669376 : sql_bind_func_(mvc *sql, const char *sname, const char *name, list *ops, sql_ftype type, bool private, bool exact)
704 : {
705 1669376 : char *F = NULL, *objstr = NULL;
706 1669376 : const char error[] = "CATALOG";
707 1669376 : sql_subfunc *res = NULL;
708 :
709 1669376 : FUNC_TYPE_STR(type, F, objstr);
710 1669376 : (void) F; /* not used */
711 :
712 1670930 : search_object_on_path(res = os_bind_func__(sql, next->funcs, name, ops, type, private, exact), functions_without_schema, sql_bind_func__extra, SQLSTATE(42000), true);
713 : return res;
714 : }
715 :
716 : static sql_subfunc *
717 40754 : sql_bind_func_result_internal(mvc *sql, list *ff, const char *fname, sql_ftype type, bool private, list *ops, sql_subtype *res)
718 : {
719 40754 : sql_subtype *tp = sql_bind_localtype("bit");
720 40754 : sql_func *cand = NULL;
721 40754 : int points = 0, npoints = 0;
722 :
723 40754 : if (ff) {
724 40754 : if (ff->ht) {
725 40754 : int key = hash_key(fname);
726 40754 : sql_hash_e *he = ff->ht->buckets[key&(ff->ht->size-1)];
727 143968 : for (; he; he = he->chain) {
728 103214 : sql_func *f = he->value;
729 103214 : sql_arg *firstres = NULL;
730 :
731 103214 : if ((!f->res && !IS_FILT(f)) || (f->private && !private))
732 0 : continue;
733 103214 : firstres = IS_FILT(f)?tp->type:f->res->h->data;
734 103214 : if (strcmp(f->base.name, fname) == 0 && f->type == type && (is_subtype(&firstres->type, res) || firstres->type.type->eclass == EC_ANY) && list_cmp(f->ops, ops, (fcmp) &arg_subtype_cmp) == 0) {
735 40753 : npoints = next_cand_points(f->ops, ops);
736 :
737 40753 : if (!cand || npoints > points) {
738 103214 : cand = f;
739 103214 : points = npoints;
740 : }
741 : }
742 : }
743 : } else {
744 0 : node *n;
745 0 : sql_base_loop( ff, n) {
746 0 : sql_func *f = n->data;
747 0 : sql_arg *firstres = NULL;
748 :
749 0 : if ((!f->res && !IS_FILT(f)) || (f->private && !private))
750 0 : continue;
751 0 : firstres = IS_FILT(f)?tp->type:f->res->h->data;
752 0 : if (strcmp(f->base.name, fname) == 0 && f->type == type && (is_subtype(&firstres->type, res) || firstres->type.type->eclass == EC_ANY) && list_cmp(f->ops, ops, (fcmp) &arg_subtype_cmp) == 0) {
753 0 : npoints = next_cand_points(f->ops, ops);
754 :
755 0 : if (!cand || npoints > points) {
756 0 : cand = f;
757 0 : points = npoints;
758 : }
759 : }
760 : }
761 : }
762 : }
763 40754 : if (cand)
764 40753 : return (type == F_AGGR) ? _dup_subaggr(sql->sa, cand, NULL) : sql_dup_subfunc(sql->sa, cand, ops, NULL);
765 : return NULL;
766 : }
767 :
768 : static sql_subfunc *
769 1 : os_bind_func_result_internal(mvc *sql, struct objectset *ff, const char *fname, sql_ftype type, bool private, list *ops, sql_subtype *res)
770 : {
771 1 : sql_subtype *tp = sql_bind_localtype("bit");
772 1 : sql_func *cand = NULL;
773 1 : int points = 0, npoints = 0;
774 :
775 1 : if (ff) {
776 1 : struct os_iter oi;
777 1 : os_iterator(&oi, ff, sql->session->tr, fname);
778 2 : for (sql_base *b = oi_next(&oi); b; b=oi_next(&oi)) {
779 1 : sql_func *f = (sql_func*)b;
780 1 : sql_arg *firstres = NULL;
781 :
782 1 : if ((!f->res && !IS_FILT(f)) || (f->private && !private))
783 0 : continue;
784 1 : firstres = IS_FILT(f)?tp->type:f->res->h->data;
785 1 : if (strcmp(f->base.name, fname) == 0 && f->type == type && (is_subtype(&firstres->type, res) || firstres->type.type->eclass == EC_ANY) && list_cmp(f->ops, ops, (fcmp) &arg_subtype_cmp) == 0) {
786 1 : npoints = next_cand_points(f->ops, ops);
787 :
788 1 : if (!cand || npoints > points) {
789 1 : cand = f;
790 1 : points = npoints;
791 : }
792 : }
793 : }
794 : }
795 1 : if (cand)
796 1 : return (type == F_AGGR) ? _dup_subaggr(sql->sa, cand, NULL) : sql_dup_subfunc(sql->sa, cand, ops, NULL);
797 : return NULL;
798 : }
799 :
800 : #define sql_bind_func_result_extra \
801 : do { \
802 : if (!res) \
803 : res = sql_bind_func_result_internal(sql, funcs, name, type, private, ops, r_res); /* search system wide functions first */ \
804 : } while (0)
805 :
806 :
807 : sql_subfunc *
808 40754 : sql_bind_func_result(mvc *sql, const char *sname, const char *name, sql_ftype type, bool private, sql_subtype *r_res, int nargs, ...)
809 : {
810 40754 : char *F = NULL, *objstr = NULL;
811 40754 : const char error[] = "CATALOG";
812 40754 : sql_subfunc *res = NULL;
813 40754 : list *ops = sa_list(sql->sa);
814 40754 : va_list valist;
815 :
816 40754 : FUNC_TYPE_STR(type, F, objstr);
817 40754 : (void) F; /* not used */
818 :
819 40754 : va_start(valist, nargs);
820 123725 : for (int i = 0; i < nargs; i++) {
821 82971 : sql_type *tpe = va_arg(valist, sql_type*);
822 82971 : list_append(ops, tpe);
823 : }
824 40754 : va_end(valist);
825 :
826 40754 : search_object_on_path(res = os_bind_func_result_internal(sql, next->funcs, name, type, private, ops, r_res), functions_without_schema, sql_bind_func_result_extra, SQLSTATE(42000), true);
827 40754 : if (res) /* make sure we have the correct result type */
828 40754 : res->res->h->data = r_res;
829 40754 : return res;
830 : }
831 :
832 : static list *
833 5336 : sql_find_funcs_by_name_internal(mvc *sql, list *ff, const char *fname, sql_ftype type, bool private)
834 : {
835 5336 : int key = hash_key(fname);
836 5336 : list *res = NULL;
837 :
838 5336 : if (ff) {
839 5336 : if (ff->ht) {
840 5336 : for (sql_hash_e *he = ff->ht->buckets[key&(ff->ht->size-1)]; he; he = he->chain) {
841 0 : sql_func *f = he->value;
842 :
843 0 : if (f->type != type || (f->private && !private))
844 0 : continue;
845 0 : if (strcmp(f->base.name, fname) == 0) {
846 0 : if (!res)
847 0 : res = sa_list(sql->sa);
848 0 : list_append(res, f);
849 : }
850 : }
851 : } else {
852 0 : node *n;
853 0 : sql_base_loop( ff, n) {
854 0 : sql_func *f = n->data;
855 :
856 0 : if (f->type != type || (f->private && !private))
857 0 : continue;
858 0 : if (strcmp(f->base.name, fname) == 0) {
859 0 : if (!res)
860 0 : res = sa_list(sql->sa);
861 0 : list_append(res, f);
862 : }
863 : }
864 : }
865 : }
866 5336 : return res;
867 : }
868 :
869 : static list *
870 9212 : os_find_funcs_by_name_internal(mvc *sql, struct objectset *ff, const char *fname, sql_ftype type, bool private)
871 : {
872 9212 : list *res = NULL;
873 :
874 9212 : if (ff) {
875 9212 : struct os_iter oi;
876 9212 : os_iterator(&oi, ff, sql->session->tr, fname);
877 15054 : for (sql_base *b = oi_next(&oi); b; b=oi_next(&oi)) {
878 5842 : sql_func *f = (sql_func*)b;
879 :
880 5842 : if (f->type != type || (f->private && !private))
881 1346 : continue;
882 4496 : if (strcmp(f->base.name, fname) == 0) {
883 4496 : if (!res)
884 4468 : res = sa_list(sql->sa);
885 4496 : list_append(res, f);
886 : }
887 : }
888 : }
889 9212 : return res;
890 : }
891 :
892 : #define sql_find_funcs_by_name_extra \
893 : do { \
894 : if (!res && (res = sql_find_funcs_by_name_internal(sql, funcs, name, type, private))) /* search system wide functions first */ \
895 : return res; \
896 : } while (0)
897 :
898 : list *
899 5817 : sql_find_funcs_by_name(mvc *sql, const char *sname, const char *name, sql_ftype type, bool private)
900 : {
901 5817 : char *F = NULL, *objstr = NULL;
902 5817 : const char error[] = "CATALOG";
903 5817 : list *res = NULL;
904 :
905 5817 : FUNC_TYPE_STR(type, F, objstr);
906 5817 : (void) F; /* not used */
907 :
908 6168 : search_object_on_path(res = os_find_funcs_by_name_internal(sql, next->funcs, name, type, private), functions_without_schema, sql_find_funcs_by_name_extra, "", false);
909 : return res;
910 : }
911 :
912 : char *
913 2029433 : qname_schema(dlist *qname)
914 : {
915 2029433 : assert(qname && qname->h);
916 :
917 2029433 : if (dlist_length(qname) == 2) {
918 1208002 : return qname->h->data.sval;
919 821431 : } else if (dlist_length(qname) == 3) {
920 4 : return qname->h->next->data.sval;
921 : }
922 : return NULL;
923 : }
924 :
925 : char *
926 2039899 : qname_schema_object(dlist *qname)
927 : {
928 2039899 : assert(qname && qname->h);
929 :
930 2039899 : if (dlist_length(qname) == 1) {
931 831546 : return qname->h->data.sval;
932 1208352 : } else if (dlist_length(qname) == 2) {
933 1208348 : return qname->h->next->data.sval;
934 4 : } else if (dlist_length(qname) == 3) {
935 4 : return qname->h->next->next->data.sval;
936 : }
937 : return "unknown";
938 : }
939 :
940 : char *
941 0 : qname_catalog(dlist *qname)
942 : {
943 0 : assert(qname && qname->h);
944 :
945 0 : if (dlist_length(qname) == 3) {
946 0 : return qname->h->data.sval;
947 : }
948 : return NULL;
949 : }
950 :
951 : int
952 1558 : set_type_param(mvc *sql, sql_subtype *type, int nr)
953 : {
954 1558 : sql_arg *a = sql_bind_paramnr(sql, nr);
955 :
956 1558 : if (!a)
957 : return -1;
958 1558 : a->type = *type;
959 1558 : return 0;
960 : }
961 :
962 : /*
963 : * Find the result_datatype for certain combinations of values
964 : * (like case expressions or columns in a result of a query expression).
965 : * See standaard pages 505-507 Result of data type combinations */
966 : sql_subtype *
967 210028 : result_datatype(sql_subtype *super, sql_subtype *l, sql_subtype *r)
968 : {
969 210028 : int lclass = l->type->eclass, rclass = r->type->eclass;
970 :
971 : /* case a strings */
972 293243 : if (EC_VARCHAR(lclass) || EC_VARCHAR(rclass)) {
973 83215 : const char *tpe = "varchar";
974 83215 : unsigned int digits = 0;
975 83215 : if (!EC_VARCHAR(lclass)) {
976 498 : tpe = r->type->base.name;
977 498 : digits = (!l->digits)?0:r->digits;
978 82717 : } else if (!EC_VARCHAR(rclass)) {
979 5246 : tpe = l->type->base.name;
980 5246 : digits = (!r->digits)?0:l->digits;
981 : } else { /* both */
982 77471 : tpe = !strcmp(l->type->base.name, "varchar")?l->type->base.name:!strcmp(r->type->base.name, "varchar")?r->type->base.name:
983 7 : (l->type->base.id > r->type->base.id)?l->type->base.name:r->type->base.name;
984 77471 : digits = (!l->digits||!r->digits)?0:sql_max(l->digits, r->digits);
985 : }
986 83215 : sql_find_subtype(super, tpe, digits, 0);
987 : /* case b blob */
988 126813 : } else if (lclass == EC_BLOB || rclass == EC_BLOB) {
989 14 : *super = (lclass == EC_BLOB) ? *l : *r;
990 : /* case c all exact numeric */
991 225829 : } else if (EC_EXACTNUM(lclass) && EC_EXACTNUM(rclass)) {
992 99030 : char *tpe = (l->type->base.id > r->type->base.id)?l->type->base.name:r->type->base.name;
993 99030 : unsigned int digits = sql_max(l->digits, r->digits);
994 99030 : unsigned int scale = sql_max(l->scale, r->scale);
995 :
996 99030 : if (l->type->radix == 10 && r->type->radix == 10) {
997 90 : digits = scale + (sql_max(l->digits - l->scale, r->digits - r->scale));
998 : #ifdef HAVE_HGE
999 90 : if (digits > 38) {
1000 0 : digits = 38;
1001 : #else
1002 : if (digits > 18) {
1003 : digits = 18;
1004 : #endif
1005 0 : scale = MIN(scale, digits - 1);
1006 : }
1007 98940 : } else if (l->type->radix == 2 && r->type->radix == 10) { /* change to radix 10 */
1008 47 : digits = bits2digits(l->type->digits);
1009 47 : digits = sql_max(r->digits, digits);
1010 47 : scale = r->scale;
1011 98893 : } else if (l->type->radix == 10 && r->type->radix == 2) { /* change to radix 10 */
1012 121 : digits = bits2digits(r->type->digits);
1013 121 : digits = sql_max(l->digits, digits);
1014 121 : scale = l->scale;
1015 : }
1016 99030 : sql_find_subtype(super, tpe, digits, scale);
1017 : /* case d approximate numeric */
1018 27769 : } else if (EC_APPNUM(lclass) || EC_APPNUM(rclass)) {
1019 157 : if (!EC_APPNUM(lclass)) {
1020 45 : *super = *r;
1021 112 : } else if (!EC_APPNUM(rclass)) {
1022 91 : *super = *l;
1023 : } else { /* both */
1024 21 : char *tpe = (l->type->base.id > r->type->base.id)?l->type->base.name:r->type->base.name;
1025 21 : unsigned int digits = sql_max(l->digits, r->digits); /* bits precision */
1026 21 : sql_find_subtype(super, tpe, digits, 0);
1027 : }
1028 : /* now its getting serious, ie e any 'case e' datetime data type */
1029 : /* 'case f' interval types */
1030 : /* 'case g' boolean */
1031 : /* 'case h-l' compounds like row (tuple), etc */
1032 : } else {
1033 27612 : return supertype(super, l, r);
1034 : }
1035 : return super;
1036 : }
1037 :
1038 : char *
1039 80 : toUpperCopy(char *dest, const char *src)
1040 : {
1041 80 : size_t i, len;
1042 :
1043 80 : if (src == NULL) {
1044 0 : *dest = '\0';
1045 0 : return(dest);
1046 : }
1047 :
1048 80 : len = _strlen(src);
1049 433 : for (i = 0; i < len; i++)
1050 353 : dest[i] = (char)toupper((int)src[i]);
1051 :
1052 80 : dest[i] = '\0';
1053 80 : return(dest);
1054 : }
1055 :
1056 : static char * _symbol2string(mvc *sql, symbol *se, int expression, char **err);
1057 :
1058 : static char *
1059 1 : dlist2string(mvc *sql, dlist *l, int expression, char **err)
1060 : {
1061 1 : char *b = NULL;
1062 1 : dnode *n;
1063 :
1064 3 : for (n=l->h; n; n = n->next) {
1065 2 : char *s = NULL;
1066 :
1067 2 : if (n->type == type_string && n->data.sval)
1068 2 : s = sa_strdup(sql->ta, n->data.sval);
1069 0 : else if (n->type == type_symbol)
1070 0 : s = _symbol2string(sql, n->data.sym, expression, err);
1071 :
1072 2 : if (!s)
1073 0 : return NULL;
1074 2 : if (b) {
1075 1 : char *o = SA_NEW_ARRAY(sql->ta, char, strlen(b) + strlen(s) + 2);
1076 1 : if (o)
1077 1 : stpcpy(stpcpy(stpcpy(o, b), "."), s);
1078 0 : b = o;
1079 1 : if (b == NULL)
1080 : return NULL;
1081 : } else {
1082 : b = s;
1083 : }
1084 : }
1085 : return b;
1086 : }
1087 :
1088 : static const char *
1089 882 : symbol_escape_ident(allocator *sa, const char *s)
1090 : {
1091 882 : char *res = NULL;
1092 882 : if (s) {
1093 830 : size_t l = strlen(s);
1094 830 : char *r = SA_NEW_ARRAY(sa, char, (l * 2) + 1);
1095 :
1096 830 : res = r;
1097 6139 : while (*s) {
1098 5309 : if (*s == '"')
1099 1 : *r++ = '"';
1100 5309 : *r++ = *s++;
1101 : }
1102 830 : *r = '\0';
1103 : }
1104 882 : return res;
1105 : }
1106 :
1107 : char *
1108 1593 : _symbol2string(mvc *sql, symbol *se, int expression, char **err)
1109 : {
1110 : /* inner symbol2string uses the temporary allocator */
1111 1593 : switch (se->token) {
1112 153 : case SQL_NOP: {
1113 153 : dnode *lst = se->data.lval->h, *ops = NULL, *aux;
1114 153 : const char *op = symbol_escape_ident(sql->ta, qname_schema_object(lst->data.lval)),
1115 153 : *sname = symbol_escape_ident(sql->ta, qname_schema(lst->data.lval));
1116 153 : int i = 0, nargs = 0;
1117 153 : char** inputs = NULL, *res;
1118 153 : size_t inputs_length = 0, extra = sname ? strlen(sname) + 3 : 0;
1119 :
1120 153 : if (lst->next->next->data.lval)
1121 113 : ops = lst->next->next->data.lval->h;
1122 :
1123 294 : for (aux = ops; aux; aux = aux->next)
1124 141 : nargs++;
1125 153 : if (!(inputs = SA_ZNEW_ARRAY(sql->ta, char*, nargs)))
1126 : return NULL;
1127 :
1128 289 : for (aux = ops; aux; aux = aux->next) {
1129 139 : if (!(inputs[i] = _symbol2string(sql, aux->data.sym, expression, err))) {
1130 : return NULL;
1131 : }
1132 136 : inputs_length += strlen(inputs[i]);
1133 136 : i++;
1134 : }
1135 :
1136 300 : if ((res = SA_NEW_ARRAY(sql->ta, char, extra + strlen(op) + inputs_length + 3 + (nargs - 1 /* commas */) + 2))) {
1137 150 : char *concat = res;
1138 150 : if (sname)
1139 100 : concat = stpcpy(stpcpy(stpcpy(res, "\""), sname), "\".");
1140 150 : concat = stpcpy(stpcpy(stpcpy(concat, "\""), op), "\"(");
1141 150 : i = 0;
1142 286 : for (aux = ops; aux; aux = aux->next) {
1143 136 : concat = stpcpy(concat, inputs[i]);
1144 136 : if (aux->next)
1145 26 : concat = stpcpy(concat, ",");
1146 136 : i++;
1147 : }
1148 150 : concat = stpcpy(concat, ")");
1149 : }
1150 : return res;
1151 : }
1152 0 : case SQL_PARAMETER:
1153 0 : return sa_strdup(sql->ta, "?");
1154 193 : case SQL_NULL:
1155 193 : return sa_strdup(sql->ta, "NULL");
1156 : case SQL_ATOM:{
1157 935 : AtomNode *an = (AtomNode *) se;
1158 935 : if (an && an->a)
1159 935 : return atom2sql(sql->ta, an->a, sql->timezone);
1160 : else
1161 0 : return sa_strdup(sql->ta, "NULL");
1162 : }
1163 272 : case SQL_NEXT: {
1164 272 : const char *seq = symbol_escape_ident(sql->ta, qname_schema_object(se->data.lval)),
1165 272 : *sname = qname_schema(se->data.lval);
1166 272 : char *res;
1167 :
1168 272 : if (!sname)
1169 203 : sname = sql->session->schema->base.name;
1170 272 : sname = symbol_escape_ident(sql->ta, sname);
1171 :
1172 544 : if ((res = SA_NEW_ARRAY(sql->ta, char, strlen("next value for \"") + strlen(sname) + strlen(seq) + 5)))
1173 272 : stpcpy(stpcpy(stpcpy(stpcpy(stpcpy(res, "next value for \""), sname), "\".\""), seq), "\"");
1174 : return res;
1175 33 : } break;
1176 33 : case SQL_IDENT:
1177 : case SQL_COLUMN: {
1178 : /* can only be variables */
1179 33 : dlist *l = se->data.lval;
1180 33 : assert(l->h->type != type_lng);
1181 33 : if (expression && dlist_length(l) == 1 && l->h->type == type_string) {
1182 : /* when compiling an expression, a column of a table might be present in the symbol, so we need this case */
1183 32 : const char *op = symbol_escape_ident(sql->ta, l->h->data.sval);
1184 32 : char *res;
1185 :
1186 64 : if ((res = SA_NEW_ARRAY(sql->ta, char, strlen(op) + 3)))
1187 32 : stpcpy(stpcpy(stpcpy(res, "\""), op), "\"");
1188 32 : return res;
1189 0 : } else if (expression && dlist_length(l) == 2 && l->h->type == type_string && l->h->next->type == type_string) {
1190 0 : const char *first = symbol_escape_ident(sql->ta, l->h->data.sval),
1191 0 : *second = symbol_escape_ident(sql->ta, l->h->next->data.sval);
1192 0 : char *res;
1193 :
1194 0 : if (!first || !second)
1195 : return NULL;
1196 0 : if ((res = SA_NEW_ARRAY(sql->ta, char, strlen(first) + strlen(second) + 6)))
1197 0 : stpcpy(stpcpy(stpcpy(stpcpy(stpcpy(res, "\""), first), "\".\""), second), "\"");
1198 0 : return res;
1199 : } else {
1200 1 : char *e = dlist2string(sql, l, expression, err);
1201 1 : if (e)
1202 1 : *err = e;
1203 1 : return NULL;
1204 : }
1205 : }
1206 6 : case SQL_CAST: {
1207 6 : dlist *dl = se->data.lval;
1208 6 : char *val = NULL, *tpe = NULL, *res;
1209 :
1210 6 : if (!(val = _symbol2string(sql, dl->h->data.sym, expression, err)) || !(tpe = subtype2string2(sql->ta, &dl->h->next->data.typeval)))
1211 0 : return NULL;
1212 12 : if ((res = SA_NEW_ARRAY(sql->ta, char, strlen(val) + strlen(tpe) + 11)))
1213 6 : stpcpy(stpcpy(stpcpy(stpcpy(stpcpy(res, "cast("), val), " as "), tpe), ")");
1214 : return res;
1215 : }
1216 1 : default: {
1217 1 : const char msg[] = "SQL feature not yet available for expressions and default values: ";
1218 1 : char *tok_str = token2string(se->token);
1219 2 : if ((*err = SA_NEW_ARRAY(sql->ta, char, strlen(msg) + strlen(tok_str) + 1)))
1220 1 : stpcpy(stpcpy(*err, msg), tok_str);
1221 : }
1222 : }
1223 1 : return NULL;
1224 : }
1225 :
1226 : char *
1227 1448 : symbol2string(mvc *sql, symbol *se, int expression, char **err)
1228 : {
1229 1448 : char *res = _symbol2string(sql, se, expression, err);
1230 :
1231 1448 : if (res)
1232 1446 : res = sa_strdup(sql->sa, res);
1233 1448 : if (*err)
1234 2 : *err = sa_strdup(sql->sa, *err);
1235 1448 : sa_reset(sql->ta);
1236 1448 : return res;
1237 : }
|
