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 814363 : compare_str2type(const char *compare_op)
24 : {
25 814363 : comp_type type = cmp_filter;
26 :
27 814363 : if (compare_op[0] == '=') {
28 : type = cmp_equal;
29 159432 : } else if (compare_op[0] == '<') {
30 102511 : type = cmp_lt;
31 102511 : if (compare_op[1] == '>')
32 : type = cmp_notequal;
33 22966 : else if (compare_op[1] == '=')
34 4031 : type = cmp_lte;
35 56921 : } else if (compare_op[0] == '>') {
36 56921 : type = cmp_gt;
37 56921 : if (compare_op[1] == '=')
38 3151 : type = cmp_gte;
39 : }
40 814363 : return type;
41 : }
42 :
43 : comp_type
44 51792 : swap_compare( comp_type t )
45 : {
46 51792 : 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 7653 : negate_compare( comp_type t )
66 : {
67 7653 : switch(t) {
68 : case cmp_equal:
69 : return cmp_notequal;
70 24 : case cmp_notequal:
71 24 : return cmp_equal;
72 2 : case cmp_lt:
73 2 : return cmp_gte;
74 5 : case cmp_lte:
75 5 : return cmp_gt;
76 2 : case cmp_gte:
77 2 : 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 3056 : range2lcompare( int r )
93 : {
94 3056 : if (r&1) {
95 : return cmp_gte;
96 : } else {
97 1155 : return cmp_gt;
98 : }
99 : }
100 :
101 : comp_type
102 3113 : range2rcompare( int r )
103 : {
104 3113 : if (r&2) {
105 : return cmp_lte;
106 : } else {
107 1193 : return cmp_lt;
108 : }
109 : }
110 :
111 : int
112 1872 : compare2range( int l, int r )
113 : {
114 1872 : if (l == cmp_gt) {
115 1772 : if (r == cmp_lt)
116 : return 0;
117 19 : else if (r == cmp_lte)
118 19 : return 2;
119 100 : } else if (l == cmp_gte) {
120 100 : if (r == cmp_lt)
121 : return 1;
122 65 : else if (r == cmp_lte)
123 65 : return 3;
124 : }
125 : return -1;
126 : }
127 :
128 : int
129 107 : compare_funcs2range(const char *l_op, const char *r_op)
130 : {
131 107 : assert(l_op[0] == '>' && r_op[0] == '<');
132 107 : if (!l_op[1] && !r_op[1])
133 : return 0;
134 105 : if (!l_op[1] && r_op[1] == '=')
135 : return 2;
136 105 : if (l_op[1] == '=' && !r_op[1])
137 : return 1;
138 13 : if (l_op[1] == '=' && r_op[1] == '=')
139 : return 3;
140 0 : assert(0);
141 : return 0;
142 : }
143 :
144 : static sql_exp *
145 18172617 : exp_create(allocator *sa, int type)
146 : {
147 18172617 : sql_exp *e = SA_NEW(sa, sql_exp);
148 :
149 18173060 : if (!e)
150 : return NULL;
151 18173060 : *e = (sql_exp) {
152 18173060 : .type = (expression_type) type,
153 : };
154 18173060 : return e;
155 : }
156 :
157 : sql_exp *
158 448004 : exp_compare(allocator *sa, sql_exp *l, sql_exp *r, int cmptype)
159 : {
160 448004 : sql_exp *e = exp_create(sa, e_cmp);
161 448004 : if (e == NULL)
162 : return NULL;
163 448004 : e->card = MAX(l->card,r->card);
164 448004 : e->l = l;
165 448004 : e->r = r;
166 448004 : e->flag = cmptype;
167 448004 : if (!has_nil(l) && !has_nil(r))
168 36130 : set_has_no_nil(e);
169 : return e;
170 : }
171 :
172 : sql_exp *
173 6469 : exp_compare2(allocator *sa, sql_exp *l, sql_exp *r, sql_exp *f, int cmptype, int symmetric)
174 : {
175 6469 : sql_exp *e = exp_create(sa, e_cmp);
176 6469 : if (e == NULL)
177 : return NULL;
178 6469 : assert(f);
179 6469 : e->card = MAX(MAX(l->card,r->card),f->card);
180 6469 : e->l = l;
181 6469 : e->r = r;
182 6469 : e->f = f;
183 6469 : e->flag = cmptype;
184 6469 : if (symmetric)
185 75 : set_symmetric(e);
186 6469 : if (!has_nil(l) && !has_nil(r) && !has_nil(f))
187 507 : set_has_no_nil(e);
188 : return e;
189 : }
190 :
191 : sql_exp *
192 6582 : exp_filter(allocator *sa, list *l, list *r, sql_subfunc *f, int anti)
193 : {
194 6582 : sql_exp *e = exp_create(sa, e_cmp);
195 :
196 6582 : if (e == NULL)
197 : return NULL;
198 6582 : e->card = MAX(exps_card(l),exps_card(r));
199 6582 : if (!r) { /* split l */
200 1372 : list *nl = sa_list(sa), *nr = sa_list(sa);
201 1372 : node *n = l->h;
202 1372 : append(nl, n->data); /* sofar only first is left */
203 3537 : for(n = n->next; n; n = n->next)
204 2165 : append(nr, n->data);
205 : l = nl;
206 : r = nr;
207 : }
208 6582 : e->l = l;
209 6582 : e->r = r;
210 6582 : e->f = f;
211 6582 : e->flag = cmp_filter;
212 6582 : if (anti)
213 793 : set_anti(e);
214 6582 : if (!have_nil(l) && !have_nil(r))
215 3055 : set_has_no_nil(e);
216 : return e;
217 : }
218 :
219 : sql_exp *
220 64667 : exp_or(allocator *sa, list *l, list *r, int anti)
221 : {
222 64667 : sql_exp *e = exp_create(sa, e_cmp);
223 :
224 64667 : if (e == NULL)
225 : return NULL;
226 64667 : e->card = MAX(exps_card(l),exps_card(r));
227 64667 : e->l = l;
228 64667 : e->r = r;
229 64667 : e->flag = cmp_or;
230 64667 : if (anti)
231 0 : set_anti(e);
232 64667 : if (!have_nil(l) && !have_nil(r))
233 2185 : set_has_no_nil(e);
234 : return e;
235 : }
236 :
237 : sql_exp *
238 27646 : exp_in(allocator *sa, sql_exp *l, list *r, int cmptype)
239 : {
240 27646 : sql_exp *e = exp_create(sa, e_cmp);
241 27646 : unsigned int exps_card = CARD_ATOM;
242 :
243 27646 : if (e == NULL)
244 : return NULL;
245 :
246 : /* ignore the cardinalites of sub-relations */
247 139671 : for (node *n = r->h; n ; n = n->next) {
248 112025 : sql_exp *next = n->data;
249 :
250 112025 : if (!exp_is_rel(next) && exps_card < next->card)
251 112025 : exps_card = next->card;
252 : }
253 27646 : e->card = MAX(l->card, exps_card);
254 27646 : e->l = l;
255 27646 : e->r = r;
256 27646 : assert( cmptype == cmp_in || cmptype == cmp_notin);
257 27646 : e->flag = cmptype;
258 27646 : if (!has_nil(l) && !have_nil(r))
259 1758 : set_has_no_nil(e);
260 : return e;
261 : }
262 :
263 : sql_exp *
264 36532 : exp_in_func(mvc *sql, sql_exp *le, sql_exp *vals, int anyequal, int is_tuple)
265 : {
266 36532 : sql_subfunc *a_func = NULL;
267 36532 : sql_exp *e = le;
268 :
269 36532 : if (is_tuple) {
270 5449 : list *l = exp_get_values(e);
271 5449 : e = l->h->data;
272 : }
273 43480 : 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 36532 : e = exp_binop(sql->sa, le, vals, a_func);
276 36532 : if (e) {
277 36532 : unsigned int exps_card = CARD_ATOM;
278 :
279 : /* ignore the cardinalites of sub-relations */
280 36532 : if (vals->type == e_atom && vals->f) {
281 161583 : for (node *n = ((list*)vals->f)->h ; n ; n = n->next) {
282 127937 : sql_exp *next = n->data;
283 :
284 127937 : if (!exp_is_rel(next) && exps_card < next->card)
285 127937 : exps_card = next->card;
286 : }
287 2886 : } else if (!exp_is_rel(vals))
288 2886 : exps_card = vals->card;
289 :
290 36532 : e->card = MAX(le->card, exps_card);
291 36532 : if (!has_nil(le) && !has_nil(vals))
292 603 : set_has_no_nil(e);
293 : }
294 : return e;
295 : }
296 :
297 : sql_exp *
298 5418 : exp_in_aggr(mvc *sql, sql_exp *le, sql_exp *vals, int anyequal, int is_tuple)
299 : {
300 5418 : sql_subfunc *a_func = NULL;
301 5418 : sql_exp *e = le;
302 :
303 5418 : if (is_tuple) {
304 0 : list *l = exp_get_values(e);
305 0 : e = l->h->data;
306 : }
307 5427 : 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 5418 : e = exp_aggr2(sql->sa, le, vals, a_func, need_distinct(e), need_no_nil(e), e->card, has_nil(e));
310 5418 : if (e) {
311 5418 : unsigned int exps_card = CARD_ATOM;
312 :
313 : /* ignore the cardinalites of sub-relations */
314 5418 : if (vals->type == e_atom && vals->f) {
315 30656 : for (node *n = ((list*)vals->f)->h ; n ; n = n->next) {
316 25238 : sql_exp *next = n->data;
317 :
318 25238 : if (!exp_is_rel(next) && exps_card < next->card)
319 25238 : exps_card = next->card;
320 : }
321 0 : } else if (!exp_is_rel(vals))
322 0 : exps_card = vals->card;
323 :
324 5418 : e->card = MAX(le->card, exps_card);
325 5418 : if (!has_nil(le) && !has_nil(vals))
326 0 : set_has_no_nil(e);
327 : }
328 : return e;
329 : }
330 :
331 : sql_exp *
332 119767 : exp_compare_func(mvc *sql, sql_exp *le, sql_exp *re, const char *compareop, int quantifier)
333 : {
334 119767 : sql_subfunc *cmp_func = sql_bind_func(sql, "sys", compareop, exp_subtype(le), exp_subtype(le), F_FUNC, true, true);
335 119767 : sql_exp *e = NULL;
336 :
337 119767 : if (cmp_func == NULL)
338 : return NULL;
339 :
340 119767 : e = exp_binop(sql->sa, le, re, cmp_func);
341 119767 : if (e) {
342 119767 : e->flag = quantifier;
343 : /* At ANY and ALL operators, the cardinality on the right side is ignored if it is a sub-relation */
344 119767 : e->card = quantifier && exp_is_rel(re) ? le->card : MAX(le->card, re->card);
345 119767 : if (!has_nil(le) && !has_nil(re))
346 28151 : set_has_no_nil(e);
347 : }
348 : return e;
349 : }
350 :
351 : static sql_subtype*
352 578703 : dup_subtype(allocator *sa, sql_subtype *st)
353 : {
354 578703 : sql_subtype *res = SA_NEW(sa, sql_subtype);
355 :
356 578703 : if (res == NULL)
357 : return NULL;
358 578703 : *res = *st;
359 578703 : return res;
360 : }
361 :
362 : sql_exp *
363 289352 : exp_convert(allocator *sa, sql_exp *exp, sql_subtype *fromtype, sql_subtype *totype )
364 : {
365 289352 : sql_exp *e = exp_create(sa, e_convert);
366 289351 : if (e == NULL)
367 : return NULL;
368 289351 : e->card = exp->card;
369 289351 : e->l = exp;
370 289351 : totype = dup_subtype(sa, totype);
371 289351 : e->r = append(append(sa_list(sa), dup_subtype(sa, fromtype)),totype);
372 289352 : e->tpe = *totype;
373 289352 : e->alias = exp->alias;
374 289352 : if (!has_nil(exp))
375 81729 : set_has_no_nil(e);
376 : return e;
377 : }
378 :
379 : sql_exp *
380 1074363 : exp_op( allocator *sa, list *l, sql_subfunc *f )
381 : {
382 1074363 : if (f->func->type == F_FILT)
383 1372 : return exp_filter(sa, l, NULL, f, false);
384 1072991 : sql_exp *e = exp_create(sa, e_func);
385 1072991 : if (e == NULL)
386 : return NULL;
387 1072991 : e->card = exps_card(l);
388 1072993 : e->l = l;
389 1072993 : e->f = f;
390 1072993 : e->semantics = f->func->semantics;
391 1072993 : if (!is_semantics(e) && !is_any(e) && l && !have_nil(l))
392 81754 : set_has_no_nil(e);
393 : return e;
394 : }
395 :
396 : sql_exp *
397 18499 : exp_rank_op( allocator *sa, list *l, list *gbe, list *obe, sql_subfunc *f )
398 : {
399 18499 : sql_exp *e = exp_create(sa, e_func);
400 18499 : if (e == NULL)
401 : return NULL;
402 18499 : e->card = list_empty(l)?CARD_MULTI:exps_card(l);
403 18499 : e->l = l;
404 18499 : e->r = append(append(sa_list(sa), gbe), obe);
405 18499 : e->f = f;
406 18499 : if (!f->func->s && strcmp(f->func->base.name, "count") == 0)
407 179 : set_has_no_nil(e);
408 18499 : e->semantics = f->func->semantics;
409 18499 : return e;
410 : }
411 :
412 : sql_exp *
413 59221 : exp_aggr( allocator *sa, list *l, sql_subfunc *a, int distinct, int no_nils, unsigned int card, int has_nils )
414 : {
415 59221 : sql_exp *e = exp_create(sa, e_aggr);
416 59222 : if (e == NULL)
417 : return NULL;
418 59222 : e->card = card;
419 59222 : e->l = l;
420 59222 : e->f = a;
421 59222 : e->semantics = a->func->semantics;
422 59222 : if (distinct)
423 348 : set_distinct(e);
424 59222 : if (no_nils)
425 24369 : set_no_nil(e);
426 59222 : if ((!a->func->semantics && !has_nils) || (!a->func->s && strcmp(a->func->base.name, "count") == 0))
427 23237 : set_has_no_nil(e);
428 : return e;
429 : }
430 :
431 : sql_exp *
432 4522938 : exp_atom(allocator *sa, atom *a)
433 : {
434 4522938 : sql_exp *e = exp_create(sa, e_atom);
435 4522217 : if (e == NULL)
436 : return NULL;
437 4522217 : e->card = CARD_ATOM;
438 4522217 : e->tpe = a->tpe;
439 4522217 : e->l = a;
440 4522217 : if (!a->isnull)
441 4348118 : set_has_no_nil(e);
442 : return e;
443 : }
444 :
445 : sql_exp *
446 0 : exp_atom_max(allocator *sa, sql_subtype *tpe)
447 : {
448 0 : if (tpe->type->localtype == TYPE_bte) {
449 0 : return exp_atom_bte(sa, GDK_bte_max);
450 : } else if (tpe->type->localtype == TYPE_sht) {
451 0 : return exp_atom_sht(sa, GDK_sht_max);
452 : } else if (tpe->type->localtype == TYPE_int) {
453 0 : return exp_atom_int(sa, GDK_int_max);
454 : } else if (tpe->type->localtype == TYPE_lng) {
455 0 : return exp_atom_lng(sa, GDK_lng_max);
456 : #ifdef HAVE_HGE
457 : } else if (tpe->type->localtype == TYPE_hge) {
458 0 : return exp_atom_hge(sa, GDK_hge_max);
459 : #endif
460 : }
461 : return NULL;
462 : }
463 :
464 : sql_exp *
465 131494 : exp_atom_bool(allocator *sa, int b)
466 : {
467 131494 : sql_subtype bt;
468 :
469 131494 : sql_find_subtype(&bt, "boolean", 0, 0);
470 131568 : if (b)
471 83792 : return exp_atom(sa, atom_bool(sa, &bt, TRUE ));
472 : else
473 47776 : return exp_atom(sa, atom_bool(sa, &bt, FALSE ));
474 : }
475 :
476 : sql_exp *
477 0 : exp_atom_bte(allocator *sa, bte i)
478 : {
479 0 : sql_subtype it;
480 :
481 0 : sql_find_subtype(&it, "tinyint", 3, 0);
482 0 : return exp_atom(sa, atom_int(sa, &it, i ));
483 : }
484 :
485 : sql_exp *
486 0 : exp_atom_sht(allocator *sa, sht i)
487 : {
488 0 : sql_subtype it;
489 :
490 0 : sql_find_subtype(&it, "smallint", 5, 0);
491 0 : return exp_atom(sa, atom_int(sa, &it, i ));
492 : }
493 :
494 : sql_exp *
495 832524 : exp_atom_int(allocator *sa, int i)
496 : {
497 832524 : sql_subtype it;
498 :
499 832524 : sql_find_subtype(&it, "int", 9, 0);
500 832753 : return exp_atom(sa, atom_int(sa, &it, i ));
501 : }
502 :
503 : sql_exp *
504 15301 : exp_atom_lng(allocator *sa, lng i)
505 : {
506 15301 : sql_subtype it;
507 :
508 : #ifdef HAVE_HGE
509 15301 : sql_find_subtype(&it, "bigint", 18, 0);
510 : #else
511 : sql_find_subtype(&it, "bigint", 19, 0);
512 : #endif
513 15308 : return exp_atom(sa, atom_int(sa, &it, i ));
514 : }
515 :
516 : sql_exp *
517 16738 : exp_atom_oid(allocator *sa, oid i)
518 : {
519 16738 : sql_subtype it;
520 :
521 : #if SIZEOF_OID == SIZEOF_INT
522 : sql_find_subtype(&it, "oid", 31, 0);
523 : #else
524 16738 : sql_find_subtype(&it, "oid", 63, 0);
525 : #endif
526 16738 : return exp_atom(sa, atom_int(sa, &it, i ));
527 : }
528 :
529 : #ifdef HAVE_HGE
530 : sql_exp *
531 1 : exp_atom_hge(allocator *sa, hge i)
532 : {
533 1 : sql_subtype it;
534 :
535 1 : sql_find_subtype(&it, "hugeint", 39, 0);
536 1 : return exp_atom(sa, atom_int(sa, &it, i ));
537 : }
538 : #endif
539 :
540 : sql_exp *
541 0 : exp_atom_flt(allocator *sa, flt f)
542 : {
543 0 : sql_subtype it;
544 :
545 0 : sql_find_subtype(&it, "real", 24, 0);
546 0 : return exp_atom(sa, atom_float(sa, &it, (dbl)f ));
547 : }
548 :
549 : sql_exp *
550 0 : exp_atom_dbl(allocator *sa, dbl f)
551 : {
552 0 : sql_subtype it;
553 :
554 0 : sql_find_subtype(&it, "double", 53, 0);
555 0 : return exp_atom(sa, atom_float(sa, &it, (dbl)f ));
556 : }
557 :
558 : sql_exp *
559 82516 : exp_atom_str(allocator *sa, const char *s, sql_subtype *st)
560 : {
561 160666 : return exp_atom(sa, atom_string(sa, st, s?sa_strdup(sa, s):NULL));
562 : }
563 :
564 : sql_exp *
565 719315 : exp_atom_clob(allocator *sa, const char *s)
566 : {
567 719315 : sql_subtype clob;
568 :
569 719315 : sql_find_subtype(&clob, "varchar", 0, 0);
570 1437256 : return exp_atom(sa, atom_string(sa, &clob, s?sa_strdup(sa, s):NULL));
571 : }
572 :
573 : sql_exp *
574 261705 : exp_atom_ptr(allocator *sa, void *s)
575 : {
576 261705 : sql_subtype *t = sql_bind_localtype("ptr");
577 261705 : return exp_atom(sa, atom_ptr(sa, t, s));
578 : }
579 :
580 : sql_exp *
581 1664 : exp_atom_ref(allocator *sa, int i, sql_subtype *tpe)
582 : {
583 1664 : sql_exp *e = exp_create(sa, e_atom);
584 1664 : if (e == NULL)
585 : return NULL;
586 1664 : e->card = CARD_ATOM;
587 1664 : e->flag = i;
588 1664 : if (tpe)
589 1664 : e->tpe = *tpe;
590 : return e;
591 : }
592 :
593 : sql_exp *
594 109487 : exp_null(allocator *sa, sql_subtype *tpe)
595 : {
596 109487 : atom *a = atom_general(sa, tpe, NULL, 0);
597 109487 : return exp_atom(sa, a);
598 : }
599 :
600 : sql_exp *
601 2 : exp_zero(allocator *sa, sql_subtype *tpe)
602 : {
603 2 : atom *a = atom_zero_value(sa, tpe);
604 2 : return exp_atom(sa, a);
605 : }
606 :
607 : atom *
608 346 : exp_value(mvc *sql, sql_exp *e)
609 : {
610 346 : if (!e || e->type != e_atom)
611 : return NULL;
612 338 : if (e->l) { /* literal */
613 : return e->l;
614 8 : } else if (e->r) { /* param (ie not set) */
615 8 : sql_var_name *vname = (sql_var_name*) e->r;
616 :
617 8 : assert(e->flag != 0 || vname->sname); /* global variables must have a schema */
618 8 : sql_var *var = e->flag == 0 ? find_global_var(sql, mvc_bind_schema(sql, vname->sname), vname->name) :
619 8 : stack_find_var_at_level(sql, vname->name, e->flag);
620 8 : if (var)
621 0 : return &(var->var);
622 : }
623 : return NULL;
624 : }
625 :
626 : sql_exp *
627 122741 : exp_param_or_declared(allocator *sa, const char *sname, const char *name, sql_subtype *tpe, int frame)
628 : {
629 122741 : sql_var_name *vname;
630 122741 : sql_exp *e = exp_create(sa, e_atom);
631 122741 : if (e == NULL)
632 : return NULL;
633 :
634 122741 : e->r = sa_alloc(sa, sizeof(sql_var_name));
635 122741 : vname = (sql_var_name*) e->r;
636 122741 : vname->sname = sname;
637 122741 : vname->name = name;
638 122741 : e->card = CARD_ATOM;
639 122741 : e->flag = frame;
640 122741 : if (tpe)
641 122741 : e->tpe = *tpe;
642 : return e;
643 : }
644 :
645 : sql_exp *
646 208561 : exp_values(allocator *sa, list *exps)
647 : {
648 208561 : sql_exp *e = exp_create(sa, e_atom);
649 208672 : if (e == NULL)
650 : return NULL;
651 208672 : e->card = exps_card(exps);
652 208762 : e->f = exps;
653 208762 : return e;
654 : }
655 :
656 : list *
657 27297 : exp_get_values(sql_exp *e)
658 : {
659 27297 : if (is_atom(e->type) && e->f)
660 : return e->f;
661 : return NULL;
662 : }
663 :
664 : list *
665 41024 : exp_types(allocator *sa, list *exps)
666 : {
667 41024 : list *l = sa_list(sa);
668 :
669 41024 : if (exps)
670 91920 : for (node *n = exps->h; n; n = n->next)
671 50896 : list_append(l, exp_subtype(n->data));
672 41024 : return l;
673 : }
674 :
675 : int
676 929297 : have_nil(list *exps)
677 : {
678 929297 : int has_nil = 0;
679 :
680 929297 : if (exps)
681 2052099 : for (node *n = exps->h; n && !has_nil; n = n->next) {
682 1122802 : sql_exp *e = n->data;
683 1122802 : has_nil |= has_nil(e);
684 : }
685 929297 : return has_nil;
686 : }
687 :
688 : int
689 213 : have_semantics(list *exps)
690 : {
691 213 : int has_semantics = 0;
692 :
693 213 : if (exps)
694 72 : for (node *n = exps->h; n && !has_semantics; n = n->next) {
695 37 : sql_exp *e = n->data;
696 72 : has_semantics |= is_compare(e->type) && is_semantics(e);
697 : }
698 213 : return has_semantics;
699 : }
700 :
701 : sql_exp *
702 11187030 : exp_column(allocator *sa, const char *rname, const char *cname, sql_subtype *t, unsigned int card, int has_nils, int unique, int intern)
703 : {
704 11187030 : sql_exp *e = exp_create(sa, e_column);
705 :
706 11186997 : if (e == NULL)
707 : return NULL;
708 11186997 : assert(cname);
709 11186997 : e->card = card;
710 11186997 : e->alias.name = cname;
711 11186997 : e->alias.rname = rname;
712 11186997 : e->r = (char*)e->alias.name;
713 11186997 : e->l = (char*)e->alias.rname;
714 11186997 : if (t)
715 11186492 : e->tpe = *t;
716 11186997 : if (!has_nils)
717 2238833 : set_has_no_nil(e);
718 11186997 : if (unique)
719 1563431 : set_unique(e);
720 11186997 : if (intern)
721 817087 : set_intern(e);
722 : return e;
723 : }
724 :
725 : sql_exp *
726 7175768 : exp_propagate(allocator *sa, sql_exp *ne, sql_exp *oe)
727 : {
728 7175768 : if (has_label(oe) &&
729 517291 : (oe->alias.rname == ne->alias.rname || (oe->alias.rname && ne->alias.rname && strcmp(oe->alias.rname, ne->alias.rname) == 0)) &&
730 511146 : (oe->alias.name == ne->alias.name || (oe->alias.name && ne->alias.name && strcmp(oe->alias.name, ne->alias.name) == 0)))
731 511082 : ne->alias.label = oe->alias.label;
732 7175768 : if (is_intern(oe))
733 271731 : set_intern(ne);
734 7175768 : if (is_anti(oe))
735 4282 : set_anti(ne);
736 7175768 : if (is_semantics(oe))
737 567546 : set_semantics(ne);
738 7175768 : if (is_any(oe))
739 22 : set_any(ne);
740 7175768 : if (is_symmetric(oe))
741 13 : set_symmetric(ne);
742 7175768 : if (is_ascending(oe))
743 20299 : set_ascending(ne);
744 7175768 : if (nulls_last(oe))
745 4209 : set_nulls_last(ne);
746 7175768 : if (need_distinct(oe))
747 636 : set_distinct(ne);
748 7175768 : if (zero_if_empty(oe))
749 0 : set_zero_if_empty(ne);
750 7175768 : if (need_no_nil(oe))
751 78985 : set_no_nil(ne);
752 7175768 : if (!has_nil(oe))
753 1668505 : set_has_no_nil(ne);
754 7175768 : if (is_unique(oe))
755 876059 : set_unique(ne);
756 7175768 : if (is_basecol(oe))
757 5829908 : set_basecol(ne);
758 7175768 : ne->p = prop_copy(sa, oe->p);
759 7175768 : return ne;
760 : }
761 :
762 : sql_exp *
763 613529 : exp_ref(mvc *sql, sql_exp *e)
764 : {
765 613529 : if (!exp_name(e))
766 5935 : exp_label(sql->sa, e, ++sql->label);
767 613529 : return 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);
768 : }
769 :
770 : sql_exp *
771 14200 : exp_ref_save(mvc *sql, sql_exp *e)
772 : {
773 14200 : if (is_atom(e->type))
774 5329 : return exp_copy(sql, e);
775 8871 : if (!exp_name(e) || is_convert(e->type))
776 71 : exp_label(sql->sa, e, ++sql->label);
777 8871 : if (e->type != e_column)
778 5217 : e->ref = 1;
779 8871 : sql_exp *ne = exp_ref(sql, e);
780 8871 : if (ne && is_freevar(e))
781 33 : set_freevar(ne, is_freevar(e)-1);
782 : return ne;
783 : }
784 :
785 : sql_exp *
786 2624249 : exp_alias(allocator *sa, 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)
787 : {
788 2624249 : sql_exp *e = exp_column(sa, org_rname, org_cname, t, card, has_nils, unique, intern);
789 :
790 2624700 : if (e == NULL)
791 : return NULL;
792 2624700 : assert(acname && org_cname);
793 2624700 : exp_setname(sa, e, (arname)?arname:org_rname, acname);
794 2624700 : return e;
795 : }
796 :
797 : sql_exp *
798 5444934 : exp_alias_or_copy( mvc *sql, const char *tname, const char *cname, sql_rel *orel, sql_exp *old)
799 : {
800 5444934 : sql_exp *ne = NULL;
801 :
802 5444934 : if (!tname)
803 4724230 : tname = exp_relname(old);
804 :
805 5444932 : if (!cname && exp_name(old) && has_label(old)) {
806 0 : ne = exp_column(sql->sa, exp_relname(old), exp_name(old), exp_subtype(old), orel && old->card != CARD_ATOM?orel->card:CARD_ATOM, has_nil(old), is_unique(old), is_intern(old));
807 0 : return exp_propagate(sql->sa, ne, old);
808 5444932 : } else if (!cname) {
809 21820 : exp_label(sql->sa, old, ++sql->label);
810 21820 : ne = exp_column(sql->sa, exp_relname(old), exp_name(old), exp_subtype(old), orel && old->card != CARD_ATOM?orel->card:CARD_ATOM, has_nil(old), is_unique(old), is_intern(old));
811 21820 : return exp_propagate(sql->sa, ne, old);
812 5423112 : } else if (cname && !old->alias.name) {
813 1816 : exp_setname(sql->sa, old, tname, cname);
814 : }
815 5423112 : ne = exp_column(sql->sa, tname, cname, exp_subtype(old), orel && old->card != CARD_ATOM?orel->card:CARD_ATOM, has_nil(old), is_unique(old), is_intern(old));
816 5423122 : return exp_propagate(sql->sa, ne, old);
817 : }
818 :
819 : sql_exp *
820 0 : exp_alias_ref(mvc *sql, sql_exp *e)
821 : {
822 0 : sql_exp *ne = NULL;
823 0 : const char *tname = exp_relname(e);
824 0 : const char *cname = exp_name(e);
825 :
826 0 : if (!has_label(e))
827 0 : exp_label(sql->sa, e, ++sql->label);
828 0 : ne = exp_ref(sql, e);
829 0 : exp_setname(sql->sa, ne, tname, cname);
830 0 : return exp_propagate(sql->sa, ne, e);
831 : }
832 :
833 : sql_exp *
834 15905 : exp_set(allocator *sa, const char *sname, const char *name, sql_exp *val, int level)
835 : {
836 15905 : sql_exp *e = exp_create(sa, e_psm);
837 :
838 15905 : if (e == NULL)
839 : return NULL;
840 15905 : e->alias.rname = sname;
841 15905 : e->alias.name = name;
842 15905 : e->l = val;
843 15905 : e->flag = PSM_SET + SET_PSM_LEVEL(level);
844 15905 : return e;
845 : }
846 :
847 : sql_exp *
848 9376 : exp_var(allocator *sa, const char *sname, const char *name, sql_subtype *type, int level)
849 : {
850 9376 : sql_exp *e = exp_create(sa, e_psm);
851 :
852 9376 : if (e == NULL)
853 : return NULL;
854 9376 : e->alias.rname = sname;
855 9376 : e->alias.name = name;
856 9376 : e->tpe = *type;
857 9376 : e->flag = PSM_VAR + SET_PSM_LEVEL(level);
858 9376 : return e;
859 : }
860 :
861 : sql_exp *
862 117 : exp_table(allocator *sa, const char *name, sql_table *t, int level)
863 : {
864 117 : sql_exp *e = exp_create(sa, e_psm);
865 :
866 117 : if (e == NULL)
867 : return NULL;
868 117 : e->alias.rname = NULL;
869 117 : e->alias.name = name;
870 117 : e->f = t;
871 117 : e->flag = PSM_VAR + SET_PSM_LEVEL(level);
872 117 : return e;
873 : }
874 :
875 : sql_exp *
876 22936 : exp_return(allocator *sa, sql_exp *val, int level)
877 : {
878 22936 : sql_exp *e = exp_create(sa, e_psm);
879 :
880 22937 : if (e == NULL)
881 : return NULL;
882 22937 : e->l = val;
883 22937 : e->flag = PSM_RETURN + SET_PSM_LEVEL(level);
884 22937 : return e;
885 : }
886 :
887 : sql_exp *
888 1000 : exp_while(allocator *sa, sql_exp *cond, list *stmts)
889 : {
890 1000 : sql_exp *e = exp_create(sa, e_psm);
891 :
892 1000 : if (e == NULL)
893 : return NULL;
894 1000 : e->l = cond;
895 1000 : e->r = stmts;
896 1000 : e->flag = PSM_WHILE;
897 1000 : return e;
898 : }
899 :
900 : sql_exp *
901 11433 : exp_if(allocator *sa, sql_exp *cond, list *if_stmts, list *else_stmts)
902 : {
903 11433 : sql_exp *e = exp_create(sa, e_psm);
904 :
905 11433 : if (e == NULL)
906 : return NULL;
907 11433 : e->l = cond;
908 11433 : e->r = if_stmts;
909 11433 : e->f = else_stmts;
910 11433 : e->flag = PSM_IF;
911 11433 : return e;
912 : }
913 :
914 : sql_exp *
915 77681 : exp_rel(mvc *sql, sql_rel *rel)
916 : {
917 77681 : sql_exp *e = exp_create(sql->sa, e_psm);
918 :
919 77681 : if (e == NULL)
920 : return NULL;
921 77681 : e->l = rel;
922 77681 : e->flag = PSM_REL;
923 77681 : e->card = is_single(rel)?CARD_ATOM:rel->card;
924 77681 : assert(rel);
925 77681 : if (is_topn(rel->op))
926 3 : rel = rel->l;
927 77681 : if (is_project(rel->op)) {
928 58933 : sql_exp *last = rel->exps->t->data;
929 58933 : sql_subtype *t = exp_subtype(last);
930 58934 : e->tpe = t ? *t : (sql_subtype) {0};
931 : }
932 : return e;
933 : }
934 :
935 : sql_exp *
936 157 : exp_exception(allocator *sa, sql_exp *cond, const char *error_message)
937 : {
938 157 : sql_exp *e = exp_create(sa, e_psm);
939 :
940 157 : if (e == NULL)
941 : return NULL;
942 157 : e->l = cond;
943 157 : e->r = sa_strdup(sa, error_message);
944 157 : e->flag = PSM_EXCEPTION;
945 157 : return e;
946 : }
947 :
948 : /* Set a name (alias) for the expression, such that we can refer
949 : to this expression by this simple name.
950 : */
951 : void
952 3786525 : exp_setname(allocator *sa, sql_exp *e, const char *rname, const char *name )
953 : {
954 3786525 : (void)sa;
955 3786525 : e->alias.label = 0;
956 3786525 : if (name)
957 3625315 : e->alias.name = name;
958 3786525 : e->alias.rname = (rname);
959 3786525 : }
960 :
961 : void
962 158165 : noninternexp_setname(allocator *sa, sql_exp *e, const char *rname, const char *name )
963 : {
964 158165 : if (!is_intern(e))
965 158164 : exp_setname(sa, e, rname, name);
966 158165 : }
967 :
968 : void
969 119551 : exp_setalias(sql_exp *e, const char *rname, const char *name )
970 : {
971 119551 : e->alias.label = 0;
972 119551 : e->alias.name = name;
973 119551 : e->alias.rname = rname;
974 119551 : }
975 :
976 : void
977 675448 : exp_prop_alias(allocator *sa, sql_exp *e, sql_exp *oe )
978 : {
979 675448 : e->ref = oe->ref;
980 675448 : if (oe->alias.name == NULL && exp_has_rel(oe)) {
981 7915 : sql_rel *r = exp_rel_get_rel(sa, oe);
982 7915 : if (!is_project(r->op))
983 : return ;
984 7915 : oe = r->exps->t->data;
985 : }
986 675448 : e->alias = oe->alias;
987 : }
988 :
989 : str
990 3445013 : number2name(str s, int len, int i)
991 : {
992 3445013 : s[--len] = 0;
993 9517277 : while(i>0) {
994 6072264 : s[--len] = '0' + (i & 7);
995 6072264 : i >>= 3;
996 : }
997 3445013 : s[--len] = '%';
998 3445013 : return s + len;
999 : }
1000 :
1001 : void
1002 1623490 : exp_setrelname(allocator *sa, sql_exp *e, int nr)
1003 : {
1004 1623490 : char name[16], *nme;
1005 :
1006 1623490 : nme = number2name(name, sizeof(name), nr);
1007 1623490 : e->alias.label = 0;
1008 1623490 : e->alias.rname = sa_strdup(sa, nme);
1009 1623490 : }
1010 :
1011 : char *
1012 1764907 : make_label(allocator *sa, int nr)
1013 : {
1014 1764907 : char name[16], *nme;
1015 :
1016 1764907 : nme = number2name(name, sizeof(name), nr);
1017 1765348 : return sa_strdup(sa, nme);
1018 : }
1019 :
1020 : sql_exp*
1021 1755606 : exp_label(allocator *sa, sql_exp *e, int nr)
1022 : {
1023 1755606 : assert(nr > 0);
1024 1755606 : e->alias.label = nr;
1025 1755606 : e->alias.rname = e->alias.name = make_label(sa, nr);
1026 1756027 : return e;
1027 : }
1028 :
1029 : list*
1030 4209 : exps_label(allocator *sa, list *exps, int nr)
1031 : {
1032 4209 : if (!exps)
1033 : return NULL;
1034 11423 : for (node *n = exps->h; n; n = n->next)
1035 7214 : n->data = exp_label(sa, n->data, nr++);
1036 4209 : list_hash_clear(exps);
1037 4209 : return exps;
1038 : }
1039 :
1040 : void
1041 20454 : exp_swap( sql_exp *e )
1042 : {
1043 20454 : sql_exp *s = e->l;
1044 :
1045 20454 : e->l = e->r;
1046 20454 : e->r = s;
1047 20454 : e->flag = swap_compare((comp_type)e->flag);
1048 20454 : assert(!e->f);
1049 20454 : }
1050 :
1051 : sql_subtype *
1052 31174972 : exp_subtype( sql_exp *e )
1053 : {
1054 31175012 : switch(e->type) {
1055 7774631 : case e_atom: {
1056 7774631 : if (e->l) {
1057 7053873 : atom *a = e->l;
1058 7053873 : return atom_type(a);
1059 720758 : } else if (e->tpe.type) { /* atom reference */
1060 718914 : return &e->tpe;
1061 1844 : } else if (e->f) {
1062 40 : list *vals = exp_get_values(e);
1063 40 : if (!list_empty(vals))
1064 40 : return exp_subtype(vals->h->data);
1065 : }
1066 : break;
1067 : }
1068 18725707 : case e_convert:
1069 : case e_column:
1070 18725707 : if (e->tpe.type)
1071 18725593 : return &e->tpe;
1072 : break;
1073 4540927 : case e_aggr:
1074 : case e_func: {
1075 4540927 : if (e->f) {
1076 4540927 : sql_subfunc *f = e->f;
1077 4540927 : if (f->res && list_length(f->res) == 1)
1078 4530712 : return f->res->h->data;
1079 : }
1080 : return NULL;
1081 : }
1082 7269 : case e_cmp:
1083 7269 : return sql_bind_localtype("bit");
1084 126478 : case e_psm:
1085 126478 : if (e->tpe.type)
1086 126463 : return &e->tpe;
1087 : /* fall through */
1088 : default:
1089 : return NULL;
1090 : }
1091 : return NULL;
1092 : }
1093 :
1094 : const char *
1095 34065212 : exp_name( sql_exp *e )
1096 : {
1097 34081360 : if (e->alias.name)
1098 : return e->alias.name;
1099 1410018 : if (e->type == e_convert && e->l)
1100 : return exp_name(e->l);
1101 1405147 : if (e->type == e_psm && e->l) { /* subquery return name of last expression */
1102 11277 : sql_rel *r = e->l;
1103 11277 : if (is_project(r->op))
1104 11277 : return exp_name(r->exps->t->data);
1105 : }
1106 : return NULL;
1107 : }
1108 :
1109 : const char *
1110 14069486 : exp_relname( sql_exp *e )
1111 : {
1112 14071605 : if (e->alias.rname)
1113 : return e->alias.rname;
1114 598913 : if (!e->alias.name && e->type == e_convert && e->l)
1115 : return exp_relname(e->l);
1116 597954 : if (!e->alias.name && e->type == e_psm && e->l) { /* subquery return name of last expression */
1117 1160 : sql_rel *r = e->l;
1118 1160 : if (is_project(r->op))
1119 1160 : return exp_relname(r->exps->t->data);
1120 : }
1121 : return NULL;
1122 : }
1123 :
1124 : const char *
1125 15598 : exp_find_rel_name(sql_exp *e)
1126 : {
1127 15598 : if (e->alias.rname)
1128 : return e->alias.rname;
1129 261 : switch(e->type) {
1130 : case e_column:
1131 : break;
1132 0 : case e_convert:
1133 0 : return exp_find_rel_name(e->l);
1134 : default:
1135 : return NULL;
1136 : }
1137 : return NULL;
1138 : }
1139 :
1140 : unsigned int
1141 2405577 : exp_card( sql_exp *e )
1142 : {
1143 2405577 : return e->card;
1144 : }
1145 :
1146 : const char *
1147 0 : exp_func_name( sql_exp *e )
1148 : {
1149 0 : if (e->type == e_func && e->f) {
1150 0 : sql_subfunc *f = e->f;
1151 0 : return f->func->base.name;
1152 : }
1153 0 : if (e->alias.name)
1154 : return e->alias.name;
1155 0 : if (e->type == e_convert && e->l)
1156 0 : return exp_name(e->l);
1157 : return NULL;
1158 : }
1159 :
1160 : int
1161 47935419 : exp_cmp( sql_exp *e1, sql_exp *e2)
1162 : {
1163 47935419 : return (e1 == e2)?0:-1;
1164 : }
1165 :
1166 : int
1167 224700 : exp_equal( sql_exp *e1, sql_exp *e2)
1168 : {
1169 224700 : if (e1 == e2)
1170 : return 0;
1171 224700 : if (e1->alias.rname && e2->alias.rname && strcmp(e1->alias.rname, e2->alias.rname) == 0)
1172 168570 : return strcmp(e1->alias.name, e2->alias.name);
1173 56130 : if (!e1->alias.rname && !e2->alias.rname && e1->alias.label == e2->alias.label && e1->alias.name && e2->alias.name)
1174 536 : return strcmp(e1->alias.name, e2->alias.name);
1175 : return -1;
1176 : }
1177 :
1178 : int
1179 47935321 : exp_match( sql_exp *e1, sql_exp *e2)
1180 : {
1181 47935321 : if (exp_cmp(e1, e2) == 0)
1182 : return 1;
1183 47684823 : if (e1->type == e2->type && e1->type == e_column) {
1184 23164773 : if (e1->l != e2->l && (!e1->l || !e2->l || strcmp(e1->l, e2->l) != 0))
1185 : return 0;
1186 13573755 : if (!e1->r || !e2->r || strcmp(e1->r, e2->r) != 0)
1187 : return 0;
1188 : return 1;
1189 : }
1190 24520050 : if (e1->type == e2->type && e1->type == e_func) {
1191 8778352 : if (is_identity(e1, NULL) && is_identity(e2, NULL)) {
1192 0 : list *args1 = e1->l;
1193 0 : list *args2 = e2->l;
1194 :
1195 0 : if (list_length(args1) == list_length(args2) && list_length(args1) == 1) {
1196 0 : sql_exp *ne1 = args1->h->data;
1197 0 : sql_exp *ne2 = args2->h->data;
1198 :
1199 0 : if (exp_match(ne1,ne2))
1200 : return 1;
1201 : }
1202 : }
1203 : }
1204 : return 0;
1205 : }
1206 :
1207 : /* list already contains matching expression */
1208 : sql_exp*
1209 419561 : exps_find_exp( list *l, sql_exp *e)
1210 : {
1211 419561 : node *n;
1212 :
1213 419561 : if (!l || !l->h)
1214 : return NULL;
1215 :
1216 1014100 : for(n=l->h; n; n = n->next) {
1217 945898 : if (exp_match(n->data, e) || exp_refers(n->data, e))
1218 338572 : return n->data;
1219 : }
1220 : return NULL;
1221 : }
1222 :
1223 :
1224 : /* c refers to the parent p */
1225 : int
1226 3995398 : exp_refers( sql_exp *p, sql_exp *c)
1227 : {
1228 3995398 : if (c->type == e_column) {
1229 : // at first they need to have the same expression names
1230 850108 : if (!p->alias.name || !c->r || strcmp(p->alias.name, c->r) != 0)
1231 : return 0;
1232 74580 : if (!c->l)
1233 : return 1;
1234 : // then compare the relation names
1235 64167 : if (c->l && (p->alias.rname || p->l)) {
1236 : // if the parent has an alias for the relation name compare with the child's relation name
1237 64166 : if (p->alias.rname && strcmp(p->alias.rname, c->l) != 0)
1238 : return 0;
1239 : // if the parent does NOT have a relation name alias compare his relation name with the child's
1240 44869 : if (!p->alias.rname && p->l && (strcmp(p->l, c->l) != 0 || strcmp(p->alias.name, p->r) !=0))
1241 : return 0;
1242 44860 : return 1;
1243 : }
1244 : }
1245 : return 0;
1246 : }
1247 :
1248 : int
1249 0 : exp_match_col_exps( sql_exp *e, list *l)
1250 : {
1251 0 : node *n;
1252 :
1253 0 : for(n=l->h; n; n = n->next) {
1254 0 : sql_exp *re = n->data;
1255 0 : sql_exp *re_r = re->r;
1256 :
1257 0 : if (re->type == e_cmp && re->flag == cmp_or)
1258 0 : return exp_match_col_exps(e, re->l) &&
1259 0 : exp_match_col_exps(e, re->r);
1260 :
1261 0 : if (re->type != e_cmp || !re_r || re_r->card != 1 || !exp_match_exp(e, re->l))
1262 0 : return 0;
1263 : }
1264 : return 1;
1265 : }
1266 :
1267 : int
1268 10543 : exps_match_col_exps( sql_exp *e1, sql_exp *e2)
1269 : {
1270 10543 : sql_exp *e1_r = e1->r;
1271 10543 : sql_exp *e2_r = e2->r;
1272 :
1273 10543 : if (e1->type != e_cmp || e2->type != e_cmp)
1274 : return 0;
1275 :
1276 10483 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1277 5969 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1278 5043 : return exp_match_exp(e1->l, e2->l);
1279 :
1280 5440 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1281 926 : (e2->flag == cmp_in || e2->flag == cmp_notin))
1282 844 : return exp_match_exp(e1->l, e2->l);
1283 4596 : if ((e1->flag == cmp_in || e1->flag == cmp_notin) &&
1284 2110 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1285 1583 : return exp_match_exp(e1->l, e2->l);
1286 :
1287 3013 : if ((e1->flag == cmp_in || e1->flag == cmp_notin) &&
1288 527 : (e2->flag == cmp_in || e2->flag == cmp_notin))
1289 527 : return exp_match_exp(e1->l, e2->l);
1290 :
1291 2486 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1292 82 : e2->flag == cmp_or)
1293 0 : return exp_match_col_exps(e1->l, e2->l) &&
1294 0 : exp_match_col_exps(e1->l, e2->r);
1295 :
1296 2486 : if (e1->flag == cmp_or &&
1297 0 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1298 0 : return exp_match_col_exps(e2->l, e1->l) &&
1299 0 : exp_match_col_exps(e2->l, e1->r);
1300 :
1301 2486 : if (e1->flag == cmp_or && e2->flag == cmp_or) {
1302 0 : list *l = e1->l, *r = e1->r;
1303 0 : sql_exp *el = l->h->data;
1304 0 : sql_exp *er = r->h->data;
1305 :
1306 0 : return list_length(l) == 1 && list_length(r) == 1 &&
1307 0 : exps_match_col_exps(el, e2) &&
1308 0 : exps_match_col_exps(er, e2);
1309 : }
1310 : return 0;
1311 : }
1312 :
1313 : int
1314 47756 : exp_match_list( list *l, list *r)
1315 : {
1316 47756 : node *n, *m;
1317 47756 : char *lu, *ru;
1318 47756 : int lc = 0, rc = 0, match = 0;
1319 :
1320 47756 : if (!l || !r)
1321 11 : return l == r;
1322 47745 : if (list_length(l) != list_length(r) || list_length(l) == 0 || list_length(r) == 0)
1323 587 : return 0;
1324 47158 : if (list_length(l) > 10 || list_length(r) > 10)
1325 5 : return 0;/* to expensive */
1326 :
1327 47153 : lu = ZNEW_ARRAY(char, list_length(l));
1328 47153 : ru = ZNEW_ARRAY(char, list_length(r));
1329 47153 : if (!lu || !ru) {
1330 0 : _DELETE(lu);
1331 0 : _DELETE(ru);
1332 0 : return 0;
1333 : }
1334 138417 : for (n = l->h, lc = 0; n; n = n->next, lc++) {
1335 91264 : sql_exp *le = n->data;
1336 :
1337 271716 : for ( m = r->h, rc = 0; m; m = m->next, rc++) {
1338 180452 : sql_exp *re = m->data;
1339 :
1340 180452 : if (!ru[rc] && exp_match_exp(le,re)) {
1341 6791 : lu[lc] = 1;
1342 6791 : ru[rc] = 1;
1343 6791 : match = 1;
1344 : }
1345 : }
1346 : }
1347 54405 : for (n = l->h, lc = 0; n && match; n = n->next, lc++)
1348 7252 : if (!lu[lc])
1349 1378 : match = 0;
1350 52535 : for (n = r->h, rc = 0; n && match; n = n->next, rc++)
1351 5382 : if (!ru[rc])
1352 0 : match = 0;
1353 47153 : _DELETE(lu);
1354 47153 : _DELETE(ru);
1355 47153 : return match;
1356 : }
1357 :
1358 : static int
1359 2417634 : exps_equal( list *l, list *r)
1360 : {
1361 2417634 : node *n, *m;
1362 :
1363 2417634 : if (!l || !r)
1364 50805 : return l == r;
1365 2366829 : if (list_length(l) != list_length(r))
1366 : return 0;
1367 3475683 : for (n = l->h, m = r->h; n && m; n = n->next, m = m->next) {
1368 3428483 : sql_exp *le = n->data, *re = m->data;
1369 :
1370 3428483 : if (!exp_match_exp(le,re))
1371 : return 0;
1372 : }
1373 : return 1;
1374 : }
1375 :
1376 : int
1377 43685600 : exp_match_exp_semantics( sql_exp *e1, sql_exp *e2, bool semantics)
1378 : {
1379 43685600 : if (exp_match(e1, e2))
1380 : return 1;
1381 42490363 : if (is_ascending(e1) != is_ascending(e2) || nulls_last(e1) != nulls_last(e2) || zero_if_empty(e1) != zero_if_empty(e2) ||
1382 42490359 : need_no_nil(e1) != need_no_nil(e2) || is_anti(e1) != is_anti(e2) || (semantics && is_semantics(e1) != is_semantics(e2)) ||
1383 30807462 : (semantics && is_any(e1) != is_any(e2)) ||
1384 31130259 : is_symmetric(e1) != is_symmetric(e2) || is_unique(e1) != is_unique(e2) || need_distinct(e1) != need_distinct(e2))
1385 : return 0;
1386 30503453 : if (e1->type == e2->type) {
1387 22475951 : switch(e1->type) {
1388 380767 : case e_cmp:
1389 632197 : if (e1->flag == e2->flag && !is_complex_exp(e1->flag) &&
1390 255677 : exp_match_exp(e1->l, e2->l) && exp_match_exp(e1->r, e2->r) &&
1391 939 : ((!e1->f && !e2->f) || (e1->f && e2->f && exp_match_exp(e1->f, e2->f))))
1392 936 : return 1;
1393 383267 : else if (e1->flag == e2->flag && e1->flag == cmp_or &&
1394 3448 : exp_match_list(e1->l, e2->l) && exp_match_list(e1->r, e2->r))
1395 : return 1;
1396 379826 : else if (e1->flag == e2->flag &&
1397 259908 : (e1->flag == cmp_in || e1->flag == cmp_notin) &&
1398 2947 : exp_match_exp(e1->l, e2->l) && exp_match_list(e1->r, e2->r))
1399 : return 1;
1400 627183 : else if (e1->flag == e2->flag && (e1->flag == cmp_equal || e1->flag == cmp_notequal) &&
1401 247395 : exp_match_exp(e1->l, e2->r) && exp_match_exp(e1->r, e2->l))
1402 : return 1; /* = and <> operations are reflective, so exp_match_exp can be called crossed */
1403 : break;
1404 277088 : case e_convert:
1405 342859 : if (!subtype_cmp(exp_totype(e1), exp_totype(e2)) &&
1406 94220 : !subtype_cmp(exp_fromtype(e1), exp_fromtype(e2)) &&
1407 28449 : exp_match_exp(e1->l, e2->l))
1408 : return 1;
1409 : break;
1410 58633 : case e_aggr:
1411 93608 : if (!subfunc_cmp(e1->f, e2->f) && /* equal aggregation*/
1412 34975 : exps_equal(e1->l, e2->l))
1413 : return 1;
1414 : break;
1415 4449712 : case e_func: {
1416 4449712 : sql_subfunc *e1f = (sql_subfunc*) e1->f;
1417 4449712 : const char *sname = e1f->func->s ? e1f->func->s->base.name : NULL;
1418 4449712 : int (*comp)(list*, list*) = is_commutative(sname, e1f->func->base.name) ? exp_match_list : exps_equal;
1419 :
1420 8899424 : if (!e1f->func->side_effect &&
1421 6821576 : !subfunc_cmp(e1f, e2->f) && /* equal functions */
1422 2421441 : comp(e1->l, e2->l) &&
1423 : /* optional order by expressions */
1424 49577 : exps_equal(e1->r, e2->r))
1425 : return 1;
1426 : } break;
1427 1068309 : case e_atom:
1428 1068309 : if (e1->l && e2->l && !atom_cmp(e1->l, e2->l))
1429 : return 1;
1430 1036991 : if (e1->f && e2->f && exps_equal(e1->f, e2->f))
1431 : return 1;
1432 1036963 : if (e1->r && e2->r && e1->flag == e2->flag && !subtype_cmp(&e1->tpe, &e2->tpe)) {
1433 0 : sql_var_name *v1 = (sql_var_name*) e1->r, *v2 = (sql_var_name*) e2->r;
1434 0 : if (((!v1->sname && !v2->sname) || (v1->sname && v2->sname && strcmp(v1->sname, v2->sname) == 0)) &&
1435 0 : ((!v1->name && !v2->name) || (v1->name && v2->name && strcmp(v1->name, v2->name) == 0)))
1436 : return 1;
1437 : }
1438 1036963 : if (!e1->l && !e1->r && !e1->f && !e2->l && !e2->r && !e2->f && e1->flag == e2->flag && !subtype_cmp(&e1->tpe, &e2->tpe))
1439 : return 1;
1440 : break;
1441 : default:
1442 : break;
1443 : }
1444 : }
1445 : return 0;
1446 : }
1447 :
1448 : int
1449 43359807 : exp_match_exp( sql_exp *e1, sql_exp *e2)
1450 : {
1451 43359807 : return exp_match_exp_semantics( e1, e2, true);
1452 : }
1453 :
1454 : sql_exp *
1455 141585 : exps_any_match(list *l, sql_exp *e)
1456 : {
1457 141585 : if (!l)
1458 : return NULL;
1459 552543 : for (node *n = l->h; n ; n = n->next) {
1460 500249 : sql_exp *ne = (sql_exp *) n->data;
1461 500249 : if (exp_match_exp(ne, e))
1462 89291 : return ne;
1463 : }
1464 : return NULL;
1465 : }
1466 :
1467 : static int
1468 24 : exps_are_joins( list *l )
1469 : {
1470 24 : if (l)
1471 52 : for (node *n = l->h; n; n = n->next) {
1472 28 : sql_exp *e = n->data;
1473 :
1474 28 : if (exp_is_join_exp(e))
1475 : return -1;
1476 : }
1477 : return 0;
1478 : }
1479 :
1480 : int
1481 257 : exp_is_join_exp(sql_exp *e)
1482 : {
1483 257 : if (exp_is_join(e, NULL) == 0)
1484 : return 0;
1485 25 : if (e->type == e_cmp && e->flag == cmp_or && e->card >= CARD_AGGR)
1486 12 : if (exps_are_joins(e->l) == 0 && exps_are_joins(e->r) == 0)
1487 : return 0;
1488 : return -1;
1489 : }
1490 :
1491 : static int
1492 700299 : exp_is_complex_select( sql_exp *e )
1493 : {
1494 716628 : switch (e->type) {
1495 483 : case e_atom: {
1496 483 : if (e->f) {
1497 0 : int r = (e->card == CARD_ATOM);
1498 0 : list *l = e->f;
1499 :
1500 0 : if (r)
1501 0 : for (node *n = l->h; n && !r; n = n->next)
1502 0 : r |= exp_is_complex_select(n->data);
1503 0 : return r;
1504 : }
1505 : return 0;
1506 : }
1507 16329 : case e_convert:
1508 16329 : return exp_is_complex_select(e->l);
1509 2048 : case e_func:
1510 : case e_aggr:
1511 : {
1512 2048 : int r = (e->card == CARD_ATOM);
1513 2048 : list *l = e->l;
1514 :
1515 2048 : if (r && l)
1516 17 : for (node *n = l->h; n && !r; n = n->next)
1517 0 : r |= exp_is_complex_select(n->data);
1518 : return r;
1519 : }
1520 : case e_psm:
1521 : return 1;
1522 : case e_column:
1523 : case e_cmp:
1524 : default:
1525 : return 0;
1526 : }
1527 : }
1528 :
1529 : static int
1530 350154 : complex_select(sql_exp *e)
1531 : {
1532 350154 : sql_exp *l = e->l, *r = e->r;
1533 :
1534 350154 : if (exp_is_complex_select(l) || exp_is_complex_select(r))
1535 17 : return 1;
1536 : return 0;
1537 : }
1538 :
1539 : static int
1540 843 : distinct_rel(sql_exp *e, const char **rname)
1541 : {
1542 965 : const char *e_rname = NULL;
1543 :
1544 965 : switch(e->type) {
1545 571 : case e_column:
1546 571 : e_rname = exp_relname(e);
1547 :
1548 571 : if (*rname && e_rname && strcmp(*rname, e_rname) == 0)
1549 : return 1;
1550 461 : if (!*rname) {
1551 283 : *rname = e_rname;
1552 283 : return 1;
1553 : }
1554 : break;
1555 139 : case e_aggr:
1556 : case e_func:
1557 139 : if (e->l) {
1558 139 : int m = 1;
1559 139 : list *l = e->l;
1560 139 : node *n;
1561 :
1562 422 : for(n=l->h; n && m; n = n->next) {
1563 283 : sql_exp *ae = n->data;
1564 :
1565 283 : m = distinct_rel(ae, rname);
1566 : }
1567 139 : return m;
1568 : }
1569 : return 0;
1570 : case e_atom:
1571 : return 1;
1572 122 : case e_convert:
1573 122 : return distinct_rel(e->l, rname);
1574 : default:
1575 : return 0;
1576 : }
1577 : return 0;
1578 : }
1579 :
1580 : int
1581 19934587 : rel_has_exp(sql_rel *rel, sql_exp *e, bool subexp)
1582 : {
1583 19934587 : if (rel_find_exp_and_corresponding_rel(rel, e, subexp, NULL, NULL))
1584 4075315 : return 0;
1585 : return -1;
1586 : }
1587 :
1588 : int
1589 0 : rel_has_exps(sql_rel *rel, list *exps, bool subexp)
1590 : {
1591 0 : if (list_empty(exps))
1592 : return 0;
1593 0 : for (node *n = exps->h; n; n = n->next)
1594 0 : if (rel_has_exp(rel, n->data, subexp) >= 0)
1595 : return 0;
1596 : return -1;
1597 : }
1598 :
1599 : int
1600 4790 : rel_has_all_exps(sql_rel *rel, list *exps)
1601 : {
1602 4790 : if (list_empty(exps))
1603 : return 1;
1604 9784 : for (node *n = exps->h; n; n = n->next)
1605 9579 : if (rel_has_exp(rel, n->data, false) < 0)
1606 : return 0;
1607 : return 1;
1608 : }
1609 :
1610 : static int
1611 15402553 : rel_has_exp2(sql_rel *rel, sql_exp *e)
1612 : {
1613 15402553 : return rel_has_exp(rel, e, false);
1614 : }
1615 :
1616 : sql_rel *
1617 5761502 : find_rel(list *rels, sql_exp *e)
1618 : {
1619 5761502 : node *n = list_find(rels, e, (fcmp)&rel_has_exp2);
1620 5761502 : if (n)
1621 3188471 : return n->data;
1622 : return NULL;
1623 : }
1624 :
1625 : sql_rel *
1626 0 : find_one_rel(list *rels, sql_exp *e)
1627 : {
1628 0 : node *n;
1629 0 : sql_rel *fnd = NULL;
1630 :
1631 0 : for(n = rels->h; n; n = n->next) {
1632 0 : if (rel_has_exp(n->data, e, false) == 0) {
1633 0 : if (fnd)
1634 : return NULL;
1635 0 : fnd = n->data;
1636 : }
1637 : }
1638 : return fnd;
1639 : }
1640 :
1641 : static int
1642 288 : exp_is_rangejoin(sql_exp *e, list *rels)
1643 : {
1644 : /* assume e is a e_cmp with 3 args
1645 : * Need to check e->r and e->f only touch one table.
1646 : */
1647 288 : const char *rname = 0;
1648 :
1649 288 : if (distinct_rel(e->r, &rname) && distinct_rel(e->f, &rname))
1650 : return 0;
1651 178 : if (rels) {
1652 128 : sql_rel *r = find_rel(rels, e->r);
1653 128 : sql_rel *f = find_rel(rels, e->f);
1654 128 : if (r && f && r == f)
1655 : return 0;
1656 : }
1657 : return -1;
1658 : }
1659 :
1660 : int
1661 351717 : exp_is_join(sql_exp *e, list *rels)
1662 : {
1663 : /* only simple compare expressions, ie not or lists
1664 : or range expressions (e->f)
1665 : */
1666 351717 : if (e->type == e_cmp && !is_complex_exp(e->flag) && e->l && e->r && !e->f && e->card >= CARD_AGGR && !complex_select(e))
1667 : return 0;
1668 1868 : if (e->type == e_cmp && e->flag == cmp_filter && e->l && e->r && e->card >= CARD_AGGR)
1669 : return 0;
1670 : /* range expression */
1671 1719 : if (e->type == e_cmp && !is_complex_exp(e->flag) && e->l && e->r && e->f && e->card >= CARD_AGGR && !complex_select(e))
1672 288 : return exp_is_rangejoin(e, rels);
1673 : return -1;
1674 : }
1675 :
1676 : int
1677 345965 : exp_is_eqjoin(sql_exp *e)
1678 : {
1679 345965 : if (e->flag == cmp_equal) {
1680 336230 : sql_exp *l = e->l;
1681 336230 : sql_exp *r = e->r;
1682 :
1683 336230 : if (!is_func(l->type) && !is_func(r->type))
1684 335128 : return 0;
1685 : }
1686 : return -1;
1687 : }
1688 :
1689 : sql_exp *
1690 231026 : exps_find_prop(list *exps, rel_prop kind)
1691 : {
1692 231026 : if (list_empty(exps))
1693 : return NULL;
1694 460765 : for (node *n = exps->h ; n ; n = n->next) {
1695 231026 : sql_exp *e = n->data;
1696 :
1697 231026 : if (find_prop(e->p, kind))
1698 1287 : return e;
1699 : }
1700 : return NULL;
1701 : }
1702 :
1703 : static sql_exp *
1704 71749063 : rel_find_exp_and_corresponding_rel_(sql_rel *rel, sql_exp *e, bool subexp, sql_rel **res)
1705 : {
1706 71749063 : sql_exp *ne = NULL;
1707 :
1708 71749063 : if (!rel)
1709 : return NULL;
1710 71748982 : switch(e->type) {
1711 70442792 : case e_column:
1712 70442792 : if (is_basetable(rel->op) && !rel->exps) {
1713 16158 : if (e->l) {
1714 16156 : if (rel_base_bind_column2_(rel, e->l, e->r))
1715 14115 : ne = e;
1716 2 : } else if (rel_base_bind_column_(rel, e->r))
1717 14115 : ne = e;
1718 90483933 : } else if ((!list_empty(rel->exps) && (is_project(rel->op) || is_base(rel->op))) ||
1719 20548964 : (!list_empty(rel->attr) && is_join(rel->op))) {
1720 50860992 : list *l = rel->attr ? rel->attr : rel->exps;
1721 50860992 : if (e->l) {
1722 49608579 : ne = exps_bind_column2(l, e->l, e->r, NULL);
1723 : } else {
1724 1252413 : ne = exps_bind_column(l, e->r, NULL, NULL, 1);
1725 : }
1726 : }
1727 70442820 : if (ne && res)
1728 62856 : *res = rel;
1729 : return ne;
1730 547050 : case e_convert:
1731 547050 : return rel_find_exp_and_corresponding_rel_(rel, e->l, subexp, res);
1732 427727 : case e_aggr:
1733 : case e_func:
1734 427727 : if (e->l) {
1735 425655 : list *l = e->l;
1736 425655 : node *n = l->h;
1737 :
1738 425655 : ne = n->data;
1739 1122342 : while ((subexp || ne != NULL) && n != NULL) {
1740 705222 : ne = rel_find_exp_and_corresponding_rel_(rel, n->data, subexp, res);
1741 705222 : if (subexp && ne)
1742 : break;
1743 696687 : n = n->next;
1744 : }
1745 425655 : return ne;
1746 : }
1747 : break;
1748 : /* fall through */
1749 : case e_cmp:
1750 : case e_psm:
1751 : return NULL;
1752 330673 : case e_atom:
1753 330673 : if (e->f) { /* values */
1754 7446 : list *l = e->f;
1755 7446 : node *n = l->h;
1756 :
1757 7446 : ne = n->data;
1758 17098 : while ((subexp || ne != NULL) && n != NULL) {
1759 9652 : ne = rel_find_exp_and_corresponding_rel_(rel, n->data, subexp, res);
1760 9652 : if (subexp && ne)
1761 : break;
1762 9652 : n = n->next;
1763 : }
1764 7446 : return ne;
1765 : }
1766 : return e;
1767 : }
1768 : return ne;
1769 : }
1770 :
1771 : sql_exp *
1772 70487068 : rel_find_exp_and_corresponding_rel(sql_rel *rel, sql_exp *e, bool subexp, sql_rel **res, bool *under_join)
1773 : {
1774 70487068 : sql_exp *ne = rel_find_exp_and_corresponding_rel_(rel, e, subexp, res);
1775 :
1776 70487186 : if (rel && !ne) {
1777 51314315 : switch(rel->op) {
1778 13282385 : case op_left:
1779 : case op_right:
1780 : case op_full:
1781 : case op_join:
1782 : case op_semi:
1783 : case op_anti:
1784 13282385 : ne = rel_find_exp_and_corresponding_rel(rel->l, e, subexp, res, under_join);
1785 13282385 : if (!ne && is_join(rel->op))
1786 8589483 : ne = rel_find_exp_and_corresponding_rel(rel->r, e, subexp, res, under_join);
1787 : break;
1788 : case op_table:
1789 : case op_basetable:
1790 : break;
1791 296668 : case op_munion:
1792 763834 : for (node* n = ((list*)rel->l)->h; n && !ne; n = n->next)
1793 467166 : ne = rel_find_exp_and_corresponding_rel(n->data, e, subexp, res, under_join);
1794 : break;
1795 10602818 : default:
1796 10602818 : if (!is_project(rel->op) && rel->l)
1797 6763017 : ne = rel_find_exp_and_corresponding_rel(rel->l, e, subexp, res, under_join);
1798 : }
1799 : }
1800 70487186 : if (ne && under_join && is_join(rel->op))
1801 2903361 : *under_join = true;
1802 70487186 : return ne;
1803 : }
1804 :
1805 : sql_exp *
1806 16424389 : rel_find_exp(sql_rel *rel, sql_exp *e)
1807 : {
1808 16424389 : return rel_find_exp_and_corresponding_rel(rel, e, false, NULL, NULL);
1809 : }
1810 :
1811 : int
1812 3982058 : exp_is_true(sql_exp *e)
1813 : {
1814 3982058 : if (e->type == e_atom && e->l)
1815 19582 : return atom_is_true(e->l);
1816 3962476 : if (e->type == e_cmp && e->flag == cmp_equal)
1817 3211889 : return (exp_is_true(e->l) && exp_is_true(e->r) && exp_match_exp(e->l, e->r));
1818 : return 0;
1819 : }
1820 :
1821 : static inline bool
1822 307466 : exp_is_cmp_exp_is_false(sql_exp* e)
1823 : {
1824 307466 : sql_exp *l = e->l;
1825 307466 : sql_exp *r = e->r;
1826 307466 : assert(e->type == e_cmp && e->f == NULL && l && r);
1827 :
1828 : /* Handle 'v is x' and 'v is not x' expressions.
1829 : * Other cases in is-semantics are unspecified.
1830 : */
1831 307466 : if (e->flag != cmp_equal && e->flag != cmp_notequal)
1832 : return false;
1833 307466 : if (e->flag == cmp_equal && !is_anti(e))
1834 487966 : return ((exp_is_null(l) && exp_is_not_null(r)) || (exp_is_not_null(l) && exp_is_null(r)));
1835 63483 : if ((e->flag == cmp_notequal && !is_anti(e)) || (e->flag == cmp_equal && is_anti(e)))
1836 126914 : return exp_is_null(l) && exp_is_null(r);
1837 : return false;
1838 : }
1839 :
1840 : static inline bool
1841 5376411 : exp_single_bound_cmp_exp_is_false(sql_exp* e) {
1842 5376411 : assert(e->type == e_cmp);
1843 5376411 : sql_exp* l = e->l;
1844 5376411 : sql_exp* r = e->r;
1845 5376411 : assert(e->f == NULL);
1846 5376411 : assert (l && r);
1847 :
1848 5376411 : return exp_is_null(l) || exp_is_null(r);
1849 : }
1850 :
1851 : static inline bool
1852 73961 : exp_two_sided_bound_cmp_exp_is_false(sql_exp* e) {
1853 73961 : assert(e->type == e_cmp);
1854 73961 : sql_exp* v = e->l;
1855 73961 : sql_exp* l = e->r;
1856 73961 : sql_exp* h = e->f;
1857 73961 : assert (v && l && h);
1858 :
1859 73961 : return is_anti(e) ? exp_is_null(v) || (exp_is_null(l) && exp_is_null(h)) : false;
1860 : }
1861 :
1862 : static inline bool
1863 5765637 : exp_regular_cmp_exp_is_false(sql_exp* e) {
1864 5765637 : assert(e->type == e_cmp);
1865 :
1866 5765637 : if (is_semantics(e) && !is_any(e)) return exp_is_cmp_exp_is_false(e);
1867 5458171 : if (is_any(e)) return false;
1868 5450372 : if (e -> f) return exp_two_sided_bound_cmp_exp_is_false(e);
1869 5376411 : else return exp_single_bound_cmp_exp_is_false(e);
1870 : }
1871 :
1872 : static inline bool
1873 593439 : exp_or_exp_is_false(sql_exp* e) {
1874 593439 : assert(e->type == e_cmp && e->flag == cmp_or);
1875 :
1876 593439 : list* left = e->l;
1877 593439 : list* right = e->r;
1878 :
1879 593439 : bool left_is_false = false;
1880 1238193 : for(node* n = left->h; n; n=n->next) {
1881 645121 : if (exp_is_false(n->data)) {
1882 : left_is_false=true;
1883 : break;
1884 : }
1885 : }
1886 :
1887 593439 : if (!left_is_false) {
1888 : return false;
1889 : }
1890 :
1891 689 : for(node* n = right->h; n; n=n->next) {
1892 387 : if (exp_is_false(n->data)) {
1893 : return true;
1894 : }
1895 : }
1896 :
1897 : return false;
1898 : }
1899 :
1900 : static inline bool
1901 6676445 : exp_cmp_exp_is_false(sql_exp* e) {
1902 6676445 : assert(e->type == e_cmp);
1903 :
1904 6676445 : switch (e->flag) {
1905 5765637 : case cmp_gt:
1906 : case cmp_gte:
1907 : case cmp_lte:
1908 : case cmp_lt:
1909 : case cmp_equal:
1910 : case cmp_notequal:
1911 5765637 : return exp_regular_cmp_exp_is_false(e);
1912 593439 : case cmp_or:
1913 593439 : return exp_or_exp_is_false(e);
1914 : default:
1915 : return false;
1916 : }
1917 : }
1918 :
1919 : int
1920 6752692 : exp_is_false(sql_exp *e)
1921 : {
1922 6752692 : if (e->type == e_atom && e->l)
1923 33349 : return atom_is_false(e->l);
1924 6719343 : else if (e->type == e_cmp)
1925 6676445 : return exp_cmp_exp_is_false(e);
1926 : return 0;
1927 : }
1928 :
1929 : int
1930 17333 : exp_is_zero(sql_exp *e)
1931 : {
1932 17333 : if (e->type == e_atom && e->l)
1933 17036 : return atom_is_zero(e->l);
1934 : return 0;
1935 : }
1936 :
1937 : int
1938 363992 : exp_is_not_null(sql_exp *e)
1939 : {
1940 364421 : if (!has_nil(e))
1941 : return true;
1942 :
1943 220755 : switch (e->type) {
1944 2729 : case e_atom:
1945 2729 : if (e->f) /* values list */
1946 : return false;
1947 2729 : if (e->l)
1948 2601 : return !(atom_null(e->l));
1949 : return false;
1950 429 : case e_convert:
1951 429 : return exp_is_not_null(e->l);
1952 776 : case e_func:
1953 776 : if (!is_semantics(e) && e->l) {
1954 413 : list *l = e->l;
1955 460 : for (node *n = l->h; n; n=n->next) {
1956 460 : sql_exp *p = n->data;
1957 460 : if (!exp_is_not_null(p))
1958 : return false;
1959 : }
1960 : return true;
1961 : }
1962 : return false;
1963 : case e_aggr:
1964 : case e_column:
1965 : case e_cmp:
1966 : case e_psm:
1967 : return false;
1968 : }
1969 : return false;
1970 : }
1971 :
1972 : int
1973 12021384 : exp_is_null(sql_exp *e )
1974 : {
1975 12098215 : if (!has_nil(e))
1976 : return false;
1977 :
1978 7068183 : switch (e->type) {
1979 200658 : case e_atom:
1980 200658 : if (e->f) /* values list */
1981 : return 0;
1982 200658 : if (e->l)
1983 124189 : return (atom_null(e->l));
1984 : return 0;
1985 76831 : case e_convert:
1986 76831 : return exp_is_null(e->l);
1987 155336 : case e_func:
1988 155336 : if (!is_semantics(e) && e->l) {
1989 : /* This is a call to a function with no-nil semantics.
1990 : * If one of the parameters is null the expression itself is null
1991 : */
1992 142767 : list* l = e->l;
1993 425874 : for(node* n = l->h; n; n=n->next) {
1994 283266 : sql_exp* p = n->data;
1995 283266 : if (exp_is_null(p)) {
1996 : return true;
1997 : }
1998 : }
1999 : }
2000 : return 0;
2001 : case e_aggr:
2002 : case e_column:
2003 : case e_cmp:
2004 : case e_psm:
2005 : return 0;
2006 : }
2007 : return 0;
2008 : }
2009 :
2010 : int
2011 1809817 : exp_is_rel( sql_exp *e )
2012 : {
2013 1819012 : if (e) {
2014 1819012 : switch(e->type){
2015 9195 : case e_convert:
2016 9195 : return exp_is_rel(e->l);
2017 335216 : case e_psm:
2018 335216 : return e->flag == PSM_REL && e->l;
2019 : default:
2020 : return 0;
2021 : }
2022 : }
2023 : return 0;
2024 : }
2025 :
2026 : int
2027 7106 : exps_one_is_rel(list *exps)
2028 : {
2029 7106 : if (list_empty(exps))
2030 : return 0;
2031 21217 : for(node *n = exps->h ; n ; n = n->next)
2032 14119 : if (exp_is_rel(n->data))
2033 : return 1;
2034 : return 0;
2035 : }
2036 :
2037 : int
2038 8322130 : exp_is_atom( sql_exp *e )
2039 : {
2040 8562070 : switch (e->type) {
2041 1142965 : case e_atom:
2042 1142965 : if (e->f) /* values list */
2043 : return 0;
2044 : return 1;
2045 239940 : case e_convert:
2046 239940 : return exp_is_atom(e->l);
2047 1187687 : case e_func:
2048 : case e_aggr:
2049 1187687 : return e->card == CARD_ATOM && exps_are_atoms(e->l);
2050 2697 : case e_cmp:
2051 2697 : if (e->card != CARD_ATOM)
2052 : return 0;
2053 141 : if (e->flag == cmp_or || e->flag == cmp_filter)
2054 79 : return exps_are_atoms(e->l) && exps_are_atoms(e->r);
2055 66 : if (e->flag == cmp_in || e->flag == cmp_notin)
2056 0 : return exp_is_atom(e->l) && exps_are_atoms(e->r);
2057 66 : return exp_is_atom(e->l) && exp_is_atom(e->r) && (!e->f || exp_is_atom(e->f));
2058 : case e_column:
2059 : case e_psm:
2060 : return 0;
2061 : }
2062 : return 0;
2063 : }
2064 :
2065 : int
2066 29270441 : exp_has_rel( sql_exp *e )
2067 : {
2068 29892465 : if (!e)
2069 : return 0;
2070 29890951 : switch(e->type){
2071 4438884 : case e_func:
2072 : case e_aggr:
2073 4438884 : return exps_have_rel_exp(e->l);
2074 673163 : case e_cmp:
2075 673163 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2076 74544 : return (exps_have_rel_exp(e->l) || exps_have_rel_exp(e->r));
2077 599095 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2078 36231 : return (exp_has_rel(e->l) || exps_have_rel_exp(e->r));
2079 : } else {
2080 1125728 : return (exp_has_rel(e->l) || exp_has_rel(e->r) || (e->f && exp_has_rel(e->f)));
2081 : }
2082 622024 : case e_convert:
2083 622024 : return exp_has_rel(e->l);
2084 166278 : case e_psm:
2085 166278 : return exp_is_rel(e);
2086 12528915 : case e_atom:
2087 12528915 : return (e->f && exps_have_rel_exp(e->f));
2088 : case e_column:
2089 : return 0;
2090 : }
2091 : return 0;
2092 : }
2093 :
2094 : int
2095 5187142 : exps_have_rel_exp( list *exps)
2096 : {
2097 5187142 : if (list_empty(exps))
2098 : return 0;
2099 16882990 : for(node *n=exps->h; n; n=n->next) {
2100 11820489 : sql_exp *e = n->data;
2101 :
2102 11820489 : if (exp_has_rel(e))
2103 : return 1;
2104 : }
2105 : return 0;
2106 : }
2107 :
2108 : static sql_rel *
2109 547 : exps_rel_get_rel(allocator *sa, list *exps )
2110 : {
2111 547 : sql_rel *r = NULL, *xp = NULL;
2112 :
2113 547 : if (list_empty(exps))
2114 : return NULL;
2115 1612 : for (node *n = exps->h; n; n=n->next){
2116 1065 : sql_exp *e = n->data;
2117 :
2118 1065 : if (exp_has_rel(e)) {
2119 552 : if (!(r = exp_rel_get_rel(sa, e)))
2120 : return NULL;
2121 552 : if (xp) {
2122 5 : xp = rel_crossproduct(sa, xp, r, op_full);
2123 5 : set_processed(xp);
2124 : } else {
2125 : xp = r;
2126 : }
2127 : }
2128 : }
2129 : return xp;
2130 : }
2131 :
2132 : int
2133 45 : exp_rel_depth(sql_exp *e)
2134 : {
2135 45 : if (!e)
2136 : return 0;
2137 45 : switch(e->type){
2138 : case e_func:
2139 : case e_aggr:
2140 : case e_cmp:
2141 : return 1;
2142 : case e_convert:
2143 : return 0;
2144 33 : case e_psm:
2145 33 : if (exp_is_rel(e))
2146 : return 0;
2147 : return 1;
2148 : case e_atom:
2149 : case e_column:
2150 : return 0;
2151 : }
2152 : return 0;
2153 : }
2154 :
2155 : sql_rel *
2156 73643 : exp_rel_get_rel(allocator *sa, sql_exp *e)
2157 : {
2158 74534 : if (!e)
2159 : return NULL;
2160 :
2161 74534 : switch(e->type){
2162 519 : case e_func:
2163 : case e_aggr:
2164 519 : return exps_rel_get_rel(sa, e->l);
2165 36 : case e_cmp: {
2166 36 : sql_rel *r = NULL, *xp = NULL;
2167 :
2168 36 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2169 12 : if (exps_have_rel_exp(e->l))
2170 6 : xp = exps_rel_get_rel(sa, e->l);
2171 12 : if (exps_have_rel_exp(e->r)) {
2172 7 : if (!(r = exps_rel_get_rel(sa, e->r)))
2173 : return NULL;
2174 7 : if (xp) {
2175 1 : xp = rel_crossproduct(sa, xp, r, op_join);
2176 1 : set_processed(xp);
2177 : } else {
2178 : xp = r;
2179 : }
2180 : }
2181 24 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2182 0 : if (exp_has_rel(e->l))
2183 0 : xp = exp_rel_get_rel(sa, e->l);
2184 0 : if (exps_have_rel_exp(e->r)) {
2185 0 : if (!(r = exps_rel_get_rel(sa, e->r)))
2186 : return NULL;
2187 0 : if (xp) {
2188 0 : xp = rel_crossproduct(sa, xp, r, op_join);
2189 0 : set_processed(xp);
2190 : } else {
2191 : xp = r;
2192 : }
2193 : }
2194 : } else {
2195 24 : if (exp_has_rel(e->l))
2196 23 : xp = exp_rel_get_rel(sa, e->l);
2197 24 : if (exp_has_rel(e->r)) {
2198 6 : if (!(r = exp_rel_get_rel(sa, e->r)))
2199 : return NULL;
2200 6 : if (xp) {
2201 5 : xp = rel_crossproduct(sa, xp, r, op_join);
2202 5 : set_processed(xp);
2203 : } else {
2204 : xp = r;
2205 : }
2206 : }
2207 24 : if (e->f && exp_has_rel(e->f)) {
2208 0 : if (!(r = exp_rel_get_rel(sa, e->f)))
2209 : return NULL;
2210 0 : if (xp) {
2211 0 : xp = rel_crossproduct(sa, xp, r, op_join);
2212 0 : set_processed(xp);
2213 : } else {
2214 : xp = r;
2215 : }
2216 : }
2217 : }
2218 : return xp;
2219 : }
2220 891 : case e_convert:
2221 891 : return exp_rel_get_rel(sa, e->l);
2222 73073 : case e_psm:
2223 73073 : if (exp_is_rel(e))
2224 73073 : return e->l;
2225 : return NULL;
2226 15 : case e_atom:
2227 15 : if (e->f && exps_have_rel_exp(e->f))
2228 15 : return exps_rel_get_rel(sa, e->f);
2229 : return NULL;
2230 : case e_column:
2231 : return NULL;
2232 : }
2233 : return NULL;
2234 : }
2235 :
2236 : static void exp_rel_update_set_freevar(sql_exp *e);
2237 :
2238 : static void
2239 901 : exps_rel_update_set_freevar(list *exps)
2240 : {
2241 901 : if (!list_empty(exps))
2242 2930 : for (node *n=exps->h; n ; n=n->next)
2243 2029 : exp_rel_update_set_freevar(n->data);
2244 901 : }
2245 :
2246 : static void
2247 2313 : exp_rel_update_set_freevar(sql_exp *e)
2248 : {
2249 2323 : if (!e)
2250 : return ;
2251 :
2252 2323 : switch(e->type){
2253 898 : case e_func:
2254 : case e_aggr:
2255 898 : exps_rel_update_set_freevar(e->l);
2256 898 : break;
2257 8 : case e_cmp:
2258 8 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2259 0 : exps_rel_update_set_freevar(e->l);
2260 0 : exps_rel_update_set_freevar(e->r);
2261 8 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2262 0 : exp_rel_update_set_freevar(e->l);
2263 0 : exps_rel_update_set_freevar(e->r);
2264 : } else {
2265 8 : exp_rel_update_set_freevar(e->l);
2266 8 : exp_rel_update_set_freevar(e->r);
2267 8 : if (e->f)
2268 : exp_rel_update_set_freevar(e->f);
2269 : }
2270 : break;
2271 7 : case e_convert:
2272 7 : exp_rel_update_set_freevar(e->l);
2273 7 : break;
2274 1135 : case e_atom:
2275 1135 : if (e->f)
2276 3 : exps_rel_update_set_freevar(e->f);
2277 : break;
2278 275 : case e_column:
2279 275 : set_freevar(e, 1);
2280 275 : break;
2281 : case e_psm:
2282 : break;
2283 : }
2284 : }
2285 :
2286 : static list *
2287 547 : exp_rel_update_exps(mvc *sql, list *exps, bool up)
2288 : {
2289 547 : if (list_empty(exps))
2290 : return exps;
2291 1612 : for (node *n = exps->h; n; n=n->next){
2292 1065 : sql_exp *e = n->data;
2293 :
2294 1065 : if (exp_has_rel(e))
2295 552 : n->data = exp_rel_update_exp(sql, e, up);
2296 513 : else if (!exp_is_atom(e) && !up)
2297 262 : exp_rel_update_set_freevar(e);
2298 : }
2299 : return exps;
2300 : }
2301 :
2302 : static sql_exp *
2303 51 : exp_rel_update_exp_(mvc *sql, sql_exp *e, bool up)
2304 : {
2305 51 : if (exp_has_rel(e))
2306 28 : e = exp_rel_update_exp(sql, e, up);
2307 23 : else if (!exp_is_atom(e) && !up)
2308 6 : exp_rel_update_set_freevar(e);
2309 51 : return e;
2310 : }
2311 :
2312 : sql_exp *
2313 12743 : exp_rel_update_exp(mvc *sql, sql_exp *e, bool up)
2314 : {
2315 12743 : if (!e)
2316 : return NULL;
2317 :
2318 12743 : switch(e->type){
2319 519 : case e_func:
2320 : case e_aggr:
2321 519 : if (exps_have_rel_exp(e->l))
2322 519 : e->l = exp_rel_update_exps(sql, e->l, up);
2323 : return e;
2324 35 : case e_cmp:
2325 35 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2326 12 : if (exps_have_rel_exp(e->l))
2327 6 : e->l = exp_rel_update_exps(sql, e->l, up);
2328 12 : if (exps_have_rel_exp(e->r))
2329 7 : e->r = exp_rel_update_exps(sql, e->r, up);
2330 23 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2331 0 : if (exp_has_rel(e->l))
2332 0 : e->l = exp_rel_update_exp(sql, e->l, up);
2333 0 : if (exps_have_rel_exp(e->r))
2334 0 : e->r = exp_rel_update_exps(sql, e->r, up);
2335 : } else {
2336 : //if (exp_has_rel(e->l))
2337 23 : e->l = exp_rel_update_exp_(sql, e->l, up);
2338 : //if (exp_has_rel(e->r))
2339 23 : e->r = exp_rel_update_exp_(sql, e->r, up);
2340 23 : if (e->f /*&& exp_has_rel(e->f)*/)
2341 5 : e->f = exp_rel_update_exp_(sql, e->f, up);
2342 : }
2343 : return e;
2344 891 : case e_convert:
2345 891 : if (exp_has_rel(e->l))
2346 891 : e->l = exp_rel_update_exp(sql, e->l, up);
2347 : return e;
2348 11283 : case e_psm:
2349 11283 : if (exp_is_rel(e)) {
2350 11283 : sql_rel *r = exp_rel_get_rel(sql->sa, e), *nr = r;
2351 11283 : if (is_topn(r->op)) {
2352 2 : nr = r->l;
2353 2 : if (nr && !is_project(nr->op))
2354 0 : r->l = nr = rel_project(sql->sa, nr, rel_projections(sql, nr, NULL, 1, 0));
2355 : }
2356 11283 : e = nr->exps->t->data;
2357 11283 : e = exp_ref(sql, e);
2358 11283 : if (up)
2359 0 : set_freevar(e, 1);
2360 11283 : return e;
2361 : }
2362 : return e;
2363 15 : case e_atom:
2364 15 : if (e->f && exps_have_rel_exp(e->f))
2365 15 : e->f = exp_rel_update_exps(sql, e->f, up);
2366 : return e;
2367 : case e_column:
2368 : return e;
2369 : }
2370 : return e;
2371 : }
2372 :
2373 : sql_exp *
2374 3725 : exp_rel_label(mvc *sql, sql_exp *e)
2375 : {
2376 3725 : if (exp_is_rel(e))
2377 3725 : e->l = rel_label(sql, e->l, 1);
2378 3725 : return e;
2379 : }
2380 :
2381 : int
2382 162559 : exps_are_atoms( list *exps)
2383 : {
2384 162559 : int atoms = 1;
2385 162559 : if (!list_empty(exps))
2386 390196 : for(node *n=exps->h; n && atoms; n=n->next)
2387 277401 : atoms &= exp_is_atom(n->data);
2388 162562 : return atoms;
2389 : }
2390 :
2391 : int
2392 83 : exps_have_func(list *exps)
2393 : {
2394 83 : if (list_empty(exps))
2395 : return 0;
2396 131 : for(node *n=exps->h; n; n=n->next) {
2397 98 : sql_exp *e = n->data;
2398 :
2399 98 : if (exp_has_func(e))
2400 : return 1;
2401 : }
2402 : return 0;
2403 : }
2404 :
2405 : static int exp_has_func_or_cmp(sql_exp *e, bool cmp);
2406 :
2407 : static int
2408 63041 : exps_have_func_or_cmp(list *exps, bool cmp)
2409 : {
2410 63041 : if (list_empty(exps))
2411 : return 0;
2412 184345 : for(node *n=exps->h; n; n=n->next) {
2413 130543 : sql_exp *e = n->data;
2414 :
2415 130543 : if (exp_has_func_or_cmp(e, cmp))
2416 : return 1;
2417 : }
2418 : return 0;
2419 : }
2420 :
2421 : static int
2422 2077678 : exp_has_func_or_cmp(sql_exp *e, bool cmp)
2423 : {
2424 2077678 : if (!e)
2425 : return 0;
2426 2077678 : switch (e->type) {
2427 308868 : case e_atom:
2428 308868 : if (e->f)
2429 0 : return exps_have_func_or_cmp(e->f, true);
2430 : return 0;
2431 15027 : case e_convert:
2432 15027 : return exp_has_func_or_cmp(e->l, cmp);
2433 : case e_func:
2434 : return 1;
2435 15561 : case e_aggr:
2436 15561 : if (e->l)
2437 13084 : return exps_have_func_or_cmp(e->l, true);
2438 : return 0;
2439 272266 : case e_cmp:
2440 272266 : if (cmp)
2441 : return 1;
2442 263131 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2443 21790 : return (exps_have_func_or_cmp(e->l, true) || exps_have_func_or_cmp(e->r, true));
2444 250517 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2445 33944 : return (exp_has_func_or_cmp(e->l, true) || exps_have_func_or_cmp(e->r, true));
2446 : } else {
2447 433236 : return (exp_has_func_or_cmp(e->l, true) || exp_has_func_or_cmp(e->r, true) ||
2448 201183 : (e->f && exp_has_func_or_cmp(e->f, true)));
2449 : }
2450 : case e_column:
2451 : case e_psm:
2452 : return 0;
2453 : }
2454 : return 0;
2455 : }
2456 :
2457 : int
2458 1477701 : exp_has_func(sql_exp *e)
2459 : {
2460 1477701 : return exp_has_func_or_cmp(e, false);
2461 : }
2462 :
2463 : static int
2464 727368 : exps_has_sideeffect( list *exps)
2465 : {
2466 727368 : node *n;
2467 727368 : int has_sideeffect = 0;
2468 :
2469 2230048 : for(n=exps->h; n && !has_sideeffect; n=n->next)
2470 1502681 : has_sideeffect |= exp_has_sideeffect(n->data);
2471 727367 : return has_sideeffect;
2472 : }
2473 :
2474 : int
2475 1688081 : exp_has_sideeffect( sql_exp *e )
2476 : {
2477 1712860 : switch (e->type) {
2478 24779 : case e_convert:
2479 24779 : return exp_has_sideeffect(e->l);
2480 727388 : case e_func:
2481 : {
2482 727388 : sql_subfunc *f = e->f;
2483 :
2484 727388 : if (f->func->side_effect)
2485 : return 1;
2486 727375 : if (e->l)
2487 727368 : return exps_has_sideeffect(e->l);
2488 : return 0;
2489 : }
2490 473811 : case e_atom:
2491 473811 : if (e->f)
2492 0 : return exps_has_sideeffect(e->f);
2493 : return 0;
2494 : case e_aggr:
2495 : case e_cmp:
2496 : case e_column:
2497 : case e_psm:
2498 : return 0;
2499 : }
2500 : return 0;
2501 : }
2502 :
2503 : int
2504 782396 : exps_have_unsafe(list *exps, int allow_identity)
2505 : {
2506 782396 : int unsafe = 0;
2507 :
2508 782396 : if (list_empty(exps))
2509 : return 0;
2510 2695166 : for (node *n = exps->h; n && !unsafe; n = n->next)
2511 1919140 : unsafe |= exp_unsafe(n->data, allow_identity);
2512 : return unsafe;
2513 : }
2514 :
2515 : int
2516 6510817 : exp_unsafe(sql_exp *e, int allow_identity)
2517 : {
2518 6784168 : switch (e->type) {
2519 273351 : case e_convert:
2520 273351 : return exp_unsafe(e->l, allow_identity);
2521 846951 : case e_aggr:
2522 : case e_func: {
2523 846951 : sql_subfunc *f = e->f;
2524 :
2525 846951 : if (IS_ANALYTIC(f->func) || !LANG_INT_OR_MAL(f->func->lang) || f->func->side_effect || (!allow_identity && is_identity(e, NULL)))
2526 114794 : return 1;
2527 732157 : return exps_have_unsafe(e->l, allow_identity);
2528 518 : } break;
2529 518 : case e_cmp: {
2530 518 : if (e->flag == cmp_in || e->flag == cmp_notin) {
2531 0 : return exp_unsafe(e->l, allow_identity) || exps_have_unsafe(e->r, allow_identity);
2532 518 : } else if (e->flag == cmp_or || e->flag == cmp_filter) {
2533 216 : return exps_have_unsafe(e->l, allow_identity) || exps_have_unsafe(e->r, allow_identity);
2534 : } else {
2535 604 : return exp_unsafe(e->l, allow_identity) || exp_unsafe(e->r, allow_identity) || (e->f && exp_unsafe(e->f, allow_identity));
2536 : }
2537 597795 : } break;
2538 597795 : case e_atom: {
2539 597795 : if (e->f)
2540 0 : return exps_have_unsafe(e->f, allow_identity);
2541 : return 0;
2542 : } break;
2543 : case e_column:
2544 : case e_psm:
2545 : return 0;
2546 : }
2547 : return 0;
2548 : }
2549 :
2550 : static inline int
2551 8765826 : exp_key( sql_exp *e )
2552 : {
2553 8765826 : if (e->alias.name)
2554 8765494 : return hash_key(e->alias.name);
2555 : return 0;
2556 : }
2557 :
2558 : sql_exp *
2559 3053925 : exps_bind_column(list *exps, const char *cname, int *ambiguous, int *multiple, int no_tname)
2560 : {
2561 3053925 : sql_exp *res = NULL;
2562 :
2563 3053925 : if (exps && cname) {
2564 3053752 : node *en;
2565 :
2566 3053752 : if (exps) {
2567 3053752 : if (!exps->ht && list_length(exps) > HASH_MIN_SIZE) {
2568 124663 : exps->ht = hash_new(exps->sa, list_length(exps), (fkeyvalue)&exp_key);
2569 124663 : if (exps->ht == NULL)
2570 : return NULL;
2571 1183136 : for (en = exps->h; en; en = en->next ) {
2572 1058473 : sql_exp *e = en->data;
2573 1058473 : if (e->alias.name) {
2574 1058473 : int key = exp_key(e);
2575 :
2576 1058473 : if (hash_add(exps->ht, key, e) == NULL)
2577 : return NULL;
2578 : }
2579 : }
2580 : }
2581 3053752 : if (exps->ht) {
2582 2231985 : int key = hash_key(cname);
2583 2231985 : sql_hash_e *he = exps->ht->buckets[key&(exps->ht->size-1)];
2584 :
2585 5273208 : for (; he; he = he->chain) {
2586 3041227 : sql_exp *e = he->value;
2587 :
2588 3041227 : if (e->alias.name && strcmp(e->alias.name, cname) == 0 && (!no_tname || !e->alias.rname)) {
2589 1273591 : if (res && multiple)
2590 4 : *multiple = 1;
2591 1273591 : if (!res)
2592 1273591 : res = e;
2593 :
2594 1273591 : if (res && res != e && e->alias.rname && res->alias.rname && strcmp(e->alias.rname, res->alias.rname) != 0 ) {
2595 4 : if (ambiguous)
2596 4 : *ambiguous = 1;
2597 4 : return NULL;
2598 : }
2599 : res = e;
2600 : }
2601 : }
2602 2231981 : return res;
2603 : }
2604 : }
2605 2772479 : for (en = exps->h; en; en = en->next ) {
2606 1950717 : sql_exp *e = en->data;
2607 :
2608 1950717 : if (e->alias.name && strcmp(e->alias.name, cname) == 0 && (!no_tname || !e->alias.rname)) {
2609 75587 : if (res && multiple)
2610 8 : *multiple = 1;
2611 75587 : if (!res)
2612 75587 : res = e;
2613 :
2614 75587 : if (res && res != e && e->alias.rname && res->alias.rname && strcmp(e->alias.rname, res->alias.rname) != 0 ) {
2615 5 : if (ambiguous)
2616 5 : *ambiguous = 1;
2617 5 : return NULL;
2618 : }
2619 : res = e;
2620 : }
2621 : }
2622 : }
2623 : return res;
2624 : }
2625 :
2626 : sql_exp *
2627 56481665 : exps_bind_column2(list *exps, const char *rname, const char *cname, int *multiple)
2628 : {
2629 56481665 : sql_exp *res = NULL;
2630 :
2631 56481665 : if (exps) {
2632 56411873 : node *en;
2633 :
2634 56411873 : if (!exps->ht && list_length(exps) > HASH_MIN_SIZE) {
2635 476391 : exps->ht = hash_new(exps->sa, list_length(exps), (fkeyvalue)&exp_key);
2636 476392 : if (exps->ht == NULL)
2637 : return res;
2638 :
2639 6633745 : for (en = exps->h; en; en = en->next ) {
2640 6157349 : sql_exp *e = en->data;
2641 6157349 : if (e->alias.name) {
2642 6146321 : int key = exp_key(e);
2643 :
2644 6146352 : if (hash_add(exps->ht, key, e) == NULL)
2645 : return res;
2646 : }
2647 : }
2648 : }
2649 56412239 : if (exps->ht) {
2650 22164931 : int key = hash_key(cname);
2651 22164931 : sql_hash_e *he = exps->ht->buckets[key&(exps->ht->size-1)];
2652 :
2653 56255082 : for (; he; he = he->chain) {
2654 34743246 : sql_exp *e = he->value;
2655 :
2656 34743246 : if (e && e->alias.name && e->alias.rname && strcmp(e->alias.name, cname) == 0 && strcmp(e->alias.rname, rname) == 0) {
2657 14473344 : if (res && multiple)
2658 0 : *multiple = 1;
2659 14473344 : if (!res)
2660 : res = e;
2661 14473344 : if (res && res->alias.label) /* aliases maybe used multiple times without problems */
2662 653095 : return res;
2663 : }
2664 : }
2665 21511836 : return res;
2666 : }
2667 145710686 : for (en = exps->h; en; en = en->next ) {
2668 112775986 : sql_exp *e = en->data;
2669 :
2670 112775986 : if (e && e->alias.name && e->alias.rname && strcmp(e->alias.name, cname) == 0 && strcmp(e->alias.rname, rname) == 0) {
2671 7649123 : if (res && multiple)
2672 2 : *multiple = 1;
2673 7649123 : if (!res)
2674 : res = e;
2675 7649123 : if (res && res->alias.label) /* aliases maybe used multiple times without problems */
2676 1312608 : return res;
2677 : }
2678 : }
2679 : }
2680 : return res;
2681 : }
2682 :
2683 : /* find an column based on the original name, not the alias it got */
2684 : sql_exp *
2685 332 : exps_bind_alias( list *exps, const char *rname, const char *cname )
2686 : {
2687 332 : if (exps) {
2688 332 : node *en;
2689 :
2690 759 : for (en = exps->h; en; en = en->next ) {
2691 431 : sql_exp *e = en->data;
2692 :
2693 431 : if (e && is_column(e->type) && !rname && e->r && strcmp(e->r, cname) == 0)
2694 0 : return e;
2695 431 : if (e && e->type == e_column && rname && e->l && e->r && strcmp(e->r, cname) == 0 && strcmp(e->l, rname) == 0) {
2696 4 : return e;
2697 : }
2698 : }
2699 : }
2700 : return NULL;
2701 : }
2702 :
2703 : unsigned int
2704 3141929 : exps_card( list *l )
2705 : {
2706 3141929 : node *n;
2707 3141929 : unsigned int card = CARD_ATOM;
2708 :
2709 13916774 : if (l) for(n = l->h; n; n = n->next) {
2710 10774845 : sql_exp *e = n->data;
2711 :
2712 10774845 : if (e && card < e->card)
2713 10774845 : card = e->card;
2714 : }
2715 3141929 : return card;
2716 : }
2717 :
2718 : void
2719 38930 : exps_fix_card( list *exps, unsigned int card)
2720 : {
2721 38930 : if (exps)
2722 969892 : for (node *n = exps->h; n; n = n->next) {
2723 930962 : sql_exp *e = n->data;
2724 :
2725 930962 : if (e && e->card > card)
2726 0 : e->card = card;
2727 : }
2728 38930 : }
2729 :
2730 : void
2731 3991 : exps_setcard( list *exps, unsigned int card)
2732 : {
2733 3991 : if (exps)
2734 23488 : for (node *n = exps->h; n; n = n->next) {
2735 19497 : sql_exp *e = n->data;
2736 :
2737 19497 : if (e && e->card != CARD_ATOM)
2738 19469 : e->card = card;
2739 : }
2740 3991 : }
2741 :
2742 : int
2743 0 : exps_intern(list *exps)
2744 : {
2745 0 : if (exps)
2746 0 : for (node *n=exps->h; n; n = n->next) {
2747 0 : sql_exp *e = n->data;
2748 :
2749 0 : if (is_intern(e))
2750 : return 1;
2751 : }
2752 : return 0;
2753 : }
2754 :
2755 : sql_exp *
2756 3671 : exps_find_one_multi_exp(list *exps)
2757 : {
2758 3671 : sql_exp *l = NULL;
2759 3671 : int skip = 0;
2760 :
2761 : /* Find one and only 1 expression with card > CARD_ATOM */
2762 3671 : if (!list_empty(exps)) {
2763 7521 : for (node *m = exps->h ; m && !skip ; m = m->next) {
2764 3850 : sql_exp *e = m->data;
2765 :
2766 3850 : if (e->card > CARD_ATOM) {
2767 3638 : skip |= l != NULL;
2768 3638 : l = e;
2769 : }
2770 : }
2771 : }
2772 3671 : if (skip)
2773 4 : l = NULL;
2774 3671 : return l;
2775 : }
2776 :
2777 : const char *
2778 127058 : compare_func( comp_type t, int anti )
2779 : {
2780 127058 : switch(t) {
2781 73253 : case cmp_equal:
2782 73253 : return anti?"<>":"=";
2783 7979 : case cmp_lt:
2784 7979 : return anti?">":"<";
2785 2093 : case cmp_lte:
2786 2093 : return anti?">=":"<=";
2787 1130 : case cmp_gte:
2788 1130 : return anti?"<=":">=";
2789 30632 : case cmp_gt:
2790 30632 : return anti?"<":">";
2791 11971 : case cmp_notequal:
2792 11971 : return anti?"=":"<>";
2793 : default:
2794 : return NULL;
2795 : }
2796 : }
2797 :
2798 : int
2799 9524221 : is_identity( sql_exp *e, sql_rel *r)
2800 : {
2801 9533688 : switch(e->type) {
2802 33299 : case e_column:
2803 33299 : if (r && is_project(r->op)) {
2804 11989 : sql_exp *re = NULL;
2805 11989 : if (e->l)
2806 11928 : re = exps_bind_column2(r->exps, e->l, e->r, NULL);
2807 11989 : if (!re && has_label(e))
2808 263 : re = exps_bind_column(r->exps, e->r, NULL, NULL, 1);
2809 2522 : if (re)
2810 9467 : return is_identity(re, r->l);
2811 : }
2812 : return 0;
2813 9494944 : case e_func: {
2814 9494944 : sql_subfunc *f = e->f;
2815 9494944 : return !f->func->s && strcmp(f->func->base.name, "identity") == 0;
2816 : }
2817 : default:
2818 : return 0;
2819 : }
2820 : }
2821 :
2822 : list *
2823 90 : exps_alias(mvc *sql, list *exps)
2824 : {
2825 90 : list *nl = new_exp_list(sql->sa);
2826 :
2827 90 : if (exps)
2828 458 : for (node *n = exps->h; n; n = n->next) {
2829 368 : sql_exp *e = n->data, *ne;
2830 :
2831 368 : assert(exp_name(e));
2832 368 : ne = exp_ref(sql, e);
2833 368 : append(nl, ne);
2834 : }
2835 90 : return nl;
2836 : }
2837 :
2838 : list *
2839 56919 : exps_copy(mvc *sql, list *exps)
2840 : {
2841 56919 : list *nl;
2842 :
2843 56919 : if (mvc_highwater(sql))
2844 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
2845 :
2846 56919 : if (!exps)
2847 : return NULL;
2848 51146 : nl = new_exp_list(sql->sa);
2849 133644 : for (node *n = exps->h; n; n = n->next) {
2850 82498 : sql_exp *arg = n->data;
2851 :
2852 82498 : arg = exp_copy(sql, arg);
2853 82498 : if (!arg)
2854 : return NULL;
2855 82498 : append(nl, arg);
2856 : }
2857 : return nl;
2858 : }
2859 :
2860 : sql_exp *
2861 264143 : exp_copy(mvc *sql, sql_exp * e)
2862 : {
2863 264143 : sql_exp *l, *r, *r2, *ne = NULL;
2864 :
2865 264143 : if (mvc_highwater(sql))
2866 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
2867 :
2868 264143 : if (!e)
2869 : return NULL;
2870 264143 : switch(e->type){
2871 97653 : case e_column:
2872 97653 : ne = exp_column(sql->sa, e->l, e->r, exp_subtype(e), e->card, has_nil(e), is_unique(e), is_intern(e));
2873 97653 : ne->flag = e->flag;
2874 97653 : break;
2875 30268 : case e_cmp:
2876 30268 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2877 3299 : list *l = exps_copy(sql, e->l);
2878 3299 : list *r = exps_copy(sql, e->r);
2879 :
2880 3299 : if (e->flag == cmp_filter)
2881 605 : ne = exp_filter(sql->sa, l, r, e->f, is_anti(e));
2882 : else
2883 2694 : ne = exp_or(sql->sa, l, r, is_anti(e));
2884 26969 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2885 1104 : sql_exp *l = exp_copy(sql, e->l);
2886 1104 : list *r = exps_copy(sql, e->r);
2887 :
2888 1104 : ne = exp_in(sql->sa, l, r, e->flag);
2889 : } else {
2890 25865 : l = exp_copy(sql, e->l);
2891 25865 : r = exp_copy(sql, e->r);
2892 :
2893 25865 : if (e->f) {
2894 632 : r2 = exp_copy(sql, e->f);
2895 632 : ne = exp_compare2(sql->sa, l, r, r2, e->flag, is_symmetric(e));
2896 : } else {
2897 25233 : ne = exp_compare(sql->sa, l, r, e->flag);
2898 : }
2899 : }
2900 : break;
2901 3404 : case e_convert:
2902 3404 : ne = exp_convert(sql->sa, exp_copy(sql, e->l), exp_fromtype(e), exp_totype(e));
2903 3404 : break;
2904 9451 : case e_aggr:
2905 : case e_func: {
2906 9451 : list *l = exps_copy(sql, e->l);
2907 :
2908 9451 : if (e->type == e_func)
2909 7948 : ne = exp_op(sql->sa, l, e->f);
2910 : else
2911 1503 : ne = exp_aggr(sql->sa, l, e->f, need_distinct(e), need_no_nil(e), e->card, has_nil(e));
2912 9451 : if (e->r) { /* copy obe and gbe lists */
2913 1 : list *er = (list*) e->r;
2914 1 : assert(list_length(er) <= 2);
2915 1 : if (list_length(er) == 2)
2916 0 : ne->r = list_append(list_append(sa_list(sql->sa), exps_copy(sql, er->h->data)), exps_copy(sql, er->h->next->data));
2917 : else
2918 1 : ne->r = list_append(sa_list(sql->sa), exps_copy(sql, er->h->data));
2919 : }
2920 : break;
2921 : }
2922 123363 : case e_atom:
2923 123363 : if (e->l)
2924 119701 : ne = exp_atom(sql->sa, e->l);
2925 3662 : else if (e->r) {
2926 3605 : sql_var_name *vname = (sql_var_name*) e->r;
2927 3605 : ne = exp_param_or_declared(sql->sa, vname->sname, vname->name, &e->tpe, e->flag);
2928 57 : } else if (e->f)
2929 3 : ne = exp_values(sql->sa, exps_copy(sql, e->f));
2930 : else
2931 54 : ne = exp_atom_ref(sql->sa, e->flag, &e->tpe);
2932 : break;
2933 4 : case e_psm:
2934 4 : if (e->flag & PSM_SET) {
2935 0 : ne = exp_set(sql->sa, e->alias.rname, e->alias.name, exp_copy(sql, e->l), GET_PSM_LEVEL(e->flag));
2936 4 : } else if (e->flag & PSM_VAR) {
2937 0 : if (e->f)
2938 0 : ne = exp_table(sql->sa, e->alias.name, e->f, GET_PSM_LEVEL(e->flag));
2939 : else
2940 0 : ne = exp_var(sql->sa, e->alias.rname, e->alias.name, &e->tpe, GET_PSM_LEVEL(e->flag));
2941 4 : } else if (e->flag & PSM_RETURN) {
2942 0 : ne = exp_return(sql->sa, exp_copy(sql, e->l), GET_PSM_LEVEL(e->flag));
2943 4 : } else if (e->flag & PSM_WHILE) {
2944 0 : ne = exp_while(sql->sa, exp_copy(sql, e->l), exps_copy(sql, e->r));
2945 4 : } else if (e->flag & PSM_IF) {
2946 0 : ne = exp_if(sql->sa, exp_copy(sql, e->l), exps_copy(sql, e->r), exps_copy(sql, e->f));
2947 4 : } else if (e->flag & PSM_REL) {
2948 4 : return exp_ref(sql, e);
2949 0 : } else if (e->flag & PSM_EXCEPTION) {
2950 0 : ne = exp_exception(sql->sa, exp_copy(sql, e->l), (const char *) e->r);
2951 : }
2952 : break;
2953 : }
2954 264139 : if (!ne)
2955 0 : return ne;
2956 264139 : if (e->alias.name)
2957 136756 : exp_prop_alias(sql->sa, ne, e);
2958 264139 : ne = exp_propagate(sql->sa, ne, e);
2959 264139 : if (is_freevar(e))
2960 8142 : set_freevar(ne, is_freevar(e)-1);
2961 : return ne;
2962 : }
2963 :
2964 : /* scaling for the division operator */
2965 : static sql_exp *
2966 2558 : exp_scale_algebra(mvc *sql, sql_subfunc *f, sql_rel *rel, sql_exp *l, sql_exp *r)
2967 : {
2968 2558 : sql_subtype *lt = exp_subtype(l);
2969 2558 : sql_subtype *rt = exp_subtype(r);
2970 :
2971 2558 : if (lt->type->scale == SCALE_FIX && (lt->scale || rt->scale) &&
2972 340 : strcmp(sql_func_imp(f->func), "/") == 0) {
2973 171 : sql_subtype *res = f->res->h->data;
2974 171 : unsigned int scale, digits, digL, scaleL;
2975 171 : sql_subtype nlt;
2976 :
2977 : /* scale fixing may require a larger type ! */
2978 : /* TODO make '3' setable by user (division_minimal_scale or so) */
2979 171 : scaleL = (lt->scale < 3) ? 3 : lt->scale;
2980 171 : scaleL += (scaleL < rt->scale)?(rt->scale - scaleL):0;
2981 171 : scale = scaleL;
2982 171 : scaleL += rt->scale;
2983 171 : digL = lt->digits + (scaleL - lt->scale);
2984 171 : digits = (digL > rt->digits) ? digL : rt->digits;
2985 :
2986 : /* HACK alert: digits should be less than max */
2987 : #ifdef HAVE_HGE
2988 171 : if (res->type->radix == 10 && digits > 38)
2989 171 : digits = 38;
2990 171 : if (res->type->radix == 2 && digits > 127)
2991 171 : digits = 127;
2992 : #else
2993 : if (res->type->radix == 10 && digits > 18)
2994 : digits = 18;
2995 : if (res->type->radix == 2 && digits > 63)
2996 : digits = 63;
2997 : #endif
2998 :
2999 171 : sql_find_subtype(&nlt, lt->type->base.name, digL, scaleL);
3000 171 : if (nlt.digits < scaleL)
3001 2 : return sql_error(sql, 01, SQLSTATE(42000) "Scale (%d) overflows type", scaleL);
3002 169 : l = exp_check_type(sql, &nlt, rel, l, type_equal);
3003 :
3004 169 : sql_find_subtype(res, lt->type->base.name, digits, scale);
3005 2387 : } else if (lt->type->scale == SCALE_FIX) {
3006 2196 : sql_subtype *res = f->res->h->data;
3007 2196 : if (res->type->eclass == EC_NUM)
3008 2183 : res->digits = MAX(lt->digits, rt->digits);
3009 : }
3010 : return l;
3011 : }
3012 :
3013 : sql_exp *
3014 2558 : exps_scale_algebra(mvc *sql, sql_subfunc *f, sql_rel *rel, list *exps)
3015 : {
3016 2558 : if (list_length(exps) != 2)
3017 : return NULL;
3018 2558 : sql_exp *e = exp_scale_algebra(sql, f, rel, exps->h->data, exps->h->next->data);
3019 2558 : if (e)
3020 2556 : exps->h->data = e;
3021 : return e;
3022 : }
3023 :
3024 : void
3025 183089 : exps_digits_add(sql_subfunc *f, list *exps)
3026 : {
3027 : /* concat and friends need larger results */
3028 183089 : if (!f->func->res)
3029 : return;
3030 183089 : int digits = 0;
3031 326579 : for(node *n = exps->h; n; n = n->next) {
3032 267092 : sql_subtype *t = exp_subtype(n->data);
3033 :
3034 267092 : if (!t->digits) {
3035 : digits = 0;
3036 : break;
3037 : }
3038 143490 : digits += t->digits;
3039 : }
3040 183089 : sql_subtype *res = f->res->h->data;
3041 183089 : res->digits = digits;
3042 : }
3043 :
3044 : void
3045 24569 : exps_sum_scales(sql_subfunc *f, list *exps)
3046 : {
3047 : /* sum scales and digits for multiply operation */
3048 24569 : sql_arg *ares = f->func->res->h->data;
3049 :
3050 24569 : if (ares->type.type->scale == SCALE_FIX && strcmp(sql_func_imp(f->func), "*") == 0) {
3051 23581 : unsigned int digits = 0, scale = 0;
3052 23581 : sql_type *largesttype = ares->type.type;
3053 :
3054 70743 : for(node *n = exps->h; n; n = n->next) {
3055 47162 : sql_exp *e = n->data;
3056 47162 : sql_subtype *t = exp_subtype(e);
3057 :
3058 47162 : scale += t->scale;
3059 47162 : digits += t->digits;
3060 47162 : if (largesttype->localtype < t->type->localtype)
3061 0 : largesttype = t->type;
3062 : }
3063 23581 : sql_subtype *res = f->res->h->data;
3064 :
3065 23581 : res->scale = scale;
3066 23581 : res->digits = digits;
3067 :
3068 : /* HACK alert: digits should be less than max */
3069 : #ifdef HAVE_HGE
3070 23581 : if (ares->type.type->radix == 10 && res->digits > 38) {
3071 2414 : res->digits = 38;
3072 2414 : res->scale = MIN(res->scale, res->digits - 1);
3073 : }
3074 23581 : if (ares->type.type->radix == 2 && res->digits > 127) {
3075 24 : res->digits = 127;
3076 24 : res->scale = MIN(res->scale, res->digits - 1);
3077 : }
3078 : #else
3079 : if (ares->type.type->radix == 10 && res->digits > 18) {
3080 : res->digits = 18;
3081 : res->scale = MIN(res->scale, res->digits - 1);
3082 : }
3083 : if (ares->type.type->radix == 2 && res->digits > 63) {
3084 : res->digits = 63;
3085 : res->scale = MIN(res->scale, res->digits - 1);
3086 : }
3087 : #endif
3088 :
3089 23581 : sql_subtype t;
3090 : /* numeric types are fixed length */
3091 23581 : if (ares->type.type->eclass == EC_NUM) {
3092 : #ifdef HAVE_HGE
3093 20879 : if (ares->type.type->localtype == TYPE_hge && res->digits == 127)
3094 24 : t = *sql_bind_localtype("hge");
3095 : else
3096 : #endif
3097 20855 : if (ares->type.type->localtype == TYPE_lng && res->digits == 63)
3098 3 : t = *sql_bind_localtype("lng");
3099 20852 : else if (res->type->digits >= res->digits)
3100 8753 : t = *res; /* we cannot reduce types! */
3101 : else
3102 12099 : sql_find_numeric(&t, ares->type.type->localtype, res->digits);
3103 : } else {
3104 2702 : if (res->digits > largesttype->digits)
3105 216 : sql_find_subtype(&t, largesttype->base.name, res->digits, res->scale);
3106 : else
3107 2486 : sql_init_subtype(&t, largesttype, res->digits, res->scale);
3108 : }
3109 23581 : *res = t;
3110 : }
3111 24569 : }
3112 :
3113 : void
3114 110404 : exps_max_bits(sql_subfunc *f, list *exps)
3115 : {
3116 : /* + and - have max_bits + 1 */
3117 110404 : if (!f->func->res)
3118 : return;
3119 110404 : unsigned int digits = 0;
3120 331214 : for(node *n = exps->h; n; n = n->next) {
3121 220809 : sql_subtype *t = exp_subtype(n->data);
3122 :
3123 220810 : if (!t)
3124 0 : continue;
3125 220810 : if (digits < t->digits)
3126 220810 : digits = t->digits;
3127 : }
3128 : /* + and - (because of negative numbers) could need one extra bit (or digit) */
3129 110405 : digits += 1;
3130 110405 : sql_subtype *res = f->res->h->data;
3131 110405 : if (digits > res->type->digits)
3132 47060 : res = sql_find_numeric(res, res->type->localtype, digits);
3133 : else
3134 63345 : res->digits = digits;
3135 : }
3136 :
3137 : void
3138 18852 : exps_inout(sql_subfunc *f, list *exps)
3139 : {
3140 : /* output == first input */
3141 18852 : if (!f->func->res)
3142 : return;
3143 18852 : sql_subtype *res = f->res->h->data;
3144 18852 : bool is_decimal = (res->type->eclass == EC_DEC);
3145 18852 : unsigned int digits = 0, scale = 0;
3146 18852 : sql_type *largesttype = NULL;
3147 18852 : for(node *n = exps->h; n; n = n->next) {
3148 18852 : sql_subtype *t = exp_subtype(n->data);
3149 :
3150 18852 : if (!t)
3151 0 : continue;
3152 :
3153 18852 : if (is_decimal && t->type->eclass == EC_DEC && (!largesttype || largesttype->localtype < t->type->localtype))
3154 380 : largesttype = t->type;
3155 380 : if (is_decimal && t->type->eclass == EC_NUM) {
3156 0 : unsigned int d = bits2digits(t->digits);
3157 0 : digits = d>digits?d:digits;
3158 18852 : } else if (digits < t->digits)
3159 : digits = t->digits;
3160 18852 : if (scale < t->scale)
3161 : scale = t->scale;
3162 : break;
3163 : }
3164 18852 : if (digits > res->digits || scale > res->scale) {
3165 9088 : if (largesttype)
3166 366 : sql_init_subtype(res, largesttype, digits, scale);
3167 : else
3168 8722 : sql_find_subtype(res, res->type->base.name, digits, scale);
3169 : } else
3170 9764 : res->digits = digits;
3171 : }
3172 :
3173 : /* for aggregates we can reduce the result types size based on real digits/bits used number of known input rows */
3174 : void
3175 8982 : exps_largest_int(sql_subfunc *f, list *exps, lng cnt)
3176 : {
3177 8982 : if (!f->func->res || cnt == 0)
3178 : return;
3179 514 : sql_subtype *res = f->res->h->data;
3180 514 : if (res->type->eclass != EC_DEC && res->type->eclass != EC_NUM)
3181 : return;
3182 440 : bool is_decimal = (res->type->eclass == EC_DEC);
3183 440 : unsigned int digits = 0, scale = 0, mdigits = is_decimal ? decimal_digits(cnt) : number_bits(cnt);
3184 440 : sql_type *largesttype = NULL;
3185 440 : for(node *n = exps->h; n; n = n->next) {
3186 440 : sql_subtype *t = exp_subtype(n->data);
3187 :
3188 440 : if (!t)
3189 0 : continue;
3190 :
3191 440 : largesttype = t->type;
3192 440 : if (is_decimal && t->type->eclass == EC_NUM) {
3193 0 : unsigned int d = bits2digits(t->digits);
3194 0 : digits = d>digits?d:digits;
3195 440 : } else if (digits < t->digits)
3196 : digits = t->digits;
3197 440 : if (scale < t->scale)
3198 : scale = t->scale;
3199 : break;
3200 : }
3201 440 : digits += mdigits;
3202 440 : if (largesttype && digits <= largesttype->digits)
3203 379 : sql_init_subtype(res, largesttype, digits, scale);
3204 61 : else if (is_decimal)
3205 8 : sql_find_subtype(res, res->type->base.name, digits, scale);
3206 : else
3207 53 : sql_find_numeric(res, 1, digits);
3208 : }
3209 :
3210 : #define is_addition(fname) (strcmp(fname, "sql_add") == 0)
3211 : #define is_subtraction(fname) (strcmp(fname, "sql_sub") == 0)
3212 : void
3213 271105 : exps_scale_fix(sql_subfunc *f, list *exps, sql_subtype *atp)
3214 : {
3215 271105 : if (!f->func->res)
3216 : return;
3217 :
3218 271105 : sql_subtype *res = f->res->h->data;
3219 271105 : if (res->type->eclass != EC_ANY && res->type->eclass != EC_DEC)
3220 : return;
3221 :
3222 62155 : unsigned int digits = 0, scale = 0;
3223 62155 : sql_type *largesttype = NULL;
3224 241719 : for(node *n = exps->h; n; n = n->next) {
3225 179564 : sql_subtype *t = exp_subtype(n->data);
3226 :
3227 179564 : if (!t)
3228 0 : continue;
3229 179564 : if (digits < t->digits)
3230 : digits = t->digits;
3231 179564 : if (scale < t->scale)
3232 : scale = t->scale;
3233 179564 : if (t->type->eclass == EC_DEC && (!largesttype || largesttype->localtype < t->type->localtype))
3234 179564 : largesttype = t->type;
3235 : }
3236 62155 : res->scale = scale;
3237 62155 : if (res->type->eclass == EC_DEC)
3238 647 : digits += (is_addition(f->func->base.name) || is_subtraction(f->func->base.name));
3239 62155 : if (digits > res->type->digits) {
3240 61831 : if (largesttype && largesttype->localtype > res->type->localtype)
3241 80 : sql_init_subtype(res, largesttype, digits, scale);
3242 : else
3243 61751 : sql_find_subtype(res, res->type->localtype?res->type->base.name:atp->type->base.name, digits, scale);
3244 324 : } else if (res->type->eclass == EC_DEC || res->type->eclass == EC_NUM)
3245 253 : res->digits = digits;
3246 : }
3247 :
3248 : int
3249 129122 : exp_aggr_is_count(sql_exp *e)
3250 : {
3251 129122 : if (e->type == e_aggr && !((sql_subfunc *)e->f)->func->s && strcmp(((sql_subfunc *)e->f)->func->base.name, "count") == 0)
3252 37955 : return 1;
3253 : return 0;
3254 : }
3255 :
3256 : list *
3257 64801 : check_distinct_exp_names(mvc *sql, list *exps)
3258 : {
3259 64801 : list *distinct_exps = NULL;
3260 64801 : bool duplicates = false;
3261 :
3262 64801 : if (list_length(exps) < 2) {
3263 : return exps; /* always true */
3264 63228 : } else if (list_length(exps) < 5) {
3265 14167 : distinct_exps = list_distinct(exps, (fcmp) exp_equal, (fdup) NULL);
3266 : } else { /* for longer lists, use hashing */
3267 49061 : sql_hash *ht = hash_new(sql->ta, list_length(exps), (fkeyvalue)&exp_key);
3268 :
3269 479861 : for (node *n = exps->h; n && !duplicates; n = n->next) {
3270 430800 : sql_exp *e = n->data;
3271 430800 : int key = ht->key(e);
3272 430801 : sql_hash_e *he = ht->buckets[key&(ht->size-1)];
3273 :
3274 553826 : for (; he && !duplicates; he = he->chain) {
3275 123021 : sql_exp *f = he->value;
3276 :
3277 123021 : if (!exp_equal(e, f))
3278 1 : duplicates = true;
3279 : }
3280 430805 : hash_add(ht, key, e);
3281 : }
3282 : }
3283 63228 : if ((distinct_exps && list_length(distinct_exps) != list_length(exps)) || duplicates)
3284 4 : return NULL;
3285 : return exps;
3286 : }
3287 :
3288 : static int rel_find_parameter(mvc *sql, sql_subtype *type, sql_rel *rel, const char *relname, const char *expname);
3289 :
3290 : static int
3291 1633 : set_exp_type(mvc *sql, sql_subtype *type, sql_rel *rel, sql_exp *e)
3292 : {
3293 1639 : if (mvc_highwater(sql)) {
3294 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3295 0 : return -1;
3296 : }
3297 1639 : if (e->type == e_column) {
3298 60 : const char *nrname = (const char*) e->l, *nename = (const char*) e->r;
3299 : /* find all the column references and set the type */
3300 60 : e->tpe = *type;
3301 60 : return rel_find_parameter(sql, type, rel, nrname, nename);
3302 1579 : } else if (e->type == e_atom && e->f) {
3303 25 : list *atoms = e->f;
3304 25 : if (!list_empty(atoms))
3305 61 : for (node *n = atoms->h; n; n = n->next)
3306 36 : if (set_exp_type(sql, type, rel, n->data) < 0) /* set recursively */
3307 : return -1;
3308 25 : e->tpe = *type;
3309 25 : return 1; /* on a list of atoms, everything should be found */
3310 1554 : } else if (e->type == e_atom && !e->l && !e->r && !e->f) {
3311 1548 : e->tpe = *type;
3312 1548 : return set_type_param(sql, type, e->flag) == 0 ? 1 : 0;
3313 6 : } else if (exp_is_rel(e)) { /* for relation expressions, restart cycle */
3314 6 : rel = (sql_rel*) e->l;
3315 : /* limiting to these cases */
3316 6 : if (!is_project(rel->op) || list_length(rel->exps) != 1)
3317 0 : return 0;
3318 6 : sql_exp *re = rel->exps->h->data;
3319 :
3320 6 : e->tpe = *type;
3321 6 : return set_exp_type(sql, type, rel, re); /* set recursively */
3322 : }
3323 : return 0;
3324 : }
3325 :
3326 : int
3327 1541 : rel_set_type_param(mvc *sql, sql_subtype *type, sql_rel *rel, sql_exp *exp, int upcast)
3328 : {
3329 1541 : if (!type || !exp || (exp->type != e_atom && exp->type != e_column && !exp_is_rel(exp)))
3330 0 : return -1;
3331 :
3332 : /* use largest numeric types */
3333 1541 : if (upcast && type->type->eclass == EC_NUM)
3334 : #ifdef HAVE_HGE
3335 8 : type = sql_bind_localtype("hge");
3336 : #else
3337 : type = sql_bind_localtype("lng");
3338 : #endif
3339 6 : else if (upcast && type->type->eclass == EC_FLT)
3340 1 : type = sql_bind_localtype("dbl");
3341 :
3342 : /* TODO we could use the sql_query* struct to set paremeters used as freevars,
3343 : but it requires to change a lot of interfaces */
3344 : /* if (is_freevar(exp))
3345 : rel = query_fetch_outer(query, is_freevar(exp)-1); */
3346 1541 : return set_exp_type(sql, type, rel, exp);
3347 : }
3348 :
3349 : /* try to do an in-place conversion
3350 : *
3351 : * in-place conversion is only possible if the exp is a variable.
3352 : * This is only done to be able to map more cached queries onto the same
3353 : * interface.
3354 : */
3355 : sql_exp *
3356 4842599 : exp_convert_inplace(mvc *sql, sql_subtype *t, sql_exp *exp)
3357 : {
3358 4842599 : atom *a, *na;
3359 :
3360 : /* exclude named variables and variable lists */
3361 4842599 : if (exp->type != e_atom || exp->r /* named */ || exp->f /* list */ || !exp->l /* not direct atom */)
3362 : return NULL;
3363 :
3364 2714141 : a = exp->l;
3365 2714141 : if (!a->isnull && t->scale && t->type->eclass != EC_FLT)
3366 : return NULL;
3367 :
3368 2709000 : if ((na = atom_cast(sql->sa, a, t))) {
3369 2705951 : exp->l = na;
3370 2705951 : return exp;
3371 : }
3372 : return NULL;
3373 : }
3374 :
3375 : sql_exp *
3376 0 : exp_numeric_supertype(mvc *sql, sql_exp *e )
3377 : {
3378 0 : sql_subtype *tp = exp_subtype(e);
3379 :
3380 0 : if (tp->type->eclass == EC_DEC) {
3381 0 : sql_subtype *dtp = sql_bind_localtype("dbl");
3382 :
3383 0 : return exp_check_type(sql, dtp, NULL, e, type_cast);
3384 : }
3385 0 : if (tp->type->eclass == EC_NUM) {
3386 : #ifdef HAVE_HGE
3387 0 : sql_subtype *ltp = sql_bind_localtype("hge");
3388 : #else
3389 : sql_subtype *ltp = sql_bind_localtype("lng");
3390 : #endif
3391 :
3392 0 : return exp_check_type(sql, ltp, NULL, e, type_cast);
3393 : }
3394 : return e;
3395 : }
3396 :
3397 : sql_exp *
3398 4841759 : exp_check_type(mvc *sql, sql_subtype *t, sql_rel *rel, sql_exp *exp, check_type tpe)
3399 : {
3400 4841759 : int c, err = 0;
3401 4841759 : sql_exp* nexp = NULL;
3402 4841759 : sql_subtype *fromtype = exp_subtype(exp);
3403 :
3404 4842085 : if ((!fromtype || !fromtype->type) && rel_set_type_param(sql, t, rel, exp, 0) == 0)
3405 : return exp;
3406 :
3407 : /* first try cheap internal (in-place) conversions ! */
3408 4842084 : if ((nexp = exp_convert_inplace(sql, t, exp)) != NULL)
3409 : return nexp;
3410 :
3411 2136177 : if (fromtype && subtype_cmp(t, fromtype) != 0) {
3412 251255 : if (EC_INTERVAL(fromtype->type->eclass) && (t->type->eclass == EC_NUM || t->type->eclass == EC_POS) && t->digits < fromtype->digits) {
3413 : err = 1; /* conversion from interval to num depends on the number of digits */
3414 : } else {
3415 251255 : c = sql_type_convert(fromtype->type->eclass, t->type->eclass);
3416 251255 : if (!c || (c == 2 && tpe == type_set) || (c == 3 && tpe != type_cast)) {
3417 : err = 1;
3418 : } else {
3419 250741 : exp = exp_convert(sql->sa, exp, fromtype, t);
3420 : }
3421 : }
3422 : }
3423 250741 : if (err) {
3424 514 : const char *name = (exp->type == e_column && !has_label(exp)) ? exp_name(exp) : "%";
3425 576 : sql_exp *res = sql_error( sql, 03, SQLSTATE(42000) "types %s(%u,%u) and %s(%u,%u) are not equal%s%s%s",
3426 514 : fromtype->type->base.name,
3427 : fromtype->digits,
3428 : fromtype->scale,
3429 514 : t->type->base.name,
3430 : t->digits,
3431 : t->scale,
3432 : (name[0] != '%' ? " for column '" : ""),
3433 : (name[0] != '%' ? name : ""),
3434 514 : (name[0] != '%' ? "'" : "")
3435 : );
3436 514 : return res;
3437 : }
3438 : return exp;
3439 : }
3440 :
3441 : sql_exp *
3442 6624 : exp_values_set_supertype(mvc *sql, sql_exp *values, sql_subtype *opt_super)
3443 : {
3444 6624 : assert(is_values(values));
3445 6624 : list *vals = exp_get_values(values), *nexps;
3446 6624 : sql_subtype *tpe = opt_super?opt_super:exp_subtype(vals->h->data);
3447 :
3448 6624 : if (!opt_super && tpe)
3449 6525 : values->tpe = *tpe;
3450 :
3451 29325 : for (node *m = vals->h; m; m = m->next) {
3452 22701 : sql_exp *e = m->data;
3453 22701 : sql_subtype super, *ttpe;
3454 :
3455 : /* if the expression is a parameter set its type */
3456 22701 : if (tpe && e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
3457 4 : if (set_type_param(sql, tpe, e->flag) == 0)
3458 4 : e->tpe = *tpe;
3459 : else
3460 0 : return NULL;
3461 : }
3462 22701 : ttpe = exp_subtype(e);
3463 22701 : if (tpe && ttpe) {
3464 22649 : supertype(&super, ttpe, tpe);
3465 22649 : values->tpe = super;
3466 22649 : tpe = &values->tpe;
3467 : } else {
3468 : tpe = ttpe;
3469 : }
3470 : }
3471 :
3472 6624 : if (tpe) {
3473 : /* if the expression is a parameter set its type */
3474 29239 : for (node *m = vals->h; m; m = m->next) {
3475 22653 : sql_exp *e = m->data;
3476 22653 : if (e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
3477 1 : if (set_type_param(sql, tpe, e->flag) == 0)
3478 1 : e->tpe = *tpe;
3479 : else
3480 : return NULL;
3481 : }
3482 : }
3483 6586 : values->tpe = *tpe;
3484 6586 : nexps = sa_list(sql->sa);
3485 29234 : for (node *m = vals->h; m; m = m->next) {
3486 22651 : sql_exp *e = m->data;
3487 22651 : e = exp_check_type(sql, &values->tpe, NULL, e, type_equal);
3488 22651 : if (!e)
3489 : return NULL;
3490 22648 : exp_label(sql->sa, e, ++sql->label);
3491 22648 : append(nexps, e);
3492 : }
3493 6583 : values->f = nexps;
3494 : }
3495 : return values;
3496 : }
3497 :
3498 : /* return -1 on error, 0 not found, 1 found */
3499 : static int
3500 86 : rel_find_parameter(mvc *sql, sql_subtype *type, sql_rel *rel, const char *relname, const char *expname)
3501 : {
3502 138 : int res = 0;
3503 :
3504 138 : if (mvc_highwater(sql)) {
3505 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3506 0 : return -1;
3507 : }
3508 138 : if (!rel)
3509 : return 0;
3510 :
3511 135 : const char *nrname = relname, *nename = expname;
3512 135 : if (is_project(rel->op) && !list_empty(rel->exps)) {
3513 111 : sql_exp *e = NULL;
3514 :
3515 111 : if (nrname && nename) { /* find the column reference and propagate type setting */
3516 111 : e = exps_bind_column2(rel->exps, nrname, nename, NULL);
3517 0 : } else if (nename) {
3518 0 : e = exps_bind_column(rel->exps, nename, NULL, NULL, 1);
3519 : }
3520 111 : if (!e)
3521 3 : return 0; /* not found */
3522 108 : if (is_mset(rel->op)) { /* TODO for set relations this needs further improvement */
3523 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Cannot set parameter types under set relations at the moment");
3524 0 : return -1;
3525 : }
3526 : /* set order by column types */
3527 108 : if (is_simple_project(rel->op) && !list_empty(rel->r)) {
3528 0 : sql_exp *ordere = NULL;
3529 0 : if (nrname && nename) {
3530 0 : ordere = exps_bind_column2(rel->r, nrname, nename, NULL);
3531 0 : } else if (nename) {
3532 0 : ordere = exps_bind_column(rel->r, nename, NULL, NULL, 1);
3533 : }
3534 0 : if (ordere && ordere->type == e_column)
3535 0 : ordere->tpe = *type;
3536 : }
3537 108 : if (e->type == e_column) {
3538 52 : nrname = (const char*) e->l;
3539 52 : nename = (const char*) e->r;
3540 52 : e->tpe = *type;
3541 52 : res = 1; /* found */
3542 56 : } else if ((e->type == e_atom || exp_is_rel(e)) && (res = set_exp_type(sql, type, rel, e)) <= 0) {
3543 : return res; /* don't search further */
3544 : }
3545 : /* group by columns can have aliases! */
3546 108 : if (is_groupby(rel->op) && !list_empty(rel->r)) {
3547 0 : if (nrname && nename) {
3548 0 : e = exps_bind_column2(rel->r, nrname, nename, NULL);
3549 0 : } else if (nename) {
3550 0 : e = exps_bind_column(rel->r, nename, NULL, NULL, 1);
3551 : }
3552 0 : if (!e)
3553 : return res; /* don't search further */
3554 0 : if (e->type == e_column) {
3555 0 : nrname = (const char*) e->l;
3556 0 : nename = (const char*) e->r;
3557 0 : e->tpe = *type;
3558 0 : } else if ((e->type == e_atom || exp_is_rel(e)) && (res = set_exp_type(sql, type, rel, e)) <= 0) {
3559 : return res; /* don't search further */
3560 : }
3561 : }
3562 108 : if (e->type != e_column)
3563 : return res; /* don't search further */
3564 : }
3565 :
3566 76 : switch (rel->op) {
3567 14 : case op_join:
3568 : case op_left:
3569 : case op_right:
3570 : case op_full:
3571 14 : if (rel->l)
3572 14 : res = rel_find_parameter(sql, type, rel->l, nrname, nename);
3573 14 : if (rel->r && res <= 0) { /* try other relation if not found */
3574 12 : int err = sql->session->status, lres = res;
3575 12 : char buf[ERRSIZE];
3576 :
3577 12 : strcpy(buf, sql->errstr); /* keep error found and try other join relation */
3578 12 : sql->session->status = 0;
3579 12 : sql->errstr[0] = '\0';
3580 12 : res = rel_find_parameter(sql, type, rel->r, nrname, nename);
3581 12 : if (res == 0) { /* parameter wasn't found, set error */
3582 1 : res = lres;
3583 1 : sql->session->status = err;
3584 1 : strcpy(sql->errstr, buf);
3585 : }
3586 : }
3587 : break;
3588 52 : case op_semi:
3589 : case op_anti:
3590 : case op_groupby:
3591 : case op_project:
3592 : case op_select:
3593 : case op_topn:
3594 : case op_sample:
3595 52 : if (rel->l)
3596 : res = rel_find_parameter(sql, type, rel->l, nrname, nename);
3597 : break;
3598 0 : case op_union: /* TODO for set relations this needs further improvement */
3599 : case op_inter:
3600 : case op_except:
3601 : case op_munion: {
3602 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Cannot set parameter types under set relations at the moment");
3603 0 : return -1;
3604 : }
3605 : default: /* For table returning functions, the type must be set when the relation is created */
3606 : return 0;
3607 : }
3608 : return res;
3609 : }
3610 :
3611 : sql_exp *
3612 17599 : list_find_exp( list *exps, sql_exp *e)
3613 : {
3614 17599 : sql_exp *ne = NULL;
3615 :
3616 17599 : if (e->type != e_column)
3617 : return NULL;
3618 17559 : if (( e->l && (ne=exps_bind_column2(exps, e->l, e->r, NULL)) != NULL) ||
3619 17210 : ((!e->l && (ne=exps_bind_column(exps, e->r, NULL, NULL, 1)) != NULL)))
3620 365 : return ne;
3621 : return NULL;
3622 : }
|
