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 "rel_select.h"
15 : #include "sql_tokens.h"
16 : #include "sql_privileges.h"
17 : #include "sql_env.h"
18 : #include "sql_decimal.h"
19 : #include "sql_qc.h"
20 : #include "rel_rel.h"
21 : #include "rel_basetable.h"
22 : #include "rel_exp.h"
23 : #include "rel_xml.h"
24 : #include "rel_dump.h"
25 : #include "rel_prop.h"
26 : #include "rel_psm.h"
27 : #include "rel_schema.h"
28 : #include "rel_unnest.h"
29 : #include "rel_sequence.h"
30 : #include "rel_file_loader.h"
31 : #include "rel_proto_loader.h"
32 : #include "rel_optimizer_private.h"
33 :
34 : #define VALUE_FUNC(f) (f->func->type == F_FUNC || f->func->type == F_FILT)
35 : #define check_card(card,f) ((card == card_none && !f->res) || (CARD_VALUE(card) && f->res && VALUE_FUNC(f)) || card == card_loader || (card == card_relation && f->func->type == F_UNION))
36 :
37 : /* return all expressions, with table name == tname */
38 : static list *
39 58251 : rel_table_projections( mvc *sql, sql_rel *rel, char *tname, int level )
40 : {
41 58779 : list *exps;
42 :
43 58779 : if (mvc_highwater(sql))
44 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
45 :
46 58779 : if (!rel)
47 : return NULL;
48 :
49 58779 : if (!tname)
50 42863 : return _rel_projections(sql, rel, NULL, 1, 0, 1);
51 :
52 15916 : switch(rel->op) {
53 541 : case op_join:
54 : case op_left:
55 : case op_right:
56 : case op_full:
57 541 : exps = rel_table_projections( sql, rel->l, tname, level+1);
58 541 : if (exps)
59 : return exps;
60 20 : return rel_table_projections( sql, rel->r, tname, level+1);
61 508 : case op_semi:
62 : case op_anti:
63 : case op_select:
64 508 : return rel_table_projections( sql, rel->l, tname, level+1);
65 :
66 137 : case op_topn:
67 : case op_sample:
68 : case op_groupby:
69 : case op_union:
70 : case op_except:
71 : case op_inter:
72 : case op_project:
73 137 : if (!is_processed(rel) && level == 0)
74 0 : return rel_table_projections( sql, rel->l, tname, level+1);
75 : /* fall through */
76 : case op_munion:
77 146 : if (!is_processed(rel) && level == 0) {
78 0 : node *n = ((list*)rel->l)->h;
79 0 : if (n)
80 0 : return rel_table_projections(sql, n->data, tname, level+1);
81 : }
82 : /* fall through */
83 : case op_table:
84 : case op_basetable:
85 14867 : if (is_basetable(rel->op) && !rel->exps)
86 14213 : return rel_base_project_all(sql, rel, tname);
87 654 : if (rel->exps) {
88 654 : int rename = 0;
89 654 : node *en;
90 :
91 : /* first check alias */
92 654 : if (!is_base(rel->op) && !level) {
93 129 : list *exps = sa_list(sql->sa);
94 :
95 647 : for (en = rel->exps->h; en && !rename; en = en->next) {
96 518 : sql_exp *e = en->data;;
97 :
98 518 : if ((is_basecol(e) && exp_relname(e) && strcmp(exp_relname(e), tname) == 0) ||
99 283 : (is_basecol(e) && !exp_relname(e) && e->l && strcmp(e->l, tname) == 0)) {
100 235 : if (exp_name(e) && exps_bind_column2(exps, tname, exp_name(e), NULL))
101 : rename = 1;
102 : else
103 234 : append(exps, e);
104 : }
105 : }
106 : }
107 :
108 654 : exps = new_exp_list(sql->sa);
109 5270 : for (en = rel->exps->h; en; en = en->next) {
110 4616 : sql_exp *e = en->data;
111 4616 : if (is_basecol(e) && exp_relname(e) && strcmp(exp_relname(e), tname) == 0) {
112 4323 : if (rename)
113 2 : append(exps, exp_alias_ref(sql, e));
114 : else {
115 4321 : sql_exp *ne = exp_ref(sql, e);
116 4321 : exp_setname(sql, ne, tname, exp_name(e));
117 4321 : append(exps, ne);
118 : }
119 : }
120 4616 : if (is_basecol(e) && !exp_relname(e) && e->l && strcmp(e->l, tname) == 0) {
121 0 : if (rename)
122 0 : append(exps, exp_alias_ref(sql, e));
123 : else {
124 0 : sql_exp *ne = exp_ref(sql, e);
125 0 : exp_setname(sql, ne, tname, exp_name(e));
126 0 : append(exps, ne);
127 : }
128 : }
129 :
130 : }
131 654 : if (exps && list_length(exps))
132 : return exps;
133 : }
134 : /* fall through */
135 : default:
136 : return NULL;
137 : }
138 : }
139 :
140 : static sql_exp *
141 0 : rel_lastexp(mvc *sql, sql_rel *rel )
142 : {
143 0 : sql_exp *e;
144 :
145 0 : if (!is_processed(rel) || is_topn(rel->op) || is_sample(rel->op))
146 0 : rel = rel_parent(rel);
147 0 : assert(list_length(rel->exps));
148 0 : if (rel->op == op_project) {
149 0 : list_hash_clear(rel->exps);
150 0 : return exp_ref(sql, rel->exps->t->data);
151 : }
152 0 : assert(is_project(rel->op));
153 0 : e = rel->exps->t->data;
154 0 : return exp_ref(sql, e);
155 : }
156 :
157 : static sql_rel *
158 37435 : rel_orderby(mvc *sql, sql_rel *l)
159 : {
160 37435 : sql_rel *rel = rel_create(sql->sa);
161 37435 : if (!rel)
162 : return NULL;
163 :
164 37435 : assert(l->op == op_project && !l->r);
165 37435 : rel->l = l;
166 37435 : rel->r = NULL;
167 37435 : rel->op = op_project;
168 37435 : rel->exps = rel_projections(sql, l, NULL, 1, 0);
169 37435 : rel->card = l->card;
170 37435 : rel->nrcols = l->nrcols;
171 37435 : return rel;
172 : }
173 :
174 : /* forward refs */
175 : static sql_rel * rel_setquery(sql_query *query, symbol *sq);
176 : static sql_rel * rel_joinquery(sql_query *query, symbol *sq, list *refs);
177 :
178 : static sql_rel *
179 211629 : rel_table_optname(mvc *sql, sql_rel *sq, symbol *optname, list *refs)
180 : {
181 211629 : sql_rel *osq = sq;
182 211629 : node *ne;
183 :
184 211629 : if (optname && optname->token == SQL_NAME) {
185 17338 : dlist *columnrefs = NULL;
186 17338 : char *tname = optname->data.lval->h->data.sval;
187 17338 : list *l = sa_list(sql->sa);
188 :
189 17338 : columnrefs = optname->data.lval->h->next->data.lval;
190 17338 : if (is_topn(sq->op) || is_sample(sq->op) || ((is_simple_project(sq->op) || is_groupby(sq->op)) && sq->r) || is_base(sq->op)) {
191 138 : sq = rel_project(sql->sa, sq, rel_projections(sql, sq, NULL, 1, 0));
192 138 : osq = sq;
193 : }
194 17338 : if (columnrefs && dlist_length(columnrefs) != list_length(sq->exps))
195 6 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: The number of aliases don't match the number of columns (%d != %d)", dlist_length(columnrefs), sq->nrcols);
196 3961 : if (columnrefs && sq->exps) {
197 3961 : dnode *d = columnrefs->h;
198 :
199 3961 : ne = sq->exps->h;
200 3961 : list_hash_clear(sq->exps);
201 17737 : for (; d && ne; d = d->next, ne = ne->next) {
202 9816 : sql_exp *e = ne->data;
203 :
204 9816 : if (exps_bind_column2(l, tname, d->data.sval, NULL))
205 1 : return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "SELECT: Duplicate column name '%s.%s'", tname, d->data.sval);
206 9815 : exp_setname(sql, e, tname, d->data.sval );
207 9815 : if (!is_intern(e))
208 9815 : set_basecol(e);
209 9815 : append(l, e);
210 : }
211 : }
212 17331 : if (!columnrefs && sq->exps) {
213 13371 : ne = sq->exps->h;
214 13371 : list_hash_clear(sq->exps);
215 127504 : for (; ne; ne = ne->next) {
216 100762 : sql_exp *e = ne->data;
217 100762 : char *name = NULL;
218 :
219 100762 : if (!is_intern(e)) {
220 100762 : if (!exp_name(e))
221 109 : name = make_label(sql->sa, ++sql->label);
222 100762 : noninternexp_setname(sql, e, tname, name);
223 100762 : set_basecol(e);
224 : }
225 : }
226 : }
227 17331 : if (refs) { /* if this relation is under a FROM clause, check for duplicate names */
228 17281 : if (list_find(refs, tname, (fcmp) &strcmp))
229 6 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: relation name \"%s\" specified more than once", tname);
230 17275 : assert(tname);
231 17275 : list_append(refs, tname);
232 : }
233 : } else {
234 194291 : if (!is_project(sq->op) || is_topn(sq->op) || is_sample(sq->op) || ((is_simple_project(sq->op) || is_groupby(sq->op)) && sq->r)) {
235 59912 : sq = rel_project(sql->sa, sq, rel_projections(sql, sq, NULL, 1, 1));
236 59912 : osq = sq;
237 : }
238 2428293 : for (ne = osq->exps->h; ne; ne = ne->next) {
239 2234002 : sql_exp *e = ne->data;
240 :
241 2234002 : if (!is_intern(e))
242 2101890 : set_basecol(e);
243 : }
244 : }
245 : return osq;
246 : }
247 :
248 : static sql_rel *
249 102959 : rel_subquery_optname(sql_query *query, symbol *ast, list *refs)
250 : {
251 102959 : mvc *sql = query->sql;
252 102959 : SelectNode *sn = (SelectNode *) ast;
253 102959 : exp_kind ek = {type_value, card_relation, TRUE};
254 102959 : sql_rel *sq = rel_subquery(query, ast, ek);
255 :
256 102959 : assert(ast->token == SQL_SELECT);
257 102959 : if (!sq)
258 : return NULL;
259 :
260 102937 : return rel_table_optname(sql, sq, sn->name, refs);
261 : }
262 :
263 : static void
264 10177 : rel_rename(mvc *sql, sql_rel *nrel, char *rname, sql_rel *brel)
265 : {
266 10177 : assert(is_project(nrel->op));
267 10177 : if (brel) {
268 156 : if (is_project(nrel->op) && nrel->exps) {
269 368 : for (node *ne = nrel->exps->h, *be = brel->exps->h; ne && be; ne = ne->next, be = be->next) {
270 212 : sql_exp *e = ne->data;
271 212 : sql_exp *b = be->data;
272 212 : char *name = NULL;
273 :
274 212 : if (!is_intern(e)) {
275 212 : if (!exp_name(e))
276 0 : name = make_label(sql->sa, ++sql->label);
277 212 : noninternexp_setname(sql, e, rname, name);
278 212 : set_basecol(e);
279 212 : e->alias.label = b->alias.label;
280 : }
281 : }
282 : }
283 156 : list_hash_clear(nrel->exps);
284 10021 : } else if (is_project(nrel->op) && nrel->exps) {
285 10021 : node *ne = nrel->exps->h;
286 :
287 41404 : for (; ne; ne = ne->next) {
288 31383 : sql_exp *e = ne->data;
289 31383 : char *name = NULL;
290 :
291 31383 : if (!is_intern(e)) {
292 31383 : if (!exp_name(e))
293 17 : name = make_label(sql->sa, ++sql->label);
294 31383 : noninternexp_setname(sql, e, rname, name);
295 31383 : set_basecol(e);
296 : }
297 : }
298 10021 : list_hash_clear(nrel->exps);
299 : }
300 10177 : }
301 :
302 : sql_rel *
303 5937 : rel_with_query(sql_query *query, symbol *q )
304 : {
305 5937 : mvc *sql = query->sql;
306 5937 : dnode *d = q->data.lval->h;
307 5937 : symbol *next = d->next->data.sym;
308 5937 : bool recursive = d->next->next->data.i_val;
309 5937 : sql_rel *rel;
310 :
311 5937 : if (!stack_push_frame(sql, NULL))
312 0 : return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
313 : /* first handle all with's (ie inlined views) */
314 16036 : for (d = d->data.lval->h; d; d = d->next) {
315 10119 : symbol *sym = d->data.sym;
316 10119 : dnode *dn = sym->data.lval->h->next;
317 10119 : char *rname = qname_schema_object(dn->data.lval);
318 10119 : sql_rel *nrel, *base_rel = NULL;
319 10119 : symbol *recursive_part = NULL;
320 10119 : sql_rel_view *recursive_union = NULL;
321 10119 : int recursive_distinct = 0;
322 :
323 10119 : if (frame_find_rel_view(sql, rname)) {
324 3 : stack_pop_frame(sql);
325 3 : return sql_error(sql, 01, SQLSTATE(42000) "View '%s' already declared", rname);
326 : }
327 10116 : if (recursive) {
328 103 : symbol *union_stmt = dn->next->next->data.sym;
329 103 : if (union_stmt->token == SQL_UNION) { /* split in base and recursive part */
330 78 : dnode *n = union_stmt->data.lval->h;
331 78 : symbol *base = n->data.sym;
332 78 : recursive_distinct = n->next->data.i_val;
333 78 : dlist *corresponding = n->next->next->data.lval;
334 78 : recursive_part = n->next->next->next->data.sym;
335 78 : if (corresponding)
336 0 : return sql_error(sql, 01, SQLSTATE(42000) "Recursive with corresponding is not supported");
337 78 : dn->next->next->data.sym = base;
338 : }
339 : }
340 10116 : nrel = rel_semantic(query, sym);
341 10116 : if (!nrel) {
342 17 : stack_pop_frame(sql);
343 17 : return NULL;
344 : }
345 10099 : if (!(recursive_union = stack_push_rel_view(sql, rname, nrel))) {
346 0 : stack_pop_frame(sql);
347 0 : return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
348 : }
349 10099 : if (recursive && recursive_part) {
350 78 : base_rel = nrel;
351 78 : rel_rename(sql, base_rel, rname, base_rel);
352 78 : dn->next->next->data.sym = recursive_part;
353 78 : set_processed(nrel);
354 78 : nrel = rel_semantic(query, sym);
355 78 : if (!nrel) {
356 0 : stack_pop_frame(sql);
357 0 : return NULL;
358 : }
359 78 : list *ls = rel_projections(sql, base_rel, NULL, 0, 1);
360 78 : list *rs = rel_projections(sql, nrel, NULL, 0, 1);
361 :
362 78 : if (!rel_is_ref(base_rel)) { /* not recursive */
363 3 : nrel = rel_setop_n_ary_check_types(sql, base_rel, nrel, ls, rs, op_munion);
364 : } else {
365 75 : base_rel->used |= statistics_gathered;
366 75 : prop *p = base_rel->p = prop_create(sql->sa, PROP_COUNT, base_rel->p);
367 75 : p->value.lval = 1000000; /* random ? */
368 :
369 : /* down cast the recursive side (on errors users should add casts on the base side) */
370 75 : list *nrs = new_exp_list(sql->sa);
371 75 : if(!nrs)
372 : return NULL;
373 :
374 174 : for (node *n = ls->h, *m = rs->h; n && m; n = n->next, m = m->next) {
375 99 : sql_subtype *t = exp_subtype(n->data);
376 99 : append(nrs, exp_check_type(sql, t, nrel, m->data, type_equal));
377 : }
378 75 : nrel = rel_project(sql->sa, nrel, nrs);
379 75 : nrel = rel_setop_n_ary(sql->sa, append(append(sa_list(sql->sa), base_rel), nrel), op_munion);
380 75 : set_recursive(nrel);
381 : }
382 78 : if (recursive_distinct)
383 34 : set_distinct(nrel);
384 78 : rel_setop_n_ary_set_exps(sql, nrel, rel_projections(sql, nrel, NULL, 0, 1), false);
385 78 : set_processed(nrel);
386 78 : recursive_union->rel_view = nrel;
387 : }
388 10099 : if (!is_project(nrel->op)) {
389 0 : if (is_topn(nrel->op) || is_sample(nrel->op)) {
390 0 : nrel = rel_project(sql->sa, nrel, rel_projections(sql, nrel, NULL, 1, 1));
391 : } else {
392 0 : stack_pop_frame(sql);
393 0 : return NULL;
394 : }
395 : }
396 10099 : rel_rename(sql, nrel, rname, base_rel);
397 : }
398 5917 : rel = rel_semantic(query, next);
399 5917 : stack_pop_frame(sql);
400 5917 : return rel;
401 : }
402 :
403 : static sql_rel *
404 61027 : query_exp_optname(sql_query *query, symbol *q, list *refs)
405 : {
406 61027 : mvc *sql = query->sql;
407 61027 : switch (q->token) {
408 995 : case SQL_WITH:
409 : {
410 995 : sql_rel *tq = rel_with_query(query, q);
411 :
412 995 : if (!tq)
413 : return NULL;
414 995 : if (q->data.lval->t->type == type_symbol)
415 995 : return rel_table_optname(sql, tq, q->data.lval->t->data.sym, refs);
416 : return tq;
417 : }
418 60032 : case SQL_JOIN:
419 : {
420 60032 : sql_rel *tq = rel_joinquery(query, q, refs);
421 :
422 60032 : if (!tq)
423 : return NULL;
424 59993 : return rel_table_optname(sql, tq, q->data.lval->t->data.sym, NULL);
425 : }
426 0 : default:
427 0 : (void) sql_error(sql, 02, SQLSTATE(42000) "case %d %s", (int) q->token, token2string(q->token));
428 : }
429 0 : return NULL;
430 : }
431 :
432 : static sql_subfunc *
433 588699 : bind_func_(mvc *sql, char *sname, char *fname, list *ops, sql_ftype type, bool private, bool *found, bool exact)
434 : {
435 588699 : sql_subfunc *sf = NULL;
436 :
437 589162 : if (sql->forward && strcmp(fname, sql->forward->base.name) == 0 &&
438 465 : list_cmp(sql->forward->ops, ops, (fcmp)&arg_subtype_cmp) == 0 &&
439 4 : execute_priv(sql, sql->forward) && type == sql->forward->type)
440 2 : return sql_dup_subfunc(sql->sa, sql->forward, NULL, NULL);
441 588697 : sf = sql_bind_func_(sql, sname, fname, ops, type, private, exact);
442 588696 : if (found)
443 588149 : *found |= sf != NULL;
444 588696 : if (sf && execute_priv(sql, sf->func))
445 : return sf;
446 : return NULL;
447 : }
448 :
449 : static sql_subfunc *
450 220229 : bind_func(mvc *sql, char *sname, char *fname, sql_subtype *t1, sql_subtype *t2, int nr, sql_ftype type, bool private, bool *found, bool exact)
451 : {
452 220229 : list *tl = sa_list(sql->sa);
453 220229 : assert(nr >= 1 && nr <= 2);
454 220229 : append(tl, t1);
455 220229 : if (nr == 2)
456 184505 : append(tl, t2);
457 220229 : sql_subfunc *sf = NULL;
458 :
459 220229 : if (sql->forward) {
460 22910 : if (execute_priv(sql, sql->forward) &&
461 22910 : strcmp(fname, sql->forward->base.name) == 0 &&
462 0 : ((!t1 && list_length(sql->forward->ops) == 0) ||
463 0 : (!t2 && list_length(sql->forward->ops) == 1 && arg_subtype_cmp(sql->forward->ops->h->data, t1) == 0) ||
464 0 : (list_length(sql->forward->ops) == 2 &&
465 0 : arg_subtype_cmp(sql->forward->ops->h->data, t1) == 0 &&
466 0 : arg_subtype_cmp(sql->forward->ops->h->next->data, t2) == 0)) && type == sql->forward->type) {
467 0 : return sql_dup_subfunc(sql->sa, sql->forward, NULL, NULL);
468 : }
469 : }
470 220229 : sf = sql_bind_func_(sql, sname, fname, tl, type, private, exact);
471 220229 : if (found)
472 220229 : *found |= sf != NULL;
473 220229 : if (sf && execute_priv(sql, sf->func))
474 : return sf;
475 : return NULL;
476 : }
477 :
478 : static sql_subfunc *
479 693717 : find_func(mvc *sql, char *sname, char *fname, int len, sql_ftype type, bool private, sql_subfunc *prev, bool *found)
480 : {
481 693717 : sql_subfunc *sf = NULL;
482 :
483 693717 : if (sql->forward && strcmp(fname, sql->forward->base.name) == 0 && list_length(sql->forward->ops) == len && execute_priv(sql, sql->forward) && type == sql->forward->type)
484 0 : return sql_dup_subfunc(sql->sa, sql->forward, NULL, NULL);
485 693717 : sf = sql_find_func(sql, sname, fname, len, type, private, prev);
486 693717 : if (found)
487 0 : *found |= sf != NULL;
488 693717 : if (sf && execute_priv(sql, sf->func))
489 : return sf;
490 : return NULL;
491 : }
492 :
493 : static sql_exp *
494 806736 : exp_fix_scale(mvc *sql, sql_subtype *ct, sql_exp *e)
495 : {
496 806736 : sql_subtype *et = exp_subtype(e);
497 :
498 806736 : if (ct->type->scale == SCALE_FIX && et->type->scale == SCALE_FIX) {
499 139309 : int scale_diff = ((int) ct->scale - (int) et->scale);
500 :
501 139309 : if (scale_diff) {
502 132 : if (scale_diff < 0)
503 : return e;
504 102 : sql_subtype st;
505 102 : int scale = ct->scale;
506 102 : int digits = ((et->type->eclass == EC_NUM)?bits2digits(et->digits):et->digits)-et->scale+scale;
507 102 : (void)sql_find_subtype(&st, ct->type->base.name, digits, scale);
508 102 : return exp_convert(sql, e, et, &st);
509 : }
510 : }
511 : return e;
512 : }
513 :
514 : static lng
515 9835 : rel_get_count(sql_rel *rel)
516 : {
517 31648 : if (!rel)
518 : return 0;
519 31644 : prop *p = NULL;
520 31644 : if (rel->p && (p = find_prop(rel->p, PROP_COUNT)) != NULL)
521 3106 : return p->value.lval;
522 28538 : else if(is_munion(rel->op)) {
523 174 : lng cnt = 0;
524 174 : list *l = rel->l;
525 522 : for (node *n = l->h; n; n = n->next) {
526 348 : lng lcnt = rel_get_count(n->data);
527 348 : if (lcnt == BUN_MAX)
528 : return BUN_MAX;
529 348 : cnt += lcnt;
530 : }
531 174 : return cnt;
532 28364 : } else if(rel->l) {
533 25650 : if (is_select(rel->op) || is_project(rel->op))
534 : return rel_get_count(rel->l);
535 : }
536 : return 0;
537 : }
538 :
539 : #define is_sum_aggr(f) (f->type == F_AGGR && strcmp(f->base.name, "sum") == 0)
540 :
541 : list *
542 821232 : check_arguments_and_find_largest_any_type(mvc *sql, sql_rel *rel, list *exps, sql_subfunc *sf, int maybe_zero_or_one, bool internal)
543 : {
544 821232 : list *nexps = new_exp_list(sql->sa);
545 821230 : sql_subtype *atp = NULL, super, *res = !list_empty(sf->res) ? sf->res->h->data: NULL;
546 821230 : unsigned int digits = 0, scale = 0;
547 :
548 : /* find largest any type argument */
549 2395367 : for (node *n = exps->h, *m = sf->func->ops->h; n && m; n = n->next, m = m->next) {
550 1574137 : sql_arg *a = m->data;
551 1574137 : sql_exp *e = n->data;
552 1574137 : sql_subtype *t = exp_subtype(e);
553 :
554 1574137 : if (a->type.type->eclass == EC_ANY) {
555 291472 : if (t && atp) {
556 129027 : supertype(&super, t, atp);
557 129027 : atp = &super;
558 162445 : } else if (t) {
559 : atp = t;
560 : }
561 : }
562 1574134 : if (t && sf->func->fix_scale == SCALE_FIX && t->type->eclass == EC_DEC) {
563 1260 : if (digits < t->digits)
564 : digits = t->digits;
565 1260 : if (scale < t->scale)
566 : scale = t->scale;
567 : }
568 : }
569 821230 : if (!atp && !list_empty(exps))
570 656914 : atp = exp_subtype(exps->h->data);
571 :
572 821229 : if ((atp && atp->type->localtype == TYPE_void) || !atp) /* NULL */
573 12057 : atp = sql_bind_localtype("str");
574 :
575 821229 : node *n, *m;
576 821229 : sql_arg *last = NULL;
577 3969593 : for (n = exps->h, m = sf->func->ops->h; n && ((sf->func->vararg && last) || m); n = n->next, m = m?m->next:NULL) {
578 1574184 : sql_arg *a = m?m->data:last;
579 1574184 : sql_exp *e = n->data;
580 1574184 : sql_subtype *ntp = &a->type, *t = exp_subtype(e);
581 :
582 1574182 : last = a;
583 1574182 : if (!t) {
584 37 : if (a->type.type->eclass == EC_ANY && atp)
585 3 : ntp = sql_create_subtype(sql->sa, atp->type, atp->digits, atp->scale);
586 59 : rel_set_type_param(sql, ntp, rel, e, sf->func->fix_scale != INOUT && !UDF_LANG(sf->func->lang));
587 1574145 : } else if (a->type.type->eclass == EC_ANY && atp) {
588 291516 : ntp = sql_create_subtype(sql->sa, atp->type, atp->digits, atp->scale);
589 1282629 : } else if (t && ntp->digits == 0 && EC_VARCHAR(a->type.type->eclass)) {
590 533974 : ntp = sql_create_subtype(sql->sa, a->type.type, type_digits_to_char_digits(t), 0);
591 748655 : } else if (t && ntp->digits > 0 && a->type.type->eclass == EC_NUM && t->type->eclass == EC_NUM) {
592 400974 : ntp = sql_create_subtype(sql->sa, a->type.type, t->digits, 0);
593 347681 : } else if (t && ntp->scale == 0 && ntp->type->eclass == EC_DEC && EC_VARCHAR(t->type->eclass)) {
594 0 : sql_subtype *res = SA_NEW(sql->sa, sql_subtype);
595 0 : int digits = t->digits?t->digits+3:ntp->digits;
596 0 : (void)sql_find_subtype(res, a->type.type->base.name, digits, 3);
597 0 : ntp = res;
598 347681 : } else if (t && ntp->scale == 0 && ntp->type->eclass == EC_DEC) {
599 4914 : ntp = sql_create_subtype(sql->sa, a->type.type, t->type->eclass == EC_NUM?bits2digits(t->digits):t->digits, t->scale);
600 342767 : } else if (t->type == ntp->type) {
601 340656 : ntp = t;
602 : }
603 1574182 : if (!(e = exp_check_type(sql, ntp, rel, e, type_equal)))
604 : return NULL;
605 1574185 : if (sf->func->fix_scale == SCALE_FIX) {
606 592898 : ntp = sql_create_subtype(sql->sa, a->type.type->localtype?a->type.type:t?t->type:atp->type, digits, scale);
607 592898 : e = exp_fix_scale(sql, ntp, e);
608 981287 : } else if (sf->func->fix_scale == SCALE_EQ) {
609 213838 : e = exp_fix_scale(sql, &a->type, e);
610 : }
611 1574185 : if (maybe_zero_or_one && e->card > CARD_ATOM) {
612 22 : sql_subfunc *zero_or_one = sql_bind_func(sql, "sys", "zero_or_one", exp_subtype(e), NULL, F_AGGR, true, false);
613 22 : e = exp_aggr1(sql->sa, e, zero_or_one, 0, 0, CARD_ATOM, has_nil(e));
614 : }
615 1574185 : append(nexps, e);
616 : }
617 : /* handle any extra arguments for rel_dump/analytic funcs */
618 821449 : for ( ; n; n = n->next)
619 222 : append(nexps, n->data);
620 821227 : if (sf->func->fix_scale == SCALE_FIX || IS_ANALYTIC(sf->func)) {
621 299011 : exps_scale_fix(sf, nexps, atp);
622 522216 : } else if (sf->func->fix_scale == MAX_BITS) {
623 114559 : exps_max_bits(sf, nexps);
624 407657 : } else if (sf->func->fix_scale == SCALE_MUL) {
625 25384 : exps_sum_scales(sf, nexps);
626 382273 : } else if (!internal && sf->func->fix_scale == SCALE_DIV) {
627 2625 : if (!exps_scale_algebra(sql, sf, rel, nexps))
628 : return NULL;
629 379648 : } else if (sf->func->fix_scale == DIGITS_ADD) {
630 188947 : exps_digits_add(sf, nexps);
631 190701 : } else if (sf->func->fix_scale == INOUT) {
632 19792 : exps_inout(sf, nexps);
633 170909 : } else if (is_sum_aggr(sf->func))
634 9487 : exps_largest_int(sf, nexps, rel_get_count(rel));
635 :
636 : /* dirty hack */
637 821225 : if (sf->func->type != F_PROC && sf->func->type != F_UNION && sf->func->type != F_LOADER && res) {
638 782551 : if (res->type->eclass == EC_ANY && atp)
639 73 : sf->res->h->data = sql_create_subtype(sql->sa, atp->type, atp->digits, atp->scale);
640 : }
641 : return nexps;
642 : }
643 :
644 : static char *
645 286 : nary_function_arg_types_2str(mvc *sql, list* types, int N)
646 : {
647 286 : char *arg_list = NULL;
648 286 : int i = 0;
649 :
650 770 : for (node *n = types->h; n && i < N; n = n->next) {
651 484 : sql_subtype *t = (sql_subtype *) n->data;
652 484 : char *tpe = t ? sql_subtype_string(sql->ta, t) : "?";
653 :
654 484 : if (arg_list) {
655 215 : arg_list = sa_message(sql->ta, "%s, %s", arg_list, tpe);
656 : } else {
657 : arg_list = tpe;
658 : }
659 484 : i++;
660 : }
661 286 : return arg_list;
662 : }
663 :
664 : static char *
665 35 : file_loader_add_table_column_types(mvc *sql, sql_subfunc *f, list *exps, list *res_exps, char *tname)
666 : {
667 35 : sql_exp *file = exps->h->data;
668 35 : if (!exp_is_atom(file))
669 : return "Filename missing";
670 :
671 35 : atom *a = file->l;
672 35 : if (a->data.vtype != TYPE_str || !a->data.val.sval)
673 : return "Filename missing";
674 :
675 35 : char *filename = a->data.val.sval;
676 35 : if (strcmp(filename, "") == 0)
677 : return "Filename missing";
678 :
679 33 : char *ext = strrchr(filename, '.'), *ep = ext;
680 :
681 33 : if (ext) {
682 30 : ext = ext + 1;
683 30 : ext = mkLower(sa_strdup(sql->sa, ext));
684 : }
685 30 : if (!ext)
686 3 : return "Filename extension missing";
687 :
688 30 : file_loader_t *fl = fl_find(ext);
689 30 : if (!fl) {
690 : /* maybe compressed */
691 10 : char *p = ep - 1;
692 66 : while (p > filename && *p != '.')
693 56 : p--;
694 10 : if (p != filename) {
695 8 : ext = p + 1;
696 8 : ext = sa_strdup(sql->sa, ext);
697 8 : char *d = strchr(ext, '.');
698 8 : assert(d);
699 8 : *d = 0;
700 8 : fl = fl_find(ext);
701 : }
702 10 : if (!fl) /* fallback */
703 2 : fl = fl_find("csv");
704 2 : if (!fl) /* not expected */
705 0 : return sa_message(sql->ta, "Filename extension '%s' missing", ext?ext:"");
706 : }
707 30 : str err = fl->add_types(sql, f, filename, res_exps, tname);
708 30 : if (err)
709 : return err;
710 16 : sql_subtype *st = sql_bind_localtype("str");
711 16 : sql_exp *ext_exp = exp_atom(sql->sa, atom_string(sql->sa, st, ext));
712 16 : if (!ext_exp)
713 : return MAL_MALLOC_FAIL;
714 16 : append(exps, ext_exp);
715 16 : return NULL;
716 : }
717 :
718 : static sql_rel *
719 35 : rel_file_loader(mvc *sql, list *exps, list *tl, char *tname)
720 : {
721 35 : sql_subfunc *f = NULL;
722 35 : bool found = false;
723 :
724 35 : if ((f = bind_func_(sql, NULL, "file_loader", tl, F_UNION, true, &found, false))) {
725 35 : list *nexps = exps;
726 35 : if (list_empty(tl) || (nexps = check_arguments_and_find_largest_any_type(sql, NULL, exps, f, 1, false))) {
727 35 : list *res_exps = sa_list(sql->sa);
728 35 : if (list_length(exps) == 1 && f && f->func->varres && strlen(f->func->mod) == 0 && strlen(f->func->imp) == 0) {
729 35 : char *err = file_loader_add_table_column_types(sql, f, nexps, res_exps, tname);
730 35 : if (err)
731 19 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: file_loader function failed '%s'", err);
732 : }
733 16 : sql_exp *e = exp_op(sql->sa, nexps, f);
734 16 : sql_rel *rel = rel_table_func(sql->sa, NULL, e, res_exps, TABLE_PROD_FUNC);
735 16 : if (rel)
736 16 : rel = rel_project(sql->sa, rel, exps_alias(sql, res_exps));
737 16 : return rel;
738 : }
739 : }
740 : return NULL;
741 : }
742 :
743 : static char *
744 71 : proto_loader_add_table_column_types(mvc *sql, sql_subfunc *f, list *exps, list *res_exps, char *tname)
745 : {
746 71 : sql_exp *uri = exps->h->data;
747 71 : if (!exp_is_atom(uri))
748 : return "URI missing";
749 :
750 71 : atom *a = uri->l;
751 71 : if (a->data.vtype != TYPE_str || !a->data.val.sval)
752 : return "URI missing";
753 :
754 71 : char *uristr = a->data.val.sval;
755 71 : if (strcmp(uristr, "") == 0)
756 : return "URI missing";
757 :
758 71 : char *proto = uristr;
759 71 : char *ep = strchr(uristr, ':');
760 71 : if (ep) {
761 70 : *ep = 0;
762 70 : proto = mkLower(sa_strdup(sql->sa, proto));
763 70 : *ep = ':';
764 : } else {
765 : return "Missing ':' separator to determine the URI scheme";
766 : }
767 :
768 70 : if (!proto)
769 : return "URI scheme missing";
770 :
771 : // find uri scheme in registered protocols (e.g. is: 'file' or 'monetdb' or 'odbc')
772 70 : proto_loader_t *pl = pl_find(proto);
773 70 : if (!pl)
774 0 : return sa_message(sql->ta, "URI protocol '%s' not supported", proto?proto:"");
775 :
776 70 : str err = pl->add_types(sql, f, uristr, res_exps, tname);
777 70 : if (err)
778 : return err;
779 :
780 53 : sql_subtype *st = sql_bind_localtype("str");
781 53 : sql_exp *proto_exp = exp_atom(sql->sa, atom_string(sql->sa, st, proto));
782 53 : if (!proto_exp)
783 : return MAL_MALLOC_FAIL;
784 :
785 53 : append(exps, proto_exp);
786 53 : return NULL;
787 : }
788 :
789 : static sql_rel *
790 72 : rel_proto_loader(mvc *sql, list *exps, list *tl, char *tname)
791 : {
792 72 : sql_subfunc *f = NULL;
793 72 : bool found = false;
794 :
795 72 : if ((f = bind_func_(sql, NULL, "proto_loader", tl, F_UNION, true, &found, false))) {
796 71 : list *nexps = exps;
797 71 : if (list_empty(tl) || f->func->vararg || (nexps = check_arguments_and_find_largest_any_type(sql, NULL, exps, f, 1, false))) {
798 71 : list *res_exps = sa_list(sql->sa);
799 71 : if (list_length(exps) == 1 && f && f->func->varres && strlen(f->func->mod) == 0 && strlen(f->func->imp) == 0) {
800 71 : char *err = proto_loader_add_table_column_types(sql, f, nexps, res_exps, tname);
801 71 : if (err)
802 18 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: proto_loader function failed '%s'", err);
803 : }
804 53 : sql_exp *e = exp_op(sql->sa, nexps, f);
805 53 : sql_rel *rel = rel_table_func(sql->sa, NULL, e, res_exps, TABLE_PROD_FUNC);
806 53 : if (rel)
807 53 : rel = rel_project(sql->sa, rel, exps_alias(sql, res_exps));
808 53 : return rel;
809 : }
810 : }
811 : return NULL;
812 : }
813 :
814 : sql_exp *
815 10999 : find_table_function(mvc *sql, char *sname, char *fname, list *exps, list *tl, sql_ftype type)
816 : {
817 10999 : bool found = false;
818 10999 : sql_subfunc *f = NULL;
819 :
820 10999 : assert(type == F_UNION || type == F_LOADER);
821 10999 : if ((f = bind_func_(sql, sname, fname, tl, type, false, &found, false))) {
822 10976 : list *nexps = exps;
823 10976 : if (list_empty(tl) || (nexps = check_arguments_and_find_largest_any_type(sql, NULL, exps, f, 1, false)))
824 10976 : return exp_op(sql->sa, nexps, f);
825 0 : found = false;
826 : }
827 23 : char *arg_list = list_length(tl) ? nary_function_arg_types_2str(sql, tl, list_length(tl)) : NULL;
828 61 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s %s function %s%s%s'%s'(%s)",
829 23 : found ? "insufficient privileges for" : "no such", type == F_UNION ? "table returning" : "loader", sname ? "'":"", sname ? sname : "",
830 : sname ? "'.":"", fname, arg_list ? arg_list : "");
831 : }
832 :
833 : static sql_rel *
834 11087 : rel_named_table_function(sql_query *query, sql_rel *rel, symbol *ast, int lateral, list *refs)
835 : {
836 11087 : mvc *sql = query->sql;
837 11087 : list *exps = NULL, *tl;
838 11087 : node *m;
839 11087 : exp_kind ek = {type_value, card_relation, TRUE};
840 11087 : sql_rel *sq = NULL, *outer = NULL;
841 11087 : sql_exp *e = NULL;
842 11087 : sql_subfunc *sf = NULL;
843 11087 : symbol *sym = ast->data.lval->h->data.sym, *subquery = NULL;
844 11087 : dnode *l = sym->data.lval->h, *n;
845 11087 : char *tname = NULL;
846 11087 : char *fname = qname_schema_object(l->data.lval);
847 11087 : char *sname = qname_schema(l->data.lval);
848 :
849 11087 : tl = sa_list(sql->sa);
850 11087 : exps = sa_list(sql->sa);
851 11087 : if (l->next)
852 11087 : l = l->next; /* skip distinct */
853 11087 : if (l->next) { /* table call with subquery */
854 11087 : int is_value = 1;
855 11087 : if (l->next->type == type_symbol || l->next->type == type_list) {
856 11087 : exp_kind iek = {type_value, card_set, TRUE};
857 11087 : int count = 0;
858 :
859 11087 : if (l->next->type == type_symbol)
860 : n = l->next;
861 : else
862 11087 : n = l->next->data.lval?l->next->data.lval->h:NULL;
863 :
864 13873 : for (dnode *m = n; m; m = m->next) {
865 2786 : if (m->type == type_symbol && m->data.sym->token == SQL_SELECT)
866 2786 : subquery = m->data.sym;
867 2786 : count++;
868 : }
869 11087 : if (subquery && count > 1)
870 17 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: The input for the table returning function %s%s%s'%s' must be either a single sub query, or a list of values",
871 : sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname);
872 :
873 11082 : if (subquery) {
874 40 : if (!(sq = rel_subquery(query, subquery, ek)))
875 : return NULL;
876 : is_value = 0;
877 : } else {
878 13767 : for ( ; n; n = n->next) {
879 2731 : sql_exp *e = rel_value_exp(query, &outer, n->data.sym, sql_sel | sql_from, iek);
880 :
881 2731 : if (!e)
882 : return NULL;
883 2725 : append(exps, e);
884 2725 : is_value &= exp_is_atom(e);
885 : }
886 11036 : if (!is_value || (lateral && outer))
887 14 : sq = rel_project(sql->sa, NULL, exps);
888 14 : if (lateral && outer) {
889 0 : sq = rel_crossproduct(sql->sa, sq, outer, op_join);
890 0 : set_dependent(sq);
891 0 : set_processed(sq);
892 : }
893 : }
894 : }
895 11075 : if (!is_value && (!sq || (!lateral && outer)))
896 0 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: no such table returning function %s%s%s'%s'", sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname);
897 11075 : if (!is_value) {
898 53 : if (list_length(exps))
899 14 : exps = sa_list(sql->sa);
900 171 : for (node *en = sq->exps->h; en; en = en->next) {
901 118 : sql_exp *e = en->data;
902 :
903 118 : if (!e->alias.label)
904 28 : exp_label(sql->sa, e, ++sql->label);
905 118 : sql_exp *ne = exp_ref(sql, e);
906 : /* allow for table functions with table input */
907 118 : ne->card = CARD_ATOM;
908 118 : exp_setname(sql, ne, tname, exp_name(e));
909 118 : append(exps, ne);
910 118 : append(tl, exp_subtype(e));
911 : }
912 : } else {
913 13722 : for (node *en = exps->h; en; en = en->next)
914 2700 : append(tl, exp_subtype(en->data));
915 : }
916 : }
917 :
918 11075 : rel = NULL;
919 11075 : if (ast->data.lval->t->type == type_symbol && ast->data.lval->t->data.sym)
920 1234 : tname = ast->data.lval->t->data.sym->data.lval->h->data.sval;
921 : else
922 9841 : tname = make_label(sql->sa, ++sql->label);
923 :
924 11075 : if (!sname && strcmp(fname, "proto_loader") == 0) {
925 72 : rel = rel_proto_loader(sql, exps, tl, tname);
926 72 : if (!rel)
927 : return NULL;
928 795 : } else if (!sname && strcmp(fname, "file_loader") == 0) {
929 35 : rel = rel_file_loader(sql, exps, tl, tname);
930 35 : if (!rel)
931 : return NULL;
932 20914 : } else if (!(e = find_table_function(sql, sname, fname, list_empty(exps) ? NULL : exps, tl, F_UNION)))
933 : return NULL;
934 :
935 10946 : if (!rel) {
936 10946 : rel = sq;
937 :
938 : /* column or table function */
939 10946 : sf = e->f;
940 10946 : if (e->type != e_func || sf->func->type != F_UNION)
941 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: '%s' does not return a table", exp_func_name(e));
942 :
943 10946 : if (sq) {
944 171 : for (node *n = sq->exps->h, *m = sf->func->ops->h ; n && m ; n = n->next, m = m->next) {
945 118 : sql_exp *e = (sql_exp*) n->data;
946 118 : sql_arg *a = (sql_arg*) m->data;
947 118 : if (!exp_subtype(e) && rel_set_type_param(sql, &(a->type), sq, e, 0) < 0)
948 : return NULL;
949 : }
950 : }
951 :
952 : /* for each column add table.column name */
953 10946 : exps = new_exp_list(sql->sa);
954 107603 : for (m = sf->func->res->h; m; m = m->next) {
955 96657 : sql_arg *a = m->data;
956 96657 : sql_exp *e = exp_column(sql->sa, tname, a->name, &a->type, CARD_MULTI, 1, 0, 0);
957 96657 : e->alias.label = -(sql->nid++);
958 :
959 96657 : set_basecol(e);
960 96657 : append(exps, e);
961 : }
962 21839 : rel = rel_table_func(sql->sa, rel, e, exps, (sq)?TABLE_FROM_RELATION:TABLE_PROD_FUNC);
963 : }
964 11015 : if (ast->data.lval->t->type == type_symbol && ast->data.lval->t->data.sym && ast->data.lval->t->data.sym->data.lval->h->next->data.lval) {
965 49 : rel = rel_table_optname(sql, rel, ast->data.lval->t->data.sym, refs);
966 10966 : } else if (refs) { /* if this relation is under a FROM clause, check for duplicate names */
967 10966 : if (list_find(refs, tname, (fcmp) &strcmp))
968 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: relation name \"%s\" specified more than once", tname);
969 10966 : list_append(refs, tname);
970 : }
971 : return rel;
972 : }
973 :
974 : static sql_exp*
975 4210 : exp_tuples_set_supertype(mvc *sql, list *tuple_values, sql_exp *tuples)
976 : {
977 4210 : assert(is_values(tuples));
978 4210 : list *vals = exp_get_values(tuples);
979 4210 : if (!vals || !vals->h)
980 : return NULL;
981 :
982 4210 : int tuple_width = list_length(tuple_values), i;
983 4210 : sql_subtype *types = SA_NEW_ARRAY(sql->sa, sql_subtype, tuple_width);
984 4210 : bool *has_type = SA_NEW_ARRAY(sql->sa, bool, tuple_width);
985 4210 : node *n;
986 :
987 4210 : memset(has_type, 0, sizeof(bool)*tuple_width);
988 13716 : for(n = tuple_values->h, i = 0; n; n = n->next, i++) {
989 9506 : sql_exp *e = n->data;
990 9506 : if (exp_subtype(e)) {
991 9504 : types[i] = *exp_subtype(e);
992 9504 : has_type[i] = 1;
993 : }
994 : }
995 :
996 8422 : for (node *m = vals->h; m; m = m->next) {
997 4212 : sql_exp *tuple = m->data;
998 4212 : if (is_values(tuple)) {
999 0 : list *exps = tuple->f;
1000 0 : for(n = exps->h, i = 0; n; n = n->next, i++) {
1001 0 : sql_subtype *tpe;
1002 0 : sql_exp *e = n->data;
1003 :
1004 0 : if (has_type[i] && e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
1005 0 : if (set_type_param(sql, types+i, e->flag) == 0)
1006 0 : e->tpe = types[i];
1007 : else
1008 : return NULL;
1009 : }
1010 0 : tpe = exp_subtype(e);
1011 0 : if (!tpe)
1012 : return NULL;
1013 0 : if (has_type[i] && tpe) {
1014 0 : supertype(types+i, types+i, tpe);
1015 : } else {
1016 0 : has_type[i] = 1;
1017 0 : types[i] = *tpe;
1018 : }
1019 : }
1020 : } else {
1021 4212 : sql_rel *tuple_relation = exp_rel_get_rel(sql->sa, tuple);
1022 :
1023 13722 : for(n = tuple_relation->exps->h, i = 0; n; n = n->next, i++) {
1024 9510 : sql_subtype *tpe;
1025 9510 : sql_exp *e = n->data;
1026 :
1027 9510 : if (has_type[i] && e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
1028 5 : if (set_type_param(sql, types+i, e->flag) == 0)
1029 5 : e->tpe = types[i];
1030 : else
1031 : return NULL;
1032 : }
1033 9510 : tpe = exp_subtype(e);
1034 9510 : if (!tpe)
1035 : return NULL;
1036 9510 : if (has_type[i] && tpe) {
1037 9508 : cmp_supertype(types+i, types+i, tpe);
1038 : } else {
1039 2 : has_type[i] = 1;
1040 2 : types[i] = *tpe;
1041 : }
1042 : }
1043 : }
1044 : }
1045 :
1046 8422 : for (node *m = vals->h; m; m = m->next) {
1047 4212 : sql_exp *tuple = m->data;
1048 4212 : if (is_values(tuple)) {
1049 0 : list *exps = tuple->f;
1050 0 : list *nexps = sa_list(sql->sa);
1051 0 : for(n = exps->h, i = 0; n; n = n->next, i++) {
1052 0 : sql_exp *e = n->data;
1053 :
1054 0 : e = exp_check_type(sql, types+i, NULL, e, type_equal);
1055 0 : if (!e)
1056 : return NULL;
1057 0 : exp_label(sql->sa, e, ++sql->label);
1058 0 : append(nexps, e);
1059 : }
1060 0 : tuple->f = nexps;
1061 : } else {
1062 4212 : sql_rel *tuple_relation = exp_rel_get_rel(sql->sa, tuple);
1063 :
1064 4212 : list *nexps = sa_list(sql->sa);
1065 13722 : for(n = tuple_relation->exps->h, i = 0; n; n = n->next, i++) {
1066 9510 : sql_exp *e = n->data;
1067 :
1068 9510 : e = exp_check_type(sql, types+i, NULL, e, type_equal);
1069 9510 : if (!e)
1070 : return NULL;
1071 9510 : append(nexps, e);
1072 : }
1073 4212 : tuple_relation->exps = nexps;
1074 : }
1075 : }
1076 : return tuples;
1077 : }
1078 :
1079 : static int
1080 9506 : rel_binop_check_types(mvc *sql, sql_rel *rel, sql_exp *ls, sql_exp *rs, int upcast)
1081 : {
1082 9506 : sql_subtype *t1 = exp_subtype(ls), *t2 = exp_subtype(rs);
1083 :
1084 9506 : if (!t1 || !t2) {
1085 2 : if (t2 && !t1 && rel_set_type_param(sql, t2, rel, ls, upcast) < 0)
1086 : return -1;
1087 2 : if (t1 && !t2 && rel_set_type_param(sql, t1, rel, rs, upcast) < 0)
1088 : return -1;
1089 : }
1090 9506 : if (!exp_subtype(ls) && !exp_subtype(rs)) {
1091 0 : (void) sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) on both sides of an expression");
1092 0 : return -1;
1093 : }
1094 : return 0;
1095 : }
1096 :
1097 : static list *
1098 4210 : tuples_check_types(mvc *sql, list *tuple_values, sql_exp *tuples)
1099 : {
1100 4210 : list *tuples_list = exp_get_values(tuples);
1101 4210 : sql_exp *first_tuple = tuples_list->h->data;
1102 4210 : list *nvalues = sa_list(sql->sa);
1103 4210 : if (is_values(first_tuple)) {
1104 0 : list *vals = first_tuple->f;
1105 :
1106 0 : for (node *n = tuple_values->h, *m = vals->h; n && m; n = n->next, m = m->next) {
1107 0 : sql_exp *le = n->data, *re = m->data;
1108 :
1109 0 : if (rel_binop_check_types(sql, NULL, le, re, 0) < 0)
1110 : return NULL;
1111 0 : if ((le = exp_check_type(sql, exp_subtype(re), NULL, le, type_equal)) == NULL)
1112 : return NULL;
1113 0 : append(nvalues, le);
1114 : }
1115 : return nvalues;
1116 : } else {
1117 4210 : sql_rel *tuple_relation = exp_rel_get_rel(sql->sa, first_tuple);
1118 :
1119 4210 : assert(list_length(tuple_values) == list_length(tuple_relation->exps));
1120 13716 : for (node *n = tuple_values->h, *m = tuple_relation->exps->h; n && m; n = n->next, m = m->next) {
1121 9506 : sql_exp *le = n->data, *re = m->data;
1122 :
1123 9506 : if (rel_binop_check_types(sql, NULL, le, re, 0) < 0)
1124 : return NULL;
1125 9506 : if ((le = exp_check_type(sql, exp_subtype(re), NULL, le, type_equal)) == NULL)
1126 : return NULL;
1127 9506 : append(nvalues, le);
1128 : }
1129 : return nvalues;
1130 : }
1131 : return tuple_values;
1132 : }
1133 :
1134 : static sql_rel *
1135 3941 : rel_values(sql_query *query, symbol *tableref, list *refs)
1136 : {
1137 3941 : mvc *sql = query->sql;
1138 3941 : sql_rel *r = NULL;
1139 3941 : symbol *values = tableref;
1140 3941 : symbol *optname = NULL;
1141 3941 : if (tableref->token == SQL_TABLE) {
1142 1410 : values = tableref->data.lval->h->data.sym;
1143 1410 : optname = tableref->data.lval->t->type == type_symbol ? tableref->data.lval->t->data.sym : NULL;
1144 : }
1145 3941 : dlist *rowlist = values->data.lval;
1146 3941 : node *m;
1147 3941 : list *exps = sa_list(sql->sa);
1148 3941 : exp_kind ek = {type_value, card_value, TRUE};
1149 :
1150 15679 : for (dnode *o = rowlist->h; o; o = o->next) {
1151 11748 : dlist *values = o->data.lval;
1152 :
1153 11748 : if (!list_empty(exps) && list_length(exps) != dlist_length(values)) {
1154 3 : return sql_error(sql, 02, SQLSTATE(42000) "VALUES: number of columns doesn't match between rows");
1155 : } else {
1156 11745 : dnode *n;
1157 :
1158 11745 : if (list_empty(exps)) {
1159 12485 : for (n = values->h; n; n = n->next) {
1160 8544 : sql_exp *vals = exp_values(sql->sa, sa_list(sql->sa));
1161 :
1162 8544 : exp_label(sql->sa, vals, ++sql->label);
1163 8544 : list_append(exps, vals);
1164 : }
1165 : }
1166 37179 : for (n = values->h, m = exps->h; n && m; n = n->next, m = m->next) {
1167 25441 : sql_exp *vals = m->data;
1168 25441 : list *vals_list = vals->f;
1169 25441 : sql_exp *e = rel_value_exp(query, NULL, n->data.sym, sql_sel | sql_values, ek);
1170 25441 : if (!e)
1171 : return NULL;
1172 25434 : list_append(vals_list, e);
1173 : }
1174 : }
1175 : }
1176 :
1177 : /* loop to check types and cardinality */
1178 3931 : unsigned int card = exps->h && list_length(((sql_exp*)exps->h->data)->f) > 1 ? CARD_MULTI : CARD_ATOM;
1179 12458 : for (m = exps->h; m; m = m->next) {
1180 8530 : sql_exp *e = m->data;
1181 :
1182 8530 : if (!(e = exp_values_set_supertype(sql, e, NULL)))
1183 : return NULL;
1184 8527 : e->card = card;
1185 8527 : m->data = e;
1186 : }
1187 :
1188 3928 : r = rel_project(sql->sa, NULL, exps);
1189 3928 : r->nrcols = list_length(exps);
1190 3928 : r->card = card;
1191 3928 : return rel_table_optname(sql, r, optname, refs);
1192 : }
1193 :
1194 : static int
1195 513933 : check_is_lateral(symbol *tableref)
1196 : {
1197 513933 : if (tableref->token == SQL_NAME || tableref->token == SQL_TABLE ||
1198 : tableref->token == SQL_VALUES) {
1199 462915 : if (dlist_length(tableref->data.lval) == 3)
1200 462914 : return tableref->data.lval->h->next->data.i_val;
1201 : return 0;
1202 : } else if (tableref->token == SQL_WITH) {
1203 993 : if (dlist_length(tableref->data.lval) == 5)
1204 16 : return tableref->data.lval->h->next->next->next->data.i_val;
1205 : return 0;
1206 : } else if (tableref->token == SQL_SELECT) {
1207 2327 : SelectNode *sn = (SelectNode *) tableref;
1208 2327 : return sn->lateral;
1209 : } else if (tableref->token == SQL_EXCEPT || tableref->token == SQL_INTERSECT ||
1210 : tableref->token == SQL_UNION) {
1211 11116 : if (dlist_length(tableref->data.lval) == 6)
1212 9361 : return tableref->data.lval->h->next->next->next->next->data.i_val;
1213 : return 0;
1214 : } else {
1215 : return 0;
1216 : }
1217 : }
1218 :
1219 : sql_rel *
1220 25 : rel_reduce_on_column_privileges(mvc *sql, sql_rel *rel, sql_table *t)
1221 : {
1222 25 : list *exps = sa_list(sql->sa);
1223 :
1224 99 : for (node *n = rel->exps->h, *m = ol_first_node(t->columns); n && m; n = n->next, m = m->next) {
1225 74 : sql_exp *e = n->data;
1226 74 : sql_column *c = m->data;
1227 :
1228 74 : if (column_privs(sql, c, PRIV_SELECT))
1229 12 : append(exps, e);
1230 : }
1231 25 : if (!list_empty(exps)) {
1232 9 : rel->exps = exps;
1233 9 : return rel;
1234 : }
1235 : return NULL;
1236 : }
1237 :
1238 : sql_rel *
1239 704451 : table_ref(sql_query *query, symbol *tableref, int lateral, list *refs)
1240 : {
1241 704451 : mvc *sql = query->sql;
1242 704451 : char *tname = NULL;
1243 704451 : sql_table *t = NULL;
1244 704451 : sql_rel *res = NULL;
1245 :
1246 704451 : if (tableref->token == SQL_NAME) {
1247 484219 : dlist *name = tableref->data.lval->h->data.lval;
1248 484219 : sql_rel *temp_table = NULL;
1249 484219 : char *sname = qname_schema(name);
1250 484219 : int allowed = 1;
1251 :
1252 484219 : tname = qname_schema_object(name);
1253 :
1254 484219 : if (dlist_length(name) > 2)
1255 4 : return sql_error(sql, 02, SQLSTATE(3F000) "SELECT: only a schema and table name expected");
1256 :
1257 484215 : if (!sname)
1258 110111 : temp_table = stack_find_rel_view(sql, tname);
1259 110111 : if (!temp_table)
1260 471259 : t = find_table_or_view_on_scope(sql, NULL, sname, tname, "SELECT", false);
1261 484215 : if (!t && !temp_table)
1262 : return NULL;
1263 484108 : if (!temp_table && !table_privs(sql, t, PRIV_SELECT))
1264 484108 : allowed = 0;
1265 :
1266 484108 : if (tableref->data.lval->t->type == type_symbol && tableref->data.lval->t->data.sym) /* AS */
1267 286760 : tname = tableref->data.lval->t->data.sym->data.lval->h->data.sval;
1268 484108 : if (temp_table && !t) {
1269 12956 : node *n;
1270 12956 : int needed = !is_simple_project(temp_table->op);
1271 :
1272 12956 : if (is_basetable(temp_table->op) && !temp_table->exps) {
1273 0 : if (strcmp(rel_base_name(temp_table), tname) != 0)
1274 0 : rel_base_rename(temp_table, tname);
1275 : } else {
1276 42450 : for (n = temp_table->exps->h; n && !needed; n = n->next) {
1277 29494 : sql_exp *e = n->data;
1278 :
1279 29494 : if (!exp_relname(e) || strcmp(exp_relname(e), tname) != 0)
1280 : needed = 1;
1281 : }
1282 :
1283 12956 : if (needed) {
1284 5824 : list *exps = rel_projections(sql, temp_table, NULL, 1, 1);
1285 :
1286 5824 : temp_table = rel_project(sql->sa, temp_table, exps);
1287 18731 : for (n = exps->h; n; n = n->next) {
1288 12907 : sql_exp *e = n->data;
1289 :
1290 12907 : noninternexp_setname(sql, e, tname, NULL);
1291 12907 : set_basecol(e);
1292 : }
1293 5824 : list_hash_clear(exps);
1294 : }
1295 : }
1296 12956 : if (temp_table && tableref->data.lval->t->type == type_symbol && tableref->data.lval->t->data.sym && tableref->data.lval->t->data.sym->data.lval->h->next->data.lval) /* AS with column aliases */
1297 10 : temp_table = rel_table_optname(sql, temp_table, tableref->data.lval->t->data.sym, refs);
1298 12956 : if (allowed)
1299 : return temp_table;
1300 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: access denied for %s to table '%s'", get_string_global_var(sql, "current_user"), tname);
1301 471152 : } else if (isView(t)) {
1302 : /* instantiate base view */
1303 72117 : node *n,*m;
1304 72117 : sql_rel *rel;
1305 :
1306 72117 : if (sql->emode == m_deps) {
1307 25335 : rel = rel_basetable(sql, t, tname);
1308 25335 : if (!allowed)
1309 0 : rel_base_disallow(rel);
1310 : } else {
1311 : /* when recreating a view, the view itself can't be found */
1312 46782 : if (sql->objid && sql->objid == t->base.id)
1313 1 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: attempting to recursively bind view '%s'.'%s'", t->s->base.name, tname);
1314 46781 : rel = rel_parse(sql, t->s, t->query, m_instantiate);
1315 46781 : if (rel && sql->emode == m_deps)
1316 0 : rel = rel_unnest(sql, rel);
1317 : }
1318 :
1319 72114 : if (!rel)
1320 2 : return NULL;
1321 : /* Rename columns of the rel_parse relation */
1322 72114 : if (sql->emode != m_deps) {
1323 46779 : assert(is_project(rel->op));
1324 46779 : set_processed(rel);
1325 46779 : if (is_mset(rel->op) || is_simple_project(rel->op) || (is_groupby(rel->op) && !list_empty(rel->r))) {
1326 : /* it's unsafe to set the projection names because of possible dependent sorting/grouping columns */
1327 46779 : rel = rel_project(sql->sa, rel, rel_projections(sql, rel, NULL, 0, 0));
1328 46779 : set_processed(rel);
1329 : }
1330 420905 : for (n = ol_first_node(t->columns), m = rel->exps->h; n && m; n = n->next, m = m->next) {
1331 374126 : sql_column *c = n->data;
1332 374126 : sql_exp *e = m->data;
1333 :
1334 374126 : exp_setname(sql, e, tname, c->base.name);
1335 374126 : set_basecol(e);
1336 : }
1337 46779 : list_hash_clear(rel->exps);
1338 : }
1339 72114 : if (rel && !allowed && t->query && (rel = rel_reduce_on_column_privileges(sql, rel, t)) == NULL)
1340 16 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: access denied for %s to view '%s.%s'", get_string_global_var(sql, "current_user"), t->s->base.name, tname);
1341 72098 : return rel;
1342 : }
1343 399035 : if ((isMergeTable(t) || isReplicaTable(t)) && list_length(t->members)==0)
1344 14 : return sql_error(sql, 02, SQLSTATE(42000) "%s '%s'.'%s' should have at least one table associated",
1345 14 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->s->base.name, tname);
1346 399021 : res = rel_basetable(sql, t, tname);
1347 399021 : if (!allowed) {
1348 53 : rel_base_disallow(res);
1349 53 : if (rel_base_has_column_privileges(sql, res) == 0)
1350 62 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: access denied for %s to %s '%s.%s'", get_string_global_var(sql, "current_user"), isView(t) ? "view" : "table", t->s->base.name, tname);
1351 : }
1352 398990 : if (tableref->data.lval->t->type == type_symbol && tableref->data.lval->t->data.sym && tableref->data.lval->t->data.sym->data.lval->h->next->data.lval) { /* AS with column aliases */
1353 12 : res = rel_table_optname(sql, res, tableref->data.lval->t->data.sym, refs);
1354 398978 : } else if (refs) { /* if this relation is under a FROM clause, check for duplicate names */
1355 398973 : if (list_find(refs, tname, (fcmp) &strcmp))
1356 7 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: relation name \"%s\" specified more than once", tname);
1357 398966 : assert(tname);
1358 398966 : list_append(refs, tname);
1359 : }
1360 398983 : return res;
1361 220232 : } else if (tableref->token == SQL_VALUES || (tableref->token == SQL_TABLE && tableref->data.lval->h->data.sym->token == SQL_VALUES)) {
1362 1447 : return rel_values(query, tableref, refs);
1363 218785 : } else if (tableref->token == SQL_TABLE) {
1364 11087 : return rel_named_table_function(query, NULL, tableref, lateral, refs);
1365 : } else if (tableref->token == SQL_SELECT) {
1366 102959 : return rel_subquery_optname(query, tableref, refs);
1367 : } else if (tableref->token == SQL_UNION || tableref->token == SQL_EXCEPT || tableref->token == SQL_INTERSECT) {
1368 : /* subqueries will be called, ie no need to test for duplicate references */
1369 43712 : sql_rel *tq = rel_setquery(query, tableref);
1370 :
1371 43712 : if (!tq)
1372 : return NULL;
1373 : /* look for lateral joins */
1374 43705 : symbol *optname = tableref->data.lval->t->type == type_symbol ? tableref->data.lval->t->data.sym : NULL;
1375 43705 : return rel_table_optname(sql, tq, optname, refs);
1376 : } else {
1377 61027 : return query_exp_optname(query, tableref, refs);
1378 : }
1379 : }
1380 :
1381 : static sql_exp *
1382 123895 : rel_exp_variable_on_scope(mvc *sql, const char *sname, const char *vname)
1383 : {
1384 123895 : sql_subtype *tpe = NULL;
1385 123895 : sql_var *var = NULL;
1386 123895 : sql_arg *a = NULL;
1387 123895 : int level = 1;
1388 :
1389 123895 : if (find_variable_on_scope(sql, sname, vname, &var, &a, &tpe, &level, "SELECT")) {
1390 122944 : if (var) /* if variable is known from the stack or a global var */
1391 37948 : return exp_param_or_declared(sql->sa, var->sname ? sa_strdup(sql->sa, var->sname) : NULL, sa_strdup(sql->sa, var->name), &(var->var.tpe), level);
1392 90054 : if (a) /* if variable is a parameter */
1393 90054 : return exp_param_or_declared(sql->sa, NULL, sa_strdup(sql->sa, vname), &(a->type), level);
1394 : }
1395 : return NULL;
1396 : }
1397 :
1398 : static sql_exp *
1399 9259 : exps_get_exp(list *exps, int nth)
1400 : {
1401 9259 : node *n = NULL;
1402 9259 : int i = 0;
1403 :
1404 9259 : if (exps)
1405 27182 : for (n=exps->h, i=1; n && i<nth; n=n->next, i++)
1406 : ;
1407 9259 : if (n && i == nth)
1408 9256 : return n->data;
1409 : return NULL;
1410 : }
1411 :
1412 : static sql_rel *
1413 31278 : rel_find_groupby(sql_rel *groupby)
1414 : {
1415 31278 : if (groupby && !is_processed(groupby) && !is_base(groupby->op)) {
1416 41048 : while(!is_processed(groupby) && !is_base(groupby->op)) {
1417 33115 : if (is_groupby(groupby->op) || !groupby->l)
1418 : break;
1419 : if (groupby->l)
1420 : groupby = groupby->l;
1421 : }
1422 31153 : if (groupby && is_groupby(groupby->op))
1423 23220 : return groupby;
1424 : }
1425 : return NULL;
1426 : }
1427 :
1428 : static int
1429 307 : is_groupby_col(sql_rel *gb, sql_exp *e)
1430 : {
1431 307 : gb = rel_find_groupby(gb);
1432 :
1433 307 : if (gb) {
1434 174 : if (exp_relname(e)) {
1435 163 : if (exp_name(e) && exps_bind_column2(gb->r, exp_relname(e), exp_name(e), NULL))
1436 : return 1;
1437 : } else {
1438 11 : if (exp_name(e) && exps_bind_column(gb->r, exp_name(e), NULL, NULL, 1))
1439 : return 1;
1440 : }
1441 : }
1442 : return 0;
1443 : }
1444 :
1445 : static void
1446 4834 : set_dependent_( sql_rel *r)
1447 : {
1448 4834 : if (is_select(r->op))
1449 3658 : r = r->l;
1450 4834 : if (r && is_join(r->op))
1451 1238 : set_dependent(r);
1452 4834 : }
1453 :
1454 : static
1455 15 : sql_rel* find_union(visitor *v, sql_rel *rel) {
1456 15 : if (rel->op == op_union || rel->op == op_munion)
1457 1 : v->data = rel;
1458 15 : return rel;
1459 : }
1460 :
1461 : static inline
1462 54 : bool group_by_pk_project_uk_cond(mvc* sql, sql_rel* inner, sql_exp* exp,const char* sname, const char* tname) {
1463 54 : sql_table* t = find_table_or_view_on_scope(sql, NULL, sname, tname, "SELECT", false);
1464 54 : bool allow = false;
1465 54 : if (t) {
1466 17 : sql_idx* pki = NULL;
1467 17 : list *ukil = sa_list(sql->sa);
1468 :
1469 23 : for (node * n = ol_first_node(t->idxs); n; n = n->next) {
1470 6 : sql_idx *i = n->data;
1471 6 : if (!i->key)
1472 1 : continue;
1473 5 : switch (i->key->type) {
1474 3 : case pkey:
1475 3 : pki = i;
1476 3 : continue;
1477 2 : case ukey:
1478 : case unndkey:
1479 2 : list_append(ukil, i);
1480 2 : continue;
1481 0 : default:
1482 0 : continue;
1483 : }
1484 : }
1485 17 : if (pki && pki->columns->cnt == 1 && inner->r && ((list*) inner->r)->cnt == 1) {
1486 : /* for now only check simple case where primary key and group by expression is a single column*/
1487 3 : sql_exp* gbe = ((list*) inner->r)->h->data;
1488 3 : sql_column* pkc = ((sql_kc *)pki->columns->h->data)->c;
1489 3 : if (gbe->type == e_column && strcmp(gbe->alias.name, pkc->base.name) == 0) {
1490 2 : node *n;
1491 2 : for (n = ukil->h; n; n = n->next){
1492 2 : sql_idx* uki = n->data;
1493 2 : if (uki->columns->cnt == 1) {
1494 : /* for now only check simple case where unique key is a single column*/
1495 2 : sql_column* ukc = ((sql_kc *)uki->columns->h->data)->c;
1496 2 : if (strcmp(exp->alias.name, ukc->base.name) == 0) {
1497 : allow = true;
1498 : break;
1499 : }
1500 : }
1501 : }
1502 : }
1503 : }
1504 :
1505 2 : if (allow) {
1506 : /* sufficiency condition: abort if relation contains union subrelation
1507 : * because it may break functional dependency between pk and uk */
1508 2 : visitor v = {.sql=sql};
1509 2 : rel_visitor_topdown(&v, inner, &find_union);
1510 2 : if (v.data)
1511 1 : allow = false;
1512 : }
1513 : }
1514 :
1515 54 : return allow;
1516 :
1517 : }
1518 :
1519 : static sql_exp *
1520 2414585 : rel_column_ref(sql_query *query, sql_rel **rel, symbol *column_r, int f)
1521 : {
1522 2414585 : mvc *sql = query->sql;
1523 2414585 : sql_exp *exp = NULL;
1524 2414585 : dlist *l = NULL;
1525 2414585 : sql_rel *inner = rel?*rel:NULL, *outer = NULL;
1526 2414585 : int used_lower_after_processed = 0;
1527 :
1528 2414585 : assert((column_r->token == SQL_COLUMN || column_r->token == SQL_IDENT) && column_r->type == type_list);
1529 2414585 : l = column_r->data.lval;
1530 :
1531 2414585 : if (dlist_length(l) == 1) {
1532 1113061 : const char *name = l->h->data.sval;
1533 1113061 : if (!name)
1534 : return NULL;
1535 :
1536 1113061 : if (!exp && inner)
1537 1016120 : if (!(exp = rel_bind_column(sql, inner, name, f, 0)) && sql->session->status == -ERR_AMBIGUOUS)
1538 : return NULL;
1539 1113047 : if (!exp && inner && ((is_sql_aggr(f) && (is_groupby(inner->op) || is_select(inner->op))) ||
1540 24313 : (is_groupby(inner->op) && inner->flag))) {
1541 : /* if inner is selection, ie having clause, get the left relation to reach group by */
1542 : sql_rel *gp = inner;
1543 258 : while (gp && is_select(gp->op))
1544 27 : gp = gp->l;
1545 231 : if (gp && !is_basetable(gp->op) && gp->l && !(exp = rel_bind_column(sql, gp->l, name, f, 0)) && sql->session->status == -ERR_AMBIGUOUS)
1546 : return NULL;
1547 : }
1548 1113047 : if (!exp && query && query_has_outer(query)) {
1549 472 : int i;
1550 :
1551 525 : for (i=query_has_outer(query)-1; i>= 0 && !exp && (outer = query_fetch_outer(query,i)); i--) {
1552 496 : if (!(exp = rel_bind_column(sql, outer, name, f, 0)) && sql->session->status == -ERR_AMBIGUOUS)
1553 : return NULL;
1554 84 : if (!exp && is_groupby(outer->op)) {
1555 31 : if (!(exp = rel_bind_column(sql, outer->l, name, f, 0)) && sql->session->status == -ERR_AMBIGUOUS)
1556 : return NULL;
1557 : else
1558 31 : used_lower_after_processed = is_processed(outer);
1559 : }
1560 496 : if (exp && is_simple_project(outer->op) && !rel_find_exp(outer, exp))
1561 0 : exp = rel_project_add_exp(sql, outer, exp);
1562 443 : if (exp)
1563 : break;
1564 : }
1565 472 : if (exp && exp->card != CARD_AGGR && is_groupby(outer->op) && !is_sql_aggr(f) && rel_find_exp(outer->l, exp))
1566 5 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", name);
1567 467 : if (exp && outer && outer->card <= CARD_AGGR && exp->card > CARD_AGGR && !is_sql_aggr(f))
1568 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", name);
1569 467 : if (exp && outer && !is_sql_aggr(f) && !is_sql_aggr(query_fetch_outer_state(query, i))) {
1570 299 : if (used_lower_after_processed || query_outer_used_exp( query, i, exp, f)) {
1571 0 : sql_exp *lu = used_lower_after_processed?exp:query_outer_last_used(query, i);
1572 0 : if (exp_name(lu) && exp_relname(lu) && !has_label(lu))
1573 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column \"%s.%s\" from outer query", exp_relname(lu), exp_name(lu));
1574 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
1575 : }
1576 : }
1577 467 : if (exp) {
1578 438 : int of = query_fetch_outer_state(query, i);
1579 438 : if (is_groupby(outer->op) && !is_sql_aggr(f)) {
1580 37 : exp = rel_groupby_add_aggr(sql, outer, exp);
1581 37 : exp->card = CARD_ATOM;
1582 401 : } else if (is_groupby(outer->op) && is_sql_aggr(f) && exps_any_match(outer->exps, exp))
1583 57 : exp = exp_ref(sql, exp);
1584 : else
1585 344 : exp->card = CARD_ATOM;
1586 438 : set_freevar(exp, i);
1587 438 : if (!is_sql_where(of) && !is_sql_aggr(of) && !is_sql_aggr(f) && !outer->grouped)
1588 147 : set_outer(outer);
1589 : }
1590 467 : if (exp && outer && (is_select(outer->op) || is_join(outer->op)))
1591 43 : set_dependent_(outer);
1592 : }
1593 :
1594 : /* some views are just in the stack, like before and after updates views */
1595 1113042 : if (rel && sql->use_views) {
1596 13 : sql_rel *v = NULL;
1597 13 : int dup = stack_find_rel_view_projection_columns(sql, name, &v); /* trigger views are basetables relations, so those may conflict */
1598 :
1599 13 : if (dup < 0 || (v && exp && *rel && is_base(v->op) && v != *rel)) /* comparing pointers, ugh */
1600 2 : return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "SELECT: identifier '%s' ambiguous", name);
1601 11 : if (v && !exp) {
1602 4 : if (*rel)
1603 1 : *rel = rel_crossproduct(sql->sa, *rel, rel_dup(v), op_join);
1604 : else
1605 3 : *rel = rel_dup(v);
1606 4 : exp = rel_bind_column(sql, *rel, name, f, 0);
1607 : }
1608 : }
1609 1113040 : if (!exp) /* If no column was found, try a variable or parameter */
1610 120840 : exp = rel_exp_variable_on_scope(sql, NULL, name);
1611 :
1612 120840 : if (!exp) {
1613 951 : if (inner && !is_sql_aggr(f) && is_groupby(inner->op) && inner->l && (exp = rel_bind_column(sql, inner->l, name, f, 0)))
1614 47 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", name);
1615 : }
1616 :
1617 1112089 : if (!exp)
1618 904 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: identifier '%s' unknown", name);
1619 1112089 : if (exp && inner && inner->card <= CARD_AGGR && exp->card > CARD_AGGR && (is_sql_sel(f) || is_sql_having(f)) && (!is_sql_aggr(f) && !(inner->flag)))
1620 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", name);
1621 1112089 : if (exp && inner && is_groupby(inner->op) && !is_sql_aggr(f) && !is_freevar(exp) && !inner->flag)
1622 26410 : exp = rel_groupby_add_aggr(sql, inner, exp);
1623 1301524 : } else if (dlist_length(l) == 2 || dlist_length(l) == 3) {
1624 1301524 : const char *sname = NULL;
1625 1301524 : const char *tname = l->h->data.sval;
1626 1301524 : const char *cname = l->h->next->data.sval;
1627 1301524 : if (dlist_length(l) == 3) {
1628 1 : sname = l->h->data.sval;
1629 1 : tname = l->h->next->data.sval;
1630 1 : cname = l->h->next->next->data.sval;
1631 : }
1632 1301524 : if (!cname)
1633 : return NULL;
1634 :
1635 1286794 : if (!exp && rel && inner)
1636 1286667 : if (!(exp = rel_bind_column3(sql, inner, sname, tname, cname, f)) && sql->session->status == -ERR_AMBIGUOUS)
1637 : return NULL;
1638 1286793 : if (!exp && inner && is_sql_aggr(f) && (is_groupby(inner->op) || is_select(inner->op))) {
1639 : /* if inner is selection, ie having clause, get the left relation to reach group by */
1640 : sql_rel *gp = inner;
1641 59 : while (gp && is_select(gp->op))
1642 5 : gp = gp->l;
1643 54 : if (gp && !is_basetable(gp->op) && gp->l && !(exp = rel_bind_column3(sql, gp->l, sname, tname, cname, f)) && sql->session->status == -ERR_AMBIGUOUS)
1644 : return NULL;
1645 : }
1646 1286793 : if (!exp && query && query_has_outer(query)) {
1647 12094 : int i;
1648 :
1649 12304 : for (i=query_has_outer(query)-1; i>= 0 && !exp && (outer = query_fetch_outer(query,i)); i--) {
1650 12303 : if (!(exp = rel_bind_column3(sql, outer, sname, tname, cname, f | sql_outer)) && sql->session->status == -ERR_AMBIGUOUS)
1651 : return NULL;
1652 293 : if (!exp && is_groupby(outer->op)) {
1653 102 : if (!(exp = rel_bind_column3(sql, outer->l, sname, tname, cname, f)) && sql->session->status == -ERR_AMBIGUOUS)
1654 : return NULL;
1655 : else
1656 102 : used_lower_after_processed = is_processed(outer);
1657 : }
1658 12303 : if (exp && is_simple_project(outer->op) && !rel_find_exp(outer, exp))
1659 0 : exp = rel_project_add_exp(sql, outer, exp);
1660 12093 : if (exp)
1661 : break;
1662 : }
1663 12094 : if (exp && exp->card != CARD_AGGR && is_groupby(outer->op) && !is_sql_aggr(f) && rel_find_exp(outer->l, exp))
1664 6 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", tname, cname);
1665 12088 : if (exp && outer && outer->card <= CARD_AGGR && exp->card > CARD_AGGR && !is_sql_aggr(f))
1666 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", tname, cname);
1667 12088 : if (exp && outer && !is_sql_aggr(f)) {
1668 11811 : if (used_lower_after_processed || query_outer_used_exp( query, i, exp, f)) {
1669 0 : sql_exp *lu = used_lower_after_processed?exp:query_outer_last_used(query, i);
1670 0 : if (exp_name(lu) && exp_relname(lu) && !has_label(lu))
1671 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column \"%s.%s\" from outer query", exp_relname(lu), exp_name(lu));
1672 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
1673 : }
1674 : }
1675 12088 : if (exp) {
1676 12087 : int of = query_fetch_outer_state(query, i);
1677 12087 : if (is_groupby(outer->op) && !is_sql_aggr(f)) {
1678 64 : exp = rel_groupby_add_aggr(sql, outer, exp);
1679 64 : exp->card = CARD_ATOM;
1680 12023 : } else if (is_groupby(outer->op) && is_sql_aggr(f) && exps_any_match(outer->exps, exp))
1681 52 : exp = exp_ref(sql, exp);
1682 : else
1683 11971 : exp->card = CARD_ATOM;
1684 12087 : set_freevar(exp, i);
1685 12087 : if (!is_sql_where(of) && !is_sql_aggr(of) && !is_sql_aggr(f) && !outer->grouped)
1686 10373 : set_outer(outer);
1687 : }
1688 12088 : if (exp && outer && (is_select(outer->op) || is_join(outer->op)))
1689 4791 : set_dependent_(outer);
1690 : }
1691 :
1692 : /* some views are just in the stack, like before and after updates views */
1693 1286787 : if (rel && sql->use_views) {
1694 40 : sql_rel *v = stack_find_rel_view(sql, tname);
1695 :
1696 40 : if (v && exp && *rel && is_base(v->op) && v != *rel) /* trigger views are basetables relations, so those may conflict */
1697 0 : return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "SELECT: identifier '%s.%s' ambiguous", tname, cname);
1698 40 : if (v && !exp) {
1699 20 : if (*rel)
1700 0 : *rel = rel_crossproduct(sql->sa, *rel, rel_dup(v), op_join);
1701 : else
1702 20 : *rel = rel_dup(v);
1703 20 : if (!(exp = rel_bind_column3(sql, *rel, sname, tname, cname, f)) && sql->session->status == -ERR_AMBIGUOUS)
1704 : return NULL;
1705 : }
1706 : }
1707 1286767 : if (!exp) { /* If no column was found, try a global variable */
1708 67872 : sql_var *var = NULL;
1709 67872 : sql_subtype *tpe = NULL;
1710 67872 : int level = 0;
1711 67872 : sql_arg *a = NULL;
1712 :
1713 67872 : if (find_variable_on_scope(sql, tname, cname, &var, &a, &tpe, &level, "SELECT")) { /* search schema with table name, ugh */
1714 10 : assert(level == 0);
1715 10 : exp = exp_param_or_declared(sql->sa, sa_strdup(sql->sa, var->sname), sa_strdup(sql->sa, var->name), &(var->var.tpe), 0);
1716 : }
1717 : }
1718 67872 : if (!exp) {
1719 67862 : if (inner && !is_sql_aggr(f) && is_groupby(inner->op) && inner->l && (exp = rel_bind_column3(sql, inner->l, sname, tname, cname, f))) {
1720 54 : if (group_by_pk_project_uk_cond(sql, inner, exp, sname, tname)) {
1721 : /* SQL23 feature: very special case where primary key is used in GROUP BY expression and
1722 : * unique key is in the project list or ORDER BY clause */
1723 1 : sql->session->status = 0;
1724 1 : sql->errstr[0] = 0;
1725 1 : exp->card = CARD_AGGR;
1726 1 : list_append(inner->exps, exp);
1727 : }
1728 : else
1729 53 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", tname, cname);
1730 : }
1731 : }
1732 :
1733 1 : if (!exp)
1734 67808 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42S22) "SELECT: no such column '%s.%s'", tname, cname);
1735 1218926 : if (exp && inner && inner->card <= CARD_AGGR && exp->card > CARD_AGGR && (is_sql_sel(f) || is_sql_having(f)) && !is_sql_aggr(f))
1736 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", tname, cname);
1737 1218926 : if (exp && inner && is_groupby(inner->op) && !is_sql_aggr(f) && !is_freevar(exp))
1738 17732 : exp = rel_groupby_add_aggr(sql, inner, exp);
1739 0 : } else if (dlist_length(l) > 3) {
1740 0 : return sql_error(sql, 02, SQLSTATE(42000) "cross-database references are not implemented");
1741 : }
1742 2331015 : if (exp && !exp_is_atom(exp) && rel && !outer) {
1743 2198597 : if (query->last_exp && query->last_rel == *rel && !is_sql_aggr(query->last_state) && is_sql_aggr(f)) {
1744 55 : if (!is_groupby(query->last_rel->op) || list_empty(query->last_rel->r) || !exps_find_exp(query->last_rel->r, query->last_exp)) {
1745 34 : if (exp_relname(query->last_exp) && exp_name(query->last_exp) && !has_label(query->last_exp))
1746 34 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", exp_relname(query->last_exp), exp_name(query->last_exp));
1747 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
1748 : }
1749 : }
1750 2198563 : query->prev = query->last_exp;
1751 2198563 : query->last_exp = exp;
1752 2198563 : query->last_state = f;
1753 2198563 : query->last_rel = *rel;
1754 : }
1755 : return exp;
1756 : }
1757 :
1758 : int
1759 1035512 : rel_convert_types(mvc *sql, sql_rel *ll, sql_rel *rr, sql_exp **L, sql_exp **R, int scale_fixing, check_type tpe)
1760 : {
1761 1035512 : sql_exp *ls = *L;
1762 1035512 : sql_exp *rs = *R;
1763 1035512 : sql_subtype *lt = exp_subtype(ls);
1764 1035512 : sql_subtype *rt = exp_subtype(rs);
1765 :
1766 1035512 : if (!rt && !lt) {
1767 2 : sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) on both sides of an expression");
1768 2 : return -1;
1769 : }
1770 1035510 : if (rt && (!lt || !lt->type))
1771 7 : return rel_set_type_param(sql, rt, ll, ls, 0);
1772 1035503 : if (lt && (!rt || !rt->type))
1773 648 : return rel_set_type_param(sql, lt, rr, rs, 0);
1774 :
1775 1034855 : if (rt && lt) {
1776 1034855 : sql_subtype *i = lt;
1777 1034855 : sql_subtype *r = rt;
1778 :
1779 1034855 : if (subtype_cmp(lt, rt) != 0 || (tpe == type_equal_no_any && (lt->type->localtype==0 || rt->type->localtype==0))) {
1780 280060 : sql_subtype super;
1781 :
1782 280060 : cmp_supertype(&super, r, i);
1783 280060 : if (scale_fixing) {
1784 : /* convert ls to super type */
1785 280060 : ls = exp_check_type(sql, &super, ll, ls, tpe);
1786 : /* convert rs to super type */
1787 280060 : rs = exp_check_type(sql, &super, rr, rs, tpe);
1788 : } else {
1789 : /* convert ls to super type */
1790 0 : super.scale = lt->scale;
1791 0 : ls = exp_check_type(sql, &super, ll, ls, tpe);
1792 : /* convert rs to super type */
1793 0 : super.scale = rt->scale;
1794 0 : rs = exp_check_type(sql, &super, rr, rs, tpe);
1795 : }
1796 : }
1797 1034855 : *L = ls;
1798 1034855 : *R = rs;
1799 1034855 : if (!ls || !rs)
1800 : return -1;
1801 : return 0;
1802 : }
1803 : return -1;
1804 : }
1805 :
1806 : static sql_rel *
1807 103082 : push_select_exp(mvc *sql, sql_rel *rel, sql_exp *e, sql_exp *ls, int f)
1808 : {
1809 103082 : if (is_outerjoin(rel->op)) {
1810 1195 : if ((is_left(rel->op) || is_full(rel->op)) && rel_find_exp(rel->l, ls)) {
1811 38 : rel_join_add_exp(sql->sa, rel, e);
1812 38 : return rel;
1813 1157 : } else if ((is_right(rel->op) || is_full(rel->op)) && rel_find_exp(rel->r, ls)) {
1814 5 : rel_join_add_exp(sql->sa, rel, e);
1815 5 : return rel;
1816 : }
1817 1152 : if (is_left(rel->op) && rel_find_exp(rel->r, ls)) {
1818 1125 : rel->r = rel_push_select(sql, rel->r, ls, e, f);
1819 1125 : return rel;
1820 27 : } else if (is_right(rel->op) && rel_find_exp(rel->l, ls)) {
1821 11 : rel->l = rel_push_select(sql, rel->l, ls, e, f);
1822 11 : return rel;
1823 : }
1824 : }
1825 : /* push select into the given relation */
1826 101903 : return rel_push_select(sql, rel, ls, e, f);
1827 : }
1828 :
1829 : static sql_rel *
1830 211612 : push_join_exp(mvc *sql, sql_rel *rel, sql_exp *e, sql_exp *L, sql_exp *R, sql_exp *R2, int f)
1831 : {
1832 211612 : sql_rel *r;
1833 211612 : if (/*is_semi(rel->op) ||*/ (is_outerjoin(rel->op) && !is_processed((rel)))) {
1834 21446 : rel_join_add_exp(sql->sa, rel, e);
1835 21446 : return rel;
1836 : }
1837 : /* push join into the given relation */
1838 190166 : if ((r = rel_push_join(sql, rel, L, R, R2, e, f)) != NULL)
1839 : return r;
1840 0 : rel_join_add_exp(sql->sa, rel, e);
1841 0 : return rel;
1842 : }
1843 :
1844 : static sql_rel *
1845 3759 : rel_select_push_filter_exp_down(mvc *sql, sql_rel *rel, sql_exp *e, list *l, list *r, int ff)
1846 : {
1847 3759 : sql_exp *ll;
1848 3759 : if (exps_card(r) <= CARD_ATOM && (exps_are_atoms(r) || exps_have_freevar(sql, r) || exps_have_freevar(sql, l))) {
1849 3660 : if (exps_card(l) == exps_card(r) || rel->processed) /* bin compare op */
1850 96 : return rel_select(sql->sa, rel, e);
1851 3564 : if ((ll = exps_find_one_multi_exp(l)))
1852 3564 : return push_select_exp(sql, rel, e, ll, ff);
1853 : }
1854 99 : if (is_outerjoin(rel->op))
1855 7 : return rel_select(sql->sa, rel, e);
1856 92 : return rel_select_add_exp(sql->sa, rel, e);
1857 : }
1858 :
1859 : static sql_rel *
1860 3640 : rel_filter(mvc *sql, sql_rel *rel, list *l, list *r, char *sname, char *filter_op, int anti, int ff)
1861 : {
1862 3640 : node *n;
1863 3640 : sql_exp *e = NULL;
1864 3640 : sql_subfunc *f = NULL;
1865 3640 : list *tl = sa_list(sql->sa);
1866 3640 : bool found = false;
1867 :
1868 7284 : for (n = l->h; n; n = n->next){
1869 3644 : sql_exp *e = n->data;
1870 :
1871 3644 : list_append(tl, exp_subtype(e));
1872 : }
1873 14482 : for (n = r->h; n; n = n->next){
1874 10842 : sql_exp *e = n->data;
1875 :
1876 10842 : list_append(tl, exp_subtype(e));
1877 : }
1878 : /* find filter function */
1879 3640 : f = bind_func_(sql, sname, filter_op, tl, F_FILT, false, &found, false);
1880 3640 : if (f) {
1881 3638 : node *n,*m = f->func->ops->h;
1882 3638 : list *nexps = sa_list(sql->sa);
1883 :
1884 7280 : for(n=l->h; m && n; m = m->next, n = n->next) {
1885 3642 : sql_arg *a = m->data;
1886 3642 : sql_exp *e = n->data;
1887 :
1888 3642 : e = exp_check_type(sql, &a->type, rel, e, type_equal);
1889 3642 : if (!e)
1890 : return NULL;
1891 3642 : list_append(nexps, e);
1892 : }
1893 3638 : l = nexps;
1894 3638 : nexps = sa_list(sql->sa);
1895 14472 : for(n=r->h; m && n; m = m->next, n = n->next) {
1896 10834 : sql_arg *a = m->data;
1897 10834 : sql_exp *e = n->data;
1898 :
1899 10834 : e = exp_check_type(sql, &a->type, rel, e, type_equal);
1900 10834 : if (!e)
1901 : return NULL;
1902 10834 : list_append(nexps, e);
1903 : }
1904 : r = nexps;
1905 : }
1906 3640 : if (!f)
1907 4 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s FILTER function %s%s%s'%s'",
1908 2 : found ? "insufficient privileges for" : "no such", sname ? "'":"", sname ? sname : "", sname ? "'.":"", filter_op);
1909 3638 : e = exp_filter(sql->sa, l, r, f, anti);
1910 :
1911 3638 : if (exps_one_is_rel(l) || exps_one_is_rel(r)) /* uncorrelated subquery case */
1912 9 : return rel_select(sql->sa, rel, e);
1913 : /* atom or row => select */
1914 7262 : for (node *n=l->h; n; n = n->next) {
1915 3633 : sql_exp *ls = n->data;
1916 :
1917 3633 : if (ls->card > rel->card) {
1918 0 : if (exp_name(ls) && !has_label(ls))
1919 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(ls));
1920 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
1921 : }
1922 : }
1923 14436 : for (node *n=r->h; n; n = n->next) {
1924 10807 : sql_exp *rs = n->data;
1925 :
1926 10807 : if (rs->card > rel->card) {
1927 0 : if (exp_name(rs) && !has_label(rs))
1928 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(rs));
1929 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
1930 : }
1931 : }
1932 3629 : return rel_select_push_filter_exp_down(sql, rel, e, l, r, ff);
1933 : }
1934 :
1935 : static sql_rel *
1936 3575 : rel_filter_exp_(mvc *sql, sql_rel *rel, sql_exp *ls, sql_exp *r1, sql_exp *r2, sql_exp *r3, char *filter_op, int anti, int f)
1937 : {
1938 3575 : list *l = sa_list(sql->sa);
1939 3575 : list *r = sa_list(sql->sa);
1940 :
1941 3575 : list_append(l, ls);
1942 3575 : list_append(r, r1);
1943 3575 : if (r2)
1944 3575 : list_append(r, r2);
1945 3575 : if (r3)
1946 3575 : list_append(r, r3);
1947 3575 : return rel_filter(sql, rel, l, r, "sys", filter_op, anti, f);
1948 : }
1949 :
1950 : static sql_rel *
1951 380128 : rel_select_push_compare_exp_down(mvc *sql, sql_rel *rel, sql_exp *e, sql_exp *ls, sql_exp *rs, sql_exp *rs2, int f)
1952 : {
1953 380128 : if (!is_join(rel->op) && !is_select(rel->op))
1954 85171 : return rel_select(sql->sa, rel, e);
1955 378853 : if ((rs->card <= CARD_ATOM || (rs2 && ls->card <= CARD_ATOM)) &&
1956 167792 : (exp_is_atom(rs) || (rs2 && exp_is_atom(ls)) || exp_has_freevar(sql, rs) || exp_has_freevar(sql, ls)) &&
1957 482 : (!rs2 || (rs2->card <= CARD_ATOM && (exp_is_atom(rs2) || exp_has_freevar(sql, rs2))))) {
1958 83345 : if (ls->card == rs->card || (rs2 && (ls->card == rs2->card || rs->card == rs2->card)) || rel->processed) /* bin compare op */
1959 1018 : return rel_select(sql->sa, rel, e);
1960 :
1961 82327 : return push_select_exp(sql, rel, e, ls, f);
1962 : } else { /* join */
1963 211612 : return push_join_exp(sql, rel, e, ls, rs, rs2, f);
1964 : }
1965 : return rel;
1966 : }
1967 :
1968 : static sql_rel *
1969 353056 : rel_compare_exp_(sql_query *query, sql_rel *rel, sql_exp *ls, sql_exp *rs, sql_exp *rs2, int type, int anti, int quantifier, int f, int symmetric, int is_semantics)
1970 : {
1971 353056 : mvc *sql = query->sql;
1972 353056 : sql_exp *e = NULL;
1973 :
1974 353056 : if (quantifier || exp_is_rel(ls) || exp_is_rel(rs) || (rs2 && exp_is_rel(rs2))) {
1975 3350 : if (rs2) {
1976 7 : e = exp_compare2(sql->sa, ls, rs, rs2, type, symmetric);
1977 7 : if (anti)
1978 0 : set_anti(e);
1979 : } else {
1980 3343 : assert(!symmetric);
1981 3343 : if (rel_convert_types(sql, rel, rel, &ls, &rs, 1, type_equal_no_any) < 0)
1982 : return NULL;
1983 3343 : e = exp_compare_func(sql, ls, rs, compare_func((comp_type)type, anti), quantifier);
1984 : }
1985 3350 : return rel_select(sql->sa, rel, e);
1986 349706 : } else if (!rs2) {
1987 346780 : assert(!symmetric);
1988 346780 : if (ls->card < rs->card) {
1989 8825 : sql_exp *swap = ls;
1990 8825 : ls = rs;
1991 8825 : rs = swap;
1992 8825 : type = (int)swap_compare((comp_type)type);
1993 : }
1994 346780 : if (rel_convert_types(sql, rel, rel, &ls, &rs, 1, type_equal_no_any) < 0)
1995 : return NULL;
1996 346777 : e = exp_compare(sql->sa, ls, rs, type);
1997 346777 : if (is_semantics) set_semantics(e);
1998 : } else {
1999 2926 : assert(rs2);
2000 2926 : if (rel_convert_types(sql, rel, rel, &ls, &rs, 1, type_equal_no_any) < 0)
2001 : return NULL;
2002 2926 : if (!(rs2 = exp_check_type(sql, exp_subtype(ls), rel, rs2, type_equal)))
2003 : return NULL;
2004 2926 : e = exp_compare2(sql->sa, ls, rs, rs2, type, symmetric);
2005 : }
2006 349703 : if (anti)
2007 837 : set_anti(e);
2008 :
2009 349703 : if (!rel)
2010 0 : return rel_select(sql->sa, rel_project_exp(sql, exp_atom_bool(sql->sa, 1)), e);
2011 :
2012 : /* atom or row => select */
2013 349703 : if (ls->card > rel->card || rs->card > rel->card || (rs2 && rs2->card > rel->card)) {
2014 0 : sql_exp *e = ls->card > rel->card ? ls : rs->card > rel->card ? rs : rs2;
2015 0 : if (exp_name(e) && !has_label(e))
2016 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(e));
2017 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
2018 : }
2019 349703 : return rel_select_push_compare_exp_down(sql, rel, e, ls, rs, rs2, f);
2020 : }
2021 :
2022 : static sql_rel *
2023 350123 : rel_compare_exp(sql_query *query, sql_rel *rel, sql_exp *ls, sql_exp *rs, char *compare_op, int reduce, int quantifier, int need_not, int f, int is_semantics)
2024 : {
2025 350123 : mvc *sql = query->sql;
2026 350123 : comp_type type = cmp_equal;
2027 :
2028 350123 : if (!ls || !rs)
2029 : return NULL;
2030 :
2031 350123 : if (!quantifier && ((!rel && !query_has_outer(query)) || !reduce)) {
2032 : /* TODO to handle filters here */
2033 0 : sql_exp *e;
2034 :
2035 0 : if (rel_convert_types(sql, rel, rel, &ls, &rs, 1, type_equal_no_any) < 0)
2036 : return NULL;
2037 0 : e = rel_binop_(sql, rel, ls, rs, "sys", compare_op, card_value, true);
2038 :
2039 0 : if (!e)
2040 : return NULL;
2041 0 : if (!reduce) {
2042 0 : if (rel->op == op_project) {
2043 0 : append(rel->exps, e);
2044 : } else {
2045 0 : list *exps = new_exp_list(sql->sa);
2046 :
2047 0 : append(exps, e);
2048 0 : return rel_project(sql->sa, rel, exps);
2049 : }
2050 : } else {
2051 0 : return rel_select(sql->sa, rel, e);
2052 : }
2053 : }
2054 350123 : type = compare_str2type(compare_op);
2055 350123 : assert(type != cmp_filter);
2056 350123 : return rel_compare_exp_(query, rel, ls, rs, NULL, type, need_not, quantifier, f, 0, is_semantics);
2057 : }
2058 :
2059 : static sql_rel *
2060 350094 : rel_compare(sql_query *query, sql_rel *rel, symbol *sc, symbol *lo, symbol *ro, char *compare_op, int f, exp_kind k, int quantifier, int is_semantics)
2061 : {
2062 350094 : mvc *sql = query->sql;
2063 350094 : sql_exp *rs = NULL, *ls;
2064 350094 : comp_type cmp_type = compare_str2type(compare_op);
2065 350094 : exp_kind ek = {type_value, card_column, FALSE};
2066 350094 : int need_not = 0;
2067 :
2068 350094 : if ((quantifier == 1 && cmp_type == cmp_equal) ||
2069 350059 : (quantifier == 2 && cmp_type == cmp_notequal)) {
2070 61 : dnode *n = sc->data.lval->h;
2071 61 : dlist *dl = dlist_create(sql->sa);
2072 : /* map into IN/NOT IN */
2073 61 : sc->token = cmp_type==cmp_equal?SQL_IN:SQL_NOT_IN;
2074 61 : n->next->type = type_list;
2075 61 : n->next->data.lval = dl;
2076 61 : n->next->next->next = NULL; /* remove quantifier */
2077 61 : dl->h = n->next->next;
2078 61 : n->next->next = NULL; /* (remove comparison) moved righthand side */
2079 61 : return rel_logical_exp(query, rel, sc, f);
2080 : }
2081 : /* <> ANY -> NOT (= ALL) */
2082 350033 : if (quantifier == 1 && cmp_type == cmp_notequal) {
2083 5 : need_not = 1;
2084 5 : quantifier = 2;
2085 5 : cmp_type = cmp_equal;
2086 5 : compare_op = "=";
2087 : }
2088 :
2089 350033 : if ((lo->token == SQL_SELECT || lo->token == SQL_UNION || lo->token == SQL_EXCEPT || lo->token == SQL_INTERSECT || lo->token == SQL_VALUES) &&
2090 41 : (ro->token != SQL_SELECT && ro->token != SQL_UNION && ro->token != SQL_EXCEPT && ro->token != SQL_INTERSECT && ro->token != SQL_VALUES)) {
2091 28 : symbol *tmp = lo; /* swap subquery to the right hand side */
2092 :
2093 28 : lo = ro;
2094 28 : ro = tmp;
2095 :
2096 28 : if (compare_op[0] == '>')
2097 16 : compare_op[0] = '<';
2098 12 : else if (compare_op[0] == '<' && compare_op[1] != '>')
2099 1 : compare_op[0] = '>';
2100 28 : cmp_type = swap_compare(cmp_type);
2101 : }
2102 :
2103 350033 : ls = rel_value_exp(query, &rel, lo, f|sql_farg, ek);
2104 350033 : if (!ls)
2105 : return NULL;
2106 349985 : if (ls && rel && exp_has_freevar(sql, ls) && is_sql_sel(f))
2107 0 : ls = rel_project_add_exp(sql, rel, ls);
2108 349985 : if (quantifier)
2109 57 : ek.card = card_set;
2110 :
2111 349985 : rs = rel_value_exp(query, &rel, ro, f|sql_farg, ek);
2112 349985 : if (!rs)
2113 : return NULL;
2114 349955 : if (ls->card > rs->card && rs->card == CARD_AGGR && is_sql_having(f)) {
2115 0 : if (exp_name(ls) && exp_relname(ls) && !has_label(ls))
2116 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", exp_relname(ls), exp_name(ls));
2117 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
2118 : }
2119 349955 : if (rs->card > ls->card && ls->card == CARD_AGGR && is_sql_having(f)) {
2120 0 : if (exp_name(rs) && exp_relname(rs) && !has_label(rs))
2121 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", exp_relname(rs), exp_name(rs));
2122 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
2123 : }
2124 349955 : return rel_compare_exp(query, rel, ls, rs, compare_op, k.reduce, quantifier, need_not, f, is_semantics);
2125 : }
2126 :
2127 : static sql_exp*
2128 560623 : _rel_nop(mvc *sql, char *sname, char *fname, list *tl, sql_rel *rel, list *exps, exp_kind ek)
2129 : {
2130 560623 : bool found = false;
2131 560623 : int table_func = (ek.card == card_relation);
2132 560623 : sql_ftype type = (ek.card == card_loader)?F_LOADER:((ek.card == card_none)?F_PROC:
2133 : ((ek.card == card_relation)?F_UNION:F_FUNC));
2134 :
2135 560623 : sql_subfunc *f = bind_func_(sql, sname, fname, tl, type, false, &found, false);
2136 560623 : if (f && !(exps = check_arguments_and_find_largest_any_type(sql, rel, exps, f, table_func, false)))
2137 : f = NULL;
2138 :
2139 560355 : if (f)
2140 560355 : return exp_op(sql->sa, exps, f);
2141 267 : char *arg_list = nary_function_arg_types_2str(sql, tl, list_length(tl));
2142 551 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s operator %s%s%s'%s'(%s)",
2143 267 : found ? "insufficient privileges for" : "no such", sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname, arg_list ? arg_list : "");
2144 : }
2145 :
2146 : static sql_exp *
2147 2110 : exp_exist(sql_query *query, sql_rel *rel, sql_exp *le, int exists)
2148 : {
2149 2110 : mvc *sql = query->sql;
2150 2110 : sql_subfunc *exists_func = NULL;
2151 2110 : sql_subtype *t;
2152 2110 : sql_exp *res;
2153 :
2154 2110 : if (!exp_name(le))
2155 753 : exp_label(sql->sa, le, ++sql->label);
2156 2110 : if (exp_is_rel(le)) { /* for the subquery case, propagate to the inner query */
2157 2110 : sql_rel *r = exp_rel_get_rel(sql->sa, le);
2158 2110 : if (is_project(r->op) && !list_empty(r->exps)) {
2159 6151 : for (node *n = r->exps->h; n; n = n->next)
2160 4041 : if (!exp_subtype(n->data) && rel_set_type_param(sql, sql_bind_localtype("bit"), r, n->data, 0) < 0) /* workaround */
2161 : return NULL;
2162 2110 : le->tpe = *exp_subtype(r->exps->h->data); /* just take the first expression type */
2163 : }
2164 0 : } else if (!exp_subtype(le) && rel_set_type_param(sql, sql_bind_localtype("bit"), rel, le, 0) < 0) /* workaround */
2165 : return NULL;
2166 2110 : t = exp_subtype(le);
2167 :
2168 2171 : if (!(exists_func = sql_bind_func(sql, "sys", exists ? "sql_exists" : "sql_not_exists", t, NULL, F_FUNC, true, true)))
2169 0 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "exist operator on type %s missing", t ? t->type->base.name : "unknown");
2170 2110 : res = exp_unop(sql->sa, le, exists_func);
2171 2110 : set_has_no_nil(res);
2172 2110 : return res;
2173 : }
2174 :
2175 : static sql_exp *
2176 1105 : rel_exists_value_exp(sql_query *query, sql_rel **rel, symbol *sc, int f)
2177 : {
2178 1105 : exp_kind ek = {type_value, card_exists, FALSE};
2179 1105 : sql_exp *le, *e;
2180 :
2181 1105 : le = rel_value_exp(query, rel, sc->data.sym, f|sql_farg, ek);
2182 1105 : if (!le)
2183 : return NULL;
2184 1104 : if (!(e = exp_exist(query, rel ? *rel : NULL, le, sc->token == SQL_EXISTS)))
2185 : return NULL;
2186 : /* only freevar should have CARD_AGGR */
2187 1104 : e->card = CARD_ATOM;
2188 1104 : return e;
2189 : }
2190 :
2191 : static sql_rel *
2192 1014 : rel_exists_exp(sql_query *query, sql_rel *rel, symbol *sc, int f)
2193 : {
2194 1014 : exp_kind ek = {type_value, card_exists, TRUE};
2195 1014 : mvc *sql = query->sql;
2196 1014 : sql_rel *sq = NULL;
2197 :
2198 1014 : if (is_psm_call(f) || is_sql_merge(f))
2199 3 : return sql_error(sql, 02, SQLSTATE(42000) "%s: subqueries not supported inside %s", is_psm_call(f) ? "CALL" : "MERGE", is_psm_call(f) ? "CALL statements" : "MERGE conditions");
2200 1013 : if (rel) {
2201 1013 : query_processed(query);
2202 1013 : query_push_outer(query, rel, f);
2203 : }
2204 1013 : sq = rel_subquery(query, sc->data.sym, ek);
2205 1013 : if (rel)
2206 1013 : rel = query_pop_outer(query);
2207 1013 : assert(!is_sql_sel(f));
2208 1013 : if (sq) {
2209 1006 : sql_exp *e = exp_rel(sql, sq);
2210 1006 : if (!(e = exp_exist(query, rel, e, sc->token == SQL_EXISTS)))
2211 : return NULL;
2212 : /* only freevar should have CARD_AGGR */
2213 1006 : e->card = CARD_ATOM;
2214 1006 : rel = rel_select_add_exp(sql->sa, rel, e);
2215 1006 : return rel;
2216 : }
2217 : return NULL;
2218 : }
2219 :
2220 : static int
2221 8662 : is_project_true(sql_rel *r)
2222 : {
2223 8662 : if (r && !r->l && list_length(r->exps) == 1) {
2224 82 : sql_exp *e = r->exps->h->data;
2225 82 : if (exp_is_atom(e) && exp_is_true(e))
2226 : return 1;
2227 : }
2228 : return 0;
2229 : }
2230 :
2231 : static sql_exp *
2232 65202 : rel_in_value_exp(sql_query *query, sql_rel **rel, symbol *sc, int f)
2233 : {
2234 65202 : mvc *sql = query->sql;
2235 65202 : exp_kind ek = {type_value, card_column, TRUE};
2236 65202 : dlist *dl = sc->data.lval;
2237 65202 : symbol *lo = NULL;
2238 65202 : dnode *n = dl->h->next, *dn = NULL;
2239 65202 : sql_exp *le = NULL, *re, *e = NULL;
2240 65202 : list *ll = sa_list(sql->sa);
2241 65202 : int is_tuple = 0, add_select = 0;
2242 :
2243 : /* complex case */
2244 : //if (dl->h->type == type_list) { /* (a,b..) in (.. ) */
2245 65202 : if (dl->h->type == type_symbol && dl->h->data.sym->token == SQL_VALUES) {
2246 4227 : lo = dl->h->data.sym;
2247 4227 : dn = lo->data.lval->h->data.lval->h;
2248 4227 : lo = dn->data.sym;
2249 4227 : dn = dn->next;
2250 : } else {
2251 60975 : lo = dl->h->data.sym;
2252 : }
2253 206220 : for( ; lo; lo = dn?dn->data.sym:NULL, dn = dn?dn->next:NULL ) {
2254 70513 : le = rel_value_exp(query, rel, lo, f|sql_farg, ek);
2255 70513 : if (!le)
2256 : return NULL;
2257 70509 : append(ll, le);
2258 : }
2259 65198 : if (list_length(ll) == 1) {
2260 60973 : le = ll->h->data;
2261 60973 : ek.card = card_set;
2262 : } else {
2263 4225 : le = exp_values(sql->sa, ll);
2264 4225 : exp_label(sql->sa, le, ++sql->label);
2265 4225 : ek.type = list_length(ll);
2266 4225 : is_tuple = list_length(ll);
2267 : }
2268 : /* list of values or subqueries */
2269 : /* 3 right hand side cases,
2270 : * 1 - value/tuple list of atoms
2271 : * 2 - list of scalar sub queries (needs check on 1 row/column per query)
2272 : * 3 - single tabular ie. multi column, multi row query
2273 : */
2274 65198 : if (n->type == type_list) {
2275 65198 : sql_exp *values;
2276 65198 : list *vals = sa_list(sql->sa);
2277 :
2278 65198 : n = dl->h->next;
2279 65198 : n = n->data.lval->h;
2280 :
2281 319782 : for (; n; n = n->next) {
2282 254623 : if (n->type == type_list) {
2283 0 : dnode *m = n->data.lval->h;
2284 0 : list *rl = sa_list(sql->sa);
2285 0 : for (; m; m = m->next) {
2286 0 : assert(m->type == type_symbol);
2287 0 : sql_exp *re = rel_value_exp(query, rel, m->data.sym, f|sql_farg, ek);
2288 0 : if (!re)
2289 : return NULL;
2290 0 : append(rl, re);
2291 : }
2292 0 : re = exp_values(sql->sa, rl);
2293 : } else {
2294 254623 : assert(n->type == type_symbol);
2295 254623 : re = rel_value_exp(query, rel, n->data.sym, f|sql_farg, ek);
2296 : }
2297 254623 : if (!re)
2298 : return NULL;
2299 254599 : if (is_tuple && (!exp_is_rel(re) && !is_values(re)))
2300 4 : return sql_error(sql, 02, SQLSTATE(42000) "Cannot match a tuple to a single value");
2301 4223 : if (is_tuple && exp_is_rel(re)) {
2302 4223 : sql_rel *r = exp_rel_get_rel(sql->sa, re);
2303 :
2304 4223 : if (!r)
2305 0 : return sql_error(sql, 02, SQLSTATE(42000) "Subquery missing");
2306 4223 : if (r->nrcols != ek.type)
2307 12 : return sql_error(sql, 02, SQLSTATE(42000) "Subquery has too %s columns", (r->nrcols < ek.type) ? "few" : "many");
2308 4214 : re = exp_rel_label(sql, re);
2309 4214 : if (r && r->l && n->next) /* not a value list */
2310 2 : return sql_error(sql, 02, SQLSTATE(42000) "subquery must return only one column");
2311 250372 : } else if (exp_is_rel(re)) {
2312 8663 : sql_rel *r = exp_rel_get_rel(sql->sa, re);
2313 8663 : add_select = 1;
2314 8663 : if (rel && *rel && is_join((*rel)->op))
2315 4506 : set_dependent((*rel));
2316 8663 : if (is_project(r->op) && is_project_true(r->l) && list_length(r->exps) == 1)
2317 80 : re = r->exps->h->data;
2318 241709 : } else if (is_values(re) && is_tuple != list_length(exp_get_values(re))) {
2319 0 : return sql_error(sql, 02, SQLSTATE(42000) "Tuple sizes do not match");
2320 : }
2321 254584 : append(vals, re);
2322 : }
2323 :
2324 65159 : if (list_empty(vals))
2325 0 : return sql_error(sql, 02, SQLSTATE(42000) "The list of values for IN operator cannot be empty");
2326 :
2327 65159 : values = exp_values(sql->sa, vals);
2328 65159 : exp_label(sql->sa, values, ++sql->label);
2329 65159 : if (is_tuple) {
2330 4210 : if (!(values = exp_tuples_set_supertype(sql, exp_get_values(le), values)))
2331 : return NULL;
2332 4210 : if (!(le->f = tuples_check_types(sql, exp_get_values(le), values)))
2333 : return NULL;
2334 : } else { /* if it's not a tuple, enforce coercion on the type for every element on the list */
2335 60949 : sql_subtype super, *le_tpe = exp_subtype(le), *values_tpe = NULL;
2336 :
2337 311320 : for (node *m = vals->h; m; m = m->next) { /* first get values supertype */
2338 250371 : sql_exp *e = m->data;
2339 250371 : sql_subtype *tpe = exp_subtype(e);
2340 :
2341 250371 : if (values_tpe && tpe) {
2342 189419 : cmp_supertype(&super, values_tpe, tpe);
2343 189419 : *values_tpe = super;
2344 60952 : } else if (!values_tpe && tpe) {
2345 60945 : super = *tpe;
2346 60945 : values_tpe = &super;
2347 : }
2348 : }
2349 60949 : if (!le_tpe)
2350 2 : le_tpe = values_tpe;
2351 60949 : if (!values_tpe)
2352 4 : values_tpe = le_tpe;
2353 60949 : if (!le_tpe || !values_tpe)
2354 1 : return sql_error(sql, 01, SQLSTATE(42000) "For the IN operator, both sides must have a type defined");
2355 60948 : cmp_supertype(&super, values_tpe, le_tpe); /* compute supertype */
2356 :
2357 : /* on selection/join cases we can generate cmp expressions instead of anyequal for trivial cases */
2358 60948 : if ((is_sql_where(f) || is_sql_having(f)) && !is_sql_farg(f) && !exp_has_rel(le) && exps_are_atoms(vals)) {
2359 22665 : if (list_length(vals) == 1) { /* use cmp_equal instead of cmp_in for 1 expression */
2360 112 : sql_exp *first = vals->h->data;
2361 112 : if (rel_convert_types(sql, rel ? *rel : NULL, rel ? *rel : NULL, &le, &first, 1, type_equal_no_any) < 0)
2362 0 : return NULL;
2363 134 : e = exp_compare(sql->sa, le, first, (sc->token == SQL_IN) ? cmp_equal : cmp_notequal);
2364 : } else { /* use cmp_in instead of anyequal for n simple expressions */
2365 108215 : for (node *n = vals->h ; n ; n = n->next)
2366 85662 : if ((n->data = exp_check_type(sql, &super, rel ? *rel : NULL, n->data, type_equal)) == NULL)
2367 : return NULL;
2368 22553 : if ((le = exp_check_type(sql, &super, rel ? *rel : NULL, le, type_equal)) == NULL)
2369 : return NULL;
2370 29865 : e = exp_in(sql->sa, le, vals, (sc->token == SQL_IN) ? cmp_in : cmp_notin);
2371 : }
2372 : }
2373 22665 : if (!e) { /* after computing supertype, check types for each IN value */
2374 202879 : for (node *n = vals->h ; n ; n = n->next)
2375 164596 : if ((n->data = exp_check_type(sql, &super, rel ? *rel : NULL, n->data, type_equal)) == NULL)
2376 : return NULL;
2377 38283 : values->tpe = *exp_subtype(vals->h->data);
2378 38283 : if (!(le = exp_check_type(sql, &super, rel ? *rel : NULL, le, type_equal)))
2379 : return NULL;
2380 : }
2381 : }
2382 60948 : if (!e) {
2383 42493 : if (add_select && rel && *rel && !is_project((*rel)->op) && !is_select((*rel)->op) && !is_base((*rel)->op))
2384 4505 : *rel = rel_select(sql->sa, *rel, NULL);
2385 42493 : if ((rel && *rel) || exp_has_rel(le) || exp_has_rel(values))
2386 36835 : e = exp_in_func(sql, le, values, (sc->token == SQL_IN), is_tuple);
2387 : else
2388 5658 : e = exp_in_aggr(sql, le, values, (sc->token == SQL_IN), is_tuple);
2389 : }
2390 : }
2391 : return e;
2392 : }
2393 :
2394 : static sql_rel *
2395 32948 : rel_in_exp(sql_query *query, sql_rel *rel, symbol *sc, int f)
2396 : {
2397 32948 : mvc *sql = query->sql;
2398 32948 : sql_exp *e = rel_in_value_exp(query, &rel, sc, f);
2399 :
2400 32948 : assert(!is_sql_sel(f));
2401 32948 : if (!e || !rel)
2402 : return NULL;
2403 :
2404 32921 : if (e->type == e_cmp) { /* it's a exp_in or cmp_equal of simple expressions, push down early on if possible */
2405 22663 : sql_exp *ls = e->l;
2406 22663 : bool rlist = (e->flag == cmp_in || e->flag == cmp_notin);
2407 22663 : unsigned int rcard = rlist ? exps_card(e->r) : exp_card(e->r);
2408 22663 : int r_is_atoms = rlist ? exps_are_atoms(e->r) : exp_is_atom(e->r);
2409 22663 : int r_has_freevar = rlist ? exps_have_freevar(sql, e->r) : exp_has_freevar(sql, e->r);
2410 :
2411 22663 : if (rcard <= CARD_ATOM && (r_is_atoms || r_has_freevar || exp_has_freevar(sql, ls))) {
2412 22663 : if ((exp_card(ls) == rcard) || rel->processed) /* bin compare op */
2413 5472 : return rel_select(sql->sa, rel, e);
2414 :
2415 17191 : return push_select_exp(sql, rel, e, ls, f);
2416 : } else { /* join */
2417 0 : sql_exp *rs = rlist ? exps_find_one_multi_exp(e->r) : e->r;
2418 0 : if (rs)
2419 0 : return push_join_exp(sql, rel, e, ls, rs, NULL, f);
2420 : }
2421 : }
2422 10258 : if (is_outerjoin(rel->op))
2423 13 : return rel_select(sql->sa, rel, e);
2424 10245 : return rel_select_add_exp(sql->sa, rel, e);
2425 : }
2426 :
2427 : static int
2428 3111 : exp_between_check_types(sql_subtype *res, sql_subtype *t1, sql_subtype *t2, sql_subtype *t3)
2429 : {
2430 3111 : bool type_found = false;
2431 3111 : sql_subtype super;
2432 :
2433 3111 : if (t1 && t2) {
2434 3105 : cmp_supertype(&super, t2, t1);
2435 3105 : type_found = true;
2436 6 : } else if (t1) {
2437 3 : super = *t1;
2438 3 : type_found = true;
2439 3 : } else if (t2) {
2440 1 : super = *t2;
2441 1 : type_found = true;
2442 : }
2443 3111 : if (t3) {
2444 3108 : if (type_found)
2445 3107 : cmp_supertype(&super, t3, &super);
2446 : else
2447 1 : super = *t3;
2448 : type_found = true;
2449 : }
2450 3 : if (!type_found)
2451 : return -1;
2452 3110 : *res = super;
2453 3110 : return 0;
2454 : }
2455 :
2456 : static bool
2457 128051 : exp_is_null_no_value_opt(sql_exp *e)
2458 : {
2459 128051 : if (!e)
2460 : return false;
2461 131994 : while (is_convert(e->type))
2462 3943 : e = e->l;
2463 256075 : return e->type == e_atom && e->l && atom_null(e->l);
2464 : }
2465 :
2466 : sql_exp *
2467 2737107 : rel_logical_value_exp(sql_query *query, sql_rel **rel, symbol *sc, int f, exp_kind ek)
2468 : {
2469 2737107 : mvc *sql = query->sql;
2470 :
2471 2737107 : if (!sc)
2472 : return NULL;
2473 :
2474 2737107 : if (mvc_highwater(sql))
2475 2 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
2476 :
2477 2737106 : switch (sc->token) {
2478 59870 : case SQL_OR:
2479 : case SQL_AND:
2480 : {
2481 59870 : symbol *lo = sc->data.lval->h->data.sym;
2482 59870 : symbol *ro = sc->data.lval->h->next->data.sym;
2483 59870 : sql_exp *ls, *rs;
2484 :
2485 59870 : if (!(ls = rel_value_exp(query, rel, lo, f|sql_farg, ek)))
2486 : return NULL;
2487 59869 : if (!(rs = rel_value_exp(query, rel, ro, f|sql_farg, ek)))
2488 : return NULL;
2489 103701 : return rel_binop_(sql, rel ? *rel : NULL, ls, rs, "sys", sc->token == SQL_OR ? "or": "and", card_value, false);
2490 : }
2491 5 : case SQL_FILTER:
2492 : /* [ x,..] filter [ y,..] */
2493 : /* todo add anti, [ x,..] not filter [ y,...] */
2494 : /* no correlation */
2495 : {
2496 5 : dnode *ln = sc->data.lval->h->data.lval->h;
2497 5 : dnode *rn = sc->data.lval->h->next->next->data.lval->h;
2498 5 : dlist *filter_op = sc->data.lval->h->next->data.lval;
2499 5 : char *fname = qname_schema_object(filter_op);
2500 5 : char *sname = qname_schema(filter_op);
2501 5 : list *exps, *tl;
2502 5 : sql_subtype *obj_type = NULL;
2503 :
2504 5 : exps = sa_list(sql->sa);
2505 5 : tl = sa_list(sql->sa);
2506 15 : for (; ln; ln = ln->next) {
2507 5 : symbol *sym = ln->data.sym;
2508 :
2509 5 : sql_exp *e = rel_value_exp(query, rel, sym, f|sql_farg, ek);
2510 5 : if (!e)
2511 : return NULL;
2512 5 : if (!obj_type)
2513 5 : obj_type = exp_subtype(e);
2514 5 : list_append(exps, e);
2515 5 : append(tl, exp_subtype(e));
2516 : }
2517 13 : for (; rn; rn = rn->next) {
2518 10 : symbol *sym = rn->data.sym;
2519 :
2520 10 : sql_exp *e = rel_value_exp(query, rel, sym, f|sql_farg, ek);
2521 10 : if (!e)
2522 : return NULL;
2523 8 : list_append(exps, e);
2524 8 : append(tl, exp_subtype(e));
2525 : }
2526 : /* find the predicate filter function */
2527 3 : return _rel_nop(sql, sname, fname, tl, rel ? *rel : NULL, exps, ek);
2528 : }
2529 127770 : case SQL_COMPARE:
2530 : {
2531 127770 : dnode *n = sc->data.lval->h;
2532 127770 : symbol *lo = n->data.sym;
2533 127770 : symbol *ro = n->next->next->data.sym;
2534 127770 : char *compare_op = n->next->data.sval;
2535 127770 : int quantifier = 0, need_not = 0;
2536 127770 : sql_exp *rs = NULL, *ls;
2537 127770 : comp_type cmp_type = compare_str2type(compare_op);
2538 127770 : bool is_not_distinct_from = false;
2539 127770 : bool is_distinct_from = false;
2540 :
2541 : /*
2542 : * = ANY -> IN, <> ALL -> NOT( = ANY) -> NOT IN
2543 : * = ALL -> all(groupby(all, nil)), <> ANY -> NOT ( = ALL )
2544 : */
2545 127770 : if (n->next->next->next)
2546 261 : quantifier = n->next->next->next->data.i_val + 1;
2547 261 : assert(quantifier == 0 || quantifier == 1 || quantifier == 2 || quantifier == 3 || quantifier == 4);
2548 :
2549 : /* [NOT] DISTINCT FROM */
2550 127770 : if (quantifier == 3) {
2551 : is_not_distinct_from = true;
2552 : quantifier = 0;
2553 : }
2554 127755 : else if (quantifier == 4) {
2555 13 : is_distinct_from = true;
2556 13 : quantifier = 0;
2557 : }
2558 :
2559 127770 : if ((quantifier == 1 && cmp_type == cmp_equal) ||
2560 127703 : (quantifier == 2 && cmp_type == cmp_notequal)) {
2561 95 : dlist *dl = dlist_create(sql->sa);
2562 : /* map into IN/NOT IN */
2563 95 : sc->token = cmp_type==cmp_equal?SQL_IN:SQL_NOT_IN;
2564 95 : n->next->type = type_list;
2565 95 : n->next->data.lval = dl;
2566 95 : n->next->next->next = NULL; /* remove quantifier */
2567 95 : dl->h = n->next->next;
2568 95 : n->next->next = NULL; /* (remove comparison) moved righthand side */
2569 95 : return rel_logical_value_exp(query, rel, sc, f, ek);
2570 : }
2571 : /* <> ANY -> NOT (= ALL) */
2572 127675 : if (quantifier == 1 && cmp_type == cmp_notequal) {
2573 18 : need_not = 1;
2574 18 : quantifier = 2;
2575 18 : cmp_type = cmp_equal;
2576 18 : compare_op = "=";
2577 : }
2578 :
2579 127675 : ls = rel_value_exp(query, rel, lo, f|sql_farg, ek);
2580 127675 : if (!ls)
2581 : return NULL;
2582 127663 : if (quantifier)
2583 138 : ek.card = card_set;
2584 :
2585 127663 : rs = rel_value_exp(query, rel, ro, f|sql_farg, ek);
2586 127663 : if (!rs)
2587 : return NULL;
2588 :
2589 127653 : if (is_distinct_from || is_not_distinct_from) {
2590 28 : if (rel_convert_types(sql, rel ? *rel : NULL, rel ? *rel : NULL, &ls, &rs, 1, type_equal_no_any) < 0)
2591 : return NULL;
2592 41 : sql_exp* e = exp_compare(sql->sa, ls, rs, is_not_distinct_from?cmp_equal:cmp_notequal);
2593 28 : set_semantics(e);
2594 28 : return e;
2595 : }
2596 :
2597 127625 : if (rs->type == e_atom)
2598 112243 : quantifier = 0;
2599 :
2600 127625 : if (!exp_is_rel(ls) && !exp_is_rel(rs) && ls->card < rs->card) {
2601 3836 : sql_exp *swap = ls; /* has to swap parameters like in the rel_logical_exp case */
2602 3836 : ls = rs;
2603 3836 : rs = swap;
2604 3836 : cmp_type = swap_compare(cmp_type);
2605 : }
2606 :
2607 127625 : if (rel_convert_types(sql, rel ? *rel : NULL, rel ? *rel : NULL, &ls, &rs, 1, type_equal_no_any) < 0)
2608 : return NULL;
2609 127622 : if (exp_is_null_no_value_opt(ls) && exp_is_null_no_value_opt(rs))
2610 7 : return exp_atom(sql->sa, atom_general(sql->sa, sql_bind_localtype("bit"), NULL, 0));
2611 :
2612 127615 : return exp_compare_func(sql, ls, rs, compare_func(cmp_type, need_not), quantifier);
2613 : }
2614 : /* Set Member ship */
2615 32254 : case SQL_IN:
2616 : case SQL_NOT_IN:
2617 32254 : return rel_in_value_exp(query, rel, sc, f);
2618 1105 : case SQL_EXISTS:
2619 : case SQL_NOT_EXISTS:
2620 1105 : return rel_exists_value_exp(query, rel, sc, f);
2621 355 : case SQL_LIKE:
2622 : case SQL_NOT_LIKE:
2623 : {
2624 355 : symbol *lo = sc->data.lval->h->data.sym;
2625 355 : symbol *ro = sc->data.lval->h->next->data.sym;
2626 355 : int insensitive = sc->data.lval->h->next->next->data.i_val;
2627 355 : int anti = (sc->token == SQL_NOT_LIKE) != (sc->data.lval->h->next->next->next->data.i_val != 0);
2628 355 : sql_subtype *st = sql_bind_localtype("str");
2629 355 : sql_exp *le = rel_value_exp(query, rel, lo, f|sql_farg, ek), *re, *ee = NULL, *ie = exp_atom_bool(sql->sa, insensitive);
2630 :
2631 355 : if (!le)
2632 : return NULL;
2633 :
2634 355 : if (!exp_subtype(le))
2635 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: parameter not allowed on "
2636 : "left hand side of LIKE operator");
2637 :
2638 355 : lo = ro->data.lval->h->data.sym;
2639 : /* like uses a single string pattern */
2640 355 : ek.card = card_value;
2641 355 : re = rel_value_exp(query, rel, lo, f|sql_farg, ek);
2642 355 : if (!re)
2643 : return NULL;
2644 351 : if ((re = exp_check_type(sql, st, rel ? *rel : NULL, re, type_equal)) == NULL)
2645 0 : return sql_error(sql, 02, SQLSTATE(42000) "LIKE: wrong type, should be string");
2646 351 : if ((le = exp_check_type(sql, st, rel ? *rel : NULL, le, type_equal)) == NULL)
2647 0 : return sql_error(sql, 02, SQLSTATE(42000) "LIKE: wrong type, should be string");
2648 : /* Do we need to escape ? */
2649 351 : if (dlist_length(ro->data.lval) == 2) {
2650 63 : char *escape = ro->data.lval->h->next->data.sval;
2651 63 : ee = exp_atom(sql->sa, atom_string(sql->sa, st, sa_strdup(sql->sa, escape)));
2652 : } else {
2653 288 : ee = exp_atom(sql->sa, atom_string(sql->sa, st, sa_strdup(sql->sa, "")));
2654 : }
2655 585 : return rel_nop_(sql, rel ? *rel : NULL, le, re, ee, ie, "sys", anti ? "not_like" : "like", card_value);
2656 : }
2657 186 : case SQL_BETWEEN:
2658 : case SQL_NOT_BETWEEN:
2659 : {
2660 186 : symbol *lo = sc->data.lval->h->data.sym;
2661 186 : int symmetric = sc->data.lval->h->next->data.i_val;
2662 186 : symbol *ro1 = sc->data.lval->h->next->next->data.sym;
2663 186 : symbol *ro2 = sc->data.lval->h->next->next->next->data.sym;
2664 186 : sql_exp *le, *re1, *re2;
2665 186 : sql_subtype super;
2666 :
2667 186 : assert(sc->data.lval->h->next->type == type_int);
2668 :
2669 186 : if (!(le = rel_value_exp(query, rel, lo, f|sql_farg, ek)))
2670 : return NULL;
2671 185 : if (!(re1 = rel_value_exp(query, rel, ro1, f|sql_farg, ek)))
2672 : return NULL;
2673 182 : if (!(re2 = rel_value_exp(query, rel, ro2, f|sql_farg, ek)))
2674 : return NULL;
2675 :
2676 177 : if (exp_between_check_types(&super, exp_subtype(le), exp_subtype(re1), exp_subtype(re2)) < 0)
2677 0 : return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) on both sides of an expression");
2678 :
2679 177 : if ((le = exp_check_type(sql, &super, rel ? *rel:NULL, le, type_equal)) == NULL ||
2680 177 : (re1 = exp_check_type(sql, &super, rel ? *rel:NULL, re1, type_equal)) == NULL ||
2681 177 : (re2 = exp_check_type(sql, &super, rel ? *rel:NULL, re2, type_equal)) == NULL)
2682 0 : return NULL;
2683 :
2684 177 : le = exp_compare2(sql->sa, le, re1, re2, 3, symmetric);
2685 177 : if (sc->token == SQL_NOT_BETWEEN)
2686 60 : set_anti(le);
2687 : return le;
2688 : }
2689 15437 : case SQL_IS_NULL:
2690 : case SQL_IS_NOT_NULL:
2691 : /* is (NOT) NULL */
2692 : {
2693 15437 : sql_exp *le = rel_value_exp(query, rel, sc->data.sym, f|sql_farg, ek);
2694 :
2695 15437 : if (!le)
2696 : return NULL;
2697 19788 : le = rel_unop_(sql, rel ? *rel : NULL, le, "sys", sc->token == SQL_IS_NULL ? "isnull" : "isnotnull", card_value);
2698 15434 : if (!le)
2699 : return NULL;
2700 15434 : set_has_no_nil(le);
2701 15434 : return le;
2702 : }
2703 19488 : case SQL_NOT: {
2704 19488 : sql_exp *le = rel_value_exp(query, rel, sc->data.sym, f|sql_farg, ek);
2705 :
2706 19488 : if (!le)
2707 : return NULL;
2708 19486 : return rel_unop_(sql, rel ? *rel : NULL, le, "sys", "not", card_value);
2709 : }
2710 : case SQL_ATOM: {
2711 2459124 : AtomNode *an = (AtomNode *) sc;
2712 2459124 : assert(an && an->a);
2713 2459124 : return exp_atom(sql->sa, an->a);
2714 : }
2715 20991 : case SQL_IDENT:
2716 : case SQL_COLUMN:
2717 20991 : return rel_column_ref(query, rel, sc, f);
2718 202 : case SQL_UNION:
2719 : case SQL_EXCEPT:
2720 : case SQL_INTERSECT: {
2721 202 : sql_rel *sq;
2722 :
2723 202 : if (is_psm_call(f) || is_sql_merge(f))
2724 4 : return sql_error(sql, 02, SQLSTATE(42000) "%s: subqueries not supported inside %s", is_psm_call(f) ? "CALL" : "MERGE", is_psm_call(f) ? "CALL statements" : "MERGE conditions");
2725 200 : if (rel && *rel)
2726 142 : query_push_outer(query, *rel, f);
2727 200 : sq = rel_setquery(query, sc);
2728 200 : if (rel && *rel) {
2729 142 : *rel = query_pop_outer(query);
2730 142 : if (is_sql_join(f) && is_groupby((*rel)->op)) {
2731 0 : return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in JOIN conditions");
2732 142 : } else if (is_sql_where(f) && is_groupby((*rel)->op)) {
2733 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in WHERE clause");
2734 142 : } else if ((is_sql_update_set(f) || is_sql_psm(f)) && is_groupby((*rel)->op)) {
2735 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses");
2736 : }
2737 : }
2738 200 : if (!sq)
2739 : return NULL;
2740 198 : if (ek.type == type_value && ek.card <= card_set && is_project(sq->op) && list_length(sq->exps) > 1)
2741 1 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery must return only one column");
2742 197 : if (ek.type == type_relation && is_project(sq->op) && list_length(sq->exps) != ek.type)
2743 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery has too %s columns", list_length(sq->exps) < ek.type ? "few" : "many");
2744 303 : if (ek.type == type_value && ek.card < card_set && sq->card >= CARD_AGGR && (is_sql_sel(f) | is_sql_having(f) | is_sql_farg(f) |
2745 106 : ( is_sql_where(f) && rel && (!*rel || is_basetable((*rel)->op) || is_simple_project((*rel)->op) || is_joinop((*rel)->op)))))
2746 106 : sq = rel_zero_or_one(sql, sq, ek);
2747 197 : return exp_rel(sql, sq);
2748 : }
2749 1 : case SQL_DEFAULT:
2750 1 : return sql_error(sql, 02, SQLSTATE(42000) "DEFAULT keyword not allowed outside insert and update statements");
2751 318 : default: {
2752 318 : sql_exp *le = rel_value_exp(query, rel, sc, f|sql_farg, ek);
2753 318 : sql_subtype bt;
2754 :
2755 318 : if (!le)
2756 : return NULL;
2757 316 : sql_find_subtype(&bt, "boolean", 0, 0);
2758 316 : if ((le = exp_check_type(sql, &bt, rel ? *rel : NULL, le, type_equal)) == NULL)
2759 : return NULL;
2760 316 : return rel_binop_(sql, rel ? *rel : NULL, le, exp_atom_bool(sql->sa, 1), "sys", "=", 0, true);
2761 : }
2762 : }
2763 : /* never reached, as all switch cases have a `return` */
2764 : }
2765 :
2766 : sql_rel *
2767 629725 : rel_logical_exp(sql_query *query, sql_rel *rel, symbol *sc, int f)
2768 : {
2769 629725 : mvc *sql = query->sql;
2770 629725 : exp_kind ek = {type_value, card_column, TRUE};
2771 :
2772 629725 : if (!sc)
2773 : return NULL;
2774 :
2775 629725 : if (mvc_highwater(sql))
2776 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
2777 :
2778 629725 : switch (sc->token) {
2779 14559 : case SQL_OR:
2780 : {
2781 14559 : list *exps = NULL, *lexps = NULL, *rexps = NULL;
2782 14559 : symbol *lo = sc->data.lval->h->data.sym;
2783 14559 : symbol *ro = sc->data.lval->h->next->data.sym;
2784 14559 : sql_rel *lr, *rr;
2785 :
2786 14559 : if (!rel)
2787 : return NULL;
2788 :
2789 14559 : lr = rel;
2790 14559 : rr = rel_dup(lr);
2791 :
2792 14559 : if (is_outerjoin(rel->op) && !is_processed(rel)) {
2793 44 : exps = rel->exps;
2794 :
2795 44 : lr = rel_select_copy(sql->sa, lr, sa_list(sql->sa));
2796 44 : lr = rel_logical_exp(query, lr, lo, f | sql_or);
2797 44 : if (!lr)
2798 : return NULL;
2799 43 : query_processed(query);
2800 43 : rr = rel_select_copy(sql->sa, rr, sa_list(sql->sa));
2801 43 : rr = rel_logical_exp(query, rr, ro, f | sql_or);
2802 43 : if (!rr)
2803 : return NULL;
2804 42 : if (lr->l == rr->l) {
2805 42 : lexps = lr->exps;
2806 42 : lr = lr->l;
2807 42 : rexps = rr->exps;
2808 42 : rr = rr->l;
2809 : }
2810 42 : rel = NULL;
2811 : } else {
2812 14515 : lr = rel_logical_exp(query, lr, lo, f | sql_or);
2813 14515 : if (!lr)
2814 : return NULL;
2815 14513 : rr = rel_logical_exp(query, rr, ro, f | sql_or);
2816 : }
2817 :
2818 14555 : if (!lr || !rr)
2819 : return NULL;
2820 14555 : return rel_or(sql, rel, lr, rr, exps, lexps, rexps);
2821 : }
2822 193936 : case SQL_AND:
2823 : {
2824 193936 : symbol *lo = sc->data.lval->h->data.sym;
2825 193936 : symbol *ro = sc->data.lval->h->next->data.sym;
2826 193936 : rel = rel_logical_exp(query, rel, lo, f);
2827 193936 : if (!rel)
2828 : return NULL;
2829 193929 : return rel_logical_exp(query, rel, ro, f);
2830 : }
2831 65 : case SQL_FILTER:
2832 : /* [ x,..] filter [ y,..] */
2833 : /* todo add anti, [ x,..] NOT filter [ y,...] */
2834 : /* no correlation */
2835 : {
2836 65 : dnode *ln = sc->data.lval->h->data.lval->h;
2837 65 : dnode *rn = sc->data.lval->h->next->next->data.lval->h;
2838 65 : dlist *filter_op = sc->data.lval->h->next->data.lval;
2839 65 : char *fname = qname_schema_object(filter_op);
2840 65 : char *sname = qname_schema(filter_op);
2841 65 : list *l, *r;
2842 :
2843 65 : l = sa_list(sql->sa);
2844 65 : r = sa_list(sql->sa);
2845 199 : for (; ln; ln = ln->next) {
2846 69 : symbol *sym = ln->data.sym;
2847 :
2848 69 : sql_exp *e = rel_value_exp(query, &rel, sym, f|sql_farg, ek);
2849 69 : if (!e)
2850 : return NULL;
2851 69 : list_append(l, e);
2852 : }
2853 182 : for (; rn; rn = rn->next) {
2854 117 : symbol *sym = rn->data.sym;
2855 :
2856 117 : sql_exp *e = rel_value_exp(query, &rel, sym, f|sql_farg, ek);
2857 117 : if (!e)
2858 : return NULL;
2859 117 : list_append(r, e);
2860 : }
2861 65 : return rel_filter(sql, rel, l, r, sname, fname, 0, f);
2862 : }
2863 350094 : case SQL_COMPARE:
2864 : {
2865 350094 : dnode *n = sc->data.lval->h;
2866 350094 : symbol *lo = n->data.sym;
2867 350094 : symbol *ro = n->next->next->data.sym;
2868 350094 : char *compare_op = n->next->data.sval;
2869 350094 : int quantifier = 0;
2870 350094 : int is_semantics = 0;
2871 :
2872 350094 : if (n->next->next->next)
2873 128 : quantifier = n->next->next->next->data.i_val + 1;
2874 128 : assert(quantifier == 0 || quantifier == 1 || quantifier == 2 || quantifier == 3 || quantifier == 4);
2875 :
2876 350094 : if (quantifier >= 3) {
2877 10 : if (quantifier == 4)
2878 6 : compare_op = "<>";
2879 : quantifier = 0;
2880 : is_semantics = 1;
2881 : }
2882 350094 : return rel_compare(query, rel, sc, lo, ro, compare_op, f, ek, quantifier, is_semantics);
2883 : }
2884 : /* Set Member ship */
2885 32948 : case SQL_IN:
2886 : case SQL_NOT_IN:
2887 32948 : return rel_in_exp(query, rel, sc, f);
2888 1014 : case SQL_EXISTS:
2889 : case SQL_NOT_EXISTS:
2890 1014 : return rel_exists_exp(query, rel , sc, f);
2891 3578 : case SQL_LIKE:
2892 : case SQL_NOT_LIKE:
2893 : {
2894 3578 : symbol *lo = sc->data.lval->h->data.sym;
2895 3578 : symbol *ro = sc->data.lval->h->next->data.sym;
2896 3578 : int insensitive = sc->data.lval->h->next->next->data.i_val;
2897 3578 : int anti = (sc->token == SQL_NOT_LIKE) != (sc->data.lval->h->next->next->next->data.i_val != 0);
2898 3578 : sql_subtype *st = sql_bind_localtype("str");
2899 3578 : sql_exp *le = rel_value_exp(query, &rel, lo, f|sql_farg, ek), *re, *ee = NULL, *ie = exp_atom_bool(sql->sa, insensitive);
2900 :
2901 3578 : if (!le)
2902 : return NULL;
2903 :
2904 3576 : if (!exp_subtype(le))
2905 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: parameter not allowed on "
2906 : "left hand side of LIKE operator");
2907 :
2908 : /* Do we need to escape ? */
2909 3576 : if (dlist_length(ro->data.lval) == 2) {
2910 82 : char *escape = ro->data.lval->h->next->data.sval;
2911 82 : ee = exp_atom(sql->sa, atom_string(sql->sa, st, sa_strdup(sql->sa, escape)));
2912 : } else {
2913 3494 : ee = exp_atom(sql->sa, atom_string(sql->sa, st, sa_strdup(sql->sa, "")));
2914 : }
2915 3576 : ro = ro->data.lval->h->data.sym;
2916 3576 : re = rel_value_exp(query, &rel, ro, f|sql_farg, ek);
2917 3576 : if (!re)
2918 : return NULL;
2919 3575 : if ((re = exp_check_type(sql, st, rel, re, type_equal)) == NULL)
2920 0 : return sql_error(sql, 02, SQLSTATE(42000) "LIKE: wrong type, should be string");
2921 3575 : if ((le = exp_check_type(sql, st, rel, le, type_equal)) == NULL)
2922 0 : return sql_error(sql, 02, SQLSTATE(42000) "LIKE: wrong type, should be string");
2923 3575 : return rel_filter_exp_(sql, rel, le, re, ee, ie, "like", anti, f);
2924 : }
2925 2938 : case SQL_BETWEEN:
2926 : case SQL_NOT_BETWEEN:
2927 : {
2928 2938 : symbol *lo = sc->data.lval->h->data.sym;
2929 2938 : int symmetric = sc->data.lval->h->next->data.i_val;
2930 2938 : symbol *ro1 = sc->data.lval->h->next->next->data.sym;
2931 2938 : symbol *ro2 = sc->data.lval->h->next->next->next->data.sym;
2932 2938 : sql_exp *le, *re1, *re2;
2933 2938 : sql_subtype super;
2934 :
2935 2938 : assert(sc->data.lval->h->next->type == type_int);
2936 :
2937 2938 : if (!(le = rel_value_exp(query, &rel, lo, f|sql_farg, ek)))
2938 : return NULL;
2939 2936 : if (!(re1 = rel_value_exp(query, &rel, ro1, f|sql_farg, ek)))
2940 : return NULL;
2941 2934 : if (!(re2 = rel_value_exp(query, &rel, ro2, f|sql_farg, ek)))
2942 : return NULL;
2943 :
2944 2934 : if (exp_between_check_types(&super, exp_subtype(le), exp_subtype(re1), exp_subtype(re2)) < 0)
2945 1 : return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) on both sides of an expression");
2946 :
2947 2933 : if ((le = exp_check_type(sql, &super, rel, le, type_equal)) == NULL ||
2948 2933 : (re1 = exp_check_type(sql, &super, rel, re1, type_equal)) == NULL ||
2949 2933 : (re2 = exp_check_type(sql, &super, rel, re2, type_equal)) == NULL)
2950 0 : return NULL;
2951 :
2952 2933 : return rel_compare_exp_(query, rel, le, re1, re2, 3, sc->token == SQL_NOT_BETWEEN ? 1 : 0, 0, f, symmetric, 0);
2953 : }
2954 7948 : case SQL_IS_NULL:
2955 : case SQL_IS_NOT_NULL:
2956 : /* is (NOT) NULL */
2957 : {
2958 7948 : sql_exp *le = rel_value_exp(query, &rel, sc->data.sym, f|sql_farg, ek);
2959 7948 : sql_subtype *t;
2960 :
2961 7948 : if (!le)
2962 : return NULL;
2963 7944 : if (!(t = exp_subtype(le)))
2964 1 : return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) for IS%s NULL operator", sc->token == SQL_IS_NOT_NULL ? " NOT" : "");
2965 7943 : le = exp_compare(sql->sa, le, exp_atom(sql->sa, atom_general(sql->sa, t, NULL, 0)), cmp_equal);
2966 7943 : if (sc->token == SQL_IS_NOT_NULL)
2967 2605 : set_anti(le);
2968 7943 : set_has_no_nil(le);
2969 7943 : set_semantics(le);
2970 7943 : return rel_select_push_compare_exp_down(sql, rel, le, le->l, le->r, NULL, f);
2971 : }
2972 20851 : case SQL_NOT: {
2973 20851 : sql_exp *le = rel_value_exp(query, &rel, sc->data.sym, f|sql_farg, ek);
2974 20851 : sql_subtype bt;
2975 :
2976 20851 : sql_find_subtype(&bt, "boolean", 0, 0);
2977 20851 : if (!le || !(le = exp_check_type(sql, &bt, rel, le, type_equal)))
2978 1 : return NULL;
2979 20850 : le = exp_compare(sql->sa, le, exp_atom_bool(sql->sa, 0), cmp_equal);
2980 20850 : return rel_select_push_compare_exp_down(sql, rel, le, le->l, le->r, NULL, f);
2981 : }
2982 625 : case SQL_ATOM: {
2983 : /* TRUE or FALSE */
2984 625 : sql_rel *or = rel;
2985 625 : AtomNode *an = (AtomNode *) sc;
2986 625 : sql_exp *e = exp_atom(sql->sa, an->a);
2987 :
2988 625 : if (e) {
2989 625 : sql_subtype bt;
2990 :
2991 625 : sql_find_subtype(&bt, "boolean", 0, 0);
2992 625 : e = exp_check_type(sql, &bt, rel, e, type_equal);
2993 : }
2994 625 : if (!e || or != rel)
2995 2 : return NULL;
2996 623 : e = exp_compare(sql->sa, e, exp_atom_bool(sql->sa, 1), cmp_equal);
2997 623 : return rel_select_push_compare_exp_down(sql, rel, e, e->l, e->r, NULL, f);
2998 : }
2999 716 : case SQL_IDENT:
3000 : case SQL_COLUMN: {
3001 716 : sql_rel *or = rel;
3002 716 : sql_exp *e = rel_column_ref(query, &rel, sc, f);
3003 :
3004 716 : if (e) {
3005 713 : sql_subtype bt;
3006 :
3007 713 : sql_find_subtype(&bt, "boolean", 0, 0);
3008 713 : e = exp_check_type(sql, &bt, rel, e, type_equal);
3009 : }
3010 713 : if (!e || or != rel)
3011 3 : return NULL;
3012 713 : e = exp_compare(sql->sa, e, exp_atom_bool(sql->sa, 1), cmp_equal);
3013 713 : return rel_select_push_compare_exp_down(sql, rel, e, e->l, e->r, NULL, f);
3014 : }
3015 12 : case SQL_UNION:
3016 : case SQL_EXCEPT:
3017 : case SQL_INTERSECT: {
3018 12 : sql_rel *sq;
3019 :
3020 12 : if (is_psm_call(f) || is_sql_merge(f))
3021 3 : return sql_error(sql, 02, SQLSTATE(42000) "%s: set operations not supported inside %s", is_psm_call(f) ? "CALL" : "MERGE", is_psm_call(f) ? "CALL statements" : "MERGE conditions");
3022 11 : if (rel)
3023 11 : query_push_outer(query, rel, f);
3024 11 : sq = rel_setquery(query, sc);
3025 11 : if (rel) {
3026 11 : rel = query_pop_outer(query);
3027 11 : if (is_sql_join(f) && is_groupby(rel->op)) {
3028 0 : return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in JOIN conditions");
3029 11 : } else if (is_sql_where(f) && is_groupby(rel->op)) {
3030 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in WHERE clause");
3031 11 : } else if ((is_sql_update_set(f) || is_sql_psm(f)) && is_groupby(rel->op)) {
3032 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses");
3033 : }
3034 : }
3035 11 : if (!sq)
3036 : return NULL;
3037 11 : assert(ek.type == type_value); /* I don't expect IN tuple matching calls to land here */
3038 11 : if (is_sql_where(f) && is_groupby(rel->op))
3039 0 : assert(0);
3040 11 : if (ek.card <= card_set && is_project(sq->op) && list_length(sq->exps) > 1)
3041 1 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery must return only one column");
3042 10 : if (!rel)
3043 : return sq;
3044 10 : sq = rel_zero_or_one(sql, sq, ek);
3045 10 : if (is_sql_where(f) || is_sql_having(f)) {
3046 10 : sql_exp *le = exp_rel(sql, sq);
3047 10 : sql_subtype bt;
3048 :
3049 10 : sql_find_subtype(&bt, "boolean", 0, 0);
3050 10 : le = exp_check_type(sql, &bt, rel, le, type_equal);
3051 10 : if (!le)
3052 : return NULL;
3053 10 : le = exp_compare(sql->sa, le, exp_atom_bool(sql->sa, 1), cmp_equal);
3054 10 : return rel_select_push_compare_exp_down(sql, rel, le, le->l, le->r, NULL, f);
3055 : } else {
3056 0 : sq = rel_crossproduct(sql->sa, rel, sq, (f==sql_sel || is_single(sq))?op_left:op_join);
3057 0 : set_processed(sq);
3058 : }
3059 0 : return sq;
3060 : }
3061 0 : case SQL_DEFAULT:
3062 0 : return sql_error(sql, 02, SQLSTATE(42000) "DEFAULT keyword not allowed outside insert and update statements");
3063 441 : default: {
3064 441 : sql_exp *le = rel_value_exp(query, &rel, sc, f|sql_farg, ek);
3065 441 : sql_subtype bt;
3066 :
3067 441 : if (!le)
3068 : return NULL;
3069 416 : if (le && (!is_compare(le->type) || le->flag > cmp_filter)) {
3070 285 : sql_find_subtype(&bt, "boolean", 0, 0);
3071 285 : if (!(le = exp_check_type(sql, &bt, rel, le, type_equal)))
3072 : return NULL;
3073 285 : le = exp_compare(sql->sa, le, exp_atom_bool(sql->sa, 1), cmp_equal);
3074 : }
3075 416 : if (le->flag == cmp_filter)
3076 130 : return rel_select_push_filter_exp_down(sql, rel, le, le->l, le->r, f);
3077 : else
3078 286 : return rel_select_push_compare_exp_down(sql, rel, le, le->l, le->r, le->f, f);
3079 : }
3080 : }
3081 : /* never reached, as all switch cases have a `return` */
3082 : }
3083 :
3084 : static sql_exp * _rel_aggr(sql_query *query, sql_rel **rel, int distinct, char *sname, char *aname, dnode *arguments, symbol *orderby, int f);
3085 : static sql_exp *rel_aggr(sql_query *query, sql_rel **rel, symbol *se, int f);
3086 :
3087 : sql_exp *
3088 35724 : rel_unop_(mvc *sql, sql_rel *rel, sql_exp *e, char *sname, char *fname, int card)
3089 : {
3090 35724 : bool found = false;
3091 35724 : sql_subtype *t = exp_subtype(e);
3092 35724 : sql_ftype type = (card == card_loader)?F_LOADER:((card == card_none)?F_PROC:
3093 : ((card == card_relation)?F_UNION:F_FUNC));
3094 :
3095 35724 : sql_subfunc *f = bind_func(sql, sname, fname, t, NULL, 1, type, false, &found, false);
3096 35724 : if (f) {
3097 35723 : sql_arg *a = f->func->ops->h->data;
3098 35723 : t = &a->type;
3099 : }
3100 35724 : if (f && t && type_has_tz(t) && f->func->fix_scale == SCALE_FIX) {
3101 : /* set timezone (using msec (.3)) */
3102 0 : sql_subtype *intsec = sql_bind_subtype(sql->sa, "sec_interval", 10 /*hour to second */, 3);
3103 0 : atom *a = atom_int(sql->sa, intsec, sql->timezone);
3104 0 : sql_exp *tz = exp_atom(sql->sa, a);
3105 :
3106 0 : e = rel_binop_(sql, rel, e, tz, "sys", "sql_add", card, true);
3107 0 : if (!e)
3108 : return NULL;
3109 : }
3110 35724 : if (f) {
3111 35723 : if (check_card(card, f)) {
3112 35723 : list *args = list_append(sa_list(sql->sa), e);
3113 71446 : args = check_arguments_and_find_largest_any_type(sql, rel, args, f, card == card_relation && e->card > CARD_ATOM, false);
3114 35723 : if (args)
3115 35723 : return exp_op(sql->sa, args, f);
3116 : }
3117 0 : found = false; /* reset found */
3118 0 : f = NULL;
3119 : }
3120 : /* reset error */
3121 1 : sql->session->status = 0;
3122 1 : sql->errstr[0] = '\0';
3123 3 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s unary operator %s%s%s'%s'(%s)",
3124 2 : found ? "insufficient privileges for" : "no such", sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname, t ? t->type->base.name : "?");
3125 : }
3126 :
3127 : sql_exp *
3128 184505 : rel_binop_(mvc *sql, sql_rel *rel, sql_exp *l, sql_exp *r, char *sname, char *fname, int card, bool exact)
3129 : {
3130 184505 : sql_subtype *t1 = exp_subtype(l), *t2 = exp_subtype(r);
3131 184505 : sql_ftype type = (card == card_loader)?F_LOADER:((card == card_none)?F_PROC:((card == card_relation)?F_UNION:F_FUNC));
3132 184505 : bool found = false;
3133 :
3134 184505 : if (card == card_loader)
3135 0 : card = card_none;
3136 :
3137 184505 : if (is_commutative(sname, fname) && l->card < r->card) { /* move constants to the right if possible */
3138 : sql_subtype *tmp = t1;
3139 184505 : t1 = t2;
3140 184505 : t2 = tmp;
3141 : sql_exp *res = l;
3142 184505 : l = r;
3143 184505 : r = res;
3144 : }
3145 : /* swap complex types (intervals) to left side of +, * */
3146 184505 : if (t1 && t2 && is_commutative(sname, fname)) {
3147 68 : if ((EC_INTERVAL(t1->type->eclass) && EC_TEMP(t2->type->eclass)) ||
3148 68 : ((!EC_TEMP(t1->type->eclass) && !EC_INTERVAL(t1->type->eclass)) && EC_INTERVAL(t2->type->eclass))) {
3149 : sql_subtype *tmp = t1;
3150 184505 : t1 = t2;
3151 184505 : t2 = tmp;
3152 : sql_exp *res = l;
3153 184505 : l = r;
3154 184505 : r = res;
3155 : }
3156 : }
3157 :
3158 184505 : sql_subfunc *f = bind_func(sql, sname, fname, t1, t2, 2, type, false, &found, exact);
3159 184505 : if (f && check_card(card,f)) {
3160 184505 : t1 = exp_subtype(l);
3161 184505 : t2 = exp_subtype(r);
3162 184505 : list *args = list_append(list_append(sa_list(sql->sa), l), r);
3163 :
3164 184505 : args = check_arguments_and_find_largest_any_type(sql, rel, args, f, 0, false);
3165 184505 : if (args)
3166 184505 : return exp_op(sql->sa, args, f);
3167 : return NULL;
3168 : }
3169 :
3170 0 : if (!exp_subtype(l) || !exp_subtype(r))
3171 0 : return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) on both sides of an expression");
3172 0 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s binary operator %s%s%s'%s'(%s,%s)",
3173 0 : found ? "insufficient privileges for" : "no such", sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname,
3174 0 : exp_subtype(l)->type->base.name, exp_subtype(r)->type->base.name);
3175 : }
3176 :
3177 : sql_exp *
3178 547 : rel_nop_(mvc *sql, sql_rel *rel, sql_exp *a1, sql_exp *a2, sql_exp *a3, sql_exp *a4, char *sname, char *fname, int card)
3179 : {
3180 547 : list *tl = sa_list(sql->sa);
3181 547 : sql_subfunc *f = NULL;
3182 547 : sql_ftype type = (card == card_none)?F_PROC:((card == card_relation)?F_UNION:F_FUNC);
3183 :
3184 : /* rel_nop_ should only be called for functions available to everyone, ie defined at sql_types! */
3185 547 : (void) rel;
3186 547 : append(tl, exp_subtype(a1));
3187 547 : append(tl, exp_subtype(a2));
3188 547 : append(tl, exp_subtype(a3));
3189 547 : if (a4)
3190 379 : append(tl, exp_subtype(a4));
3191 :
3192 547 : if (!(f = bind_func_(sql, sname, fname, tl, type, false, NULL, true)))
3193 : return NULL;
3194 547 : if (!a4)
3195 168 : return exp_op3(sql->sa, a1,a2,a3,f);
3196 379 : return exp_op4(sql->sa, a1,a2,a3,a4,f);
3197 : }
3198 :
3199 : static sql_func *
3200 3 : inplace_func(mvc *sql)
3201 : {
3202 3 : sql_func *f = SA_NEW(sql->sa, sql_func);
3203 :
3204 3 : *f = (sql_func) {
3205 : .mod = "",
3206 : .imp = "",
3207 : .type = F_PROC,
3208 : .lang = FUNC_LANG_INT,
3209 : .query = NULL,
3210 3 : .ops = sql->params,
3211 : .res = NULL,
3212 : };
3213 3 : base_init(sql->sa, &f->base, 0, true, NULL);
3214 3 : f->base.new = 1;
3215 3 : f->base.id = -1;
3216 3 : f->base.name = "-1";
3217 3 : f->instantiated = TRUE;
3218 3 : return f;
3219 : }
3220 :
3221 : static list *
3222 3 : reorder_args(mvc *sql, list *exps, list *names, list *params)
3223 : {
3224 3 : list *nexps = sa_list(sql->sa);
3225 8 : for(node *n = params->h; n; n = n->next) {
3226 5 : sql_arg *a = n->data;
3227 5 : int found =0;
3228 7 : for(node *m = names->h, *o = exps->h; m && o; m = m->next, o = o->next) {
3229 7 : if (strcmp(m->data, a->name) == 0) {
3230 5 : append(nexps, o->data);
3231 5 : found = 1;
3232 5 : break;
3233 : }
3234 : }
3235 5 : if (!found)
3236 : return NULL;
3237 : }
3238 : return nexps;
3239 : }
3240 :
3241 : static sql_exp *
3242 593209 : rel_nop(sql_query *query, sql_rel **rel, symbol *se, int fs, exp_kind ek)
3243 : {
3244 593209 : mvc *sql = query->sql;
3245 593209 : dnode *l = se->data.lval->h;
3246 593209 : dnode *ops = l->next->next->data.lval?l->next->next->data.lval->h:NULL;
3247 593209 : list *names = NULL;
3248 593209 : char *fname = NULL, *sname = NULL;;
3249 :
3250 593209 : if (l->type != type_int) {
3251 587300 : int nargs = 0;
3252 587300 : fname = qname_schema_object(l->data.lval);
3253 587299 : sname = qname_schema(l->data.lval);
3254 :
3255 1740135 : for (dnode *n = ops; n; n = n->next)
3256 1152836 : nargs++;
3257 :
3258 : /* first try aggregate */
3259 587300 : if (find_func(sql, sname, fname, nargs, F_AGGR, false, NULL, NULL)) {
3260 26594 : dnode *dn = l->next->next;
3261 26594 : symbol *orderby = dn->next?dn->next->data.sym:NULL;
3262 26594 : return _rel_aggr(query, rel, l->next->data.i_val, sname, fname, dn->data.lval->h, orderby, fs);
3263 : }
3264 : }
3265 :
3266 566615 : int nr_args = 0;
3267 566615 : int split = (l->type == type_int && l->data.i_val == -1);
3268 566615 : list *exps = sa_list(sql->sa), *tl = sa_list(sql->sa);
3269 566615 : exp_kind iek = {type_value, card_column, FALSE};
3270 :
3271 566615 : if (split)
3272 3 : names = sa_list(sql->sa);
3273 1700038 : for (; ops; ops = ops->next, nr_args++) {
3274 1133510 : sql_exp *e = rel_value_exp(query, rel, ops->data.sym, fs|sql_farg, iek);
3275 1133510 : if (!e)
3276 : return NULL;
3277 1133424 : if (split) {
3278 5 : ops = ops->next;
3279 5 : append(names, ops->data.sval);
3280 : }
3281 1133424 : append(exps, e);
3282 1133424 : append(tl, exp_subtype(e));
3283 : }
3284 566528 : if (l->type == type_int) {
3285 : /* exec nr (ops)*/
3286 5908 : int nr = l->data.i_val;
3287 5908 : cq *q = NULL;
3288 :
3289 5908 : if (nr == -1 || (q = qc_find(sql->qc, nr))) {
3290 5906 : list *nexps = new_exp_list(sql->sa);
3291 5906 : sql_func *f = q?q->f:inplace_func(sql);
3292 5906 : list *ops = q?f->ops:sql->params;
3293 :
3294 5906 : tl = sa_list(sql->sa);
3295 5906 : if (list_length(ops) != list_length(exps))
3296 3 : return sql_error(sql, 02, SQLSTATE(42000) "EXEC called with wrong number of arguments: expected %d, got %d", list_length(ops), list_length(exps));
3297 5903 : if (split) {
3298 3 : exps = reorder_args(sql, exps, names, ops);
3299 3 : if (!exps)
3300 0 : return sql_error(sql, 02, SQLSTATE(42000) "EXEC called with wrong arguments");
3301 : }
3302 5903 : if (exps->h && ops) {
3303 21928 : for (node *n = exps->h, *m = ops->h; n && m; n = n->next, m = m->next) {
3304 16116 : sql_arg *a = m->data;
3305 16116 : sql_exp *e = n->data;
3306 16116 : sql_subtype *ntp = &a->type;
3307 :
3308 16116 : if (ntp && ntp->type)
3309 16116 : e = exp_check_type(sql, ntp, NULL, e, type_equal);
3310 : else
3311 0 : a->type = *exp_subtype(e);
3312 16116 : if (!e)
3313 : return NULL;
3314 16115 : append(nexps, e);
3315 16115 : append(tl, exp_subtype(e));
3316 : }
3317 : }
3318 :
3319 5902 : if (q)
3320 5899 : sql->type = q->type;
3321 5992 : return exp_op(sql->sa, list_empty(nexps) ? NULL : nexps, sql_dup_subfunc(sql->sa, f, tl, NULL));
3322 : } else {
3323 2 : return sql_error(sql, 02, SQLSTATE(42000) "EXEC: PREPARED Statement missing '%d'", nr);
3324 : }
3325 : }
3326 :
3327 560620 : if (nr_args == 2 && is_commutative(sname, fname)) {
3328 124173 : sql_subtype *t1 = tl->h->data;
3329 124173 : sql_subtype *t2 = tl->t->data;
3330 :
3331 124173 : if (t1 && t2 && ((EC_INTERVAL(t1->type->eclass) && EC_TEMP(t2->type->eclass)) ||
3332 124164 : ((!EC_TEMP(t1->type->eclass) && !EC_INTERVAL(t1->type->eclass)) && EC_INTERVAL(t2->type->eclass)))) {
3333 8 : list_revert(exps);
3334 8 : list_revert(tl);
3335 : }
3336 :
3337 : }
3338 :
3339 560620 : if (!sname && strcmp(fname, "field") == 0) { /* map into join */
3340 1 : if (list_length(exps) < 2)
3341 1 : return sql_error(sql, 02, SQLSTATE(42000) "Field function called with not enough arguments");
3342 0 : sql_exp *le = exps->h->data;
3343 0 : set_freevar(le, 1);
3344 0 : list_remove_data(exps, NULL, le);
3345 0 : sql_exp *re = exp_values(sql->sa, exps);
3346 0 : exp_label(sql->sa, re, ++sql->label);
3347 0 : sql_rel *r = rel_project(sql->sa, NULL, append(sa_list(sql->sa), re));
3348 0 : sql_exp *id = NULL;
3349 0 : rel_add_identity(sql, r, &id);
3350 0 : re = exp_ref(sql, re);
3351 0 : id = exp_ref(sql, id);
3352 0 : if (r) {
3353 0 : r->nrcols = list_length(exps);
3354 0 : sql_exp *e = exp_compare(sql->sa, le, re, cmp_equal);
3355 0 : r = rel_select(sql->sa, r, e);
3356 0 : r = rel_project(sql->sa, r, append(sa_list(sql->sa), exp_convert(sql, id, exp_subtype(id), sql_bind_localtype("int"))));
3357 0 : re = exp_rel(sql, r);
3358 0 : return re;
3359 : }
3360 : }
3361 560619 : return _rel_nop(sql, sname, fname, tl, rel ? *rel : NULL, exps, ek);
3362 : }
3363 :
3364 : typedef struct aggr_input {
3365 : sql_query *query;
3366 : int groupby;
3367 : char *err;
3368 : } aggr_input;
3369 :
3370 : static sql_exp *
3371 373 : exp_valid(visitor *v, sql_rel *rel, sql_exp *e, int depth)
3372 : {
3373 373 : aggr_input *ai = v->data;
3374 373 : (void)rel; (void)depth;
3375 :
3376 373 : int vf = is_freevar(e);
3377 373 : if (!v->changes && vf && vf < ai->groupby) { /* check need with outer query */
3378 14 : sql_rel *sq = query_fetch_outer(ai->query, vf-1);
3379 :
3380 : /* problem freevar have cardinality CARD_ATOM */
3381 14 : if (sq->card <= CARD_AGGR && exp_card(e) != CARD_AGGR && is_alias(e->type)) {
3382 4 : if (!exps_bind_column(sq->exps, e->l, e->r, NULL, 0)) {
3383 1 : v->changes = 1;
3384 1 : ai->err = SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query";
3385 : }
3386 : }
3387 359 : } else if (!v->changes && vf && vf == ai->groupby) { /* check if input is already aggregated */
3388 280 : sql_rel *sq = query_fetch_outer(ai->query, vf-1);
3389 280 : sql_exp *a = NULL;
3390 :
3391 280 : if (sq->card <= CARD_AGGR && is_alias(e->type)) {
3392 187 : if ((a = exps_bind_column(sq->exps, e->l, e->r, NULL, 0)) && is_aggr(a->type)) { /* aggregate */
3393 9 : v->changes = 1;
3394 9 : ai->err = SQLSTATE(42000) "SELECT: aggregate function calls cannot be nested";
3395 : }
3396 : }
3397 : }
3398 373 : return e;
3399 : }
3400 :
3401 : static char *
3402 273 : exps_valid(sql_query *query, list *exps, int groupby)
3403 : {
3404 273 : aggr_input ai = { .query = query, .groupby = groupby };
3405 273 : visitor v = { .sql = query->sql, .data = &ai };
3406 :
3407 273 : exps_exp_visitor_topdown(&v, NULL, exps, 0, &exp_valid, true);
3408 273 : if (v.changes)
3409 10 : return ai.err;
3410 : return NULL;
3411 : }
3412 :
3413 : static list * rel_order_by(sql_query *query, sql_rel **R, symbol *orderby, int needs_distinct, int f);
3414 :
3415 : static sql_exp *
3416 46201 : _rel_aggr(sql_query *query, sql_rel **rel, int distinct, char *sname, char *aname, dnode *args, symbol *orderby, int f)
3417 : {
3418 46201 : mvc *sql = query->sql;
3419 46201 : exp_kind ek = {type_value, card_column, FALSE};
3420 46201 : sql_subfunc *a = NULL;
3421 46201 : int no_nil = 0, group = 0, all_aggr = query_has_outer(query), i;
3422 46201 : unsigned int all_freevar = 0;
3423 46201 : sql_rel *groupby = rel ? *rel : NULL, *sel = NULL, *gr, *og = NULL, *res = groupby;
3424 46201 : sql_rel *subquery = NULL;
3425 46201 : list *exps = NULL, *ungrouped_cols = NULL;
3426 46201 : bool is_grouping = !strcmp(aname, "grouping"), has_args = false, found = false, used_rel = false;
3427 :
3428 46201 : if (!all_aggr) {
3429 31126 : if (!groupby) {
3430 4 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3431 4 : return sql_error(sql, 02, SQLSTATE(42000) "%s: missing group by", toUpperCopy(uaname, aname));
3432 31122 : } else if (is_sql_groupby(f)) {
3433 8 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3434 8 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate function '%s' not allowed in GROUP BY clause", toUpperCopy(uaname, aname), aname);
3435 31114 : } else if (is_sql_values(f)) {
3436 1 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3437 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed on an unique value", toUpperCopy(uaname, aname));
3438 31113 : } else if (is_sql_join(f)) { /* the is_sql_join test must come before is_sql_where, because the join conditions are handled with sql_where */
3439 3 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3440 3 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in JOIN conditions", toUpperCopy(uaname, aname));
3441 31110 : } else if (is_sql_where(f)) {
3442 4 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3443 4 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in WHERE clause", toUpperCopy(uaname, aname));
3444 31106 : } else if (is_sql_update_set(f) || is_sql_psm(f)) {
3445 1 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3446 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses (use subquery)", toUpperCopy(uaname, aname));
3447 31105 : } else if (is_sql_aggr(f)) {
3448 4 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3449 4 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions cannot be nested", toUpperCopy(uaname, aname));
3450 31101 : } else if (is_psm_call(f)) {
3451 0 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3452 0 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed inside CALL", toUpperCopy(uaname, aname));
3453 31101 : } else if (is_sql_from(f)) {
3454 0 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3455 0 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in functions in FROM", toUpperCopy(uaname, aname));
3456 : }
3457 : }
3458 :
3459 46176 : exps = sa_list(sql->sa);
3460 46176 : if (args && args->data.sym) {
3461 26682 : bool arguments_correlated = true, all_const = true;
3462 :
3463 26682 : all_freevar = all_aggr?1:0;
3464 62185 : for (i = 0; args && args->data.sym; args = args->next, i++) {
3465 35563 : int base = (!groupby || !is_project(groupby->op) || is_base(groupby->op) || is_processed(groupby));
3466 27526 : sql_rel *gl = base?groupby:groupby->l, *ogl = gl; /* handle case of subqueries without correlation */
3467 35563 : sql_exp *e = rel_value_exp(query, &gl, args->data.sym, (f | sql_aggr)& ~sql_farg, ek);
3468 35563 : bool found_one_freevar = false;
3469 :
3470 35563 : if (!e)
3471 60 : return NULL;
3472 35509 : used_rel |= (rel_has_exp(gl, e, true) == 0);
3473 35509 : has_args = true;
3474 35509 : if (gl && gl != ogl) {
3475 5 : if (gl->grouped) {
3476 5 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3477 5 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions cannot be nested", toUpperCopy(uaname, aname));
3478 : }
3479 0 : if (!base)
3480 0 : groupby->l = subquery = gl;
3481 : else
3482 : groupby = subquery = gl;
3483 : }
3484 35504 : sql_subtype *t = exp_subtype(e);
3485 35504 : if (!t) { /* we also do not expect parameters here */
3486 1 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3487 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: parameters not allowed as arguments to aggregate functions", toUpperCopy(uaname, aname));
3488 : }
3489 35503 : if (!t->type->localtype) {
3490 52 : if (e->type == e_atom && !e->f) {
3491 49 : t = sql_bind_localtype("bte");
3492 49 : e->tpe = *t;
3493 49 : if (e->l)
3494 49 : e->l = atom_set_type(sql->sa, e->l, t);
3495 : }
3496 : }
3497 :
3498 35503 : all_aggr &= (exp_card(e) <= CARD_AGGR && !exp_is_atom(e) && is_aggr(e->type) && !is_func(e->type) && (!groupby || !is_groupby(groupby->op) || !groupby->r || !exps_find_exp(groupby->r, e)));
3499 35503 : exp_only_freevar(query, e, &arguments_correlated, &found_one_freevar, &ungrouped_cols);
3500 35503 : all_freevar &= (arguments_correlated && found_one_freevar) || (is_atom(e->type)?all_freevar:0); /* no uncorrelated variables must be found, plus at least one correlated variable to push this aggregate to an outer query */
3501 35503 : all_const &= is_atom(e->type);
3502 35503 : list_append(exps, e);
3503 : }
3504 26622 : if (all_const)
3505 229 : all_freevar = 0;
3506 : }
3507 46116 : if (!all_freevar) {
3508 45823 : if (is_sql_groupby(f)) {
3509 1 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3510 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate function '%s' not allowed in GROUP BY clause", toUpperCopy(uaname, aname), aname);
3511 45822 : } else if (is_sql_from(f)) {
3512 2 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3513 2 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in functions in FROM", toUpperCopy(uaname, aname));
3514 45820 : } else if (is_sql_aggr(f) && groupby->grouped) {
3515 2 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3516 2 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions cannot be nested", toUpperCopy(uaname, aname));
3517 45818 : } else if (is_sql_values(f)) {
3518 1 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3519 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed on an unique value", toUpperCopy(uaname, aname));
3520 45817 : } else if (is_sql_join(f)) { /* the is_sql_join test must come before is_sql_where, because the join conditions are handled with sql_where */
3521 1 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3522 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in JOIN conditions", toUpperCopy(uaname, aname));
3523 45816 : } else if (is_sql_where(f)) {
3524 5 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3525 5 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in WHERE clause", toUpperCopy(uaname, aname));
3526 45811 : } else if (!all_aggr && !list_empty(ungrouped_cols)) {
3527 123 : for (node *n = ungrouped_cols->h ; n ; n = n->next) {
3528 66 : sql_rel *outer;
3529 66 : sql_exp *e = (sql_exp*) n->data;
3530 :
3531 66 : if ((outer = query_fetch_outer(query, is_freevar(e)-1))) {
3532 66 : int of = query_fetch_outer_state(query, is_freevar(e)-1);
3533 66 : if (outer->grouped) {
3534 24 : bool err = false, was_processed = false;
3535 :
3536 24 : if (is_processed(outer)) {
3537 5 : was_processed = true;
3538 5 : reset_processed(outer);
3539 : }
3540 24 : if (!is_groupby_col(outer, e))
3541 3 : err = true;
3542 24 : if (was_processed)
3543 5 : set_processed(outer);
3544 24 : if (err) {
3545 3 : if (exp_name(e) && exp_relname(e) && !has_label(e))
3546 3 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column \"%s.%s\" from outer query", exp_relname(e), exp_name(e));
3547 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
3548 : }
3549 42 : } else if (!used_rel && is_sql_where(of)) {
3550 2 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3551 2 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions not allowed in WHERE clause", toUpperCopy(uaname, aname));
3552 40 : } else if (!is_sql_aggr(of)) {
3553 36 : set_outer(outer);
3554 : }
3555 : }
3556 : }
3557 : }
3558 : }
3559 :
3560 46099 : if (all_freevar) { /* case 2, ie use outer */
3561 293 : int card;
3562 293 : sql_exp *exp = NULL;
3563 : /* find proper groupby relation */
3564 593 : for (node *n = exps->h; n; n = n->next) {
3565 300 : sql_exp *e = n->data;
3566 :
3567 300 : int vf = exp_freevar_offset(sql, e);
3568 300 : if (vf > (int)all_freevar)
3569 23 : all_freevar = vf;
3570 300 : exp = e;
3571 : }
3572 293 : if (query_has_outer(query) >= all_freevar) {
3573 293 : int sql_state = query_fetch_outer_state(query,all_freevar-1);
3574 293 : res = groupby = query_fetch_outer(query, all_freevar-1);
3575 293 : card = query_outer_used_card(query, all_freevar-1);
3576 : /* given groupby validate all input expressions */
3577 293 : char *err;
3578 293 : if (groupby && !is_groupby(groupby->op)) {
3579 112 : sql_exp *p = query_outer_last_used(query, all_freevar-1);
3580 112 : if (p && !is_aggr(p->type) && !is_groupby_col(groupby, p)) {
3581 20 : if (p->type == e_column)
3582 20 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", (char*)p->l, (char*)p->r);
3583 0 : if (exp_name(p) && exp_relname(p) && !has_label(p))
3584 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", exp_relname(p), exp_name(p));
3585 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
3586 : }
3587 : }
3588 273 : if ((err = exps_valid(query, exps, all_freevar)) != NULL) {
3589 10 : strcpy(sql->errstr, err);
3590 10 : sql->session->status = -ERR_GROUPBY;
3591 10 : return NULL;
3592 : }
3593 263 : if (exp && !is_groupby_col(res, exp)) {
3594 192 : if (is_sql_groupby(sql_state))
3595 2 : return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate function '%s' not allowed in GROUP BY clause", aname);
3596 190 : if (is_sql_aggr(sql_state) && groupby->grouped) {
3597 3 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3598 3 : return sql_error(sql, 02, SQLSTATE(42000) "%s: aggregate functions cannot be nested", toUpperCopy(uaname, aname));
3599 : }
3600 187 : if (is_sql_values(sql_state))
3601 0 : return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed on an unique value");
3602 187 : if (is_sql_update_set(sql_state) || is_sql_psm(f))
3603 2 : return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses");
3604 185 : if (is_sql_join(sql_state))
3605 4 : return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in JOIN conditions");
3606 181 : if (is_sql_where(sql_state))
3607 3 : return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in WHERE clause");
3608 178 : if (is_psm_call(sql_state))
3609 0 : return sql_error(sql, 05, SQLSTATE(42000) "CALL: aggregate functions not allowed inside CALL");
3610 178 : if (is_sql_from(sql_state))
3611 0 : return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in functions in FROM");
3612 178 : if (card > CARD_AGGR) { /* used an expression before on the non grouped relation */
3613 0 : sql_exp *lu = query_outer_last_used(query, all_freevar-1);
3614 0 : if (lu->type == e_column)
3615 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column \"%s.%s\" from outer query", (char*)lu->l, (char*)lu->r);
3616 0 : if (exp_name(lu) && exp_relname(lu) && !has_label(lu))
3617 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column \"%s.%s\" from outer query", exp_relname(lu), exp_name(lu));
3618 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
3619 : }
3620 178 : if (is_outer(groupby))
3621 2 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
3622 : }
3623 : } else {
3624 : all_freevar = 0;
3625 : }
3626 45806 : } else if (!subquery && groupby && is_outer(groupby) && !is_groupby(groupby->op))
3627 1 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: subquery uses ungrouped column from outer query");
3628 :
3629 : /* find having select */
3630 46052 : if (!subquery && groupby && !is_processed(groupby) && is_sql_having(f)) {
3631 108 : og = groupby;
3632 108 : while(!is_processed(groupby) && !is_base(groupby->op)) {
3633 63 : if (is_select(groupby->op) || !groupby->l)
3634 : break;
3635 : if (groupby->l)
3636 : groupby = groupby->l;
3637 : }
3638 67 : if (groupby && is_select(groupby->op) && !is_processed(groupby)) {
3639 22 : group = 1;
3640 22 : sel = groupby;
3641 : /* At the end we switch back to the old projection relation og.
3642 : * During the partitioning and ordering we add the expressions to the intermediate relations. */
3643 : }
3644 22 : if (!sel)
3645 : groupby = og;
3646 22 : if (sel && sel->l)
3647 22 : groupby = sel->l;
3648 : }
3649 :
3650 : /* find groupby */
3651 46052 : if (!subquery && groupby && !is_processed(groupby) && !is_base(groupby->op)) {
3652 30971 : og = groupby;
3653 30971 : groupby = rel_find_groupby(groupby);
3654 30971 : if (groupby)
3655 : group = 1;
3656 : else
3657 : groupby = og;
3658 : }
3659 :
3660 7925 : if (!groupby && exps_card(exps) > CARD_ATOM) {
3661 0 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3662 0 : return sql_error(sql, 02, SQLSTATE(42000) "%s: missing group by", toUpperCopy(uaname, aname));
3663 : }
3664 :
3665 46052 : if (!subquery && groupby && groupby->op != op_groupby) { /* implicit groupby */
3666 21267 : if (!all_freevar && query->last_exp && !is_sql_aggr(query->last_state)) {
3667 9 : if (exp_relname(query->last_exp) && exp_name(query->last_exp) && !has_label(query->last_exp))
3668 9 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s.%s' in query results without an aggregate function", exp_relname(query->last_exp), exp_name(query->last_exp));
3669 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
3670 : }
3671 21258 : res = groupby = rel_groupby(sql, groupby, NULL);
3672 : }
3673 46043 : if (subquery) {
3674 0 : assert(!all_freevar);
3675 0 : res = groupby;
3676 0 : if (is_sql_sel(f) && is_left(subquery->op) && !is_groupby(groupby->op)) {
3677 0 : res = groupby = rel_groupby(sql, groupby, NULL);
3678 0 : exps_set_freevar(sql, exps, groupby); /* mark free variables */
3679 0 : } else if (!is_groupby(groupby->op)) {
3680 0 : res = groupby = rel_groupby(sql, groupby, NULL);
3681 : }
3682 0 : assert(!is_base(groupby->op));
3683 : }
3684 46043 : if ((!exps || exps_card(exps) > CARD_ATOM) && (!res || !groupby))
3685 : return NULL;
3686 :
3687 46043 : list *obe = NULL;
3688 46043 : bool handled_order = true;
3689 46043 : if (args)
3690 : return NULL;
3691 46043 : if (orderby) { /* handle order by */
3692 4464 : int base = (!groupby || !is_project(groupby->op) || is_base(groupby->op) || is_processed(groupby));
3693 4464 : sql_rel *gl = base?groupby:groupby->l;//, *ogl = gl; /* handle case of subqueries without correlation */
3694 4464 : obe = rel_order_by(query, &gl, orderby, 0, f);
3695 4464 : if (!obe)
3696 0 : return NULL;
3697 4464 : handled_order = false;
3698 : }
3699 :
3700 46043 : if (all_freevar) {
3701 247 : query_update_outer(query, res, all_freevar-1);
3702 45796 : } else if (rel) {
3703 45796 : *rel = res;
3704 45796 : if (query->last_rel != res) {
3705 41834 : query->last_rel = res;
3706 41834 : query->last_state |= sql_aggr;
3707 : }
3708 : }
3709 :
3710 46043 : if (!has_args) { /* count(*) case */
3711 19490 : obe = NULL; /* no errors, although the order by is useless */
3712 19490 : sql_exp *e;
3713 :
3714 19490 : if (strcmp(aname, "count") != 0) {
3715 2 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3716 2 : return sql_error(sql, 02, SQLSTATE(42000) "%s: unable to perform '%s(*)'", toUpperCopy(uaname, aname), aname);
3717 : }
3718 19488 : a = sql_bind_func(sql, "sys", aname, sql_bind_localtype("void"), NULL, F_AGGR, true, true);
3719 19488 : e = exp_aggr(sql->sa, NULL, a, distinct, 0, groupby?groupby->card:CARD_ATOM, 0);
3720 :
3721 19488 : if (!groupby)
3722 : return e;
3723 19488 : if (all_freevar)
3724 0 : query_outer_used_exp(query, all_freevar-1, e, sql_aggr);
3725 19488 : e = rel_groupby_add_aggr(sql, groupby, e);
3726 19488 : if (!group && !all_freevar)
3727 : return e;
3728 3231 : if (all_freevar) {
3729 0 : assert(!is_simple_project(res->op));
3730 0 : e->card = CARD_ATOM;
3731 0 : set_freevar(e, all_freevar-1);
3732 0 : return e;
3733 : }
3734 : return e;
3735 : }
3736 :
3737 : /* use cnt as nils shouldn't be counted */
3738 26553 : no_nil = 1;
3739 :
3740 26553 : gr = groupby;
3741 26553 : if (gr && gr->op == op_project && gr->l)
3742 : gr = gr->l;
3743 :
3744 26553 : if (is_grouping) {
3745 109 : sql_subtype *tpe;
3746 109 : list *l = (list*) groupby->r;
3747 :
3748 109 : if (list_length(l) <= 7)
3749 107 : tpe = sql_bind_localtype("bte");
3750 2 : else if (list_length(l) <= 15)
3751 2 : tpe = sql_bind_localtype("sht");
3752 0 : else if (list_length(l) <= 31)
3753 0 : tpe = sql_bind_localtype("int");
3754 0 : else if (list_length(l) <= 63)
3755 0 : tpe = sql_bind_localtype("lng");
3756 : #ifdef HAVE_HGE
3757 0 : else if (list_length(l) <= 127)
3758 0 : tpe = sql_bind_localtype("hge");
3759 : #endif
3760 : else
3761 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: GROUPING the number of grouping columns is larger"
3762 : " than the maximum number of representable bits from this server (%d > %d)", list_length(l),
3763 : #ifdef HAVE_HGE
3764 : 127
3765 : #else
3766 : 63
3767 : #endif
3768 : );
3769 109 : a = sql_bind_func_result(sql, sname, aname, F_AGGR, true, tpe, 1, exp_subtype(exps->h->data));
3770 : } else {
3771 26444 : a = sql_bind_func_(sql, sname, aname, exp_types(sql->sa, exps), F_AGGR, false, false);
3772 26444 : if (!a && obe && list_length(obe) == 1) { /* try to find aggregation function with requires order by column */
3773 0 : list *nexps = append(sa_list(sql->sa), obe->h->data);
3774 0 : nexps = list_merge(nexps, exps, (fdup) NULL);
3775 0 : a = sql_bind_func_(sql, sname, aname, exp_types(sql->sa, nexps), F_AGGR, false, false);
3776 0 : if (a && a->func->order_required) {
3777 : /* reset error */
3778 0 : handled_order = true;
3779 0 : sql->session->status = 0;
3780 0 : sql->errstr[0] = '\0';
3781 0 : exps = nexps;
3782 0 : obe = NULL;
3783 : }
3784 : }
3785 : }
3786 :
3787 26553 : if (a) {
3788 26548 : found = true;
3789 26548 : if (!execute_priv(sql, a->func))
3790 0 : a = NULL;
3791 26548 : if (!is_grouping && a && !(exps = check_arguments_and_find_largest_any_type(sql, rel ? *rel : NULL, exps, a, 0, false)))
3792 0 : a = NULL;
3793 : }
3794 :
3795 26553 : if (a) {
3796 26548 : bool hasnil = have_nil(exps) || (strcmp(aname, "count") != 0 && (!groupby || list_empty(groupby->r))); /* for global case, the aggregate may return NULL */
3797 26548 : sql_exp *e = exp_aggr(sql->sa, exps, a, distinct, no_nil, groupby?groupby->card:CARD_ATOM, hasnil);
3798 :
3799 26548 : if (!obe && a->func->order_required && !handled_order) {
3800 : /* TODO proper error on missing order by */
3801 : return NULL;
3802 : }
3803 4464 : if (obe && !a->func->order_required && !a->func->opt_order)
3804 : obe = NULL;
3805 4464 : if (obe) /* add order by expressions */
3806 4464 : e->r = append(sa_list(sql->sa), obe);
3807 26548 : if (!groupby)
3808 : return e;
3809 26548 : if (all_freevar)
3810 247 : query_outer_aggregated(query, all_freevar-1, e);
3811 26548 : e = rel_groupby_add_aggr(sql, groupby, e);
3812 26548 : if (!group && !all_freevar)
3813 : return e;
3814 19933 : if (all_freevar) {
3815 247 : rel_bind_vars(sql, groupby->l, exps);
3816 247 : assert(!is_simple_project(res->op));
3817 247 : e->card = CARD_ATOM;
3818 247 : set_freevar(e, all_freevar-1);
3819 247 : return e;
3820 : }
3821 : return e;
3822 : }
3823 5 : const char *type = "unknown";
3824 5 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
3825 :
3826 5 : if (!list_empty(exps)) {
3827 5 : sql_exp *e = exps->h->data;
3828 5 : type = exp_subtype(e)->type->base.name;
3829 : }
3830 15 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "%s: %s aggregate %s%s%s'%s'(%s)", toUpperCopy(uaname, aname), found ? "insufficient privileges for" : "no such",
3831 : sname ? "'":"", sname ? sname : "", sname ? "'.":"", aname, type);
3832 : }
3833 :
3834 : static sql_exp *
3835 19607 : rel_aggr(sql_query *query, sql_rel **rel, symbol *se, int f)
3836 : {
3837 19607 : dlist *l = se->data.lval;
3838 19607 : dnode *d = l->h->next->next;
3839 19607 : symbol *orderby = d->next?d->next->data.sym:NULL;
3840 19607 : int distinct = l->h->next->data.i_val;
3841 19607 : char *aname = qname_schema_object(l->h->data.lval);
3842 19607 : char *sname = qname_schema(l->h->data.lval);
3843 :
3844 19607 : return _rel_aggr(query, rel, distinct, sname, aname, d->data.lval?d->data.lval->h:NULL, orderby, f);
3845 : }
3846 :
3847 : static sql_exp *
3848 102377 : rel_case(sql_query *query, sql_rel **rel, symbol *opt_cond, dlist *when_search_list, symbol *opt_else, int f)
3849 : {
3850 102377 : mvc *sql = query->sql;
3851 102377 : sql_subtype *tpe = NULL;
3852 102377 : list *conds = new_exp_list(sql->sa), *results = new_exp_list(sql->sa);
3853 102377 : sql_subtype *restype = NULL, *condtype = NULL, ctype, rtype, bt;
3854 102377 : sql_exp *res = NULL, *opt_cond_exp = NULL;
3855 102377 : exp_kind ek = {type_value, card_column, FALSE};
3856 :
3857 102377 : if (opt_cond) {
3858 9630 : if (!(opt_cond_exp = rel_value_exp(query, rel, opt_cond, f, ek)))
3859 : return NULL;
3860 9629 : condtype = exp_subtype(opt_cond_exp);
3861 : }
3862 :
3863 252813 : for (dnode *dn = when_search_list->h; dn; dn = dn->next) {
3864 150446 : sql_exp *cond = NULL, *result = NULL;
3865 150446 : dlist *when = dn->data.sym->data.lval;
3866 :
3867 150446 : if (opt_cond)
3868 46416 : cond = rel_value_exp(query, rel, when->h->data.sym, f, ek);
3869 : else
3870 104030 : cond = rel_logical_value_exp(query, rel, when->h->data.sym, f, ek);
3871 150446 : if (!cond)
3872 : return NULL;
3873 150440 : append(conds, cond);
3874 150440 : tpe = exp_subtype(cond);
3875 150440 : if (tpe && condtype) {
3876 57693 : result_datatype(&ctype, condtype, tpe);
3877 57693 : condtype = &ctype;
3878 92747 : } else if (tpe) {
3879 92745 : condtype = tpe;
3880 : }
3881 :
3882 150440 : if (!(result = rel_value_exp(query, rel, when->h->next->data.sym, f, ek)))
3883 : return NULL;
3884 150437 : append(results, result);
3885 150437 : tpe = exp_subtype(result);
3886 150437 : if (tpe && restype) {
3887 48067 : result_datatype(&rtype, restype, tpe);
3888 48067 : restype = &rtype;
3889 102370 : } else if (tpe) {
3890 102364 : restype = tpe;
3891 : }
3892 : }
3893 102367 : if (opt_else) {
3894 99749 : if (!(res = rel_value_exp(query, rel, opt_else, f, ek)))
3895 : return NULL;
3896 :
3897 99749 : tpe = exp_subtype(res);
3898 99749 : if (tpe && restype) {
3899 99744 : result_datatype(&rtype, restype, tpe);
3900 99744 : restype = &rtype;
3901 5 : } else if (tpe) {
3902 : restype = tpe;
3903 : }
3904 :
3905 99747 : if (!restype)
3906 2 : return sql_error(sql, 02, SQLSTATE(42000) "Result type missing");
3907 99747 : if (restype->type->localtype == TYPE_void) /* NULL */
3908 0 : restype = sql_bind_localtype("str");
3909 :
3910 99747 : if (!(res = exp_check_type(sql, restype, rel ? *rel : NULL, res, type_equal)))
3911 : return NULL;
3912 : } else {
3913 2618 : if (!restype)
3914 0 : return sql_error(sql, 02, SQLSTATE(42000) "Result type missing");
3915 2618 : if (restype->type->localtype == TYPE_void) /* NULL */
3916 7 : restype = sql_bind_localtype("str");
3917 2618 : res = exp_null(sql->sa, restype);
3918 : }
3919 :
3920 102365 : if (!condtype)
3921 0 : return sql_error(sql, 02, SQLSTATE(42000) "Condition type missing");
3922 102365 : if (condtype->type->localtype == TYPE_void) /* NULL */
3923 0 : condtype = sql_bind_localtype("str");
3924 102365 : if (opt_cond_exp && !(opt_cond_exp = exp_check_type(sql, condtype, rel ? *rel : NULL, opt_cond_exp, type_equal)))
3925 : return NULL;
3926 102365 : sql_find_subtype(&bt, "boolean", 0, 0);
3927 102365 : list *args = sa_list(sql->sa);
3928 102365 : if (opt_cond_exp)
3929 9623 : append(args, opt_cond_exp);
3930 252795 : for (node *n = conds->h, *m = results->h; n && m; n = n->next, m = m->next) {
3931 150431 : sql_exp *cond = n->data;
3932 150431 : sql_exp *result = m->data;
3933 :
3934 150431 : if (!(result = exp_check_type(sql, restype, rel ? *rel : NULL, result, type_equal)))
3935 : return NULL;
3936 :
3937 150431 : if (!(cond = exp_check_type(sql, condtype, rel ? *rel : NULL, cond, type_equal)))
3938 : return NULL;
3939 150430 : if (!opt_cond_exp && !(cond = exp_check_type(sql, &bt, rel ? *rel : NULL, cond, type_equal)))
3940 : return NULL;
3941 150430 : append(args, cond);
3942 150430 : append(args, result);
3943 : }
3944 102364 : assert(res);
3945 102364 : list_append(args, res);
3946 102364 : list *types = sa_list(sql->sa);
3947 102364 : types = append(append(types, restype), restype);
3948 195106 : sql_subfunc *case_func = find_func(sql, NULL, opt_cond_exp?"casewhen":"case", list_length(types), F_FUNC, true, NULL, NULL);
3949 102364 : res = exp_op(sql->sa, args, case_func);
3950 102364 : ((sql_subfunc*)res->f)->res->h->data = sql_create_subtype(sql->sa, restype->type, restype->digits, restype->scale);
3951 102364 : return res;
3952 : }
3953 :
3954 : static sql_exp *
3955 4066 : rel_complex_case(sql_query *query, sql_rel **rel, dlist *case_args, int f, str func)
3956 : {
3957 4066 : exp_kind ek = {type_value, card_column, FALSE};
3958 4066 : list *args = sa_list(query->sql->sa);
3959 4066 : sql_subtype *restype = NULL, rtype;
3960 4066 : sql_exp *res;
3961 :
3962 : /* generate nested func calls */
3963 12654 : for(dnode *dn = case_args->h; dn; dn = dn->next) {
3964 8601 : sql_exp *a = rel_value_exp(query, rel, dn->data.sym, f, ek);
3965 8601 : if (!a)
3966 : return NULL;
3967 8588 : append(args, a);
3968 : /* all arguments should have the same type */
3969 8588 : sql_subtype *tpe = exp_subtype(a);
3970 8588 : if (tpe && restype) {
3971 4524 : result_datatype(&rtype, restype, tpe);
3972 4524 : restype = &rtype;
3973 4064 : } else if (tpe) {
3974 4064 : restype = tpe;
3975 : }
3976 : }
3977 4053 : if (!restype)
3978 0 : return sql_error(query->sql, 02, SQLSTATE(42000) "Result type missing");
3979 4053 : if (restype->type->localtype == TYPE_void) /* NULL */
3980 0 : restype = sql_bind_localtype("str");
3981 4053 : list *nargs = sa_list(query->sql->sa);
3982 12626 : for (node *m = args->h; m; m = m->next) {
3983 8573 : sql_exp *result = m->data;
3984 :
3985 8573 : if (!(result = exp_check_type(query->sql, restype, rel ? *rel : NULL, result, type_equal)))
3986 : return NULL;
3987 8573 : append(nargs, result);
3988 : }
3989 4053 : list *types = append(append(sa_list(query->sql->sa), restype), restype);
3990 4053 : sql_subfunc *fnc = find_func(query->sql, NULL, func, list_length(types), F_FUNC, true, NULL, NULL);
3991 4053 : res = exp_op(query->sql->sa, nargs, fnc);
3992 4053 : ((sql_subfunc*)res->f)->res->h->data = sql_create_subtype(query->sql->sa, restype->type, restype->digits, restype->scale);
3993 4053 : return res;
3994 : }
3995 :
3996 : static sql_exp *
3997 106443 : rel_case_exp(sql_query *query, sql_rel **rel, symbol *se, int f)
3998 : {
3999 106443 : dlist *l = se->data.lval;
4000 :
4001 106443 : if (se->token == SQL_COALESCE) {
4002 3915 : return rel_complex_case(query, rel, l, f | sql_farg, "coalesce");
4003 102528 : } else if (se->token == SQL_NULLIF) {
4004 151 : return rel_complex_case(query, rel, l, f | sql_farg, "nullif");
4005 102377 : } else if (l->h->type == type_list) {
4006 92747 : dlist *when_search_list = l->h->data.lval;
4007 92747 : symbol *opt_else = l->h->next->data.sym;
4008 :
4009 92747 : return rel_case(query, rel, NULL, when_search_list, opt_else, f | sql_farg);
4010 : } else {
4011 9630 : symbol *scalar_exp = l->h->data.sym;
4012 9630 : dlist *when_value_list = l->h->next->data.lval;
4013 9630 : symbol *opt_else = l->h->next->next->data.sym;
4014 :
4015 9630 : return rel_case(query, rel, scalar_exp, when_value_list, opt_else, f | sql_farg);
4016 : }
4017 : }
4018 :
4019 : #define E_ATOM_STRING(e) ((atom*)(e)->l)->data.val.sval
4020 :
4021 : static sql_exp *
4022 176254 : rel_cast(sql_query *query, sql_rel **rel, symbol *se, int f)
4023 : {
4024 176254 : mvc *sql = query->sql;
4025 176254 : dlist *dl = se->data.lval;
4026 176254 : symbol *s = dl->h->data.sym;
4027 176254 : sql_subtype *tpe = &dl->h->next->data.typeval;
4028 176254 : exp_kind ek = {type_value, card_column, FALSE};
4029 176254 : sql_exp *e = rel_value_exp(query, rel, s, f|sql_farg, ek);
4030 :
4031 176254 : if (!e)
4032 : return NULL;
4033 :
4034 : /* strings may need to be truncated */
4035 176239 : if (EC_VARCHAR(tpe->type->eclass) && tpe->digits > 0) {
4036 85770 : sql_subtype *et = exp_subtype(e);
4037 : /* truncate only if the number of digits are smaller or from clob */
4038 85770 : if (et && EC_VARCHAR(et->type->eclass) && (tpe->digits < et->digits || et->digits == 0)) {
4039 2920 : sql_subfunc *c = sql_bind_func(sql, "sys", "truncate", et, sql_bind_localtype("int"), F_FUNC, true, true);
4040 2920 : if (c)
4041 2920 : e = exp_binop(sql->sa, e, exp_atom_int(sql->sa, tpe->digits), c);
4042 : }
4043 : }
4044 :
4045 176239 : if (tpe->type->eclass == EC_DEC) {
4046 469 : sql_subtype *et = exp_subtype(e);
4047 469 : if (e->type == e_atom && !tpe->digits) {
4048 9 : if (et->type->eclass == EC_NUM || et->type->eclass == EC_DEC) {
4049 6 : tpe->digits = atom_num_digits(e->l);
4050 6 : tpe = sql_bind_subtype(sql->sa, "decimal", tpe->digits, et->scale);
4051 3 : } else if (EC_VARCHAR(et->type->eclass)) {
4052 2 : char *s = E_ATOM_STRING(e);
4053 2 : unsigned int min_precision = 0, min_scale = 0;
4054 2 : bool dot_seen = false;
4055 16 : for (size_t i = 0; i < strlen(s); i++) {
4056 14 : if (isdigit(s[i])) {
4057 12 : min_precision++;
4058 12 : if (dot_seen)
4059 10 : min_scale++;
4060 2 : } else if (s[i] == '.') {
4061 2 : dot_seen = true;
4062 : }
4063 : }
4064 2 : tpe = sql_bind_subtype(sql->sa, "decimal", min_precision, min_scale);
4065 : } else { /* fallback */
4066 1 : tpe = sql_bind_subtype(sql->sa, "decimal", 18, 3);
4067 : }
4068 460 : } else if (!tpe->digits && !tpe->scale) {
4069 105 : if (et->type->eclass == EC_NUM)
4070 36 : tpe = sql_bind_subtype(sql->sa, "decimal", et->digits, 0);
4071 : else /* fallback */
4072 69 : tpe = sql_bind_subtype(sql->sa, "decimal", 18, 3);
4073 : }
4074 : }
4075 :
4076 176239 : if (e)
4077 176239 : e = exp_check_type(sql, tpe, rel ? *rel : NULL, e, type_cast);
4078 :
4079 176239 : if (e && e->type == e_convert)
4080 49885 : exp_label(sql->sa, e, ++sql->label);
4081 :
4082 : return e;
4083 : }
4084 :
4085 : static sql_exp *
4086 1590 : rel_next_value_for( mvc *sql, symbol *se )
4087 : {
4088 1590 : char *sname = qname_schema(se->data.lval);
4089 1590 : char *seqname = qname_schema_object(se->data.lval);
4090 1590 : sql_sequence *seq = NULL;
4091 1590 : sql_subtype t;
4092 1590 : sql_subfunc *f;
4093 :
4094 1590 : if (!sname)
4095 225 : sname = "sys";
4096 1590 : if (!stack_find_rel_view(sql, seqname)) {
4097 1389 : if (!(seq = find_sequence_on_scope(sql, sname, seqname, "NEXT VALUE FOR")))
4098 : return NULL;
4099 1387 : if (!mvc_schema_privs(sql, seq->s))
4100 0 : return sql_error(sql, 02, SQLSTATE(42000) "NEXT VALUE FOR: access denied for %s to schema '%s'", get_string_global_var(sql, "current_user"), seq->s->base.name);
4101 : }
4102 1588 : sql_find_subtype(&t, "varchar", 0, 0);
4103 1588 : f = sql_bind_func(sql, "sys", "next_value_for", &t, &t, F_FUNC, true, true);
4104 1588 : assert(f);
4105 : /* sequence found in the stack, ie just created. use given schema? */
4106 1588 : return exp_binop(sql->sa, exp_atom_str(sql->sa, seq && seq->s ? seq->s->base.name : sname, &t), exp_atom_str(sql->sa, seqname, &t), f);
4107 : }
4108 :
4109 : /* some users like to use aliases already in the groupby */
4110 : static sql_exp *
4111 165 : rel_selection_ref(sql_query *query, sql_rel **rel, char *name, dlist *selection)
4112 : {
4113 165 : allocator *sa = query->sql->sa;
4114 165 : dlist *nl;
4115 165 : exp_kind ek = {type_value, card_column, FALSE};
4116 165 : sql_exp *res = NULL;
4117 165 : symbol *nsym;
4118 :
4119 165 : if (!selection)
4120 : return NULL;
4121 :
4122 679 : for (dnode *n = selection->h; n; n = n->next) {
4123 : /* we only look for columns */
4124 517 : tokens to = n->data.sym->token;
4125 517 : if (to == SQL_COLUMN || to == SQL_IDENT) {
4126 515 : dlist *l = n->data.sym->data.lval;
4127 : /* AS name */
4128 515 : if (l->h->next->data.sval && strcmp(l->h->next->data.sval, name) == 0) {
4129 146 : sql_exp *ve = rel_value_exp(query, rel, l->h->data.sym, sql_sel|sql_groupby, ek);
4130 146 : if (ve) {
4131 145 : if (res)
4132 1 : return sql_error(query->sql, ERR_AMBIGUOUS, SQLSTATE(42000) "SELECT: identifier '%s' ambiguous", name);
4133 144 : res = ve;
4134 :
4135 144 : nl = dlist_create(sa);
4136 144 : exp_setname(query->sql, ve, NULL, name);
4137 : /* now we should rewrite the selection such that it uses the new group by column */
4138 144 : dlist_append_string(sa, nl, sa_strdup(sa, name));
4139 144 : nsym = symbol_create_list(sa, to, nl);
4140 144 : nl = dlist_create(sa);
4141 144 : dlist_append_symbol(sa, nl, nsym);
4142 : /* no alias */
4143 144 : dlist_append_symbol(sa, nl, NULL);
4144 144 : n->data.sym = symbol_create_list(sa, to, nl);
4145 : }
4146 : }
4147 : }
4148 : }
4149 : return res;
4150 : }
4151 :
4152 : static char*
4153 197 : symbol_get_identifier(symbol *sym)
4154 : {
4155 197 : dlist *syml;
4156 :
4157 197 : if (sym->token != SQL_COLUMN && sym->token != SQL_IDENT)
4158 : return NULL;
4159 182 : syml = sym->data.lval;
4160 182 : if (dlist_length(syml) > 1)
4161 : return NULL;
4162 :
4163 165 : return syml->h->data.sval;
4164 : }
4165 :
4166 : static sql_exp*
4167 36823 : rel_group_column(sql_query *query, sql_rel **rel, symbol *grp, dlist *selection, list *exps, int f)
4168 : {
4169 36823 : sql_query *lquery = query_create(query->sql);
4170 36823 : mvc *sql = query->sql;
4171 36823 : exp_kind ek = {type_value, card_value, TRUE};
4172 36823 : sql_exp *e = rel_value_exp2(lquery, rel, grp, f, ek);
4173 :
4174 36823 : if (e && exp_is_atom(e)) {
4175 35 : sql_subtype *tpe = exp_subtype(e);
4176 35 : if (!is_atom(e->type) ||!tpe || tpe->type->eclass != EC_NUM) {
4177 3 : if (!tpe)
4178 2 : return sql_error(sql, 02, SQLSTATE(42000) "Cannot have a parameter (?) for group by column");
4179 4 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: non-integer constant in GROUP BY");
4180 : }
4181 : }
4182 :
4183 192 : if (!e) {
4184 192 : char buf[ERRSIZE], *name;
4185 192 : int status = sql->session->status;
4186 192 : strcpy(buf, sql->errstr);
4187 : /* reset error */
4188 192 : sql->session->status = 0;
4189 192 : sql->errstr[0] = '\0';
4190 :
4191 192 : if ((name = symbol_get_identifier(grp))) {
4192 163 : e = rel_selection_ref(query, rel, name, selection);
4193 163 : if (!e) { /* attempt to find in the existing list of group by expressions */
4194 29 : for (node *n = exps->h ; n && !e ; n = n->next) {
4195 9 : sql_exp *ge = (sql_exp *) n->data;
4196 9 : const char *gen = exp_name(ge);
4197 :
4198 9 : if (gen && strcmp(name, gen) == 0)
4199 5 : e = exp_ref(sql, ge);
4200 : }
4201 : }
4202 : }
4203 49 : if (!e && query_has_outer(query)) {
4204 : /* reset error */
4205 32 : sql->session->status = 0;
4206 32 : sql->errstr[0] = '\0';
4207 32 : e = rel_value_exp2(query, rel, grp, f, ek);
4208 : }
4209 44 : if (!e) {
4210 13 : if (sql->errstr[0] == 0) {
4211 10 : sql->session->status = status;
4212 10 : strcpy(sql->errstr, buf);
4213 : }
4214 13 : return NULL;
4215 : }
4216 : }
4217 36804 : if (!exp_subtype(e))
4218 0 : return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) for group by column");
4219 : return e;
4220 : }
4221 :
4222 : static list*
4223 44 : list_power_set(allocator *sa, list* input) /* cube */
4224 : {
4225 44 : list *res = sa_list(sa);
4226 : /* N stores total number of subsets */
4227 44 : int N = (int) pow(2, input->cnt);
4228 :
4229 : /* generate each subset one by one */
4230 266 : for (int i = 0; i < N; i++) {
4231 222 : list *ll = sa_list(sa);
4232 222 : int j = 0; /* check every bit of i */
4233 844 : for (node *n = input->h ; n ; n = n->next) {
4234 : /* if j'th bit of i is set, then append */
4235 622 : if (i & (1 << j))
4236 311 : list_prepend(ll, n->data);
4237 622 : j++;
4238 : }
4239 222 : list_prepend(res, ll);
4240 : }
4241 44 : return res;
4242 : }
4243 :
4244 : static list*
4245 61 : list_rollup(allocator *sa, list* input)
4246 : {
4247 61 : list *res = sa_list(sa);
4248 :
4249 188 : for (int counter = input->cnt; counter > 0; counter--) {
4250 127 : list *ll = sa_list(sa);
4251 127 : int j = 0;
4252 376 : for (node *n = input->h; n && j < counter; j++, n = n->next)
4253 249 : list_append(ll, n->data);
4254 127 : list_append(res, ll);
4255 : }
4256 61 : list_append(res, sa_list(sa)); /* global aggregate case */
4257 61 : return res;
4258 : }
4259 :
4260 : static int
4261 320 : list_equal(list* list1, list* list2)
4262 : {
4263 375 : for (node *n = list1->h; n ; n = n->next) {
4264 328 : sql_exp *e = (sql_exp*) n->data;
4265 328 : if (!exps_find_exp(list2, e))
4266 : return 1;
4267 : }
4268 78 : for (node *n = list2->h; n ; n = n->next) {
4269 47 : sql_exp *e = (sql_exp*) n->data;
4270 47 : if (!exps_find_exp(list1, e))
4271 : return 1;
4272 : }
4273 : return 0;
4274 : }
4275 :
4276 : static list*
4277 26 : lists_cartesian_product_and_distinct(allocator *sa, list *l1, list *l2)
4278 : {
4279 26 : list *res = sa_list(sa);
4280 :
4281 : /* for each list of l2, merge into each list of l1 while removing duplicates */
4282 116 : for (node *n = l1->h ; n ; n = n->next) {
4283 90 : list *sub_list = (list*) n->data;
4284 :
4285 279 : for (node *m = l2->h ; m ; m = m->next) {
4286 189 : list *other = (list*) m->data;
4287 189 : list_append(res, list_distinct(list_merge(list_dup(sub_list, (fdup) NULL), other, (fdup) NULL), (fcmp) list_equal, (fdup) NULL));
4288 : }
4289 : }
4290 26 : return res;
4291 : }
4292 :
4293 : static list*
4294 13584 : rel_groupings(sql_query *query, sql_rel **rel, symbol *groupby, dlist *selection, int f, bool grouping_sets, list **sets)
4295 : {
4296 13584 : mvc *sql = query->sql;
4297 13584 : list *exps = new_exp_list(sql->sa);
4298 :
4299 13584 : if (mvc_highwater(sql))
4300 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
4301 :
4302 50314 : for (dnode *o = groupby->data.lval->h; o; o = o->next) {
4303 36750 : symbol *grouping = o->data.sym;
4304 36750 : list *next_set = NULL;
4305 :
4306 36750 : if (grouping->token == SQL_GROUPING_SETS) { /* call recursively, and merge the generated sets */
4307 39 : list *other = rel_groupings(query, rel, grouping, selection, f, true, &next_set);
4308 39 : if (!other)
4309 20 : return NULL;
4310 39 : exps = list_distinct(list_merge(exps, other, (fdup) NULL), (fcmp) exp_equal, (fdup) NULL);
4311 : } else {
4312 36711 : dlist *dl = grouping->data.lval;
4313 36711 : if (dl) {
4314 36685 : list *set_cols = new_exp_list(sql->sa); /* columns and combination of columns to be used for the next set */
4315 :
4316 73459 : for (dnode *oo = dl->h; oo; oo = oo->next) {
4317 36793 : symbol *grp = oo->data.sym;
4318 36793 : list *next_tuple = new_exp_list(sql->sa); /* next tuple of columns */
4319 :
4320 36793 : if (grp->token == SQL_COLUMN_GROUP) { /* set of columns */
4321 71 : assert(is_sql_group_totals(f));
4322 172 : for (dnode *ooo = grp->data.lval->h; ooo; ooo = ooo->next) {
4323 101 : symbol *elm = ooo->data.sym;
4324 101 : sql_exp *e = rel_group_column(query, rel, elm, selection, exps, f);
4325 101 : if (!e)
4326 : return NULL;
4327 101 : assert(e->type == e_column);
4328 101 : list_append(next_tuple, e);
4329 101 : list_append(exps, e);
4330 : }
4331 : } else { /* single column or expression */
4332 36722 : sql_exp *e = rel_group_column(query, rel, grp, selection, exps, f);
4333 36722 : if (!e)
4334 : return NULL;
4335 36703 : if (e->type != e_column && !exp_is_atom(e)) { /* store group by expressions in the stack */
4336 142 : if (is_sql_group_totals(f))
4337 0 : return sql_error(sql, 02, SQLSTATE(42000) "GROUP BY: grouping expressions not possible with ROLLUP, CUBE and GROUPING SETS");
4338 142 : if (!exp_has_rel(e) && !frame_push_groupby_expression(sql, grp, e))
4339 : return NULL;
4340 : }
4341 36703 : list_append(next_tuple, e);
4342 36703 : list_append(exps, e);
4343 : }
4344 36774 : list_append(set_cols, next_tuple);
4345 : }
4346 36666 : if (is_sql_group_totals(f)) {
4347 178 : if (grouping->token == SQL_ROLLUP)
4348 61 : next_set = list_rollup(sql->sa, set_cols);
4349 117 : else if (grouping->token == SQL_CUBE)
4350 44 : next_set = list_power_set(sql->sa, set_cols);
4351 : else /* the list of sets is not used in the "GROUP BY a, b, ..." case */
4352 73 : next_set = list_append(new_exp_list(sql->sa), set_cols);
4353 : }
4354 26 : } else if (is_sql_group_totals(f) && grouping_sets) /* The GROUP BY () case is the global aggregate which is always added by ROLLUP and CUBE */
4355 17 : next_set = list_append(new_exp_list(sql->sa), new_exp_list(sql->sa));
4356 : }
4357 36731 : if (is_sql_group_totals(f)) { /* if there are no sets, set the found one, otherwise calculate cartesian product and merge the distinct ones */
4358 235 : if (!next_set)
4359 1 : return sql_error(sql, 02, SQLSTATE(42000) "GROUP BY: GROUPING SETS is empty");
4360 234 : if (!*sets)
4361 157 : *sets = next_set;
4362 : else
4363 77 : *sets = grouping_sets ? list_merge(*sets, next_set, (fdup) NULL) : lists_cartesian_product_and_distinct(sql->sa, *sets, next_set);
4364 : }
4365 : }
4366 : return exps;
4367 : }
4368 :
4369 : static list*
4370 2339 : rel_partition_groupings(sql_query *query, sql_rel **rel, symbol *partitionby, dlist *selection, int f)
4371 : {
4372 2339 : mvc *sql = query->sql;
4373 2339 : dnode *o = partitionby->data.lval->h;
4374 2339 : list *exps = new_exp_list(sql->sa);
4375 :
4376 7048 : for (; o; o = o->next) {
4377 2378 : symbol *grp = o->data.sym;
4378 2378 : exp_kind ek = {type_value, card_value, TRUE};
4379 2378 : sql_exp *e = rel_value_exp2(query, rel, grp, f, ek);
4380 :
4381 2378 : if (!e) {
4382 5 : int status = sql->session->status;
4383 5 : char buf[ERRSIZE], *name;
4384 :
4385 : /* reset error */
4386 5 : sql->session->status = 0;
4387 5 : strcpy(buf, sql->errstr);
4388 5 : sql->errstr[0] = '\0';
4389 :
4390 5 : if ((name = symbol_get_identifier(grp))) {
4391 2 : e = rel_selection_ref(query, rel, name, selection);
4392 2 : if (!e) { /* attempt to find in the existing list of partition by expressions */
4393 3 : for (node *n = exps->h ; n ; n = n->next) {
4394 1 : sql_exp *ge = (sql_exp *) n->data;
4395 1 : const char *gen = exp_name(ge);
4396 :
4397 1 : if (gen && strcmp(name, gen) == 0) {
4398 0 : e = exp_ref(sql, ge);
4399 0 : break;
4400 : }
4401 : }
4402 : }
4403 : }
4404 5 : if (!e) {
4405 5 : if (sql->errstr[0] == 0) {
4406 5 : sql->session->status = status;
4407 5 : strcpy(sql->errstr, buf);
4408 : }
4409 5 : return NULL;
4410 : }
4411 : }
4412 :
4413 2373 : if (exp_has_rel(e))
4414 3 : return sql_error(sql, 02, SQLSTATE(42000) "PARTITION BY: subqueries not allowed in PARTITION BY clause");
4415 :
4416 2370 : if (e->type != e_column) { /* store group by expressions in the stack */
4417 42 : if (!frame_push_groupby_expression(sql, grp, e))
4418 : return NULL;
4419 : }
4420 :
4421 2370 : if (e->card > CARD_AGGR)
4422 2248 : e->card = CARD_AGGR;
4423 2370 : append(exps, e);
4424 : }
4425 : return exps;
4426 : }
4427 :
4428 : /* find selection expressions matching the order by column expression */
4429 : /* complex columns only */
4430 : static sql_exp *
4431 68605 : rel_order_by_column_exp(sql_query *query, sql_rel **R, symbol *column_r, int needs_distinct, int f)
4432 : {
4433 68605 : mvc *sql = query->sql;
4434 68605 : sql_rel *r = *R, *p = NULL;
4435 68605 : sql_exp *e = NULL, *found = NULL;
4436 68605 : exp_kind ek = {type_value, card_column, FALSE};
4437 :
4438 68605 : if (!r)
4439 : return e;
4440 :
4441 68605 : if (is_simple_project(r->op) && r->l && is_processed(r)) {
4442 68543 : p = r;
4443 68543 : r = r->l;
4444 : }
4445 :
4446 68605 : e = rel_value_exp(query, &r, column_r, f, ek);
4447 :
4448 68605 : if (r && !p)
4449 62 : *R = r;
4450 68543 : else if (r)
4451 68543 : p->l = r;
4452 68605 : if (e && p) {
4453 68516 : if (is_project(p->op) && (found = exps_any_match(p->exps, e))) { /* if one of the projections matches, return a reference to it */
4454 60785 : e = exp_ref(sql, found);
4455 : } else {
4456 7731 : if (needs_distinct)
4457 2 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: with DISTINCT ORDER BY expressions must appear in select list");
4458 7729 : e = rel_project_add_exp(sql, p, e);
4459 7729 : if (r) {
4460 126861 : for (node *n = p->exps->h ; n ; n = n->next) {
4461 119134 : sql_exp *ee = n->data;
4462 :
4463 119134 : if (ee->card > r->card) {
4464 2 : if (exp_name(ee) && !has_label(ee))
4465 2 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(ee));
4466 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
4467 : }
4468 : }
4469 : }
4470 : }
4471 68512 : return e;
4472 : }
4473 89 : if (e && r && is_project(r->op)) {
4474 28 : sql_exp *found = exps_find_exp(r->exps, e);
4475 :
4476 28 : if (!found) {
4477 8 : if (needs_distinct)
4478 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: with DISTINCT ORDER BY expressions must appear in select list");
4479 8 : if (!is_simple_project(r->op) && !is_groupby(r->op))
4480 1 : *R = r = rel_project(sql->sa, r, rel_projections(sql, r, NULL, 1, 0));
4481 8 : append(r->exps, e);
4482 : } else {
4483 : e = found;
4484 : }
4485 28 : e = exp_ref(sql, e);
4486 : }
4487 : return e;
4488 : }
4489 :
4490 : static dlist *
4491 115640 : simple_selection(symbol *sq)
4492 : {
4493 115640 : if (sq->token == SQL_SELECT) {
4494 13 : SelectNode *sn;
4495 13 : sn = (SelectNode *) sq;
4496 :
4497 13 : if (!sn->from && !sn->where && !sn->distinct && !sn->window && dlist_length(sn->selection) == 1)
4498 7 : return sn->selection;
4499 : }
4500 : return NULL;
4501 : }
4502 :
4503 : static list *
4504 44952 : rel_order_by(sql_query *query, sql_rel **R, symbol *orderby, int needs_distinct, int f)
4505 : {
4506 44952 : mvc *sql = query->sql;
4507 44952 : sql_rel *rel = *R, *or = rel; /* the order by relation */
4508 44952 : list *exps = new_exp_list(sql->sa);
4509 :
4510 44952 : if (!orderby->data.lval) { /* by all */
4511 6 : if (is_sql_orderby(f)) {
4512 6 : assert(is_project(rel->op));
4513 22 : for(node *n = rel->exps->h; n; n = n->next) {
4514 16 : sql_exp *e = n->data;
4515 16 : append(exps, exp_ref(sql, e));
4516 : }
4517 : return exps;
4518 : }
4519 : return NULL;
4520 : }
4521 :
4522 44946 : dnode *o = orderby->data.lval->h;
4523 44946 : dlist *selection = NULL;
4524 :
4525 44946 : if (is_sql_orderby(f)) {
4526 37429 : assert(is_project(rel->op));
4527 37429 : rel = rel->l;
4528 : }
4529 :
4530 160538 : for (; o; o = o->next) {
4531 115640 : symbol *order = o->data.sym;
4532 :
4533 115640 : if (order->token == SQL_COLUMN || order->token == SQL_IDENT) {
4534 115640 : symbol *col = order->data.lval->h->data.sym;
4535 115640 : int direction = order->data.lval->h->next->data.i_val;
4536 115640 : sql_exp *e = NULL;
4537 :
4538 115640 : assert(order->data.lval->h->next->type == type_int);
4539 115640 : if ((selection = simple_selection(col)) != NULL) {
4540 7 : dnode *o = selection->h;
4541 7 : order = o->data.sym;
4542 7 : if (order->data.lval->h->type == type_symbol)
4543 6 : col = order->data.lval->h->data.sym;
4544 : /* remove optional name from selection */
4545 7 : order->data.lval->h->next = NULL;
4546 : }
4547 :
4548 115640 : if (col->token == SQL_COLUMN || col->token == SQL_IDENT || col->token == SQL_ATOM) {
4549 115418 : exp_kind ek = {type_value, card_column, FALSE};
4550 :
4551 115418 : e = rel_value_exp2(query, &rel, col, f, ek);
4552 :
4553 115418 : if (e && e->card <= CARD_ATOM) {
4554 9376 : sql_subtype *tpe = exp_subtype(e);
4555 : /* integer atom on the stack */
4556 9376 : if (!is_sql_window(f) && e->type == e_atom &&
4557 9268 : tpe->type->eclass == EC_NUM) {
4558 9259 : atom *a = e->l;
4559 9259 : int nr = (int)atom_get_int(a);
4560 :
4561 9259 : e = exps_get_exp(rel->exps, nr);
4562 9259 : if (!e)
4563 3 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: the order by column number (%d) is not in the number of projections range (%d)", nr, list_length(rel->exps));
4564 9256 : e = exp_ref(sql, e);
4565 : }
4566 37653 : } else if (e && exp_card(e) > rel->card) {
4567 0 : if (exp_name(e) && !has_label(e))
4568 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(e));
4569 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
4570 : }
4571 115415 : if (e && !exp_name(e))
4572 23 : exp_label(sql->sa, e, ++sql->label);
4573 47026 : if (e && rel && is_project(rel->op)) {
4574 40016 : sql_exp *found = exps_find_exp(rel->exps, e);
4575 :
4576 40016 : if (!found) {
4577 33 : if (needs_distinct)
4578 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: with DISTINCT ORDER BY expressions must appear in select list");
4579 33 : if (!is_freevar(e))
4580 16 : append(rel->exps, e);
4581 : } else {
4582 : e = found;
4583 : }
4584 40016 : if (!is_freevar(e))
4585 39999 : e = exp_ref(sql, e);
4586 : }
4587 : }
4588 :
4589 115637 : if (rel && !e && sql->session->status != -ERR_AMBIGUOUS) {
4590 : /* reset error */
4591 68605 : sql->session->status = 0;
4592 68605 : sql->errstr[0] = '\0';
4593 :
4594 68605 : e = rel_order_by_column_exp(query, &rel, col, needs_distinct, sql_sel | sql_orderby | (f & sql_group_totals) | (f & sql_window));
4595 : }
4596 68611 : if (!e)
4597 : return NULL;
4598 115593 : if (!exp_subtype(e))
4599 1 : return sql_error(sql, 01, SQLSTATE(42000) "Cannot have a parameter (?) for order by column");
4600 115592 : set_direction(e, direction);
4601 115592 : list_append(exps, e);
4602 : } else {
4603 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: order not of type SQL_COLUMN");
4604 : }
4605 : }
4606 44898 : if (is_sql_orderby(f) && or != rel)
4607 37388 : or->l = rel;
4608 44898 : if (is_sql_window(f))
4609 3046 : *R = rel;
4610 : return exps;
4611 : }
4612 :
4613 : static int
4614 814 : generate_window_bound(tokens sql_token, bool first_half)
4615 : {
4616 814 : switch (sql_token) {
4617 408 : case SQL_PRECEDING:
4618 408 : return first_half ? BOUND_FIRST_HALF_PRECEDING : BOUND_SECOND_HALF_PRECEDING;
4619 284 : case SQL_FOLLOWING:
4620 284 : return first_half ? BOUND_FIRST_HALF_FOLLOWING : BOUND_SECOND_HALF_FOLLOWING;
4621 122 : case SQL_CURRENT_ROW:
4622 122 : return first_half ? CURRENT_ROW_PRECEDING : CURRENT_ROW_FOLLOWING;
4623 : default:
4624 0 : assert(0);
4625 : }
4626 : return 0;
4627 : }
4628 :
4629 : /* window functions */
4630 : static sql_exp*
4631 407 : generate_window_bound_call(mvc *sql, sql_exp **estart, sql_exp **eend, sql_exp *pe, sql_exp *e,
4632 : sql_exp *start, sql_exp *fend, int frame_type, int excl, tokens t1, tokens t2)
4633 : {
4634 407 : list *rargs1 = sa_list(sql->sa), *rargs2 = sa_list(sql->sa), *targs1 = sa_list(sql->sa), *targs2 = sa_list(sql->sa);
4635 407 : sql_subfunc *dc1, *dc2;
4636 407 : sql_subtype *it = sql_bind_localtype("int");
4637 :
4638 407 : if (pe) {
4639 186 : append(targs1, exp_subtype(pe));
4640 186 : append(targs2, exp_subtype(pe));
4641 186 : append(rargs1, exp_copy(sql, pe));
4642 186 : append(rargs2, exp_copy(sql, pe));
4643 : }
4644 407 : append(rargs1, exp_copy(sql, e));
4645 407 : append(rargs2, exp_copy(sql, e));
4646 407 : append(targs1, exp_subtype(e));
4647 407 : append(targs2, exp_subtype(e));
4648 407 : append(targs1, it);
4649 407 : append(targs2, it);
4650 407 : append(targs1, it);
4651 407 : append(targs2, it);
4652 407 : append(targs1, it);
4653 407 : append(targs2, it);
4654 407 : append(targs1, exp_subtype(start));
4655 407 : append(targs2, exp_subtype(fend));
4656 :
4657 407 : dc1 = sql_bind_func_(sql, "sys", "window_bound", targs1, F_ANALYTIC, true, false);
4658 407 : dc2 = sql_bind_func_(sql, "sys", "window_bound", targs2, F_ANALYTIC, true, false);
4659 407 : if (!dc1 || !dc2)
4660 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: function 'window_bound' not found");
4661 407 : append(rargs1, exp_atom_int(sql->sa, frame_type));
4662 407 : append(rargs2, exp_atom_int(sql->sa, frame_type));
4663 407 : append(rargs1, exp_atom_int(sql->sa, generate_window_bound(t1, true)));
4664 407 : append(rargs2, exp_atom_int(sql->sa, generate_window_bound(t2, false)));
4665 407 : append(rargs1, exp_atom_int(sql->sa, excl));
4666 407 : append(rargs2, exp_atom_int(sql->sa, excl));
4667 407 : append(rargs1, start);
4668 407 : append(rargs2, fend);
4669 :
4670 407 : *estart = exp_op(sql->sa, rargs1, dc1);
4671 407 : *eend = exp_op(sql->sa, rargs2, dc2);
4672 407 : return e; /* return something to say there were no errors */
4673 : }
4674 :
4675 : #define EC_NUMERIC(e) (e==EC_NUM||EC_INTERVAL(e)||e==EC_DEC||e==EC_FLT)
4676 :
4677 : static sql_exp*
4678 601 : calculate_window_bound(sql_query *query, sql_rel *p, tokens token, symbol *bound, sql_exp *ie, int frame_type, int f)
4679 : {
4680 601 : mvc *sql = query->sql;
4681 601 : sql_subtype *bt, *bound_tp = sql_bind_localtype("lng"), *iet = exp_subtype(ie);
4682 601 : sql_exp *res = NULL;
4683 :
4684 792 : if ((bound->token == SQL_PRECEDING || bound->token == SQL_FOLLOWING || bound->token == SQL_CURRENT_ROW) && bound->type == type_int) {
4685 191 : atom *a = NULL;
4686 191 : bt = (frame_type == FRAME_ROWS || frame_type == FRAME_GROUPS) ? bound_tp : iet;
4687 :
4688 191 : if ((bound->data.i_val == UNBOUNDED_PRECEDING_BOUND || bound->data.i_val == UNBOUNDED_FOLLOWING_BOUND)) {
4689 69 : a = atom_max_value(sql->sa, EC_NUMERIC(bt->type->eclass) ? bt : bound_tp);
4690 122 : } else if (bound->data.i_val == CURRENT_ROW_BOUND) {
4691 124 : a = atom_zero_value(sql->sa, EC_NUMERIC(bt->type->eclass) ? bt : bound_tp);
4692 : } else {
4693 0 : assert(0);
4694 : }
4695 191 : res = exp_atom(sql->sa, a);
4696 : } else { /* arbitrary expression case */
4697 410 : exp_kind ek = {type_value, card_column, FALSE};
4698 410 : const char *bound_desc = (token == SQL_PRECEDING) ? "PRECEDING" : "FOLLOWING";
4699 :
4700 410 : assert(token == SQL_PRECEDING || token == SQL_FOLLOWING);
4701 410 : if (!(res = rel_value_exp2(query, &p, bound, f, ek)))
4702 3 : return NULL;
4703 410 : if (!(bt = exp_subtype(res))) { /* frame bound is a parameter */
4704 3 : sql_subtype *t = (frame_type == FRAME_ROWS || frame_type == FRAME_GROUPS) ? bound_tp : iet;
4705 3 : if (rel_set_type_param(sql, t, p, res, 0) < 0) /* workaround */
4706 : return NULL;
4707 3 : bt = exp_subtype(res);
4708 : }
4709 410 : if (exp_is_null_no_value_opt(res))
4710 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s offset must not be NULL", bound_desc);
4711 409 : if ((frame_type == FRAME_ROWS || frame_type == FRAME_GROUPS) && bt->type->eclass != EC_NUM && !(res = exp_check_type(sql, bound_tp, p, res, type_equal)))
4712 : return NULL;
4713 409 : if (frame_type == FRAME_RANGE) {
4714 70 : sql_class iet_class = iet->type->eclass;
4715 :
4716 70 : if (!EC_NUMERIC(iet_class) && !EC_TEMP(iet_class))
4717 1 : return sql_error(sql, 02, SQLSTATE(42000) "Ranges with arbitrary expressions are available to numeric, interval and temporal types only");
4718 12 : if (EC_NUMERIC(iet_class) && !(res = exp_check_type(sql, iet, p, res, type_equal)))
4719 : return NULL;
4720 69 : if ((iet_class == EC_TIME || iet_class == EC_TIME_TZ) && bt->type->eclass != EC_SEC) {
4721 1 : (void) sql_error(sql, 02, SQLSTATE(42000) "For %s input the %s boundary must be an interval type up to the day", subtype2string2(sql->ta, iet), bound_desc);
4722 1 : sa_reset(sql->ta);
4723 1 : return NULL;
4724 : }
4725 68 : if (EC_TEMP(iet->type->eclass) && !EC_INTERVAL(bt->type->eclass)) {
4726 0 : (void) sql_error(sql, 02, SQLSTATE(42000) "For %s input the %s boundary must be an interval type", subtype2string2(sql->ta, iet), bound_desc);
4727 0 : sa_reset(sql->ta);
4728 0 : return NULL;
4729 : }
4730 : }
4731 : }
4732 : return res;
4733 : }
4734 :
4735 : static dlist*
4736 16 : get_window_clauses(mvc *sql, char* ident, symbol **partition_by_clause, symbol **order_by_clause, symbol **frame_clause)
4737 : {
4738 16 : dlist *window_specification = NULL;
4739 16 : char *window_ident;
4740 16 : int pos;
4741 :
4742 16 : if (mvc_highwater(sql))
4743 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
4744 :
4745 16 : if ((window_specification = frame_get_window_def(sql, ident, &pos)) == NULL)
4746 1 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: window '%s' not found", ident);
4747 :
4748 : /* avoid infinite lookups */
4749 15 : if (frame_check_var_visited(sql, pos))
4750 1 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: cyclic references to window '%s' found", ident);
4751 14 : frame_set_var_visited(sql, pos);
4752 :
4753 14 : if (window_specification->h->next->data.sym) {
4754 2 : if (*partition_by_clause)
4755 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: redefinition of PARTITION BY clause from window '%s'", ident);
4756 2 : *partition_by_clause = window_specification->h->next->data.sym;
4757 : }
4758 14 : if (window_specification->h->next->next->data.sym) {
4759 4 : if (*order_by_clause)
4760 1 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: redefinition of ORDER BY clause from window '%s'", ident);
4761 3 : *order_by_clause = window_specification->h->next->next->data.sym;
4762 : }
4763 13 : if (window_specification->h->next->next->next->data.sym) {
4764 0 : if (*frame_clause)
4765 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: redefinition of frame clause from window '%s'", ident);
4766 0 : *frame_clause = window_specification->h->next->next->next->data.sym;
4767 : }
4768 :
4769 13 : window_ident = window_specification->h->data.sval;
4770 13 : if (window_ident && !get_window_clauses(sql, window_ident, partition_by_clause, order_by_clause, frame_clause))
4771 : return NULL; /* the error was already set */
4772 :
4773 : return window_specification; /* return something to say there were no errors */
4774 : }
4775 :
4776 : /*
4777 : * select x, y, rank_op() over (partition by x order by y) as, ...
4778 : aggr_op(z) over (partition by y order by x) as, ...
4779 : * from table [x,y,z,w,v]
4780 : *
4781 : * project and order by over x,y / y,x
4782 : * a = project( table ) [ x, y, z, w, v ], [ x, y]
4783 : * b = project( table ) [ x, y, z, w, v ], [ y, x]
4784 : *
4785 : * project with order dependent operators, ie combined prev/current value
4786 : * aa = project (a) [ x, y, r = rank_op(diff(x) (marks a new partition), rediff(diff(x), y) (marks diff value with in partition)), z, w, v ]
4787 : * project(aa) [ aa.x, aa.y, aa.r ] -- only keep current output list
4788 : * bb = project (b) [ x, y, a = aggr_op(z, diff(y), rediff(diff(y), x)), z, w, v ]
4789 : * project(bb) [ bb.x, bb.y, bb.a ] -- only keep current output list
4790 : */
4791 : static sql_exp *
4792 12839 : rel_rankop(sql_query *query, sql_rel **rel, symbol *se, int f)
4793 : {
4794 12839 : mvc *sql = query->sql;
4795 12839 : node *n;
4796 12839 : dlist *l = se->data.lval, *window_specification = NULL;
4797 12839 : symbol *window_function = l->h->data.sym, *partition_by_clause = NULL, *order_by_clause = NULL, *frame_clause = NULL;
4798 12839 : char *aname = NULL, *sname = NULL, *window_ident = NULL;
4799 12839 : sql_subfunc *wf = NULL;
4800 12839 : sql_exp *in = NULL, *pe = NULL, *oe = NULL, *call = NULL, *start = NULL, *eend = NULL, *fstart = NULL, *fend = NULL, *ie = NULL;
4801 12839 : sql_rel *p;
4802 12839 : list *gbe = NULL, *obe = NULL, *args = NULL, *types = NULL, *fargs = NULL;
4803 12839 : dnode *dn = window_function->data.lval->h, *dargs = NULL;
4804 12839 : int distinct = 0, frame_type, pos, nf = f, nfargs = 0;
4805 12839 : bool is_nth_value, supports_frames = false, found = false;
4806 :
4807 12839 : frame_clear_visited_flag(sql); /* clear visited flags before iterating */
4808 :
4809 12839 : if (l->h->next->type == type_list) {
4810 12823 : window_specification = l->h->next->data.lval;
4811 16 : } else if (l->h->next->type == type_string) {
4812 16 : const char* window_alias = l->h->next->data.sval;
4813 16 : if ((window_specification = frame_get_window_def(sql, window_alias, &pos)) == NULL)
4814 1 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: window '%s' not found", window_alias);
4815 15 : frame_set_var_visited(sql, pos);
4816 : } else {
4817 0 : assert(0);
4818 : }
4819 :
4820 12838 : window_ident = window_specification->h->data.sval;
4821 12838 : partition_by_clause = window_specification->h->next->data.sym;
4822 12838 : order_by_clause = window_specification->h->next->next->data.sym;
4823 12838 : frame_clause = window_specification->h->next->next->next->data.sym;
4824 :
4825 12838 : if (window_ident && !get_window_clauses(sql, window_ident, &partition_by_clause, &order_by_clause, &frame_clause))
4826 : return NULL;
4827 :
4828 12835 : frame_type = frame_clause ? frame_clause->data.lval->h->next->next->data.i_val : FRAME_RANGE;
4829 12835 : aname = qname_schema_object(dn->data.lval);
4830 12835 : sname = qname_schema(dn->data.lval);
4831 :
4832 12835 : is_nth_value = !strcmp(aname, "nth_value");
4833 12835 : bool is_value = is_nth_value || !strcmp(aname, "first_value") || !strcmp(aname, "last_value");
4834 12835 : bool rank = false;
4835 12835 : if (strcmp(aname, "row_number") == 0 || strcmp(aname, "rank") == 0 || strcmp(aname, "dense_rank") == 0 ||
4836 2935 : strcmp(aname, "percent_rank") == 0 || strcmp(aname, "cume_dist") == 0 || strcmp(aname, "ntile") == 0 ||
4837 2831 : strcmp(aname, "lag") == 0 || strcmp(aname, "lead") == 0 || strcmp(aname, "fetch") == 0)
4838 10076 : rank = true;
4839 12835 : supports_frames = (!rank || is_value);
4840 :
4841 12835 : if (is_sql_update_set(f) || is_sql_psm(f) || is_sql_values(f) || is_sql_join(f) || is_sql_where(f) || is_sql_groupby(f) || is_sql_having(f) || is_psm_call(f) || is_sql_from(f)) {
4842 13 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
4843 13 : const char *clause = is_sql_update_set(f)||is_sql_psm(f)?"in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses (use subquery)":is_sql_values(f)?"on an unique value":
4844 8 : is_sql_join(f)?"in JOIN conditions":is_sql_where(f)?"in WHERE clause":is_sql_groupby(f)?"in GROUP BY clause":
4845 4 : is_psm_call(f)?"in CALL":is_sql_from(f)?"in functions in FROM":"in HAVING clause";
4846 13 : return sql_error(sql, 02, SQLSTATE(42000) "%s: window function '%s' not allowed %s", toUpperCopy(uaname, aname), aname, clause);
4847 12822 : } else if (is_sql_aggr(f)) {
4848 2 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
4849 2 : return sql_error(sql, 02, SQLSTATE(42000) "%s: window functions not allowed inside aggregation functions", toUpperCopy(uaname, aname));
4850 12820 : } else if (is_sql_window(f)) {
4851 6 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
4852 6 : return sql_error(sql, 02, SQLSTATE(42000) "%s: window functions cannot be nested", toUpperCopy(uaname, aname));
4853 : }
4854 12814 : if (window_function->token == SQL_AGGR) {
4855 106 : dn->next->next->type = type_list;
4856 106 : dn->next->next->data.lval = dlist_append_symbol(sql->sa, dlist_create( sql->sa ), dn->next->next->data.sym); /* make a list */
4857 : }
4858 12814 : if (window_function->token == SQL_NOP)
4859 12708 : window_function->token = SQL_AGGR;
4860 12814 : if (window_function->token != SQL_RANK && window_function->token != SQL_AGGR) {
4861 0 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
4862 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: window function '%s' unknown", toUpperCopy(uaname, aname));
4863 : }
4864 :
4865 : /* window operations are only allowed in the projection */
4866 12814 : if (!is_sql_sel(f) && !is_sql_qualify(f))
4867 0 : return sql_error(sql, 02, SQLSTATE(42000) "OVER: only possible within the selection");
4868 :
4869 12814 : p = *rel;
4870 : /* Partition By */
4871 12814 : if (partition_by_clause) {
4872 2339 : gbe = rel_partition_groupings(query, &p, partition_by_clause, NULL /* cannot use (selection) column references, as this result is a selection column */, nf | sql_window);
4873 2339 : if (!gbe)
4874 : return NULL;
4875 4698 : for (n = gbe->h ; n ; n = n->next) {
4876 2367 : sql_exp *en = n->data;
4877 :
4878 2367 : set_ascending(en);
4879 2367 : set_nulls_first(en);
4880 : }
4881 : }
4882 :
4883 : /* Order By */
4884 12806 : if (order_by_clause) {
4885 3053 : obe = rel_order_by(query, &p, order_by_clause, 0, sql_window);
4886 3053 : if (!obe)
4887 : return NULL;
4888 : }
4889 :
4890 12799 : fargs = sa_list(sql->sa);
4891 12799 : if (rank) { /* rank function call */
4892 10062 : dlist *dl = dn->next->next->data.lval;
4893 10062 : bool is_lag = !strcmp(aname, "lag"), is_lead = !strcmp(aname, "lead"),
4894 10062 : extra_input = !strcmp(aname, "ntile") || !strcmp(aname, "rank") || !strcmp(aname, "dense_rank") || !strcmp(aname, "row_number") || !strcmp(aname, "percent_rank") || !strcmp(aname, "cume_dist");
4895 :
4896 10062 : distinct = dn->next->data.i_val;
4897 10062 : if (extra_input) { /* pass an input column for analytic functions that don't require it */
4898 9991 : sql_subfunc *star = sql_bind_func(sql, "sys", "star", NULL, NULL, F_FUNC, true, true);
4899 9991 : in = exp_op(sql->sa, NULL, star);
4900 9991 : append(fargs, in);
4901 : }
4902 10062 : if (dl)
4903 324 : for (dargs = dl->h ; dargs ; dargs = dargs->next) {
4904 182 : exp_kind ek = {type_value, card_column, FALSE};
4905 182 : sql_subtype *empty = sql_bind_localtype("void"), *bte = sql_bind_localtype("bte");
4906 :
4907 182 : in = rel_value_exp2(query, &p, dargs->data.sym, f | sql_window | sql_farg, ek);
4908 182 : if (!in)
4909 0 : return NULL;
4910 182 : if (!exp_subtype(in)) { /* we also do not expect parameters here */
4911 0 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
4912 0 : return sql_error(sql, 02, SQLSTATE(42000) "%s: parameters not allowed as arguments to window functions", toUpperCopy(uaname, aname));
4913 : }
4914 182 : if (!exp_name(in))
4915 99 : exp_label(sql->sa, in, ++sql->label);
4916 :
4917 : /* corner case, if the argument is null convert it into something countable such as bte */
4918 182 : if (subtype_cmp(exp_subtype(in), empty) == 0)
4919 13 : in = exp_convert(sql, in, empty, bte);
4920 182 : if ((is_lag || is_lead) && nfargs == 2) { /* lag and lead 3rd arg must have same type as 1st arg */
4921 10 : sql_exp *first = (sql_exp*) fargs->h->data;
4922 10 : if (!(in = exp_check_type(sql, exp_subtype(first), p, in, type_equal)))
4923 : return NULL;
4924 : }
4925 172 : if (!in)
4926 : return NULL;
4927 :
4928 182 : append(fargs, in);
4929 182 : in = exp_ref_save(sql, in);
4930 182 : nfargs++;
4931 : }
4932 : } else { /* aggregation function call */
4933 2737 : distinct = dn->next->data.i_val;
4934 2737 : assert(dn->next->next->type == type_list);
4935 2737 : dlist *dl = dn->next->next->data.lval;
4936 9215 : for (dargs = dl?dl->h:NULL; dargs && dargs->data.sym ; dargs = dargs->next) {
4937 3749 : exp_kind ek = {type_value, card_column, FALSE};
4938 3749 : sql_subtype *empty = sql_bind_localtype("void"), *bte = sql_bind_localtype("bte");
4939 :
4940 3749 : in = rel_value_exp2(query, &p, dargs->data.sym, f | sql_window | sql_farg, ek);
4941 3749 : if (!in)
4942 8 : return NULL;
4943 3742 : if (!exp_subtype(in)) { /* we also do not expect parameters here */
4944 1 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
4945 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: parameters not allowed as arguments to window functions", toUpperCopy(uaname, aname));
4946 : }
4947 3741 : if (!exp_name(in))
4948 2012 : exp_label(sql->sa, in, ++sql->label);
4949 :
4950 : /* corner case, if the argument is null convert it into something countable such as bte */
4951 3741 : if (subtype_cmp(exp_subtype(in), empty) == 0)
4952 53 : in = exp_convert(sql, in, empty, bte);
4953 3741 : if (!in)
4954 : return NULL;
4955 :
4956 3741 : append(fargs, in);
4957 3741 : in = exp_ref_save(sql, in);
4958 3741 : nfargs++;
4959 :
4960 3741 : if (!strcmp(aname, "count"))
4961 86 : append(fargs, exp_atom_bool(sql->sa, 1)); /* ignore nills */
4962 : }
4963 :
4964 2729 : if (!nfargs) { /* count(*) */
4965 110 : if (window_function->token == SQL_AGGR && strcmp(aname, "count") != 0) {
4966 3 : char *uaname = SA_NEW_ARRAY(sql->ta, char, strlen(aname) + 1);
4967 3 : return sql_error(sql, 02, SQLSTATE(42000) "%s: unable to perform '%s(*)'", toUpperCopy(uaname, aname), aname);
4968 : }
4969 107 : sql_subfunc *star = sql_bind_func(sql, "sys", "star", NULL, NULL, F_FUNC, true, true);
4970 107 : in = exp_op(sql->sa, NULL, star);
4971 107 : append(fargs, in);
4972 107 : append(fargs, exp_atom_bool(sql->sa, 0)); /* don't ignore nills */
4973 : }
4974 : }
4975 :
4976 12788 : if (distinct)
4977 4 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: DISTINCT clause is not implemented for window functions");
4978 :
4979 : /* diff for partitions */
4980 12784 : if (gbe) {
4981 2322 : sql_subtype *bt = sql_bind_localtype("bit");
4982 :
4983 4679 : for( n = gbe->h; n; n = n->next) {
4984 2358 : sql_subfunc *df;
4985 2358 : sql_exp *e = n->data;
4986 :
4987 2358 : if (!exp_subtype(e))
4988 1 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: parameters not allowed at PARTITION BY clause from window functions");
4989 :
4990 2357 : e = exp_copy(sql, e);
4991 2357 : args = sa_list(sql->sa);
4992 2357 : if (pe) {
4993 36 : df = sql_bind_func(sql, "sys", "diff", bt, exp_subtype(e), F_ANALYTIC, true, true);
4994 36 : append(args, pe);
4995 : } else {
4996 2321 : df = sql_bind_func(sql, "sys", "diff", exp_subtype(e), NULL, F_ANALYTIC, true, true);
4997 : }
4998 2357 : if (!df)
4999 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: function 'diff' not found");
5000 2357 : append(args, e);
5001 2357 : pe = exp_op(sql->sa, args, df);
5002 : }
5003 : } else {
5004 10462 : pe = exp_atom_bool(sql->sa, 0);
5005 : }
5006 :
5007 : /* diff for orderby */
5008 12783 : if (obe) {
5009 3044 : sql_subtype *bt = sql_bind_localtype("bit");
5010 :
5011 6244 : for( n = obe->h; n; n = n->next) {
5012 3200 : sql_subfunc *df;
5013 3200 : sql_exp *e = n->data;
5014 :
5015 3200 : if (!exp_subtype(e))
5016 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: parameters not allowed at ORDER BY clause from window functions");
5017 :
5018 3200 : e = exp_copy(sql, e);
5019 3200 : args = sa_list(sql->sa);
5020 3200 : if (oe) {
5021 156 : df = sql_bind_func(sql, "sys", "diff", bt, exp_subtype(e), F_ANALYTIC, true, true);
5022 156 : append(args, oe);
5023 : } else {
5024 3044 : df = sql_bind_func(sql, "sys", "diff", exp_subtype(e), NULL, F_ANALYTIC, true, true);
5025 : }
5026 3200 : if (!df)
5027 0 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: function 'diff' not found");
5028 3200 : append(args, e);
5029 3200 : oe = exp_op(sql->sa, args, df);
5030 : }
5031 : } else {
5032 9739 : oe = exp_atom_bool(sql->sa, 0);
5033 : }
5034 :
5035 12783 : if (frame_clause || supports_frames) {
5036 2726 : if (frame_type == FRAME_RANGE)
5037 2415 : ie = obe ? (sql_exp*) obe->t->data : in;
5038 : else
5039 311 : ie = obe ? oe : in;
5040 : }
5041 12783 : assert(oe && pe);
5042 :
5043 12783 : types = exp_types(sql->sa, fargs);
5044 12783 : wf = bind_func_(sql, sname, aname, types, F_ANALYTIC, false, &found, false);
5045 12783 : if (wf && !list_empty(fargs) && !(fargs = check_arguments_and_find_largest_any_type(sql, NULL, fargs, wf, 0, false)))
5046 : wf = NULL;
5047 12779 : if (!wf) {
5048 4 : char *arg_list = nfargs ? nary_function_arg_types_2str(sql, types, nfargs) : NULL;
5049 8 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: %s window function %s%s%s'%s'(%s)",
5050 4 : found ? "insufficient privileges for" : "no such", sname ? "'":"", sname ? sname : "", sname ? "'.":"", aname, arg_list ? arg_list : "");
5051 : }
5052 :
5053 : /* Frame */
5054 12779 : if (frame_clause) {
5055 410 : dnode *d = frame_clause->data.lval->h;
5056 410 : symbol *wstart = d->data.sym, *wend = d->next->data.sym, *rstart = wstart->data.lval->h->data.sym,
5057 410 : *rend = wend->data.lval->h->data.sym;
5058 410 : int excl = d->next->next->next->data.i_val;
5059 410 : bool shortcut = false;
5060 :
5061 410 : if (!supports_frames)
5062 4 : return sql_error(sql, 02, SQLSTATE(42000) "OVER: frame extend only possible with aggregation and first_value, last_value and nth_value functions");
5063 406 : if (excl != EXCLUDE_NONE)
5064 0 : return sql_error(sql, 02, SQLSTATE(42000) "Only EXCLUDE NO OTHERS exclusion is currently implemented");
5065 406 : if (list_empty(obe) && frame_type == FRAME_GROUPS)
5066 2 : return sql_error(sql, 02, SQLSTATE(42000) "GROUPS frame requires an order by expression");
5067 404 : if (wstart->token == SQL_FOLLOWING && wend->token == SQL_PRECEDING)
5068 1 : return sql_error(sql, 02, SQLSTATE(42000) "FOLLOWING offset must come after PRECEDING offset");
5069 403 : if (wstart->token == SQL_CURRENT_ROW && wend->token == SQL_PRECEDING)
5070 1 : return sql_error(sql, 02, SQLSTATE(42000) "CURRENT ROW offset must come after PRECEDING offset");
5071 402 : if (wstart->token == SQL_FOLLOWING && wend->token == SQL_CURRENT_ROW)
5072 1 : return sql_error(sql, 02, SQLSTATE(42000) "FOLLOWING offset must come after CURRENT ROW offset");
5073 401 : if (wstart->token != SQL_CURRENT_ROW && wend->token != SQL_CURRENT_ROW && wstart->token == wend->token && frame_type != FRAME_ROWS)
5074 4 : return sql_error(sql, 02, SQLSTATE(42000) "Non-centered windows are only supported in row frames");
5075 367 : if (frame_type == FRAME_RANGE) {
5076 97 : if (((wstart->token == SQL_PRECEDING || wstart->token == SQL_FOLLOWING) && rstart->token != SQL_PRECEDING && rstart->token != SQL_CURRENT_ROW && rstart->token != SQL_FOLLOWING) ||
5077 59 : ((wend->token == SQL_PRECEDING || wend->token == SQL_FOLLOWING) && rend->token != SQL_PRECEDING && rend->token != SQL_CURRENT_ROW && rend->token != SQL_FOLLOWING)) {
5078 40 : if (list_empty(obe))
5079 2 : return sql_error(sql, 02, SQLSTATE(42000) "RANGE frame with PRECEDING/FOLLOWING offset requires an order by expression");
5080 38 : if (list_length(obe) > 1)
5081 0 : return sql_error(sql, 02, SQLSTATE(42000) "RANGE with offset PRECEDING/FOLLOWING requires exactly one ORDER BY column");
5082 : }
5083 : }
5084 :
5085 395 : if (list_empty(obe) && frame_type == FRAME_RANGE) { /* window functions are weird */
5086 : frame_type = FRAME_ALL;
5087 : shortcut = true;
5088 383 : } else if (!is_value && (rstart->token == SQL_PRECEDING || rstart->token == SQL_CURRENT_ROW || rstart->token == SQL_FOLLOWING) && rstart->type == type_int &&
5089 150 : (rend->token == SQL_PRECEDING || rend->token == SQL_CURRENT_ROW || rend->token == SQL_FOLLOWING) && rend->type == type_int) {
5090 : /* special cases, don't calculate bounds */
5091 146 : if (frame_type != FRAME_ROWS && rstart->data.i_val == UNBOUNDED_PRECEDING_BOUND && rend->data.i_val == CURRENT_ROW_BOUND) {
5092 : frame_type = FRAME_UNBOUNDED_TILL_CURRENT_ROW;
5093 : shortcut = true;
5094 21 : } else if (frame_type != FRAME_ROWS && rstart->data.i_val == CURRENT_ROW_BOUND && rend->data.i_val == UNBOUNDED_FOLLOWING_BOUND) {
5095 : frame_type = FRAME_CURRENT_ROW_TILL_UNBOUNDED;
5096 : shortcut = true;
5097 86 : } else if (rstart->data.i_val == UNBOUNDED_PRECEDING_BOUND && rend->data.i_val == UNBOUNDED_FOLLOWING_BOUND) {
5098 : frame_type = FRAME_ALL;
5099 : shortcut = true;
5100 76 : } else if (rstart->data.i_val == CURRENT_ROW_BOUND && rend->data.i_val == CURRENT_ROW_BOUND) {
5101 395 : frame_type = FRAME_CURRENT_ROW;
5102 395 : shortcut = true;
5103 : }
5104 : }
5105 395 : if (!shortcut) {
5106 302 : if (!(fstart = calculate_window_bound(query, p, wstart->token, rstart, ie, frame_type, f | sql_window)))
5107 : return NULL;
5108 299 : if (!(fend = calculate_window_bound(query, p, wend->token, rend, ie, frame_type, f | sql_window)))
5109 : return NULL;
5110 471 : if (!generate_window_bound_call(sql, &start, &eend, gbe ? pe : NULL, ie, fstart, fend, frame_type, excl,
5111 : wstart->token, wend->token))
5112 : return NULL;
5113 : }
5114 12369 : } else if (supports_frames) { /* for analytic functions with no frame clause, we use the standard default values */
5115 2314 : if (is_value) {
5116 108 : sql_subtype *bound_tp = sql_bind_localtype("lng"), *bt = (frame_type == FRAME_ROWS || frame_type == FRAME_GROUPS) ? bound_tp : exp_subtype(ie);
5117 108 : unsigned char sclass = bt->type->eclass;
5118 :
5119 136 : fstart = exp_atom(sql->sa, atom_max_value(sql->sa, EC_NUMERIC(sclass) ? bt : bound_tp));
5120 108 : fend = order_by_clause ? exp_atom(sql->sa, atom_zero_value(sql->sa, EC_NUMERIC(sclass) ? bt : bound_tp)) :
5121 23 : exp_atom(sql->sa, atom_max_value(sql->sa, EC_NUMERIC(sclass) ? bt : bound_tp));
5122 :
5123 157 : if (generate_window_bound_call(sql, &start, &eend, gbe ? pe : NULL, ie, fstart, fend, frame_type, EXCLUDE_NONE, SQL_PRECEDING, SQL_FOLLOWING) == NULL)
5124 : return NULL;
5125 : } else {
5126 2206 : frame_type = list_empty(obe) ? FRAME_ALL : FRAME_UNBOUNDED_TILL_CURRENT_ROW;
5127 : }
5128 : }
5129 :
5130 12761 : args = sa_list(sql->sa);
5131 26925 : for (node *n = fargs->h ; n ; n = n->next)
5132 14164 : list_append(args, n->data);
5133 12761 : list_append(args, pe);
5134 12761 : list_append(args, oe);
5135 12761 : if (supports_frames) {
5136 2706 : list_append(args, exp_atom_int(sql->sa, frame_type));
5137 2706 : list_append(args, start ? start : exp_atom_oid(sql->sa, 1));
5138 2706 : list_append(args, eend ? eend : exp_atom_oid(sql->sa, 1));
5139 : }
5140 12761 : call = exp_rank_op(sql->sa, list_empty(args) ? NULL : args, gbe, obe, wf);
5141 12761 : *rel = p;
5142 12761 : return call;
5143 : }
5144 :
5145 : sql_exp *
5146 6088359 : rel_value_exp2(sql_query *query, sql_rel **rel, symbol *se, int f, exp_kind ek)
5147 : {
5148 6088359 : mvc *sql = query->sql;
5149 6088359 : if (!se)
5150 : return NULL;
5151 :
5152 6088359 : if (mvc_highwater(sql))
5153 9 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
5154 :
5155 6088349 : if (rel && *rel && (*rel)->card == CARD_AGGR) { /* group by expression case, handle it before */
5156 137885 : sql_exp *exp = NULL;
5157 137885 : if (!is_sql_aggr(f) && !is_sql_window(f))
5158 137419 : exp = frame_get_groupby_expression(sql, se);
5159 137885 : if (sql->errstr[0] != '\0')
5160 : return NULL;
5161 137885 : if (exp) {
5162 80 : sql_exp *res = exp_ref(sql, exp);
5163 80 : res->card = (*rel)->card;
5164 80 : if (se->token == SQL_AGGR) {
5165 0 : dlist *l = se->data.lval;
5166 0 : int distinct = l->h->next->data.i_val;
5167 0 : if (distinct)
5168 0 : set_distinct(res);
5169 : }
5170 80 : if (!query_has_outer(query) && is_groupby((*rel)->op))
5171 76 : res = rel_groupby_add_aggr(sql, *rel, res);
5172 80 : return res;
5173 : }
5174 : }
5175 :
5176 6088269 : switch (se->token) {
5177 593209 : case SQL_NOP:
5178 593209 : return rel_nop(query, rel, se, f, ek);
5179 19607 : case SQL_AGGR:
5180 19607 : return rel_aggr(query, rel, se, f);
5181 12839 : case SQL_WINDOW:
5182 12839 : return rel_rankop(query, rel, se, f);
5183 2392878 : case SQL_IDENT:
5184 : case SQL_COLUMN:
5185 2392878 : return rel_column_ref(query, rel, se, f );
5186 3055 : case SQL_NAME: {
5187 3055 : dlist *l = se->data.lval;
5188 3055 : const char *sname = qname_schema(l);
5189 3055 : const char *vname = qname_schema_object(l);
5190 3055 : return rel_exp_variable_on_scope(sql, sname, vname);
5191 : }
5192 51239 : case SQL_VALUES:
5193 : case SQL_WITH:
5194 : case SQL_SELECT: {
5195 51239 : sql_rel *r = NULL;
5196 :
5197 51239 : if (is_psm_call(f) || is_sql_merge(f))
5198 8 : return sql_error(sql, 02, SQLSTATE(42000) "%s: subqueries not supported inside %s", is_psm_call(f) ? "CALL" : "MERGE", is_psm_call(f) ? "CALL statements" : "MERGE conditions");
5199 51235 : if (rel && *rel)
5200 36948 : query_push_outer(query, *rel, f);
5201 51235 : if (se->token == SQL_WITH) {
5202 36 : r = rel_with_query(query, se);
5203 51199 : } else if (se->token == SQL_VALUES) {
5204 240 : r = rel_values(query, se, NULL);
5205 : } else {
5206 50959 : assert(se->token == SQL_SELECT);
5207 50959 : exp_kind nek = ek;
5208 50959 : nek.aggr = is_sql_aggr(f);
5209 50959 : if (is_sql_no_subquery(f))
5210 3 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery not allowed");
5211 :
5212 50956 : r = rel_subquery(query, se, nek);
5213 50956 : if (r)
5214 50855 : exps_label(sql, r->exps);
5215 : }
5216 51232 : if (rel && *rel) {
5217 36945 : *rel = query_pop_outer(query);
5218 36945 : if (is_sql_join(f) && is_groupby((*rel)->op)) {
5219 0 : return sql_error(sql, 05, SQLSTATE(42000) "SELECT: aggregate functions not allowed in JOIN conditions");
5220 36945 : } else if (is_sql_where(f) && is_groupby((*rel)->op)) {
5221 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in WHERE clause");
5222 36945 : } else if ((is_sql_update_set(f) || is_sql_psm(f)) && is_groupby((*rel)->op)) {
5223 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions not allowed in SET, WHILE, IF, ELSE, CASE, WHEN, RETURN, ANALYZE clauses");
5224 : }
5225 : }
5226 51232 : if (!r)
5227 : return NULL;
5228 51128 : if (ek.type == type_value && ek.card <= card_set && is_project(r->op) && list_length(r->exps) > 1)
5229 17 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery must return only one column");
5230 51111 : if (ek.type == type_relation && is_project(r->op) && list_length(r->exps) != ek.type)
5231 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery has too %s columns", list_length(r->exps) < ek.type ? "few" : "many");
5232 51111 : if (ek.type == type_value && list_length(r->exps) == 1 && !is_sql_psm(f)) /* for now don't rename multi attribute results */
5233 38701 : r = rel_zero_or_one(sql, r, ek);
5234 51111 : return exp_rel(sql, r);
5235 : }
5236 215 : case SQL_TABLE: {
5237 : /* turn a subquery into a tabular result */
5238 215 : *rel = rel_selects(query, se->data.sym);
5239 215 : if (*rel)
5240 213 : return lastexp(*rel);
5241 : return NULL;
5242 : }
5243 1611 : case SQL_PARAMETER: {
5244 1611 : assert(se->type == type_int);
5245 1611 : sql_arg *a = sql_bind_paramnr(sql, se->data.i_val);
5246 1611 : if (sql->emode != m_prepare) {
5247 1 : if (a && a->name && a->name[0])
5248 1 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: named placeholder ('%s') but named values list is missing", a->name);
5249 : else
5250 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: parameters ('?') not allowed in normal queries, use PREPARE");
5251 : }
5252 1610 : return exp_atom_ref(sql->sa, se->data.i_val, a?&a->type:NULL);
5253 : }
5254 109527 : case SQL_NULL:
5255 109527 : return exp_null(sql->sa, sql_bind_localtype("void"));
5256 1590 : case SQL_NEXT:
5257 1590 : return rel_next_value_for(sql, se);
5258 176254 : case SQL_CAST:
5259 176254 : return rel_cast(query, rel, se, f);
5260 106443 : case SQL_CASE:
5261 : case SQL_COALESCE:
5262 : case SQL_NULLIF:
5263 106443 : return rel_case_exp(query, rel, se, f);
5264 0 : case SQL_RANK:
5265 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: window function %s requires an OVER clause", qname_schema_object(se->data.lval->h->data.lval));
5266 25 : case SQL_XMLELEMENT:
5267 : case SQL_XMLFOREST:
5268 : case SQL_XMLCOMMENT:
5269 : case SQL_XMLATTRIBUTE:
5270 : case SQL_XMLCONCAT:
5271 : case SQL_XMLDOCUMENT:
5272 : case SQL_XMLPI:
5273 : case SQL_XMLTEXT:
5274 25 : return rel_xml(query, rel, se, f, ek);
5275 2619777 : default:
5276 2619777 : return rel_logical_value_exp(query, rel, se, f, ek);
5277 : }
5278 : }
5279 :
5280 : static int exps_has_rank(list *exps);
5281 :
5282 : static int
5283 : exp_has_rank(sql_exp *e)
5284 : {
5285 : switch(e->type) {
5286 : case e_convert:
5287 : return exp_has_rank(e->l);
5288 : case e_func:
5289 : if (e->r)
5290 : return 1;
5291 : /* fall through */
5292 : case e_aggr:
5293 : return exps_has_rank(e->l);
5294 : case e_cmp:
5295 : if (e->flag == cmp_or || e->flag == cmp_filter)
5296 : return exps_has_rank(e->l) || exps_has_rank(e->r);
5297 : if (e->flag == cmp_in || e->flag == cmp_notin)
5298 : return exp_has_rank(e->l) || exps_has_rank(e->r);
5299 : return exp_has_rank(e->l) || exp_has_rank(e->r) || (e->f && exp_has_rank(e->f));
5300 : default:
5301 : return 0;
5302 : }
5303 : }
5304 :
5305 : /* TODO create exps_has (list, fptr ) */
5306 : static int
5307 : exps_has_rank(list *exps)
5308 : {
5309 : if (!exps || list_empty(exps))
5310 : return 0;
5311 : for(node *n = exps->h; n; n=n->next){
5312 : sql_exp *e = n->data;
5313 :
5314 : if (exp_has_rank(e))
5315 : return 1;
5316 : }
5317 : return 0;
5318 : }
5319 :
5320 : sql_exp *
5321 4657718 : rel_value_exp(sql_query *query, sql_rel **rel, symbol *se, int f, exp_kind ek)
5322 : {
5323 4657718 : if (!se)
5324 : return NULL;
5325 :
5326 4657718 : if (mvc_highwater(query->sql))
5327 1 : return sql_error(query->sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
5328 :
5329 4657717 : sql_exp *e = rel_value_exp2(query, rel, se, f, ek);
5330 4657710 : if (e && (se->token == SQL_SELECT || se->token == SQL_TABLE) && !exp_is_rel(e)) {
5331 0 : assert(*rel);
5332 0 : return rel_lastexp(query->sql, *rel);
5333 : }
5334 : return e;
5335 : }
5336 :
5337 : static sql_exp *
5338 1352976 : column_exp(sql_query *query, sql_rel **rel, symbol *column_e, int f)
5339 : {
5340 1352976 : dlist *l = column_e->data.lval;
5341 1352976 : exp_kind ek = {type_value, card_column, FALSE};
5342 1352976 : sql_exp *ve;
5343 :
5344 1352976 : if (f == sql_sel && rel && *rel && (*rel)->card < CARD_AGGR)
5345 83228 : ek.card = card_value;
5346 1352976 : ve = rel_value_exp(query, rel, l->h->data.sym, f, ek);
5347 1352974 : if (!ve)
5348 : return NULL;
5349 : /* AS name */
5350 1337122 : if (ve && l->h->next->data.sval)
5351 513609 : exp_setname(query->sql, ve, NULL, l->h->next->data.sval);
5352 : return ve;
5353 : }
5354 :
5355 : static int
5356 852851 : exp_is_not_intern(sql_exp *e)
5357 : {
5358 852851 : return is_intern(e)?-1:0;
5359 : }
5360 :
5361 : static void
5362 130650 : rel_remove_internal_exp(sql_rel *rel)
5363 : {
5364 130650 : if (rel->exps) {
5365 130650 : list *n_exps = list_select(rel->exps, rel, (fcmp)&exp_is_not_intern, (fdup)NULL);
5366 :
5367 130650 : rel->exps = n_exps;
5368 : }
5369 130650 : }
5370 :
5371 : static inline int
5372 39 : exp_key(sql_exp *e)
5373 : {
5374 39 : if (e->alias.name)
5375 39 : return hash_key(e->alias.name);
5376 : return 0;
5377 : }
5378 :
5379 : static list *
5380 17 : group_merge_exps(mvc *sql, list *gexps, list *exps)
5381 : {
5382 17 : int nexps = list_length(gexps) + list_length(exps);
5383 :
5384 17 : sql_hash *ht = hash_new(sql->ta, nexps, (fkeyvalue)&exp_key);
5385 :
5386 27 : for (node *n = gexps->h; n ; n = n->next) { /* first add grouping expressions */
5387 10 : sql_exp *e = n->data;
5388 10 : int key = ht->key(e);
5389 :
5390 10 : hash_add(ht, key, e);
5391 : }
5392 :
5393 46 : for (node *n = exps->h; n ; n = n->next) { /* then test if the new grouping expressions are already there */
5394 29 : sql_exp *e = n->data;
5395 29 : int key = ht->key(e);
5396 29 : sql_hash_e *he = ht->buckets[key&(ht->size-1)];
5397 29 : bool duplicates = false;
5398 :
5399 37 : for (; he && !duplicates; he = he->chain) {
5400 8 : sql_exp *f = he->value;
5401 :
5402 8 : if (!exp_equal(e, f))
5403 4 : duplicates = true;
5404 : }
5405 29 : hash_add(ht, key, e);
5406 29 : if (!duplicates) {
5407 25 : list_append(gexps, e);
5408 25 : n->data = exp_ref(sql, e);
5409 : }
5410 : }
5411 17 : return gexps;
5412 : }
5413 :
5414 : static list *
5415 59246 : rel_table_exp(sql_query *query, sql_rel **rel, symbol *column_e, bool single_exp )
5416 : {
5417 59246 : mvc *sql = query->sql;
5418 59246 : if (column_e->token == SQL_TABLE && column_e->data.lval->h->type == type_symbol) {
5419 0 : sql_rel *r;
5420 :
5421 0 : if (!is_project((*rel)->op))
5422 : return NULL;
5423 0 : r = rel_named_table_function(query, (*rel)->l, column_e, 0, NULL);
5424 0 : if (!r)
5425 : return NULL;
5426 0 : *rel = r;
5427 0 : return sa_list(sql->sa);
5428 : }
5429 59246 : char *tname = NULL;
5430 59246 : if (column_e->token == SQL_TABLE) {
5431 43405 : tname = column_e->data.lval->h->data.sval;
5432 15841 : } else if (column_e->token == SQL_COLUMN && column_e->data.lval->h->type == type_symbol) {
5433 15841 : symbol *sym = column_e->data.lval->h->data.sym;
5434 15841 : if (sym->token == SQL_COLUMN)
5435 14847 : tname = sym->data.lval->h->data.sval;
5436 : else
5437 : return NULL;
5438 : } else {
5439 : return NULL;
5440 : }
5441 :
5442 58252 : list *exps = NULL;
5443 58252 : sql_rel *project = *rel, *groupby = NULL;
5444 :
5445 : /* if there's a group by relation in the tree, skip it for the '*' case and use the underlying projection */
5446 58252 : if (project) {
5447 67698 : while (is_groupby(project->op) || is_select(project->op)) {
5448 9446 : if (is_groupby(project->op))
5449 37 : groupby = project;
5450 9446 : if (project->l)
5451 9446 : project = project->l;
5452 : }
5453 : assert(project);
5454 : }
5455 :
5456 58252 : if (project->op == op_project && project->l && project == *rel && !tname && !rel_is_ref(project) && !need_distinct(project) && single_exp) {
5457 549 : sql_rel *l = project->l;
5458 549 : if (!l || !is_project(l->op) || list_length(project->exps) == list_length(l->exps)) {
5459 542 : rel_remove_internal_exp(*rel);
5460 542 : exps = project->exps;
5461 542 : *rel = project->l;
5462 : }
5463 : }
5464 58252 : if ((exps || (exps = rel_table_projections(sql, project, tname, 0)) != NULL) && !list_empty(exps)) {
5465 58149 : if (!(exps = check_distinct_exp_names(sql, exps)))
5466 0 : return sql_error(sql, 02, SQLSTATE(42000) "Duplicate column names in table%s%s%s projection list", tname ? " '" : "", tname ? tname : "", tname ? "'" : "");
5467 58149 : if (groupby) {
5468 17 : groupby->exps = group_merge_exps(sql, groupby->exps, exps);
5469 40 : for (node *n = groupby->exps->h ; n ; n = n->next) {
5470 30 : sql_exp *e = n->data;
5471 :
5472 30 : if (e->card > groupby->card) {
5473 7 : if (exp_name(e) && !has_label(e))
5474 7 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(e));
5475 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
5476 : }
5477 : }
5478 : }
5479 58142 : return exps;
5480 : }
5481 103 : if (!tname)
5482 2 : return sql_error(sql, 02, SQLSTATE(42000) "Table expression without table name");
5483 101 : return sql_error(sql, 02, SQLSTATE(42000) "Column expression Table '%s' unknown", tname);
5484 : }
5485 :
5486 : sql_exp *
5487 1396381 : rel_column_exp(sql_query *query, sql_rel **rel, symbol *column_e, int f)
5488 : {
5489 1396381 : if (column_e->token == SQL_COLUMN || column_e->token == SQL_IDENT)
5490 1352976 : return column_exp(query, rel, column_e, f);
5491 : return NULL;
5492 : }
5493 :
5494 : static sql_rel*
5495 377727 : rel_where_groupby_nodes(sql_query *query, sql_rel *rel, SelectNode *sn, int *group_totals)
5496 : {
5497 377727 : mvc *sql = query->sql;
5498 :
5499 377727 : if (sn->where) {
5500 147801 : rel = rel_logical_exp(query, rel, sn->where, sql_where);
5501 147801 : if (!rel) {
5502 76 : if (sql->errstr[0] == 0)
5503 0 : return sql_error(sql, 02, SQLSTATE(42000) "Subquery result missing");
5504 : return NULL;
5505 : }
5506 : }
5507 377651 : query_processed(query);
5508 :
5509 377651 : if (rel && sn->groupby) {
5510 13553 : list *gbe = NULL, *sets = NULL;
5511 13553 : int all = 0;
5512 13553 : if (sn->groupby->data.lval == NULL) { /* ALL */
5513 : all = 1;
5514 : } else {
5515 50069 : for (dnode *o = sn->groupby->data.lval->h; o ; o = o->next) {
5516 36643 : symbol *grouping = o->data.sym;
5517 36643 : if (grouping->token == SQL_ROLLUP || grouping->token == SQL_CUBE || grouping->token == SQL_GROUPING_SETS) {
5518 119 : *group_totals |= sql_group_totals;
5519 119 : break;
5520 : }
5521 : }
5522 13545 : gbe = rel_groupings(query, &rel, sn->groupby, sn->selection, sql_sel | sql_groupby | *group_totals, false, &sets);
5523 13545 : if (!gbe)
5524 20 : return NULL;
5525 : }
5526 13533 : rel = rel_groupby(sql, rel, gbe);
5527 13533 : if (rel && all)
5528 8 : rel->flag = 2;
5529 13533 : if (sets && list_length(sets) > 1) { /* if there is only one combination, there is no reason to generate unions */
5530 114 : prop *p = prop_create(sql->sa, PROP_GROUPINGS, rel->p);
5531 114 : p->value.pval = sets;
5532 114 : rel->p = p;
5533 : }
5534 : }
5535 :
5536 377631 : if (rel && sn->having) {
5537 : /* having implies group by, ie if not supplied do a group by */
5538 1766 : if (rel->op != op_groupby)
5539 128 : rel = rel_groupby(sql, rel, NULL);
5540 : }
5541 377631 : query_processed(query);
5542 377631 : return rel;
5543 : }
5544 :
5545 : static sql_rel*
5546 376519 : rel_having_limits_nodes(sql_query *query, sql_rel *rel, SelectNode *sn, exp_kind ek, int group_totals)
5547 : {
5548 376519 : mvc *sql = query->sql;
5549 376519 : sql_rel *inner = NULL;
5550 376519 : int single_value = 1;
5551 :
5552 376519 : if (is_project(rel->op) && rel->l) {
5553 376519 : inner = rel->l;
5554 376519 : single_value = 0;
5555 : }
5556 :
5557 376519 : if (sn->having) {
5558 1759 : if (inner && is_groupby(inner->op))
5559 1759 : set_processed(inner);
5560 1759 : if (!(inner = rel_logical_exp(query, inner, sn->having, sql_having | group_totals)))
5561 : return NULL;
5562 1718 : if (inner->exps && exps_card(inner->exps) > CARD_AGGR)
5563 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: cannot compare sets with values, probably an aggregate function missing");
5564 1718 : if (!single_value)
5565 1718 : rel->l = inner;
5566 : }
5567 :
5568 376478 : if (sn->qualify) {
5569 0 : if (!(rel = rel_logical_exp(query, rel, sn->qualify, sql_qualify)))
5570 : return NULL;
5571 : }
5572 :
5573 376478 : if (rel && sn->distinct)
5574 1039 : rel = rel_distinct(rel);
5575 :
5576 376478 : if (rel && sn->orderby) {
5577 37435 : list *obe = NULL;
5578 37435 : sql_rel *sel = NULL, *l = rel->l;
5579 :
5580 : /* project( select ) */
5581 37435 : if (sn->having && is_select(l->op)) {
5582 52 : sel = l;
5583 52 : rel->l = l->l;
5584 : }
5585 37435 : rel = rel_orderby(sql, rel);
5586 37435 : set_processed(rel);
5587 37435 : obe = rel_order_by(query, &rel, sn->orderby, sn->distinct, sql_orderby | group_totals);
5588 37435 : if (!obe)
5589 : return NULL;
5590 37394 : rel->r = obe;
5591 37394 : if (sel) {
5592 51 : sql_rel *o = rel, *p = o->l;
5593 51 : p->l = sel;
5594 : }
5595 : }
5596 376437 : if (!rel)
5597 : return NULL;
5598 :
5599 376437 : if (sn->limit || sn->offset) {
5600 16628 : sql_subtype *lng = sql_bind_localtype("lng");
5601 16628 : list *exps = new_exp_list(sql->sa);
5602 :
5603 16628 : if (sn->limit) {
5604 16602 : sql_exp *l = rel_value_exp(query, NULL, sn->limit, 0, ek);
5605 :
5606 16602 : if (!l || !(l=exp_check_type(sql, lng, NULL, l, type_equal)))
5607 0 : return NULL;
5608 16602 : if ((ek.card != card_relation && sn->limit) &&
5609 : (ek.card == card_value && sn->limit)) {
5610 12 : sql_subfunc *zero_or_one = sql_bind_func(sql, "sys", "zero_or_one", exp_subtype(l), NULL, F_AGGR, true, true);
5611 12 : l = exp_aggr1(sql->sa, l, zero_or_one, 0, 0, CARD_ATOM, has_nil(l));
5612 : }
5613 16602 : list_append(exps, l);
5614 : } else
5615 26 : list_append(exps, exp_atom(sql->sa, atom_general(sql->sa, lng, NULL, 0)));
5616 16628 : if (sn->offset) {
5617 86 : sql_exp *o = rel_value_exp( query, NULL, sn->offset, 0, ek);
5618 86 : if (!o || !(o=exp_check_type(sql, lng, NULL, o, type_equal)))
5619 0 : return NULL;
5620 86 : list_append(exps, o);
5621 : }
5622 16628 : rel = rel_topn(sql->sa, rel, exps);
5623 : }
5624 :
5625 376437 : if (sn->sample || sn->seed) {
5626 23 : list *exps = new_exp_list(sql->sa);
5627 :
5628 23 : if (sn->sample) {
5629 23 : sql_exp *s = rel_value_exp(query, NULL, sn->sample, 0, ek);
5630 23 : if (!s)
5631 : return NULL;
5632 23 : if (!exp_subtype(s) && rel_set_type_param(sql, sql_bind_localtype("lng"), NULL, s, 0) < 0)
5633 : return NULL;
5634 23 : list_append(exps, s);
5635 : } else {
5636 0 : assert(sn->seed);
5637 0 : return sql_error(sql, 02, SQLSTATE(42000) "SEED: cannot have SEED without SAMPLE");
5638 : }
5639 23 : if (sn->seed) {
5640 12 : sql_exp *e = rel_value_exp(query, NULL, sn->seed, 0, ek);
5641 12 : if (!e || !(e=exp_check_type(sql, sql_bind_localtype("int"), NULL, e, type_equal)))
5642 0 : return NULL;
5643 12 : list_append(exps, e);
5644 : }
5645 23 : rel = rel_sample(sql->sa, rel, exps);
5646 : }
5647 :
5648 : /* after parsing the current query, set the group by relation as processed */
5649 376437 : if (!sn->having && inner && is_groupby(inner->op))
5650 33024 : set_processed(inner);
5651 376437 : if (rel)
5652 376437 : set_processed(rel);
5653 : return rel;
5654 : }
5655 :
5656 : static sql_rel *
5657 62 : join_on_column_name(sql_query *query, sql_rel *rel, sql_rel *t1, sql_rel *t2, int op, int l_nil, int r_nil)
5658 : {
5659 62 : mvc *sql = query->sql;
5660 62 : int found = 0, full = (op == op_full), right = (op == op_right);
5661 62 : list *exps = rel_projections(sql, t1, NULL, 1, 0);
5662 62 : list *r_exps = rel_projections(sql, t2, NULL, 1, 0);
5663 62 : list *outexps = new_exp_list(sql->sa);
5664 :
5665 62 : if (!exps || !r_exps)
5666 : return NULL;
5667 244 : for (node *n = exps->h; n; n = n->next) {
5668 185 : sql_exp *le = n->data;
5669 185 : int multi = 0;
5670 185 : const char *rname = exp_relname(le), *name = exp_name(le);
5671 185 : sql_exp *re = exps_bind_column(r_exps, name, NULL, &multi, 0);
5672 :
5673 185 : if (re) {
5674 140 : if (multi)
5675 3 : return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "NATURAL JOIN: common column name '%s' appears more than once in right table", rname);
5676 138 : multi = 0;
5677 138 : le = exps_bind_column(exps, name, NULL, &multi, 0);
5678 138 : if (multi)
5679 0 : return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "NATURAL JOIN: common column name '%s' appears more than once in left table", rname);
5680 :
5681 138 : found = 1;
5682 138 : if (!(rel = rel_compare_exp(query, rel, le, re, "=", TRUE, 0, 0, 0, 0)))
5683 : return NULL;
5684 137 : list_remove_data(r_exps, NULL, re);
5685 137 : if (full) {
5686 12 : sql_exp *cond = rel_unop_(sql, rel, le, "sys", "isnull", card_value);
5687 12 : if (!cond)
5688 : return NULL;
5689 12 : set_has_no_nil(cond);
5690 12 : if (rel_convert_types(sql, NULL, NULL, &le, &re, 1, type_equal_no_any) < 0)
5691 : return NULL;
5692 12 : if (!(le = rel_nop_(sql, rel, cond, re, le, NULL, "sys", "ifthenelse", card_value)))
5693 : return NULL;
5694 125 : } else if (right) {
5695 3 : le = re;
5696 : }
5697 137 : exp_setname(sql, le, rname, name);
5698 137 : set_not_unique(le);
5699 137 : append(outexps, le);
5700 : } else {
5701 45 : if (l_nil)
5702 5 : set_has_nil(le);
5703 45 : set_not_unique(le);
5704 45 : append(outexps, le);
5705 : }
5706 : }
5707 59 : if (!found)
5708 2 : return sql_error(sql, 02, SQLSTATE(42000) "JOIN: no columns of tables '%s' and '%s' match", rel_name(t1)?rel_name(t1):"", rel_name(t2)?rel_name(t2):"");
5709 90 : for (node *n = r_exps->h; n; n = n->next) {
5710 33 : sql_exp *re = n->data;
5711 33 : if (r_nil)
5712 3 : set_has_nil(re);
5713 33 : set_not_unique(re);
5714 33 : append(outexps, re);
5715 : }
5716 57 : rel = rel_project(sql->sa, rel, outexps);
5717 57 : return rel;
5718 : }
5719 :
5720 : static sql_rel *
5721 377727 : rel_select_exp(sql_query *query, sql_rel *rel, SelectNode *sn, exp_kind ek)
5722 : {
5723 377727 : mvc *sql = query->sql;
5724 377727 : sql_rel *inner = NULL;
5725 377727 : int group_totals = 0;
5726 377727 : list *pexps = NULL;
5727 :
5728 377727 : assert(sn->s.token == SQL_SELECT);
5729 377727 : if (!sn->selection)
5730 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: the selection or from part is missing");
5731 :
5732 377727 : if (!rel)
5733 72933 : rel = rel_project_exp(sql, exp_atom_bool(sql->sa, 1));
5734 377727 : rel = rel_where_groupby_nodes(query, rel, sn, &group_totals);
5735 377727 : if (sql->session->status) /* rel might be NULL as input, so we have to check for the session status for errors */
5736 : return NULL;
5737 :
5738 377628 : inner = rel;
5739 377628 : pexps = sa_list(sql->sa);
5740 1772868 : for (dnode *n = sn->selection->h; n; n = n->next) {
5741 : /* Here we could get real column expressions
5742 : * (including single atoms) but also table results.
5743 : * Therefore we try both rel_column_exp
5744 : * and rel_table_exp.
5745 : */
5746 1396345 : list *te = NULL;
5747 2792631 : sql_exp *ce = rel_column_exp(query, &inner, n->data.sym, sql_sel | group_totals | (ek.aggr?sql_aggr:0));
5748 :
5749 1396344 : if (ce) {
5750 1337098 : if (inner && inner->flag && is_groupby(inner->op)) {
5751 62 : int found = 0;
5752 62 : list *gbe = inner->r;
5753 : /* flag == 2 just add to group by/ aggrs and ref-to pexps*/
5754 : /* flag == 1 find group by exp referencing this column nr */
5755 62 : if (inner->flag == 2) {
5756 25 : if (ce->card > CARD_AGGR) {
5757 9 : if (!gbe)
5758 8 : inner->r = gbe = sa_list(sql->sa);
5759 9 : append(gbe, ce);
5760 9 : ce = exp_ref(sql, ce);
5761 9 : ce->card = CARD_AGGR;
5762 9 : list_append(inner->exps, ce);
5763 9 : ce = exp_ref(sql, ce);
5764 9 : found = 1;
5765 : }
5766 : } else {
5767 81 : for(node *n = gbe->h; n && !found; n = n->next) {
5768 44 : sql_exp *e = n->data;
5769 44 : if (is_atom(e->type) && !e->alias.name) {
5770 29 : atom *a = e->l;
5771 29 : int nr = (int)atom_get_int(a);
5772 29 : if (nr == (list_length(pexps) + 1)) {
5773 27 : n->data = ce;
5774 27 : ce = exp_ref(sql, ce);
5775 27 : ce->card = CARD_AGGR;
5776 27 : list_append(inner->exps, ce);
5777 27 : ce = exp_ref(sql, ce);
5778 27 : found = 1;
5779 : }
5780 : }
5781 : }
5782 : }
5783 : }
5784 1337098 : pexps = append(pexps, ce);
5785 1337098 : rel = inner;
5786 1337098 : continue;
5787 : } else {
5788 63813 : te = rel_table_exp(query, &rel, n->data.sym, !list_length(pexps) && !n->next);
5789 : }
5790 59246 : if (!ce && !te) {
5791 1104 : if (sql->errstr[0])
5792 : return NULL;
5793 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: subquery result missing");
5794 : }
5795 : /* here we should merge the column expressions we
5796 : * obtained so far with the table expression, ie
5797 : * t1.* or a subquery.
5798 : */
5799 58142 : pexps = list_merge(pexps, te, (fdup)NULL);
5800 : }
5801 376523 : if (rel && is_groupby(rel->op) && rel->flag) {
5802 34 : list *gbe = rel->r;
5803 34 : if (!list_empty(gbe)) {
5804 68 : for (node *n=gbe->h; n; n = n->next) {
5805 37 : sql_exp *e = n->data;
5806 37 : if (rel->flag == 1 && is_atom(e->type) && !e->alias.name) {
5807 1 : atom *a = e->l;
5808 1 : int nr = (int)atom_get_int(a);
5809 1 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: GROUP BY position %d is not in select list", nr);
5810 : }
5811 36 : if (exp_has_aggr(rel, e))
5812 2 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: aggregate functions are not allowed in GROUP BY");
5813 : }
5814 : }
5815 : }
5816 376520 : if (rel && is_groupby(rel->op) && (!sn->groupby || rel->flag) && !is_processed(rel)) {
5817 43640 : for (node *n=pexps->h; n; n = n->next) {
5818 22288 : sql_exp *ce = n->data;
5819 22288 : if (rel->card < ce->card && !exp_is_aggr(rel, ce)) {
5820 0 : if (exp_name(ce) && !has_label(ce))
5821 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column '%s' in query results without an aggregate function", exp_name(ce));
5822 0 : return sql_error(sql, ERR_GROUPBY, SQLSTATE(42000) "SELECT: cannot use non GROUP BY column in query results without an aggregate function");
5823 : }
5824 : }
5825 21352 : set_processed(rel);
5826 : }
5827 376520 : rel = rel_project(sql->sa, rel, pexps);
5828 :
5829 376519 : rel = rel_having_limits_nodes(query, rel, sn, ek, group_totals);
5830 376519 : return rel;
5831 : }
5832 :
5833 : static sql_rel*
5834 130060 : rel_unique_names(mvc *sql, sql_rel *rel)
5835 : {
5836 130060 : list *l;
5837 :
5838 130060 : if (!is_project(rel->op))
5839 : return rel;
5840 130060 : l = sa_list(sql->sa);
5841 980146 : for (node *n = rel->exps->h; n; n = n->next) {
5842 850086 : sql_exp *e = n->data;
5843 850086 : const char *name = exp_name(e);
5844 :
5845 : /* If there are two identical expression names, there will be ambiguity */
5846 850086 : if (!name || exps_bind_column(l, name, NULL, NULL, 0))
5847 59145 : exp_label(sql->sa, e, ++sql->label);
5848 850086 : append(l,e);
5849 : }
5850 130060 : rel->exps = l;
5851 130060 : return rel;
5852 : }
5853 :
5854 : static sql_rel *
5855 378055 : rel_query(sql_query *query, symbol *sq, exp_kind ek)
5856 : {
5857 378055 : mvc *sql = query->sql;
5858 378055 : sql_rel *res = NULL;
5859 378055 : SelectNode *sn = NULL;
5860 :
5861 378055 : if (sq->token != SQL_SELECT)
5862 22 : return table_ref(query, sq, 0, NULL);
5863 :
5864 : /* select ... into is currently not handled here ! */
5865 378033 : sn = (SelectNode *) sq;
5866 378033 : if (sn->into)
5867 : return NULL;
5868 :
5869 378033 : if (ek.card != card_relation && sn->orderby)
5870 2 : return sql_error(sql, 01, SQLSTATE(42000) "SELECT: ORDER BY only allowed on outermost SELECT");
5871 :
5872 378031 : if (sn->window) {
5873 20 : dlist *wl = sn->window->data.lval;
5874 51 : for (dnode *n = wl->h; n ; n = n->next) {
5875 32 : dlist *wd = n->data.sym->data.lval;
5876 32 : const char *name = wd->h->data.sval;
5877 32 : dlist *wdef = wd->h->next->data.lval;
5878 32 : if (frame_get_window_def(sql, name, NULL)) {
5879 1 : return sql_error(sql, 01, SQLSTATE(42000) "SELECT: Redefinition of window '%s'", name);
5880 31 : } else if (!frame_push_window_def(sql, name, wdef)) {
5881 0 : return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
5882 : }
5883 : }
5884 : }
5885 :
5886 378030 : if (sn->from) {
5887 305097 : dlist *fl = sn->from->data.lval;
5888 305097 : sql_rel *fnd = NULL;
5889 305097 : list *refs = new_exp_list(sql->sa); /* Keep list of relation names in order to test for duplicates */
5890 :
5891 758962 : for (dnode *n = fl->h; n ; n = n->next) {
5892 454168 : int lateral = check_is_lateral(n->data.sym);
5893 :
5894 : /* just used current expression */
5895 454167 : if (lateral && res)
5896 22 : query_push_outer(query, res, sql_from);
5897 454167 : fnd = table_ref(query, n->data.sym, lateral, refs);
5898 454168 : if (lateral && res)
5899 22 : res = query_pop_outer(query);
5900 454168 : if (!fnd)
5901 : break;
5902 453865 : if (res) {
5903 149059 : res = rel_crossproduct(sql->sa, res, fnd, op_join);
5904 149059 : if (lateral)
5905 22 : set_dependent(res);
5906 : } else {
5907 : res = fnd;
5908 : }
5909 : }
5910 305097 : if (!fnd) {
5911 303 : if (res)
5912 12 : rel_destroy(res);
5913 303 : return NULL;
5914 : }
5915 72933 : } else if (!query_has_outer(query) || !res) {/* only on top level query */
5916 72933 : return rel_select_exp(query, NULL, sn, ek);
5917 : }
5918 :
5919 304794 : sql_rel *rel = NULL;
5920 304794 : if (res)
5921 304794 : rel = rel_select_exp(query, res, sn, ek);
5922 304794 : if (!rel && res)
5923 1041 : rel_destroy(res);
5924 : return rel;
5925 : }
5926 :
5927 : /* NOTE: does NOT "set" query but instead generate set ops (union, except, intersect) */
5928 : static sql_rel *
5929 23 : rel_setquery_corresponding(sql_query *query, sql_rel *l, sql_rel *r, dlist *cols, int op, int outer, bool n_ary_op)
5930 : {
5931 23 : mvc *sql = query->sql;
5932 23 : const char *opname = op==SQL_EXCEPT?"EXCEPT":op==SQL_INTERSECT?"INTERSECT":outer?"OUTER UNION":"UNION";
5933 23 : list *lexps = sa_list(query->sql->sa), *rexps = sa_list(query->sql->sa);
5934 23 : if (!lexps || !rexps)
5935 : return NULL;
5936 23 : assert(cols);
5937 23 : if (dlist_length(cols)) {
5938 22 : for (dnode *dn = cols->h; dn; dn = dn ->next) {
5939 13 : char *nm = dn->data.sym->data.lval->h->data.sval;
5940 13 : sql_exp *ls, *rs;
5941 :
5942 13 : if (!(ls = rel_bind_column(sql, l, nm, sql_where | sql_join, 0)) && sql->session->status == -ERR_AMBIGUOUS)
5943 : return NULL;
5944 13 : if (!(rs = rel_bind_column(sql, r, nm, sql_where | sql_join, 0)) && sql->session->status == -ERR_AMBIGUOUS)
5945 : return NULL;
5946 13 : if ((!outer && (!ls || !rs)) || (outer && !ls && !rs))
5947 2 : return sql_error(sql, 02, SQLSTATE(42000) "%s: tables '%s' and '%s' do not have a matching column '%s'", opname, rel_name(l)?rel_name(l):"", rel_name(r)?rel_name(r):"", nm);
5948 11 : if (outer && !ls)
5949 4 : ls = exp_null(sql->sa, exp_subtype(rs));
5950 11 : if (outer && !rs)
5951 4 : rs = exp_null(sql->sa, exp_subtype(ls));
5952 11 : append(lexps, ls);
5953 11 : append(rexps, rs);
5954 : }
5955 : } else {
5956 12 : int found = 0;
5957 12 : list *exps = rel_projections(sql, l, NULL, 1, 0), *r_exps = rel_projections(sql, r, NULL, 1, 0);
5958 12 : if (!exps || !r_exps)
5959 : return NULL;
5960 : /* find cols which exist on both sides */
5961 35 : for (node *n = exps->h; n; n = n->next) {
5962 23 : sql_exp *le = n->data;
5963 23 : int multi = 0;
5964 23 : const char *rname = exp_relname(le), *name = exp_name(le);
5965 23 : sql_exp *re = exps_bind_column(r_exps, name, NULL, &multi, 0);
5966 23 : if (re) {
5967 13 : if (multi)
5968 0 : return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "%s: common column name '%s' appears more than once in right table", opname, rname);
5969 13 : multi = 0;
5970 13 : le = exps_bind_column(exps, name, NULL, &multi, 0);
5971 13 : if (multi)
5972 0 : return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "%s: common column name '%s' appears more than once in left table", opname, rname);
5973 :
5974 13 : found = 1;
5975 13 : append(lexps, le);
5976 13 : append(rexps, re);
5977 13 : list_remove_data(r_exps, NULL, re);
5978 10 : } else if (outer) {
5979 3 : append(lexps, le);
5980 3 : re = exp_null(sql->sa, exp_subtype(le));
5981 3 : append(rexps, re); /* nils */
5982 : }
5983 : }
5984 12 : if (!found)
5985 0 : return sql_error(sql, 02, SQLSTATE(42000) "%s: no columns of tables '%s' and '%s' match", opname, rel_name(l)?rel_name(l):"", rel_name(r)?rel_name(r):"");
5986 12 : if (outer) {
5987 7 : for (node *n = r_exps->h; n; n = n->next) {
5988 4 : sql_exp *re = n->data, *le;
5989 4 : append(rexps, re);
5990 4 : le = exp_null(sql->sa, exp_subtype(re));
5991 4 : append(lexps, le); /* nils */
5992 : }
5993 : }
5994 : }
5995 21 : return n_ary_op ?
5996 21 : rel_setop_n_ary_check_types(sql, l, r, lexps, rexps, (operator_type)op) :
5997 2 : rel_setop_check_types(sql, l, r, lexps, rexps, (operator_type)op);
5998 : }
5999 :
6000 : static sql_rel *
6001 2484 : rel_setquery_(sql_query *query, sql_rel *l, sql_rel *r, dlist *cols, int op, int outer)
6002 : {
6003 2484 : mvc *sql = query->sql;
6004 2484 : sql_rel *rel;
6005 :
6006 2484 : if (outer && !cols)
6007 0 : return sql_error(sql, 02, SQLSTATE(42000) "UNION: OUTER needs to be combined with CORRESPONDING [ BY ( column list ) ]");
6008 2484 : if (!cols) {
6009 2482 : list *ls, *rs;
6010 :
6011 2482 : l = rel_unique_names(sql, l);
6012 2482 : r = rel_unique_names(sql, r);
6013 2482 : ls = rel_projections(sql, l, NULL, 0, 1);
6014 2482 : rs = rel_projections(sql, r, NULL, 0, 1);
6015 2482 : rel = rel_setop_check_types(sql, l, r, ls, rs, (operator_type)op);
6016 : } else {
6017 2 : rel = rel_setquery_corresponding(query, l, r, cols, op, outer, false);
6018 : }
6019 2484 : if (rel) {
6020 2481 : rel_setop_set_exps(sql, rel, rel_projections(sql, rel, NULL, 0, 1), false);
6021 2481 : set_processed(rel);
6022 : }
6023 : return rel;
6024 : }
6025 :
6026 : /* Generate n-ary set operator */
6027 : static sql_rel *
6028 62569 : rel_setquery_n_ary_(sql_query *query, sql_rel *l, sql_rel *r, dlist *cols, int op, int outer)
6029 : {
6030 : /* even though this is for a general n-ary operators in this phase of the query
6031 : * processing we gonna have only two operands (so technically it's binary). In
6032 : * general this op supports arbitrary number of operands.
6033 : */
6034 : // TODO: for now we support only multi-union
6035 62569 : assert(op == op_munion);
6036 :
6037 62569 : mvc *sql = query->sql;
6038 62569 : sql_rel *rel;
6039 :
6040 62569 : if (outer && !cols)
6041 0 : return sql_error(sql, 02, SQLSTATE(42000) "UNION: OUTER needs to be combined with CORRESPONDING [ BY ( column list ) ]");
6042 62569 : if (!cols) {
6043 : // TODO: make rel_setop_n_ary_check_types to accept a list of rels
6044 : // and a list of lists of exps
6045 62548 : list *ls, *rs;
6046 :
6047 62548 : l = rel_unique_names(sql, l);
6048 62548 : r = rel_unique_names(sql, r);
6049 62548 : ls = rel_projections(sql, l, NULL, 0, 1);
6050 62548 : rs = rel_projections(sql, r, NULL, 0, 1);
6051 62548 : rel = rel_setop_n_ary_check_types(sql, l, r, ls, rs, (operator_type)op);
6052 : } else {
6053 21 : rel = rel_setquery_corresponding(query, l, r, cols, op, outer, true);
6054 : }
6055 :
6056 62569 : if (rel) {
6057 62563 : rel_setop_n_ary_set_exps(sql, rel, rel_projections(sql, rel, NULL, 0, 1), false);
6058 62563 : set_processed(rel);
6059 : }
6060 :
6061 : return rel;
6062 :
6063 : }
6064 :
6065 : static sql_rel *
6066 65066 : rel_setquery(sql_query *query, symbol *q)
6067 : {
6068 65066 : mvc *sql = query->sql;
6069 65066 : sql_rel *res = NULL;
6070 65066 : dnode *n = q->data.lval->h;
6071 65066 : symbol *tab_ref1 = n->data.sym;
6072 65066 : int distinct = n->next->data.i_val;
6073 65066 : dlist *corresponding = n->next->next->data.lval;
6074 65066 : symbol *tab_ref2 = n->next->next->next->data.sym;
6075 65066 : sql_rel *t1, *t2;
6076 :
6077 65066 : assert(n->next->type == type_int);
6078 65066 : t1 = table_ref(query, tab_ref1, 0, NULL);
6079 65066 : if (!t1)
6080 : return NULL;
6081 65062 : t2 = table_ref(query, tab_ref2, 0, NULL);
6082 65062 : if (!t2)
6083 : return NULL;
6084 :
6085 65054 : rel_remove_internal_exp(t1);
6086 65054 : rel_remove_internal_exp(t2);
6087 65054 : if (!corresponding && list_length(t1->exps) != list_length(t2->exps)) {
6088 1 : int t1nrcols = list_length(t1->exps);
6089 1 : int t2nrcols = list_length(t2->exps);
6090 1 : const char *op = "UNION";
6091 1 : if (q->token == SQL_EXCEPT)
6092 : op = "EXCEPT";
6093 0 : else if (q->token == SQL_INTERSECT)
6094 0 : op = "INTERSECT";
6095 1 : rel_destroy(t1);
6096 1 : rel_destroy(t2);
6097 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: column counts (%d and %d) do not match", op, t1nrcols, t2nrcols);
6098 : }
6099 65053 : if ( q->token == SQL_UNION) {
6100 62569 : int outer = n->next->next->next->next->data.i_val;
6101 : /* For EXCEPT/INTERSECT the group by is always done within the implementation */
6102 : /* TODO add those later in an optimizer ! */
6103 62569 : if (t1 && distinct)
6104 3505 : t1 = rel_distinct(t1);
6105 62569 : if (t2 && distinct)
6106 3505 : t2 = rel_distinct(t2);
6107 : // TODO: this has to be fixed
6108 : /*res = rel_setquery_(query, t1, t2, corresponding, op_union, outer);*/
6109 62569 : res = rel_setquery_n_ary_(query, t1, t2, corresponding, op_munion, outer);
6110 2484 : } else if ( q->token == SQL_EXCEPT)
6111 2026 : res = rel_setquery_(query, t1, t2, corresponding, op_except, 0);
6112 458 : else if ( q->token == SQL_INTERSECT)
6113 458 : res = rel_setquery_(query, t1, t2, corresponding, op_inter, 0);
6114 65053 : if (res) {
6115 65044 : set_processed(res);
6116 65044 : if (distinct)
6117 5863 : res = rel_distinct(res);
6118 : }
6119 : return res;
6120 : }
6121 :
6122 : static sql_rel *
6123 60032 : rel_joinquery_(sql_query *query, symbol *tab1, int natural, jt jointype, symbol *tab2, symbol *js, list *refs)
6124 : {
6125 60032 : mvc *sql = query->sql;
6126 60032 : operator_type op = op_join;
6127 60032 : sql_rel *t1 = NULL, *t2 = NULL, *inner, *rel = NULL;
6128 60032 : int l_nil = 0, r_nil = 0, lateral = 0;
6129 :
6130 60032 : switch(jointype) {
6131 : case jt_inner:
6132 : case jt_cross: op = op_join;
6133 : break;
6134 : case jt_left: op = op_left;
6135 : r_nil = 1;
6136 : break;
6137 : case jt_right: op = op_right;
6138 : l_nil = 1;
6139 : break;
6140 : case jt_full: op = op_full;
6141 : l_nil = 1;
6142 : r_nil = 1;
6143 : break;
6144 : }
6145 :
6146 : /* a dependent join cannot depend on the right side, so disable lateral check for right and full joins */
6147 60032 : lateral = (op == op_join || op == op_left) && check_is_lateral(tab2);
6148 60032 : t1 = table_ref(query, tab1, 0, refs);
6149 60032 : if (t1) {
6150 60027 : if (!lateral) {
6151 59992 : t2 = table_ref(query, tab2, 0, refs);
6152 : } else {
6153 35 : query_processed(query);
6154 35 : query_push_outer(query, t1, sql_from);
6155 35 : t2 = table_ref(query, tab2, 0, refs);
6156 35 : t1 = query_pop_outer(query);
6157 : }
6158 : }
6159 60032 : if (!t1 || !t2)
6160 : return NULL;
6161 :
6162 60011 : query_processed(query);
6163 60011 : if (strcmp(rel_name(t1), rel_name(t2)) == 0) {
6164 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: ERROR: table name '%s' specified more than once", rel_name(t1));
6165 : }
6166 60011 : inner = rel = rel_crossproduct(sql->sa, t1, t2, op);
6167 60011 : if (!rel)
6168 : return NULL;
6169 60011 : if (lateral)
6170 34 : set_dependent(rel);
6171 :
6172 60011 : assert(jointype != jt_cross || (!natural && !js)); /* there are no natural cross joins, or cross joins with conditions */
6173 60011 : if (js && natural)
6174 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: cannot have a NATURAL JOIN with a join specification (ON or USING)");
6175 60011 : if (jointype != jt_cross && !js && !natural)
6176 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: must have NATURAL JOIN or a JOIN with a join specification (ON or USING)");
6177 :
6178 60011 : if (js && js->token != SQL_USING) { /* On sql_logical_exp */
6179 59834 : rel = rel_logical_exp(query, rel, js, sql_where | sql_join);
6180 177 : } else if (js) { /* using */
6181 24 : char rname[16], *rnme;
6182 24 : dnode *n = js->data.lval->h;
6183 24 : list *outexps = new_exp_list(sql->sa), *exps;
6184 24 : node *m;
6185 :
6186 24 : rnme = sa_strdup(sql->sa, number2name(rname, sizeof(rname), ++sql->label));
6187 54 : for (; n; n = n->next) {
6188 30 : char *nm = n->data.sval;
6189 30 : sql_exp *cond, *ls, *rs;
6190 :
6191 30 : if (!(ls = rel_bind_column(sql, t1, nm, sql_where | sql_join, 0)) && sql->session->status == -ERR_AMBIGUOUS)
6192 0 : return NULL;
6193 30 : if (!(rs = rel_bind_column(sql, t2, nm, sql_where | sql_join, 0)) && sql->session->status == -ERR_AMBIGUOUS)
6194 : return NULL;
6195 30 : if (!ls || !rs)
6196 0 : return sql_error(sql, 02, SQLSTATE(42000) "JOIN: tables '%s' and '%s' do not have a matching column '%s'", rel_name(t1)?rel_name(t1):"", rel_name(t2)?rel_name(t2):"", nm);
6197 30 : if (!(rel = rel_compare_exp(query, rel, ls, rs, "=", TRUE, 0, 0, 0, 0)))
6198 : return NULL;
6199 30 : if (op != op_join) {
6200 12 : if (!(cond = rel_unop_(sql, rel, ls, "sys", "isnull", card_value)))
6201 : return NULL;
6202 12 : set_has_no_nil(cond);
6203 12 : if (rel_convert_types(sql, t1, t2, &ls, &rs, 1, type_equal) < 0)
6204 : return NULL;
6205 12 : if (!(ls = rel_nop_(sql, rel, cond, rs, ls, NULL, "sys", "ifthenelse", card_value)))
6206 : return NULL;
6207 : }
6208 30 : exp_setname(sql, ls, rnme, nm);
6209 30 : append(outexps, ls);
6210 30 : if (!rel)
6211 : return NULL;
6212 : }
6213 24 : exps = rel_projections(sql, t1, NULL, 1, 1);
6214 207 : for (m = exps->h; m; m = m->next) {
6215 183 : const char *nm = exp_name(m->data);
6216 183 : int fnd = 0;
6217 :
6218 433 : for (n = js->data.lval->h; n; n = n->next) {
6219 280 : if (strcmp(nm, n->data.sval) == 0) {
6220 : fnd = 1;
6221 : break;
6222 : }
6223 : }
6224 183 : if (!fnd) {
6225 153 : sql_exp *ls = m->data;
6226 153 : if (l_nil)
6227 18 : set_has_nil(ls);
6228 153 : set_not_unique(ls);
6229 153 : append(outexps, ls);
6230 : }
6231 : }
6232 24 : exps = rel_projections(sql, t2, NULL, 1, 1);
6233 108 : for (m = exps->h; m; m = m->next) {
6234 84 : const char *nm = exp_name(m->data);
6235 84 : int fnd = 0;
6236 :
6237 234 : for (n = js->data.lval->h; n; n = n->next) {
6238 180 : if (strcmp(nm, n->data.sval) == 0) {
6239 : fnd = 1;
6240 : break;
6241 : }
6242 : }
6243 84 : if (!fnd) {
6244 54 : sql_exp *rs = m->data;
6245 54 : if (r_nil)
6246 14 : set_has_nil(rs);
6247 54 : set_not_unique(rs);
6248 54 : append(outexps, rs);
6249 : }
6250 : }
6251 24 : rel = rel_project(sql->sa, rel, outexps);
6252 153 : } else if (jointype != jt_cross) { /* ! js -> natural join */
6253 62 : rel = join_on_column_name(query, rel, t1, t2, op, l_nil, r_nil);
6254 : }
6255 60011 : if (!rel)
6256 : return NULL;
6257 59993 : if (inner && is_outerjoin(inner->op))
6258 21103 : set_processed(inner);
6259 59993 : set_processed(rel);
6260 59993 : query_processed(query);
6261 59993 : return rel;
6262 : }
6263 :
6264 : static sql_rel *
6265 60032 : rel_joinquery(sql_query *query, symbol *q, list *refs)
6266 : {
6267 60032 : dnode *n = q->data.lval->h;
6268 60032 : symbol *tab_ref1 = n->data.sym;
6269 60032 : int natural = n->next->data.i_val;
6270 60032 : jt jointype = (jt) n->next->next->data.i_val;
6271 60032 : symbol *tab_ref2 = n->next->next->next->data.sym;
6272 60032 : symbol *joinspec = n->next->next->next->next->data.sym;
6273 :
6274 60032 : assert(n->next->type == type_int);
6275 60032 : assert(n->next->next->type == type_int);
6276 60032 : return rel_joinquery_(query, tab_ref1, natural, jointype, tab_ref2, joinspec, refs);
6277 : }
6278 :
6279 : sql_rel *
6280 378055 : rel_subquery(sql_query *query, symbol *sq, exp_kind ek)
6281 : {
6282 378055 : mvc *sql = query->sql;
6283 :
6284 378055 : query_processed(query);
6285 378055 : if (!stack_push_frame(sql, NULL))
6286 0 : return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
6287 378055 : sql_rel *rel = rel_query(query, sq, ek);
6288 378055 : stack_pop_frame(sql);
6289 378054 : if (!query_has_outer(query))
6290 339078 : query_processed(query);
6291 378054 : if (rel && ek.type == type_relation && ek.card < card_set && rel->card >= CARD_AGGR)
6292 15 : return rel_zero_or_one(sql, rel, ek);
6293 : return rel;
6294 : }
6295 :
6296 : sql_rel *
6297 238824 : rel_selects(sql_query *query, symbol *s)
6298 : {
6299 238824 : mvc *sql = query->sql;
6300 238824 : sql_rel *ret = NULL;
6301 :
6302 238824 : switch (s->token) {
6303 4523 : case SQL_WITH:
6304 4523 : ret = rel_with_query(query, s);
6305 4523 : sql->type = Q_TABLE;
6306 4523 : break;
6307 2254 : case SQL_VALUES:
6308 2254 : ret = rel_values(query, s, NULL);
6309 2254 : sql->type = Q_TABLE;
6310 2254 : break;
6311 210904 : case SQL_SELECT: {
6312 210904 : exp_kind ek = {type_value, card_relation, TRUE};
6313 210904 : SelectNode *sn = (SelectNode *) s;
6314 :
6315 210904 : if (sn->into) {
6316 1 : sql->type = Q_SCHEMA;
6317 1 : ret = rel_select_with_into(query, s);
6318 : } else {
6319 210903 : ret = rel_subquery(query, s, ek);
6320 210902 : sql->type = Q_TABLE;
6321 : }
6322 210903 : } break;
6323 0 : case SQL_JOIN:
6324 0 : ret = rel_joinquery(query, s, NULL);
6325 0 : sql->type = Q_TABLE;
6326 0 : break;
6327 21143 : case SQL_UNION:
6328 : case SQL_EXCEPT:
6329 : case SQL_INTERSECT:
6330 21143 : ret = rel_setquery(query, s);
6331 21143 : sql->type = Q_TABLE;
6332 21143 : break;
6333 : default:
6334 : return NULL;
6335 : }
6336 238823 : if (!ret && sql->errstr[0] == 0)
6337 0 : (void) sql_error(sql, 02, SQLSTATE(42000) "relational query without result");
6338 : return ret;
6339 : }
6340 :
6341 : sql_rel *
6342 78540 : schema_selects(sql_query *query, sql_schema *schema, symbol *s)
6343 : {
6344 78540 : mvc *sql = query->sql;
6345 78540 : sql_rel *res;
6346 78540 : sql_schema *os = cur_schema(sql);
6347 :
6348 78540 : sql->session->schema = schema;
6349 78540 : res = rel_selects(query, s);
6350 78540 : sql->session->schema = os;
6351 78540 : return res;
6352 : }
6353 :
6354 : sql_rel *
6355 26 : rel_loader_function(sql_query *query, symbol* fcall, list *fexps, sql_subfunc **loader_function)
6356 : {
6357 26 : mvc *sql = query->sql;
6358 26 : sql_rel *sq = NULL;
6359 26 : dnode *l = fcall->data.lval->h;
6360 26 : char *sname = qname_schema(l->data.lval);
6361 26 : char *fname = qname_schema_object(l->data.lval);
6362 :
6363 26 : list *tl = sa_list(sql->sa);
6364 26 : list *exps = sa_list(sql->sa);
6365 26 : if (l->next)
6366 26 : l = l->next; /* skip distinct */
6367 26 : if (l->next) { /* table call with subquery */
6368 26 : if (l->next->type == type_symbol || l->next->type == type_list) {
6369 26 : int count = 0;
6370 26 : symbol *subquery = NULL;
6371 26 : dnode *n = NULL;
6372 :
6373 26 : if (l->next->type == type_symbol)
6374 : n = l->next;
6375 : else
6376 26 : n = l->next->data.lval?l->next->data.lval->h:NULL;
6377 :
6378 70 : for (dnode *m = n; m; m = m->next) {
6379 44 : if (m->type == type_symbol && m->data.sym->token == SQL_SELECT)
6380 44 : subquery = m->data.sym;
6381 44 : count++;
6382 : }
6383 26 : if (subquery && count > 1)
6384 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT: The input for the loader function '%s' must be either a single sub query, or a list of values", fname);
6385 :
6386 26 : if (subquery) {
6387 0 : exp_kind ek = { type_value, card_relation, TRUE };
6388 0 : if (!(sq = rel_subquery(query, subquery, ek)))
6389 0 : return NULL;
6390 : } else {
6391 26 : exp_kind ek = { type_value, card_column, TRUE };
6392 26 : list *exps = sa_list(sql->sa);
6393 96 : for ( ; n; n = n->next) {
6394 44 : sql_exp *e = rel_value_exp(query, NULL, n->data.sym, sql_sel | sql_from, ek);
6395 :
6396 44 : if (!e)
6397 0 : return NULL;
6398 44 : append(exps, e);
6399 : }
6400 26 : sq = rel_project(sql->sa, NULL, exps);
6401 : }
6402 : }
6403 26 : if (!sq)
6404 0 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "SELECT: no such loader function %s%s%s'%s'", sname ? "'":"", sname ? sname : "", sname ? "'.":"", fname);
6405 70 : for (node *en = sq->exps->h; en; en = en->next) {
6406 44 : sql_exp *e = en->data;
6407 :
6408 44 : append(exps, e = exp_ref(sql, e));
6409 44 : append(tl, exp_subtype(e));
6410 : }
6411 : }
6412 :
6413 26 : sql_exp *e = NULL;
6414 26 : if (!(e = find_table_function(sql, sname, fname, exps, tl, F_LOADER)))
6415 : return NULL;
6416 25 : sql_subfunc *sf = e->f;
6417 25 : if (sq) {
6418 69 : for (node *n = sq->exps->h, *m = sf->func->ops->h ; n && m ; n = n->next, m = m->next) {
6419 44 : sql_exp *e = (sql_exp*) n->data;
6420 44 : sql_arg *a = (sql_arg*) m->data;
6421 44 : if (!exp_subtype(e) && rel_set_type_param(sql, &(a->type), sq, e, 0) < 0)
6422 : return NULL;
6423 : }
6424 : }
6425 :
6426 25 : if (loader_function)
6427 25 : *loader_function = sf;
6428 :
6429 25 : return rel_table_func(sql->sa, sq, e, fexps, (sq)?TABLE_FROM_RELATION:TABLE_PROD_FUNC);
6430 : }
|
