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