Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : #include "monetdb_config.h"
14 : #include "sql_relation.h"
15 : #include "sql_semantic.h"
16 : #include "sql_decimal.h"
17 : #include "rel_exp.h"
18 : #include "rel_rel.h"
19 : #include "rel_basetable.h"
20 : #include "rel_prop.h"
21 :
22 : comp_type
23 825919 : compare_str2type(const char *compare_op)
24 : {
25 825919 : comp_type type = cmp_filter;
26 :
27 825919 : if (compare_op[0] == '=') {
28 : type = cmp_equal;
29 162104 : } else if (compare_op[0] == '<') {
30 103578 : type = cmp_lt;
31 103578 : if (compare_op[1] == '>')
32 : type = cmp_notequal;
33 23229 : else if (compare_op[1] == '=')
34 4164 : type = cmp_lte;
35 58526 : } else if (compare_op[0] == '>') {
36 58526 : type = cmp_gt;
37 58526 : if (compare_op[1] == '=')
38 3337 : type = cmp_gte;
39 : }
40 825919 : return type;
41 : }
42 :
43 : comp_type
44 52368 : swap_compare( comp_type t )
45 : {
46 52368 : switch(t) {
47 : case cmp_equal:
48 : return cmp_equal;
49 : case cmp_lt:
50 : return cmp_gt;
51 : case cmp_lte:
52 : return cmp_gte;
53 : case cmp_gte:
54 : return cmp_lte;
55 : case cmp_gt:
56 : return cmp_lt;
57 : case cmp_notequal:
58 : return cmp_notequal;
59 : default:
60 : return cmp_equal;
61 : }
62 : }
63 :
64 : comp_type
65 7662 : negate_compare( comp_type t )
66 : {
67 7662 : switch(t) {
68 : case cmp_equal:
69 : return cmp_notequal;
70 29 : case cmp_notequal:
71 29 : return cmp_equal;
72 2 : case cmp_lt:
73 2 : return cmp_gte;
74 5 : case cmp_lte:
75 5 : return cmp_gt;
76 3 : case cmp_gte:
77 3 : return cmp_lt;
78 3 : case cmp_gt:
79 3 : return cmp_lte;
80 :
81 0 : case cmp_in:
82 0 : return cmp_notin;
83 0 : case cmp_notin:
84 0 : return cmp_in;
85 :
86 0 : default:
87 0 : return t;
88 : }
89 : }
90 :
91 : comp_type
92 3203 : range2lcompare( int r )
93 : {
94 3203 : if (r&1) {
95 : return cmp_gte;
96 : } else {
97 1215 : return cmp_gt;
98 : }
99 : }
100 :
101 : comp_type
102 3260 : range2rcompare( int r )
103 : {
104 3260 : if (r&2) {
105 : return cmp_lte;
106 : } else {
107 1252 : return cmp_lt;
108 : }
109 : }
110 :
111 : int
112 1910 : compare2range( int l, int r )
113 : {
114 1910 : if (l == cmp_gt) {
115 1787 : if (r == cmp_lt)
116 : return 0;
117 23 : else if (r == cmp_lte)
118 23 : return 2;
119 123 : } else if (l == cmp_gte) {
120 123 : if (r == cmp_lt)
121 : return 1;
122 85 : else if (r == cmp_lte)
123 85 : return 3;
124 : }
125 : return -1;
126 : }
127 :
128 : int
129 95 : compare_funcs2range(const char *l_op, const char *r_op)
130 : {
131 95 : assert(l_op[0] == '>' && r_op[0] == '<');
132 95 : if (!l_op[1] && !r_op[1])
133 : return 0;
134 93 : if (!l_op[1] && r_op[1] == '=')
135 : return 2;
136 93 : if (l_op[1] == '=' && !r_op[1])
137 : return 1;
138 1 : if (l_op[1] == '=' && r_op[1] == '=')
139 : return 3;
140 0 : assert(0);
141 : return 0;
142 : }
143 :
144 : static sql_exp *
145 20947233 : exp_create(allocator *sa, int type)
146 : {
147 20947233 : sql_exp *e = SA_NEW(sa, sql_exp);
148 :
149 20947465 : if (!e)
150 : return NULL;
151 20947465 : *e = (sql_exp) {
152 20947465 : .type = (expression_type) type,
153 : };
154 20947465 : return e;
155 : }
156 :
157 : sql_exp *
158 474619 : exp_compare(allocator *sa, sql_exp *l, sql_exp *r, int cmptype)
159 : {
160 474619 : sql_exp *e = exp_create(sa, e_cmp);
161 474619 : if (e == NULL)
162 : return NULL;
163 474619 : e->card = MAX(l->card,r->card);
164 474619 : e->l = l;
165 474619 : e->r = r;
166 474619 : e->flag = cmptype;
167 474619 : if (!has_nil(l) && !has_nil(r))
168 340842 : set_has_no_nil(e);
169 : return e;
170 : }
171 :
172 : sql_exp *
173 6662 : exp_compare2(allocator *sa, sql_exp *l, sql_exp *r, sql_exp *f, int cmptype, int symmetric)
174 : {
175 6662 : sql_exp *e = exp_create(sa, e_cmp);
176 6662 : if (e == NULL)
177 : return NULL;
178 6662 : assert(f);
179 6662 : e->card = MAX(MAX(l->card,r->card),f->card);
180 6662 : e->l = l;
181 6662 : e->r = r;
182 6662 : e->f = f;
183 6662 : e->flag = cmptype;
184 6662 : if (symmetric)
185 77 : set_symmetric(e);
186 6662 : if (!has_nil(l) && !has_nil(r) && !has_nil(f))
187 1590 : set_has_no_nil(e);
188 : return e;
189 : }
190 :
191 : sql_exp *
192 6322 : exp_filter(allocator *sa, list *l, list *r, sql_subfunc *f, int anti)
193 : {
194 6322 : sql_exp *e = exp_create(sa, e_cmp);
195 :
196 6322 : if (e == NULL)
197 : return NULL;
198 6322 : e->card = MAX(exps_card(l),exps_card(r));
199 6322 : if (!r) { /* split l */
200 1384 : list *nl = sa_list(sa), *nr = sa_list(sa);
201 1384 : node *n = l->h;
202 1384 : append(nl, n->data); /* sofar only first is left */
203 3583 : for(n = n->next; n; n = n->next)
204 2199 : append(nr, n->data);
205 : l = nl;
206 : r = nr;
207 : }
208 6322 : e->l = l;
209 6322 : e->r = r;
210 6322 : e->f = f;
211 6322 : e->flag = cmp_filter;
212 6322 : if (anti)
213 704 : set_anti(e);
214 6322 : if (!have_nil(l) && !have_nil(r))
215 4564 : set_has_no_nil(e);
216 : return e;
217 : }
218 :
219 : sql_exp *
220 66095 : exp_or(allocator *sa, list *l, list *r, int anti)
221 : {
222 66095 : sql_exp *e = exp_create(sa, e_cmp);
223 :
224 66095 : if (e == NULL)
225 : return NULL;
226 66095 : e->card = MAX(exps_card(l),exps_card(r));
227 66095 : e->l = l;
228 66095 : e->r = r;
229 66095 : e->flag = cmp_or;
230 66095 : if (anti)
231 2 : set_anti(e);
232 66095 : if (!have_nil(l) && !have_nil(r))
233 45357 : set_has_no_nil(e);
234 : return e;
235 : }
236 :
237 : sql_exp *
238 29568 : exp_in(allocator *sa, sql_exp *l, list *r, int cmptype)
239 : {
240 29568 : sql_exp *e = exp_create(sa, e_cmp);
241 29568 : unsigned int exps_card = CARD_ATOM;
242 :
243 29568 : if (e == NULL)
244 : return NULL;
245 :
246 : /* ignore the cardinalites of sub-relations */
247 146183 : for (node *n = r->h; n ; n = n->next) {
248 116615 : sql_exp *next = n->data;
249 :
250 116615 : if (!exp_is_rel(next) && exps_card < next->card)
251 116615 : exps_card = next->card;
252 : }
253 29568 : e->card = MAX(l->card, exps_card);
254 29568 : e->l = l;
255 29568 : e->r = r;
256 29568 : assert( cmptype == cmp_in || cmptype == cmp_notin);
257 29568 : e->flag = cmptype;
258 29568 : if (!has_nil(l) && !have_nil(r))
259 23227 : set_has_no_nil(e);
260 : return e;
261 : }
262 :
263 : sql_exp *
264 32692 : exp_in_func(mvc *sql, sql_exp *le, sql_exp *vals, int anyequal, int is_tuple)
265 : {
266 32692 : sql_subfunc *a_func = NULL;
267 32692 : sql_exp *e = le;
268 :
269 32692 : if (is_tuple) {
270 4100 : list *l = exp_get_values(e);
271 4100 : e = l->h->data;
272 : }
273 37048 : if (!(a_func = sql_bind_func(sql, "sys", anyequal ? "sql_anyequal" : "sql_not_anyequal", exp_subtype(e), exp_subtype(e), F_FUNC, true, true)))
274 0 : return sql_error(sql, 02, SQLSTATE(42000) "(NOT) IN operator on type %s missing", exp_subtype(e) ? exp_subtype(e)->type->base.name : "unknown");
275 32692 : e = exp_binop(sql->sa, le, vals, a_func);
276 32692 : if (e) {
277 32692 : unsigned int exps_card = CARD_ATOM;
278 :
279 : /* ignore the cardinalites of sub-relations */
280 32692 : if (vals->type == e_atom && vals->f) {
281 156510 : for (node *n = ((list*)vals->f)->h ; n ; n = n->next) {
282 123818 : sql_exp *next = n->data;
283 :
284 123818 : if (!exp_is_rel(next) && exps_card < next->card)
285 123818 : exps_card = next->card;
286 : }
287 0 : } else if (!exp_is_rel(vals))
288 0 : exps_card = vals->card;
289 :
290 32692 : e->card = MAX(le->card, exps_card);
291 32692 : if (!has_nil(le) && !has_nil(vals))
292 0 : set_has_no_nil(e);
293 : }
294 : return e;
295 : }
296 :
297 : sql_exp *
298 5562 : exp_in_aggr(mvc *sql, sql_exp *le, sql_exp *vals, int anyequal, int is_tuple)
299 : {
300 5562 : sql_subfunc *a_func = NULL;
301 5562 : sql_exp *e = le;
302 :
303 5562 : if (is_tuple) {
304 0 : list *l = exp_get_values(e);
305 0 : e = l->h->data;
306 : }
307 5571 : if (!(a_func = sql_bind_func(sql, "sys", anyequal ? "anyequal" : "allnotequal", exp_subtype(e), exp_subtype(e), F_AGGR, true, true)))
308 0 : return sql_error(sql, 02, SQLSTATE(42000) "(NOT) IN operator on type %s missing", exp_subtype(e) ? exp_subtype(e)->type->base.name : "unknown");
309 5562 : e = exp_aggr2(sql->sa, le, vals, a_func, need_distinct(e), need_no_nil(e), e->card, has_nil(e));
310 5562 : if (e) {
311 5562 : unsigned int exps_card = CARD_ATOM;
312 :
313 : /* ignore the cardinalites of sub-relations */
314 5562 : if (vals->type == e_atom && vals->f) {
315 31472 : for (node *n = ((list*)vals->f)->h ; n ; n = n->next) {
316 25910 : sql_exp *next = n->data;
317 :
318 25910 : if (!exp_is_rel(next) && exps_card < next->card)
319 25910 : exps_card = next->card;
320 : }
321 0 : } else if (!exp_is_rel(vals))
322 0 : exps_card = vals->card;
323 :
324 5562 : e->card = MAX(le->card, exps_card);
325 5562 : if (!has_nil(le) && !has_nil(vals))
326 0 : set_has_no_nil(e);
327 : }
328 : return e;
329 : }
330 :
331 : sql_exp *
332 120812 : exp_compare_func(mvc *sql, sql_exp *le, sql_exp *re, const char *compareop, int quantifier)
333 : {
334 120812 : sql_subfunc *cmp_func = sql_bind_func(sql, "sys", compareop, exp_subtype(le), exp_subtype(le), F_FUNC, true, true);
335 120812 : sql_exp *e = NULL;
336 :
337 120812 : if (cmp_func == NULL)
338 : return NULL;
339 :
340 120812 : e = exp_binop(sql->sa, le, re, cmp_func);
341 120812 : if (e) {
342 120812 : e->flag = quantifier;
343 : /* At ANY and ALL operators, the cardinality on the right side is ignored if it is a sub-relation */
344 120812 : e->card = quantifier && exp_is_rel(re) ? le->card : MAX(le->card, re->card);
345 120812 : if (!has_nil(le) && !has_nil(re))
346 77285 : set_has_no_nil(e);
347 : }
348 : return e;
349 : }
350 :
351 : static sql_subtype*
352 852338 : dup_subtype(allocator *sa, sql_subtype *st)
353 : {
354 852338 : sql_subtype *res = SA_NEW(sa, sql_subtype);
355 :
356 852338 : if (res == NULL)
357 : return NULL;
358 852338 : *res = *st;
359 852338 : return res;
360 : }
361 :
362 : sql_exp *
363 426169 : exp_convert(mvc *sql, sql_exp *exp, sql_subtype *fromtype, sql_subtype *totype )
364 : {
365 426169 : sql_exp *e = exp_create(sql->sa, e_convert);
366 426169 : if (e == NULL)
367 : return NULL;
368 426169 : e->card = exp->card;
369 426169 : e->l = exp;
370 426169 : totype = dup_subtype(sql->sa, totype);
371 426169 : e->r = append(append(sa_list(sql->sa), dup_subtype(sql->sa, fromtype)),totype);
372 426169 : e->tpe = *totype;
373 426169 : e->alias = exp->alias;
374 426169 : if (e->alias.label)
375 278342 : e->alias.label = -(sql->nid++);
376 426169 : if (!has_nil(exp))
377 166711 : set_has_no_nil(e);
378 : return e;
379 : }
380 :
381 : sql_exp *
382 1079860 : exp_op( allocator *sa, list *l, sql_subfunc *f )
383 : {
384 1079860 : if (f->func->type == F_FILT)
385 1384 : return exp_filter(sa, l, NULL, f, false);
386 1078476 : sql_exp *e = exp_create(sa, e_func);
387 1078476 : if (e == NULL)
388 : return NULL;
389 1078476 : e->card = exps_card(l);
390 1078476 : e->l = l;
391 1078476 : e->f = f;
392 1078476 : e->semantics = f->func->semantics;
393 1078476 : if (!is_semantics(e) && !is_any(e) && l && !have_nil(l))
394 253581 : set_has_no_nil(e);
395 : return e;
396 : }
397 :
398 : sql_exp *
399 17869 : exp_rank_op( allocator *sa, list *l, list *gbe, list *obe, sql_subfunc *f )
400 : {
401 17869 : sql_exp *e = exp_create(sa, e_func);
402 17869 : if (e == NULL)
403 : return NULL;
404 17869 : e->card = list_empty(l)?CARD_MULTI:exps_card(l);
405 17869 : e->l = l;
406 17869 : e->r = append(append(sa_list(sa), gbe), obe);
407 17869 : e->f = f;
408 17869 : if (!f->func->s && strcmp(f->func->base.name, "count") == 0)
409 180 : set_has_no_nil(e);
410 17869 : e->semantics = f->func->semantics;
411 17869 : return e;
412 : }
413 :
414 : sql_exp *
415 60883 : exp_aggr( allocator *sa, list *l, sql_subfunc *a, int distinct, int no_nils, unsigned int card, int has_nils )
416 : {
417 60883 : sql_exp *e = exp_create(sa, e_aggr);
418 60883 : if (e == NULL)
419 : return NULL;
420 60883 : e->card = card;
421 60883 : e->l = l;
422 60883 : e->f = a;
423 60883 : e->semantics = a->func->semantics;
424 60883 : if (distinct)
425 373 : set_distinct(e);
426 60883 : if (no_nils)
427 25166 : set_no_nil(e);
428 60883 : if ((!a->func->semantics && !has_nils) || (!a->func->s && strcmp(a->func->base.name, "count") == 0))
429 25765 : set_has_no_nil(e);
430 : return e;
431 : }
432 :
433 : sql_exp *
434 4904707 : exp_atom(allocator *sa, atom *a)
435 : {
436 4904707 : sql_exp *e = exp_create(sa, e_atom);
437 4903580 : if (e == NULL)
438 : return NULL;
439 4903580 : e->card = CARD_ATOM;
440 4903580 : e->tpe = a->tpe;
441 4903580 : e->l = a;
442 4903580 : if (!a->isnull)
443 4629239 : set_has_no_nil(e);
444 : return e;
445 : }
446 :
447 : sql_exp *
448 0 : exp_atom_max(allocator *sa, sql_subtype *tpe)
449 : {
450 0 : if (tpe->type->localtype == TYPE_bte) {
451 0 : return exp_atom_bte(sa, GDK_bte_max);
452 : } else if (tpe->type->localtype == TYPE_sht) {
453 0 : return exp_atom_sht(sa, GDK_sht_max);
454 : } else if (tpe->type->localtype == TYPE_int) {
455 0 : return exp_atom_int(sa, GDK_int_max);
456 : } else if (tpe->type->localtype == TYPE_lng) {
457 0 : return exp_atom_lng(sa, GDK_lng_max);
458 : #ifdef HAVE_HGE
459 : } else if (tpe->type->localtype == TYPE_hge) {
460 0 : return exp_atom_hge(sa, GDK_hge_max);
461 : #endif
462 : }
463 : return NULL;
464 : }
465 :
466 : sql_exp *
467 146470 : exp_atom_bool(allocator *sa, int b)
468 : {
469 146470 : sql_subtype bt;
470 :
471 146470 : sql_find_subtype(&bt, "boolean", 0, 0);
472 146537 : if (b)
473 98488 : return exp_atom(sa, atom_bool(sa, &bt, TRUE ));
474 : else
475 48049 : return exp_atom(sa, atom_bool(sa, &bt, FALSE ));
476 : }
477 :
478 : sql_exp *
479 0 : exp_atom_bte(allocator *sa, bte i)
480 : {
481 0 : sql_subtype it;
482 :
483 0 : sql_find_subtype(&it, "tinyint", 3, 0);
484 0 : return exp_atom(sa, atom_int(sa, &it, i ));
485 : }
486 :
487 : sql_exp *
488 0 : exp_atom_sht(allocator *sa, sht i)
489 : {
490 0 : sql_subtype it;
491 :
492 0 : sql_find_subtype(&it, "smallint", 5, 0);
493 0 : return exp_atom(sa, atom_int(sa, &it, i ));
494 : }
495 :
496 : sql_exp *
497 865915 : exp_atom_int(allocator *sa, int i)
498 : {
499 865915 : sql_subtype it;
500 :
501 865915 : sql_find_subtype(&it, "int", 9, 0);
502 866061 : return exp_atom(sa, atom_int(sa, &it, i ));
503 : }
504 :
505 : sql_exp *
506 16420 : exp_atom_lng(allocator *sa, lng i)
507 : {
508 16420 : sql_subtype it;
509 :
510 : #ifdef HAVE_HGE
511 16420 : sql_find_subtype(&it, "bigint", 18, 0);
512 : #else
513 : sql_find_subtype(&it, "bigint", 19, 0);
514 : #endif
515 16434 : return exp_atom(sa, atom_int(sa, &it, i ));
516 : }
517 :
518 : sql_exp *
519 16336 : exp_atom_oid(allocator *sa, oid i)
520 : {
521 16336 : sql_subtype it;
522 :
523 : #if SIZEOF_OID == SIZEOF_INT
524 : sql_find_subtype(&it, "oid", 31, 0);
525 : #else
526 16336 : sql_find_subtype(&it, "oid", 63, 0);
527 : #endif
528 16336 : return exp_atom(sa, atom_int(sa, &it, i ));
529 : }
530 :
531 : #ifdef HAVE_HGE
532 : sql_exp *
533 1 : exp_atom_hge(allocator *sa, hge i)
534 : {
535 1 : sql_subtype it;
536 :
537 1 : sql_find_subtype(&it, "hugeint", 39, 0);
538 1 : return exp_atom(sa, atom_int(sa, &it, i ));
539 : }
540 : #endif
541 :
542 : sql_exp *
543 0 : exp_atom_flt(allocator *sa, flt f)
544 : {
545 0 : sql_subtype it;
546 :
547 0 : sql_find_subtype(&it, "real", 24, 0);
548 0 : return exp_atom(sa, atom_float(sa, &it, (dbl)f ));
549 : }
550 :
551 : sql_exp *
552 0 : exp_atom_dbl(allocator *sa, dbl f)
553 : {
554 0 : sql_subtype it;
555 :
556 0 : sql_find_subtype(&it, "double", 53, 0);
557 0 : return exp_atom(sa, atom_float(sa, &it, (dbl)f ));
558 : }
559 :
560 : sql_exp *
561 85463 : exp_atom_str(allocator *sa, const char *s, sql_subtype *st)
562 : {
563 166341 : return exp_atom(sa, atom_string(sa, st, s?sa_strdup(sa, s):NULL));
564 : }
565 :
566 : sql_exp *
567 745404 : exp_atom_clob(allocator *sa, const char *s)
568 : {
569 745404 : sql_subtype clob;
570 :
571 745404 : sql_find_subtype(&clob, "varchar", 0, 0);
572 1489213 : return exp_atom(sa, atom_string(sa, &clob, s?sa_strdup(sa, s):NULL));
573 : }
574 :
575 : sql_exp *
576 268269 : exp_atom_ptr(allocator *sa, void *s)
577 : {
578 268269 : sql_subtype *t = sql_bind_localtype("ptr");
579 268269 : return exp_atom(sa, atom_ptr(sa, t, s));
580 : }
581 :
582 : sql_exp *
583 2164 : exp_atom_ref(allocator *sa, int i, sql_subtype *tpe)
584 : {
585 2164 : sql_exp *e = exp_create(sa, e_atom);
586 2164 : if (e == NULL)
587 : return NULL;
588 2164 : e->card = CARD_ATOM;
589 2164 : e->flag = i;
590 2164 : if (tpe)
591 2164 : e->tpe = *tpe;
592 : return e;
593 : }
594 :
595 : sql_exp *
596 108094 : exp_null(allocator *sa, sql_subtype *tpe)
597 : {
598 108094 : atom *a = atom_general(sa, tpe, NULL, 0);
599 108094 : return exp_atom(sa, a);
600 : }
601 :
602 : sql_exp *
603 2 : exp_zero(allocator *sa, sql_subtype *tpe)
604 : {
605 2 : atom *a = atom_zero_value(sa, tpe);
606 2 : return exp_atom(sa, a);
607 : }
608 :
609 : atom *
610 395 : exp_value(mvc *sql, sql_exp *e)
611 : {
612 395 : if (!e || e->type != e_atom)
613 : return NULL;
614 384 : if (e->l) { /* literal */
615 : return e->l;
616 0 : } else if (e->r) { /* param (ie not set) */
617 0 : sql_var_name *vname = (sql_var_name*) e->r;
618 :
619 0 : assert(e->flag != 0 || vname->sname); /* global variables must have a schema */
620 0 : sql_var *var = e->flag == 0 ? find_global_var(sql, mvc_bind_schema(sql, vname->sname), vname->name) :
621 0 : stack_find_var_at_level(sql, vname->name, e->flag);
622 0 : if (var)
623 0 : return &(var->var);
624 : }
625 : return NULL;
626 : }
627 :
628 : sql_exp *
629 123441 : exp_param_or_declared(allocator *sa, const char *sname, const char *name, sql_subtype *tpe, int frame)
630 : {
631 123441 : sql_var_name *vname;
632 123441 : sql_exp *e = exp_create(sa, e_atom);
633 123441 : if (e == NULL)
634 : return NULL;
635 :
636 123441 : e->r = sa_alloc(sa, sizeof(sql_var_name));
637 123441 : vname = (sql_var_name*) e->r;
638 123441 : vname->sname = sname;
639 123441 : vname->name = name;
640 123441 : e->card = CARD_ATOM;
641 123441 : e->flag = frame;
642 123441 : if (tpe)
643 123441 : e->tpe = *tpe;
644 : return e;
645 : }
646 :
647 : sql_exp *
648 209170 : exp_values(allocator *sa, list *exps)
649 : {
650 209170 : sql_exp *e = exp_create(sa, e_atom);
651 209217 : if (e == NULL)
652 : return NULL;
653 209217 : e->card = exps_card(exps);
654 209304 : e->f = exps;
655 209304 : return e;
656 : }
657 :
658 : list *
659 27861 : exp_get_values(sql_exp *e)
660 : {
661 27861 : if (is_atom(e->type) && e->f)
662 : return e->f;
663 : return NULL;
664 : }
665 :
666 : list *
667 40769 : exp_types(allocator *sa, list *exps)
668 : {
669 40769 : list *l = sa_list(sa);
670 :
671 40769 : if (exps)
672 91242 : for (node *n = exps->h; n; n = n->next)
673 50473 : list_append(l, exp_subtype(n->data));
674 40769 : return l;
675 : }
676 :
677 : int
678 1045066 : have_nil(list *exps)
679 : {
680 1045066 : int has_nil = 0;
681 :
682 1045066 : if (exps)
683 2635379 : for (node *n = exps->h; n && !has_nil; n = n->next) {
684 1590313 : sql_exp *e = n->data;
685 1590313 : has_nil |= has_nil(e);
686 : }
687 1045066 : return has_nil;
688 : }
689 :
690 : int
691 212 : have_semantics(list *exps)
692 : {
693 212 : int has_semantics = 0;
694 :
695 212 : if (exps)
696 65 : for (node *n = exps->h; n && !has_semantics; n = n->next) {
697 33 : sql_exp *e = n->data;
698 66 : has_semantics |= is_compare(e->type) && is_semantics(e);
699 : }
700 212 : return has_semantics;
701 : }
702 :
703 : sql_exp *
704 6776519 : exp_column(allocator *sa, const char *rname, const char *cname, sql_subtype *t, unsigned int card, int has_nils, int unique, int intern)
705 : {
706 6776519 : sql_exp *e = exp_create(sa, e_column);
707 :
708 6776527 : if (e == NULL)
709 : return NULL;
710 6776527 : assert(cname);
711 6776527 : e->card = card;
712 6776527 : e->alias.name = cname;
713 6776527 : e->alias.rname = rname;
714 6776527 : e->r = (char*)e->alias.name;
715 6776527 : e->l = (char*)e->alias.rname;
716 6776527 : if (t)
717 6776129 : e->tpe = *t;
718 6776527 : if (!has_nils)
719 1945522 : set_has_no_nil(e);
720 6776527 : if (unique)
721 908427 : set_unique(e);
722 6776527 : if (intern)
723 578692 : set_intern(e);
724 : return e;
725 : }
726 :
727 : sql_exp *
728 9773485 : exp_propagate(allocator *sa, sql_exp *ne, sql_exp *oe)
729 : {
730 9773485 : if (has_label(oe) &&
731 517961 : (oe->alias.rname == ne->alias.rname || (oe->alias.rname && ne->alias.rname && strcmp(oe->alias.rname, ne->alias.rname) == 0)) &&
732 510757 : (oe->alias.name == ne->alias.name || (oe->alias.name && ne->alias.name && strcmp(oe->alias.name, ne->alias.name) == 0)))
733 510757 : ne->alias.label = oe->alias.label;
734 9773485 : if (is_intern(oe))
735 314544 : set_intern(ne);
736 9773485 : if (is_anti(oe))
737 2291 : set_anti(ne);
738 9773485 : if (is_semantics(oe))
739 654423 : set_semantics(ne);
740 9773485 : if (is_any(oe))
741 44 : set_any(ne);
742 9773485 : if (is_symmetric(oe))
743 16 : set_symmetric(ne);
744 9773485 : if (is_ascending(oe))
745 19724 : set_ascending(ne);
746 9773485 : if (nulls_last(oe))
747 4096 : set_nulls_last(ne);
748 9773485 : if (need_distinct(oe))
749 670 : set_distinct(ne);
750 9773485 : if (zero_if_empty(oe))
751 0 : set_zero_if_empty(ne);
752 9773485 : if (need_no_nil(oe))
753 79563 : set_no_nil(ne);
754 9773485 : if (!has_nil(oe))
755 5731060 : set_has_no_nil(ne);
756 9773485 : if (has_nil(oe))
757 4042426 : set_has_nil(ne);
758 9773485 : if (is_unique(oe))
759 1087277 : set_unique(ne);
760 9773485 : if (is_basecol(oe))
761 8085597 : set_basecol(ne);
762 9773485 : ne->p = prop_copy(sa, oe->p);
763 9773492 : return ne;
764 : }
765 :
766 : static sql_exp *
767 6626685 : exp_ref_by_label(allocator *sa, sql_exp *o)
768 : {
769 6626685 : sql_exp *e = exp_create(sa, e_column);
770 :
771 6626697 : if (e == NULL)
772 : return NULL;
773 6626697 : e->card = o->card;
774 6626697 : e->alias = o->alias;
775 6626697 : assert(e->alias.label);
776 6626697 : e->r = (char*)e->alias.name;
777 6626697 : e->l = (char*)e->alias.rname;
778 6626697 : e->nid = o->alias.label;
779 6626697 : assert(e->nid);
780 6626697 : sql_subtype *t = exp_subtype(o);
781 6626698 : if (t)
782 6626583 : e->tpe = *t;
783 6626698 : if (!has_nil(o))
784 4040147 : set_has_no_nil(e);
785 6626698 : if (has_nil(o))
786 2586552 : set_has_nil(e);
787 6626698 : if (is_unique(o))
788 860709 : set_unique(e);
789 6626698 : if (is_intern(o))
790 279415 : set_intern(e);
791 6626698 : return exp_propagate(sa, e, o);
792 : }
793 :
794 : sql_exp *
795 6626685 : exp_ref(mvc *sql, sql_exp *e)
796 : {
797 6626685 : if (!has_label(e) && !exp_name(e))
798 2258 : exp_label(sql->sa, e, ++sql->label);
799 6626688 : if (e->alias.label)
800 6626688 : return exp_ref_by_label(sql->sa, e);
801 0 : sql_exp *ne = exp_propagate(sql->sa, exp_column(sql->sa, exp_relname(e), exp_name(e), exp_subtype(e), exp_card(e), has_nil(e), is_unique(e), is_intern(e)), e);
802 0 : if (ne) {
803 0 : ne->nid = e->alias.label;
804 0 : assert(ne->nid);
805 0 : assert(!ne->nid || ne->alias.name);
806 0 : ne->alias.label = ne->nid;
807 : }
808 : return ne;
809 : }
810 :
811 : sql_exp *
812 13868 : exp_ref_save(mvc *sql, sql_exp *e)
813 : {
814 13868 : if (e->type == e_column)
815 : return e;
816 10274 : if (is_atom(e->type))
817 5195 : return exp_copy(sql, e);
818 5079 : if (!e->alias.label || !exp_name(e))
819 8 : exp_label(sql->sa, e, ++sql->label);
820 5079 : if (e->type != e_column) /* ref as referenced within the (same) rank expression */
821 5079 : e->ref = 1;
822 5079 : sql_exp *ne = exp_ref(sql, e);
823 5079 : if (ne && is_freevar(e))
824 0 : set_freevar(ne, is_freevar(e)-1);
825 : return ne;
826 : }
827 :
828 : sql_exp *
829 2056688 : exp_alias(mvc *sql, const char *arname, const char *acname, const char *org_rname, const char *org_cname, sql_subtype *t, unsigned int card, int has_nils, int unique, int intern)
830 : {
831 2056688 : sql_exp *e = exp_column(sql->sa, org_rname, org_cname, t, card, has_nils, unique, intern);
832 :
833 2057259 : if (e == NULL)
834 : return NULL;
835 2057259 : assert(acname && org_cname);
836 2057259 : exp_setname(sql, e, (arname)?arname:org_rname, acname);
837 2057259 : return e;
838 : }
839 :
840 : sql_exp *
841 0 : exp_alias_ref(mvc *sql, sql_exp *e)
842 : {
843 0 : const char *tname = exp_relname(e);
844 0 : const char *cname = exp_name(e);
845 :
846 0 : if (!has_label(e))
847 0 : exp_label(sql->sa, e, ++sql->label);
848 0 : sql_exp *ne = exp_ref(sql, e);
849 0 : if (ne == NULL)
850 : return NULL;
851 0 : exp_setname(sql, ne, tname, cname);
852 0 : return ne;
853 : }
854 :
855 : sql_exp *
856 16148 : exp_set(allocator *sa, const char *sname, const char *name, sql_exp *val, int level)
857 : {
858 16148 : sql_exp *e = exp_create(sa, e_psm);
859 :
860 16148 : if (e == NULL)
861 : return NULL;
862 16148 : e->alias.rname = sname;
863 16148 : e->alias.name = name;
864 16148 : e->l = val;
865 16148 : e->flag = PSM_SET + SET_PSM_LEVEL(level);
866 16148 : return e;
867 : }
868 :
869 : sql_exp *
870 9523 : exp_var(allocator *sa, const char *sname, const char *name, sql_subtype *type, int level)
871 : {
872 9523 : sql_exp *e = exp_create(sa, e_psm);
873 :
874 9523 : if (e == NULL)
875 : return NULL;
876 9523 : e->alias.rname = sname;
877 9523 : e->alias.name = name;
878 9523 : e->tpe = *type;
879 9523 : e->flag = PSM_VAR + SET_PSM_LEVEL(level);
880 9523 : return e;
881 : }
882 :
883 : sql_exp *
884 119 : exp_table(allocator *sa, const char *name, sql_table *t, int level)
885 : {
886 119 : sql_exp *e = exp_create(sa, e_psm);
887 :
888 119 : if (e == NULL)
889 : return NULL;
890 119 : e->alias.rname = NULL;
891 119 : e->alias.name = name;
892 119 : e->f = t;
893 119 : e->flag = PSM_VAR + SET_PSM_LEVEL(level);
894 119 : return e;
895 : }
896 :
897 : sql_exp *
898 23338 : exp_return(allocator *sa, sql_exp *val, int level)
899 : {
900 23338 : sql_exp *e = exp_create(sa, e_psm);
901 :
902 23338 : if (e == NULL)
903 : return NULL;
904 23338 : e->l = val;
905 23338 : e->flag = PSM_RETURN + SET_PSM_LEVEL(level);
906 23338 : return e;
907 : }
908 :
909 : sql_exp *
910 1019 : exp_while(allocator *sa, sql_exp *cond, list *stmts)
911 : {
912 1019 : sql_exp *e = exp_create(sa, e_psm);
913 :
914 1019 : if (e == NULL)
915 : return NULL;
916 1019 : e->l = cond;
917 1019 : e->r = stmts;
918 1019 : e->flag = PSM_WHILE;
919 1019 : return e;
920 : }
921 :
922 : sql_exp *
923 11661 : exp_if(allocator *sa, sql_exp *cond, list *if_stmts, list *else_stmts)
924 : {
925 11661 : sql_exp *e = exp_create(sa, e_psm);
926 :
927 11661 : if (e == NULL)
928 : return NULL;
929 11661 : e->l = cond;
930 11661 : e->r = if_stmts;
931 11661 : e->f = else_stmts;
932 11661 : e->flag = PSM_IF;
933 11661 : return e;
934 : }
935 :
936 : sql_exp *
937 78204 : exp_rel(mvc *sql, sql_rel *rel)
938 : {
939 78204 : sql_exp *e = exp_create(sql->sa, e_psm);
940 :
941 78204 : if (e == NULL)
942 : return NULL;
943 78204 : e->l = rel;
944 78204 : e->flag = PSM_REL;
945 78204 : e->card = is_single(rel)?CARD_ATOM:rel->card;
946 78204 : assert(rel);
947 78204 : if (is_topn(rel->op))
948 3 : rel = rel->l;
949 78204 : if (is_project(rel->op)) {
950 59748 : sql_exp *last = rel->exps->t->data;
951 59748 : sql_subtype *t = exp_subtype(last);
952 59748 : e->tpe = t ? *t : (sql_subtype) {0};
953 : }
954 : return e;
955 : }
956 :
957 : sql_exp *
958 157 : exp_exception(allocator *sa, sql_exp *cond, const char *error_message)
959 : {
960 157 : sql_exp *e = exp_create(sa, e_psm);
961 :
962 157 : if (e == NULL)
963 : return NULL;
964 157 : e->l = cond;
965 157 : e->r = sa_strdup(sa, error_message);
966 157 : e->flag = PSM_EXCEPTION;
967 157 : return e;
968 : }
969 :
970 : /* Set a name (alias) for the expression, such that we can refer
971 : to this expression by this simple name.
972 : */
973 : void
974 3586513 : exp_setname(mvc *sql, sql_exp *e, const char *rname, const char *name )
975 : {
976 3586513 : assert(name || rname);
977 3586513 : e->alias.label = -(sql->nid++);
978 : //e->alias.label = 0;
979 3586513 : if (name)
980 3424484 : e->alias.name = name;
981 3586513 : e->alias.rname = (rname);
982 3586513 : }
983 :
984 : void
985 162152 : noninternexp_setname(mvc *sql, sql_exp *e, const char *rname, const char *name )
986 : {
987 162152 : if (!is_intern(e))
988 162150 : exp_setname(sql, e, rname, name);
989 162152 : }
990 :
991 : void
992 648204 : exp_setalias(sql_exp *e, int label, const char *rname, const char *name )
993 : {
994 648204 : e->alias.label = label;
995 648204 : assert(e->alias.label);
996 648204 : e->alias.name = name;
997 648204 : e->alias.rname = rname;
998 648204 : }
999 :
1000 : void
1001 4316476 : exp_prop_alias(allocator *sa, sql_exp *e, sql_exp *oe )
1002 : {
1003 4316476 : e->ref = oe->ref;
1004 4316476 : if (oe->alias.name == NULL && exp_has_rel(oe)) {
1005 7756 : sql_rel *r = exp_rel_get_rel(sa, oe);
1006 7756 : if (!is_project(r->op))
1007 : return ;
1008 7756 : oe = r->exps->t->data;
1009 : }
1010 4316476 : e->alias = oe->alias;
1011 : }
1012 :
1013 : str
1014 1995291 : number2name(str s, int len, int i)
1015 : {
1016 1995291 : s[--len] = 0;
1017 6083850 : while(i>0) {
1018 4088559 : s[--len] = '0' + (i & 7);
1019 4088559 : i >>= 3;
1020 : }
1021 1995291 : s[--len] = '%';
1022 1995291 : return s + len;
1023 : }
1024 :
1025 : void
1026 0 : exp_setrelname(allocator *sa, sql_exp *e, int nr)
1027 : {
1028 0 : char name[16], *nme;
1029 :
1030 0 : nme = number2name(name, sizeof(name), nr);
1031 0 : e->alias.label = 0;
1032 0 : e->alias.rname = sa_strdup(sa, nme);
1033 0 : }
1034 :
1035 : char *
1036 1934158 : make_label(allocator *sa, int nr)
1037 : {
1038 1934158 : char name[16], *nme;
1039 :
1040 1934158 : nme = number2name(name, sizeof(name), nr);
1041 1934601 : return sa_strdup(sa, nme);
1042 : }
1043 :
1044 : sql_exp*
1045 1924447 : exp_label(allocator *sa, sql_exp *e, int nr)
1046 : {
1047 1924447 : assert(nr > 0);
1048 : //assert (e->alias.label == 0);
1049 1924447 : e->alias.label = nr;
1050 1924447 : e->alias.rname = e->alias.name = make_label(sa, nr);
1051 1925478 : return e;
1052 : }
1053 :
1054 : list*
1055 52086 : exps_label(mvc *sql, list *exps)
1056 : {
1057 52086 : if (!exps)
1058 : return NULL;
1059 :
1060 52086 : int nr = sql->label+1;
1061 52086 : sql->label += list_length(exps);
1062 119922 : for (node *n = exps->h; n; n = n->next)
1063 67836 : n->data = exp_label(sql->sa, n->data, nr++);
1064 52086 : list_hash_clear(exps);
1065 52086 : return exps;
1066 : }
1067 :
1068 : void
1069 20905 : exp_swap( sql_exp *e )
1070 : {
1071 20905 : sql_exp *s = e->l;
1072 :
1073 20905 : e->l = e->r;
1074 20905 : e->r = s;
1075 20905 : e->flag = swap_compare((comp_type)e->flag);
1076 20905 : assert(!e->f);
1077 20905 : }
1078 :
1079 : sql_subtype *
1080 33924965 : exp_subtype( sql_exp *e )
1081 : {
1082 33925013 : switch(e->type) {
1083 7880810 : case e_atom: {
1084 7880810 : if (e->l) {
1085 7153436 : atom *a = e->l;
1086 7153436 : return atom_type(a);
1087 727374 : } else if (e->tpe.type) { /* atom reference */
1088 725515 : return &e->tpe;
1089 1859 : } else if (e->f) {
1090 48 : list *vals = exp_get_values(e);
1091 48 : if (!list_empty(vals))
1092 48 : return exp_subtype(vals->h->data);
1093 : }
1094 : break;
1095 : }
1096 21372242 : case e_convert:
1097 : case e_column:
1098 21372242 : if (e->tpe.type)
1099 21372131 : return &e->tpe;
1100 : break;
1101 4538646 : case e_aggr:
1102 : case e_func: {
1103 4538646 : if (e->f) {
1104 4538646 : sql_subfunc *f = e->f;
1105 4538646 : if (f->res && list_length(f->res) == 1)
1106 4528109 : return f->res->h->data;
1107 : }
1108 : return NULL;
1109 : }
1110 7237 : case e_cmp:
1111 7237 : return sql_bind_localtype("bit");
1112 126078 : case e_psm:
1113 126078 : if (e->tpe.type)
1114 126063 : return &e->tpe;
1115 : /* fall through */
1116 : default:
1117 : return NULL;
1118 : }
1119 : return NULL;
1120 : }
1121 :
1122 : const char *
1123 34363296 : exp_name( sql_exp *e )
1124 : {
1125 34377173 : if (e->alias.name)
1126 : return e->alias.name;
1127 1496965 : if (e->type == e_convert && e->l)
1128 : return exp_name(e->l);
1129 1492978 : if (e->type == e_psm && e->l) { /* subquery return name of last expression */
1130 9890 : sql_rel *r = e->l;
1131 9890 : if (is_project(r->op))
1132 9890 : return exp_name(r->exps->t->data);
1133 : }
1134 : return NULL;
1135 : }
1136 :
1137 : const char *
1138 3805893 : exp_relname( sql_exp *e )
1139 : {
1140 3805905 : if (e->alias.rname)
1141 : return e->alias.rname;
1142 454774 : if (!e->alias.name && e->type == e_convert && e->l)
1143 : return exp_relname(e->l);
1144 454762 : if (!e->alias.name && e->type == e_psm && e->l) { /* subquery return name of last expression */
1145 0 : sql_rel *r = e->l;
1146 0 : if (is_project(r->op))
1147 0 : return exp_relname(r->exps->t->data);
1148 : }
1149 : return NULL;
1150 : }
1151 :
1152 : const char *
1153 17070 : exp_find_rel_name(sql_exp *e)
1154 : {
1155 17070 : if (e->alias.rname)
1156 : return e->alias.rname;
1157 467 : switch(e->type) {
1158 : case e_column:
1159 : break;
1160 0 : case e_convert:
1161 0 : return exp_find_rel_name(e->l);
1162 : default:
1163 : return NULL;
1164 : }
1165 : return NULL;
1166 : }
1167 :
1168 : unsigned int
1169 1834684 : exp_card( sql_exp *e )
1170 : {
1171 1834684 : return e->card;
1172 : }
1173 :
1174 : unsigned int
1175 1520647 : exp_get_label( sql_exp *e )
1176 : {
1177 1520659 : if (e->alias.label)
1178 1520647 : return e->alias.label;
1179 12 : if (e->type == e_convert && e->l)
1180 : return exp_get_label(e->l);
1181 0 : if (e->type == e_psm && e->l) { /* subquery return name of last expression */
1182 0 : sql_rel *r = e->l;
1183 0 : if (is_project(r->op))
1184 0 : return exp_get_label(r->exps->t->data);
1185 : }
1186 : return 0;
1187 : }
1188 :
1189 :
1190 : const char *
1191 0 : exp_func_name( sql_exp *e )
1192 : {
1193 0 : if (e->type == e_func && e->f) {
1194 0 : sql_subfunc *f = e->f;
1195 0 : return f->func->base.name;
1196 : }
1197 0 : if (e->alias.name)
1198 : return e->alias.name;
1199 0 : if (e->type == e_convert && e->l)
1200 0 : return exp_name(e->l);
1201 : return NULL;
1202 : }
1203 :
1204 : int
1205 48968578 : exp_cmp( sql_exp *e1, sql_exp *e2)
1206 : {
1207 48968578 : return (e1 == e2)?0:-1;
1208 : }
1209 :
1210 : int
1211 230286 : exp_equal( sql_exp *e1, sql_exp *e2)
1212 : {
1213 230286 : if (e1 == e2)
1214 : return 0;
1215 230286 : if (e1->alias.label && e1->alias.label == e2->alias.label)
1216 3743 : return 0;
1217 : return -1;
1218 : if (e1->alias.rname && e2->alias.rname && strcmp(e1->alias.rname, e2->alias.rname) == 0)
1219 : if (e1->alias.name && e2->alias.name && strcmp(e1->alias.name, e2->alias.name) == 0)
1220 : return 0;
1221 : if (!e1->alias.rname && !e2->alias.rname && /*has_label(e1) &&*/ e1->alias.label == e2->alias.label && e1->alias.name && e2->alias.name)
1222 : return strcmp(e1->alias.name, e2->alias.name);
1223 : return -1;
1224 : }
1225 :
1226 : int
1227 48968451 : exp_match( sql_exp *e1, sql_exp *e2)
1228 : {
1229 48968451 : if (exp_cmp(e1, e2) == 0)
1230 : return 1;
1231 48722037 : if (e1->type == e2->type && e1->type == e_column) {
1232 24400671 : if (e1->nid && e1->nid == e2->nid)
1233 : return 1;
1234 23189631 : if (e1->alias.label != e2->alias.label || !e1->alias.label || !e2->alias.label)
1235 : return 0;
1236 : return 1;
1237 : }
1238 24321366 : if (e1->type == e2->type && e1->type == e_func) {
1239 8534570 : if (is_identity(e1, NULL) && is_identity(e2, NULL)) {
1240 0 : list *args1 = e1->l;
1241 0 : list *args2 = e2->l;
1242 :
1243 0 : if (list_length(args1) == list_length(args2) && list_length(args1) == 1) {
1244 0 : sql_exp *ne1 = args1->h->data;
1245 0 : sql_exp *ne2 = args2->h->data;
1246 :
1247 0 : if (exp_match(ne1,ne2))
1248 : return 1;
1249 : }
1250 : }
1251 : }
1252 : return 0;
1253 : }
1254 :
1255 : /* list already contains matching expression */
1256 : sql_exp*
1257 163390 : exps_find_exp( list *l, sql_exp *e)
1258 : {
1259 163390 : node *n;
1260 :
1261 163390 : if (!l || !l->h)
1262 : return NULL;
1263 :
1264 397392 : for(n=l->h; n; n = n->next) {
1265 357301 : if (exp_match(n->data, e) || exp_refers(n->data, e))
1266 110546 : return n->data;
1267 : }
1268 : return NULL;
1269 : }
1270 :
1271 : /* c refers to the parent p */
1272 : int
1273 3495801 : exp_refers( sql_exp *p, sql_exp *c)
1274 : {
1275 3495801 : if (c->type == e_column && c->nid)
1276 398498 : return c->nid == p->alias.label;
1277 : return 0;
1278 : }
1279 :
1280 : sql_exp*
1281 218 : exps_refers(sql_exp *p, list *l)
1282 : {
1283 218 : node *n;
1284 :
1285 218 : if (!l || !l->h)
1286 : return NULL;
1287 :
1288 532 : for(n=l->h; n; n = n->next) {
1289 318 : if (exp_refers(p, n->data))
1290 4 : return n->data;
1291 : }
1292 : return NULL;
1293 : }
1294 :
1295 : int
1296 0 : exp_match_col_exps( sql_exp *e, list *l)
1297 : {
1298 0 : node *n;
1299 :
1300 0 : for(n=l->h; n; n = n->next) {
1301 0 : sql_exp *re = n->data;
1302 0 : sql_exp *re_r = re->r;
1303 :
1304 0 : if (re->type == e_cmp && re->flag == cmp_or)
1305 0 : return exp_match_col_exps(e, re->l) &&
1306 0 : exp_match_col_exps(e, re->r);
1307 :
1308 0 : if (re->type != e_cmp || !re_r || re_r->card != 1 || !exp_match_exp(e, re->l))
1309 0 : return 0;
1310 : }
1311 : return 1;
1312 : }
1313 :
1314 : int
1315 10818 : exps_match_col_exps( sql_exp *e1, sql_exp *e2)
1316 : {
1317 10818 : sql_exp *e1_r = e1->r;
1318 10818 : sql_exp *e2_r = e2->r;
1319 :
1320 10818 : if (e1->type != e_cmp || e2->type != e_cmp)
1321 : return 0;
1322 :
1323 10747 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1324 5995 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1325 5068 : return exp_match_exp(e1->l, e2->l);
1326 :
1327 5679 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1328 927 : (e2->flag == cmp_in || e2->flag == cmp_notin))
1329 845 : return exp_match_exp(e1->l, e2->l);
1330 4834 : if ((e1->flag == cmp_in || e1->flag == cmp_notin) &&
1331 2331 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1332 1579 : return exp_match_exp(e1->l, e2->l);
1333 :
1334 3255 : if ((e1->flag == cmp_in || e1->flag == cmp_notin) &&
1335 752 : (e2->flag == cmp_in || e2->flag == cmp_notin))
1336 752 : return exp_match_exp(e1->l, e2->l);
1337 :
1338 2503 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1339 82 : e2->flag == cmp_or)
1340 0 : return exp_match_col_exps(e1->l, e2->l) &&
1341 0 : exp_match_col_exps(e1->l, e2->r);
1342 :
1343 2503 : if (e1->flag == cmp_or &&
1344 0 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1345 0 : return exp_match_col_exps(e2->l, e1->l) &&
1346 0 : exp_match_col_exps(e2->l, e1->r);
1347 :
1348 2503 : if (e1->flag == cmp_or && e2->flag == cmp_or) {
1349 0 : list *l = e1->l, *r = e1->r;
1350 0 : sql_exp *el = l->h->data;
1351 0 : sql_exp *er = r->h->data;
1352 :
1353 0 : return list_length(l) == 1 && list_length(r) == 1 &&
1354 0 : exps_match_col_exps(el, e2) &&
1355 0 : exps_match_col_exps(er, e2);
1356 : }
1357 : return 0;
1358 : }
1359 :
1360 : int
1361 47556 : exp_match_list( list *l, list *r)
1362 : {
1363 47556 : node *n, *m;
1364 47556 : char *lu, *ru;
1365 47556 : int lc = 0, rc = 0, match = 0;
1366 :
1367 47556 : if (!l || !r)
1368 0 : return l == r;
1369 47556 : if (list_length(l) != list_length(r) || list_length(l) == 0 || list_length(r) == 0)
1370 601 : return 0;
1371 46955 : if (list_length(l) > 10 || list_length(r) > 10)
1372 5 : return 0;/* to expensive */
1373 :
1374 46950 : lu = ZNEW_ARRAY(char, list_length(l));
1375 46950 : ru = ZNEW_ARRAY(char, list_length(r));
1376 46950 : if (!lu || !ru) {
1377 0 : _DELETE(lu);
1378 0 : _DELETE(ru);
1379 0 : return 0;
1380 : }
1381 137761 : for (n = l->h, lc = 0; n; n = n->next, lc++) {
1382 90811 : sql_exp *le = n->data;
1383 :
1384 270310 : for ( m = r->h, rc = 0; m; m = m->next, rc++) {
1385 179499 : sql_exp *re = m->data;
1386 :
1387 179499 : if (!ru[rc] && exp_match_exp(le,re)) {
1388 6715 : lu[lc] = 1;
1389 6715 : ru[rc] = 1;
1390 6715 : match = 1;
1391 : }
1392 : }
1393 : }
1394 54112 : for (n = l->h, lc = 0; n && match; n = n->next, lc++)
1395 7162 : if (!lu[lc])
1396 1274 : match = 0;
1397 52360 : for (n = r->h, rc = 0; n && match; n = n->next, rc++)
1398 5410 : if (!ru[rc])
1399 0 : match = 0;
1400 46950 : _DELETE(lu);
1401 46950 : _DELETE(ru);
1402 46950 : return match;
1403 : }
1404 :
1405 : static int
1406 2368629 : exps_equal( list *l, list *r)
1407 : {
1408 2368629 : node *n, *m;
1409 :
1410 2368629 : if (!l || !r)
1411 50123 : return l == r;
1412 2318506 : if (list_length(l) != list_length(r))
1413 : return 0;
1414 3408189 : for (n = l->h, m = r->h; n && m; n = n->next, m = m->next) {
1415 3362027 : sql_exp *le = n->data, *re = m->data;
1416 :
1417 3362027 : if (!exp_match_exp(le,re))
1418 : return 0;
1419 : }
1420 : return 1;
1421 : }
1422 :
1423 : int
1424 45389395 : exp_match_exp_semantics( sql_exp *e1, sql_exp *e2, bool semantics)
1425 : {
1426 45389395 : if (exp_match(e1, e2))
1427 : return 1;
1428 :
1429 44195780 : if (is_ascending(e1) != is_ascending(e2) ||
1430 44195776 : nulls_last(e1) != nulls_last(e2) ||
1431 44195776 : zero_if_empty(e1) != zero_if_empty(e2) ||
1432 44195776 : need_no_nil(e1) != need_no_nil(e2) ||
1433 44019228 : is_anti(e1) != is_anti(e2) ||
1434 44015388 : (semantics && is_semantics(e1) != is_semantics(e2)) ||
1435 33033636 : (semantics && is_any(e1) != is_any(e2)) ||
1436 33033727 : is_symmetric(e1) != is_symmetric(e2) ||
1437 33033710 : is_unique(e1) != is_unique(e2) ||
1438 : need_distinct(e1) != need_distinct(e2))
1439 : return 0;
1440 :
1441 32451620 : if (e1->type == e2->type) {
1442 24274756 : switch(e1->type) {
1443 346509 : case e_cmp:
1444 579806 : if (e1->flag == e2->flag && !is_complex_exp(e1->flag) &&
1445 237562 : exp_match_exp(e1->l, e2->l) && exp_match_exp(e1->r, e2->r) &&
1446 1010 : ((!e1->f && !e2->f) || (e1->f && e2->f && exp_match_exp(e1->f, e2->f))))
1447 1003 : return 1;
1448 348978 : else if (e1->flag == e2->flag && e1->flag == cmp_or &&
1449 3483 : exp_match_list(e1->l, e2->l) && exp_match_list(e1->r, e2->r))
1450 : return 1;
1451 345501 : else if (e1->flag == e2->flag &&
1452 242726 : (e1->flag == cmp_in || e1->flag == cmp_notin) &&
1453 3454 : exp_match_exp(e1->l, e2->l) && exp_match_list(e1->r, e2->r))
1454 : return 1;
1455 574639 : else if (e1->flag == e2->flag && (e1->flag == cmp_equal || e1->flag == cmp_notequal) &&
1456 229179 : exp_match_exp(e1->l, e2->r) && exp_match_exp(e1->r, e2->l))
1457 : return 1; /* = and <> operations are reflective, so exp_match_exp can be called crossed */
1458 : break;
1459 290684 : case e_convert:
1460 351655 : if (!subtype_cmp(exp_totype(e1), exp_totype(e2)) &&
1461 91290 : !subtype_cmp(exp_fromtype(e1), exp_fromtype(e2)) &&
1462 30319 : exp_match_exp(e1->l, e2->l))
1463 : return 1;
1464 : break;
1465 57165 : case e_aggr:
1466 93389 : if (!subfunc_cmp(e1->f, e2->f) && /* equal aggregation*/
1467 36224 : exps_equal(e1->l, e2->l))
1468 : return 1;
1469 : break;
1470 4338100 : case e_func: {
1471 4338100 : sql_subfunc *e1f = (sql_subfunc*) e1->f;
1472 4338100 : const char *sname = e1f->func->s ? e1f->func->s->base.name : NULL;
1473 4338100 : int (*comp)(list*, list*) = is_commutative(sname, e1f->func->base.name) ? exp_match_list : exps_equal;
1474 :
1475 8676200 : if (!e1f->func->side_effect &&
1476 6665533 : !subfunc_cmp(e1f, e2->f) && /* equal functions */
1477 2376001 : comp(e1->l, e2->l) &&
1478 : /* optional order by expressions */
1479 48568 : exps_equal(e1->r, e2->r))
1480 : return 1;
1481 : } break;
1482 1051179 : case e_atom:
1483 1051179 : if (e1->l && e2->l && !atom_cmp(e1->l, e2->l))
1484 : return 1;
1485 1010061 : if (e1->f && e2->f && exps_equal(e1->f, e2->f))
1486 : return 1;
1487 1010060 : if (e1->r && e2->r && e1->flag == e2->flag && !subtype_cmp(&e1->tpe, &e2->tpe)) {
1488 54 : sql_var_name *v1 = (sql_var_name*) e1->r, *v2 = (sql_var_name*) e2->r;
1489 54 : if (((!v1->sname && !v2->sname) || (v1->sname && v2->sname && strcmp(v1->sname, v2->sname) == 0)) &&
1490 54 : ((!v1->name && !v2->name) || (v1->name && v2->name && strcmp(v1->name, v2->name) == 0)))
1491 : return 1;
1492 : }
1493 1010060 : if (!e1->l && !e1->r && !e1->f && !e2->l && !e2->r && !e2->f && e1->flag == e2->flag && !subtype_cmp(&e1->tpe, &e2->tpe))
1494 : return 1;
1495 : break;
1496 : default:
1497 : break;
1498 : }
1499 : }
1500 : return 0;
1501 : }
1502 :
1503 : int
1504 45097266 : exp_match_exp( sql_exp *e1, sql_exp *e2)
1505 : {
1506 45097266 : return exp_match_exp_semantics( e1, e2, true);
1507 : }
1508 :
1509 : sql_exp *
1510 144797 : exps_any_match(list *l, sql_exp *e)
1511 : {
1512 144797 : if (!l)
1513 : return NULL;
1514 562782 : for (node *n = l->h; n ; n = n->next) {
1515 510169 : sql_exp *ne = (sql_exp *) n->data;
1516 510169 : if (exp_match_exp(ne, e))
1517 92184 : return ne;
1518 : }
1519 : return NULL;
1520 : }
1521 :
1522 : static int
1523 24 : exps_are_joins( list *l )
1524 : {
1525 24 : if (l)
1526 52 : for (node *n = l->h; n; n = n->next) {
1527 28 : sql_exp *e = n->data;
1528 :
1529 28 : if (exp_is_join_exp(e))
1530 : return -1;
1531 : }
1532 : return 0;
1533 : }
1534 :
1535 : int
1536 266 : exp_is_join_exp(sql_exp *e)
1537 : {
1538 266 : if (exp_is_join(e, NULL) == 0)
1539 : return 0;
1540 24 : if (e->type == e_cmp && e->flag == cmp_or && e->card >= CARD_AGGR)
1541 12 : if (exps_are_joins(e->l) == 0 && exps_are_joins(e->r) == 0)
1542 : return 0;
1543 : return -1;
1544 : }
1545 :
1546 : static int
1547 771389 : exp_is_complex_select( sql_exp *e )
1548 : {
1549 792373 : switch (e->type) {
1550 457 : case e_atom: {
1551 457 : if (e->f) {
1552 0 : int r = (e->card == CARD_ATOM);
1553 0 : list *l = e->f;
1554 :
1555 0 : if (r)
1556 0 : for (node *n = l->h; n && !r; n = n->next)
1557 0 : r |= exp_is_complex_select(n->data);
1558 0 : return r;
1559 : }
1560 : return 0;
1561 : }
1562 20984 : case e_convert:
1563 20984 : return exp_is_complex_select(e->l);
1564 2043 : case e_func:
1565 : case e_aggr:
1566 : {
1567 2043 : int r = (e->card == CARD_ATOM);
1568 2043 : list *l = e->l;
1569 :
1570 2043 : if (r && l)
1571 39 : for (node *n = l->h; n && !r; n = n->next)
1572 0 : r |= exp_is_complex_select(n->data);
1573 : return r;
1574 : }
1575 : case e_psm:
1576 : return 1;
1577 : case e_column:
1578 : case e_cmp:
1579 : default:
1580 : return 0;
1581 : }
1582 : }
1583 :
1584 : static int
1585 385700 : complex_select(sql_exp *e)
1586 : {
1587 385700 : sql_exp *l = e->l, *r = e->r;
1588 :
1589 385700 : if (exp_is_complex_select(l) || exp_is_complex_select(r))
1590 39 : return 1;
1591 : return 0;
1592 : }
1593 :
1594 : static int
1595 929 : distinct_rel(sql_exp *e, const char **rname)
1596 : {
1597 1083 : const char *e_rname = NULL;
1598 :
1599 1083 : switch(e->type) {
1600 651 : case e_column:
1601 651 : e_rname = exp_relname(e);
1602 :
1603 651 : if (*rname && e_rname && strcmp(*rname, e_rname) == 0)
1604 : return 1;
1605 504 : if (!*rname) {
1606 321 : *rname = e_rname;
1607 321 : return 1;
1608 : }
1609 : break;
1610 145 : case e_aggr:
1611 : case e_func:
1612 145 : if (e->l) {
1613 145 : int m = 1;
1614 145 : list *l = e->l;
1615 145 : node *n;
1616 :
1617 438 : for(n=l->h; n && m; n = n->next) {
1618 293 : sql_exp *ae = n->data;
1619 :
1620 293 : m = distinct_rel(ae, rname);
1621 : }
1622 145 : return m;
1623 : }
1624 : return 0;
1625 : case e_atom:
1626 : return 1;
1627 154 : case e_convert:
1628 154 : return distinct_rel(e->l, rname);
1629 : default:
1630 : return 0;
1631 : }
1632 : return 0;
1633 : }
1634 :
1635 : int
1636 20274721 : rel_has_exp(sql_rel *rel, sql_exp *e, bool subexp)
1637 : {
1638 20274721 : if (rel_find_exp_and_corresponding_rel(rel, e, subexp, NULL, NULL))
1639 4442119 : return 0;
1640 : return -1;
1641 : }
1642 :
1643 : int
1644 0 : rel_has_exps(sql_rel *rel, list *exps, bool subexp)
1645 : {
1646 0 : if (list_empty(exps))
1647 : return 0;
1648 0 : for (node *n = exps->h; n; n = n->next)
1649 0 : if (rel_has_exp(rel, n->data, subexp) >= 0)
1650 : return 0;
1651 : return -1;
1652 : }
1653 :
1654 : int
1655 0 : rel_has_all_exps(sql_rel *rel, list *exps)
1656 : {
1657 0 : if (list_empty(exps))
1658 : return 1;
1659 0 : for (node *n = exps->h; n; n = n->next)
1660 0 : if (rel_has_exp(rel, n->data, false) < 0)
1661 : return 0;
1662 : return 1;
1663 : }
1664 :
1665 : static int
1666 15325956 : rel_has_exp2(sql_rel *rel, sql_exp *e)
1667 : {
1668 15325956 : return rel_has_exp(rel, e, false);
1669 : }
1670 :
1671 : sql_rel *
1672 5813132 : find_rel(list *rels, sql_exp *e)
1673 : {
1674 5813132 : node *n = list_find(rels, e, (fcmp)&rel_has_exp2);
1675 5813132 : if (n)
1676 3309813 : return n->data;
1677 : return NULL;
1678 : }
1679 :
1680 : sql_rel *
1681 0 : find_one_rel(list *rels, sql_exp *e)
1682 : {
1683 0 : node *n;
1684 0 : sql_rel *fnd = NULL;
1685 :
1686 0 : for(n = rels->h; n; n = n->next) {
1687 0 : if (rel_has_exp(n->data, e, false) == 0) {
1688 0 : if (fnd)
1689 : return NULL;
1690 0 : fnd = n->data;
1691 : }
1692 : }
1693 : return fnd;
1694 : }
1695 :
1696 : static int
1697 326 : exp_is_rangejoin(sql_exp *e, list *rels)
1698 : {
1699 : /* assume e is a e_cmp with 3 args
1700 : * Need to check e->r and e->f only touch one table.
1701 : */
1702 326 : const char *rname = 0;
1703 :
1704 326 : if (distinct_rel(e->r, &rname) && distinct_rel(e->f, &rname))
1705 : return 0;
1706 183 : if (rels) {
1707 138 : sql_rel *r = find_rel(rels, e->r);
1708 138 : sql_rel *f = find_rel(rels, e->f);
1709 138 : if (r && f && r == f)
1710 : return 0;
1711 : }
1712 : return -1;
1713 : }
1714 :
1715 : int
1716 387340 : exp_is_join(sql_exp *e, list *rels)
1717 : {
1718 : /* only simple compare expressions, ie not or lists
1719 : or range expressions (e->f)
1720 : */
1721 387340 : if (e->type == e_cmp && !is_complex_exp(e->flag) && e->l && e->r && !e->f && e->card >= CARD_AGGR && !complex_select(e))
1722 : return 0;
1723 2005 : if (e->type == e_cmp && e->flag == cmp_filter && e->l && e->r && e->card >= CARD_AGGR)
1724 : return 0;
1725 : /* range expression */
1726 1827 : if (e->type == e_cmp && !is_complex_exp(e->flag) && e->l && e->r && e->f && e->card >= CARD_AGGR && !complex_select(e))
1727 326 : return exp_is_rangejoin(e, rels);
1728 : return -1;
1729 : }
1730 :
1731 : int
1732 381125 : exp_is_eqjoin(sql_exp *e)
1733 : {
1734 381125 : if (e->flag == cmp_equal) {
1735 371301 : sql_exp *l = e->l;
1736 371301 : sql_exp *r = e->r;
1737 :
1738 371301 : if (!is_func(l->type) && !is_func(r->type))
1739 370186 : return 0;
1740 : }
1741 : return -1;
1742 : }
1743 :
1744 : sql_exp *
1745 232123 : exps_find_prop(list *exps, rel_prop kind)
1746 : {
1747 232123 : if (list_empty(exps))
1748 : return NULL;
1749 462979 : for (node *n = exps->h ; n ; n = n->next) {
1750 232123 : sql_exp *e = n->data;
1751 :
1752 232123 : if (find_prop(e->p, kind))
1753 1267 : return e;
1754 : }
1755 : return NULL;
1756 : }
1757 :
1758 : /* check is one of the exps can be found in this relation */
1759 : static sql_exp* rel_find_exp_and_corresponding_rel_(sql_rel *rel, sql_exp *e, bool subexp, sql_rel **res);
1760 :
1761 : static bool
1762 596526 : rel_find_exps_and_corresponding_rel_(sql_rel *rel, list *l, bool subexp, sql_rel **res)
1763 : {
1764 596526 : int all = 1;
1765 :
1766 596526 : if (list_empty(l))
1767 : return true;
1768 1607866 : for(node *n = l->h; n && (subexp || all); n = n->next) {
1769 1020431 : sql_exp *ne = rel_find_exp_and_corresponding_rel_(rel, n->data, subexp, res);
1770 1020431 : if (subexp && ne)
1771 : return true;
1772 1011340 : all &= (ne?1:0);
1773 : }
1774 587435 : if (all)
1775 : return true;
1776 : return false;
1777 : }
1778 :
1779 : static sql_exp *
1780 78685768 : rel_find_exp_and_corresponding_rel_(sql_rel *rel, sql_exp *e, bool subexp, sql_rel **res)
1781 : {
1782 78685768 : sql_exp *ne = NULL;
1783 :
1784 78685768 : if (!rel)
1785 : return NULL;
1786 78685656 : switch(e->type) {
1787 76384942 : case e_column:
1788 76384942 : if (is_basetable(rel->op) && !rel->exps) {
1789 16470 : assert(e->nid);
1790 16470 : if (rel_base_has_nid(rel, e->nid))
1791 76384925 : ne = e;
1792 96093974 : } else if ((!list_empty(rel->exps) && (is_project(rel->op) || is_base(rel->op))) ||
1793 20109657 : (!list_empty(rel->attr) && is_join(rel->op))) {
1794 57027110 : list *l = rel->attr ? rel->attr : rel->exps;
1795 57027110 : assert(e->nid);
1796 57027110 : ne = exps_bind_nid(l, e->nid);
1797 : }
1798 76384925 : if (ne && res)
1799 69164 : *res = rel;
1800 : return ne;
1801 1089957 : case e_convert:
1802 1089957 : return rel_find_exp_and_corresponding_rel_(rel, e->l, subexp, res);
1803 600659 : case e_aggr:
1804 : case e_func:
1805 600659 : if (e->l)
1806 596511 : if (rel_find_exps_and_corresponding_rel_(rel, e->l, subexp, res))
1807 : return e;
1808 : return NULL;
1809 447 : case e_cmp:
1810 447 : if (!subexp)
1811 : return NULL;
1812 :
1813 30 : if (e->flag == cmp_or || e->flag == cmp_filter) {
1814 13 : if (rel_find_exps_and_corresponding_rel_(rel, e->l, subexp, res) ||
1815 3 : rel_find_exps_and_corresponding_rel_(rel, e->r, subexp, res))
1816 10 : return e;
1817 20 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
1818 4 : if (rel_find_exp_and_corresponding_rel_(rel, e->l, subexp, res) ||
1819 2 : rel_find_exps_and_corresponding_rel_(rel, e->r, subexp, res))
1820 2 : return e;
1821 23 : } else if (rel_find_exp_and_corresponding_rel_(rel, e->l, subexp, res) ||
1822 5 : rel_find_exp_and_corresponding_rel_(rel, e->r, subexp, res) ||
1823 2 : (!e->f || rel_find_exp_and_corresponding_rel_(rel, e->f, subexp, res))) {
1824 16 : return e;
1825 : }
1826 : return NULL;
1827 : case e_psm:
1828 : return NULL;
1829 609041 : case e_atom:
1830 609041 : if (e->f) { /* values */
1831 12 : list *l = e->f;
1832 12 : node *n = l->h;
1833 :
1834 12 : ne = n->data;
1835 31 : while ((subexp || ne != NULL) && n != NULL) {
1836 19 : ne = rel_find_exp_and_corresponding_rel_(rel, n->data, subexp, res);
1837 19 : if (subexp && ne)
1838 : break;
1839 19 : n = n->next;
1840 : }
1841 12 : return ne;
1842 : }
1843 : return e;
1844 : }
1845 : return ne;
1846 : }
1847 :
1848 : sql_exp *
1849 76575265 : rel_find_exp_and_corresponding_rel(sql_rel *rel, sql_exp *e, bool subexp, sql_rel **res, bool *under_join)
1850 : {
1851 76575265 : sql_exp *ne = rel_find_exp_and_corresponding_rel_(rel, e, subexp, res);
1852 :
1853 76575318 : if (rel && !ne) {
1854 55080090 : switch(rel->op) {
1855 13280106 : case op_left:
1856 : case op_right:
1857 : case op_full:
1858 : case op_join:
1859 : case op_semi:
1860 : case op_anti:
1861 13280106 : ne = rel_find_exp_and_corresponding_rel(rel->l, e, subexp, res, under_join);
1862 13280106 : if (!ne && is_join(rel->op))
1863 8507608 : ne = rel_find_exp_and_corresponding_rel(rel->r, e, subexp, res, under_join);
1864 : break;
1865 : case op_table:
1866 : case op_basetable:
1867 : break;
1868 276895 : case op_munion:
1869 1533303 : for (node* n = ((list*)rel->l)->h; n && !ne; n = n->next)
1870 1256408 : ne = rel_find_exp_and_corresponding_rel(n->data, e, subexp, res, under_join);
1871 : break;
1872 14691857 : default:
1873 14691857 : if (!is_project(rel->op) && rel->l)
1874 6433960 : ne = rel_find_exp_and_corresponding_rel(rel->l, e, subexp, res, under_join);
1875 : }
1876 : }
1877 76575318 : if (ne && under_join && is_join(rel->op))
1878 2964035 : *under_join = true;
1879 76575318 : return ne;
1880 : }
1881 :
1882 : sql_exp *
1883 21606838 : rel_find_exp(sql_rel *rel, sql_exp *e)
1884 : {
1885 21606838 : return rel_find_exp_and_corresponding_rel(rel, e, false, NULL, NULL);
1886 : }
1887 :
1888 : bool
1889 64041 : rel_find_nid(sql_rel *rel, int nid)
1890 : {
1891 64456 : if (rel) {
1892 63980 : switch(rel->op) {
1893 5527 : case op_left:
1894 : case op_right:
1895 : case op_full:
1896 : case op_join:
1897 : case op_semi:
1898 : case op_anti:
1899 5527 : if (rel_find_nid(rel->l, nid))
1900 : return true;
1901 499 : if (is_join(rel->op))
1902 415 : return rel_find_nid(rel->r, nid);
1903 : break;
1904 55126 : case op_table:
1905 : case op_basetable:
1906 : case op_munion:
1907 : case op_union:
1908 : case op_inter:
1909 : case op_except:
1910 : case op_project:
1911 : case op_groupby:
1912 55126 : if (rel->exps) {
1913 55126 : if (exps_bind_nid(rel->exps, nid))
1914 : return true;
1915 0 : } else if (rel->op == op_basetable)
1916 0 : return rel_base_has_nid(rel, nid);
1917 : break;
1918 3327 : case op_select:
1919 : case op_topn:
1920 : case op_sample:
1921 3327 : if (rel_find_nid(rel->l, nid))
1922 : return true;
1923 : break;
1924 : case op_ddl:
1925 : case op_insert:
1926 : case op_update:
1927 : case op_delete:
1928 : case op_truncate:
1929 : case op_merge:
1930 : return false;
1931 :
1932 : }
1933 : }
1934 : return false;
1935 : }
1936 :
1937 : int
1938 3908094 : exp_is_true(sql_exp *e)
1939 : {
1940 3908094 : if (e->type == e_atom && e->l)
1941 46838 : return atom_is_true(e->l);
1942 3861256 : if (e->type == e_cmp && e->flag == cmp_equal)
1943 3120331 : return (exp_is_true(e->l) && exp_is_true(e->r) && exp_match_exp(e->l, e->r));
1944 : return 0;
1945 : }
1946 :
1947 : static inline bool
1948 237579 : exp_is_cmp_exp_is_false(sql_exp* e)
1949 : {
1950 237579 : sql_exp *l = e->l;
1951 237579 : sql_exp *r = e->r;
1952 237579 : assert(e->type == e_cmp && e->f == NULL && l && r);
1953 :
1954 : /* Handle 'v is x' and 'v is not x' expressions.
1955 : * Other cases in is-semantics are unspecified.
1956 : */
1957 237579 : if (e->flag != cmp_equal && e->flag != cmp_notequal)
1958 : return false;
1959 237579 : if (e->flag == cmp_equal && !is_anti(e))
1960 371786 : return ((exp_is_null(l) && exp_is_not_null(r)) || (exp_is_not_null(l) && exp_is_null(r)));
1961 51686 : if ((e->flag == cmp_notequal && !is_anti(e)) || (e->flag == cmp_equal && is_anti(e)))
1962 103320 : return exp_is_null(l) && exp_is_null(r);
1963 : return false;
1964 : }
1965 :
1966 : static inline bool
1967 5500067 : exp_single_bound_cmp_exp_is_false(sql_exp* e)
1968 : {
1969 5500067 : assert(e->type == e_cmp);
1970 5500067 : sql_exp* l = e->l;
1971 5500067 : sql_exp* r = e->r;
1972 5500067 : assert(e->f == NULL);
1973 5500067 : assert (l && r);
1974 :
1975 5500067 : return exp_is_null(l) || exp_is_null(r);
1976 : }
1977 :
1978 : static inline bool
1979 74728 : exp_two_sided_bound_cmp_exp_is_false(sql_exp* e)
1980 : {
1981 74728 : assert(e->type == e_cmp);
1982 74728 : sql_exp* v = e->l;
1983 74728 : sql_exp* l = e->r;
1984 74728 : sql_exp* h = e->f;
1985 74728 : assert (v && l && h);
1986 :
1987 74728 : return is_anti(e) ? exp_is_null(v) || (exp_is_null(l) && exp_is_null(h)) : false;
1988 : }
1989 :
1990 : static inline bool
1991 5825647 : exp_regular_cmp_exp_is_false(sql_exp* e)
1992 : {
1993 5825647 : assert(e->type == e_cmp);
1994 :
1995 5825647 : if (is_semantics(e) && !is_any(e)) return exp_is_cmp_exp_is_false(e);
1996 5588068 : if (is_any(e)) return false;
1997 5574795 : if (e -> f) return exp_two_sided_bound_cmp_exp_is_false(e);
1998 5500067 : else return exp_single_bound_cmp_exp_is_false(e);
1999 : }
2000 :
2001 : static inline bool
2002 597651 : exp_or_exp_is_false(sql_exp* e)
2003 : {
2004 597651 : assert(e->type == e_cmp && e->flag == cmp_or);
2005 :
2006 597651 : list* left = e->l;
2007 597651 : list* right = e->r;
2008 :
2009 597651 : bool left_is_false = false;
2010 1246802 : for(node* n = left->h; n; n=n->next) {
2011 649767 : if (exp_is_false(n->data)) {
2012 : left_is_false=true;
2013 : break;
2014 : }
2015 : }
2016 :
2017 597651 : if (!left_is_false) {
2018 : return false;
2019 : }
2020 :
2021 1180 : for(node* n = right->h; n; n=n->next) {
2022 645 : if (exp_is_false(n->data)) {
2023 : return true;
2024 : }
2025 : }
2026 :
2027 : return false;
2028 : }
2029 :
2030 : static inline bool
2031 6749274 : exp_cmp_exp_is_false(sql_exp* e)
2032 : {
2033 6749274 : assert(e->type == e_cmp);
2034 :
2035 6749274 : switch (e->flag) {
2036 5825647 : case cmp_gt:
2037 : case cmp_gte:
2038 : case cmp_lte:
2039 : case cmp_lt:
2040 : case cmp_equal:
2041 : case cmp_notequal:
2042 5825647 : return exp_regular_cmp_exp_is_false(e);
2043 597651 : case cmp_or:
2044 597651 : return exp_or_exp_is_false(e);
2045 : default:
2046 : return false;
2047 : }
2048 : }
2049 :
2050 : int
2051 6842552 : exp_is_false(sql_exp *e)
2052 : {
2053 6842552 : if (e->type == e_atom && e->l)
2054 46354 : return atom_is_false(e->l);
2055 6796198 : else if (e->type == e_cmp)
2056 6749274 : return exp_cmp_exp_is_false(e);
2057 : return 0;
2058 : }
2059 :
2060 : int
2061 17808 : exp_is_zero(sql_exp *e)
2062 : {
2063 17808 : if (e->type == e_atom && e->l)
2064 17531 : return atom_is_zero(e->l);
2065 : return 0;
2066 : }
2067 :
2068 : int
2069 332741 : exp_is_not_null(sql_exp *e)
2070 : {
2071 332927 : if (!has_nil(e))
2072 : return true;
2073 :
2074 103406 : switch (e->type) {
2075 3075 : case e_atom:
2076 3075 : if (e->f) /* values list */
2077 : return false;
2078 3075 : if (e->l)
2079 2785 : return !(atom_null(e->l));
2080 : return false;
2081 186 : case e_convert:
2082 186 : return exp_is_not_null(e->l);
2083 646 : case e_func:
2084 646 : if (!is_semantics(e) && e->l) {
2085 258 : list *l = e->l;
2086 303 : for (node *n = l->h; n; n=n->next) {
2087 301 : sql_exp *p = n->data;
2088 301 : if (!exp_is_not_null(p))
2089 : return false;
2090 : }
2091 : return true;
2092 : }
2093 : return false;
2094 : case e_aggr:
2095 : case e_column:
2096 : case e_cmp:
2097 : case e_psm:
2098 : return false;
2099 : }
2100 : return false;
2101 : }
2102 :
2103 : static int
2104 8269 : exps_have_null(list *l)
2105 : {
2106 8269 : if (!l)
2107 : return false;
2108 17514 : for(node *n = l->h; n; n = n->next)
2109 9249 : if (exp_is_null(n->data))
2110 : return true;
2111 : return false;
2112 : }
2113 :
2114 : int
2115 12296621 : exp_is_null(sql_exp *e )
2116 : {
2117 12339654 : if (!has_nil(e))
2118 : return false;
2119 :
2120 1623615 : switch (e->type) {
2121 167538 : case e_atom:
2122 167538 : if (e->f) /* values list */
2123 : return 0;
2124 167537 : if (e->l)
2125 93353 : return (atom_null(e->l));
2126 : return 0;
2127 43033 : case e_convert:
2128 43033 : return exp_is_null(e->l);
2129 115115 : case e_func:
2130 115115 : if (!is_semantics(e) && e->l) {
2131 : /* This is a call to a function with no-nil semantics.
2132 : * If one of the parameters is null the expression itself is null
2133 : */
2134 100376 : list* l = e->l;
2135 300277 : for(node* n = l->h; n; n=n->next) {
2136 200068 : sql_exp* p = n->data;
2137 200068 : if (exp_is_null(p)) {
2138 : return true;
2139 : }
2140 : }
2141 : }
2142 : return 0;
2143 60042 : case e_cmp:
2144 60042 : if (!is_semantics(e)) {
2145 56803 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2146 14854 : return (exps_have_null(e->l) && exps_have_null(e->r));
2147 49376 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2148 3516 : return ((e->flag == cmp_in && exp_is_null(e->l)) ||
2149 3514 : (e->flag == cmp_notin && (exp_is_null(e->l) || exps_have_null(e->r))));
2150 45860 : } else if (e->f) {
2151 7174 : return exp_is_null(e->l) && exp_is_null(e->r) && exp_is_null(e->f);
2152 : } else {
2153 42275 : return exp_is_null(e->l) || exp_is_null(e->r);
2154 : }
2155 : }
2156 : return 0;
2157 : case e_aggr:
2158 : case e_column:
2159 : case e_psm:
2160 : return 0;
2161 : }
2162 : return 0;
2163 : }
2164 :
2165 : int
2166 1790807 : exp_is_rel( sql_exp *e )
2167 : {
2168 1799947 : if (e) {
2169 1799947 : switch(e->type){
2170 9140 : case e_convert:
2171 9140 : return exp_is_rel(e->l);
2172 303100 : case e_psm:
2173 303100 : return e->flag == PSM_REL && e->l;
2174 : default:
2175 : return 0;
2176 : }
2177 : }
2178 : return 0;
2179 : }
2180 :
2181 : int
2182 6709 : exps_one_is_rel(list *exps)
2183 : {
2184 6709 : if (list_empty(exps))
2185 : return 0;
2186 20024 : for(node *n = exps->h ; n ; n = n->next)
2187 13324 : if (exp_is_rel(n->data))
2188 : return 1;
2189 : return 0;
2190 : }
2191 :
2192 : int
2193 8991443 : exp_is_atom( sql_exp *e )
2194 : {
2195 9352795 : switch (e->type) {
2196 2051289 : case e_atom:
2197 2051289 : if (e->f) /* values list */
2198 12875 : return exps_are_atoms(e->f);
2199 : return 1;
2200 361352 : case e_convert:
2201 361352 : return exp_is_atom(e->l);
2202 1091292 : case e_func:
2203 : case e_aggr:
2204 1091292 : return e->card == CARD_ATOM && exps_are_atoms(e->l);
2205 2709 : case e_cmp:
2206 2709 : if (e->card != CARD_ATOM)
2207 : return 0;
2208 157 : if (e->flag == cmp_or || e->flag == cmp_filter)
2209 82 : return exps_are_atoms(e->l) && exps_are_atoms(e->r);
2210 79 : if (e->flag == cmp_in || e->flag == cmp_notin)
2211 0 : return exp_is_atom(e->l) && exps_are_atoms(e->r);
2212 79 : return exp_is_atom(e->l) && exp_is_atom(e->r) && (!e->f || exp_is_atom(e->f));
2213 : case e_column:
2214 : case e_psm:
2215 : return 0;
2216 : }
2217 : return 0;
2218 : }
2219 :
2220 : static int
2221 1 : exps_are_aggr(sql_rel *r, list *exps)
2222 : {
2223 1 : int aggr = 1;
2224 1 : if (!list_empty(exps))
2225 3 : for(node *n=exps->h; n && aggr; n=n->next)
2226 2 : aggr &= exp_is_aggr(r, n->data);
2227 1 : return aggr;
2228 : }
2229 :
2230 : /* is expression e an aggregated result of r */
2231 : int
2232 11 : exp_is_aggr(sql_rel *r, sql_exp *e)
2233 : {
2234 11 : sql_exp *ne = NULL;
2235 :
2236 11 : switch (e->type) {
2237 : case e_atom:
2238 : return true;
2239 0 : case e_convert:
2240 0 : return exp_is_aggr(r, e->l);
2241 1 : case e_func:
2242 1 : return exps_are_aggr(r, e->l);
2243 : case e_aggr:
2244 : return true;
2245 0 : case e_cmp:
2246 0 : if (e->card != CARD_ATOM)
2247 : return false;
2248 0 : if (e->flag == cmp_or || e->flag == cmp_filter)
2249 0 : return exps_are_aggr(r, e->l) && exps_are_aggr(r, e->r);
2250 0 : if (e->flag == cmp_in || e->flag == cmp_notin)
2251 0 : return exp_is_aggr(r, e->l) && exps_are_aggr(r, e->r);
2252 0 : return exp_is_aggr(r, e->l) && exp_is_aggr(r, e->r) && (!e->f || exp_is_aggr(r, e->f));
2253 9 : case e_column:
2254 9 : if (e->freevar)
2255 : return true;
2256 9 : ne = rel_find_exp(r, e);
2257 9 : if (ne) /* found local */
2258 : return true;
2259 : else
2260 : return false;
2261 : case e_psm:
2262 : return false;
2263 : }
2264 : return false;
2265 : }
2266 :
2267 : static int
2268 19 : exps_have_aggr(sql_rel *r, list *exps)
2269 : {
2270 19 : int aggr = 0;
2271 19 : if (!list_empty(exps))
2272 63 : for(node *n=exps->h; n && !aggr; n=n->next)
2273 44 : aggr |= exp_has_aggr(r, n->data);
2274 19 : return aggr;
2275 : }
2276 :
2277 : int
2278 80 : exp_has_aggr(sql_rel *r, sql_exp *e )
2279 : {
2280 87 : sql_exp *ne = NULL;
2281 :
2282 87 : switch (e->type) {
2283 : case e_atom:
2284 : return false;
2285 7 : case e_convert:
2286 7 : return exp_has_aggr(r, e->l);
2287 19 : case e_func:
2288 19 : return exps_have_aggr(r, e->l);
2289 : case e_aggr:
2290 : return true;
2291 0 : case e_cmp:
2292 0 : if (e->card != CARD_ATOM)
2293 : return false;
2294 0 : if (e->flag == cmp_or || e->flag == cmp_filter)
2295 0 : return exps_have_aggr(r, e->l) && exps_have_aggr(r, e->r);
2296 0 : if (e->flag == cmp_in || e->flag == cmp_notin)
2297 0 : return exp_has_aggr(r, e->l) && exps_have_aggr(r, e->r);
2298 0 : return exp_has_aggr(r, e->l) && exp_has_aggr(r, e->r) && (!e->f || exp_has_aggr(r, e->f));
2299 34 : case e_column:
2300 34 : if (e->freevar)
2301 : return false;
2302 21 : ne = rel_find_exp(r->l, e);
2303 21 : if (ne) /* found lower */
2304 : return false;
2305 : else
2306 : return true;
2307 : case e_psm:
2308 : return false;
2309 : }
2310 : return false;
2311 : }
2312 :
2313 : int
2314 20398527 : exp_has_rel( sql_exp *e )
2315 : {
2316 20767271 : if (!e)
2317 : return 0;
2318 20767271 : switch(e->type){
2319 1959893 : case e_func:
2320 : case e_aggr:
2321 1959893 : return exps_have_rel_exp(e->l);
2322 690374 : case e_cmp:
2323 690374 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2324 69501 : return (exps_have_rel_exp(e->l) || exps_have_rel_exp(e->r));
2325 621327 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2326 39794 : return (exp_has_rel(e->l) || exps_have_rel_exp(e->r));
2327 : } else {
2328 1163066 : return (exp_has_rel(e->l) || exp_has_rel(e->r) || (e->f && exp_has_rel(e->f)));
2329 : }
2330 368744 : case e_convert:
2331 368744 : return exp_has_rel(e->l);
2332 123546 : case e_psm:
2333 123546 : return exp_is_rel(e);
2334 9555718 : case e_atom:
2335 9555718 : return (e->f && exps_have_rel_exp(e->f));
2336 : case e_column:
2337 : return 0;
2338 : }
2339 : return 0;
2340 : }
2341 :
2342 : int
2343 2639165 : exps_have_rel_exp( list *exps)
2344 : {
2345 2639165 : if (list_empty(exps))
2346 : return 0;
2347 9470150 : for(node *n=exps->h; n; n=n->next) {
2348 6923686 : sql_exp *e = n->data;
2349 :
2350 6923686 : if (exp_has_rel(e))
2351 : return 1;
2352 : }
2353 : return 0;
2354 : }
2355 :
2356 : static sql_rel *
2357 570 : exps_rel_get_rel(allocator *sa, list *exps )
2358 : {
2359 570 : sql_rel *r = NULL, *xp = NULL;
2360 :
2361 570 : if (list_empty(exps))
2362 : return NULL;
2363 1674 : for (node *n = exps->h; n; n=n->next){
2364 1104 : sql_exp *e = n->data;
2365 :
2366 1104 : if (exp_has_rel(e)) {
2367 576 : if (!(r = exp_rel_get_rel(sa, e)))
2368 : return NULL;
2369 576 : if (xp) {
2370 6 : xp = rel_crossproduct(sa, xp, r, op_full);
2371 6 : set_processed(xp);
2372 : } else {
2373 : xp = r;
2374 : }
2375 : }
2376 : }
2377 : return xp;
2378 : }
2379 :
2380 : int
2381 60 : exp_rel_depth(sql_exp *e)
2382 : {
2383 60 : if (!e)
2384 : return 0;
2385 60 : switch(e->type){
2386 : case e_func:
2387 : case e_aggr:
2388 : case e_cmp:
2389 : return 1;
2390 : case e_convert:
2391 : return 0;
2392 39 : case e_psm:
2393 39 : if (exp_is_rel(e))
2394 : return 0;
2395 : return 1;
2396 : case e_atom:
2397 : case e_column:
2398 : return 0;
2399 : }
2400 : return 0;
2401 : }
2402 :
2403 : sql_rel *
2404 76873 : exp_rel_get_rel(allocator *sa, sql_exp *e)
2405 : {
2406 77828 : if (!e)
2407 : return NULL;
2408 :
2409 77828 : switch(e->type){
2410 542 : case e_func:
2411 : case e_aggr:
2412 542 : return exps_rel_get_rel(sa, e->l);
2413 38 : case e_cmp: {
2414 38 : sql_rel *r = NULL, *xp = NULL;
2415 :
2416 38 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2417 11 : if (exps_have_rel_exp(e->l))
2418 7 : xp = exps_rel_get_rel(sa, e->l);
2419 11 : if (exps_have_rel_exp(e->r)) {
2420 6 : if (!(r = exps_rel_get_rel(sa, e->r)))
2421 : return NULL;
2422 6 : if (xp) {
2423 2 : xp = rel_crossproduct(sa, xp, r, op_join);
2424 2 : set_processed(xp);
2425 : } else {
2426 : xp = r;
2427 : }
2428 : }
2429 27 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2430 0 : if (exp_has_rel(e->l))
2431 0 : xp = exp_rel_get_rel(sa, e->l);
2432 0 : if (exps_have_rel_exp(e->r)) {
2433 0 : if (!(r = exps_rel_get_rel(sa, e->r)))
2434 : return NULL;
2435 0 : if (xp) {
2436 0 : xp = rel_crossproduct(sa, xp, r, op_join);
2437 0 : set_processed(xp);
2438 : } else {
2439 : xp = r;
2440 : }
2441 : }
2442 : } else {
2443 27 : if (exp_has_rel(e->l))
2444 25 : xp = exp_rel_get_rel(sa, e->l);
2445 27 : if (exp_has_rel(e->r)) {
2446 7 : if (!(r = exp_rel_get_rel(sa, e->r)))
2447 : return NULL;
2448 7 : if (xp) {
2449 5 : xp = rel_crossproduct(sa, xp, r, op_join);
2450 5 : set_processed(xp);
2451 : } else {
2452 : xp = r;
2453 : }
2454 : }
2455 27 : if (e->f && exp_has_rel(e->f)) {
2456 0 : if (!(r = exp_rel_get_rel(sa, e->f)))
2457 : return NULL;
2458 0 : if (xp) {
2459 0 : xp = rel_crossproduct(sa, xp, r, op_join);
2460 0 : set_processed(xp);
2461 : } else {
2462 : xp = r;
2463 : }
2464 : }
2465 : }
2466 : return xp;
2467 : }
2468 955 : case e_convert:
2469 955 : return exp_rel_get_rel(sa, e->l);
2470 76278 : case e_psm:
2471 76278 : if (exp_is_rel(e))
2472 76278 : return e->l;
2473 : return NULL;
2474 15 : case e_atom:
2475 15 : if (e->f && exps_have_rel_exp(e->f))
2476 15 : return exps_rel_get_rel(sa, e->f);
2477 : return NULL;
2478 : case e_column:
2479 : return NULL;
2480 : }
2481 : return NULL;
2482 : }
2483 :
2484 : static void exp_rel_update_set_freevar(sql_exp *e);
2485 :
2486 : static void
2487 921 : exps_rel_update_set_freevar(list *exps)
2488 : {
2489 921 : if (!list_empty(exps))
2490 3003 : for (node *n=exps->h; n ; n=n->next)
2491 2082 : exp_rel_update_set_freevar(n->data);
2492 921 : }
2493 :
2494 : static void
2495 2372 : exp_rel_update_set_freevar(sql_exp *e)
2496 : {
2497 2384 : if (!e)
2498 : return ;
2499 :
2500 2384 : switch(e->type){
2501 919 : case e_func:
2502 : case e_aggr:
2503 919 : exps_rel_update_set_freevar(e->l);
2504 919 : break;
2505 8 : case e_cmp:
2506 8 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2507 0 : exps_rel_update_set_freevar(e->l);
2508 0 : exps_rel_update_set_freevar(e->r);
2509 8 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2510 0 : exp_rel_update_set_freevar(e->l);
2511 0 : exps_rel_update_set_freevar(e->r);
2512 : } else {
2513 8 : exp_rel_update_set_freevar(e->l);
2514 8 : exp_rel_update_set_freevar(e->r);
2515 8 : if (e->f)
2516 : exp_rel_update_set_freevar(e->f);
2517 : }
2518 : break;
2519 9 : case e_convert:
2520 9 : exp_rel_update_set_freevar(e->l);
2521 9 : break;
2522 1166 : case e_atom:
2523 1166 : if (e->f)
2524 2 : exps_rel_update_set_freevar(e->f);
2525 : break;
2526 282 : case e_column:
2527 282 : set_freevar(e, 1);
2528 282 : break;
2529 : case e_psm:
2530 : break;
2531 : }
2532 : }
2533 :
2534 : static list *
2535 570 : exp_rel_update_exps(mvc *sql, list *exps, bool up)
2536 : {
2537 570 : if (list_empty(exps))
2538 : return exps;
2539 1674 : for (node *n = exps->h; n; n=n->next){
2540 1104 : sql_exp *e = n->data;
2541 :
2542 1104 : if (exp_has_rel(e))
2543 576 : n->data = exp_rel_update_exp(sql, e, up);
2544 528 : else if (!exp_is_atom(e) && !up)
2545 268 : exp_rel_update_set_freevar(e);
2546 : }
2547 : return exps;
2548 : }
2549 :
2550 : static sql_exp *
2551 57 : exp_rel_update_exp_(mvc *sql, sql_exp *e, bool up)
2552 : {
2553 57 : if (exp_has_rel(e))
2554 31 : e = exp_rel_update_exp(sql, e, up);
2555 26 : else if (!exp_is_atom(e) && !up)
2556 6 : exp_rel_update_set_freevar(e);
2557 57 : return e;
2558 : }
2559 :
2560 : sql_exp *
2561 13394 : exp_rel_update_exp(mvc *sql, sql_exp *e, bool up)
2562 : {
2563 13394 : if (!e)
2564 : return NULL;
2565 :
2566 13394 : switch(e->type){
2567 542 : case e_func:
2568 : case e_aggr:
2569 542 : if (exps_have_rel_exp(e->l))
2570 542 : e->l = exp_rel_update_exps(sql, e->l, up);
2571 : return e;
2572 37 : case e_cmp:
2573 37 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2574 11 : if (exps_have_rel_exp(e->l))
2575 7 : e->l = exp_rel_update_exps(sql, e->l, up);
2576 11 : if (exps_have_rel_exp(e->r))
2577 6 : e->r = exp_rel_update_exps(sql, e->r, up);
2578 26 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2579 0 : if (exp_has_rel(e->l))
2580 0 : e->l = exp_rel_update_exp(sql, e->l, up);
2581 0 : if (exps_have_rel_exp(e->r))
2582 0 : e->r = exp_rel_update_exps(sql, e->r, up);
2583 : } else {
2584 : //if (exp_has_rel(e->l))
2585 26 : e->l = exp_rel_update_exp_(sql, e->l, up);
2586 : //if (exp_has_rel(e->r))
2587 26 : e->r = exp_rel_update_exp_(sql, e->r, up);
2588 26 : if (e->f /*&& exp_has_rel(e->f)*/)
2589 5 : e->f = exp_rel_update_exp_(sql, e->f, up);
2590 : }
2591 : return e;
2592 955 : case e_convert:
2593 955 : if (exp_has_rel(e->l))
2594 955 : e->l = exp_rel_update_exp(sql, e->l, up);
2595 : return e;
2596 11845 : case e_psm:
2597 11845 : if (exp_is_rel(e)) {
2598 11845 : sql_rel *r = exp_rel_get_rel(sql->sa, e), *nr = r;
2599 11845 : if (is_topn(r->op)) {
2600 2 : nr = r->l;
2601 2 : if (nr && !is_project(nr->op))
2602 0 : r->l = nr = rel_project(sql->sa, nr, rel_projections(sql, nr, NULL, 1, 0));
2603 : }
2604 11845 : e = nr->exps->t->data;
2605 11845 : e = exp_ref(sql, e);
2606 11845 : if (up)
2607 0 : set_freevar(e, 1);
2608 11845 : return e;
2609 : }
2610 : return e;
2611 15 : case e_atom:
2612 15 : if (e->f && exps_have_rel_exp(e->f))
2613 15 : e->f = exp_rel_update_exps(sql, e->f, up);
2614 : return e;
2615 : case e_column:
2616 : return e;
2617 : }
2618 : return e;
2619 : }
2620 :
2621 : sql_exp *
2622 4099 : exp_rel_label(mvc *sql, sql_exp *e)
2623 : {
2624 4099 : if (exp_is_rel(e))
2625 4099 : e->l = rel_label(sql, e->l, 1);
2626 4099 : return e;
2627 : }
2628 :
2629 : int
2630 147074 : exps_are_atoms( list *exps)
2631 : {
2632 147074 : int atoms = 1;
2633 147074 : if (!list_empty(exps))
2634 430080 : for(node *n=exps->h; n && atoms; n=n->next)
2635 312929 : atoms &= exp_is_atom(n->data);
2636 147074 : return atoms;
2637 : }
2638 :
2639 : int
2640 144 : exps_have_func(list *exps)
2641 : {
2642 144 : if (list_empty(exps))
2643 : return 0;
2644 175 : for(node *n=exps->h; n; n=n->next) {
2645 148 : sql_exp *e = n->data;
2646 :
2647 148 : if (exp_has_func(e))
2648 : return 1;
2649 : }
2650 : return 0;
2651 : }
2652 :
2653 : static int exp_has_func_or_cmp(sql_exp *e, bool cmp);
2654 :
2655 : static int
2656 68304 : exps_have_func_or_cmp(list *exps, bool cmp)
2657 : {
2658 68304 : if (list_empty(exps))
2659 : return 0;
2660 195731 : for(node *n=exps->h; n; n=n->next) {
2661 136935 : sql_exp *e = n->data;
2662 :
2663 136935 : if (exp_has_func_or_cmp(e, cmp))
2664 : return 1;
2665 : }
2666 : return 0;
2667 : }
2668 :
2669 : static int
2670 2168017 : exp_has_func_or_cmp(sql_exp *e, bool cmp)
2671 : {
2672 2168017 : if (!e)
2673 : return 0;
2674 2168017 : switch (e->type) {
2675 307400 : case e_atom:
2676 307400 : if (e->f)
2677 4 : return exps_have_func_or_cmp(e->f, true);
2678 : return 0;
2679 16126 : case e_convert:
2680 : {
2681 16126 : sql_subtype *t = exp_totype(e);
2682 16126 : sql_subtype *f = exp_fromtype(e);
2683 16126 : if (t->type->eclass == EC_FLT && (f->type->eclass == EC_DEC || f->type->eclass == EC_NUM))
2684 167 : return exp_has_func_or_cmp(e->l, cmp);
2685 15959 : if (f->type->localtype > t->type->localtype)
2686 : return true;
2687 : }
2688 13776 : return exp_has_func_or_cmp(e->l, cmp);
2689 : case e_func:
2690 : return 1;
2691 20073 : case e_aggr:
2692 20073 : if (e->l)
2693 17252 : return exps_have_func_or_cmp(e->l, true);
2694 : return 0;
2695 270684 : case e_cmp:
2696 270684 : if (cmp)
2697 : return 1;
2698 261275 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2699 22095 : return (exps_have_func_or_cmp(e->l, true) || exps_have_func_or_cmp(e->r, true));
2700 248609 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2701 35198 : return (exp_has_func_or_cmp(e->l, true) || exps_have_func_or_cmp(e->r, true));
2702 : } else {
2703 426928 : return (exp_has_func_or_cmp(e->l, true) || exp_has_func_or_cmp(e->r, true) ||
2704 198308 : (e->f && exp_has_func_or_cmp(e->f, true)));
2705 : }
2706 : case e_column:
2707 : case e_psm:
2708 : return 0;
2709 : }
2710 : return 0;
2711 : }
2712 :
2713 : int
2714 1567408 : exp_has_func(sql_exp *e)
2715 : {
2716 1567408 : return exp_has_func_or_cmp(e, false);
2717 : }
2718 :
2719 : static int
2720 720799 : exps_have_sideeffect( list *exps)
2721 : {
2722 720799 : node *n;
2723 720799 : int has_sideeffect = 0;
2724 :
2725 2213969 : for(n=exps->h; n && !has_sideeffect; n=n->next)
2726 1493170 : has_sideeffect |= exp_has_sideeffect(n->data);
2727 720799 : return has_sideeffect;
2728 : }
2729 :
2730 : int
2731 1677965 : exp_has_sideeffect( sql_exp *e )
2732 : {
2733 1702815 : switch (e->type) {
2734 24850 : case e_convert:
2735 24850 : return exp_has_sideeffect(e->l);
2736 720838 : case e_func:
2737 : {
2738 720838 : sql_subfunc *f = e->f;
2739 :
2740 720838 : if (f->func->side_effect)
2741 : return 1;
2742 720824 : if (e->l)
2743 720799 : return exps_have_sideeffect(e->l);
2744 : return 0;
2745 : }
2746 471910 : case e_atom:
2747 471910 : if (e->f)
2748 0 : return exps_have_sideeffect(e->f);
2749 : return 0;
2750 : case e_aggr:
2751 : case e_cmp:
2752 : case e_column:
2753 : case e_psm:
2754 : return 0;
2755 : }
2756 : return 0;
2757 : }
2758 :
2759 : bool
2760 1034020 : exps_have_unsafe(list *exps, bool allow_identity, bool card)
2761 : {
2762 1034020 : int unsafe = 0;
2763 :
2764 1034020 : if (list_empty(exps))
2765 : return 0;
2766 3549658 : for (node *n = exps->h; n && !unsafe; n = n->next)
2767 2536193 : unsafe |= exp_unsafe(n->data, allow_identity, card);
2768 1013465 : return unsafe;
2769 : }
2770 :
2771 : bool
2772 12393415 : exp_unsafe(sql_exp *e, bool allow_identity, bool card)
2773 : {
2774 12393415 : switch (e->type) {
2775 762867 : case e_convert:
2776 762867 : if (card) {
2777 9026 : sql_subtype *t = exp_totype(e);
2778 9026 : sql_subtype *f = exp_fromtype(e);
2779 9026 : if (t->type->eclass == EC_FLT && (f->type->eclass == EC_DEC || f->type->eclass == EC_NUM))
2780 : return false;
2781 8945 : if (f->type->localtype > t->type->localtype)
2782 : return true;
2783 : return false;
2784 : }
2785 753841 : return exp_unsafe(e->l, allow_identity, card);
2786 990826 : case e_aggr:
2787 : case e_func: {
2788 990826 : sql_subfunc *f = e->f;
2789 :
2790 990826 : if (IS_ANALYTIC(f->func) || !LANG_INT_OR_MAL(f->func->lang) || f->func->side_effect || (!allow_identity && is_identity(e, NULL)))
2791 53171 : return 1;
2792 937655 : return exps_have_unsafe(e->l, allow_identity, card);
2793 52206 : } break;
2794 52206 : case e_cmp: {
2795 52206 : if (e->flag == cmp_in || e->flag == cmp_notin) {
2796 6363 : return exp_unsafe(e->l, allow_identity, card) || exps_have_unsafe(e->r, allow_identity, card);
2797 45843 : } else if (e->flag == cmp_or || e->flag == cmp_filter) {
2798 10590 : return exps_have_unsafe(e->l, allow_identity, card) || exps_have_unsafe(e->r, allow_identity, card);
2799 : } else {
2800 70522 : return exp_unsafe(e->l, allow_identity, card) || exp_unsafe(e->r, allow_identity, card) || (e->f && exp_unsafe(e->f, allow_identity, card));
2801 : }
2802 1103296 : } break;
2803 1103296 : case e_atom: {
2804 1103296 : if (e->f)
2805 0 : return exps_have_unsafe(e->f, allow_identity, card);
2806 : return 0;
2807 : } break;
2808 : case e_column:
2809 : case e_psm:
2810 : return 0;
2811 : }
2812 : return 0;
2813 : }
2814 :
2815 : static inline int
2816 3489292 : exp_key( sql_exp *e )
2817 : {
2818 3489292 : if (e->alias.name)
2819 3489291 : return hash_key(e->alias.name);
2820 : return 0;
2821 : }
2822 :
2823 : sql_exp *
2824 82 : exps_uses_nid(list *exps, int nid)
2825 : {
2826 82 : if (exps) {
2827 153 : for (node *en = exps->h; en; en = en->next ) {
2828 147 : sql_exp *e = en->data;
2829 :
2830 147 : if (e->nid == nid)
2831 76 : return e;
2832 : }
2833 : }
2834 : return NULL;
2835 : }
2836 :
2837 : sql_exp *
2838 70640225 : exps_bind_nid(list *exps, int nid)
2839 : {
2840 70640225 : if (exps) {
2841 5430085760 : for (node *en = exps->h; en; en = en->next ) {
2842 5388493383 : sql_exp *e = en->data;
2843 :
2844 5388493383 : if (e->alias.label == nid)
2845 28692650 : return e;
2846 : }
2847 : }
2848 : return NULL;
2849 : }
2850 :
2851 : sql_exp *
2852 957663 : exps_bind_column(list *exps, const char *cname, int *ambiguous, int *multiple, int no_tname)
2853 : {
2854 957663 : sql_exp *res = NULL;
2855 :
2856 957663 : if (exps && cname) {
2857 957662 : node *en;
2858 :
2859 957662 : if (exps) {
2860 957662 : if (!exps->ht && list_length(exps) > HASH_MIN_SIZE) {
2861 108306 : exps->ht = hash_new(exps->sa, list_length(exps), (fkeyvalue)&exp_key);
2862 108306 : if (exps->ht == NULL)
2863 : return NULL;
2864 817462 : for (en = exps->h; en; en = en->next ) {
2865 709156 : sql_exp *e = en->data;
2866 709156 : if (e->alias.name) {
2867 709156 : int key = exp_key(e);
2868 :
2869 709156 : if (hash_add(exps->ht, key, e) == NULL)
2870 : return NULL;
2871 : }
2872 : }
2873 : }
2874 957662 : if (exps->ht) {
2875 425832 : int key = hash_key(cname);
2876 425832 : sql_hash_e *he = exps->ht->buckets[key&(exps->ht->size-1)];
2877 :
2878 829253 : for (; he; he = he->chain) {
2879 403425 : sql_exp *e = he->value;
2880 :
2881 403425 : if (e->alias.name && strcmp(e->alias.name, cname) == 0 && (!no_tname || !e->alias.rname)) {
2882 145058 : if (res && multiple)
2883 4 : *multiple = 1;
2884 145058 : if (!res)
2885 145058 : res = e;
2886 :
2887 145058 : if (res && res != e && e->alias.rname && res->alias.rname && strcmp(e->alias.rname, res->alias.rname) != 0 ) {
2888 4 : if (ambiguous)
2889 4 : *ambiguous = 1;
2890 4 : return NULL;
2891 : }
2892 : res = e;
2893 : }
2894 : }
2895 425828 : return res;
2896 : }
2897 : }
2898 1551175 : for (en = exps->h; en; en = en->next ) {
2899 1019350 : sql_exp *e = en->data;
2900 :
2901 1019350 : if (e->alias.name && strcmp(e->alias.name, cname) == 0 && (!no_tname || !e->alias.rname)) {
2902 43685 : if (res && multiple)
2903 8 : *multiple = 1;
2904 43685 : if (!res)
2905 43685 : res = e;
2906 :
2907 43685 : if (res && res != e && e->alias.rname && res->alias.rname && strcmp(e->alias.rname, res->alias.rname) != 0 ) {
2908 5 : if (ambiguous)
2909 5 : *ambiguous = 1;
2910 5 : return NULL;
2911 : }
2912 : res = e;
2913 : }
2914 : }
2915 : }
2916 : return res;
2917 : }
2918 :
2919 : sql_exp *
2920 1644978 : exps_bind_column2(list *exps, const char *rname, const char *cname, int *multiple)
2921 : {
2922 1644978 : sql_exp *res = NULL;
2923 :
2924 1644978 : if (exps) {
2925 1644948 : node *en;
2926 :
2927 1644948 : if (!exps->ht && list_length(exps) > HASH_MIN_SIZE) {
2928 127390 : exps->ht = hash_new(exps->sa, list_length(exps), (fkeyvalue)&exp_key);
2929 127390 : if (exps->ht == NULL)
2930 : return res;
2931 :
2932 2143280 : for (en = exps->h; en; en = en->next ) {
2933 2015890 : sql_exp *e = en->data;
2934 2015890 : if (e->alias.name) {
2935 2015890 : int key = exp_key(e);
2936 :
2937 2015890 : if (hash_add(exps->ht, key, e) == NULL)
2938 : return res;
2939 : }
2940 : }
2941 : }
2942 1644949 : if (exps->ht) {
2943 986023 : int key = hash_key(cname);
2944 986023 : sql_hash_e *he = exps->ht->buckets[key&(exps->ht->size-1)];
2945 :
2946 2775196 : for (; he; he = he->chain) {
2947 1791285 : sql_exp *e = he->value;
2948 :
2949 1791285 : if (e && e->alias.name && e->alias.rname && strcmp(e->alias.name, cname) == 0 && strcmp(e->alias.rname, rname) == 0) {
2950 724852 : if (res && multiple)
2951 0 : *multiple = 1;
2952 724852 : if (!res)
2953 : res = e;
2954 724852 : if (res && has_label(res)) /* aliases maybe used multiple times without problems */
2955 2112 : return res;
2956 : }
2957 : }
2958 983911 : return res;
2959 : }
2960 2196136 : for (en = exps->h; en; en = en->next ) {
2961 1544392 : sql_exp *e = en->data;
2962 :
2963 1544392 : if (e && e->alias.name && e->alias.rname && strcmp(e->alias.name, cname) == 0 && strcmp(e->alias.rname, rname) == 0) {
2964 442933 : if (res && multiple)
2965 1 : *multiple = 1;
2966 442933 : if (!res)
2967 : res = e;
2968 442933 : if (res && has_label(res)) /* aliases maybe used multiple times without problems */
2969 7182 : return res;
2970 : }
2971 : }
2972 : }
2973 : return res;
2974 : }
2975 :
2976 : /* find an column based on the original name, not the alias it got */
2977 : sql_exp *
2978 0 : exps_bind_alias( list *exps, const char *rname, const char *cname )
2979 : {
2980 0 : if (exps) {
2981 0 : node *en;
2982 :
2983 0 : for (en = exps->h; en; en = en->next ) {
2984 0 : sql_exp *e = en->data;
2985 :
2986 0 : if (e && is_column(e->type) && !rname && e->r && strcmp(e->r, cname) == 0)
2987 : {
2988 0 : assert(0);
2989 : return e;
2990 : }
2991 0 : if (e && e->type == e_column && rname && e->l && e->r && strcmp(e->r, cname) == 0 && strcmp(e->l, rname) == 0) {
2992 0 : assert(0);
2993 : return e;
2994 : }
2995 : }
2996 : }
2997 0 : return NULL;
2998 : }
2999 :
3000 : unsigned int
3001 3234273 : exps_card( list *l )
3002 : {
3003 3234273 : node *n;
3004 3234273 : unsigned int card = CARD_ATOM;
3005 :
3006 14376560 : if (l) for(n = l->h; n; n = n->next) {
3007 11142287 : sql_exp *e = n->data;
3008 :
3009 11142287 : if (e && card < e->card)
3010 11142287 : card = e->card;
3011 : }
3012 3234273 : return card;
3013 : }
3014 :
3015 : void
3016 43242 : exps_fix_card( list *exps, unsigned int card)
3017 : {
3018 43242 : if (exps)
3019 1061545 : for (node *n = exps->h; n; n = n->next) {
3020 1018303 : sql_exp *e = n->data;
3021 :
3022 1018303 : if (e && e->card > card)
3023 0 : e->card = card;
3024 : }
3025 43242 : }
3026 :
3027 : void
3028 4043 : exps_setcard( list *exps, unsigned int card)
3029 : {
3030 4043 : if (exps)
3031 23834 : for (node *n = exps->h; n; n = n->next) {
3032 19791 : sql_exp *e = n->data;
3033 :
3034 19791 : if (e && e->card != CARD_ATOM)
3035 19762 : e->card = card;
3036 : }
3037 4043 : }
3038 :
3039 : int
3040 0 : exps_intern(list *exps)
3041 : {
3042 0 : if (exps)
3043 0 : for (node *n=exps->h; n; n = n->next) {
3044 0 : sql_exp *e = n->data;
3045 :
3046 0 : if (is_intern(e))
3047 : return 1;
3048 : }
3049 : return 0;
3050 : }
3051 :
3052 : sql_exp *
3053 3498 : exps_find_one_multi_exp(list *exps)
3054 : {
3055 3498 : sql_exp *l = NULL;
3056 3498 : int skip = 0;
3057 :
3058 : /* Find one and only 1 expression with card > CARD_ATOM */
3059 3498 : if (!list_empty(exps)) {
3060 7191 : for (node *m = exps->h ; m && !skip ; m = m->next) {
3061 3693 : sql_exp *e = m->data;
3062 :
3063 3693 : if (e->card > CARD_ATOM) {
3064 3465 : skip |= l != NULL;
3065 3465 : l = e;
3066 : }
3067 : }
3068 : }
3069 3498 : if (skip)
3070 6 : l = NULL;
3071 3498 : return l;
3072 : }
3073 :
3074 : const char *
3075 128145 : compare_func( comp_type t, int anti )
3076 : {
3077 128145 : switch(t) {
3078 73795 : case cmp_equal:
3079 73795 : return anti?"<>":"=";
3080 8005 : case cmp_lt:
3081 8005 : return anti?">":"<";
3082 2102 : case cmp_lte:
3083 2102 : return anti?">=":"<=";
3084 1159 : case cmp_gte:
3085 1159 : return anti?"<=":">=";
3086 31128 : case cmp_gt:
3087 31128 : return anti?"<":">";
3088 11956 : case cmp_notequal:
3089 11956 : return anti?"=":"<>";
3090 : default:
3091 : return NULL;
3092 : }
3093 : }
3094 :
3095 : int
3096 9481442 : is_identity( sql_exp *e, sql_rel *r)
3097 : {
3098 9492254 : switch(e->type) {
3099 36900 : case e_column:
3100 36900 : if (r && is_project(r->op) && !is_set(r->op)) {
3101 13634 : sql_exp *re = NULL;
3102 13634 : assert(e->nid);
3103 13634 : re = exps_bind_nid(r->exps, e->nid);
3104 13634 : if (re)
3105 10812 : return is_identity(re, r->l);
3106 : }
3107 : return 0;
3108 9448325 : case e_func: {
3109 9448325 : sql_subfunc *f = e->f;
3110 9448325 : return !f->func->s && strcmp(f->func->base.name, "identity") == 0;
3111 : }
3112 : default:
3113 : return 0;
3114 : }
3115 : }
3116 :
3117 : list *
3118 14 : exps_alias(mvc *sql, list *exps)
3119 : {
3120 14 : list *nl = new_exp_list(sql->sa);
3121 :
3122 14 : if (exps)
3123 58 : for (node *n = exps->h; n; n = n->next) {
3124 44 : sql_exp *e = n->data, *ne;
3125 :
3126 44 : assert(exp_name(e));
3127 44 : ne = exp_ref(sql, e);
3128 44 : append(nl, ne);
3129 : }
3130 14 : return nl;
3131 : }
3132 :
3133 : list *
3134 140336 : exps_copy(mvc *sql, list *exps)
3135 : {
3136 140336 : list *nl;
3137 :
3138 140336 : if (mvc_highwater(sql))
3139 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3140 :
3141 140336 : if (!exps)
3142 : return NULL;
3143 122139 : nl = new_exp_list(sql->sa);
3144 551295 : for (node *n = exps->h; n; n = n->next) {
3145 429156 : sql_exp *arg = n->data;
3146 :
3147 429156 : arg = exp_copy(sql, arg);
3148 429156 : if (!arg)
3149 : return NULL;
3150 429156 : append(nl, arg);
3151 : }
3152 : return nl;
3153 : }
3154 :
3155 : sql_exp *
3156 2594617 : exp_copy(mvc *sql, sql_exp * e)
3157 : {
3158 2594617 : sql_exp *l, *r, *r2, *ne = NULL;
3159 :
3160 2594617 : if (mvc_highwater(sql))
3161 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3162 :
3163 2594617 : if (!e)
3164 : return NULL;
3165 2594617 : switch(e->type){
3166 2235517 : case e_column:
3167 2235517 : ne = exp_column(sql->sa, e->l, e->r, exp_subtype(e), e->card, has_nil(e), is_unique(e), is_intern(e));
3168 2235517 : ne->flag = e->flag;
3169 2235517 : ne->alias.label = e->alias.label;
3170 2235517 : ne->nid = e->nid;
3171 2235517 : break;
3172 43165 : case e_cmp:
3173 43165 : if (e->flag == cmp_or || e->flag == cmp_filter) {
3174 3307 : list *l = exps_copy(sql, e->l);
3175 3307 : list *r = exps_copy(sql, e->r);
3176 :
3177 3307 : if (e->flag == cmp_filter)
3178 590 : ne = exp_filter(sql->sa, l, r, e->f, is_anti(e));
3179 : else
3180 2717 : ne = exp_or(sql->sa, l, r, is_anti(e));
3181 39858 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
3182 1420 : sql_exp *l = exp_copy(sql, e->l);
3183 1420 : list *r = exps_copy(sql, e->r);
3184 :
3185 1420 : ne = exp_in(sql->sa, l, r, e->flag);
3186 : } else {
3187 38438 : l = exp_copy(sql, e->l);
3188 38438 : r = exp_copy(sql, e->r);
3189 :
3190 38438 : if (e->f) {
3191 687 : r2 = exp_copy(sql, e->f);
3192 687 : ne = exp_compare2(sql->sa, l, r, r2, e->flag, is_symmetric(e));
3193 : } else {
3194 37751 : ne = exp_compare(sql->sa, l, r, e->flag);
3195 : }
3196 : }
3197 : break;
3198 27839 : case e_convert:
3199 27839 : ne = exp_convert(sql, exp_copy(sql, e->l), exp_fromtype(e), exp_totype(e));
3200 27839 : break;
3201 13467 : case e_aggr:
3202 : case e_func: {
3203 13467 : list *l = exps_copy(sql, e->l);
3204 :
3205 13467 : if (e->type == e_func)
3206 11523 : ne = exp_op(sql->sa, l, e->f);
3207 : else
3208 1944 : ne = exp_aggr(sql->sa, l, e->f, need_distinct(e), need_no_nil(e), e->card, has_nil(e));
3209 13467 : if (e->r) { /* copy obe and gbe lists */
3210 1 : list *er = (list*) e->r;
3211 1 : assert(list_length(er) <= 2);
3212 1 : if (list_length(er) == 2)
3213 0 : ne->r = list_append(list_append(sa_list(sql->sa), exps_copy(sql, er->h->data)), exps_copy(sql, er->h->next->data));
3214 : else
3215 1 : ne->r = list_append(sa_list(sql->sa), exps_copy(sql, er->h->data));
3216 : }
3217 : break;
3218 : }
3219 274625 : case e_atom:
3220 274625 : if (e->l)
3221 270597 : ne = exp_atom(sql->sa, e->l);
3222 4028 : else if (e->r) {
3223 3472 : sql_var_name *vname = (sql_var_name*) e->r;
3224 3472 : ne = exp_param_or_declared(sql->sa, vname->sname, vname->name, &e->tpe, e->flag);
3225 556 : } else if (e->f)
3226 3 : ne = exp_values(sql->sa, exps_copy(sql, e->f));
3227 : else
3228 553 : ne = exp_atom_ref(sql->sa, e->flag, &e->tpe);
3229 : break;
3230 4 : case e_psm:
3231 4 : if (e->flag & PSM_SET) {
3232 0 : ne = exp_set(sql->sa, e->alias.rname, e->alias.name, exp_copy(sql, e->l), GET_PSM_LEVEL(e->flag));
3233 4 : } else if (e->flag & PSM_VAR) {
3234 0 : if (e->f)
3235 0 : ne = exp_table(sql->sa, e->alias.name, e->f, GET_PSM_LEVEL(e->flag));
3236 : else
3237 0 : ne = exp_var(sql->sa, e->alias.rname, e->alias.name, &e->tpe, GET_PSM_LEVEL(e->flag));
3238 4 : } else if (e->flag & PSM_RETURN) {
3239 0 : ne = exp_return(sql->sa, exp_copy(sql, e->l), GET_PSM_LEVEL(e->flag));
3240 4 : } else if (e->flag & PSM_WHILE) {
3241 0 : ne = exp_while(sql->sa, exp_copy(sql, e->l), exps_copy(sql, e->r));
3242 4 : } else if (e->flag & PSM_IF) {
3243 0 : ne = exp_if(sql->sa, exp_copy(sql, e->l), exps_copy(sql, e->r), exps_copy(sql, e->f));
3244 4 : } else if (e->flag & PSM_REL) {
3245 4 : if (!e->alias.label)
3246 4 : exp_label(sql->sa, e, ++sql->label);
3247 4 : return exp_ref(sql, e);
3248 0 : } else if (e->flag & PSM_EXCEPTION) {
3249 0 : ne = exp_exception(sql->sa, exp_copy(sql, e->l), (const char *) e->r);
3250 : }
3251 : break;
3252 : }
3253 2594613 : if (!ne)
3254 0 : return ne;
3255 2594613 : if (e->alias.name)
3256 2391695 : exp_prop_alias(sql->sa, ne, e);
3257 2594613 : ne = exp_propagate(sql->sa, ne, e);
3258 2594613 : if (is_freevar(e))
3259 8261 : set_freevar(ne, is_freevar(e)-1);
3260 : return ne;
3261 : }
3262 :
3263 : /* scaling for the division operator */
3264 : static sql_exp *
3265 2604 : exp_scale_algebra(mvc *sql, sql_subfunc *f, sql_rel *rel, sql_exp *l, sql_exp *r)
3266 : {
3267 2604 : sql_subtype *lt = exp_subtype(l);
3268 2604 : sql_subtype *rt = exp_subtype(r);
3269 :
3270 2604 : if (!EC_INTERVAL(lt->type->eclass) && lt->type->scale == SCALE_FIX && (lt->scale || rt->scale) &&
3271 338 : strcmp(sql_func_imp(f->func), "/") == 0) {
3272 170 : sql_subtype *res = f->res->h->data;
3273 170 : unsigned int scale, digits, digL, scaleL;
3274 170 : sql_subtype nlt;
3275 :
3276 : /* scale fixing may require a larger type ! */
3277 : /* TODO make '3' setable by user (division_minimal_scale or so) */
3278 170 : scaleL = (lt->scale < 3) ? 3 : lt->scale;
3279 170 : scaleL += (scaleL < rt->scale)?(rt->scale - scaleL):0;
3280 170 : scale = scaleL;
3281 170 : scaleL += rt->scale;
3282 170 : digL = lt->digits + (scaleL - lt->scale);
3283 170 : digits = (digL > rt->digits) ? digL : rt->digits;
3284 :
3285 : /* HACK alert: digits should be less than max */
3286 : #ifdef HAVE_HGE
3287 170 : if (res->type->radix == 10 && digits > 38)
3288 170 : digits = 38;
3289 170 : if (res->type->radix == 2 && digits > 127)
3290 170 : digits = 127;
3291 : #else
3292 : if (res->type->radix == 10 && digits > 18)
3293 : digits = 18;
3294 : if (res->type->radix == 2 && digits > 63)
3295 : digits = 63;
3296 : #endif
3297 :
3298 170 : sql_find_subtype(&nlt, lt->type->base.name, digL, scaleL);
3299 170 : if (nlt.digits < scaleL)
3300 2 : return sql_error(sql, 01, SQLSTATE(42000) "Scale (%d) overflows type", scaleL);
3301 168 : l = exp_check_type(sql, &nlt, rel, l, type_equal);
3302 :
3303 168 : sql_find_subtype(res, lt->type->base.name, digits, scale);
3304 2434 : } else if (lt->type->scale == SCALE_FIX) {
3305 2236 : sql_subtype *res = f->res->h->data;
3306 2236 : if (res->type->eclass == EC_NUM)
3307 2215 : res->digits = MAX(lt->digits, rt->digits);
3308 : }
3309 : return l;
3310 : }
3311 :
3312 : sql_exp *
3313 2604 : exps_scale_algebra(mvc *sql, sql_subfunc *f, sql_rel *rel, list *exps)
3314 : {
3315 2604 : if (list_length(exps) != 2)
3316 : return NULL;
3317 2604 : sql_exp *e = exp_scale_algebra(sql, f, rel, exps->h->data, exps->h->next->data);
3318 2604 : if (e)
3319 2602 : exps->h->data = e;
3320 : return e;
3321 : }
3322 :
3323 : void
3324 181313 : exps_digits_add(sql_subfunc *f, list *exps)
3325 : {
3326 : /* concat and friends need larger results */
3327 181313 : if (!f->func->res)
3328 : return;
3329 181313 : int digits = 0;
3330 323391 : for(node *n = exps->h; n; n = n->next) {
3331 264544 : sql_subtype *t = exp_subtype(n->data);
3332 :
3333 264544 : if (!t->digits) {
3334 : digits = 0;
3335 : break;
3336 : }
3337 142078 : digits += t->digits;
3338 : }
3339 181313 : sql_subtype *res = f->res->h->data;
3340 181313 : res->digits = digits;
3341 : }
3342 :
3343 : void
3344 25185 : exps_sum_scales(sql_subfunc *f, list *exps)
3345 : {
3346 : /* sum scales and digits for multiply operation */
3347 25185 : sql_arg *ares = f->func->res->h->data;
3348 :
3349 25185 : if (ares->type.type->scale == SCALE_FIX && strcmp(sql_func_imp(f->func), "*") == 0) {
3350 23886 : unsigned int digits = 0, scale = 0;
3351 23886 : sql_type *largesttype = ares->type.type;
3352 :
3353 71658 : for(node *n = exps->h; n; n = n->next) {
3354 47772 : sql_exp *e = n->data;
3355 47772 : sql_subtype *t = exp_subtype(e);
3356 :
3357 47772 : scale += t->scale;
3358 47772 : digits += t->digits;
3359 47772 : if (largesttype->localtype < t->type->localtype)
3360 0 : largesttype = t->type;
3361 : }
3362 23886 : sql_subtype *res = f->res->h->data;
3363 :
3364 23886 : res->scale = scale;
3365 23886 : res->digits = digits;
3366 :
3367 : /* HACK alert: digits should be less than max */
3368 : #ifdef HAVE_HGE
3369 23886 : if (ares->type.type->radix == 10 && res->digits > 38) {
3370 2473 : res->digits = 38;
3371 2473 : res->scale = MIN(res->scale, res->digits - 1);
3372 : }
3373 23886 : if (ares->type.type->radix == 2 && res->digits > 127) {
3374 25 : res->digits = 127;
3375 25 : res->scale = MIN(res->scale, res->digits - 1);
3376 : }
3377 : #else
3378 : if (ares->type.type->radix == 10 && res->digits > 18) {
3379 : res->digits = 18;
3380 : res->scale = MIN(res->scale, res->digits - 1);
3381 : }
3382 : if (ares->type.type->radix == 2 && res->digits > 63) {
3383 : res->digits = 63;
3384 : res->scale = MIN(res->scale, res->digits - 1);
3385 : }
3386 : #endif
3387 :
3388 23886 : sql_subtype t;
3389 : /* numeric types are fixed length */
3390 23886 : if (ares->type.type->eclass == EC_NUM) {
3391 : #ifdef HAVE_HGE
3392 21121 : if (ares->type.type->localtype == TYPE_hge && res->digits == 127)
3393 25 : t = *sql_bind_localtype("hge");
3394 : else
3395 : #endif
3396 21096 : if (ares->type.type->localtype == TYPE_lng && res->digits == 63)
3397 3 : t = *sql_bind_localtype("lng");
3398 21093 : else if (res->type->digits >= res->digits)
3399 8854 : t = *res; /* we cannot reduce types! */
3400 : else
3401 12239 : sql_find_numeric(&t, ares->type.type->localtype, res->digits);
3402 : } else {
3403 2765 : if (res->digits > largesttype->digits)
3404 218 : sql_find_subtype(&t, largesttype->base.name, res->digits, res->scale);
3405 : else
3406 2547 : sql_init_subtype(&t, largesttype, res->digits, res->scale);
3407 : }
3408 23886 : *res = t;
3409 : }
3410 25185 : }
3411 :
3412 : void
3413 111660 : exps_max_bits(sql_subfunc *f, list *exps)
3414 : {
3415 : /* + and - have max_bits + 1 */
3416 111660 : if (!f->func->res)
3417 : return;
3418 111660 : unsigned int digits = 0;
3419 334980 : for(node *n = exps->h; n; n = n->next) {
3420 223320 : sql_subtype *t = exp_subtype(n->data);
3421 :
3422 223320 : if (!t)
3423 0 : continue;
3424 223320 : if (digits < t->digits)
3425 223320 : digits = t->digits;
3426 : }
3427 : /* + and - (because of negative numbers) could need one extra bit (or digit) */
3428 111660 : digits += 1;
3429 111660 : sql_subtype *res = f->res->h->data;
3430 111660 : if (digits > res->type->digits)
3431 47703 : res = sql_find_numeric(res, res->type->localtype, digits);
3432 : else
3433 63957 : res->digits = digits;
3434 : }
3435 :
3436 : void
3437 19015 : exps_inout(sql_subfunc *f, list *exps)
3438 : {
3439 : /* output == first input */
3440 19015 : if (!f->func->res)
3441 : return;
3442 19015 : sql_subtype *res = f->res->h->data;
3443 19015 : bool is_decimal = (res->type->eclass == EC_DEC);
3444 19015 : unsigned int digits = 0, scale = 0;
3445 19015 : sql_type *largesttype = NULL;
3446 19015 : for(node *n = exps->h; n; n = n->next) {
3447 19015 : sql_subtype *t = exp_subtype(n->data);
3448 :
3449 19015 : if (!t)
3450 0 : continue;
3451 :
3452 19015 : if (is_decimal && t->type->eclass == EC_DEC && (!largesttype || largesttype->localtype < t->type->localtype))
3453 390 : largesttype = t->type;
3454 390 : if (is_decimal && t->type->eclass == EC_NUM) {
3455 0 : unsigned int d = bits2digits(t->digits);
3456 0 : digits = d>digits?d:digits;
3457 19015 : } else if (digits < t->digits)
3458 : digits = t->digits;
3459 19015 : if (scale < t->scale)
3460 : scale = t->scale;
3461 : break;
3462 : }
3463 19015 : if (digits > res->digits || scale > res->scale) {
3464 9203 : if (largesttype)
3465 376 : sql_init_subtype(res, largesttype, digits, scale);
3466 : else
3467 8827 : sql_find_subtype(res, res->type->base.name, digits, scale);
3468 : } else
3469 9812 : res->digits = digits;
3470 : }
3471 :
3472 : /* for aggregates we can reduce the result types size based on real digits/bits used number of known input rows */
3473 : void
3474 9314 : exps_largest_int(sql_subfunc *f, list *exps, lng cnt)
3475 : {
3476 9314 : if (!f->func->res || cnt == 0)
3477 : return;
3478 552 : sql_subtype *res = f->res->h->data;
3479 552 : if (res->type->eclass != EC_DEC && res->type->eclass != EC_NUM)
3480 : return;
3481 476 : bool is_decimal = (res->type->eclass == EC_DEC);
3482 476 : unsigned int digits = 0, scale = 0, mdigits = is_decimal ? decimal_digits(cnt) : number_bits(cnt);
3483 476 : sql_type *largesttype = NULL;
3484 476 : for(node *n = exps->h; n; n = n->next) {
3485 476 : sql_subtype *t = exp_subtype(n->data);
3486 :
3487 476 : if (!t)
3488 0 : continue;
3489 :
3490 476 : largesttype = t->type;
3491 476 : if (is_decimal && t->type->eclass == EC_NUM) {
3492 0 : unsigned int d = bits2digits(t->digits);
3493 0 : digits = d>digits?d:digits;
3494 476 : } else if (digits < t->digits)
3495 : digits = t->digits;
3496 476 : if (scale < t->scale)
3497 : scale = t->scale;
3498 : break;
3499 : }
3500 476 : digits += mdigits;
3501 476 : if (largesttype && digits <= largesttype->digits)
3502 412 : sql_init_subtype(res, largesttype, digits, scale);
3503 64 : else if (is_decimal)
3504 8 : sql_find_subtype(res, res->type->base.name, digits, scale);
3505 : else
3506 56 : sql_find_numeric(res, 1, digits);
3507 : }
3508 :
3509 : #define is_addition(fname) (strcmp(fname, "sql_add") == 0)
3510 : #define is_subtraction(fname) (strcmp(fname, "sql_sub") == 0)
3511 : void
3512 270498 : exps_scale_fix(sql_subfunc *f, list *exps, sql_subtype *atp)
3513 : {
3514 270498 : if (!f->func->res)
3515 : return;
3516 :
3517 270498 : sql_subtype *res = f->res->h->data;
3518 270498 : if (res->type->eclass != EC_ANY && res->type->eclass != EC_DEC)
3519 : return;
3520 :
3521 61595 : unsigned int digits = 0, scale = 0;
3522 61595 : sql_type *largesttype = NULL;
3523 239620 : for(node *n = exps->h; n; n = n->next) {
3524 178025 : sql_subtype *t = exp_subtype(n->data);
3525 :
3526 178025 : if (!t)
3527 0 : continue;
3528 178025 : if (digits < t->digits)
3529 : digits = t->digits;
3530 178025 : if (scale < t->scale)
3531 : scale = t->scale;
3532 178025 : if (t->type->eclass == EC_DEC && (!largesttype || largesttype->localtype < t->type->localtype))
3533 178025 : largesttype = t->type;
3534 : }
3535 61595 : res->scale = scale;
3536 61595 : if (res->type->eclass == EC_DEC)
3537 646 : digits += (is_addition(f->func->base.name) || is_subtraction(f->func->base.name));
3538 61595 : if (digits > res->type->digits) {
3539 61273 : if (largesttype && largesttype->localtype > res->type->localtype)
3540 75 : sql_init_subtype(res, largesttype, digits, scale);
3541 : else
3542 61198 : sql_find_subtype(res, res->type->localtype?res->type->base.name:atp->type->base.name, digits, scale);
3543 322 : } else if (res->type->eclass == EC_DEC || res->type->eclass == EC_NUM)
3544 252 : res->digits = digits;
3545 : }
3546 :
3547 : int
3548 126415 : exp_aggr_is_count(sql_exp *e)
3549 : {
3550 126415 : if (e->type == e_aggr && !((sql_subfunc *)e->f)->func->s && strcmp(((sql_subfunc *)e->f)->func->base.name, "count") == 0)
3551 34757 : return 1;
3552 : return 0;
3553 : }
3554 :
3555 : list *
3556 66772 : check_distinct_exp_names(mvc *sql, list *exps)
3557 : {
3558 66772 : list *distinct_exps = NULL;
3559 66772 : bool duplicates = false;
3560 :
3561 66772 : if (list_length(exps) < 2) {
3562 : return exps; /* always true */
3563 64982 : } else if (list_length(exps) < 5) {
3564 14343 : distinct_exps = list_distinct(exps, (fcmp) exp_equal, (fdup) NULL);
3565 : } else { /* for longer lists, use hashing */
3566 50639 : sql_hash *ht = hash_new(sql->ta, list_length(exps), (fkeyvalue)&exp_key);
3567 :
3568 501164 : for (node *n = exps->h; n && !duplicates; n = n->next) {
3569 450525 : sql_exp *e = n->data;
3570 450525 : int key = ht->key(e);
3571 450525 : sql_hash_e *he = ht->buckets[key&(ht->size-1)];
3572 :
3573 581257 : for (; he && !duplicates; he = he->chain) {
3574 130732 : sql_exp *f = he->value;
3575 :
3576 130732 : if (!exp_equal(e, f))
3577 0 : duplicates = true;
3578 : }
3579 450525 : hash_add(ht, key, e);
3580 : }
3581 : }
3582 64982 : if ((distinct_exps && list_length(distinct_exps) != list_length(exps)) || duplicates)
3583 1 : return NULL;
3584 : return exps;
3585 : }
3586 :
3587 : static int rel_find_parameter(mvc *sql, sql_subtype *type, sql_rel *rel, int nid, const char *relname, const char *expname);
3588 :
3589 : static int
3590 1634 : set_exp_type(mvc *sql, sql_subtype *type, sql_rel *rel, sql_exp *e)
3591 : {
3592 1640 : if (mvc_highwater(sql)) {
3593 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3594 0 : return -1;
3595 : }
3596 1640 : if (e->type == e_column) {
3597 60 : const char *nrname = (const char*) e->l, *nename = (const char*) e->r;
3598 : /* find all the column references and set the type */
3599 60 : e->tpe = *type;
3600 60 : assert(e->nid);
3601 60 : return rel_find_parameter(sql, type, rel, e->nid, nrname, nename);
3602 1580 : } else if (e->type == e_atom && e->f) {
3603 25 : list *atoms = e->f;
3604 25 : if (!list_empty(atoms))
3605 61 : for (node *n = atoms->h; n; n = n->next)
3606 36 : if (set_exp_type(sql, type, rel, n->data) < 0) /* set recursively */
3607 : return -1;
3608 25 : e->tpe = *type;
3609 25 : return 1; /* on a list of atoms, everything should be found */
3610 1555 : } else if (e->type == e_atom && !e->l && !e->r && !e->f) {
3611 1549 : e->tpe = *type;
3612 1549 : return set_type_param(sql, type, e->flag) == 0 ? 1 : 0;
3613 6 : } else if (exp_is_rel(e)) { /* for relation expressions, restart cycle */
3614 6 : rel = (sql_rel*) e->l;
3615 : /* limiting to these cases */
3616 6 : if (!is_project(rel->op) || list_length(rel->exps) != 1)
3617 0 : return 0;
3618 6 : sql_exp *re = rel->exps->h->data;
3619 :
3620 6 : e->tpe = *type;
3621 6 : return set_exp_type(sql, type, rel, re); /* set recursively */
3622 : }
3623 : return 0;
3624 : }
3625 :
3626 : int
3627 1542 : rel_set_type_param(mvc *sql, sql_subtype *type, sql_rel *rel, sql_exp *exp, int upcast)
3628 : {
3629 1542 : if (!type || !exp || (exp->type != e_atom && exp->type != e_column && !exp_is_rel(exp)))
3630 0 : return -1;
3631 :
3632 : /* use largest numeric types */
3633 1542 : if (upcast && type->type->eclass == EC_NUM)
3634 : #ifdef HAVE_HGE
3635 9 : type = sql_bind_localtype("hge");
3636 : #else
3637 : type = sql_bind_localtype("lng");
3638 : #endif
3639 6 : else if (upcast && type->type->eclass == EC_FLT)
3640 1 : type = sql_bind_localtype("dbl");
3641 :
3642 : /* TODO we could use the sql_query* struct to set parameters used as freevars,
3643 : but it requires to change a lot of interfaces */
3644 : /* if (is_freevar(exp))
3645 : rel = query_fetch_outer(query, is_freevar(exp)-1); */
3646 1542 : return set_exp_type(sql, type, rel, exp);
3647 : }
3648 :
3649 : /* try to do an in-place conversion
3650 : *
3651 : * in-place conversion is only possible if the exp is a variable.
3652 : * This is only done to be able to map more cached queries onto the same
3653 : * interface.
3654 : */
3655 : sql_exp *
3656 4874806 : exp_convert_inplace(mvc *sql, sql_subtype *t, sql_exp *exp)
3657 : {
3658 4874806 : atom *a, *na;
3659 :
3660 : /* exclude named variables and variable lists */
3661 4874806 : if (exp->type != e_atom || exp->r /* named */ || exp->f /* list */ || !exp->l /* not direct atom */)
3662 : return NULL;
3663 :
3664 2725247 : a = exp->l;
3665 2725247 : if (!a->isnull && t->scale && t->type->eclass != EC_FLT)
3666 : return NULL;
3667 :
3668 2719973 : if ((na = atom_cast(sql->sa, a, t))) {
3669 2716742 : exp->l = na;
3670 2716742 : return exp;
3671 : }
3672 : return NULL;
3673 : }
3674 :
3675 : sql_exp *
3676 0 : exp_numeric_supertype(mvc *sql, sql_exp *e )
3677 : {
3678 0 : sql_subtype *tp = exp_subtype(e);
3679 :
3680 0 : if (tp->type->eclass == EC_DEC) {
3681 0 : sql_subtype *dtp = sql_bind_localtype("dbl");
3682 :
3683 0 : return exp_check_type(sql, dtp, NULL, e, type_cast);
3684 : }
3685 0 : if (tp->type->eclass == EC_NUM) {
3686 : #ifdef HAVE_HGE
3687 0 : sql_subtype *ltp = sql_bind_localtype("hge");
3688 : #else
3689 : sql_subtype *ltp = sql_bind_localtype("lng");
3690 : #endif
3691 :
3692 0 : return exp_check_type(sql, ltp, NULL, e, type_cast);
3693 : }
3694 : return e;
3695 : }
3696 :
3697 : sql_exp *
3698 4874153 : exp_check_type(mvc *sql, sql_subtype *t, sql_rel *rel, sql_exp *exp, check_type tpe)
3699 : {
3700 4874153 : int c, err = 0;
3701 4874153 : sql_exp* nexp = NULL;
3702 4874153 : sql_subtype *fromtype = exp_subtype(exp);
3703 :
3704 4874222 : if ((!fromtype || !fromtype->type) && rel_set_type_param(sql, t, rel, exp, 0) == 0)
3705 : return exp;
3706 :
3707 : /* first try cheap internal (in-place) conversions ! */
3708 4874221 : if ((nexp = exp_convert_inplace(sql, t, exp)) != NULL)
3709 : return nexp;
3710 :
3711 2157734 : if (fromtype && subtype_cmp(t, fromtype) != 0) {
3712 254815 : if (EC_INTERVAL(fromtype->type->eclass) && (t->type->eclass == EC_NUM || t->type->eclass == EC_POS) && t->digits < fromtype->digits) {
3713 : err = 1; /* conversion from interval to num depends on the number of digits */
3714 : } else {
3715 254815 : c = sql_type_convert(fromtype->type->eclass, t->type->eclass);
3716 254815 : if (!c || (c == 2 && tpe == type_set) || (c == 3 && tpe != type_cast)) {
3717 : err = 1;
3718 : } else {
3719 254300 : exp = exp_convert(sql, exp, fromtype, t);
3720 : }
3721 : }
3722 : }
3723 254300 : if (err) {
3724 515 : const char *name = (exp->type == e_column && !has_label(exp)) ? exp_name(exp) : "%";
3725 578 : sql_exp *res = sql_error( sql, 03, SQLSTATE(42000) "types %s(%u,%u) and %s(%u,%u) are not equal%s%s%s",
3726 515 : fromtype->type->base.name,
3727 : fromtype->digits,
3728 : fromtype->scale,
3729 515 : t->type->base.name,
3730 : t->digits,
3731 : t->scale,
3732 : (name[0] != '%' ? " for column '" : ""),
3733 : (name[0] != '%' ? name : ""),
3734 515 : (name[0] != '%' ? "'" : "")
3735 : );
3736 515 : return res;
3737 : }
3738 : return exp;
3739 : }
3740 :
3741 : sql_exp *
3742 7014 : exp_values_set_supertype(mvc *sql, sql_exp *values, sql_subtype *opt_super)
3743 : {
3744 7014 : assert(is_values(values));
3745 7014 : list *vals = exp_get_values(values), *nexps;
3746 7014 : sql_subtype *tpe = opt_super?opt_super:exp_subtype(vals->h->data);
3747 :
3748 7014 : if (!opt_super && tpe)
3749 6914 : values->tpe = *tpe;
3750 :
3751 30454 : for (node *m = vals->h; m; m = m->next) {
3752 23440 : sql_exp *e = m->data;
3753 23440 : sql_subtype super, *ttpe;
3754 :
3755 : /* if the expression is a parameter set its type */
3756 23440 : if (tpe && e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
3757 4 : if (set_type_param(sql, tpe, e->flag) == 0)
3758 4 : e->tpe = *tpe;
3759 : else
3760 0 : return NULL;
3761 : }
3762 23440 : ttpe = exp_subtype(e);
3763 23440 : if (tpe && ttpe) {
3764 23387 : supertype(&super, ttpe, tpe);
3765 23387 : values->tpe = super;
3766 23387 : tpe = &values->tpe;
3767 : } else {
3768 : tpe = ttpe;
3769 : }
3770 : }
3771 :
3772 7014 : if (tpe) {
3773 : /* if the expression is a parameter set its type */
3774 30367 : for (node *m = vals->h; m; m = m->next) {
3775 23391 : sql_exp *e = m->data;
3776 23391 : if (e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
3777 1 : if (set_type_param(sql, tpe, e->flag) == 0)
3778 1 : e->tpe = *tpe;
3779 : else
3780 : return NULL;
3781 : }
3782 : }
3783 6976 : values->tpe = *tpe;
3784 6976 : nexps = sa_list(sql->sa);
3785 30362 : for (node *m = vals->h; m; m = m->next) {
3786 23389 : sql_exp *e = m->data;
3787 23389 : e = exp_check_type(sql, &values->tpe, NULL, e, type_equal);
3788 23389 : if (!e)
3789 : return NULL;
3790 23386 : exp_label(sql->sa, e, ++sql->label);
3791 23386 : append(nexps, e);
3792 : }
3793 6973 : values->f = nexps;
3794 : }
3795 : return values;
3796 : }
3797 :
3798 : /* return -1 on error, 0 not found, 1 found */
3799 : static int
3800 86 : rel_find_parameter(mvc *sql, sql_subtype *type, sql_rel *rel, int nid, const char *relname, const char *expname)
3801 : {
3802 138 : int res = 0;
3803 :
3804 138 : if (mvc_highwater(sql)) {
3805 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3806 0 : return -1;
3807 : }
3808 138 : if (!rel)
3809 : return 0;
3810 :
3811 135 : const char *nrname = relname, *nename = expname;
3812 135 : if (is_project(rel->op) && !list_empty(rel->exps)) {
3813 111 : sql_exp *e = NULL;
3814 :
3815 111 : assert(nid);
3816 111 : e = exps_bind_nid(rel->exps, nid);
3817 111 : if (!e)
3818 : return 0; /* not found */
3819 108 : if (is_mset(rel->op)) { /* TODO for set relations this needs further improvement */
3820 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Cannot set parameter types under set relations at the moment");
3821 0 : return -1;
3822 : }
3823 : /* set order by column types */
3824 108 : if (is_simple_project(rel->op) && !list_empty(rel->r)) {
3825 0 : sql_exp *ordere = NULL;
3826 0 : ordere = exps_bind_nid(rel->r, nid);
3827 0 : if (ordere && ordere->type == e_column)
3828 0 : ordere->tpe = *type;
3829 : }
3830 108 : if (e->type == e_column) {
3831 52 : nid = e->nid;
3832 52 : nrname = (const char*) e->l;
3833 52 : nename = (const char*) e->r;
3834 52 : e->tpe = *type;
3835 52 : res = 1; /* found */
3836 56 : } else if ((e->type == e_atom || exp_is_rel(e)) && (res = set_exp_type(sql, type, rel, e)) <= 0) {
3837 : return res; /* don't search further */
3838 : }
3839 : /* group by columns can have aliases! */
3840 108 : if (is_groupby(rel->op) && !list_empty(rel->r)) {
3841 0 : e = exps_bind_nid(rel->r, nid);
3842 0 : if (!e)
3843 : return res; /* don't search further */
3844 0 : if (e->type == e_column) {
3845 0 : nid = e->nid;
3846 0 : nrname = (const char*) e->l;
3847 0 : nename = (const char*) e->r;
3848 0 : e->tpe = *type;
3849 0 : } else if ((e->type == e_atom || exp_is_rel(e)) && (res = set_exp_type(sql, type, rel, e)) <= 0) {
3850 : return res; /* don't search further */
3851 : }
3852 : }
3853 108 : if (e->type != e_column)
3854 : return res; /* don't search further */
3855 : }
3856 :
3857 76 : switch (rel->op) {
3858 14 : case op_join:
3859 : case op_left:
3860 : case op_right:
3861 : case op_full:
3862 14 : if (rel->l)
3863 14 : res = rel_find_parameter(sql, type, rel->l, nid, nrname, nename);
3864 14 : if (rel->r && res <= 0) { /* try other relation if not found */
3865 12 : int err = sql->session->status, lres = res;
3866 12 : char buf[ERRSIZE];
3867 :
3868 12 : strcpy(buf, sql->errstr); /* keep error found and try other join relation */
3869 12 : sql->session->status = 0;
3870 12 : sql->errstr[0] = '\0';
3871 12 : res = rel_find_parameter(sql, type, rel->r, nid, nrname, nename);
3872 12 : if (res == 0) { /* parameter wasn't found, set error */
3873 1 : res = lres;
3874 1 : sql->session->status = err;
3875 1 : strcpy(sql->errstr, buf);
3876 : }
3877 : }
3878 : break;
3879 52 : case op_semi:
3880 : case op_anti:
3881 : case op_groupby:
3882 : case op_project:
3883 : case op_select:
3884 : case op_topn:
3885 : case op_sample:
3886 52 : if (rel->l)
3887 : res = rel_find_parameter(sql, type, rel->l, nid, nrname, nename);
3888 : break;
3889 0 : case op_union: /* TODO for set relations this needs further improvement */
3890 : case op_inter:
3891 : case op_except:
3892 : case op_munion: {
3893 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Cannot set parameter types under set relations at the moment");
3894 0 : return -1;
3895 : }
3896 : default: /* For table returning functions, the type must be set when the relation is created */
3897 : return 0;
3898 : }
3899 : return res;
3900 : }
3901 :
3902 : sql_exp *
3903 18008 : list_find_exp( list *exps, sql_exp *e)
3904 : {
3905 18008 : if (e->type != e_column)
3906 : return NULL;
3907 17967 : return exps_bind_nid(exps, e->nid);
3908 : }
|
