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 826207 : compare_str2type(const char *compare_op)
24 : {
25 826207 : comp_type type = cmp_filter;
26 :
27 826207 : if (compare_op[0] == '=') {
28 : type = cmp_equal;
29 160257 : } else if (compare_op[0] == '<') {
30 103751 : type = cmp_lt;
31 103751 : if (compare_op[1] == '>')
32 : type = cmp_notequal;
33 23254 : else if (compare_op[1] == '=')
34 4164 : type = cmp_lte;
35 56506 : } else if (compare_op[0] == '>') {
36 56506 : type = cmp_gt;
37 56506 : if (compare_op[1] == '=')
38 3337 : type = cmp_gte;
39 : }
40 826207 : return type;
41 : }
42 :
43 : comp_type
44 52258 : swap_compare( comp_type t )
45 : {
46 52258 : 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 99 : compare_funcs2range(const char *l_op, const char *r_op)
130 : {
131 99 : assert(l_op[0] == '>' && r_op[0] == '<');
132 99 : if (!l_op[1] && !r_op[1])
133 : return 0;
134 97 : if (!l_op[1] && r_op[1] == '=')
135 : return 2;
136 97 : if (l_op[1] == '=' && !r_op[1])
137 : return 1;
138 5 : if (l_op[1] == '=' && r_op[1] == '=')
139 : return 3;
140 0 : assert(0);
141 : return 0;
142 : }
143 :
144 : static sql_exp *
145 21299713 : exp_create(allocator *sa, int type)
146 : {
147 21299713 : sql_exp *e = SA_NEW(sa, sql_exp);
148 :
149 21299558 : if (!e)
150 : return NULL;
151 21299558 : *e = (sql_exp) {
152 21299558 : .type = (expression_type) type,
153 : };
154 21299558 : return e;
155 : }
156 :
157 : sql_exp *
158 473324 : exp_compare(allocator *sa, sql_exp *l, sql_exp *r, int cmptype)
159 : {
160 473324 : sql_exp *e = exp_create(sa, e_cmp);
161 473324 : if (e == NULL)
162 : return NULL;
163 473324 : e->card = MAX(l->card,r->card);
164 473324 : e->l = l;
165 473324 : e->r = r;
166 473324 : e->flag = cmptype;
167 473324 : if (!has_nil(l) && !has_nil(r))
168 338792 : set_has_no_nil(e);
169 : return e;
170 : }
171 :
172 : sql_exp *
173 6670 : exp_compare2(allocator *sa, sql_exp *l, sql_exp *r, sql_exp *f, int cmptype, int symmetric)
174 : {
175 6670 : sql_exp *e = exp_create(sa, e_cmp);
176 6670 : if (e == NULL)
177 : return NULL;
178 6670 : assert(f);
179 6670 : e->card = MAX(MAX(l->card,r->card),f->card);
180 6670 : e->l = l;
181 6670 : e->r = r;
182 6670 : e->f = f;
183 6670 : e->flag = cmptype;
184 6670 : if (symmetric)
185 77 : set_symmetric(e);
186 6670 : if (!has_nil(l) && !has_nil(r) && !has_nil(f))
187 1594 : set_has_no_nil(e);
188 : return e;
189 : }
190 :
191 : sql_exp *
192 6380 : exp_filter(allocator *sa, list *l, list *r, sql_subfunc *f, int anti)
193 : {
194 6380 : sql_exp *e = exp_create(sa, e_cmp);
195 :
196 6380 : if (e == NULL)
197 : return NULL;
198 6380 : e->card = MAX(exps_card(l),exps_card(r));
199 6380 : 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 6380 : e->l = l;
209 6380 : e->r = r;
210 6380 : e->f = f;
211 6380 : e->flag = cmp_filter;
212 6380 : if (anti)
213 727 : set_anti(e);
214 6380 : if (!have_nil(l) && !have_nil(r))
215 4578 : set_has_no_nil(e);
216 : return e;
217 : }
218 :
219 : sql_exp *
220 64012 : exp_or(allocator *sa, list *l, list *r, int anti)
221 : {
222 64012 : sql_exp *e = exp_create(sa, e_cmp);
223 :
224 64012 : if (e == NULL)
225 : return NULL;
226 64012 : e->card = MAX(exps_card(l),exps_card(r));
227 64012 : e->l = l;
228 64012 : e->r = r;
229 64012 : e->flag = cmp_or;
230 64012 : if (anti)
231 2 : set_anti(e);
232 64012 : if (!have_nil(l) && !have_nil(r))
233 43040 : set_has_no_nil(e);
234 : return e;
235 : }
236 :
237 : sql_exp *
238 30021 : exp_in(allocator *sa, sql_exp *l, list *r, int cmptype)
239 : {
240 30021 : sql_exp *e = exp_create(sa, e_cmp);
241 30021 : unsigned int exps_card = CARD_ATOM;
242 :
243 30021 : if (e == NULL)
244 : return NULL;
245 :
246 : /* ignore the cardinalites of sub-relations */
247 148348 : for (node *n = r->h; n ; n = n->next) {
248 118327 : sql_exp *next = n->data;
249 :
250 118327 : if (!exp_is_rel(next) && exps_card < next->card)
251 118327 : exps_card = next->card;
252 : }
253 30021 : e->card = MAX(l->card, exps_card);
254 30021 : e->l = l;
255 30021 : e->r = r;
256 30021 : assert( cmptype == cmp_in || cmptype == cmp_notin);
257 30021 : e->flag = cmptype;
258 30021 : if (!has_nil(l) && !have_nil(r))
259 23552 : set_has_no_nil(e);
260 : return e;
261 : }
262 :
263 : sql_exp *
264 32830 : exp_in_func(mvc *sql, sql_exp *le, sql_exp *vals, int anyequal, int is_tuple)
265 : {
266 32830 : sql_subfunc *a_func = NULL;
267 32830 : sql_exp *e = le;
268 :
269 32830 : if (is_tuple) {
270 4106 : list *l = exp_get_values(e);
271 4106 : e = l->h->data;
272 : }
273 37189 : 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 32830 : e = exp_binop(sql->sa, le, vals, a_func);
276 32830 : if (e) {
277 32830 : unsigned int exps_card = CARD_ATOM;
278 :
279 : /* ignore the cardinalites of sub-relations */
280 32830 : if (vals->type == e_atom && vals->f) {
281 157170 : for (node *n = ((list*)vals->f)->h ; n ; n = n->next) {
282 124340 : sql_exp *next = n->data;
283 :
284 124340 : if (!exp_is_rel(next) && exps_card < next->card)
285 124340 : exps_card = next->card;
286 : }
287 0 : } else if (!exp_is_rel(vals))
288 0 : exps_card = vals->card;
289 :
290 32830 : e->card = MAX(le->card, exps_card);
291 32830 : 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 120889 : exp_compare_func(mvc *sql, sql_exp *le, sql_exp *re, const char *compareop, int quantifier)
333 : {
334 120889 : sql_subfunc *cmp_func = sql_bind_func(sql, "sys", compareop, exp_subtype(le), exp_subtype(le), F_FUNC, true, true);
335 120889 : sql_exp *e = NULL;
336 :
337 120889 : if (cmp_func == NULL)
338 : return NULL;
339 :
340 120889 : e = exp_binop(sql->sa, le, re, cmp_func);
341 120889 : if (e) {
342 120889 : e->flag = quantifier;
343 : /* At ANY and ALL operators, the cardinality on the right side is ignored if it is a sub-relation */
344 120889 : e->card = quantifier && exp_is_rel(re) ? le->card : MAX(le->card, re->card);
345 120889 : if (!has_nil(le) && !has_nil(re))
346 77307 : set_has_no_nil(e);
347 : }
348 : return e;
349 : }
350 :
351 : static sql_subtype*
352 867386 : dup_subtype(allocator *sa, sql_subtype *st)
353 : {
354 867386 : sql_subtype *res = SA_NEW(sa, sql_subtype);
355 :
356 867386 : if (res == NULL)
357 : return NULL;
358 867386 : *res = *st;
359 867386 : return res;
360 : }
361 :
362 : sql_exp *
363 433693 : exp_convert(mvc *sql, sql_exp *exp, sql_subtype *fromtype, sql_subtype *totype )
364 : {
365 433693 : sql_exp *e = exp_create(sql->sa, e_convert);
366 433693 : if (e == NULL)
367 : return NULL;
368 433693 : e->card = exp->card;
369 433693 : e->l = exp;
370 433693 : totype = dup_subtype(sql->sa, totype);
371 433693 : e->r = append(append(sa_list(sql->sa), dup_subtype(sql->sa, fromtype)),totype);
372 433693 : e->tpe = *totype;
373 433693 : e->alias = exp->alias;
374 433693 : if (e->alias.label)
375 286002 : e->alias.label = -(sql->nid++);
376 433693 : if (!has_nil(exp))
377 169705 : set_has_no_nil(e);
378 : return e;
379 : }
380 :
381 : sql_exp *
382 1081774 : exp_op( allocator *sa, list *l, sql_subfunc *f )
383 : {
384 1081774 : if (f->func->type == F_FILT)
385 1384 : return exp_filter(sa, l, NULL, f, false);
386 1080390 : sql_exp *e = exp_create(sa, e_func);
387 1080390 : if (e == NULL)
388 : return NULL;
389 1080390 : e->card = exps_card(l);
390 1080390 : e->l = l;
391 1080390 : e->f = f;
392 1080390 : e->semantics = f->func->semantics;
393 1080390 : if (!is_semantics(e) && !is_any(e) && l && !have_nil(l))
394 253861 : 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 60898 : exp_aggr( allocator *sa, list *l, sql_subfunc *a, int distinct, int no_nils, unsigned int card, int has_nils )
416 : {
417 60898 : sql_exp *e = exp_create(sa, e_aggr);
418 60898 : if (e == NULL)
419 : return NULL;
420 60898 : e->card = card;
421 60898 : e->l = l;
422 60898 : e->f = a;
423 60898 : e->semantics = a->func->semantics;
424 60898 : if (distinct)
425 373 : set_distinct(e);
426 60898 : if (no_nils)
427 25178 : set_no_nil(e);
428 60898 : if ((!a->func->semantics && !has_nils) || (!a->func->s && strcmp(a->func->base.name, "count") == 0))
429 25768 : set_has_no_nil(e);
430 : return e;
431 : }
432 :
433 : sql_exp *
434 5022347 : exp_atom(allocator *sa, atom *a)
435 : {
436 5022347 : sql_exp *e = exp_create(sa, e_atom);
437 5022251 : if (e == NULL)
438 : return NULL;
439 5022251 : e->card = CARD_ATOM;
440 5022251 : e->tpe = a->tpe;
441 5022251 : e->l = a;
442 5022251 : if (!a->isnull)
443 4743864 : 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 146602 : exp_atom_bool(allocator *sa, int b)
468 : {
469 146602 : sql_subtype bt;
470 :
471 146602 : sql_find_subtype(&bt, "boolean", 0, 0);
472 146602 : if (b)
473 98536 : return exp_atom(sa, atom_bool(sa, &bt, TRUE ));
474 : else
475 48066 : 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 869269 : exp_atom_int(allocator *sa, int i)
498 : {
499 869269 : sql_subtype it;
500 :
501 869269 : sql_find_subtype(&it, "int", 9, 0);
502 869267 : return exp_atom(sa, atom_int(sa, &it, i ));
503 : }
504 :
505 : sql_exp *
506 16436 : exp_atom_lng(allocator *sa, lng i)
507 : {
508 16436 : sql_subtype it;
509 :
510 : #ifdef HAVE_HGE
511 16436 : sql_find_subtype(&it, "bigint", 18, 0);
512 : #else
513 : sql_find_subtype(&it, "bigint", 19, 0);
514 : #endif
515 16436 : 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 85525 : exp_atom_str(allocator *sa, const char *s, sql_subtype *st)
562 : {
563 166465 : return exp_atom(sa, atom_string(sa, st, s?sa_strdup(sa, s):NULL));
564 : }
565 :
566 : sql_exp *
567 749904 : exp_atom_clob(allocator *sa, const char *s)
568 : {
569 749904 : sql_subtype clob;
570 :
571 749904 : sql_find_subtype(&clob, "varchar", 0, 0);
572 1498213 : return exp_atom(sa, atom_string(sa, &clob, s?sa_strdup(sa, s):NULL));
573 : }
574 :
575 : sql_exp *
576 270229 : exp_atom_ptr(allocator *sa, void *s)
577 : {
578 270229 : sql_subtype *t = sql_bind_localtype("ptr");
579 270229 : 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 108853 : exp_null(allocator *sa, sql_subtype *tpe)
597 : {
598 108853 : atom *a = atom_general(sa, tpe, NULL, 0);
599 108853 : 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 391 : exp_value(mvc *sql, sql_exp *e)
611 : {
612 391 : if (!e || e->type != e_atom)
613 : return NULL;
614 386 : 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 123442 : exp_param_or_declared(allocator *sa, const char *sname, const char *name, sql_subtype *tpe, int frame)
630 : {
631 123442 : sql_var_name *vname;
632 123442 : sql_exp *e = exp_create(sa, e_atom);
633 123442 : if (e == NULL)
634 : return NULL;
635 :
636 123442 : e->r = sa_alloc(sa, sizeof(sql_var_name));
637 123442 : vname = (sql_var_name*) e->r;
638 123442 : vname->sname = sname;
639 123442 : vname->name = name;
640 123442 : e->card = CARD_ATOM;
641 123442 : e->flag = frame;
642 123442 : if (tpe)
643 123442 : e->tpe = *tpe;
644 : return e;
645 : }
646 :
647 : sql_exp *
648 211918 : exp_values(allocator *sa, list *exps)
649 : {
650 211918 : sql_exp *e = exp_create(sa, e_atom);
651 211917 : if (e == NULL)
652 : return NULL;
653 211917 : e->card = exps_card(exps);
654 211917 : e->f = exps;
655 211917 : return e;
656 : }
657 :
658 : list *
659 29784 : exp_get_values(sql_exp *e)
660 : {
661 29784 : if (is_atom(e->type) && e->f)
662 : return e->f;
663 : return NULL;
664 : }
665 :
666 : list *
667 40778 : exp_types(allocator *sa, list *exps)
668 : {
669 40778 : list *l = sa_list(sa);
670 :
671 40778 : if (exps)
672 91260 : for (node *n = exps->h; n; n = n->next)
673 50482 : list_append(l, exp_subtype(n->data));
674 40778 : return l;
675 : }
676 :
677 : int
678 1041537 : have_nil(list *exps)
679 : {
680 1041537 : int has_nil = 0;
681 :
682 1041537 : if (exps)
683 2627905 : for (node *n = exps->h; n && !has_nil; n = n->next) {
684 1586368 : sql_exp *e = n->data;
685 1586368 : has_nil |= has_nil(e);
686 : }
687 1041537 : 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 6957979 : 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 6957979 : sql_exp *e = exp_create(sa, e_column);
707 :
708 6957937 : if (e == NULL)
709 : return NULL;
710 6957937 : assert(cname);
711 6957937 : e->card = card;
712 6957937 : e->alias.name = cname;
713 6957937 : e->alias.rname = rname;
714 6957937 : e->r = (char*)e->alias.name;
715 6957937 : e->l = (char*)e->alias.rname;
716 6957937 : if (t)
717 6957539 : e->tpe = *t;
718 6957937 : if (!has_nils)
719 1967225 : set_has_no_nil(e);
720 6957937 : if (unique)
721 923466 : set_unique(e);
722 6957937 : if (intern)
723 592160 : set_intern(e);
724 : return e;
725 : }
726 :
727 : sql_exp *
728 9879625 : exp_propagate(allocator *sa, sql_exp *ne, sql_exp *oe)
729 : {
730 9879625 : if (has_label(oe) &&
731 521114 : (oe->alias.rname == ne->alias.rname || (oe->alias.rname && ne->alias.rname && strcmp(oe->alias.rname, ne->alias.rname) == 0)) &&
732 513881 : (oe->alias.name == ne->alias.name || (oe->alias.name && ne->alias.name && strcmp(oe->alias.name, ne->alias.name) == 0)))
733 513881 : ne->alias.label = oe->alias.label;
734 9879625 : if (is_intern(oe))
735 315158 : set_intern(ne);
736 9879625 : if (is_anti(oe))
737 2314 : set_anti(ne);
738 9879625 : if (is_semantics(oe))
739 659505 : set_semantics(ne);
740 9879625 : if (is_any(oe))
741 44 : set_any(ne);
742 9879625 : if (is_symmetric(oe))
743 16 : set_symmetric(ne);
744 9879625 : if (is_ascending(oe))
745 19724 : set_ascending(ne);
746 9879625 : if (nulls_last(oe))
747 4096 : set_nulls_last(ne);
748 9879625 : if (need_distinct(oe))
749 670 : set_distinct(ne);
750 9879625 : if (zero_if_empty(oe))
751 0 : set_zero_if_empty(ne);
752 9879625 : if (need_no_nil(oe))
753 79660 : set_no_nil(ne);
754 9879625 : if (!has_nil(oe))
755 5757137 : set_has_no_nil(ne);
756 9879625 : if (has_nil(oe))
757 4122487 : set_has_nil(ne);
758 9879625 : if (is_unique(oe))
759 1088660 : set_unique(ne);
760 9879625 : if (is_basecol(oe))
761 8179345 : set_basecol(ne);
762 9879625 : ne->p = prop_copy(sa, oe->p);
763 9879624 : return ne;
764 : }
765 :
766 : static sql_exp *
767 6668608 : exp_ref_by_label(allocator *sa, sql_exp *o)
768 : {
769 6668608 : sql_exp *e = exp_create(sa, e_column);
770 :
771 6668608 : if (e == NULL)
772 : return NULL;
773 6668608 : e->card = o->card;
774 6668608 : e->alias = o->alias;
775 6668608 : assert(e->alias.label);
776 6668608 : e->r = (char*)e->alias.name;
777 6668608 : e->l = (char*)e->alias.rname;
778 6668608 : e->nid = o->alias.label;
779 6668608 : assert(e->nid);
780 6668608 : sql_subtype *t = exp_subtype(o);
781 6668608 : if (t)
782 6668493 : e->tpe = *t;
783 6668608 : if (!has_nil(o))
784 4053184 : set_has_no_nil(e);
785 6668608 : if (has_nil(o))
786 2615424 : set_has_nil(e);
787 6668608 : if (is_unique(o))
788 861285 : set_unique(e);
789 6668608 : if (is_intern(o))
790 279936 : set_intern(e);
791 6668608 : return exp_propagate(sa, e, o);
792 : }
793 :
794 : sql_exp *
795 6668608 : exp_ref(mvc *sql, sql_exp *e)
796 : {
797 6668608 : if (!has_label(e) && !exp_name(e))
798 2258 : exp_label(sql->sa, e, ++sql->label);
799 6668608 : if (e->alias.label)
800 6668608 : 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 2170476 : 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 2170476 : sql_exp *e = exp_column(sql->sa, org_rname, org_cname, t, card, has_nils, unique, intern);
832 :
833 2170480 : if (e == NULL)
834 : return NULL;
835 2170480 : assert(acname && org_cname);
836 2170480 : exp_setname(sql, e, (arname)?arname:org_rname, acname);
837 2170480 : 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 78200 : exp_rel(mvc *sql, sql_rel *rel)
938 : {
939 78200 : sql_exp *e = exp_create(sql->sa, e_psm);
940 :
941 78200 : if (e == NULL)
942 : return NULL;
943 78200 : e->l = rel;
944 78200 : e->flag = PSM_REL;
945 78200 : e->card = is_single(rel)?CARD_ATOM:rel->card;
946 78200 : assert(rel);
947 78200 : if (is_topn(rel->op))
948 3 : rel = rel->l;
949 78200 : if (is_project(rel->op)) {
950 59744 : sql_exp *last = rel->exps->t->data;
951 59744 : sql_subtype *t = exp_subtype(last);
952 59744 : 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 3711267 : exp_setname(mvc *sql, sql_exp *e, const char *rname, const char *name )
975 : {
976 3711267 : assert(name || rname);
977 3711267 : e->alias.label = -(sql->nid++);
978 : //e->alias.label = 0;
979 3711267 : if (name)
980 3549264 : e->alias.name = name;
981 3711267 : e->alias.rname = (rname);
982 3711267 : }
983 :
984 : void
985 162126 : noninternexp_setname(mvc *sql, sql_exp *e, const char *rname, const char *name )
986 : {
987 162126 : if (!is_intern(e))
988 162124 : exp_setname(sql, e, rname, name);
989 162126 : }
990 :
991 : void
992 657997 : exp_setalias(sql_exp *e, int label, const char *rname, const char *name )
993 : {
994 657997 : e->alias.label = label;
995 657997 : assert(e->alias.label);
996 657997 : e->alias.name = name;
997 657997 : e->alias.rname = rname;
998 657997 : }
999 :
1000 : void
1001 4415349 : exp_prop_alias(allocator *sa, sql_exp *e, sql_exp *oe )
1002 : {
1003 4415349 : e->ref = oe->ref;
1004 4415349 : 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 4415349 : e->alias = oe->alias;
1011 : }
1012 :
1013 : str
1014 2096102 : number2name(str s, int len, int i)
1015 : {
1016 2096102 : s[--len] = 0;
1017 6310652 : while(i>0) {
1018 4214550 : s[--len] = '0' + (i & 7);
1019 4214550 : i >>= 3;
1020 : }
1021 2096102 : s[--len] = '%';
1022 2096102 : 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 2035038 : make_label(allocator *sa, int nr)
1037 : {
1038 2035038 : char name[16], *nme;
1039 :
1040 2035038 : nme = number2name(name, sizeof(name), nr);
1041 2035003 : return sa_strdup(sa, nme);
1042 : }
1043 :
1044 : sql_exp*
1045 2025367 : exp_label(allocator *sa, sql_exp *e, int nr)
1046 : {
1047 2025367 : assert(nr > 0);
1048 : //assert (e->alias.label == 0);
1049 2025367 : e->alias.label = nr;
1050 2025367 : e->alias.rname = e->alias.name = make_label(sa, nr);
1051 2025376 : return e;
1052 : }
1053 :
1054 : list*
1055 52076 : exps_label(mvc *sql, list *exps)
1056 : {
1057 52076 : if (!exps)
1058 : return NULL;
1059 :
1060 52076 : int nr = sql->label+1;
1061 52076 : sql->label += list_length(exps);
1062 119905 : for (node *n = exps->h; n; n = n->next)
1063 67829 : n->data = exp_label(sql->sa, n->data, nr++);
1064 52076 : list_hash_clear(exps);
1065 52076 : return exps;
1066 : }
1067 :
1068 : void
1069 20840 : exp_swap( sql_exp *e )
1070 : {
1071 20840 : sql_exp *s = e->l;
1072 :
1073 20840 : e->l = e->r;
1074 20840 : e->r = s;
1075 20840 : e->flag = swap_compare((comp_type)e->flag);
1076 20840 : assert(!e->f);
1077 20840 : }
1078 :
1079 : sql_subtype *
1080 34389405 : exp_subtype( sql_exp *e )
1081 : {
1082 34391353 : switch(e->type) {
1083 8096737 : case e_atom: {
1084 8096737 : if (e->l) {
1085 7367252 : atom *a = e->l;
1086 7367252 : return atom_type(a);
1087 729485 : } else if (e->tpe.type) { /* atom reference */
1088 725726 : return &e->tpe;
1089 3759 : } else if (e->f) {
1090 1948 : list *vals = exp_get_values(e);
1091 1948 : if (!list_empty(vals))
1092 1948 : return exp_subtype(vals->h->data);
1093 : }
1094 : break;
1095 : }
1096 21616715 : case e_convert:
1097 : case e_column:
1098 21616715 : if (e->tpe.type)
1099 21616604 : return &e->tpe;
1100 : break;
1101 4544580 : case e_aggr:
1102 : case e_func: {
1103 4544580 : if (e->f) {
1104 4544580 : sql_subfunc *f = e->f;
1105 4544580 : if (f->res && list_length(f->res) == 1)
1106 4534039 : return f->res->h->data;
1107 : }
1108 : return NULL;
1109 : }
1110 7237 : case e_cmp:
1111 7237 : return sql_bind_localtype("bit");
1112 126084 : case e_psm:
1113 126084 : if (e->tpe.type)
1114 126069 : return &e->tpe;
1115 : /* fall through */
1116 : default:
1117 : return NULL;
1118 : }
1119 : return NULL;
1120 : }
1121 :
1122 : const char *
1123 34898040 : exp_name( sql_exp *e )
1124 : {
1125 34911927 : if (e->alias.name)
1126 : return e->alias.name;
1127 1596736 : if (e->type == e_convert && e->l)
1128 : return exp_name(e->l);
1129 1592742 : if (e->type == e_psm && e->l) { /* subquery return name of last expression */
1130 9893 : sql_rel *r = e->l;
1131 9893 : if (is_project(r->op))
1132 9893 : return exp_name(r->exps->t->data);
1133 : }
1134 : return NULL;
1135 : }
1136 :
1137 : const char *
1138 3922894 : exp_relname( sql_exp *e )
1139 : {
1140 3922906 : if (e->alias.rname)
1141 : return e->alias.rname;
1142 467849 : if (!e->alias.name && e->type == e_convert && e->l)
1143 : return exp_relname(e->l);
1144 467837 : 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 17067 : exp_find_rel_name(sql_exp *e)
1154 : {
1155 17067 : 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 1835055 : exp_card( sql_exp *e )
1170 : {
1171 1835055 : return e->card;
1172 : }
1173 :
1174 : unsigned int
1175 1617823 : exp_get_label( sql_exp *e )
1176 : {
1177 1617835 : if (e->alias.label)
1178 1617823 : 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 48966759 : exp_cmp( sql_exp *e1, sql_exp *e2)
1206 : {
1207 48966759 : return (e1 == e2)?0:-1;
1208 : }
1209 :
1210 : int
1211 235690 : exp_equal( sql_exp *e1, sql_exp *e2)
1212 : {
1213 235690 : if (e1 == e2)
1214 : return 0;
1215 235690 : if (e1->alias.label && e1->alias.label == e2->alias.label)
1216 8361 : return 0;
1217 : return -1;
1218 : }
1219 :
1220 : int
1221 48966626 : exp_match( sql_exp *e1, sql_exp *e2)
1222 : {
1223 48966626 : if (exp_cmp(e1, e2) == 0)
1224 : return 1;
1225 48730949 : if (e1->type == e2->type && e1->type == e_column) {
1226 24408272 : if (e1->nid && e1->nid == e2->nid)
1227 : return 1;
1228 23201857 : if (e1->alias.label != e2->alias.label || !e1->alias.label || !e2->alias.label)
1229 : return 0;
1230 : return 1;
1231 : }
1232 24322677 : if (e1->type == e2->type && e1->type == e_func) {
1233 8534561 : if (is_identity(e1, NULL) && is_identity(e2, NULL)) {
1234 0 : list *args1 = e1->l;
1235 0 : list *args2 = e2->l;
1236 :
1237 0 : if (list_length(args1) == list_length(args2) && list_length(args1) == 1) {
1238 0 : sql_exp *ne1 = args1->h->data;
1239 0 : sql_exp *ne2 = args2->h->data;
1240 :
1241 0 : if (exp_match(ne1,ne2))
1242 : return 1;
1243 : }
1244 : }
1245 : }
1246 : return 0;
1247 : }
1248 :
1249 : /* list already contains matching expression */
1250 : sql_exp*
1251 163421 : exps_find_exp( list *l, sql_exp *e)
1252 : {
1253 163421 : node *n;
1254 :
1255 163421 : if (!l || !l->h)
1256 : return NULL;
1257 :
1258 397267 : for(n=l->h; n; n = n->next) {
1259 357177 : if (exp_match(n->data, e) || exp_refers(n->data, e))
1260 110578 : return n->data;
1261 : }
1262 : return NULL;
1263 : }
1264 :
1265 : /* c refers to the parent p */
1266 : int
1267 3495574 : exp_refers( sql_exp *p, sql_exp *c)
1268 : {
1269 3495574 : if (c->type == e_column && c->nid)
1270 398281 : return c->nid == p->alias.label;
1271 : return 0;
1272 : }
1273 :
1274 : sql_exp*
1275 218 : exps_refers(sql_exp *p, list *l)
1276 : {
1277 218 : node *n;
1278 :
1279 218 : if (!l || !l->h)
1280 : return NULL;
1281 :
1282 532 : for(n=l->h; n; n = n->next) {
1283 318 : if (exp_refers(p, n->data))
1284 4 : return n->data;
1285 : }
1286 : return NULL;
1287 : }
1288 :
1289 : int
1290 0 : exp_match_col_exps( sql_exp *e, list *l)
1291 : {
1292 0 : node *n;
1293 :
1294 0 : for(n=l->h; n; n = n->next) {
1295 0 : sql_exp *re = n->data;
1296 0 : sql_exp *re_r = re->r;
1297 :
1298 0 : if (re->type == e_cmp && re->flag == cmp_or)
1299 0 : return exp_match_col_exps(e, re->l) &&
1300 0 : exp_match_col_exps(e, re->r);
1301 :
1302 0 : if (re->type != e_cmp || !re_r || re_r->card != 1 || !exp_match_exp(e, re->l))
1303 0 : return 0;
1304 : }
1305 : return 1;
1306 : }
1307 :
1308 : int
1309 10114 : exps_match_col_exps( sql_exp *e1, sql_exp *e2)
1310 : {
1311 10114 : sql_exp *e1_r = e1->r;
1312 10114 : sql_exp *e2_r = e2->r;
1313 :
1314 10114 : if (e1->type != e_cmp || e2->type != e_cmp)
1315 : return 0;
1316 :
1317 10043 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1318 4853 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1319 4042 : return exp_match_exp(e1->l, e2->l);
1320 :
1321 6001 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1322 811 : (e2->flag == cmp_in || e2->flag == cmp_notin))
1323 729 : return exp_match_exp(e1->l, e2->l);
1324 5272 : if ((e1->flag == cmp_in || e1->flag == cmp_notin) &&
1325 2769 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1326 1930 : return exp_match_exp(e1->l, e2->l);
1327 :
1328 3342 : if ((e1->flag == cmp_in || e1->flag == cmp_notin) &&
1329 839 : (e2->flag == cmp_in || e2->flag == cmp_notin))
1330 839 : return exp_match_exp(e1->l, e2->l);
1331 :
1332 2503 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1333 82 : e2->flag == cmp_or)
1334 0 : return exp_match_col_exps(e1->l, e2->l) &&
1335 0 : exp_match_col_exps(e1->l, e2->r);
1336 :
1337 2503 : if (e1->flag == cmp_or &&
1338 0 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1339 0 : return exp_match_col_exps(e2->l, e1->l) &&
1340 0 : exp_match_col_exps(e2->l, e1->r);
1341 :
1342 2503 : if (e1->flag == cmp_or && e2->flag == cmp_or) {
1343 0 : list *l = e1->l, *r = e1->r;
1344 0 : sql_exp *el = l->h->data;
1345 0 : sql_exp *er = r->h->data;
1346 :
1347 0 : return list_length(l) == 1 && list_length(r) == 1 &&
1348 0 : exps_match_col_exps(el, e2) &&
1349 0 : exps_match_col_exps(er, e2);
1350 : }
1351 : return 0;
1352 : }
1353 :
1354 : int
1355 46815 : exp_match_list( list *l, list *r)
1356 : {
1357 46815 : node *n, *m;
1358 46815 : char *lu, *ru;
1359 46815 : int lc = 0, rc = 0, match = 0;
1360 :
1361 46815 : if (!l || !r)
1362 0 : return l == r;
1363 46815 : if (list_length(l) != list_length(r) || list_length(l) == 0 || list_length(r) == 0)
1364 460 : return 0;
1365 46355 : if (list_length(l) > 10 || list_length(r) > 10)
1366 5 : return 0;/* to expensive */
1367 :
1368 46350 : lu = ZNEW_ARRAY(char, list_length(l));
1369 46350 : ru = ZNEW_ARRAY(char, list_length(r));
1370 46350 : if (!lu || !ru) {
1371 0 : _DELETE(lu);
1372 0 : _DELETE(ru);
1373 0 : return 0;
1374 : }
1375 136560 : for (n = l->h, lc = 0; n; n = n->next, lc++) {
1376 90210 : sql_exp *le = n->data;
1377 :
1378 269106 : for ( m = r->h, rc = 0; m; m = m->next, rc++) {
1379 178896 : sql_exp *re = m->data;
1380 :
1381 178896 : if (!ru[rc] && exp_match_exp(le,re)) {
1382 6715 : lu[lc] = 1;
1383 6715 : ru[rc] = 1;
1384 6715 : match = 1;
1385 : }
1386 : }
1387 : }
1388 53512 : for (n = l->h, lc = 0; n && match; n = n->next, lc++)
1389 7162 : if (!lu[lc])
1390 1274 : match = 0;
1391 51760 : for (n = r->h, rc = 0; n && match; n = n->next, rc++)
1392 5410 : if (!ru[rc])
1393 0 : match = 0;
1394 46350 : _DELETE(lu);
1395 46350 : _DELETE(ru);
1396 46350 : return match;
1397 : }
1398 :
1399 : static int
1400 2368622 : exps_equal( list *l, list *r)
1401 : {
1402 2368622 : node *n, *m;
1403 :
1404 2368622 : if (!l || !r)
1405 50123 : return l == r;
1406 2318499 : if (list_length(l) != list_length(r))
1407 : return 0;
1408 3408182 : for (n = l->h, m = r->h; n && m; n = n->next, m = m->next) {
1409 3362020 : sql_exp *le = n->data, *re = m->data;
1410 :
1411 3362020 : if (!exp_match_exp(le,re))
1412 : return 0;
1413 : }
1414 : return 1;
1415 : }
1416 :
1417 : int
1418 45411424 : exp_match_exp_semantics( sql_exp *e1, sql_exp *e2, bool semantics)
1419 : {
1420 45411424 : if (exp_match(e1, e2))
1421 : return 1;
1422 :
1423 44218737 : if (is_ascending(e1) != is_ascending(e2) ||
1424 44218733 : nulls_last(e1) != nulls_last(e2) ||
1425 44218733 : zero_if_empty(e1) != zero_if_empty(e2) ||
1426 44218733 : need_no_nil(e1) != need_no_nil(e2) ||
1427 44042211 : is_anti(e1) != is_anti(e2) ||
1428 44038370 : (semantics && is_semantics(e1) != is_semantics(e2)) ||
1429 33048722 : (semantics && is_any(e1) != is_any(e2)) ||
1430 33048802 : is_symmetric(e1) != is_symmetric(e2) ||
1431 33048785 : is_unique(e1) != is_unique(e2) ||
1432 : need_distinct(e1) != need_distinct(e2))
1433 : return 0;
1434 :
1435 32468856 : if (e1->type == e2->type) {
1436 24288367 : switch(e1->type) {
1437 339382 : case e_cmp:
1438 567252 : if (e1->flag == e2->flag && !is_complex_exp(e1->flag) &&
1439 231011 : exp_match_exp(e1->l, e2->l) && exp_match_exp(e1->r, e2->r) &&
1440 284 : ((!e1->f && !e2->f) || (e1->f && e2->f && exp_match_exp(e1->f, e2->f))))
1441 277 : return 1;
1442 341850 : else if (e1->flag == e2->flag && e1->flag == cmp_or &&
1443 2757 : exp_match_list(e1->l, e2->l) && exp_match_list(e1->r, e2->r))
1444 : return 1;
1445 339099 : else if (e1->flag == e2->flag &&
1446 237665 : (e1->flag == cmp_in || e1->flag == cmp_notin) &&
1447 3623 : exp_match_exp(e1->l, e2->l) && exp_match_list(e1->r, e2->r))
1448 : return 1;
1449 563537 : else if (e1->flag == e2->flag && (e1->flag == cmp_equal || e1->flag == cmp_notequal) &&
1450 224478 : exp_match_exp(e1->l, e2->r) && exp_match_exp(e1->r, e2->l))
1451 : return 1; /* = and <> operations are reflective, so exp_match_exp can be called crossed */
1452 : break;
1453 292180 : case e_convert:
1454 353437 : if (!subtype_cmp(exp_totype(e1), exp_totype(e2)) &&
1455 91650 : !subtype_cmp(exp_fromtype(e1), exp_fromtype(e2)) &&
1456 30393 : exp_match_exp(e1->l, e2->l))
1457 : return 1;
1458 : break;
1459 57165 : case e_aggr:
1460 93389 : if (!subfunc_cmp(e1->f, e2->f) && /* equal aggregation*/
1461 36224 : exps_equal(e1->l, e2->l))
1462 : return 1;
1463 : break;
1464 4338091 : case e_func: {
1465 4338091 : sql_subfunc *e1f = (sql_subfunc*) e1->f;
1466 4338091 : const char *sname = e1f->func->s ? e1f->func->s->base.name : NULL;
1467 4338091 : int (*comp)(list*, list*) = is_commutative(sname, e1f->func->base.name) ? exp_match_list : exps_equal;
1468 :
1469 8676182 : if (!e1f->func->side_effect &&
1470 6665517 : !subfunc_cmp(e1f, e2->f) && /* equal functions */
1471 2375994 : comp(e1->l, e2->l) &&
1472 : /* optional order by expressions */
1473 48568 : exps_equal(e1->r, e2->r))
1474 : return 1;
1475 : } break;
1476 1050099 : case e_atom:
1477 1050099 : if (e1->l && e2->l && !atom_cmp(e1->l, e2->l))
1478 : return 1;
1479 1009685 : if (e1->f && e2->f && exps_equal(e1->f, e2->f))
1480 : return 1;
1481 1009684 : if (e1->r && e2->r && e1->flag == e2->flag && !subtype_cmp(&e1->tpe, &e2->tpe)) {
1482 54 : sql_var_name *v1 = (sql_var_name*) e1->r, *v2 = (sql_var_name*) e2->r;
1483 54 : if (((!v1->sname && !v2->sname) || (v1->sname && v2->sname && strcmp(v1->sname, v2->sname) == 0)) &&
1484 54 : ((!v1->name && !v2->name) || (v1->name && v2->name && strcmp(v1->name, v2->name) == 0)))
1485 : return 1;
1486 : }
1487 1009684 : if (!e1->l && !e1->r && !e1->f && !e2->l && !e2->r && !e2->f && e1->flag == e2->flag && !subtype_cmp(&e1->tpe, &e2->tpe))
1488 : return 1;
1489 : break;
1490 : default:
1491 : break;
1492 : }
1493 : }
1494 : return 0;
1495 : }
1496 :
1497 : int
1498 45119327 : exp_match_exp( sql_exp *e1, sql_exp *e2)
1499 : {
1500 45119327 : return exp_match_exp_semantics( e1, e2, true);
1501 : }
1502 :
1503 : sql_exp *
1504 144826 : exps_any_match(list *l, sql_exp *e)
1505 : {
1506 144826 : if (!l)
1507 : return NULL;
1508 562848 : for (node *n = l->h; n ; n = n->next) {
1509 510231 : sql_exp *ne = (sql_exp *) n->data;
1510 510231 : if (exp_match_exp(ne, e))
1511 92209 : return ne;
1512 : }
1513 : return NULL;
1514 : }
1515 :
1516 : static int
1517 24 : exps_are_joins( list *l )
1518 : {
1519 24 : if (l)
1520 52 : for (node *n = l->h; n; n = n->next) {
1521 28 : sql_exp *e = n->data;
1522 :
1523 28 : if (exp_is_join_exp(e))
1524 : return -1;
1525 : }
1526 : return 0;
1527 : }
1528 :
1529 : int
1530 266 : exp_is_join_exp(sql_exp *e)
1531 : {
1532 266 : if (exp_is_join(e, NULL) == 0)
1533 : return 0;
1534 24 : if (e->type == e_cmp && e->flag == cmp_or && e->card >= CARD_AGGR)
1535 12 : if (exps_are_joins(e->l) == 0 && exps_are_joins(e->r) == 0)
1536 : return 0;
1537 : return -1;
1538 : }
1539 :
1540 : static int
1541 774087 : exp_is_complex_select( sql_exp *e )
1542 : {
1543 795268 : switch (e->type) {
1544 457 : case e_atom: {
1545 457 : if (e->f) {
1546 0 : int r = (e->card == CARD_ATOM);
1547 0 : list *l = e->f;
1548 :
1549 0 : if (r)
1550 0 : for (node *n = l->h; n && !r; n = n->next)
1551 0 : r |= exp_is_complex_select(n->data);
1552 0 : return r;
1553 : }
1554 : return 0;
1555 : }
1556 21181 : case e_convert:
1557 21181 : return exp_is_complex_select(e->l);
1558 2043 : case e_func:
1559 : case e_aggr:
1560 : {
1561 2043 : int r = (e->card == CARD_ATOM);
1562 2043 : list *l = e->l;
1563 :
1564 2043 : if (r && l)
1565 39 : for (node *n = l->h; n && !r; n = n->next)
1566 0 : r |= exp_is_complex_select(n->data);
1567 : return r;
1568 : }
1569 : case e_psm:
1570 : return 1;
1571 : case e_column:
1572 : case e_cmp:
1573 : default:
1574 : return 0;
1575 : }
1576 : }
1577 :
1578 : static int
1579 387049 : complex_select(sql_exp *e)
1580 : {
1581 387049 : sql_exp *l = e->l, *r = e->r;
1582 :
1583 387049 : if (exp_is_complex_select(l) || exp_is_complex_select(r))
1584 39 : return 1;
1585 : return 0;
1586 : }
1587 :
1588 : static int
1589 929 : distinct_rel(sql_exp *e, const char **rname)
1590 : {
1591 1071 : const char *e_rname = NULL;
1592 :
1593 1071 : switch(e->type) {
1594 651 : case e_column:
1595 651 : e_rname = exp_relname(e);
1596 :
1597 651 : if (*rname && e_rname && strcmp(*rname, e_rname) == 0)
1598 : return 1;
1599 504 : if (!*rname) {
1600 321 : *rname = e_rname;
1601 321 : return 1;
1602 : }
1603 : break;
1604 145 : case e_aggr:
1605 : case e_func:
1606 145 : if (e->l) {
1607 145 : int m = 1;
1608 145 : list *l = e->l;
1609 145 : node *n;
1610 :
1611 438 : for(n=l->h; n && m; n = n->next) {
1612 293 : sql_exp *ae = n->data;
1613 :
1614 293 : m = distinct_rel(ae, rname);
1615 : }
1616 145 : return m;
1617 : }
1618 : return 0;
1619 : case e_atom:
1620 : return 1;
1621 142 : case e_convert:
1622 142 : return distinct_rel(e->l, rname);
1623 : default:
1624 : return 0;
1625 : }
1626 : return 0;
1627 : }
1628 :
1629 : int
1630 20293572 : rel_has_exp(sql_rel *rel, sql_exp *e, bool subexp)
1631 : {
1632 20293572 : if (rel_find_exp_and_corresponding_rel(rel, e, subexp, NULL, NULL))
1633 4454221 : return 0;
1634 : return -1;
1635 : }
1636 :
1637 : int
1638 0 : rel_has_exps(sql_rel *rel, list *exps, bool subexp)
1639 : {
1640 0 : if (list_empty(exps))
1641 : return 0;
1642 0 : for (node *n = exps->h; n; n = n->next)
1643 0 : if (rel_has_exp(rel, n->data, subexp) >= 0)
1644 : return 0;
1645 : return -1;
1646 : }
1647 :
1648 : int
1649 0 : rel_has_all_exps(sql_rel *rel, list *exps)
1650 : {
1651 0 : if (list_empty(exps))
1652 : return 1;
1653 0 : for (node *n = exps->h; n; n = n->next)
1654 0 : if (rel_has_exp(rel, n->data, false) < 0)
1655 : return 0;
1656 : return 1;
1657 : }
1658 :
1659 : static int
1660 15338246 : rel_has_exp2(sql_rel *rel, sql_exp *e)
1661 : {
1662 15338246 : return rel_has_exp(rel, e, false);
1663 : }
1664 :
1665 : sql_rel *
1666 5821696 : find_rel(list *rels, sql_exp *e)
1667 : {
1668 5821696 : node *n = list_find(rels, e, (fcmp)&rel_has_exp2);
1669 5821696 : if (n)
1670 3318641 : return n->data;
1671 : return NULL;
1672 : }
1673 :
1674 : sql_rel *
1675 0 : find_one_rel(list *rels, sql_exp *e)
1676 : {
1677 0 : node *n;
1678 0 : sql_rel *fnd = NULL;
1679 :
1680 0 : for(n = rels->h; n; n = n->next) {
1681 0 : if (rel_has_exp(n->data, e, false) == 0) {
1682 0 : if (fnd)
1683 : return NULL;
1684 0 : fnd = n->data;
1685 : }
1686 : }
1687 : return fnd;
1688 : }
1689 :
1690 : static int
1691 326 : exp_is_rangejoin(sql_exp *e, list *rels)
1692 : {
1693 : /* assume e is a e_cmp with 3 args
1694 : * Need to check e->r and e->f only touch one table.
1695 : */
1696 326 : const char *rname = 0;
1697 :
1698 326 : if (distinct_rel(e->r, &rname) && distinct_rel(e->f, &rname))
1699 : return 0;
1700 183 : if (rels) {
1701 138 : sql_rel *r = find_rel(rels, e->r);
1702 138 : sql_rel *f = find_rel(rels, e->f);
1703 138 : if (r && f && r == f)
1704 : return 0;
1705 : }
1706 : return -1;
1707 : }
1708 :
1709 : int
1710 388777 : exp_is_join(sql_exp *e, list *rels)
1711 : {
1712 : /* only simple compare expressions, ie not or lists
1713 : or range expressions (e->f)
1714 : */
1715 388777 : if (e->type == e_cmp && !is_complex_exp(e->flag) && e->l && e->r && !e->f && e->card >= CARD_AGGR && !complex_select(e))
1716 : return 0;
1717 2093 : if (e->type == e_cmp && e->flag == cmp_filter && e->l && e->r && e->card >= CARD_AGGR)
1718 : return 0;
1719 : /* range expression */
1720 1915 : if (e->type == e_cmp && !is_complex_exp(e->flag) && e->l && e->r && e->f && e->card >= CARD_AGGR && !complex_select(e))
1721 326 : return exp_is_rangejoin(e, rels);
1722 : return -1;
1723 : }
1724 :
1725 : int
1726 382474 : exp_is_eqjoin(sql_exp *e)
1727 : {
1728 382474 : if (e->flag == cmp_equal) {
1729 372652 : sql_exp *l = e->l;
1730 372652 : sql_exp *r = e->r;
1731 :
1732 372652 : if (!is_func(l->type) && !is_func(r->type))
1733 371537 : return 0;
1734 : }
1735 : return -1;
1736 : }
1737 :
1738 : sql_exp *
1739 233331 : exps_find_prop(list *exps, rel_prop kind)
1740 : {
1741 233331 : if (list_empty(exps))
1742 : return NULL;
1743 465395 : for (node *n = exps->h ; n ; n = n->next) {
1744 233331 : sql_exp *e = n->data;
1745 :
1746 233331 : if (find_prop(e->p, kind))
1747 1267 : return e;
1748 : }
1749 : return NULL;
1750 : }
1751 :
1752 : /* check is one of the exps can be found in this relation */
1753 : static sql_exp* rel_find_exp_and_corresponding_rel_(sql_rel *rel, sql_exp *e, bool subexp, sql_rel **res);
1754 :
1755 : static bool
1756 602443 : rel_find_exps_and_corresponding_rel_(sql_rel *rel, list *l, bool subexp, sql_rel **res)
1757 : {
1758 602443 : int all = 1;
1759 :
1760 602443 : if (list_empty(l))
1761 : return true;
1762 1626540 : for(node *n = l->h; n && (subexp || all); n = n->next) {
1763 1033188 : sql_exp *ne = rel_find_exp_and_corresponding_rel_(rel, n->data, subexp, res);
1764 1033188 : if (subexp && ne)
1765 : return true;
1766 1024097 : all &= (ne?1:0);
1767 : }
1768 593352 : if (all)
1769 : return true;
1770 : return false;
1771 : }
1772 :
1773 : static sql_exp *
1774 78948244 : rel_find_exp_and_corresponding_rel_(sql_rel *rel, sql_exp *e, bool subexp, sql_rel **res)
1775 : {
1776 78948244 : sql_exp *ne = NULL;
1777 :
1778 78948244 : if (!rel)
1779 : return NULL;
1780 78948132 : switch(e->type) {
1781 76609342 : case e_column:
1782 76609342 : if (is_basetable(rel->op) && !rel->exps) {
1783 16474 : assert(e->nid);
1784 16474 : if (rel_base_has_nid(rel, e->nid))
1785 76609296 : ne = e;
1786 96311230 : } else if ((!list_empty(rel->exps) && (is_project(rel->op) || is_base(rel->op))) ||
1787 20102529 : (!list_empty(rel->attr) && is_join(rel->op))) {
1788 57258641 : list *l = rel->attr ? rel->attr : rel->exps;
1789 57258641 : assert(e->nid);
1790 57258641 : ne = exps_bind_nid(l, e->nid);
1791 : }
1792 76609296 : if (ne && res)
1793 69137 : *res = rel;
1794 : return ne;
1795 1110675 : case e_convert:
1796 1110675 : return rel_find_exp_and_corresponding_rel_(rel, e->l, subexp, res);
1797 606576 : case e_aggr:
1798 : case e_func:
1799 606576 : if (e->l)
1800 602428 : if (rel_find_exps_and_corresponding_rel_(rel, e->l, subexp, res))
1801 : return e;
1802 : return NULL;
1803 448 : case e_cmp:
1804 448 : if (!subexp)
1805 : return NULL;
1806 :
1807 30 : if (e->flag == cmp_or || e->flag == cmp_filter) {
1808 13 : if (rel_find_exps_and_corresponding_rel_(rel, e->l, subexp, res) ||
1809 3 : rel_find_exps_and_corresponding_rel_(rel, e->r, subexp, res))
1810 10 : return e;
1811 20 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
1812 4 : if (rel_find_exp_and_corresponding_rel_(rel, e->l, subexp, res) ||
1813 2 : rel_find_exps_and_corresponding_rel_(rel, e->r, subexp, res))
1814 2 : return e;
1815 23 : } else if (rel_find_exp_and_corresponding_rel_(rel, e->l, subexp, res) ||
1816 5 : rel_find_exp_and_corresponding_rel_(rel, e->r, subexp, res) ||
1817 2 : (!e->f || rel_find_exp_and_corresponding_rel_(rel, e->f, subexp, res))) {
1818 16 : return e;
1819 : }
1820 : return NULL;
1821 : case e_psm:
1822 : return NULL;
1823 620481 : case e_atom:
1824 620481 : if (e->f) { /* values */
1825 12 : list *l = e->f;
1826 12 : node *n = l->h;
1827 :
1828 12 : ne = n->data;
1829 31 : while ((subexp || ne != NULL) && n != NULL) {
1830 19 : ne = rel_find_exp_and_corresponding_rel_(rel, n->data, subexp, res);
1831 19 : if (subexp && ne)
1832 : break;
1833 19 : n = n->next;
1834 : }
1835 12 : return ne;
1836 : }
1837 : return e;
1838 : }
1839 : return ne;
1840 : }
1841 :
1842 : sql_exp *
1843 76804315 : rel_find_exp_and_corresponding_rel(sql_rel *rel, sql_exp *e, bool subexp, sql_rel **res, bool *under_join)
1844 : {
1845 76804315 : sql_exp *ne = rel_find_exp_and_corresponding_rel_(rel, e, subexp, res);
1846 :
1847 76804286 : if (rel && !ne) {
1848 55229694 : switch(rel->op) {
1849 13283529 : case op_left:
1850 : case op_right:
1851 : case op_full:
1852 : case op_join:
1853 : case op_semi:
1854 : case op_anti:
1855 13283529 : ne = rel_find_exp_and_corresponding_rel(rel->l, e, subexp, res, under_join);
1856 13283529 : if (!ne && is_join(rel->op))
1857 8508678 : ne = rel_find_exp_and_corresponding_rel(rel->r, e, subexp, res, under_join);
1858 : break;
1859 : case op_table:
1860 : case op_basetable:
1861 : break;
1862 276750 : case op_munion:
1863 1532618 : for (node* n = ((list*)rel->l)->h; n && !ne; n = n->next)
1864 1255868 : ne = rel_find_exp_and_corresponding_rel(n->data, e, subexp, res, under_join);
1865 : break;
1866 14820866 : default:
1867 14820866 : if (!is_project(rel->op) && rel->l)
1868 6423395 : ne = rel_find_exp_and_corresponding_rel(rel->l, e, subexp, res, under_join);
1869 : }
1870 : }
1871 76804286 : if (ne && under_join && is_join(rel->op))
1872 2968241 : *under_join = true;
1873 76804286 : return ne;
1874 : }
1875 :
1876 : sql_exp *
1877 21803023 : rel_find_exp(sql_rel *rel, sql_exp *e)
1878 : {
1879 21803023 : return rel_find_exp_and_corresponding_rel(rel, e, false, NULL, NULL);
1880 : }
1881 :
1882 : bool
1883 64039 : rel_find_nid(sql_rel *rel, int nid)
1884 : {
1885 64452 : if (rel) {
1886 63976 : switch(rel->op) {
1887 5527 : case op_left:
1888 : case op_right:
1889 : case op_full:
1890 : case op_join:
1891 : case op_semi:
1892 : case op_anti:
1893 5527 : if (rel_find_nid(rel->l, nid))
1894 : return true;
1895 497 : if (is_join(rel->op))
1896 413 : return rel_find_nid(rel->r, nid);
1897 : break;
1898 55121 : case op_table:
1899 : case op_basetable:
1900 : case op_munion:
1901 : case op_union:
1902 : case op_inter:
1903 : case op_except:
1904 : case op_project:
1905 : case op_groupby:
1906 55121 : if (rel->exps) {
1907 55121 : if (exps_bind_nid(rel->exps, nid))
1908 : return true;
1909 0 : } else if (rel->op == op_basetable)
1910 0 : return rel_base_has_nid(rel, nid);
1911 : break;
1912 3328 : case op_select:
1913 : case op_topn:
1914 : case op_sample:
1915 3328 : if (rel_find_nid(rel->l, nid))
1916 : return true;
1917 : break;
1918 : case op_ddl:
1919 : case op_insert:
1920 : case op_update:
1921 : case op_delete:
1922 : case op_truncate:
1923 : case op_merge:
1924 : return false;
1925 :
1926 : }
1927 : }
1928 : return false;
1929 : }
1930 :
1931 : int
1932 3881648 : exp_is_true(sql_exp *e)
1933 : {
1934 3881648 : if (e->type == e_atom && e->l)
1935 46889 : return atom_is_true(e->l);
1936 3834759 : if (e->type == e_cmp && e->flag == cmp_equal)
1937 3100703 : return (exp_is_true(e->l) && exp_is_true(e->r) && exp_match_exp(e->l, e->r));
1938 : return 0;
1939 : }
1940 :
1941 : static inline bool
1942 237446 : exp_is_cmp_exp_is_false(sql_exp* e)
1943 : {
1944 237446 : sql_exp *l = e->l;
1945 237446 : sql_exp *r = e->r;
1946 237446 : assert(e->type == e_cmp && e->f == NULL && l && r);
1947 :
1948 : /* Handle 'v is x' and 'v is not x' expressions.
1949 : * Other cases in is-semantics are unspecified.
1950 : */
1951 237446 : if (e->flag != cmp_equal && e->flag != cmp_notequal)
1952 : return false;
1953 237446 : if (e->flag == cmp_equal && !is_anti(e))
1954 371550 : return ((exp_is_null(l) && exp_is_not_null(r)) || (exp_is_not_null(l) && exp_is_null(r)));
1955 51671 : if ((e->flag == cmp_notequal && !is_anti(e)) || (e->flag == cmp_equal && is_anti(e)))
1956 103288 : return exp_is_null(l) && exp_is_null(r);
1957 : return false;
1958 : }
1959 :
1960 : static inline bool
1961 5458763 : exp_single_bound_cmp_exp_is_false(sql_exp* e)
1962 : {
1963 5458763 : assert(e->type == e_cmp);
1964 5458763 : sql_exp* l = e->l;
1965 5458763 : sql_exp* r = e->r;
1966 5458763 : assert(e->f == NULL);
1967 5458763 : assert (l && r);
1968 :
1969 5458763 : return exp_is_null(l) || exp_is_null(r);
1970 : }
1971 :
1972 : static inline bool
1973 74663 : exp_two_sided_bound_cmp_exp_is_false(sql_exp* e)
1974 : {
1975 74663 : assert(e->type == e_cmp);
1976 74663 : sql_exp* v = e->l;
1977 74663 : sql_exp* l = e->r;
1978 74663 : sql_exp* h = e->f;
1979 74663 : assert (v && l && h);
1980 :
1981 74663 : return is_anti(e) ? exp_is_null(v) || (exp_is_null(l) && exp_is_null(h)) : false;
1982 : }
1983 :
1984 : static inline bool
1985 5784150 : exp_regular_cmp_exp_is_false(sql_exp* e)
1986 : {
1987 5784150 : assert(e->type == e_cmp);
1988 :
1989 5784150 : if (is_semantics(e) && !is_any(e)) return exp_is_cmp_exp_is_false(e);
1990 5546704 : if (is_any(e)) return false;
1991 5533426 : if (e -> f) return exp_two_sided_bound_cmp_exp_is_false(e);
1992 5458763 : else return exp_single_bound_cmp_exp_is_false(e);
1993 : }
1994 :
1995 : static inline bool
1996 536904 : exp_or_exp_is_false(sql_exp* e)
1997 : {
1998 536904 : assert(e->type == e_cmp && e->flag == cmp_or);
1999 :
2000 536904 : list* left = e->l;
2001 536904 : list* right = e->r;
2002 :
2003 536904 : bool left_is_false = false;
2004 1118644 : for(node* n = left->h; n; n=n->next) {
2005 582354 : if (exp_is_false(n->data)) {
2006 : left_is_false=true;
2007 : break;
2008 : }
2009 : }
2010 :
2011 536904 : if (!left_is_false) {
2012 : return false;
2013 : }
2014 :
2015 1176 : for(node* n = right->h; n; n=n->next) {
2016 643 : if (exp_is_false(n->data)) {
2017 : return true;
2018 : }
2019 : }
2020 :
2021 : return false;
2022 : }
2023 :
2024 : static inline bool
2025 6663589 : exp_cmp_exp_is_false(sql_exp* e)
2026 : {
2027 6663589 : assert(e->type == e_cmp);
2028 :
2029 6663589 : switch (e->flag) {
2030 5784150 : case cmp_gt:
2031 : case cmp_gte:
2032 : case cmp_lte:
2033 : case cmp_lt:
2034 : case cmp_equal:
2035 : case cmp_notequal:
2036 5784150 : return exp_regular_cmp_exp_is_false(e);
2037 536904 : case cmp_or:
2038 536904 : return exp_or_exp_is_false(e);
2039 : default:
2040 : return false;
2041 : }
2042 : }
2043 :
2044 : int
2045 6756871 : exp_is_false(sql_exp *e)
2046 : {
2047 6756871 : if (e->type == e_atom && e->l)
2048 46349 : return atom_is_false(e->l);
2049 6710522 : else if (e->type == e_cmp)
2050 6663589 : return exp_cmp_exp_is_false(e);
2051 : return 0;
2052 : }
2053 :
2054 : int
2055 17817 : exp_is_zero(sql_exp *e)
2056 : {
2057 17817 : if (e->type == e_atom && e->l)
2058 17548 : return atom_is_zero(e->l);
2059 : return 0;
2060 : }
2061 :
2062 : int
2063 332472 : exp_is_not_null(sql_exp *e)
2064 : {
2065 332658 : if (!has_nil(e))
2066 : return true;
2067 :
2068 103320 : switch (e->type) {
2069 3093 : case e_atom:
2070 3093 : if (e->f) /* values list */
2071 : return false;
2072 3093 : if (e->l)
2073 2803 : return !(atom_null(e->l));
2074 : return false;
2075 186 : case e_convert:
2076 186 : return exp_is_not_null(e->l);
2077 651 : case e_func:
2078 651 : if (!is_semantics(e) && e->l) {
2079 263 : list *l = e->l;
2080 308 : for (node *n = l->h; n; n=n->next) {
2081 306 : sql_exp *p = n->data;
2082 306 : if (!exp_is_not_null(p))
2083 : return false;
2084 : }
2085 : return true;
2086 : }
2087 : return false;
2088 : case e_aggr:
2089 : case e_column:
2090 : case e_cmp:
2091 : case e_psm:
2092 : return false;
2093 : }
2094 : return false;
2095 : }
2096 :
2097 : static int
2098 8321 : exps_have_null(list *l)
2099 : {
2100 8321 : if (!l)
2101 : return false;
2102 17608 : for(node *n = l->h; n; n = n->next)
2103 9291 : if (exp_is_null(n->data))
2104 : return true;
2105 : return false;
2106 : }
2107 :
2108 : int
2109 12212695 : exp_is_null(sql_exp *e )
2110 : {
2111 12255882 : if (!has_nil(e))
2112 : return false;
2113 :
2114 1627746 : switch (e->type) {
2115 167622 : case e_atom:
2116 167622 : if (e->f) /* values list */
2117 : return 0;
2118 167542 : if (e->l)
2119 93354 : return (atom_null(e->l));
2120 : return 0;
2121 43187 : case e_convert:
2122 43187 : return exp_is_null(e->l);
2123 115141 : case e_func:
2124 115141 : if (!is_semantics(e) && e->l) {
2125 : /* This is a call to a function with no-nil semantics.
2126 : * If one of the parameters is null the expression itself is null
2127 : */
2128 100381 : list* l = e->l;
2129 300282 : for(node* n = l->h; n; n=n->next) {
2130 200073 : sql_exp* p = n->data;
2131 200073 : if (exp_is_null(p)) {
2132 : return true;
2133 : }
2134 : }
2135 : }
2136 : return 0;
2137 60176 : case e_cmp:
2138 60176 : if (!is_semantics(e)) {
2139 56933 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2140 14960 : return (exps_have_null(e->l) && exps_have_null(e->r));
2141 49453 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2142 3594 : return ((e->flag == cmp_in && exp_is_null(e->l)) ||
2143 3592 : (e->flag == cmp_notin && (exp_is_null(e->l) || exps_have_null(e->r))));
2144 45859 : } else if (e->f) {
2145 7174 : return exp_is_null(e->l) && exp_is_null(e->r) && exp_is_null(e->f);
2146 : } else {
2147 42274 : return exp_is_null(e->l) || exp_is_null(e->r);
2148 : }
2149 : }
2150 : return 0;
2151 : case e_aggr:
2152 : case e_column:
2153 : case e_psm:
2154 : return 0;
2155 : }
2156 : return 0;
2157 : }
2158 :
2159 : int
2160 1794104 : exp_is_rel( sql_exp *e )
2161 : {
2162 1803244 : if (e) {
2163 1803244 : switch(e->type){
2164 9140 : case e_convert:
2165 9140 : return exp_is_rel(e->l);
2166 303126 : case e_psm:
2167 303126 : return e->flag == PSM_REL && e->l;
2168 : default:
2169 : return 0;
2170 : }
2171 : }
2172 : return 0;
2173 : }
2174 :
2175 : int
2176 6741 : exps_one_is_rel(list *exps)
2177 : {
2178 6741 : if (list_empty(exps))
2179 : return 0;
2180 20120 : for(node *n = exps->h ; n ; n = n->next)
2181 13388 : if (exp_is_rel(n->data))
2182 : return 1;
2183 : return 0;
2184 : }
2185 :
2186 : int
2187 9011353 : exp_is_atom( sql_exp *e )
2188 : {
2189 9378514 : switch (e->type) {
2190 2055454 : case e_atom:
2191 2055454 : if (e->f) /* values list */
2192 12840 : return exps_are_atoms(e->f);
2193 : return 1;
2194 367161 : case e_convert:
2195 367161 : return exp_is_atom(e->l);
2196 1092354 : case e_func:
2197 : case e_aggr:
2198 1092354 : return e->card == CARD_ATOM && exps_are_atoms(e->l);
2199 2710 : case e_cmp:
2200 2710 : if (e->card != CARD_ATOM)
2201 : return 0;
2202 157 : if (e->flag == cmp_or || e->flag == cmp_filter)
2203 82 : return exps_are_atoms(e->l) && exps_are_atoms(e->r);
2204 79 : if (e->flag == cmp_in || e->flag == cmp_notin)
2205 0 : return exp_is_atom(e->l) && exps_are_atoms(e->r);
2206 79 : return exp_is_atom(e->l) && exp_is_atom(e->r) && (!e->f || exp_is_atom(e->f));
2207 : case e_column:
2208 : case e_psm:
2209 : return 0;
2210 : }
2211 : return 0;
2212 : }
2213 :
2214 : static int
2215 1 : exps_are_aggr(sql_rel *r, list *exps)
2216 : {
2217 1 : int aggr = 1;
2218 1 : if (!list_empty(exps))
2219 3 : for(node *n=exps->h; n && aggr; n=n->next)
2220 2 : aggr &= exp_is_aggr(r, n->data);
2221 1 : return aggr;
2222 : }
2223 :
2224 : /* is expression e an aggregated result of r */
2225 : int
2226 11 : exp_is_aggr(sql_rel *r, sql_exp *e)
2227 : {
2228 11 : sql_exp *ne = NULL;
2229 :
2230 11 : switch (e->type) {
2231 : case e_atom:
2232 : return true;
2233 0 : case e_convert:
2234 0 : return exp_is_aggr(r, e->l);
2235 1 : case e_func:
2236 1 : return exps_are_aggr(r, e->l);
2237 : case e_aggr:
2238 : return true;
2239 0 : case e_cmp:
2240 0 : if (e->card != CARD_ATOM)
2241 : return false;
2242 0 : if (e->flag == cmp_or || e->flag == cmp_filter)
2243 0 : return exps_are_aggr(r, e->l) && exps_are_aggr(r, e->r);
2244 0 : if (e->flag == cmp_in || e->flag == cmp_notin)
2245 0 : return exp_is_aggr(r, e->l) && exps_are_aggr(r, e->r);
2246 0 : return exp_is_aggr(r, e->l) && exp_is_aggr(r, e->r) && (!e->f || exp_is_aggr(r, e->f));
2247 9 : case e_column:
2248 9 : if (e->freevar)
2249 : return true;
2250 9 : ne = rel_find_exp(r, e);
2251 9 : if (ne) /* found local */
2252 : return true;
2253 : else
2254 : return false;
2255 : case e_psm:
2256 : return false;
2257 : }
2258 : return false;
2259 : }
2260 :
2261 : static int
2262 19 : exps_have_aggr(sql_rel *r, list *exps)
2263 : {
2264 19 : int aggr = 0;
2265 19 : if (!list_empty(exps))
2266 63 : for(node *n=exps->h; n && !aggr; n=n->next)
2267 44 : aggr |= exp_has_aggr(r, n->data);
2268 19 : return aggr;
2269 : }
2270 :
2271 : int
2272 80 : exp_has_aggr(sql_rel *r, sql_exp *e )
2273 : {
2274 87 : sql_exp *ne = NULL;
2275 :
2276 87 : switch (e->type) {
2277 : case e_atom:
2278 : return false;
2279 7 : case e_convert:
2280 7 : return exp_has_aggr(r, e->l);
2281 19 : case e_func:
2282 19 : return exps_have_aggr(r, e->l);
2283 : case e_aggr:
2284 : return true;
2285 0 : case e_cmp:
2286 0 : if (e->card != CARD_ATOM)
2287 : return false;
2288 0 : if (e->flag == cmp_or || e->flag == cmp_filter)
2289 0 : return exps_have_aggr(r, e->l) && exps_have_aggr(r, e->r);
2290 0 : if (e->flag == cmp_in || e->flag == cmp_notin)
2291 0 : return exp_has_aggr(r, e->l) && exps_have_aggr(r, e->r);
2292 0 : return exp_has_aggr(r, e->l) && exp_has_aggr(r, e->r) && (!e->f || exp_has_aggr(r, e->f));
2293 34 : case e_column:
2294 34 : if (e->freevar)
2295 : return false;
2296 21 : ne = rel_find_exp(r->l, e);
2297 21 : if (ne) /* found lower */
2298 : return false;
2299 : else
2300 : return true;
2301 : case e_psm:
2302 : return false;
2303 : }
2304 : return false;
2305 : }
2306 :
2307 : int
2308 20750080 : exp_has_rel( sql_exp *e )
2309 : {
2310 21118019 : if (!e)
2311 : return 0;
2312 21118019 : switch(e->type){
2313 1961029 : case e_func:
2314 : case e_aggr:
2315 1961029 : return exps_have_rel_exp(e->l);
2316 690542 : case e_cmp:
2317 690542 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2318 69656 : return (exps_have_rel_exp(e->l) || exps_have_rel_exp(e->r));
2319 621340 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2320 39846 : return (exp_has_rel(e->l) || exps_have_rel_exp(e->r));
2321 : } else {
2322 1162988 : return (exp_has_rel(e->l) || exp_has_rel(e->r) || (e->f && exp_has_rel(e->f)));
2323 : }
2324 367939 : case e_convert:
2325 367939 : return exp_has_rel(e->l);
2326 123560 : case e_psm:
2327 123560 : return exp_is_rel(e);
2328 9773584 : case e_atom:
2329 9773584 : return (e->f && exps_have_rel_exp(e->f));
2330 : case e_column:
2331 : return 0;
2332 : }
2333 : return 0;
2334 : }
2335 :
2336 : int
2337 2642163 : exps_have_rel_exp( list *exps)
2338 : {
2339 2642163 : if (list_empty(exps))
2340 : return 0;
2341 9482597 : for(node *n=exps->h; n; n=n->next) {
2342 6933842 : sql_exp *e = n->data;
2343 :
2344 6933842 : if (exp_has_rel(e))
2345 : return 1;
2346 : }
2347 : return 0;
2348 : }
2349 :
2350 : static sql_rel *
2351 570 : exps_rel_get_rel(allocator *sa, list *exps )
2352 : {
2353 570 : sql_rel *r = NULL, *xp = NULL;
2354 :
2355 570 : if (list_empty(exps))
2356 : return NULL;
2357 1674 : for (node *n = exps->h; n; n=n->next){
2358 1104 : sql_exp *e = n->data;
2359 :
2360 1104 : if (exp_has_rel(e)) {
2361 576 : if (!(r = exp_rel_get_rel(sa, e)))
2362 : return NULL;
2363 576 : if (xp) {
2364 6 : xp = rel_crossproduct(sa, xp, r, op_full);
2365 6 : set_processed(xp);
2366 : } else {
2367 : xp = r;
2368 : }
2369 : }
2370 : }
2371 : return xp;
2372 : }
2373 :
2374 : int
2375 60 : exp_rel_depth(sql_exp *e)
2376 : {
2377 60 : if (!e)
2378 : return 0;
2379 60 : switch(e->type){
2380 : case e_func:
2381 : case e_aggr:
2382 : case e_cmp:
2383 : return 1;
2384 : case e_convert:
2385 : return 0;
2386 39 : case e_psm:
2387 39 : if (exp_is_rel(e))
2388 : return 0;
2389 : return 1;
2390 : case e_atom:
2391 : case e_column:
2392 : return 0;
2393 : }
2394 : return 0;
2395 : }
2396 :
2397 : sql_rel *
2398 76887 : exp_rel_get_rel(allocator *sa, sql_exp *e)
2399 : {
2400 77840 : if (!e)
2401 : return NULL;
2402 :
2403 77840 : switch(e->type){
2404 542 : case e_func:
2405 : case e_aggr:
2406 542 : return exps_rel_get_rel(sa, e->l);
2407 38 : case e_cmp: {
2408 38 : sql_rel *r = NULL, *xp = NULL;
2409 :
2410 38 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2411 11 : if (exps_have_rel_exp(e->l))
2412 7 : xp = exps_rel_get_rel(sa, e->l);
2413 11 : if (exps_have_rel_exp(e->r)) {
2414 6 : if (!(r = exps_rel_get_rel(sa, e->r)))
2415 : return NULL;
2416 6 : if (xp) {
2417 2 : xp = rel_crossproduct(sa, xp, r, op_join);
2418 2 : set_processed(xp);
2419 : } else {
2420 : xp = r;
2421 : }
2422 : }
2423 27 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2424 0 : if (exp_has_rel(e->l))
2425 0 : xp = exp_rel_get_rel(sa, e->l);
2426 0 : if (exps_have_rel_exp(e->r)) {
2427 0 : if (!(r = exps_rel_get_rel(sa, e->r)))
2428 : return NULL;
2429 0 : if (xp) {
2430 0 : xp = rel_crossproduct(sa, xp, r, op_join);
2431 0 : set_processed(xp);
2432 : } else {
2433 : xp = r;
2434 : }
2435 : }
2436 : } else {
2437 27 : if (exp_has_rel(e->l))
2438 25 : xp = exp_rel_get_rel(sa, e->l);
2439 27 : if (exp_has_rel(e->r)) {
2440 7 : if (!(r = exp_rel_get_rel(sa, e->r)))
2441 : return NULL;
2442 7 : if (xp) {
2443 5 : xp = rel_crossproduct(sa, xp, r, op_join);
2444 5 : set_processed(xp);
2445 : } else {
2446 : xp = r;
2447 : }
2448 : }
2449 27 : if (e->f && exp_has_rel(e->f)) {
2450 0 : if (!(r = exp_rel_get_rel(sa, e->f)))
2451 : return NULL;
2452 0 : if (xp) {
2453 0 : xp = rel_crossproduct(sa, xp, r, op_join);
2454 0 : set_processed(xp);
2455 : } else {
2456 : xp = r;
2457 : }
2458 : }
2459 : }
2460 : return xp;
2461 : }
2462 953 : case e_convert:
2463 953 : return exp_rel_get_rel(sa, e->l);
2464 76292 : case e_psm:
2465 76292 : if (exp_is_rel(e))
2466 76292 : return e->l;
2467 : return NULL;
2468 15 : case e_atom:
2469 15 : if (e->f && exps_have_rel_exp(e->f))
2470 15 : return exps_rel_get_rel(sa, e->f);
2471 : return NULL;
2472 : case e_column:
2473 : return NULL;
2474 : }
2475 : return NULL;
2476 : }
2477 :
2478 : static void exp_rel_update_set_freevar(sql_exp *e);
2479 :
2480 : static void
2481 921 : exps_rel_update_set_freevar(list *exps)
2482 : {
2483 921 : if (!list_empty(exps))
2484 3003 : for (node *n=exps->h; n ; n=n->next)
2485 2082 : exp_rel_update_set_freevar(n->data);
2486 921 : }
2487 :
2488 : static void
2489 2372 : exp_rel_update_set_freevar(sql_exp *e)
2490 : {
2491 2384 : if (!e)
2492 : return ;
2493 :
2494 2384 : switch(e->type){
2495 919 : case e_func:
2496 : case e_aggr:
2497 919 : exps_rel_update_set_freevar(e->l);
2498 919 : break;
2499 8 : case e_cmp:
2500 8 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2501 0 : exps_rel_update_set_freevar(e->l);
2502 0 : exps_rel_update_set_freevar(e->r);
2503 8 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2504 0 : exp_rel_update_set_freevar(e->l);
2505 0 : exps_rel_update_set_freevar(e->r);
2506 : } else {
2507 8 : exp_rel_update_set_freevar(e->l);
2508 8 : exp_rel_update_set_freevar(e->r);
2509 8 : if (e->f)
2510 : exp_rel_update_set_freevar(e->f);
2511 : }
2512 : break;
2513 9 : case e_convert:
2514 9 : exp_rel_update_set_freevar(e->l);
2515 9 : break;
2516 1166 : case e_atom:
2517 1166 : if (e->f)
2518 2 : exps_rel_update_set_freevar(e->f);
2519 : break;
2520 282 : case e_column:
2521 282 : set_freevar(e, 1);
2522 282 : break;
2523 : case e_psm:
2524 : break;
2525 : }
2526 : }
2527 :
2528 : static list *
2529 570 : exp_rel_update_exps(mvc *sql, list *exps, bool up)
2530 : {
2531 570 : if (list_empty(exps))
2532 : return exps;
2533 1674 : for (node *n = exps->h; n; n=n->next){
2534 1104 : sql_exp *e = n->data;
2535 :
2536 1104 : if (exp_has_rel(e))
2537 576 : n->data = exp_rel_update_exp(sql, e, up);
2538 528 : else if (!exp_is_atom(e) && !up)
2539 268 : exp_rel_update_set_freevar(e);
2540 : }
2541 : return exps;
2542 : }
2543 :
2544 : static sql_exp *
2545 57 : exp_rel_update_exp_(mvc *sql, sql_exp *e, bool up)
2546 : {
2547 57 : if (exp_has_rel(e))
2548 31 : e = exp_rel_update_exp(sql, e, up);
2549 26 : else if (!exp_is_atom(e) && !up)
2550 6 : exp_rel_update_set_freevar(e);
2551 57 : return e;
2552 : }
2553 :
2554 : sql_exp *
2555 13379 : exp_rel_update_exp(mvc *sql, sql_exp *e, bool up)
2556 : {
2557 13379 : if (!e)
2558 : return NULL;
2559 :
2560 13379 : switch(e->type){
2561 542 : case e_func:
2562 : case e_aggr:
2563 542 : if (exps_have_rel_exp(e->l))
2564 542 : e->l = exp_rel_update_exps(sql, e->l, up);
2565 : return e;
2566 37 : case e_cmp:
2567 37 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2568 11 : if (exps_have_rel_exp(e->l))
2569 7 : e->l = exp_rel_update_exps(sql, e->l, up);
2570 11 : if (exps_have_rel_exp(e->r))
2571 6 : e->r = exp_rel_update_exps(sql, e->r, up);
2572 26 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2573 0 : if (exp_has_rel(e->l))
2574 0 : e->l = exp_rel_update_exp(sql, e->l, up);
2575 0 : if (exps_have_rel_exp(e->r))
2576 0 : e->r = exp_rel_update_exps(sql, e->r, up);
2577 : } else {
2578 : //if (exp_has_rel(e->l))
2579 26 : e->l = exp_rel_update_exp_(sql, e->l, up);
2580 : //if (exp_has_rel(e->r))
2581 26 : e->r = exp_rel_update_exp_(sql, e->r, up);
2582 26 : if (e->f /*&& exp_has_rel(e->f)*/)
2583 5 : e->f = exp_rel_update_exp_(sql, e->f, up);
2584 : }
2585 : return e;
2586 953 : case e_convert:
2587 953 : if (exp_has_rel(e->l))
2588 953 : e->l = exp_rel_update_exp(sql, e->l, up);
2589 : return e;
2590 11832 : case e_psm:
2591 11832 : if (exp_is_rel(e)) {
2592 11832 : sql_rel *r = exp_rel_get_rel(sql->sa, e), *nr = r;
2593 11832 : if (is_topn(r->op)) {
2594 2 : nr = r->l;
2595 2 : if (nr && !is_project(nr->op))
2596 0 : r->l = nr = rel_project(sql->sa, nr, rel_projections(sql, nr, NULL, 1, 0));
2597 : }
2598 11832 : e = nr->exps->t->data;
2599 11832 : e = exp_ref(sql, e);
2600 11832 : if (up)
2601 0 : set_freevar(e, 1);
2602 11832 : return e;
2603 : }
2604 : return e;
2605 15 : case e_atom:
2606 15 : if (e->f && exps_have_rel_exp(e->f))
2607 15 : e->f = exp_rel_update_exps(sql, e->f, up);
2608 : return e;
2609 : case e_column:
2610 : return e;
2611 : }
2612 : return e;
2613 : }
2614 :
2615 : sql_exp *
2616 4105 : exp_rel_label(mvc *sql, sql_exp *e)
2617 : {
2618 4105 : if (exp_is_rel(e))
2619 4105 : e->l = rel_label(sql, e->l, 1);
2620 4105 : return e;
2621 : }
2622 :
2623 : int
2624 147130 : exps_are_atoms( list *exps)
2625 : {
2626 147130 : int atoms = 1;
2627 147130 : if (!list_empty(exps))
2628 430207 : for(node *n=exps->h; n && atoms; n=n->next)
2629 313006 : atoms &= exp_is_atom(n->data);
2630 147130 : return atoms;
2631 : }
2632 :
2633 : int
2634 144 : exps_have_func(list *exps)
2635 : {
2636 144 : if (list_empty(exps))
2637 : return 0;
2638 175 : for(node *n=exps->h; n; n=n->next) {
2639 148 : sql_exp *e = n->data;
2640 :
2641 148 : if (exp_has_func(e))
2642 : return 1;
2643 : }
2644 : return 0;
2645 : }
2646 :
2647 : static int exp_has_func_or_cmp(sql_exp *e, bool cmp);
2648 :
2649 : static int
2650 68386 : exps_have_func_or_cmp(list *exps, bool cmp)
2651 : {
2652 68386 : if (list_empty(exps))
2653 : return 0;
2654 195942 : for(node *n=exps->h; n; n=n->next) {
2655 137082 : sql_exp *e = n->data;
2656 :
2657 137082 : if (exp_has_func_or_cmp(e, cmp))
2658 : return 1;
2659 : }
2660 : return 0;
2661 : }
2662 :
2663 : static int
2664 2167778 : exp_has_func_or_cmp(sql_exp *e, bool cmp)
2665 : {
2666 2167778 : if (!e)
2667 : return 0;
2668 2167778 : switch (e->type) {
2669 307201 : case e_atom:
2670 307201 : if (e->f)
2671 4 : return exps_have_func_or_cmp(e->f, true);
2672 : return 0;
2673 16136 : case e_convert:
2674 : {
2675 16136 : sql_subtype *t = exp_totype(e);
2676 16136 : sql_subtype *f = exp_fromtype(e);
2677 16136 : if (t->type->eclass == EC_FLT && (f->type->eclass == EC_DEC || f->type->eclass == EC_NUM))
2678 167 : return exp_has_func_or_cmp(e->l, cmp);
2679 15969 : if (f->type->localtype > t->type->localtype)
2680 : return true;
2681 : }
2682 13786 : return exp_has_func_or_cmp(e->l, cmp);
2683 : case e_func:
2684 : return 1;
2685 20081 : case e_aggr:
2686 20081 : if (e->l)
2687 17258 : return exps_have_func_or_cmp(e->l, true);
2688 : return 0;
2689 270455 : case e_cmp:
2690 270455 : if (cmp)
2691 : return 1;
2692 261028 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2693 22147 : return (exps_have_func_or_cmp(e->l, true) || exps_have_func_or_cmp(e->r, true));
2694 248328 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2695 35224 : return (exp_has_func_or_cmp(e->l, true) || exps_have_func_or_cmp(e->r, true));
2696 : } else {
2697 426314 : return (exp_has_func_or_cmp(e->l, true) || exp_has_func_or_cmp(e->r, true) ||
2698 198003 : (e->f && exp_has_func_or_cmp(e->f, true)));
2699 : }
2700 : case e_column:
2701 : case e_psm:
2702 : return 0;
2703 : }
2704 : return 0;
2705 : }
2706 :
2707 : int
2708 1567600 : exp_has_func(sql_exp *e)
2709 : {
2710 1567600 : return exp_has_func_or_cmp(e, false);
2711 : }
2712 :
2713 : static int
2714 720747 : exps_have_sideeffect( list *exps)
2715 : {
2716 720747 : node *n;
2717 720747 : int has_sideeffect = 0;
2718 :
2719 2213808 : for(n=exps->h; n && !has_sideeffect; n=n->next)
2720 1493061 : has_sideeffect |= exp_has_sideeffect(n->data);
2721 720747 : return has_sideeffect;
2722 : }
2723 :
2724 : int
2725 1677844 : exp_has_sideeffect( sql_exp *e )
2726 : {
2727 1702591 : switch (e->type) {
2728 24747 : case e_convert:
2729 24747 : return exp_has_sideeffect(e->l);
2730 720786 : case e_func:
2731 : {
2732 720786 : sql_subfunc *f = e->f;
2733 :
2734 720786 : if (f->func->side_effect)
2735 : return 1;
2736 720772 : if (e->l)
2737 720747 : return exps_have_sideeffect(e->l);
2738 : return 0;
2739 : }
2740 471878 : case e_atom:
2741 471878 : if (e->f)
2742 0 : return exps_have_sideeffect(e->f);
2743 : return 0;
2744 : case e_aggr:
2745 : case e_cmp:
2746 : case e_column:
2747 : case e_psm:
2748 : return 0;
2749 : }
2750 : return 0;
2751 : }
2752 :
2753 : bool
2754 1047651 : exps_have_unsafe(list *exps, bool allow_identity, bool card)
2755 : {
2756 1047651 : int unsafe = 0;
2757 :
2758 1047651 : if (list_empty(exps))
2759 : return 0;
2760 3608444 : for (node *n = exps->h; n && !unsafe; n = n->next)
2761 2581359 : unsafe |= exp_unsafe(n->data, allow_identity, card);
2762 1027085 : return unsafe;
2763 : }
2764 :
2765 : bool
2766 12617515 : exp_unsafe(sql_exp *e, bool allow_identity, bool card)
2767 : {
2768 12617515 : switch (e->type) {
2769 781955 : case e_convert:
2770 781955 : if (card) {
2771 8927 : sql_subtype *t = exp_totype(e);
2772 8927 : sql_subtype *f = exp_fromtype(e);
2773 8927 : if (t->type->eclass == EC_FLT && (f->type->eclass == EC_DEC || f->type->eclass == EC_NUM))
2774 : return false;
2775 8842 : if (f->type->localtype > t->type->localtype)
2776 : return true;
2777 : return false;
2778 : }
2779 773028 : return exp_unsafe(e->l, allow_identity, card);
2780 996755 : case e_aggr:
2781 : case e_func: {
2782 996755 : sql_subfunc *f = e->f;
2783 :
2784 996755 : if (IS_ANALYTIC(f->func) || !LANG_INT_OR_MAL(f->func->lang) || f->func->side_effect || (!allow_identity && is_identity(e, NULL)))
2785 53171 : return 1;
2786 943584 : return exps_have_unsafe(e->l, allow_identity, card);
2787 51546 : } break;
2788 51546 : case e_cmp: {
2789 51546 : if (e->flag == cmp_in || e->flag == cmp_notin) {
2790 6532 : return exp_unsafe(e->l, allow_identity, card) || exps_have_unsafe(e->r, allow_identity, card);
2791 45014 : } else if (e->flag == cmp_or || e->flag == cmp_filter) {
2792 10197 : return exps_have_unsafe(e->l, allow_identity, card) || exps_have_unsafe(e->r, allow_identity, card);
2793 : } else {
2794 69650 : return exp_unsafe(e->l, allow_identity, card) || exp_unsafe(e->r, allow_identity, card) || (e->f && exp_unsafe(e->f, allow_identity, card));
2795 : }
2796 1147468 : } break;
2797 1147468 : case e_atom: {
2798 1147468 : if (e->f)
2799 8331 : return exps_have_unsafe(e->f, allow_identity, card);
2800 : return 0;
2801 : } break;
2802 : case e_column:
2803 : case e_psm:
2804 : return 0;
2805 : }
2806 : return 0;
2807 : }
2808 :
2809 : static inline int
2810 3524388 : exp_key( sql_exp *e )
2811 : {
2812 3524388 : if (e->alias.name)
2813 3524387 : return hash_key(e->alias.name);
2814 : return 0;
2815 : }
2816 :
2817 : sql_exp *
2818 82 : exps_uses_nid(list *exps, int nid)
2819 : {
2820 82 : if (exps) {
2821 153 : for (node *en = exps->h; en; en = en->next ) {
2822 147 : sql_exp *e = en->data;
2823 :
2824 147 : if (e->nid == nid)
2825 76 : return e;
2826 : }
2827 : }
2828 : return NULL;
2829 : }
2830 :
2831 : sql_exp *
2832 71121307 : exps_bind_nid(list *exps, int nid)
2833 : {
2834 71121307 : if (exps) {
2835 5433179811 : for (node *en = exps->h; en; en = en->next ) {
2836 5391320411 : sql_exp *e = en->data;
2837 :
2838 5391320411 : if (e->alias.label == nid)
2839 28898313 : return e;
2840 : }
2841 : }
2842 : return NULL;
2843 : }
2844 :
2845 : sql_exp *
2846 972270 : exps_bind_column(list *exps, const char *cname, int *ambiguous, int *multiple, int no_tname)
2847 : {
2848 972270 : sql_exp *res = NULL;
2849 :
2850 972270 : if (exps && cname) {
2851 972269 : node *en;
2852 :
2853 972269 : if (exps) {
2854 972269 : if (!exps->ht && list_length(exps) > HASH_MIN_SIZE) {
2855 110239 : exps->ht = hash_new(exps->sa, list_length(exps), (fkeyvalue)&exp_key);
2856 110239 : if (exps->ht == NULL)
2857 : return NULL;
2858 830522 : for (en = exps->h; en; en = en->next ) {
2859 720283 : sql_exp *e = en->data;
2860 720283 : if (e->alias.name) {
2861 720283 : int key = exp_key(e);
2862 :
2863 720283 : if (hash_add(exps->ht, key, e) == NULL)
2864 : return NULL;
2865 : }
2866 : }
2867 : }
2868 972269 : if (exps->ht) {
2869 430327 : int key = hash_key(cname);
2870 430327 : sql_hash_e *he = exps->ht->buckets[key&(exps->ht->size-1)];
2871 :
2872 835490 : for (; he; he = he->chain) {
2873 405167 : sql_exp *e = he->value;
2874 :
2875 405167 : if (e->alias.name && strcmp(e->alias.name, cname) == 0 && (!no_tname || !e->alias.rname)) {
2876 145267 : if (res && multiple)
2877 4 : *multiple = 1;
2878 145267 : if (!res)
2879 145267 : res = e;
2880 :
2881 145267 : if (res && res != e && e->alias.rname && res->alias.rname && strcmp(e->alias.rname, res->alias.rname) != 0 ) {
2882 4 : if (ambiguous)
2883 4 : *ambiguous = 1;
2884 4 : return NULL;
2885 : }
2886 : res = e;
2887 : }
2888 : }
2889 430323 : return res;
2890 : }
2891 : }
2892 1581520 : for (en = exps->h; en; en = en->next ) {
2893 1039583 : sql_exp *e = en->data;
2894 :
2895 1039583 : if (e->alias.name && strcmp(e->alias.name, cname) == 0 && (!no_tname || !e->alias.rname)) {
2896 43823 : if (res && multiple)
2897 8 : *multiple = 1;
2898 43823 : if (!res)
2899 43823 : res = e;
2900 :
2901 43823 : if (res && res != e && e->alias.rname && res->alias.rname && strcmp(e->alias.rname, res->alias.rname) != 0 ) {
2902 5 : if (ambiguous)
2903 5 : *ambiguous = 1;
2904 5 : return NULL;
2905 : }
2906 : res = e;
2907 : }
2908 : }
2909 : }
2910 : return res;
2911 : }
2912 :
2913 : sql_exp *
2914 1650388 : exps_bind_column2(list *exps, const char *rname, const char *cname, int *multiple)
2915 : {
2916 1650388 : sql_exp *res = NULL;
2917 :
2918 1650388 : if (exps) {
2919 1650358 : node *en;
2920 :
2921 1650358 : if (!exps->ht && list_length(exps) > HASH_MIN_SIZE) {
2922 128436 : exps->ht = hash_new(exps->sa, list_length(exps), (fkeyvalue)&exp_key);
2923 128436 : if (exps->ht == NULL)
2924 : return res;
2925 :
2926 2163003 : for (en = exps->h; en; en = en->next ) {
2927 2034567 : sql_exp *e = en->data;
2928 2034567 : if (e->alias.name) {
2929 2034567 : int key = exp_key(e);
2930 :
2931 2034567 : if (hash_add(exps->ht, key, e) == NULL)
2932 : return res;
2933 : }
2934 : }
2935 : }
2936 1650358 : if (exps->ht) {
2937 991462 : int key = hash_key(cname);
2938 991462 : sql_hash_e *he = exps->ht->buckets[key&(exps->ht->size-1)];
2939 :
2940 2789441 : for (; he; he = he->chain) {
2941 1800091 : sql_exp *e = he->value;
2942 :
2943 1800091 : if (e && e->alias.name && e->alias.rname && strcmp(e->alias.name, cname) == 0 && strcmp(e->alias.rname, rname) == 0) {
2944 730187 : if (res && multiple)
2945 0 : *multiple = 1;
2946 730187 : if (!res)
2947 : res = e;
2948 730187 : if (res && has_label(res)) /* aliases maybe used multiple times without problems */
2949 2112 : return res;
2950 : }
2951 : }
2952 989350 : return res;
2953 : }
2954 2195957 : for (en = exps->h; en; en = en->next ) {
2955 1544246 : sql_exp *e = en->data;
2956 :
2957 1544246 : if (e && e->alias.name && e->alias.rname && strcmp(e->alias.name, cname) == 0 && strcmp(e->alias.rname, rname) == 0) {
2958 442947 : if (res && multiple)
2959 1 : *multiple = 1;
2960 442947 : if (!res)
2961 : res = e;
2962 442947 : if (res && has_label(res)) /* aliases maybe used multiple times without problems */
2963 7185 : return res;
2964 : }
2965 : }
2966 : }
2967 : return res;
2968 : }
2969 :
2970 : /* find an column based on the original name, not the alias it got */
2971 : sql_exp *
2972 0 : exps_bind_alias( list *exps, const char *rname, const char *cname )
2973 : {
2974 0 : if (exps) {
2975 0 : node *en;
2976 :
2977 0 : for (en = exps->h; en; en = en->next ) {
2978 0 : sql_exp *e = en->data;
2979 :
2980 0 : if (e && is_column(e->type) && !rname && e->r && strcmp(e->r, cname) == 0)
2981 : {
2982 0 : assert(0);
2983 : return e;
2984 : }
2985 0 : if (e && e->type == e_column && rname && e->l && e->r && strcmp(e->r, cname) == 0 && strcmp(e->l, rname) == 0) {
2986 0 : assert(0);
2987 : return e;
2988 : }
2989 : }
2990 : }
2991 0 : return NULL;
2992 : }
2993 :
2994 : unsigned int
2995 3250460 : exps_card( list *l )
2996 : {
2997 3250460 : node *n;
2998 3250460 : unsigned int card = CARD_ATOM;
2999 :
3000 14542589 : if (l) for(n = l->h; n; n = n->next) {
3001 11292129 : sql_exp *e = n->data;
3002 :
3003 11292129 : if (e && card < e->card)
3004 11292129 : card = e->card;
3005 : }
3006 3250460 : return card;
3007 : }
3008 :
3009 : void
3010 43274 : exps_fix_card( list *exps, unsigned int card)
3011 : {
3012 43274 : if (exps)
3013 1062436 : for (node *n = exps->h; n; n = n->next) {
3014 1019162 : sql_exp *e = n->data;
3015 :
3016 1019162 : if (e && e->card > card)
3017 0 : e->card = card;
3018 : }
3019 43274 : }
3020 :
3021 : void
3022 4043 : exps_setcard( list *exps, unsigned int card)
3023 : {
3024 4043 : if (exps)
3025 23834 : for (node *n = exps->h; n; n = n->next) {
3026 19791 : sql_exp *e = n->data;
3027 :
3028 19791 : if (e && e->card != CARD_ATOM)
3029 19762 : e->card = card;
3030 : }
3031 4043 : }
3032 :
3033 : int
3034 0 : exps_intern(list *exps)
3035 : {
3036 0 : if (exps)
3037 0 : for (node *n=exps->h; n; n = n->next) {
3038 0 : sql_exp *e = n->data;
3039 :
3040 0 : if (is_intern(e))
3041 : return 1;
3042 : }
3043 : return 0;
3044 : }
3045 :
3046 : sql_exp *
3047 3514 : exps_find_one_multi_exp(list *exps)
3048 : {
3049 3514 : sql_exp *l = NULL;
3050 3514 : int skip = 0;
3051 :
3052 : /* Find one and only 1 expression with card > CARD_ATOM */
3053 3514 : if (!list_empty(exps)) {
3054 7223 : for (node *m = exps->h ; m && !skip ; m = m->next) {
3055 3709 : sql_exp *e = m->data;
3056 :
3057 3709 : if (e->card > CARD_ATOM) {
3058 3481 : skip |= l != NULL;
3059 3481 : l = e;
3060 : }
3061 : }
3062 : }
3063 3514 : if (skip)
3064 6 : l = NULL;
3065 3514 : return l;
3066 : }
3067 :
3068 : const char *
3069 128223 : compare_func( comp_type t, int anti )
3070 : {
3071 128223 : switch(t) {
3072 73824 : case cmp_equal:
3073 73824 : return anti?"<>":"=";
3074 8004 : case cmp_lt:
3075 8004 : return anti?">":"<";
3076 2102 : case cmp_lte:
3077 2102 : return anti?">=":"<=";
3078 1159 : case cmp_gte:
3079 1159 : return anti?"<=":">=";
3080 31180 : case cmp_gt:
3081 31180 : return anti?"<":">";
3082 11954 : case cmp_notequal:
3083 11954 : return anti?"=":"<>";
3084 : default:
3085 : return NULL;
3086 : }
3087 : }
3088 :
3089 : int
3090 9487419 : is_identity( sql_exp *e, sql_rel *r)
3091 : {
3092 9498231 : switch(e->type) {
3093 36914 : case e_column:
3094 36914 : if (r && is_project(r->op) && !is_set(r->op)) {
3095 13634 : sql_exp *re = NULL;
3096 13634 : assert(e->nid);
3097 13634 : re = exps_bind_nid(r->exps, e->nid);
3098 13634 : if (re)
3099 10812 : return is_identity(re, r->l);
3100 : }
3101 : return 0;
3102 9454290 : case e_func: {
3103 9454290 : sql_subfunc *f = e->f;
3104 9454290 : return !f->func->s && strcmp(f->func->base.name, "identity") == 0;
3105 : }
3106 : default:
3107 : return 0;
3108 : }
3109 : }
3110 :
3111 : list *
3112 14 : exps_alias(mvc *sql, list *exps)
3113 : {
3114 14 : list *nl = new_exp_list(sql->sa);
3115 :
3116 14 : if (exps)
3117 58 : for (node *n = exps->h; n; n = n->next) {
3118 44 : sql_exp *e = n->data, *ne;
3119 :
3120 44 : assert(exp_name(e));
3121 44 : ne = exp_ref(sql, e);
3122 44 : append(nl, ne);
3123 : }
3124 14 : return nl;
3125 : }
3126 :
3127 : list *
3128 141158 : exps_copy(mvc *sql, list *exps)
3129 : {
3130 141158 : list *nl;
3131 :
3132 141158 : if (mvc_highwater(sql))
3133 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3134 :
3135 141158 : if (!exps)
3136 : return NULL;
3137 122973 : nl = new_exp_list(sql->sa);
3138 563907 : for (node *n = exps->h; n; n = n->next) {
3139 440934 : sql_exp *arg = n->data;
3140 :
3141 440934 : arg = exp_copy(sql, arg);
3142 440934 : if (!arg)
3143 : return NULL;
3144 440934 : append(nl, arg);
3145 : }
3146 : return nl;
3147 : }
3148 :
3149 : sql_exp *
3150 2651503 : exp_copy(mvc *sql, sql_exp * e)
3151 : {
3152 2651503 : sql_exp *l, *r, *r2, *ne = NULL;
3153 :
3154 2651503 : if (mvc_highwater(sql))
3155 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3156 :
3157 2651503 : if (!e)
3158 : return NULL;
3159 2651503 : switch(e->type){
3160 2285453 : case e_column:
3161 2285453 : ne = exp_column(sql->sa, e->l, e->r, exp_subtype(e), e->card, has_nil(e), is_unique(e), is_intern(e));
3162 2285453 : ne->flag = e->flag;
3163 2285453 : ne->alias.label = e->alias.label;
3164 2285453 : ne->nid = e->nid;
3165 2285453 : break;
3166 41829 : case e_cmp:
3167 41829 : if (e->flag == cmp_or || e->flag == cmp_filter) {
3168 2603 : list *l = exps_copy(sql, e->l);
3169 2603 : list *r = exps_copy(sql, e->r);
3170 :
3171 2603 : if (e->flag == cmp_filter)
3172 608 : ne = exp_filter(sql->sa, l, r, e->f, is_anti(e));
3173 : else
3174 1995 : ne = exp_or(sql->sa, l, r, is_anti(e));
3175 39226 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
3176 1431 : sql_exp *l = exp_copy(sql, e->l);
3177 1431 : list *r = exps_copy(sql, e->r);
3178 :
3179 1431 : ne = exp_in(sql->sa, l, r, e->flag);
3180 : } else {
3181 37795 : l = exp_copy(sql, e->l);
3182 37795 : r = exp_copy(sql, e->r);
3183 :
3184 37795 : if (e->f) {
3185 691 : r2 = exp_copy(sql, e->f);
3186 691 : ne = exp_compare2(sql->sa, l, r, r2, e->flag, is_symmetric(e));
3187 : } else {
3188 37104 : ne = exp_compare(sql->sa, l, r, e->flag);
3189 : }
3190 : }
3191 : break;
3192 28646 : case e_convert:
3193 28646 : ne = exp_convert(sql, exp_copy(sql, e->l), exp_fromtype(e), exp_totype(e));
3194 28646 : break;
3195 13636 : case e_aggr:
3196 : case e_func: {
3197 13636 : list *l = exps_copy(sql, e->l);
3198 :
3199 13636 : if (e->type == e_func)
3200 11692 : ne = exp_op(sql->sa, l, e->f);
3201 : else
3202 1944 : ne = exp_aggr(sql->sa, l, e->f, need_distinct(e), need_no_nil(e), e->card, has_nil(e));
3203 13636 : if (e->r) { /* copy obe and gbe lists */
3204 1 : list *er = (list*) e->r;
3205 1 : assert(list_length(er) <= 2);
3206 1 : if (list_length(er) == 2)
3207 0 : ne->r = list_append(list_append(sa_list(sql->sa), exps_copy(sql, er->h->data)), exps_copy(sql, er->h->next->data));
3208 : else
3209 1 : ne->r = list_append(sa_list(sql->sa), exps_copy(sql, er->h->data));
3210 : }
3211 : break;
3212 : }
3213 281935 : case e_atom:
3214 281935 : if (e->l)
3215 277147 : ne = exp_atom(sql->sa, e->l);
3216 4788 : else if (e->r) {
3217 3476 : sql_var_name *vname = (sql_var_name*) e->r;
3218 3476 : ne = exp_param_or_declared(sql->sa, vname->sname, vname->name, &e->tpe, e->flag);
3219 1312 : } else if (e->f)
3220 759 : ne = exp_values(sql->sa, exps_copy(sql, e->f));
3221 : else
3222 553 : ne = exp_atom_ref(sql->sa, e->flag, &e->tpe);
3223 : break;
3224 4 : case e_psm:
3225 4 : if (e->flag & PSM_SET) {
3226 0 : ne = exp_set(sql->sa, e->alias.rname, e->alias.name, exp_copy(sql, e->l), GET_PSM_LEVEL(e->flag));
3227 4 : } else if (e->flag & PSM_VAR) {
3228 0 : if (e->f)
3229 0 : ne = exp_table(sql->sa, e->alias.name, e->f, GET_PSM_LEVEL(e->flag));
3230 : else
3231 0 : ne = exp_var(sql->sa, e->alias.rname, e->alias.name, &e->tpe, GET_PSM_LEVEL(e->flag));
3232 4 : } else if (e->flag & PSM_RETURN) {
3233 0 : ne = exp_return(sql->sa, exp_copy(sql, e->l), GET_PSM_LEVEL(e->flag));
3234 4 : } else if (e->flag & PSM_WHILE) {
3235 0 : ne = exp_while(sql->sa, exp_copy(sql, e->l), exps_copy(sql, e->r));
3236 4 : } else if (e->flag & PSM_IF) {
3237 0 : ne = exp_if(sql->sa, exp_copy(sql, e->l), exps_copy(sql, e->r), exps_copy(sql, e->f));
3238 4 : } else if (e->flag & PSM_REL) {
3239 4 : if (!e->alias.label)
3240 4 : exp_label(sql->sa, e, ++sql->label);
3241 4 : return exp_ref(sql, e);
3242 0 : } else if (e->flag & PSM_EXCEPTION) {
3243 0 : ne = exp_exception(sql->sa, exp_copy(sql, e->l), (const char *) e->r);
3244 : }
3245 : break;
3246 : }
3247 2651499 : if (!ne)
3248 0 : return ne;
3249 2651499 : if (e->alias.name)
3250 2445833 : exp_prop_alias(sql->sa, ne, e);
3251 2651499 : ne = exp_propagate(sql->sa, ne, e);
3252 2651499 : if (is_freevar(e))
3253 8264 : set_freevar(ne, is_freevar(e)-1);
3254 : return ne;
3255 : }
3256 :
3257 : /* scaling for the division operator */
3258 : static sql_exp *
3259 2604 : exp_scale_algebra(mvc *sql, sql_subfunc *f, sql_rel *rel, sql_exp *l, sql_exp *r)
3260 : {
3261 2604 : sql_subtype *lt = exp_subtype(l);
3262 2604 : sql_subtype *rt = exp_subtype(r);
3263 :
3264 2604 : if (!EC_INTERVAL(lt->type->eclass) && lt->type->scale == SCALE_FIX &&
3265 2553 : (lt->scale || rt->scale) && strcmp(sql_func_imp(f->func), "/") == 0) {
3266 170 : sql_subtype *res = f->res->h->data;
3267 170 : unsigned int scale, digits, digL, scaleL;
3268 170 : sql_subtype nlt;
3269 :
3270 : /* scale fixing may require a larger type ! */
3271 170 : scaleL = (lt->scale < sql->div_min_scale) ? sql->div_min_scale : lt->scale;
3272 170 : scaleL += (scaleL < rt->scale) ? rt->scale - scaleL : 0;
3273 170 : scale = scaleL;
3274 170 : scaleL += rt->scale;
3275 170 : digL = lt->digits + (scaleL - lt->scale);
3276 170 : digits = (digL > rt->digits) ? digL : rt->digits;
3277 :
3278 : /* HACK alert: digits should be less than max */
3279 : #ifdef HAVE_HGE
3280 170 : if (res->type->radix == 10 && digits > 38)
3281 170 : digits = 38;
3282 170 : if (res->type->radix == 2 && digits > 127)
3283 170 : digits = 127;
3284 : #else
3285 : if (res->type->radix == 10 && digits > 18)
3286 : digits = 18;
3287 : if (res->type->radix == 2 && digits > 63)
3288 : digits = 63;
3289 : #endif
3290 :
3291 170 : sql_find_subtype(&nlt, lt->type->base.name, digL, scaleL);
3292 170 : if (nlt.digits < scaleL)
3293 2 : return sql_error(sql, 01, SQLSTATE(42000) "Scale (%d) overflows type", scaleL);
3294 168 : l = exp_check_type(sql, &nlt, rel, l, type_equal);
3295 :
3296 168 : sql_find_subtype(res, lt->type->base.name, digits, scale);
3297 2434 : } else if (lt->type->scale == SCALE_FIX) {
3298 2236 : sql_subtype *res = f->res->h->data;
3299 2236 : if (res->type->eclass == EC_NUM)
3300 2215 : res->digits = MAX(lt->digits, rt->digits);
3301 : }
3302 : return l;
3303 : }
3304 :
3305 : sql_exp *
3306 2604 : exps_scale_algebra(mvc *sql, sql_subfunc *f, sql_rel *rel, list *exps)
3307 : {
3308 2604 : if (list_length(exps) != 2)
3309 : return NULL;
3310 2604 : sql_exp *e = exp_scale_algebra(sql, f, rel, exps->h->data, exps->h->next->data);
3311 2604 : if (e)
3312 2602 : exps->h->data = e;
3313 : return e;
3314 : }
3315 :
3316 : void
3317 181505 : exps_digits_add(sql_subfunc *f, list *exps)
3318 : {
3319 : /* concat and friends need larger results */
3320 181505 : if (!f->func->res)
3321 : return;
3322 181505 : int digits = 0;
3323 323967 : for(node *n = exps->h; n; n = n->next) {
3324 264928 : sql_subtype *t = exp_subtype(n->data);
3325 :
3326 264928 : if (!t->digits) {
3327 : digits = 0;
3328 : break;
3329 : }
3330 142462 : digits += t->digits;
3331 : }
3332 181505 : sql_subtype *res = f->res->h->data;
3333 181505 : res->digits = digits;
3334 : }
3335 :
3336 : void
3337 25189 : exps_sum_scales(sql_subfunc *f, list *exps)
3338 : {
3339 : /* sum scales and digits for multiply operation */
3340 25189 : sql_arg *ares = f->func->res->h->data;
3341 :
3342 25189 : if (ares->type.type->scale == SCALE_FIX && strcmp(sql_func_imp(f->func), "*") == 0) {
3343 23890 : unsigned int digits = 0, scale = 0;
3344 23890 : sql_type *largesttype = ares->type.type;
3345 :
3346 71670 : for(node *n = exps->h; n; n = n->next) {
3347 47780 : sql_exp *e = n->data;
3348 47780 : sql_subtype *t = exp_subtype(e);
3349 :
3350 47780 : scale += t->scale;
3351 47780 : digits += t->digits;
3352 47780 : if (largesttype->localtype < t->type->localtype)
3353 0 : largesttype = t->type;
3354 : }
3355 23890 : sql_subtype *res = f->res->h->data;
3356 :
3357 23890 : res->scale = scale;
3358 23890 : res->digits = digits;
3359 :
3360 : /* HACK alert: digits should be less than max */
3361 : #ifdef HAVE_HGE
3362 23890 : if (ares->type.type->radix == 10 && res->digits > 38) {
3363 2473 : res->digits = 38;
3364 2473 : res->scale = MIN(res->scale, res->digits - 1);
3365 : }
3366 23890 : if (ares->type.type->radix == 2 && res->digits > 127) {
3367 25 : res->digits = 127;
3368 25 : res->scale = MIN(res->scale, res->digits - 1);
3369 : }
3370 : #else
3371 : if (ares->type.type->radix == 10 && res->digits > 18) {
3372 : res->digits = 18;
3373 : res->scale = MIN(res->scale, res->digits - 1);
3374 : }
3375 : if (ares->type.type->radix == 2 && res->digits > 63) {
3376 : res->digits = 63;
3377 : res->scale = MIN(res->scale, res->digits - 1);
3378 : }
3379 : #endif
3380 :
3381 23890 : sql_subtype t;
3382 : /* numeric types are fixed length */
3383 23890 : if (ares->type.type->eclass == EC_NUM) {
3384 : #ifdef HAVE_HGE
3385 21125 : if (ares->type.type->localtype == TYPE_hge && res->digits == 127)
3386 25 : t = *sql_bind_localtype("hge");
3387 : else
3388 : #endif
3389 21100 : if (ares->type.type->localtype == TYPE_lng && res->digits == 63)
3390 3 : t = *sql_bind_localtype("lng");
3391 21097 : else if (res->type->digits >= res->digits)
3392 8857 : t = *res; /* we cannot reduce types! */
3393 : else
3394 12240 : sql_find_numeric(&t, ares->type.type->localtype, res->digits);
3395 : } else {
3396 2765 : if (res->digits > largesttype->digits)
3397 219 : sql_find_subtype(&t, largesttype->base.name, res->digits, res->scale);
3398 : else
3399 2546 : sql_init_subtype(&t, largesttype, res->digits, res->scale);
3400 : }
3401 23890 : *res = t;
3402 : }
3403 25189 : }
3404 :
3405 : void
3406 111822 : exps_max_bits(sql_subfunc *f, list *exps)
3407 : {
3408 : /* + and - have max_bits + 1 */
3409 111822 : if (!f->func->res)
3410 : return;
3411 111822 : unsigned int digits = 0;
3412 335466 : for(node *n = exps->h; n; n = n->next) {
3413 223644 : sql_subtype *t = exp_subtype(n->data);
3414 :
3415 223644 : if (!t)
3416 0 : continue;
3417 223644 : if (digits < t->digits)
3418 223644 : digits = t->digits;
3419 : }
3420 : /* + and - (because of negative numbers) could need one extra bit (or digit) */
3421 111822 : digits += 1;
3422 111822 : sql_subtype *res = f->res->h->data;
3423 111822 : if (digits > res->type->digits)
3424 47810 : res = sql_find_numeric(res, res->type->localtype, digits);
3425 : else
3426 64012 : res->digits = digits;
3427 : }
3428 :
3429 : void
3430 19223 : exps_inout(sql_subfunc *f, list *exps)
3431 : {
3432 : /* output == first input */
3433 19223 : if (!f->func->res)
3434 : return;
3435 19223 : sql_subtype *res = f->res->h->data;
3436 19223 : bool is_decimal = (res->type->eclass == EC_DEC);
3437 19223 : unsigned int digits = 0, scale = 0;
3438 19223 : sql_type *largesttype = NULL;
3439 19223 : for(node *n = exps->h; n; n = n->next) {
3440 19223 : sql_subtype *t = exp_subtype(n->data);
3441 :
3442 19223 : if (!t)
3443 0 : continue;
3444 :
3445 19223 : if (is_decimal && t->type->eclass == EC_DEC && (!largesttype || largesttype->localtype < t->type->localtype))
3446 390 : largesttype = t->type;
3447 390 : if (is_decimal && t->type->eclass == EC_NUM) {
3448 0 : unsigned int d = bits2digits(t->digits);
3449 0 : digits = d>digits?d:digits;
3450 19223 : } else if (digits < t->digits)
3451 : digits = t->digits;
3452 19223 : if (scale < t->scale)
3453 : scale = t->scale;
3454 : break;
3455 : }
3456 19223 : if (digits > res->digits || scale > res->scale) {
3457 9395 : if (largesttype)
3458 376 : sql_init_subtype(res, largesttype, digits, scale);
3459 : else
3460 9019 : sql_find_subtype(res, res->type->base.name, digits, scale);
3461 : } else
3462 9828 : res->digits = digits;
3463 : }
3464 :
3465 : /* for aggregates we can reduce the result types size based on real digits/bits used number of known input rows */
3466 : void
3467 9322 : exps_largest_int(sql_subfunc *f, list *exps, lng cnt)
3468 : {
3469 9322 : if (!f->func->res || cnt == 0)
3470 : return;
3471 561 : sql_subtype *res = f->res->h->data;
3472 561 : if (res->type->eclass != EC_DEC && res->type->eclass != EC_NUM)
3473 : return;
3474 485 : bool is_decimal = (res->type->eclass == EC_DEC);
3475 485 : unsigned int digits = 0, scale = 0, mdigits = is_decimal ? decimal_digits(cnt) : number_bits(cnt);
3476 485 : sql_type *largesttype = NULL;
3477 485 : for(node *n = exps->h; n; n = n->next) {
3478 485 : sql_subtype *t = exp_subtype(n->data);
3479 :
3480 485 : if (!t)
3481 0 : continue;
3482 :
3483 485 : largesttype = t->type;
3484 485 : if (is_decimal && t->type->eclass == EC_NUM) {
3485 0 : unsigned int d = bits2digits(t->digits);
3486 0 : digits = d>digits?d:digits;
3487 485 : } else if (digits < t->digits)
3488 : digits = t->digits;
3489 485 : if (scale < t->scale)
3490 : scale = t->scale;
3491 : break;
3492 : }
3493 485 : digits += mdigits;
3494 485 : if (largesttype && digits <= largesttype->digits)
3495 416 : sql_init_subtype(res, largesttype, digits, scale);
3496 69 : else if (is_decimal)
3497 8 : sql_find_subtype(res, res->type->base.name, digits, scale);
3498 : else
3499 61 : sql_find_numeric(res, 1, digits);
3500 : }
3501 :
3502 : #define is_addition(fname) (strcmp(fname, "sql_add") == 0)
3503 : #define is_subtraction(fname) (strcmp(fname, "sql_sub") == 0)
3504 : void
3505 271282 : exps_scale_fix(sql_subfunc *f, list *exps, sql_subtype *atp)
3506 : {
3507 271282 : if (!f->func->res)
3508 : return;
3509 :
3510 271282 : sql_subtype *res = f->res->h->data;
3511 271282 : if (res->type->eclass != EC_ANY && res->type->eclass != EC_DEC)
3512 : return;
3513 :
3514 62043 : unsigned int digits = 0, scale = 0;
3515 62043 : sql_type *largesttype = NULL;
3516 241412 : for(node *n = exps->h; n; n = n->next) {
3517 179369 : sql_subtype *t = exp_subtype(n->data);
3518 :
3519 179369 : if (!t)
3520 0 : continue;
3521 179369 : if (digits < t->digits)
3522 : digits = t->digits;
3523 179369 : if (scale < t->scale)
3524 : scale = t->scale;
3525 179369 : if (t->type->eclass == EC_DEC && (!largesttype || largesttype->localtype < t->type->localtype))
3526 179369 : largesttype = t->type;
3527 : }
3528 62043 : res->scale = scale;
3529 62043 : if (res->type->eclass == EC_DEC)
3530 646 : digits += (is_addition(f->func->base.name) || is_subtraction(f->func->base.name));
3531 62043 : if (digits > res->type->digits) {
3532 61721 : if (largesttype && largesttype->localtype > res->type->localtype)
3533 75 : sql_init_subtype(res, largesttype, digits, scale);
3534 : else
3535 61646 : sql_find_subtype(res, res->type->localtype?res->type->base.name:atp->type->base.name, digits, scale);
3536 322 : } else if (res->type->eclass == EC_DEC || res->type->eclass == EC_NUM)
3537 252 : res->digits = digits;
3538 : }
3539 :
3540 : int
3541 126417 : exp_aggr_is_count(sql_exp *e)
3542 : {
3543 126417 : if (e->type == e_aggr && !((sql_subfunc *)e->f)->func->s && strcmp(((sql_subfunc *)e->f)->func->base.name, "count") == 0)
3544 34763 : return 1;
3545 : return 0;
3546 : }
3547 :
3548 : list *
3549 66929 : check_distinct_exp_names(mvc *sql, list *exps)
3550 : {
3551 66929 : list *distinct_exps = NULL;
3552 66929 : bool duplicates = false;
3553 :
3554 66929 : if (list_length(exps) < 2) {
3555 : return exps; /* always true */
3556 65143 : } else if (list_length(exps) < 5) {
3557 14371 : distinct_exps = list_distinct(exps, (fcmp) exp_equal, (fdup) NULL);
3558 : } else { /* for longer lists, use hashing */
3559 50772 : sql_hash *ht = hash_new(sql->ta, list_length(exps), (fkeyvalue)&exp_key);
3560 :
3561 502158 : for (node *n = exps->h; n && !duplicates; n = n->next) {
3562 451386 : sql_exp *e = n->data;
3563 451386 : int key = ht->key(e);
3564 451386 : sql_hash_e *he = ht->buckets[key&(ht->size-1)];
3565 :
3566 582189 : for (; he && !duplicates; he = he->chain) {
3567 130803 : sql_exp *f = he->value;
3568 :
3569 130803 : if (!exp_equal(e, f))
3570 0 : duplicates = true;
3571 : }
3572 451386 : hash_add(ht, key, e);
3573 : }
3574 : }
3575 65143 : if ((distinct_exps && list_length(distinct_exps) != list_length(exps)) || duplicates)
3576 1 : return NULL;
3577 : return exps;
3578 : }
3579 :
3580 : static int rel_find_parameter(mvc *sql, sql_subtype *type, sql_rel *rel, int nid, const char *relname, const char *expname);
3581 :
3582 : static int
3583 1634 : set_exp_type(mvc *sql, sql_subtype *type, sql_rel *rel, sql_exp *e)
3584 : {
3585 1640 : if (mvc_highwater(sql)) {
3586 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3587 0 : return -1;
3588 : }
3589 1640 : if (e->type == e_column) {
3590 60 : const char *nrname = (const char*) e->l, *nename = (const char*) e->r;
3591 : /* find all the column references and set the type */
3592 60 : e->tpe = *type;
3593 60 : assert(e->nid);
3594 60 : return rel_find_parameter(sql, type, rel, e->nid, nrname, nename);
3595 1580 : } else if (e->type == e_atom && e->f) {
3596 25 : list *atoms = e->f;
3597 25 : if (!list_empty(atoms))
3598 61 : for (node *n = atoms->h; n; n = n->next)
3599 36 : if (set_exp_type(sql, type, rel, n->data) < 0) /* set recursively */
3600 : return -1;
3601 25 : e->tpe = *type;
3602 25 : return 1; /* on a list of atoms, everything should be found */
3603 1555 : } else if (e->type == e_atom && !e->l && !e->r && !e->f) {
3604 1549 : e->tpe = *type;
3605 1549 : return set_type_param(sql, type, e->flag) == 0 ? 1 : 0;
3606 6 : } else if (exp_is_rel(e)) { /* for relation expressions, restart cycle */
3607 6 : rel = (sql_rel*) e->l;
3608 : /* limiting to these cases */
3609 6 : if (!is_project(rel->op) || list_length(rel->exps) != 1)
3610 0 : return 0;
3611 6 : sql_exp *re = rel->exps->h->data;
3612 :
3613 6 : e->tpe = *type;
3614 6 : return set_exp_type(sql, type, rel, re); /* set recursively */
3615 : }
3616 : return 0;
3617 : }
3618 :
3619 : int
3620 1542 : rel_set_type_param(mvc *sql, sql_subtype *type, sql_rel *rel, sql_exp *exp, int upcast)
3621 : {
3622 1542 : if (!type || !exp || (exp->type != e_atom && exp->type != e_column && !exp_is_rel(exp)))
3623 0 : return -1;
3624 :
3625 : /* use largest numeric types */
3626 1542 : if (upcast && type->type->eclass == EC_NUM)
3627 : #ifdef HAVE_HGE
3628 9 : type = sql_bind_localtype("hge");
3629 : #else
3630 : type = sql_bind_localtype("lng");
3631 : #endif
3632 6 : else if (upcast && type->type->eclass == EC_FLT)
3633 1 : type = sql_bind_localtype("dbl");
3634 :
3635 : /* TODO we could use the sql_query* struct to set parameters used as freevars,
3636 : but it requires to change a lot of interfaces */
3637 : /* if (is_freevar(exp))
3638 : rel = query_fetch_outer(query, is_freevar(exp)-1); */
3639 1542 : return set_exp_type(sql, type, rel, exp);
3640 : }
3641 :
3642 : /* try to do an in-place conversion
3643 : *
3644 : * in-place conversion is only possible if the exp is a variable.
3645 : * This is only done to be able to map more cached queries onto the same
3646 : * interface.
3647 : */
3648 : sql_exp *
3649 5077701 : exp_convert_inplace(mvc *sql, sql_subtype *t, sql_exp *exp)
3650 : {
3651 5077701 : atom *a, *na;
3652 :
3653 : /* exclude named variables and variable lists */
3654 5077701 : if (exp->type != e_atom || exp->r /* named */ || exp->f /* list */ || !exp->l /* not direct atom */)
3655 : return NULL;
3656 :
3657 2921629 : a = exp->l;
3658 2921629 : if (!a->isnull && t->scale && t->type->eclass != EC_FLT)
3659 : return NULL;
3660 :
3661 2916346 : if ((na = atom_cast(sql->sa, a, t))) {
3662 2913523 : exp->l = na;
3663 2913523 : return exp;
3664 : }
3665 : return NULL;
3666 : }
3667 :
3668 : sql_exp *
3669 0 : exp_numeric_supertype(mvc *sql, sql_exp *e )
3670 : {
3671 0 : sql_subtype *tp = exp_subtype(e);
3672 :
3673 0 : if (tp->type->eclass == EC_DEC) {
3674 0 : sql_subtype *dtp = sql_bind_localtype("dbl");
3675 :
3676 0 : return exp_check_type(sql, dtp, NULL, e, type_cast);
3677 : }
3678 0 : if (tp->type->eclass == EC_NUM) {
3679 : #ifdef HAVE_HGE
3680 0 : sql_subtype *ltp = sql_bind_localtype("hge");
3681 : #else
3682 : sql_subtype *ltp = sql_bind_localtype("lng");
3683 : #endif
3684 :
3685 0 : return exp_check_type(sql, ltp, NULL, e, type_cast);
3686 : }
3687 : return e;
3688 : }
3689 :
3690 : sql_exp *
3691 5077648 : exp_check_type(mvc *sql, sql_subtype *t, sql_rel *rel, sql_exp *exp, check_type tpe)
3692 : {
3693 5077648 : int c, err = 0;
3694 5077648 : sql_exp* nexp = NULL;
3695 5077648 : sql_subtype *fromtype = exp_subtype(exp);
3696 :
3697 5077611 : if ((!fromtype || !fromtype->type) && rel_set_type_param(sql, t, rel, exp, 0) == 0)
3698 : return exp;
3699 :
3700 : /* first try cheap internal (in-place) conversions ! */
3701 5077610 : if ((nexp = exp_convert_inplace(sql, t, exp)) != NULL)
3702 : return nexp;
3703 :
3704 2164190 : if (fromtype && subtype_cmp(t, fromtype) != 0) {
3705 256940 : if (EC_INTERVAL(fromtype->type->eclass) && (t->type->eclass == EC_NUM || t->type->eclass == EC_POS) && t->digits < fromtype->digits) {
3706 : err = 1; /* conversion from interval to num depends on the number of digits */
3707 : } else {
3708 256940 : c = sql_type_convert(fromtype->type->eclass, t->type->eclass);
3709 256940 : if (!c || (c == 2 && tpe == type_set) || (c == 3 && tpe != type_cast)) {
3710 : err = 1;
3711 : } else {
3712 256425 : exp = exp_convert(sql, exp, fromtype, t);
3713 : }
3714 : }
3715 : }
3716 256425 : if (err) {
3717 515 : const char *name = (exp->type == e_column && !has_label(exp)) ? exp_name(exp) : "%";
3718 578 : sql_exp *res = sql_error( sql, 03, SQLSTATE(42000) "types %s(%u,%u) and %s(%u,%u) are not equal%s%s%s",
3719 515 : fromtype->type->base.name,
3720 : fromtype->digits,
3721 : fromtype->scale,
3722 515 : t->type->base.name,
3723 : t->digits,
3724 : t->scale,
3725 : (name[0] != '%' ? " for column '" : ""),
3726 : (name[0] != '%' ? name : ""),
3727 515 : (name[0] != '%' ? "'" : "")
3728 : );
3729 515 : return res;
3730 : }
3731 : return exp;
3732 : }
3733 :
3734 : sql_exp *
3735 7007 : exp_values_set_supertype(mvc *sql, sql_exp *values, sql_subtype *opt_super)
3736 : {
3737 7007 : assert(is_values(values));
3738 7007 : list *vals = exp_get_values(values), *nexps;
3739 7007 : sql_subtype *tpe = opt_super?opt_super:exp_subtype(vals->h->data);
3740 :
3741 7007 : if (!opt_super && tpe)
3742 6907 : values->tpe = *tpe;
3743 :
3744 30418 : for (node *m = vals->h; m; m = m->next) {
3745 23411 : sql_exp *e = m->data;
3746 23411 : sql_subtype super, *ttpe;
3747 :
3748 : /* if the expression is a parameter set its type */
3749 23411 : if (tpe && e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
3750 4 : if (set_type_param(sql, tpe, e->flag) == 0)
3751 4 : e->tpe = *tpe;
3752 : else
3753 0 : return NULL;
3754 : }
3755 23411 : ttpe = exp_subtype(e);
3756 23411 : if (tpe && ttpe) {
3757 23358 : supertype(&super, ttpe, tpe);
3758 23358 : values->tpe = super;
3759 23358 : tpe = &values->tpe;
3760 : } else {
3761 : tpe = ttpe;
3762 : }
3763 : }
3764 :
3765 7007 : if (tpe) {
3766 : /* if the expression is a parameter set its type */
3767 30331 : for (node *m = vals->h; m; m = m->next) {
3768 23362 : sql_exp *e = m->data;
3769 23362 : if (e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
3770 1 : if (set_type_param(sql, tpe, e->flag) == 0)
3771 1 : e->tpe = *tpe;
3772 : else
3773 : return NULL;
3774 : }
3775 : }
3776 6969 : values->tpe = *tpe;
3777 6969 : nexps = sa_list(sql->sa);
3778 30326 : for (node *m = vals->h; m; m = m->next) {
3779 23360 : sql_exp *e = m->data;
3780 23360 : e = exp_check_type(sql, &values->tpe, NULL, e, type_equal);
3781 23360 : if (!e)
3782 : return NULL;
3783 23357 : exp_label(sql->sa, e, ++sql->label);
3784 23357 : append(nexps, e);
3785 : }
3786 6966 : values->f = nexps;
3787 : }
3788 : return values;
3789 : }
3790 :
3791 : /* return -1 on error, 0 not found, 1 found */
3792 : static int
3793 86 : rel_find_parameter(mvc *sql, sql_subtype *type, sql_rel *rel, int nid, const char *relname, const char *expname)
3794 : {
3795 138 : int res = 0;
3796 :
3797 138 : if (mvc_highwater(sql)) {
3798 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3799 0 : return -1;
3800 : }
3801 138 : if (!rel)
3802 : return 0;
3803 :
3804 135 : const char *nrname = relname, *nename = expname;
3805 135 : if (is_project(rel->op) && !list_empty(rel->exps)) {
3806 111 : sql_exp *e = NULL;
3807 :
3808 111 : assert(nid);
3809 111 : e = exps_bind_nid(rel->exps, nid);
3810 111 : if (!e)
3811 : return 0; /* not found */
3812 108 : if (is_mset(rel->op)) { /* TODO for set relations this needs further improvement */
3813 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Cannot set parameter types under set relations at the moment");
3814 0 : return -1;
3815 : }
3816 : /* set order by column types */
3817 108 : if (is_simple_project(rel->op) && !list_empty(rel->r)) {
3818 0 : sql_exp *ordere = NULL;
3819 0 : ordere = exps_bind_nid(rel->r, nid);
3820 0 : if (ordere && ordere->type == e_column)
3821 0 : ordere->tpe = *type;
3822 : }
3823 108 : if (e->type == e_column) {
3824 52 : nid = e->nid;
3825 52 : nrname = (const char*) e->l;
3826 52 : nename = (const char*) e->r;
3827 52 : e->tpe = *type;
3828 52 : res = 1; /* found */
3829 56 : } else if ((e->type == e_atom || exp_is_rel(e)) && (res = set_exp_type(sql, type, rel, e)) <= 0) {
3830 : return res; /* don't search further */
3831 : }
3832 : /* group by columns can have aliases! */
3833 108 : if (is_groupby(rel->op) && !list_empty(rel->r)) {
3834 0 : e = exps_bind_nid(rel->r, nid);
3835 0 : if (!e)
3836 : return res; /* don't search further */
3837 0 : if (e->type == e_column) {
3838 0 : nid = e->nid;
3839 0 : nrname = (const char*) e->l;
3840 0 : nename = (const char*) e->r;
3841 0 : e->tpe = *type;
3842 0 : } else if ((e->type == e_atom || exp_is_rel(e)) && (res = set_exp_type(sql, type, rel, e)) <= 0) {
3843 : return res; /* don't search further */
3844 : }
3845 : }
3846 108 : if (e->type != e_column)
3847 : return res; /* don't search further */
3848 : }
3849 :
3850 76 : switch (rel->op) {
3851 14 : case op_join:
3852 : case op_left:
3853 : case op_right:
3854 : case op_full:
3855 14 : if (rel->l)
3856 14 : res = rel_find_parameter(sql, type, rel->l, nid, nrname, nename);
3857 14 : if (rel->r && res <= 0) { /* try other relation if not found */
3858 12 : int err = sql->session->status, lres = res;
3859 12 : char buf[ERRSIZE];
3860 :
3861 12 : strcpy(buf, sql->errstr); /* keep error found and try other join relation */
3862 12 : sql->session->status = 0;
3863 12 : sql->errstr[0] = '\0';
3864 12 : res = rel_find_parameter(sql, type, rel->r, nid, nrname, nename);
3865 12 : if (res == 0) { /* parameter wasn't found, set error */
3866 1 : res = lres;
3867 1 : sql->session->status = err;
3868 1 : strcpy(sql->errstr, buf);
3869 : }
3870 : }
3871 : break;
3872 52 : case op_semi:
3873 : case op_anti:
3874 : case op_groupby:
3875 : case op_project:
3876 : case op_select:
3877 : case op_topn:
3878 : case op_sample:
3879 52 : if (rel->l)
3880 : res = rel_find_parameter(sql, type, rel->l, nid, nrname, nename);
3881 : break;
3882 0 : case op_union: /* TODO for set relations this needs further improvement */
3883 : case op_inter:
3884 : case op_except:
3885 : case op_munion: {
3886 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Cannot set parameter types under set relations at the moment");
3887 0 : return -1;
3888 : }
3889 : default: /* For table returning functions, the type must be set when the relation is created */
3890 : return 0;
3891 : }
3892 : return res;
3893 : }
3894 :
3895 : sql_exp *
3896 18011 : list_find_exp( list *exps, sql_exp *e)
3897 : {
3898 18011 : if (e->type != e_column)
3899 : return NULL;
3900 17970 : return exps_bind_nid(exps, e->nid);
3901 : }
|
