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 839890 : compare_str2type(const char *compare_op)
24 : {
25 839890 : comp_type type = cmp_filter;
26 :
27 839890 : if (compare_op[0] == '=') {
28 : type = cmp_equal;
29 162415 : } else if (compare_op[0] == '<') {
30 105341 : type = cmp_lt;
31 105341 : if (compare_op[1] == '>')
32 : type = cmp_notequal;
33 23522 : else if (compare_op[1] == '=')
34 4170 : type = cmp_lte;
35 57074 : } else if (compare_op[0] == '>') {
36 57074 : type = cmp_gt;
37 57074 : if (compare_op[1] == '=')
38 3348 : type = cmp_gte;
39 : }
40 839890 : return type;
41 : }
42 :
43 : comp_type
44 52660 : swap_compare( comp_type t )
45 : {
46 52660 : switch(t) {
47 : case cmp_equal:
48 : return cmp_equal;
49 : case cmp_lt:
50 : return cmp_gt;
51 : case cmp_lte:
52 : return cmp_gte;
53 : case cmp_gte:
54 : return cmp_lte;
55 : case cmp_gt:
56 : return cmp_lt;
57 : case cmp_notequal:
58 : return cmp_notequal;
59 : default:
60 : return cmp_equal;
61 : }
62 : }
63 :
64 : comp_type
65 7662 : negate_compare( comp_type t )
66 : {
67 7662 : switch(t) {
68 : case cmp_equal:
69 : return cmp_notequal;
70 29 : case cmp_notequal:
71 29 : return cmp_equal;
72 2 : case cmp_lt:
73 2 : return cmp_gte;
74 5 : case cmp_lte:
75 5 : return cmp_gt;
76 3 : case cmp_gte:
77 3 : return cmp_lt;
78 3 : case cmp_gt:
79 3 : return cmp_lte;
80 :
81 0 : case cmp_in:
82 0 : return cmp_notin;
83 0 : case cmp_notin:
84 0 : return cmp_in;
85 :
86 0 : default:
87 0 : return t;
88 : }
89 : }
90 :
91 : comp_type
92 3204 : range2lcompare( int r )
93 : {
94 3204 : if (r&1) {
95 : return cmp_gte;
96 : } else {
97 1216 : return cmp_gt;
98 : }
99 : }
100 :
101 : comp_type
102 3261 : range2rcompare( int r )
103 : {
104 3261 : if (r&2) {
105 : return cmp_lte;
106 : } else {
107 1253 : return cmp_lt;
108 : }
109 : }
110 :
111 : int
112 1913 : compare2range( int l, int r )
113 : {
114 1913 : if (l == cmp_gt) {
115 1790 : 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 21554663 : exp_create(allocator *sa, int type)
146 : {
147 21554663 : sql_exp *e = SA_NEW(sa, sql_exp);
148 :
149 21554992 : if (!e)
150 : return NULL;
151 21554992 : *e = (sql_exp) {
152 21554992 : .type = (expression_type) type,
153 : };
154 21554992 : return e;
155 : }
156 :
157 : sql_exp *
158 488193 : exp_compare(allocator *sa, sql_exp *l, sql_exp *r, int cmptype)
159 : {
160 488193 : sql_exp *e = exp_create(sa, e_cmp);
161 488193 : if (e == NULL)
162 : return NULL;
163 488193 : e->card = MAX(l->card,r->card);
164 488193 : e->l = l;
165 488193 : e->r = r;
166 488193 : e->flag = cmptype;
167 488193 : if (!has_nil(l) && !has_nil(r))
168 355776 : set_has_no_nil(e);
169 : return e;
170 : }
171 :
172 : sql_exp *
173 6692 : exp_compare2(allocator *sa, sql_exp *l, sql_exp *r, sql_exp *f, int cmptype, int symmetric)
174 : {
175 6692 : sql_exp *e = exp_create(sa, e_cmp);
176 6692 : if (e == NULL)
177 : return NULL;
178 6692 : assert(f);
179 6692 : e->card = MAX(MAX(l->card,r->card),f->card);
180 6692 : e->l = l;
181 6692 : e->r = r;
182 6692 : e->f = f;
183 6692 : e->flag = cmptype;
184 6692 : if (symmetric)
185 77 : set_symmetric(e);
186 6692 : if (!has_nil(l) && !has_nil(r) && !has_nil(f))
187 1617 : set_has_no_nil(e);
188 : return e;
189 : }
190 :
191 : sql_exp *
192 7560 : exp_filter(allocator *sa, list *l, list *r, sql_subfunc *f, int anti)
193 : {
194 7560 : sql_exp *e = exp_create(sa, e_cmp);
195 :
196 7560 : if (e == NULL)
197 : return NULL;
198 7560 : e->card = MAX(exps_card(l),exps_card(r));
199 7560 : if (!r) { /* split l */
200 1504 : list *nl = sa_list(sa), *nr = sa_list(sa);
201 1504 : node *n = l->h;
202 1504 : append(nl, n->data); /* sofar only first is left */
203 3824 : for(n = n->next; n; n = n->next)
204 2320 : append(nr, n->data);
205 : l = nl;
206 : r = nr;
207 : }
208 7560 : e->l = l;
209 7560 : e->r = r;
210 7560 : e->f = f;
211 7560 : e->flag = cmp_filter;
212 7560 : if (anti)
213 1097 : set_anti(e);
214 7560 : if (!have_nil(l) && !have_nil(r))
215 4878 : set_has_no_nil(e);
216 : return e;
217 : }
218 :
219 : sql_exp *
220 62753 : exp_or(allocator *sa, list *l, list *r, int anti)
221 : {
222 62753 : sql_exp *e = exp_create(sa, e_cmp);
223 :
224 62753 : if (e == NULL)
225 : return NULL;
226 62753 : e->card = MAX(exps_card(l),exps_card(r));
227 62753 : e->l = l;
228 62753 : e->r = r;
229 62753 : e->flag = cmp_or;
230 62753 : if (anti)
231 2 : set_anti(e);
232 62753 : if (!have_nil(l) && !have_nil(r))
233 43115 : set_has_no_nil(e);
234 : return e;
235 : }
236 :
237 : sql_exp *
238 30492 : exp_in(allocator *sa, sql_exp *l, list *r, int cmptype)
239 : {
240 30492 : sql_exp *e = exp_create(sa, e_cmp);
241 30492 : unsigned int exps_card = CARD_ATOM;
242 :
243 30492 : if (e == NULL)
244 : return NULL;
245 :
246 : /* ignore the cardinalites of sub-relations */
247 151161 : for (node *n = r->h; n ; n = n->next) {
248 120669 : sql_exp *next = n->data;
249 :
250 120669 : if (!exp_is_rel(next) && exps_card < next->card)
251 120669 : exps_card = next->card;
252 : }
253 30492 : e->card = MAX(l->card, exps_card);
254 30492 : e->l = l;
255 30492 : e->r = r;
256 30492 : assert( cmptype == cmp_in || cmptype == cmp_notin);
257 30492 : e->flag = cmptype;
258 30492 : if (!has_nil(l) && !have_nil(r))
259 23489 : set_has_no_nil(e);
260 : return e;
261 : }
262 :
263 : sql_exp *
264 35014 : exp_in_func(mvc *sql, sql_exp *le, sql_exp *vals, int anyequal, int is_tuple)
265 : {
266 35014 : sql_subfunc *a_func = NULL;
267 35014 : sql_exp *e = le;
268 :
269 35014 : if (is_tuple) {
270 4161 : list *l = exp_get_values(e);
271 4161 : e = l->h->data;
272 : }
273 40888 : 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 35014 : e = exp_binop(sql->sa, le, vals, a_func);
276 35014 : if (e) {
277 35014 : unsigned int exps_card = CARD_ATOM;
278 :
279 : /* ignore the cardinalites of sub-relations */
280 35014 : if (vals->type == e_atom && vals->f) {
281 163767 : for (node *n = ((list*)vals->f)->h ; n ; n = n->next) {
282 128753 : sql_exp *next = n->data;
283 :
284 128753 : if (!exp_is_rel(next) && exps_card < next->card)
285 128753 : exps_card = next->card;
286 : }
287 0 : } else if (!exp_is_rel(vals))
288 0 : exps_card = vals->card;
289 :
290 35014 : e->card = MAX(le->card, exps_card);
291 35014 : if (!has_nil(le) && !has_nil(vals))
292 0 : set_has_no_nil(e);
293 : }
294 : return e;
295 : }
296 :
297 : sql_exp *
298 5586 : exp_in_aggr(mvc *sql, sql_exp *le, sql_exp *vals, int anyequal, int is_tuple)
299 : {
300 5586 : sql_subfunc *a_func = NULL;
301 5586 : sql_exp *e = le;
302 :
303 5586 : if (is_tuple) {
304 0 : list *l = exp_get_values(e);
305 0 : e = l->h->data;
306 : }
307 5595 : 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 5586 : e = exp_aggr2(sql->sa, le, vals, a_func, need_distinct(e), need_no_nil(e), e->card, has_nil(e));
310 5586 : if (e) {
311 5586 : unsigned int exps_card = CARD_ATOM;
312 :
313 : /* ignore the cardinalites of sub-relations */
314 5586 : if (vals->type == e_atom && vals->f) {
315 31608 : for (node *n = ((list*)vals->f)->h ; n ; n = n->next) {
316 26022 : sql_exp *next = n->data;
317 :
318 26022 : if (!exp_is_rel(next) && exps_card < next->card)
319 26022 : exps_card = next->card;
320 : }
321 0 : } else if (!exp_is_rel(vals))
322 0 : exps_card = vals->card;
323 :
324 5586 : e->card = MAX(le->card, exps_card);
325 5586 : if (!has_nil(le) && !has_nil(vals))
326 0 : set_has_no_nil(e);
327 : }
328 : return e;
329 : }
330 :
331 : sql_exp *
332 123362 : exp_compare_func(mvc *sql, sql_exp *le, sql_exp *re, const char *compareop, int quantifier)
333 : {
334 123362 : sql_subfunc *cmp_func = sql_bind_func(sql, "sys", compareop, exp_subtype(le), exp_subtype(le), F_FUNC, true, true);
335 123362 : sql_exp *e = NULL;
336 :
337 123362 : if (cmp_func == NULL)
338 : return NULL;
339 :
340 123362 : e = exp_binop(sql->sa, le, re, cmp_func);
341 123362 : if (e) {
342 123362 : e->flag = quantifier;
343 : /* At ANY and ALL operators, the cardinality on the right side is ignored if it is a sub-relation */
344 123362 : e->card = quantifier && exp_is_rel(re) ? le->card : MAX(le->card, re->card);
345 123362 : if (!has_nil(le) && !has_nil(re))
346 78778 : set_has_no_nil(e);
347 : }
348 : return e;
349 : }
350 :
351 : static sql_subtype*
352 887794 : dup_subtype(allocator *sa, sql_subtype *st)
353 : {
354 887794 : sql_subtype *res = SA_NEW(sa, sql_subtype);
355 :
356 887794 : if (res == NULL)
357 : return NULL;
358 887794 : *res = *st;
359 887794 : return res;
360 : }
361 :
362 : sql_exp *
363 443897 : exp_convert(mvc *sql, sql_exp *exp, sql_subtype *fromtype, sql_subtype *totype )
364 : {
365 443897 : sql_exp *e = exp_create(sql->sa, e_convert);
366 443897 : if (e == NULL)
367 : return NULL;
368 443897 : e->card = exp->card;
369 443897 : e->l = exp;
370 443897 : totype = dup_subtype(sql->sa, totype);
371 443897 : e->r = append(append(sa_list(sql->sa), dup_subtype(sql->sa, fromtype)),totype);
372 443897 : e->tpe = *totype;
373 443897 : e->alias = exp->alias;
374 443897 : if (e->alias.label)
375 292364 : e->alias.label = -(sql->nid++);
376 443897 : if (!has_nil(exp))
377 174833 : set_has_no_nil(e);
378 : return e;
379 : }
380 :
381 : sql_exp *
382 1092495 : exp_op( allocator *sa, list *l, sql_subfunc *f )
383 : {
384 1092495 : if (f->func->type == F_FILT)
385 1504 : return exp_filter(sa, l, NULL, f, false);
386 1090991 : sql_exp *e = exp_create(sa, e_func);
387 1090991 : if (e == NULL)
388 : return NULL;
389 1090991 : e->card = exps_card(l);
390 1090992 : e->l = l;
391 1090992 : e->f = f;
392 1090992 : e->semantics = f->func->semantics;
393 1090992 : if (!is_semantics(e) && !is_any(e) && l && !have_nil(l))
394 259115 : set_has_no_nil(e);
395 : return e;
396 : }
397 :
398 : sql_exp *
399 12629 : exp_rank_op( allocator *sa, list *l, list *gbe, list *obe, sql_subfunc *f )
400 : {
401 12629 : sql_exp *e = exp_create(sa, e_func);
402 12629 : if (e == NULL)
403 : return NULL;
404 12629 : e->card = list_empty(l)?CARD_MULTI:exps_card(l);
405 12629 : e->l = l;
406 12629 : e->r = append(append(sa_list(sa), gbe), obe);
407 12629 : e->f = f;
408 12629 : if (!f->func->s && strcmp(f->func->base.name, "count") == 0)
409 180 : set_has_no_nil(e);
410 12629 : e->semantics = f->func->semantics;
411 12629 : return e;
412 : }
413 :
414 : sql_exp *
415 64945 : exp_aggr( allocator *sa, list *l, sql_subfunc *a, int distinct, int no_nils, unsigned int card, int has_nils )
416 : {
417 64945 : sql_exp *e = exp_create(sa, e_aggr);
418 64945 : if (e == NULL)
419 : return NULL;
420 64945 : e->card = card;
421 64945 : e->l = l;
422 64945 : e->f = a;
423 64945 : e->semantics = a->func->semantics;
424 64945 : if (distinct)
425 373 : set_distinct(e);
426 64945 : if (no_nils)
427 28437 : set_no_nil(e);
428 64945 : if ((!a->func->semantics && !has_nils) || (!a->func->s && strcmp(a->func->base.name, "count") == 0))
429 26510 : set_has_no_nil(e);
430 : return e;
431 : }
432 :
433 : sql_exp *
434 5063332 : exp_atom(allocator *sa, atom *a)
435 : {
436 5063332 : sql_exp *e = exp_create(sa, e_atom);
437 5062372 : if (e == NULL)
438 : return NULL;
439 5062372 : e->card = CARD_ATOM;
440 5062372 : e->tpe = a->tpe;
441 5062372 : e->l = a;
442 5062372 : if (!a->isnull)
443 4784468 : 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 149649 : exp_atom_bool(allocator *sa, int b)
468 : {
469 149649 : sql_subtype bt;
470 :
471 149649 : sql_find_subtype(&bt, "boolean", 0, 0);
472 149700 : if (b)
473 99510 : return exp_atom(sa, atom_bool(sa, &bt, TRUE ));
474 : else
475 50190 : 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 868527 : exp_atom_int(allocator *sa, int i)
498 : {
499 868527 : sql_subtype it;
500 :
501 868527 : sql_find_subtype(&it, "int", 9, 0);
502 868674 : return exp_atom(sa, atom_int(sa, &it, i ));
503 : }
504 :
505 : sql_exp *
506 16390 : exp_atom_lng(allocator *sa, lng i)
507 : {
508 16390 : sql_subtype it;
509 :
510 : #ifdef HAVE_HGE
511 16390 : sql_find_subtype(&it, "bigint", 18, 0);
512 : #else
513 : sql_find_subtype(&it, "bigint", 19, 0);
514 : #endif
515 16420 : return exp_atom(sa, atom_int(sa, &it, i ));
516 : }
517 :
518 : sql_exp *
519 4562 : exp_atom_oid(allocator *sa, oid i)
520 : {
521 4562 : sql_subtype it;
522 :
523 : #if SIZEOF_OID == SIZEOF_INT
524 : sql_find_subtype(&it, "oid", 31, 0);
525 : #else
526 4562 : sql_find_subtype(&it, "oid", 63, 0);
527 : #endif
528 4562 : 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 86140 : exp_atom_str(allocator *sa, const char *s, sql_subtype *st)
562 : {
563 167669 : return exp_atom(sa, atom_string(sa, st, s?sa_strdup(sa, s):NULL));
564 : }
565 :
566 : sql_exp *
567 754395 : exp_atom_clob(allocator *sa, const char *s)
568 : {
569 754395 : sql_subtype clob;
570 :
571 754395 : sql_find_subtype(&clob, "varchar", 0, 0);
572 1507192 : return exp_atom(sa, atom_string(sa, &clob, s?sa_strdup(sa, s):NULL));
573 : }
574 :
575 : sql_exp *
576 271597 : exp_atom_ptr(allocator *sa, void *s)
577 : {
578 271597 : sql_subtype *t = sql_bind_localtype("ptr");
579 271598 : return exp_atom(sa, atom_ptr(sa, t, s));
580 : }
581 :
582 : sql_exp *
583 2168 : exp_atom_ref(allocator *sa, int i, sql_subtype *tpe)
584 : {
585 2168 : sql_exp *e = exp_create(sa, e_atom);
586 2168 : if (e == NULL)
587 : return NULL;
588 2168 : e->card = CARD_ATOM;
589 2168 : e->flag = i;
590 2168 : if (tpe)
591 2168 : e->tpe = *tpe;
592 : return e;
593 : }
594 :
595 : sql_exp *
596 110684 : exp_null(allocator *sa, sql_subtype *tpe)
597 : {
598 110684 : atom *a = atom_general(sa, tpe, NULL, 0);
599 110684 : 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 125056 : exp_param_or_declared(allocator *sa, const char *sname, const char *name, sql_subtype *tpe, int frame)
630 : {
631 125056 : sql_var_name *vname;
632 125056 : sql_exp *e = exp_create(sa, e_atom);
633 125056 : if (e == NULL)
634 : return NULL;
635 :
636 125056 : e->r = sa_alloc(sa, sizeof(sql_var_name));
637 125056 : vname = (sql_var_name*) e->r;
638 125056 : vname->sname = sname;
639 125056 : vname->name = name;
640 125056 : e->card = CARD_ATOM;
641 125056 : e->flag = frame;
642 125056 : if (tpe)
643 125056 : e->tpe = *tpe;
644 : return e;
645 : }
646 :
647 : sql_exp *
648 214248 : exp_values(allocator *sa, list *exps)
649 : {
650 214248 : sql_exp *e = exp_create(sa, e_atom);
651 214269 : if (e == NULL)
652 : return NULL;
653 214269 : e->card = exps_card(exps);
654 214357 : e->f = exps;
655 214357 : return e;
656 : }
657 :
658 : list *
659 30239 : exp_get_values(sql_exp *e)
660 : {
661 30239 : if (is_atom(e->type) && e->f)
662 : return e->f;
663 : return NULL;
664 : }
665 :
666 : list *
667 38792 : exp_types(allocator *sa, list *exps)
668 : {
669 38792 : list *l = sa_list(sa);
670 :
671 38792 : if (exps)
672 87711 : for (node *n = exps->h; n; n = n->next)
673 48919 : list_append(l, exp_subtype(n->data));
674 38792 : return l;
675 : }
676 :
677 : int
678 1061247 : have_nil(list *exps)
679 : {
680 1061247 : int has_nil = 0;
681 :
682 1061247 : if (exps)
683 2676164 : for (node *n = exps->h; n && !has_nil; n = n->next) {
684 1614917 : sql_exp *e = n->data;
685 1614917 : has_nil |= has_nil(e);
686 : }
687 1061247 : 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 7055587 : 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 7055587 : sql_exp *e = exp_create(sa, e_column);
707 :
708 7055652 : if (e == NULL)
709 : return NULL;
710 7055652 : assert(cname);
711 7055652 : e->card = card;
712 7055652 : e->alias.name = cname;
713 7055652 : e->alias.rname = rname;
714 7055652 : e->r = (char*)e->alias.name;
715 7055652 : e->l = (char*)e->alias.rname;
716 7055652 : if (t)
717 7055254 : e->tpe = *t;
718 7055652 : if (!has_nils)
719 1996189 : set_has_no_nil(e);
720 7055652 : if (unique)
721 942535 : set_unique(e);
722 7055652 : if (intern)
723 598183 : set_intern(e);
724 : return e;
725 : }
726 :
727 : sql_exp *
728 10054887 : exp_propagate(allocator *sa, sql_exp *ne, sql_exp *oe)
729 : {
730 10054887 : if (has_label(oe) &&
731 524537 : (oe->alias.rname == ne->alias.rname || (oe->alias.rname && ne->alias.rname && strcmp(oe->alias.rname, ne->alias.rname) == 0)) &&
732 517065 : (oe->alias.name == ne->alias.name || (oe->alias.name && ne->alias.name && strcmp(oe->alias.name, ne->alias.name) == 0)))
733 517065 : ne->alias.label = oe->alias.label;
734 10054887 : if (is_intern(oe))
735 310246 : set_intern(ne);
736 10054887 : if (is_anti(oe))
737 3182 : set_anti(ne);
738 10054887 : if (is_semantics(oe))
739 661344 : set_semantics(ne);
740 10054887 : if (is_any(oe))
741 44 : set_any(ne);
742 10054887 : if (is_symmetric(oe))
743 16 : set_symmetric(ne);
744 10054887 : if (is_partitioning(oe))
745 1516 : set_partitioning(ne);
746 10054887 : if (is_ascending(oe))
747 7867 : set_ascending(ne);
748 10054887 : if (nulls_last(oe))
749 1806 : set_nulls_last(ne);
750 10054887 : if (need_distinct(oe))
751 670 : set_distinct(ne);
752 10054887 : if (zero_if_empty(oe))
753 0 : set_zero_if_empty(ne);
754 10054887 : if (need_no_nil(oe))
755 103046 : set_no_nil(ne);
756 10054887 : if (!has_nil(oe))
757 5898771 : set_has_no_nil(ne);
758 10054887 : if (has_nil(oe))
759 4156115 : set_has_nil(ne);
760 10054887 : if (is_unique(oe))
761 1129461 : set_unique(ne);
762 10054887 : if (is_basecol(oe))
763 8292754 : set_basecol(ne);
764 10054887 : ne->p = prop_copy(sa, oe->p);
765 10054901 : return ne;
766 : }
767 :
768 : static sql_exp *
769 6743801 : exp_ref_by_label(allocator *sa, sql_exp *o)
770 : {
771 6743801 : sql_exp *e = exp_create(sa, e_column);
772 :
773 6743841 : if (e == NULL)
774 : return NULL;
775 6743841 : e->card = o->card;
776 6743841 : e->alias = o->alias;
777 6743841 : assert(e->alias.label);
778 6743841 : e->r = (char*)e->alias.name;
779 6743841 : e->l = (char*)e->alias.rname;
780 6743841 : e->nid = o->alias.label;
781 6743841 : assert(e->nid);
782 6743841 : sql_subtype *t = exp_subtype(o);
783 6743831 : if (t)
784 6743692 : e->tpe = *t;
785 6743831 : if (!has_nil(o))
786 4116020 : set_has_no_nil(e);
787 6743831 : if (has_nil(o))
788 2627820 : set_has_nil(e);
789 6743831 : if (is_unique(o))
790 891640 : set_unique(e);
791 6743831 : if (is_intern(o))
792 274660 : set_intern(e);
793 6743831 : return exp_propagate(sa, e, o);
794 : }
795 :
796 : sql_exp *
797 6743794 : exp_ref(mvc *sql, sql_exp *e)
798 : {
799 6743794 : if (!has_label(e) && !exp_name(e))
800 2275 : exp_label(sql->sa, e, ++sql->label);
801 6743802 : if (e->alias.label)
802 6743802 : return exp_ref_by_label(sql->sa, e);
803 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);
804 0 : if (ne) {
805 0 : ne->nid = e->alias.label;
806 0 : assert(ne->nid);
807 0 : assert(!ne->nid || ne->alias.name);
808 0 : ne->alias.label = ne->nid;
809 : }
810 : return ne;
811 : }
812 :
813 : sql_exp *
814 3896 : exp_ref_save(mvc *sql, sql_exp *e)
815 : {
816 3896 : if (e->type == e_column)
817 : return e;
818 2104 : if (is_atom(e->type))
819 1110 : return exp_copy(sql, e);
820 994 : if (!e->alias.label || !exp_name(e))
821 8 : exp_label(sql->sa, e, ++sql->label);
822 994 : if (e->type != e_column) /* ref as referenced within the (same) rank expression */
823 994 : e->ref = 1;
824 994 : sql_exp *ne = exp_ref(sql, e);
825 994 : if (ne && is_freevar(e))
826 0 : set_freevar(ne, is_freevar(e)-1);
827 : return ne;
828 : }
829 :
830 : sql_exp *
831 2202055 : 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)
832 : {
833 2202055 : sql_exp *e = exp_column(sql->sa, org_rname, org_cname, t, card, has_nils, unique, intern);
834 :
835 2202486 : if (e == NULL)
836 : return NULL;
837 2202486 : assert(acname && org_cname);
838 2202486 : exp_setname(sql, e, (arname)?arname:org_rname, acname);
839 2202486 : return e;
840 : }
841 :
842 : sql_exp *
843 2 : exp_alias_ref(mvc *sql, sql_exp *e)
844 : {
845 2 : const char *tname = exp_relname(e);
846 2 : const char *cname = exp_name(e);
847 :
848 2 : if (!has_label(e))
849 2 : exp_label(sql->sa, e, ++sql->label);
850 2 : sql_exp *ne = exp_ref(sql, e);
851 2 : if (ne == NULL)
852 : return NULL;
853 2 : exp_setname(sql, ne, tname, cname);
854 2 : return ne;
855 : }
856 :
857 : sql_exp *
858 16240 : exp_set(allocator *sa, const char *sname, const char *name, sql_exp *val, int level)
859 : {
860 16240 : sql_exp *e = exp_create(sa, e_psm);
861 :
862 16240 : if (e == NULL)
863 : return NULL;
864 16240 : e->alias.rname = sname;
865 16240 : e->alias.name = name;
866 16240 : e->l = val;
867 16240 : e->flag = PSM_SET + SET_PSM_LEVEL(level);
868 16240 : return e;
869 : }
870 :
871 : sql_exp *
872 9559 : exp_var(allocator *sa, const char *sname, const char *name, sql_subtype *type, int level)
873 : {
874 9559 : sql_exp *e = exp_create(sa, e_psm);
875 :
876 9559 : if (e == NULL)
877 : return NULL;
878 9559 : e->alias.rname = sname;
879 9559 : e->alias.name = name;
880 9559 : e->tpe = *type;
881 9559 : e->flag = PSM_VAR + SET_PSM_LEVEL(level);
882 9559 : return e;
883 : }
884 :
885 : sql_exp *
886 119 : exp_table(allocator *sa, const char *name, sql_table *t, int level)
887 : {
888 119 : sql_exp *e = exp_create(sa, e_psm);
889 :
890 119 : if (e == NULL)
891 : return NULL;
892 119 : e->alias.rname = NULL;
893 119 : e->alias.name = name;
894 119 : e->f = t;
895 119 : e->flag = PSM_VAR + SET_PSM_LEVEL(level);
896 119 : return e;
897 : }
898 :
899 : sql_exp *
900 24434 : exp_return(allocator *sa, sql_exp *val, int level)
901 : {
902 24434 : sql_exp *e = exp_create(sa, e_psm);
903 :
904 24434 : if (e == NULL)
905 : return NULL;
906 24434 : e->l = val;
907 24434 : e->flag = PSM_RETURN + SET_PSM_LEVEL(level);
908 24434 : return e;
909 : }
910 :
911 : sql_exp *
912 1023 : exp_while(allocator *sa, sql_exp *cond, list *stmts)
913 : {
914 1023 : sql_exp *e = exp_create(sa, e_psm);
915 :
916 1023 : if (e == NULL)
917 : return NULL;
918 1023 : e->l = cond;
919 1023 : e->r = stmts;
920 1023 : e->flag = PSM_WHILE;
921 1023 : return e;
922 : }
923 :
924 : sql_exp *
925 11741 : exp_if(allocator *sa, sql_exp *cond, list *if_stmts, list *else_stmts)
926 : {
927 11741 : sql_exp *e = exp_create(sa, e_psm);
928 :
929 11741 : if (e == NULL)
930 : return NULL;
931 11741 : e->l = cond;
932 11741 : e->r = if_stmts;
933 11741 : e->f = else_stmts;
934 11741 : e->flag = PSM_IF;
935 11741 : return e;
936 : }
937 :
938 : sql_exp *
939 81633 : exp_rel(mvc *sql, sql_rel *rel)
940 : {
941 81633 : sql_exp *e = exp_create(sql->sa, e_psm);
942 :
943 81633 : if (e == NULL)
944 : return NULL;
945 81633 : e->l = rel;
946 81633 : e->flag = PSM_REL;
947 81633 : e->card = is_single(rel)?CARD_ATOM:rel->card;
948 81633 : assert(rel);
949 81633 : if (is_topn(rel->op))
950 4 : rel = rel->l;
951 81633 : if (is_project(rel->op)) {
952 62583 : sql_exp *last = rel->exps->t->data;
953 62583 : sql_subtype *t = exp_subtype(last);
954 62583 : e->tpe = t ? *t : (sql_subtype) {0};
955 : }
956 : return e;
957 : }
958 :
959 : sql_exp *
960 157 : exp_exception(allocator *sa, sql_exp *cond, const char *error_message)
961 : {
962 157 : sql_exp *e = exp_create(sa, e_psm);
963 :
964 157 : if (e == NULL)
965 : return NULL;
966 157 : e->l = cond;
967 157 : e->r = sa_strdup(sa, error_message);
968 157 : e->flag = PSM_EXCEPTION;
969 157 : return e;
970 : }
971 :
972 : /* Set a name (alias) for the expression, such that we can refer
973 : to this expression by this simple name.
974 : */
975 : void
976 3739264 : exp_setname(mvc *sql, sql_exp *e, const char *rname, const char *name )
977 : {
978 3739264 : assert(name || rname);
979 3739264 : e->alias.label = -(sql->nid++);
980 : //e->alias.label = 0;
981 3739264 : if (name)
982 3595811 : e->alias.name = name;
983 3739264 : e->alias.rname = (rname);
984 3739264 : }
985 :
986 : void
987 143581 : noninternexp_setname(mvc *sql, sql_exp *e, const char *rname, const char *name )
988 : {
989 143581 : if (!is_intern(e))
990 143579 : exp_setname(sql, e, rname, name);
991 143581 : }
992 :
993 : void
994 667673 : exp_setalias(sql_exp *e, int label, const char *rname, const char *name )
995 : {
996 667673 : e->alias.label = label;
997 667673 : assert(e->alias.label);
998 667673 : e->alias.name = name;
999 667673 : e->alias.rname = rname;
1000 667673 : }
1001 :
1002 : void
1003 4469062 : exp_prop_alias(allocator *sa, sql_exp *e, sql_exp *oe )
1004 : {
1005 4469062 : e->ref = oe->ref;
1006 4469062 : if (oe->alias.name == NULL && exp_has_rel(oe)) {
1007 8107 : sql_rel *r = exp_rel_get_rel(sa, oe);
1008 8107 : if (!is_project(r->op))
1009 : return ;
1010 8107 : oe = r->exps->t->data;
1011 : }
1012 4469062 : e->alias = oe->alias;
1013 : }
1014 :
1015 : str
1016 2112817 : number2name(str s, int len, int i)
1017 : {
1018 2112817 : s[--len] = 0;
1019 6362588 : while(i>0) {
1020 4249771 : s[--len] = '0' + (i & 7);
1021 4249771 : i >>= 3;
1022 : }
1023 2112817 : s[--len] = '%';
1024 2112817 : return s + len;
1025 : }
1026 :
1027 : void
1028 0 : exp_setrelname(allocator *sa, sql_exp *e, int nr)
1029 : {
1030 0 : char name[16], *nme;
1031 :
1032 0 : nme = number2name(name, sizeof(name), nr);
1033 0 : e->alias.label = 0;
1034 0 : e->alias.rname = sa_strdup(sa, nme);
1035 0 : }
1036 :
1037 : char *
1038 2051755 : make_label(allocator *sa, int nr)
1039 : {
1040 2051755 : char name[16], *nme;
1041 :
1042 2051755 : nme = number2name(name, sizeof(name), nr);
1043 2052097 : return sa_strdup(sa, nme);
1044 : }
1045 :
1046 : sql_exp*
1047 2041976 : exp_label(allocator *sa, sql_exp *e, int nr)
1048 : {
1049 2041976 : assert(nr > 0);
1050 : //assert (e->alias.label == 0);
1051 2041976 : e->alias.label = nr;
1052 2041976 : e->alias.rname = e->alias.name = make_label(sa, nr);
1053 2043081 : return e;
1054 : }
1055 :
1056 : list*
1057 54837 : exps_label(mvc *sql, list *exps)
1058 : {
1059 54837 : if (!exps)
1060 : return NULL;
1061 :
1062 54837 : int nr = sql->label+1;
1063 54837 : sql->label += list_length(exps);
1064 125518 : for (node *n = exps->h; n; n = n->next)
1065 70681 : n->data = exp_label(sql->sa, n->data, nr++);
1066 54837 : list_hash_clear(exps);
1067 54837 : return exps;
1068 : }
1069 :
1070 : void
1071 21165 : exp_swap( sql_exp *e )
1072 : {
1073 21165 : sql_exp *s = e->l;
1074 :
1075 21165 : e->l = e->r;
1076 21165 : e->r = s;
1077 21165 : e->flag = swap_compare((comp_type)e->flag);
1078 21165 : assert(!e->f);
1079 21165 : }
1080 :
1081 : sql_subtype *
1082 34075750 : exp_subtype( sql_exp *e )
1083 : {
1084 34077690 : switch(e->type) {
1085 7938669 : case e_atom: {
1086 7938669 : if (e->l) {
1087 7236237 : atom *a = e->l;
1088 7236237 : return atom_type(a);
1089 702432 : } else if (e->tpe.type) { /* atom reference */
1090 698697 : return &e->tpe;
1091 3735 : } else if (e->f) {
1092 1940 : list *vals = exp_get_values(e);
1093 1940 : if (!list_empty(vals))
1094 1940 : return exp_subtype(vals->h->data);
1095 : }
1096 : break;
1097 : }
1098 21643930 : case e_convert:
1099 : case e_column:
1100 21643930 : if (e->tpe.type)
1101 21643797 : return &e->tpe;
1102 : break;
1103 4361928 : case e_aggr:
1104 : case e_func: {
1105 4361928 : if (e->f) {
1106 4361928 : sql_subfunc *f = e->f;
1107 4361928 : if (f->res && list_length(f->res) == 1)
1108 4351199 : return f->res->h->data;
1109 : }
1110 : return NULL;
1111 : }
1112 7254 : case e_cmp:
1113 7254 : return sql_bind_localtype("bit");
1114 125909 : case e_psm:
1115 125909 : if (e->tpe.type)
1116 125894 : return &e->tpe;
1117 : /* fall through */
1118 : default:
1119 : return NULL;
1120 : }
1121 : return NULL;
1122 : }
1123 :
1124 : const char *
1125 35329538 : exp_name( sql_exp *e )
1126 : {
1127 35343852 : if (e->alias.name)
1128 : return e->alias.name;
1129 1603636 : if (e->type == e_convert && e->l)
1130 : return exp_name(e->l);
1131 1599606 : if (e->type == e_psm && e->l) { /* subquery return name of last expression */
1132 10284 : sql_rel *r = e->l;
1133 10284 : if (is_project(r->op))
1134 10284 : return exp_name(r->exps->t->data);
1135 : }
1136 : return NULL;
1137 : }
1138 :
1139 : const char *
1140 3942622 : exp_relname( sql_exp *e )
1141 : {
1142 3942634 : if (e->alias.rname)
1143 : return e->alias.rname;
1144 476275 : if (!e->alias.name && e->type == e_convert && e->l)
1145 : return exp_relname(e->l);
1146 476263 : if (!e->alias.name && e->type == e_psm && e->l) { /* subquery return name of last expression */
1147 0 : sql_rel *r = e->l;
1148 0 : if (is_project(r->op))
1149 0 : return exp_relname(r->exps->t->data);
1150 : }
1151 : return NULL;
1152 : }
1153 :
1154 : const char *
1155 17339 : exp_find_rel_name(sql_exp *e)
1156 : {
1157 17339 : if (e->alias.rname)
1158 : return e->alias.rname;
1159 566 : switch(e->type) {
1160 : case e_column:
1161 : break;
1162 0 : case e_convert:
1163 0 : return exp_find_rel_name(e->l);
1164 : default:
1165 : return NULL;
1166 : }
1167 : return NULL;
1168 : }
1169 :
1170 : unsigned int
1171 1850103 : exp_card( sql_exp *e )
1172 : {
1173 1850103 : return e->card;
1174 : }
1175 :
1176 : unsigned int
1177 1632881 : exp_get_label( sql_exp *e )
1178 : {
1179 1632893 : if (e->alias.label)
1180 1632881 : return e->alias.label;
1181 12 : if (e->type == e_convert && e->l)
1182 : return exp_get_label(e->l);
1183 0 : if (e->type == e_psm && e->l) { /* subquery return name of last expression */
1184 0 : sql_rel *r = e->l;
1185 0 : if (is_project(r->op))
1186 0 : return exp_get_label(r->exps->t->data);
1187 : }
1188 : return 0;
1189 : }
1190 :
1191 :
1192 : const char *
1193 0 : exp_func_name( sql_exp *e )
1194 : {
1195 0 : if (e->type == e_func && e->f) {
1196 0 : sql_subfunc *f = e->f;
1197 0 : return f->func->base.name;
1198 : }
1199 0 : if (e->alias.name)
1200 : return e->alias.name;
1201 0 : if (e->type == e_convert && e->l)
1202 0 : return exp_name(e->l);
1203 : return NULL;
1204 : }
1205 :
1206 : int
1207 48995600 : exp_cmp( sql_exp *e1, sql_exp *e2)
1208 : {
1209 48995600 : return (e1 == e2)?0:-1;
1210 : }
1211 :
1212 : int
1213 247063 : exp_equal( sql_exp *e1, sql_exp *e2)
1214 : {
1215 247063 : if (e1 == e2)
1216 : return 0;
1217 247063 : if (e1->alias.label && e1->alias.label == e2->alias.label)
1218 8377 : return 0;
1219 : return -1;
1220 : }
1221 :
1222 : int
1223 48995451 : exp_match( sql_exp *e1, sql_exp *e2)
1224 : {
1225 48995451 : if (exp_cmp(e1, e2) == 0)
1226 : return 1;
1227 48754856 : if (e1->type == e2->type && e1->type == e_column) {
1228 23995774 : if (e1->nid && e1->nid == e2->nid)
1229 : return 1;
1230 22753341 : if (e1->alias.label != e2->alias.label || !e1->alias.label || !e2->alias.label)
1231 : return 0;
1232 : return 1;
1233 : }
1234 24759082 : if (e1->type == e2->type && e1->type == e_func) {
1235 8729015 : if (is_identity(e1, NULL) && is_identity(e2, NULL)) {
1236 0 : list *args1 = e1->l;
1237 0 : list *args2 = e2->l;
1238 :
1239 0 : if (list_length(args1) == list_length(args2) && list_length(args1) == 1) {
1240 0 : sql_exp *ne1 = args1->h->data;
1241 0 : sql_exp *ne2 = args2->h->data;
1242 :
1243 0 : if (exp_match(ne1,ne2))
1244 : return 1;
1245 : }
1246 : }
1247 : }
1248 : return 0;
1249 : }
1250 :
1251 : /* list already contains matching expression */
1252 : sql_exp*
1253 181618 : exps_find_exp( list *l, sql_exp *e)
1254 : {
1255 181618 : node *n;
1256 :
1257 181618 : if (!l || !l->h)
1258 : return NULL;
1259 :
1260 416723 : for(n=l->h; n; n = n->next) {
1261 366163 : if (exp_match(n->data, e) || exp_refers(n->data, e))
1262 112692 : return n->data;
1263 : }
1264 : return NULL;
1265 : }
1266 :
1267 : /* c refers to the parent p */
1268 : int
1269 3583526 : exp_refers( sql_exp *p, sql_exp *c)
1270 : {
1271 3583526 : if (c->type == e_column && c->nid)
1272 424605 : return c->nid == p->alias.label;
1273 : return 0;
1274 : }
1275 :
1276 : sql_exp*
1277 216 : exps_refers(sql_exp *p, list *l)
1278 : {
1279 216 : node *n;
1280 :
1281 216 : if (!l || !l->h)
1282 : return NULL;
1283 :
1284 528 : for(n=l->h; n; n = n->next) {
1285 316 : if (exp_refers(p, n->data))
1286 4 : return n->data;
1287 : }
1288 : return NULL;
1289 : }
1290 :
1291 : int
1292 0 : exp_match_col_exps( sql_exp *e, list *l)
1293 : {
1294 0 : node *n;
1295 :
1296 0 : for(n=l->h; n; n = n->next) {
1297 0 : sql_exp *re = n->data;
1298 0 : sql_exp *re_r = re->r;
1299 :
1300 0 : if (re->type == e_cmp && re->flag == cmp_or)
1301 0 : return exp_match_col_exps(e, re->l) &&
1302 0 : exp_match_col_exps(e, re->r);
1303 :
1304 0 : if (re->type != e_cmp || !re_r || re_r->card != 1 || !exp_match_exp(e, re->l))
1305 0 : return 0;
1306 : }
1307 : return 1;
1308 : }
1309 :
1310 : int
1311 10124 : exps_match_col_exps( sql_exp *e1, sql_exp *e2)
1312 : {
1313 10124 : sql_exp *e1_r = e1->r;
1314 10124 : sql_exp *e2_r = e2->r;
1315 :
1316 10124 : if (e1->type != e_cmp || e2->type != e_cmp)
1317 : return 0;
1318 :
1319 10053 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1320 4861 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1321 4047 : return exp_match_exp(e1->l, e2->l);
1322 :
1323 6006 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1324 814 : (e2->flag == cmp_in || e2->flag == cmp_notin))
1325 729 : return exp_match_exp(e1->l, e2->l);
1326 5277 : if ((e1->flag == cmp_in || e1->flag == cmp_notin) &&
1327 2771 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1328 1931 : return exp_match_exp(e1->l, e2->l);
1329 :
1330 3346 : if ((e1->flag == cmp_in || e1->flag == cmp_notin) &&
1331 840 : (e2->flag == cmp_in || e2->flag == cmp_notin))
1332 840 : return exp_match_exp(e1->l, e2->l);
1333 :
1334 2506 : if (!is_complex_exp(e1->flag) && e1_r && e1_r->card == CARD_ATOM &&
1335 85 : e2->flag == cmp_or)
1336 0 : return exp_match_col_exps(e1->l, e2->l) &&
1337 0 : exp_match_col_exps(e1->l, e2->r);
1338 :
1339 2506 : if (e1->flag == cmp_or &&
1340 0 : !is_complex_exp(e2->flag) && e2_r && e2_r->card == CARD_ATOM)
1341 0 : return exp_match_col_exps(e2->l, e1->l) &&
1342 0 : exp_match_col_exps(e2->l, e1->r);
1343 :
1344 2506 : if (e1->flag == cmp_or && e2->flag == cmp_or) {
1345 0 : list *l = e1->l, *r = e1->r;
1346 0 : sql_exp *el = l->h->data;
1347 0 : sql_exp *er = r->h->data;
1348 :
1349 0 : return list_length(l) == 1 && list_length(r) == 1 &&
1350 0 : exps_match_col_exps(el, e2) &&
1351 0 : exps_match_col_exps(er, e2);
1352 : }
1353 : return 0;
1354 : }
1355 :
1356 : int
1357 46818 : exp_match_list( list *l, list *r)
1358 : {
1359 46818 : node *n, *m;
1360 46818 : char *lu, *ru;
1361 46818 : int lc = 0, rc = 0, match = 0;
1362 :
1363 46818 : if (!l || !r)
1364 0 : return l == r;
1365 46818 : if (list_length(l) != list_length(r) || list_length(l) == 0 || list_length(r) == 0)
1366 460 : return 0;
1367 46358 : if (list_length(l) > 10 || list_length(r) > 10)
1368 5 : return 0;/* to expensive */
1369 :
1370 46353 : lu = ZNEW_ARRAY(char, list_length(l));
1371 46353 : ru = ZNEW_ARRAY(char, list_length(r));
1372 46353 : if (!lu || !ru) {
1373 0 : _DELETE(lu);
1374 0 : _DELETE(ru);
1375 0 : return 0;
1376 : }
1377 136569 : for (n = l->h, lc = 0; n; n = n->next, lc++) {
1378 90216 : sql_exp *le = n->data;
1379 :
1380 269124 : for ( m = r->h, rc = 0; m; m = m->next, rc++) {
1381 178908 : sql_exp *re = m->data;
1382 :
1383 178908 : if (!ru[rc] && exp_match_exp(le,re)) {
1384 6701 : lu[lc] = 1;
1385 6701 : ru[rc] = 1;
1386 6701 : match = 1;
1387 : }
1388 : }
1389 : }
1390 53497 : for (n = l->h, lc = 0; n && match; n = n->next, lc++)
1391 7144 : if (!lu[lc])
1392 1274 : match = 0;
1393 51749 : for (n = r->h, rc = 0; n && match; n = n->next, rc++)
1394 5396 : if (!ru[rc])
1395 0 : match = 0;
1396 46353 : _DELETE(lu);
1397 46353 : _DELETE(ru);
1398 46353 : return match;
1399 : }
1400 :
1401 : static int
1402 2426091 : exps_equal( list *l, list *r)
1403 : {
1404 2426091 : node *n, *m;
1405 :
1406 2426091 : if (!l || !r)
1407 51775 : return l == r;
1408 2374316 : if (list_length(l) != list_length(r))
1409 : return 0;
1410 3491092 : for (n = l->h, m = r->h; n && m; n = n->next, m = m->next) {
1411 3443271 : sql_exp *le = n->data, *re = m->data;
1412 :
1413 3443271 : if (!exp_match_exp(le,re))
1414 : return 0;
1415 : }
1416 : return 1;
1417 : }
1418 :
1419 : int
1420 45434808 : exp_match_exp_semantics( sql_exp *e1, sql_exp *e2, bool semantics)
1421 : {
1422 45434808 : if (exp_match(e1, e2))
1423 : return 1;
1424 :
1425 44202646 : if (is_ascending(e1) != is_ascending(e2) ||
1426 44202644 : nulls_last(e1) != nulls_last(e2) ||
1427 44202644 : zero_if_empty(e1) != zero_if_empty(e2) ||
1428 44013257 : need_no_nil(e1) != need_no_nil(e2) ||
1429 44013257 : is_anti(e1) != is_anti(e2) ||
1430 44009326 : (semantics && is_semantics(e1) != is_semantics(e2)) ||
1431 32829972 : (semantics && is_any(e1) != is_any(e2)) ||
1432 32830059 : is_symmetric(e1) != is_symmetric(e2) ||
1433 32830042 : is_unique(e1) != is_unique(e2) ||
1434 : need_distinct(e1) != need_distinct(e2))
1435 : return 0;
1436 :
1437 32251422 : if (e1->type == e2->type) {
1438 23949708 : switch(e1->type) {
1439 341985 : case e_cmp:
1440 571225 : if (e1->flag == e2->flag && !is_complex_exp(e1->flag) &&
1441 232377 : exp_match_exp(e1->l, e2->l) && exp_match_exp(e1->r, e2->r) &&
1442 284 : ((!e1->f && !e2->f) || (e1->f && e2->f && exp_match_exp(e1->f, e2->f))))
1443 277 : return 1;
1444 344453 : else if (e1->flag == e2->flag && e1->flag == cmp_or &&
1445 2757 : exp_match_list(e1->l, e2->l) && exp_match_list(e1->r, e2->r))
1446 : return 1;
1447 341702 : else if (e1->flag == e2->flag &&
1448 239043 : (e1->flag == cmp_in || e1->flag == cmp_notin) &&
1449 3625 : exp_match_exp(e1->l, e2->l) && exp_match_list(e1->r, e2->r))
1450 : return 1;
1451 567510 : else if (e1->flag == e2->flag && (e1->flag == cmp_equal || e1->flag == cmp_notequal) &&
1452 225848 : exp_match_exp(e1->l, e2->r) && exp_match_exp(e1->r, e2->l))
1453 : return 1; /* = and <> operations are reflective, so exp_match_exp can be called crossed */
1454 : break;
1455 296110 : case e_convert:
1456 357786 : if (!subtype_cmp(exp_totype(e1), exp_totype(e2)) &&
1457 92201 : !subtype_cmp(exp_fromtype(e1), exp_fromtype(e2)) &&
1458 30525 : exp_match_exp(e1->l, e2->l))
1459 : return 1;
1460 : break;
1461 58789 : case e_aggr:
1462 96607 : if (!subfunc_cmp(e1->f, e2->f) && /* equal aggregation*/
1463 37818 : exps_equal(e1->l, e2->l))
1464 : return 1;
1465 : break;
1466 4434632 : case e_func: {
1467 4434632 : sql_subfunc *e1f = (sql_subfunc*) e1->f;
1468 4434632 : const char *sname = e1f->func->s ? e1f->func->s->base.name : NULL;
1469 4434632 : int (*comp)(list*, list*) = is_commutative(sname, e1f->func->base.name) ? exp_match_list : exps_equal;
1470 :
1471 8869264 : if (!e1f->func->side_effect &&
1472 6816286 : !subfunc_cmp(e1f, e2->f) && /* equal functions */
1473 2431872 : comp(e1->l, e2->l) &&
1474 : /* optional order by expressions */
1475 50218 : exps_equal(e1->r, e2->r))
1476 : return 1;
1477 : } break;
1478 1074625 : case e_atom:
1479 1074625 : if (e1->l && e2->l && !atom_cmp(e1->l, e2->l))
1480 : return 1;
1481 1032793 : if (e1->f && e2->f && exps_equal(e1->f, e2->f))
1482 : return 1;
1483 1032792 : if (e1->r && e2->r && e1->flag == e2->flag && !subtype_cmp(&e1->tpe, &e2->tpe)) {
1484 54 : sql_var_name *v1 = (sql_var_name*) e1->r, *v2 = (sql_var_name*) e2->r;
1485 54 : if (((!v1->sname && !v2->sname) || (v1->sname && v2->sname && strcmp(v1->sname, v2->sname) == 0)) &&
1486 54 : ((!v1->name && !v2->name) || (v1->name && v2->name && strcmp(v1->name, v2->name) == 0)))
1487 : return 1;
1488 : }
1489 1032792 : if (!e1->l && !e1->r && !e1->f && !e2->l && !e2->r && !e2->f && e1->flag == e2->flag && !subtype_cmp(&e1->tpe, &e2->tpe))
1490 : return 1;
1491 : break;
1492 : default:
1493 : break;
1494 : }
1495 : }
1496 : return 0;
1497 : }
1498 :
1499 : int
1500 45140582 : exp_match_exp( sql_exp *e1, sql_exp *e2)
1501 : {
1502 45140582 : return exp_match_exp_semantics( e1, e2, true);
1503 : }
1504 :
1505 : sql_exp *
1506 162567 : exps_any_match(list *l, sql_exp *e)
1507 : {
1508 162567 : if (!l)
1509 : return NULL;
1510 616497 : for (node *n = l->h; n ; n = n->next) {
1511 559703 : sql_exp *ne = (sql_exp *) n->data;
1512 559703 : if (exp_match_exp(ne, e))
1513 105773 : return ne;
1514 : }
1515 : return NULL;
1516 : }
1517 :
1518 : static int
1519 24 : exps_are_joins( list *l )
1520 : {
1521 24 : if (l)
1522 52 : for (node *n = l->h; n; n = n->next) {
1523 28 : sql_exp *e = n->data;
1524 :
1525 28 : if (exp_is_join_exp(e))
1526 : return -1;
1527 : }
1528 : return 0;
1529 : }
1530 :
1531 : int
1532 254 : exp_is_join_exp(sql_exp *e)
1533 : {
1534 254 : if (exp_is_join(e, NULL) == 0)
1535 : return 0;
1536 27 : if (e->type == e_cmp && e->flag == cmp_or && e->card >= CARD_AGGR)
1537 12 : if (exps_are_joins(e->l) == 0 && exps_are_joins(e->r) == 0)
1538 : return 0;
1539 : return -1;
1540 : }
1541 :
1542 : static int
1543 777329 : exp_is_complex_select( sql_exp *e )
1544 : {
1545 798867 : switch (e->type) {
1546 453 : case e_atom: {
1547 453 : if (e->f) {
1548 0 : int r = (e->card == CARD_ATOM);
1549 0 : list *l = e->f;
1550 :
1551 0 : if (r)
1552 0 : for (node *n = l->h; n && !r; n = n->next)
1553 0 : r |= exp_is_complex_select(n->data);
1554 0 : return r;
1555 : }
1556 : return 0;
1557 : }
1558 21538 : case e_convert:
1559 21538 : return exp_is_complex_select(e->l);
1560 2056 : case e_func:
1561 : case e_aggr:
1562 : {
1563 2056 : int r = (e->card == CARD_ATOM);
1564 2056 : list *l = e->l;
1565 :
1566 2056 : if (r && l)
1567 47 : for (node *n = l->h; n && !r; n = n->next)
1568 0 : r |= exp_is_complex_select(n->data);
1569 : return r;
1570 : }
1571 : case e_psm:
1572 : return 1;
1573 : case e_column:
1574 : case e_cmp:
1575 : default:
1576 : return 0;
1577 : }
1578 : }
1579 :
1580 : static int
1581 388671 : complex_select(sql_exp *e)
1582 : {
1583 388671 : sql_exp *l = e->l, *r = e->r;
1584 :
1585 388671 : if (exp_is_complex_select(l) || exp_is_complex_select(r))
1586 47 : return 1;
1587 : return 0;
1588 : }
1589 :
1590 : static int
1591 929 : distinct_rel(sql_exp *e, const char **rname)
1592 : {
1593 1071 : const char *e_rname = NULL;
1594 :
1595 1071 : switch(e->type) {
1596 651 : case e_column:
1597 651 : e_rname = exp_relname(e);
1598 :
1599 651 : if (*rname && e_rname && strcmp(*rname, e_rname) == 0)
1600 : return 1;
1601 504 : if (!*rname) {
1602 321 : *rname = e_rname;
1603 321 : return 1;
1604 : }
1605 : break;
1606 145 : case e_aggr:
1607 : case e_func:
1608 145 : if (e->l) {
1609 145 : int m = 1;
1610 145 : list *l = e->l;
1611 145 : node *n;
1612 :
1613 438 : for(n=l->h; n && m; n = n->next) {
1614 293 : sql_exp *ae = n->data;
1615 :
1616 293 : m = distinct_rel(ae, rname);
1617 : }
1618 145 : return m;
1619 : }
1620 : return 0;
1621 : case e_atom:
1622 : return 1;
1623 142 : case e_convert:
1624 142 : return distinct_rel(e->l, rname);
1625 : default:
1626 : return 0;
1627 : }
1628 : return 0;
1629 : }
1630 :
1631 : int
1632 20400624 : rel_has_exp(sql_rel *rel, sql_exp *e, bool subexp)
1633 : {
1634 20400624 : if (rel_find_exp_and_corresponding_rel(rel, e, subexp, NULL, NULL))
1635 4499021 : return 0;
1636 : return -1;
1637 : }
1638 :
1639 : int
1640 0 : rel_has_exps(sql_rel *rel, list *exps, bool subexp)
1641 : {
1642 0 : if (list_empty(exps))
1643 : return 0;
1644 0 : for (node *n = exps->h; n; n = n->next)
1645 0 : if (rel_has_exp(rel, n->data, subexp) >= 0)
1646 : return 0;
1647 : return -1;
1648 : }
1649 :
1650 : int
1651 0 : rel_has_all_exps(sql_rel *rel, list *exps)
1652 : {
1653 0 : if (list_empty(exps))
1654 : return 1;
1655 0 : for (node *n = exps->h; n; n = n->next)
1656 0 : if (rel_has_exp(rel, n->data, false) < 0)
1657 : return 0;
1658 : return 1;
1659 : }
1660 :
1661 : static int
1662 15406733 : rel_has_exp2(sql_rel *rel, sql_exp *e)
1663 : {
1664 15406733 : return rel_has_exp(rel, e, false);
1665 : }
1666 :
1667 : sql_rel *
1668 5857280 : find_rel(list *rels, sql_exp *e)
1669 : {
1670 5857280 : node *n = list_find(rels, e, (fcmp)&rel_has_exp2);
1671 5857280 : if (n)
1672 3346795 : return n->data;
1673 : return NULL;
1674 : }
1675 :
1676 : sql_rel *
1677 0 : find_one_rel(list *rels, sql_exp *e)
1678 : {
1679 0 : node *n;
1680 0 : sql_rel *fnd = NULL;
1681 :
1682 0 : for(n = rels->h; n; n = n->next) {
1683 0 : if (rel_has_exp(n->data, e, false) == 0) {
1684 0 : if (fnd)
1685 : return NULL;
1686 0 : fnd = n->data;
1687 : }
1688 : }
1689 : return fnd;
1690 : }
1691 :
1692 : static int
1693 326 : exp_is_rangejoin(sql_exp *e, list *rels)
1694 : {
1695 : /* assume e is a e_cmp with 3 args
1696 : * Need to check e->r and e->f only touch one table.
1697 : */
1698 326 : const char *rname = 0;
1699 :
1700 326 : if (distinct_rel(e->r, &rname) && distinct_rel(e->f, &rname))
1701 : return 0;
1702 183 : if (rels) {
1703 138 : sql_rel *r = find_rel(rels, e->r);
1704 138 : sql_rel *f = find_rel(rels, e->f);
1705 138 : if (r && f && r == f)
1706 : return 0;
1707 : }
1708 : return -1;
1709 : }
1710 :
1711 : int
1712 390450 : exp_is_join(sql_exp *e, list *rels)
1713 : {
1714 : /* only simple compare expressions, ie not or lists
1715 : or range expressions (e->f)
1716 : */
1717 390450 : if (e->type == e_cmp && !is_complex_exp(e->flag) && e->l && e->r && !e->f && e->card >= CARD_AGGR && !complex_select(e))
1718 : return 0;
1719 2152 : if (e->type == e_cmp && e->flag == cmp_filter && e->l && e->r && e->card >= CARD_AGGR)
1720 : return 0;
1721 : /* range expression */
1722 1958 : if (e->type == e_cmp && !is_complex_exp(e->flag) && e->l && e->r && e->f && e->card >= CARD_AGGR && !complex_select(e))
1723 326 : return exp_is_rangejoin(e, rels);
1724 : return -1;
1725 : }
1726 :
1727 : int
1728 384332 : exp_is_eqjoin(sql_exp *e)
1729 : {
1730 384332 : if (e->flag == cmp_equal) {
1731 374506 : sql_exp *l = e->l;
1732 374506 : sql_exp *r = e->r;
1733 :
1734 374506 : if (!is_func(l->type) && !is_func(r->type))
1735 373387 : return 0;
1736 : }
1737 : return -1;
1738 : }
1739 :
1740 : sql_exp *
1741 234489 : exps_find_prop(list *exps, rel_prop kind)
1742 : {
1743 234489 : if (list_empty(exps))
1744 : return NULL;
1745 467711 : for (node *n = exps->h ; n ; n = n->next) {
1746 234489 : sql_exp *e = n->data;
1747 :
1748 234489 : if (find_prop(e->p, kind))
1749 1267 : return e;
1750 : }
1751 : return NULL;
1752 : }
1753 :
1754 : /* check is one of the exps can be found in this relation */
1755 : static sql_exp* rel_find_exp_and_corresponding_rel_(sql_rel *rel, sql_exp *e, bool subexp, sql_rel **res);
1756 :
1757 : static bool
1758 628411 : rel_find_exps_and_corresponding_rel_(sql_rel *rel, list *l, bool subexp, sql_rel **res)
1759 : {
1760 628411 : int all = 1;
1761 :
1762 628411 : if (list_empty(l))
1763 : return true;
1764 1683438 : for(node *n = l->h; n && (subexp || all); n = n->next) {
1765 1074776 : sql_exp *ne = rel_find_exp_and_corresponding_rel_(rel, n->data, subexp, res);
1766 1074776 : if (subexp && ne)
1767 : return true;
1768 1059191 : all &= (ne?1:0);
1769 : }
1770 608662 : if (all)
1771 : return true;
1772 : return false;
1773 : }
1774 :
1775 : static sql_exp *
1776 79280196 : rel_find_exp_and_corresponding_rel_(sql_rel *rel, sql_exp *e, bool subexp, sql_rel **res)
1777 : {
1778 79280196 : sql_exp *ne = NULL;
1779 :
1780 79280196 : if (!rel)
1781 : return NULL;
1782 79280083 : switch(e->type) {
1783 76893852 : case e_column:
1784 76893852 : if (is_basetable(rel->op) && !rel->exps) {
1785 26424 : assert(e->nid);
1786 26424 : if (rel_base_has_nid(rel, e->nid))
1787 76893904 : ne = e;
1788 96648062 : } else if ((!list_empty(rel->exps) && (is_project(rel->op) || is_base(rel->op))) ||
1789 20166367 : (!list_empty(rel->attr) && is_join(rel->op))) {
1790 57472584 : list *l = rel->attr ? rel->attr : rel->exps;
1791 57472584 : assert(e->nid);
1792 57472584 : ne = exps_bind_nid(l, e->nid);
1793 : }
1794 76893904 : if (ne && res)
1795 71397 : *res = rel;
1796 : return ne;
1797 1122812 : case e_convert:
1798 1122812 : return rel_find_exp_and_corresponding_rel_(rel, e->l, subexp, res);
1799 628396 : case e_aggr:
1800 : case e_func:
1801 628396 : if (e->l)
1802 628396 : if (rel_find_exps_and_corresponding_rel_(rel, e->l, subexp, res))
1803 : return e;
1804 : return NULL;
1805 420 : case e_cmp:
1806 420 : if (!subexp)
1807 : return NULL;
1808 :
1809 32 : if (e->flag == cmp_or || e->flag == cmp_filter) {
1810 13 : if (rel_find_exps_and_corresponding_rel_(rel, e->l, subexp, res) ||
1811 3 : rel_find_exps_and_corresponding_rel_(rel, e->r, subexp, res))
1812 10 : return e;
1813 22 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
1814 4 : if (rel_find_exp_and_corresponding_rel_(rel, e->l, subexp, res) ||
1815 2 : rel_find_exps_and_corresponding_rel_(rel, e->r, subexp, res))
1816 2 : return e;
1817 26 : } else if (rel_find_exp_and_corresponding_rel_(rel, e->l, subexp, res) ||
1818 6 : rel_find_exp_and_corresponding_rel_(rel, e->r, subexp, res) ||
1819 2 : (!e->f || rel_find_exp_and_corresponding_rel_(rel, e->f, subexp, res))) {
1820 18 : return e;
1821 : }
1822 : return NULL;
1823 : case e_psm:
1824 : return NULL;
1825 634096 : case e_atom:
1826 634096 : if (e->f) { /* values */
1827 12 : list *l = e->f;
1828 12 : node *n = l->h;
1829 :
1830 12 : ne = n->data;
1831 31 : while ((subexp || ne != NULL) && n != NULL) {
1832 19 : ne = rel_find_exp_and_corresponding_rel_(rel, n->data, subexp, res);
1833 19 : if (subexp && ne)
1834 : break;
1835 19 : n = n->next;
1836 : }
1837 12 : return ne;
1838 : }
1839 : return e;
1840 : }
1841 : return ne;
1842 : }
1843 :
1844 : sql_exp *
1845 77082519 : rel_find_exp_and_corresponding_rel(sql_rel *rel, sql_exp *e, bool subexp, sql_rel **res, bool *under_join)
1846 : {
1847 77082519 : sql_exp *ne = rel_find_exp_and_corresponding_rel_(rel, e, subexp, res);
1848 :
1849 77082632 : if (rel && !ne) {
1850 55374017 : switch(rel->op) {
1851 13321568 : case op_left:
1852 : case op_right:
1853 : case op_full:
1854 : case op_join:
1855 : case op_semi:
1856 : case op_anti:
1857 13321568 : ne = rel_find_exp_and_corresponding_rel(rel->l, e, subexp, res, under_join);
1858 13321568 : if (!ne && is_join(rel->op))
1859 8521837 : ne = rel_find_exp_and_corresponding_rel(rel->r, e, subexp, res, under_join);
1860 : break;
1861 : case op_table:
1862 : case op_basetable:
1863 : break;
1864 281998 : case op_munion:
1865 1548968 : for (node* n = ((list*)rel->l)->h; n && !ne; n = n->next)
1866 1266970 : ne = rel_find_exp_and_corresponding_rel(n->data, e, subexp, res, under_join);
1867 : break;
1868 14830744 : default:
1869 14830744 : if (!is_project(rel->op) && rel->l)
1870 6437721 : ne = rel_find_exp_and_corresponding_rel(rel->l, e, subexp, res, under_join);
1871 : }
1872 : }
1873 77082633 : if (ne && under_join && is_join(rel->op))
1874 2957498 : *under_join = true;
1875 77082633 : return ne;
1876 : }
1877 :
1878 : sql_exp *
1879 21962433 : rel_find_exp(sql_rel *rel, sql_exp *e)
1880 : {
1881 21962433 : return rel_find_exp_and_corresponding_rel(rel, e, false, NULL, NULL);
1882 : }
1883 :
1884 : bool
1885 65397 : rel_find_nid(sql_rel *rel, int nid)
1886 : {
1887 65808 : if (rel) {
1888 65330 : switch(rel->op) {
1889 5579 : case op_left:
1890 : case op_right:
1891 : case op_full:
1892 : case op_join:
1893 : case op_semi:
1894 : case op_anti:
1895 5579 : if (rel_find_nid(rel->l, nid))
1896 : return true;
1897 495 : if (is_join(rel->op))
1898 411 : return rel_find_nid(rel->r, nid);
1899 : break;
1900 56395 : case op_table:
1901 : case op_basetable:
1902 : case op_munion:
1903 : case op_union:
1904 : case op_inter:
1905 : case op_except:
1906 : case op_project:
1907 : case op_groupby:
1908 56395 : if (rel->exps) {
1909 56395 : if (exps_bind_nid(rel->exps, nid))
1910 : return true;
1911 0 : } else if (rel->op == op_basetable)
1912 0 : return rel_base_has_nid(rel, nid);
1913 : break;
1914 3356 : case op_select:
1915 : case op_topn:
1916 : case op_sample:
1917 3356 : if (rel_find_nid(rel->l, nid))
1918 : return true;
1919 : break;
1920 : case op_ddl:
1921 : case op_insert:
1922 : case op_update:
1923 : case op_delete:
1924 : case op_truncate:
1925 : case op_merge:
1926 : return false;
1927 :
1928 : }
1929 : }
1930 : return false;
1931 : }
1932 :
1933 : int
1934 3906414 : exp_is_true(sql_exp *e)
1935 : {
1936 3906414 : if (e->type == e_atom && e->l)
1937 48473 : return atom_is_true(e->l);
1938 3857941 : if (e->type == e_cmp && e->flag == cmp_equal)
1939 3121484 : return (exp_is_true(e->l) && exp_is_true(e->r) && exp_match_exp(e->l, e->r));
1940 : return 0;
1941 : }
1942 :
1943 : static inline bool
1944 236547 : exp_is_cmp_exp_is_false(sql_exp* e)
1945 : {
1946 236547 : sql_exp *l = e->l;
1947 236547 : sql_exp *r = e->r;
1948 236547 : assert(e->type == e_cmp && e->f == NULL && l && r);
1949 :
1950 : /* Handle 'v is x' and 'v is not x' expressions.
1951 : * Other cases in is-semantics are unspecified.
1952 : */
1953 236547 : if (e->flag != cmp_equal && e->flag != cmp_notequal)
1954 : return false;
1955 236547 : if (e->flag == cmp_equal && !is_anti(e))
1956 369558 : return ((exp_is_null(l) && exp_is_not_null(r)) || (exp_is_not_null(l) && exp_is_null(r)));
1957 51768 : if ((e->flag == cmp_notequal && !is_anti(e)) || (e->flag == cmp_equal && is_anti(e)))
1958 103482 : return exp_is_null(l) && exp_is_null(r);
1959 : return false;
1960 : }
1961 :
1962 : static inline bool
1963 5476767 : exp_single_bound_cmp_exp_is_false(sql_exp* e)
1964 : {
1965 5476767 : assert(e->type == e_cmp);
1966 5476767 : sql_exp* l = e->l;
1967 5476767 : sql_exp* r = e->r;
1968 5476767 : assert(e->f == NULL);
1969 5476767 : assert (l && r);
1970 :
1971 5476767 : return exp_is_null(l) || exp_is_null(r);
1972 : }
1973 :
1974 : static inline bool
1975 74696 : exp_two_sided_bound_cmp_exp_is_false(sql_exp* e)
1976 : {
1977 74696 : assert(e->type == e_cmp);
1978 74696 : sql_exp* v = e->l;
1979 74696 : sql_exp* l = e->r;
1980 74696 : sql_exp* h = e->f;
1981 74696 : assert (v && l && h);
1982 :
1983 74696 : return is_anti(e) ? exp_is_null(v) || (exp_is_null(l) && exp_is_null(h)) : false;
1984 : }
1985 :
1986 : static inline bool
1987 5801428 : exp_regular_cmp_exp_is_false(sql_exp* e)
1988 : {
1989 5801428 : assert(e->type == e_cmp);
1990 :
1991 5801428 : if (is_semantics(e) && !is_any(e)) return exp_is_cmp_exp_is_false(e);
1992 5564881 : if (is_any(e)) return false;
1993 5551463 : if (e -> f) return exp_two_sided_bound_cmp_exp_is_false(e);
1994 5476767 : else return exp_single_bound_cmp_exp_is_false(e);
1995 : }
1996 :
1997 : static inline bool
1998 535640 : exp_or_exp_is_false(sql_exp* e)
1999 : {
2000 535640 : assert(e->type == e_cmp && e->flag == cmp_or);
2001 :
2002 535640 : list* left = e->l;
2003 535640 : list* right = e->r;
2004 :
2005 535640 : bool left_is_false = false;
2006 1116178 : for(node* n = left->h; n; n=n->next) {
2007 581152 : if (exp_is_false(n->data)) {
2008 : left_is_false=true;
2009 : break;
2010 : }
2011 : }
2012 :
2013 535640 : if (!left_is_false) {
2014 : return false;
2015 : }
2016 :
2017 1176 : for(node* n = right->h; n; n=n->next) {
2018 643 : if (exp_is_false(n->data)) {
2019 : return true;
2020 : }
2021 : }
2022 :
2023 : return false;
2024 : }
2025 :
2026 : static inline bool
2027 6681077 : exp_cmp_exp_is_false(sql_exp* e)
2028 : {
2029 6681077 : assert(e->type == e_cmp);
2030 :
2031 6681077 : switch (e->flag) {
2032 5801429 : case cmp_gt:
2033 : case cmp_gte:
2034 : case cmp_lte:
2035 : case cmp_lt:
2036 : case cmp_equal:
2037 : case cmp_notequal:
2038 5801429 : return exp_regular_cmp_exp_is_false(e);
2039 535640 : case cmp_or:
2040 535640 : return exp_or_exp_is_false(e);
2041 : default:
2042 : return false;
2043 : }
2044 : }
2045 :
2046 : int
2047 6775487 : exp_is_false(sql_exp *e)
2048 : {
2049 6775487 : if (e->type == e_atom && e->l)
2050 46552 : return atom_is_false(e->l);
2051 6728935 : else if (e->type == e_cmp)
2052 6681076 : return exp_cmp_exp_is_false(e);
2053 : return 0;
2054 : }
2055 :
2056 : int
2057 17945 : exp_is_zero(sql_exp *e)
2058 : {
2059 17945 : if (e->type == e_atom && e->l)
2060 17677 : return atom_is_zero(e->l);
2061 : return 0;
2062 : }
2063 :
2064 : int
2065 333990 : exp_is_not_null(sql_exp *e)
2066 : {
2067 334177 : if (!has_nil(e))
2068 : return true;
2069 :
2070 102127 : switch (e->type) {
2071 3093 : case e_atom:
2072 3093 : if (e->f) /* values list */
2073 : return false;
2074 3093 : if (e->l)
2075 2803 : return !(atom_null(e->l));
2076 : return false;
2077 187 : case e_convert:
2078 187 : return exp_is_not_null(e->l);
2079 651 : case e_func:
2080 651 : if (!is_semantics(e) && e->l) {
2081 263 : list *l = e->l;
2082 308 : for (node *n = l->h; n; n=n->next) {
2083 306 : sql_exp *p = n->data;
2084 306 : if (!exp_is_not_null(p))
2085 : return false;
2086 : }
2087 : return true;
2088 : }
2089 : return false;
2090 : case e_aggr:
2091 : case e_column:
2092 : case e_cmp:
2093 : case e_psm:
2094 : return false;
2095 : }
2096 : return false;
2097 : }
2098 :
2099 : static int
2100 8336 : exps_have_null(list *l)
2101 : {
2102 8336 : if (!l)
2103 : return false;
2104 17645 : for(node *n = l->h; n; n = n->next)
2105 9313 : if (exp_is_null(n->data))
2106 : return true;
2107 : return false;
2108 : }
2109 :
2110 : int
2111 12256544 : exp_is_null(sql_exp *e )
2112 : {
2113 12300262 : if (!has_nil(e))
2114 : return false;
2115 :
2116 1627631 : switch (e->type) {
2117 168197 : case e_atom:
2118 168197 : if (e->f) /* values list */
2119 : return 0;
2120 168118 : if (e->l)
2121 93632 : return (atom_null(e->l));
2122 : return 0;
2123 43718 : case e_convert:
2124 43718 : return exp_is_null(e->l);
2125 115504 : case e_func:
2126 115504 : if (!is_semantics(e) && e->l) {
2127 : /* This is a call to a function with no-nil semantics.
2128 : * If one of the parameters is null the expression itself is null
2129 : */
2130 100648 : list* l = e->l;
2131 301084 : for(node* n = l->h; n; n=n->next) {
2132 200608 : sql_exp* p = n->data;
2133 200608 : if (exp_is_null(p)) {
2134 : return true;
2135 : }
2136 : }
2137 : }
2138 : return 0;
2139 60198 : case e_cmp:
2140 60198 : if (!is_semantics(e)) {
2141 56938 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2142 14984 : return (exps_have_null(e->l) && exps_have_null(e->r));
2143 49446 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2144 3619 : return ((e->flag == cmp_in && exp_is_null(e->l)) ||
2145 3617 : (e->flag == cmp_notin && (exp_is_null(e->l) || exps_have_null(e->r))));
2146 45827 : } else if (e->f) {
2147 7170 : return exp_is_null(e->l) && exp_is_null(e->r) && exp_is_null(e->f);
2148 : } else {
2149 42244 : return exp_is_null(e->l) || exp_is_null(e->r);
2150 : }
2151 : }
2152 : return 0;
2153 : case e_aggr:
2154 : case e_column:
2155 : case e_psm:
2156 : return 0;
2157 : }
2158 : return 0;
2159 : }
2160 :
2161 : int
2162 1835667 : exp_is_rel( sql_exp *e )
2163 : {
2164 1845064 : if (e) {
2165 1845064 : switch(e->type){
2166 9397 : case e_convert:
2167 9397 : return exp_is_rel(e->l);
2168 318519 : case e_psm:
2169 318519 : return e->flag == PSM_REL && e->l;
2170 : default:
2171 : return 0;
2172 : }
2173 : }
2174 : return 0;
2175 : }
2176 :
2177 : int
2178 7227 : exps_one_is_rel(list *exps)
2179 : {
2180 7227 : if (list_empty(exps))
2181 : return 0;
2182 21578 : for(node *n = exps->h ; n ; n = n->next)
2183 14360 : if (exp_is_rel(n->data))
2184 : return 1;
2185 : return 0;
2186 : }
2187 :
2188 : int
2189 9061763 : exp_is_atom( sql_exp *e )
2190 : {
2191 9433345 : switch (e->type) {
2192 2080549 : case e_atom:
2193 2080549 : if (e->f) /* values list */
2194 13050 : return exps_are_atoms(e->f);
2195 : return 1;
2196 371582 : case e_convert:
2197 371582 : return exp_is_atom(e->l);
2198 1103896 : case e_func:
2199 : case e_aggr:
2200 1103896 : return e->card == CARD_ATOM && exps_are_atoms(e->l);
2201 2722 : case e_cmp:
2202 2722 : if (e->card != CARD_ATOM)
2203 : return 0;
2204 157 : if (e->flag == cmp_or || e->flag == cmp_filter)
2205 82 : return exps_are_atoms(e->l) && exps_are_atoms(e->r);
2206 79 : if (e->flag == cmp_in || e->flag == cmp_notin)
2207 0 : return exp_is_atom(e->l) && exps_are_atoms(e->r);
2208 79 : return exp_is_atom(e->l) && exp_is_atom(e->r) && (!e->f || exp_is_atom(e->f));
2209 : case e_column:
2210 : case e_psm:
2211 : return 0;
2212 : }
2213 : return 0;
2214 : }
2215 :
2216 : static int
2217 1 : exps_are_aggr(sql_rel *r, list *exps)
2218 : {
2219 1 : int aggr = 1;
2220 1 : if (!list_empty(exps))
2221 3 : for(node *n=exps->h; n && aggr; n=n->next)
2222 2 : aggr &= exp_is_aggr(r, n->data);
2223 1 : return aggr;
2224 : }
2225 :
2226 : /* is expression e an aggregated result of r */
2227 : int
2228 11 : exp_is_aggr(sql_rel *r, sql_exp *e)
2229 : {
2230 11 : sql_exp *ne = NULL;
2231 :
2232 11 : switch (e->type) {
2233 : case e_atom:
2234 : return true;
2235 0 : case e_convert:
2236 0 : return exp_is_aggr(r, e->l);
2237 1 : case e_func:
2238 1 : return exps_are_aggr(r, e->l);
2239 : case e_aggr:
2240 : return true;
2241 0 : case e_cmp:
2242 0 : if (e->card != CARD_ATOM)
2243 : return false;
2244 0 : if (e->flag == cmp_or || e->flag == cmp_filter)
2245 0 : return exps_are_aggr(r, e->l) && exps_are_aggr(r, e->r);
2246 0 : if (e->flag == cmp_in || e->flag == cmp_notin)
2247 0 : return exp_is_aggr(r, e->l) && exps_are_aggr(r, e->r);
2248 0 : return exp_is_aggr(r, e->l) && exp_is_aggr(r, e->r) && (!e->f || exp_is_aggr(r, e->f));
2249 9 : case e_column:
2250 9 : if (e->freevar)
2251 : return true;
2252 9 : ne = rel_find_exp(r, e);
2253 9 : if (ne) /* found local */
2254 : return true;
2255 : else
2256 : return false;
2257 : case e_psm:
2258 : return false;
2259 : }
2260 : return false;
2261 : }
2262 :
2263 : static int
2264 19 : exps_have_aggr(sql_rel *r, list *exps)
2265 : {
2266 19 : int aggr = 0;
2267 19 : if (!list_empty(exps))
2268 63 : for(node *n=exps->h; n && !aggr; n=n->next)
2269 44 : aggr |= exp_has_aggr(r, n->data);
2270 19 : return aggr;
2271 : }
2272 :
2273 : int
2274 80 : exp_has_aggr(sql_rel *r, sql_exp *e )
2275 : {
2276 87 : sql_exp *ne = NULL;
2277 :
2278 87 : switch (e->type) {
2279 : case e_atom:
2280 : return false;
2281 7 : case e_convert:
2282 7 : return exp_has_aggr(r, e->l);
2283 19 : case e_func:
2284 19 : return exps_have_aggr(r, e->l);
2285 : case e_aggr:
2286 : return true;
2287 0 : case e_cmp:
2288 0 : if (e->card != CARD_ATOM)
2289 : return false;
2290 0 : if (e->flag == cmp_or || e->flag == cmp_filter)
2291 0 : return exps_have_aggr(r, e->l) && exps_have_aggr(r, e->r);
2292 0 : if (e->flag == cmp_in || e->flag == cmp_notin)
2293 0 : return exp_has_aggr(r, e->l) && exps_have_aggr(r, e->r);
2294 0 : return exp_has_aggr(r, e->l) && exp_has_aggr(r, e->r) && (!e->f || exp_has_aggr(r, e->f));
2295 34 : case e_column:
2296 34 : if (e->freevar)
2297 : return false;
2298 21 : ne = rel_find_exp(r->l, e);
2299 21 : if (ne) /* found lower */
2300 : return false;
2301 : else
2302 : return true;
2303 : case e_psm:
2304 : return false;
2305 : }
2306 : return false;
2307 : }
2308 :
2309 : int
2310 20790013 : exp_has_rel( sql_exp *e )
2311 : {
2312 21164302 : if (!e)
2313 : return 0;
2314 21164302 : switch(e->type){
2315 1978475 : case e_func:
2316 : case e_aggr:
2317 1978475 : return exps_have_rel_exp(e->l);
2318 693745 : case e_cmp:
2319 693745 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2320 69962 : return (exps_have_rel_exp(e->l) || exps_have_rel_exp(e->r));
2321 624237 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2322 39718 : return (exp_has_rel(e->l) || exps_have_rel_exp(e->r));
2323 : } else {
2324 1169039 : return (exp_has_rel(e->l) || exp_has_rel(e->r) || (e->f && exp_has_rel(e->f)));
2325 : }
2326 374289 : case e_convert:
2327 374289 : return exp_has_rel(e->l);
2328 127939 : case e_psm:
2329 127939 : return exp_is_rel(e);
2330 9821254 : case e_atom:
2331 9821254 : return (e->f && exps_have_rel_exp(e->f));
2332 : case e_column:
2333 : return 0;
2334 : }
2335 : return 0;
2336 : }
2337 :
2338 : int
2339 2659846 : exps_have_rel_exp( list *exps)
2340 : {
2341 2659846 : if (list_empty(exps))
2342 : return 0;
2343 9526773 : for(node *n=exps->h; n; n=n->next) {
2344 6963758 : sql_exp *e = n->data;
2345 :
2346 6963758 : if (exp_has_rel(e))
2347 : return 1;
2348 : }
2349 : return 0;
2350 : }
2351 :
2352 : static sql_rel *
2353 572 : exps_rel_get_rel(allocator *sa, list *exps )
2354 : {
2355 572 : sql_rel *r = NULL, *xp = NULL;
2356 :
2357 572 : if (list_empty(exps))
2358 : return NULL;
2359 1680 : for (node *n = exps->h; n; n=n->next){
2360 1108 : sql_exp *e = n->data;
2361 :
2362 1108 : if (exp_has_rel(e)) {
2363 578 : if (!(r = exp_rel_get_rel(sa, e)))
2364 : return NULL;
2365 578 : if (xp) {
2366 6 : xp = rel_crossproduct(sa, xp, r, op_full);
2367 6 : set_processed(xp);
2368 : } else {
2369 : xp = r;
2370 : }
2371 : }
2372 : }
2373 : return xp;
2374 : }
2375 :
2376 : int
2377 60 : exp_rel_depth(sql_exp *e)
2378 : {
2379 60 : if (!e)
2380 : return 0;
2381 60 : switch(e->type){
2382 : case e_func:
2383 : case e_aggr:
2384 : case e_cmp:
2385 : return 1;
2386 : case e_convert:
2387 : return 0;
2388 39 : case e_psm:
2389 39 : if (exp_is_rel(e))
2390 : return 0;
2391 : return 1;
2392 : case e_atom:
2393 : case e_column:
2394 : return 0;
2395 : }
2396 : return 0;
2397 : }
2398 :
2399 : sql_rel *
2400 80633 : exp_rel_get_rel(allocator *sa, sql_exp *e)
2401 : {
2402 81732 : if (!e)
2403 : return NULL;
2404 :
2405 81732 : switch(e->type){
2406 544 : case e_func:
2407 : case e_aggr:
2408 544 : return exps_rel_get_rel(sa, e->l);
2409 38 : case e_cmp: {
2410 38 : sql_rel *r = NULL, *xp = NULL;
2411 :
2412 38 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2413 11 : if (exps_have_rel_exp(e->l))
2414 7 : xp = exps_rel_get_rel(sa, e->l);
2415 11 : if (exps_have_rel_exp(e->r)) {
2416 6 : if (!(r = exps_rel_get_rel(sa, e->r)))
2417 : return NULL;
2418 6 : if (xp) {
2419 2 : xp = rel_crossproduct(sa, xp, r, op_join);
2420 2 : set_processed(xp);
2421 : } else {
2422 : xp = r;
2423 : }
2424 : }
2425 27 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2426 0 : if (exp_has_rel(e->l))
2427 0 : xp = exp_rel_get_rel(sa, e->l);
2428 0 : if (exps_have_rel_exp(e->r)) {
2429 0 : if (!(r = exps_rel_get_rel(sa, e->r)))
2430 : return NULL;
2431 0 : if (xp) {
2432 0 : xp = rel_crossproduct(sa, xp, r, op_join);
2433 0 : set_processed(xp);
2434 : } else {
2435 : xp = r;
2436 : }
2437 : }
2438 : } else {
2439 27 : if (exp_has_rel(e->l))
2440 25 : xp = exp_rel_get_rel(sa, e->l);
2441 27 : if (exp_has_rel(e->r)) {
2442 7 : if (!(r = exp_rel_get_rel(sa, e->r)))
2443 : return NULL;
2444 7 : if (xp) {
2445 5 : xp = rel_crossproduct(sa, xp, r, op_join);
2446 5 : set_processed(xp);
2447 : } else {
2448 : xp = r;
2449 : }
2450 : }
2451 27 : if (e->f && exp_has_rel(e->f)) {
2452 0 : if (!(r = exp_rel_get_rel(sa, e->f)))
2453 : return NULL;
2454 0 : if (xp) {
2455 0 : xp = rel_crossproduct(sa, xp, r, op_join);
2456 0 : set_processed(xp);
2457 : } else {
2458 : xp = r;
2459 : }
2460 : }
2461 : }
2462 : return xp;
2463 : }
2464 1099 : case e_convert:
2465 1099 : return exp_rel_get_rel(sa, e->l);
2466 80036 : case e_psm:
2467 80036 : if (exp_is_rel(e))
2468 80036 : return e->l;
2469 : return NULL;
2470 15 : case e_atom:
2471 15 : if (e->f && exps_have_rel_exp(e->f))
2472 15 : return exps_rel_get_rel(sa, e->f);
2473 : return NULL;
2474 : case e_column:
2475 : return NULL;
2476 : }
2477 : return NULL;
2478 : }
2479 :
2480 : static void exp_rel_update_set_freevar(sql_exp *e);
2481 :
2482 : static void
2483 925 : exps_rel_update_set_freevar(list *exps)
2484 : {
2485 925 : if (!list_empty(exps))
2486 3016 : for (node *n=exps->h; n ; n=n->next)
2487 2091 : exp_rel_update_set_freevar(n->data);
2488 925 : }
2489 :
2490 : static void
2491 2382 : exp_rel_update_set_freevar(sql_exp *e)
2492 : {
2493 2394 : if (!e)
2494 : return ;
2495 :
2496 2394 : switch(e->type){
2497 923 : case e_func:
2498 : case e_aggr:
2499 923 : exps_rel_update_set_freevar(e->l);
2500 923 : break;
2501 8 : case e_cmp:
2502 8 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2503 0 : exps_rel_update_set_freevar(e->l);
2504 0 : exps_rel_update_set_freevar(e->r);
2505 8 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2506 0 : exp_rel_update_set_freevar(e->l);
2507 0 : exps_rel_update_set_freevar(e->r);
2508 : } else {
2509 8 : exp_rel_update_set_freevar(e->l);
2510 8 : exp_rel_update_set_freevar(e->r);
2511 8 : if (e->f)
2512 : exp_rel_update_set_freevar(e->f);
2513 : }
2514 : break;
2515 9 : case e_convert:
2516 9 : exp_rel_update_set_freevar(e->l);
2517 9 : break;
2518 1171 : case e_atom:
2519 1171 : if (e->f)
2520 2 : exps_rel_update_set_freevar(e->f);
2521 : break;
2522 283 : case e_column:
2523 283 : set_freevar(e, 1);
2524 283 : break;
2525 : case e_psm:
2526 : break;
2527 : }
2528 : }
2529 :
2530 : static list *
2531 572 : exp_rel_update_exps(mvc *sql, list *exps, bool up)
2532 : {
2533 572 : if (list_empty(exps))
2534 : return exps;
2535 1680 : for (node *n = exps->h; n; n=n->next){
2536 1108 : sql_exp *e = n->data;
2537 :
2538 1108 : if (exp_has_rel(e))
2539 578 : n->data = exp_rel_update_exp(sql, e, up);
2540 530 : else if (!exp_is_atom(e) && !up)
2541 269 : exp_rel_update_set_freevar(e);
2542 : }
2543 : return exps;
2544 : }
2545 :
2546 : static sql_exp *
2547 57 : exp_rel_update_exp_(mvc *sql, sql_exp *e, bool up)
2548 : {
2549 57 : if (exp_has_rel(e))
2550 31 : e = exp_rel_update_exp(sql, e, up);
2551 26 : else if (!exp_is_atom(e) && !up)
2552 6 : exp_rel_update_set_freevar(e);
2553 57 : return e;
2554 : }
2555 :
2556 : sql_exp *
2557 14061 : exp_rel_update_exp(mvc *sql, sql_exp *e, bool up)
2558 : {
2559 14061 : if (!e)
2560 : return NULL;
2561 :
2562 14061 : switch(e->type){
2563 544 : case e_func:
2564 : case e_aggr:
2565 544 : if (exps_have_rel_exp(e->l))
2566 544 : e->l = exp_rel_update_exps(sql, e->l, up);
2567 : return e;
2568 37 : case e_cmp:
2569 37 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2570 11 : if (exps_have_rel_exp(e->l))
2571 7 : e->l = exp_rel_update_exps(sql, e->l, up);
2572 11 : if (exps_have_rel_exp(e->r))
2573 6 : e->r = exp_rel_update_exps(sql, e->r, up);
2574 26 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2575 0 : if (exp_has_rel(e->l))
2576 0 : e->l = exp_rel_update_exp(sql, e->l, up);
2577 0 : if (exps_have_rel_exp(e->r))
2578 0 : e->r = exp_rel_update_exps(sql, e->r, up);
2579 : } else {
2580 : //if (exp_has_rel(e->l))
2581 26 : e->l = exp_rel_update_exp_(sql, e->l, up);
2582 : //if (exp_has_rel(e->r))
2583 26 : e->r = exp_rel_update_exp_(sql, e->r, up);
2584 26 : if (e->f /*&& exp_has_rel(e->f)*/)
2585 5 : e->f = exp_rel_update_exp_(sql, e->f, up);
2586 : }
2587 : return e;
2588 1099 : case e_convert:
2589 1099 : if (exp_has_rel(e->l))
2590 1099 : e->l = exp_rel_update_exp(sql, e->l, up);
2591 : return e;
2592 12366 : case e_psm:
2593 12366 : if (exp_is_rel(e)) {
2594 12366 : sql_rel *r = exp_rel_get_rel(sql->sa, e), *nr = r;
2595 12366 : if (is_topn(r->op)) {
2596 2 : nr = r->l;
2597 2 : if (nr && !is_project(nr->op))
2598 0 : r->l = nr = rel_project(sql->sa, nr, rel_projections(sql, nr, NULL, 1, 0));
2599 : }
2600 12366 : e = nr->exps->t->data;
2601 12366 : e = exp_ref(sql, e);
2602 12366 : if (up)
2603 0 : set_freevar(e, 1);
2604 12366 : return e;
2605 : }
2606 : return e;
2607 15 : case e_atom:
2608 15 : if (e->f && exps_have_rel_exp(e->f))
2609 15 : e->f = exp_rel_update_exps(sql, e->f, up);
2610 : return e;
2611 : case e_column:
2612 : return e;
2613 : }
2614 : return e;
2615 : }
2616 :
2617 : sql_exp *
2618 4165 : exp_rel_label(mvc *sql, sql_exp *e)
2619 : {
2620 4165 : if (exp_is_rel(e))
2621 4165 : e->l = rel_label(sql, e->l, 1);
2622 4165 : return e;
2623 : }
2624 :
2625 : int
2626 150876 : exps_are_atoms( list *exps)
2627 : {
2628 150876 : int atoms = 1;
2629 150876 : if (!list_empty(exps))
2630 436391 : for(node *n=exps->h; n && atoms; n=n->next)
2631 316826 : atoms &= exp_is_atom(n->data);
2632 150876 : return atoms;
2633 : }
2634 :
2635 : int
2636 142 : exps_have_func(list *exps)
2637 : {
2638 142 : if (list_empty(exps))
2639 : return 0;
2640 173 : for(node *n=exps->h; n; n=n->next) {
2641 146 : sql_exp *e = n->data;
2642 :
2643 146 : if (exp_has_func(e))
2644 : return 1;
2645 : }
2646 : return 0;
2647 : }
2648 :
2649 : static int exp_has_func_or_cmp(sql_exp *e, bool cmp);
2650 :
2651 : static int
2652 69583 : exps_have_func_or_cmp(list *exps, bool cmp)
2653 : {
2654 69583 : if (list_empty(exps))
2655 : return 0;
2656 200115 : for(node *n=exps->h; n; n=n->next) {
2657 139830 : sql_exp *e = n->data;
2658 :
2659 139830 : if (exp_has_func_or_cmp(e, cmp))
2660 : return 1;
2661 : }
2662 : return 0;
2663 : }
2664 :
2665 : static int
2666 2091500 : exp_has_func_or_cmp(sql_exp *e, bool cmp)
2667 : {
2668 2091500 : if (!e)
2669 : return 0;
2670 2091500 : switch (e->type) {
2671 311235 : case e_atom:
2672 311235 : if (e->f)
2673 0 : return exps_have_func_or_cmp(e->f, true);
2674 : return 0;
2675 16627 : case e_convert:
2676 : {
2677 16627 : sql_subtype *t = exp_totype(e);
2678 16627 : sql_subtype *f = exp_fromtype(e);
2679 16627 : if (t->type->eclass == EC_FLT && (f->type->eclass == EC_DEC || f->type->eclass == EC_NUM))
2680 170 : return exp_has_func_or_cmp(e->l, cmp);
2681 16457 : if (f->type->localtype > t->type->localtype)
2682 : return true;
2683 : }
2684 14253 : return exp_has_func_or_cmp(e->l, cmp);
2685 : case e_func:
2686 : return 1;
2687 20686 : case e_aggr:
2688 20686 : if (e->l)
2689 17859 : return exps_have_func_or_cmp(e->l, true);
2690 : return 0;
2691 273161 : case e_cmp:
2692 273161 : if (cmp)
2693 : return 1;
2694 263976 : if (e->flag == cmp_or || e->flag == cmp_filter) {
2695 22092 : return (exps_have_func_or_cmp(e->l, true) || exps_have_func_or_cmp(e->r, true));
2696 251103 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
2697 35254 : return (exp_has_func_or_cmp(e->l, true) || exps_have_func_or_cmp(e->r, true));
2698 : } else {
2699 431810 : return (exp_has_func_or_cmp(e->l, true) || exp_has_func_or_cmp(e->r, true) ||
2700 200714 : (e->f && exp_has_func_or_cmp(e->f, true)));
2701 : }
2702 : case e_column:
2703 : case e_psm:
2704 : return 0;
2705 : }
2706 : return 0;
2707 : }
2708 :
2709 : int
2710 1482614 : exp_has_func(sql_exp *e)
2711 : {
2712 1482614 : return exp_has_func_or_cmp(e, false);
2713 : }
2714 :
2715 : static int
2716 731503 : exps_have_sideeffect( list *exps)
2717 : {
2718 731503 : node *n;
2719 731503 : int has_sideeffect = 0;
2720 :
2721 2246280 : for(n=exps->h; n && !has_sideeffect; n=n->next)
2722 1514776 : has_sideeffect |= exp_has_sideeffect(n->data);
2723 731504 : return has_sideeffect;
2724 : }
2725 :
2726 : int
2727 1701811 : exp_has_sideeffect( sql_exp *e )
2728 : {
2729 1726771 : switch (e->type) {
2730 24960 : case e_convert:
2731 24960 : return exp_has_sideeffect(e->l);
2732 731519 : case e_func:
2733 : {
2734 731519 : sql_subfunc *f = e->f;
2735 :
2736 731519 : if (f->func->side_effect)
2737 : return 1;
2738 731505 : if (e->l)
2739 731503 : return exps_have_sideeffect(e->l);
2740 : return 0;
2741 : }
2742 479858 : case e_atom:
2743 479858 : if (e->f)
2744 0 : return exps_have_sideeffect(e->f);
2745 : return 0;
2746 : case e_aggr:
2747 : case e_cmp:
2748 : case e_column:
2749 : case e_psm:
2750 : return 0;
2751 : }
2752 : return 0;
2753 : }
2754 :
2755 : bool
2756 1060711 : exps_have_unsafe(list *exps, bool allow_identity, bool card)
2757 : {
2758 1060711 : int unsafe = 0;
2759 :
2760 1060711 : if (list_empty(exps))
2761 : return 0;
2762 3698160 : for (node *n = exps->h; n && !unsafe; n = n->next)
2763 2658159 : unsafe |= exp_unsafe(n->data, allow_identity, card);
2764 1040001 : return unsafe;
2765 : }
2766 :
2767 : bool
2768 12747621 : exp_unsafe(sql_exp *e, bool allow_identity, bool card)
2769 : {
2770 12747621 : switch (e->type) {
2771 792210 : case e_convert:
2772 792210 : if (card) {
2773 9039 : sql_subtype *t = exp_totype(e);
2774 9039 : sql_subtype *f = exp_fromtype(e);
2775 9039 : if (t->type->eclass == EC_FLT && (f->type->eclass == EC_DEC || f->type->eclass == EC_NUM))
2776 : return false;
2777 8954 : if (f->type->localtype > t->type->localtype)
2778 : return true;
2779 : return false;
2780 : }
2781 783171 : return exp_unsafe(e->l, allow_identity, card);
2782 995588 : case e_aggr:
2783 : case e_func: {
2784 995588 : sql_subfunc *f = e->f;
2785 :
2786 995588 : if (IS_ANALYTIC(f->func) || !LANG_INT_OR_MAL(f->func->lang) || f->func->side_effect || (!allow_identity && is_identity(e, NULL)))
2787 45610 : return 1;
2788 949978 : return exps_have_unsafe(e->l, allow_identity, card);
2789 51599 : } break;
2790 51599 : case e_cmp: {
2791 51599 : if (e->flag == cmp_in || e->flag == cmp_notin) {
2792 6551 : return exp_unsafe(e->l, allow_identity, card) || exps_have_unsafe(e->r, allow_identity, card);
2793 45048 : } else if (e->flag == cmp_or || e->flag == cmp_filter) {
2794 10341 : return exps_have_unsafe(e->l, allow_identity, card) || exps_have_unsafe(e->r, allow_identity, card);
2795 : } else {
2796 69446 : return exp_unsafe(e->l, allow_identity, card) || exp_unsafe(e->r, allow_identity, card) || (e->f && exp_unsafe(e->f, allow_identity, card));
2797 : }
2798 1158838 : } break;
2799 1158838 : case e_atom: {
2800 1158838 : if (e->f)
2801 8331 : return exps_have_unsafe(e->f, allow_identity, card);
2802 : return 0;
2803 : } break;
2804 : case e_column:
2805 : case e_psm:
2806 : return 0;
2807 : }
2808 : return 0;
2809 : }
2810 :
2811 : static inline int
2812 3560906 : exp_key( sql_exp *e )
2813 : {
2814 3560906 : if (e->alias.name)
2815 3560905 : return hash_key(e->alias.name);
2816 : return 0;
2817 : }
2818 :
2819 : sql_exp *
2820 82 : exps_uses_nid(list *exps, int nid)
2821 : {
2822 82 : if (exps) {
2823 153 : for (node *en = exps->h; en; en = en->next ) {
2824 147 : sql_exp *e = en->data;
2825 :
2826 147 : if (e->nid == nid)
2827 76 : return e;
2828 : }
2829 : }
2830 : return NULL;
2831 : }
2832 :
2833 : sql_exp *
2834 71473571 : exps_bind_nid(list *exps, int nid)
2835 : {
2836 71473571 : if (exps) {
2837 5431838293 : for (node *en = exps->h; en; en = en->next ) {
2838 5389894144 : sql_exp *e = en->data;
2839 :
2840 5389894144 : if (e->alias.label == nid)
2841 29160131 : return e;
2842 : }
2843 : }
2844 : return NULL;
2845 : }
2846 :
2847 : sql_exp *
2848 1009598 : exps_bind_column(list *exps, const char *cname, int *ambiguous, int *multiple, int no_tname)
2849 : {
2850 1009598 : sql_exp *res = NULL;
2851 :
2852 1009598 : if (exps && cname) {
2853 1009597 : node *en;
2854 :
2855 1009597 : if (exps) {
2856 1009597 : if (!exps->ht && list_length(exps) > HASH_MIN_SIZE) {
2857 110663 : exps->ht = hash_new(exps->sa, list_length(exps), (fkeyvalue)&exp_key);
2858 110663 : if (exps->ht == NULL)
2859 : return NULL;
2860 834412 : for (en = exps->h; en; en = en->next ) {
2861 723749 : sql_exp *e = en->data;
2862 723749 : if (e->alias.name) {
2863 723749 : int key = exp_key(e);
2864 :
2865 723749 : if (hash_add(exps->ht, key, e) == NULL)
2866 : return NULL;
2867 : }
2868 : }
2869 : }
2870 1009597 : if (exps->ht) {
2871 432013 : int key = hash_key(cname);
2872 432013 : sql_hash_e *he = exps->ht->buckets[key&(exps->ht->size-1)];
2873 :
2874 835932 : for (; he; he = he->chain) {
2875 403923 : sql_exp *e = he->value;
2876 :
2877 403923 : if (e->alias.name && strcmp(e->alias.name, cname) == 0 && (!no_tname || !e->alias.rname)) {
2878 143092 : if (res && multiple)
2879 4 : *multiple = 1;
2880 143092 : if (!res)
2881 143092 : res = e;
2882 :
2883 143092 : if (res && res != e && e->alias.rname && res->alias.rname && strcmp(e->alias.rname, res->alias.rname) != 0 ) {
2884 4 : if (ambiguous)
2885 4 : *ambiguous = 1;
2886 4 : return NULL;
2887 : }
2888 : res = e;
2889 : }
2890 : }
2891 432009 : return res;
2892 : }
2893 : }
2894 1689310 : for (en = exps->h; en; en = en->next ) {
2895 1111731 : sql_exp *e = en->data;
2896 :
2897 1111731 : if (e->alias.name && strcmp(e->alias.name, cname) == 0 && (!no_tname || !e->alias.rname)) {
2898 63762 : if (res && multiple)
2899 8 : *multiple = 1;
2900 63762 : if (!res)
2901 63762 : res = e;
2902 :
2903 63762 : if (res && res != e && e->alias.rname && res->alias.rname && strcmp(e->alias.rname, res->alias.rname) != 0 ) {
2904 5 : if (ambiguous)
2905 5 : *ambiguous = 1;
2906 5 : return NULL;
2907 : }
2908 : res = e;
2909 : }
2910 : }
2911 : }
2912 : return res;
2913 : }
2914 :
2915 : sql_exp *
2916 1751800 : exps_bind_column2(list *exps, const char *rname, const char *cname, int *multiple)
2917 : {
2918 1751800 : sql_exp *res = NULL;
2919 :
2920 1751800 : if (exps) {
2921 1751770 : node *en;
2922 :
2923 1751770 : if (!exps->ht && list_length(exps) > HASH_MIN_SIZE) {
2924 130509 : exps->ht = hash_new(exps->sa, list_length(exps), (fkeyvalue)&exp_key);
2925 130509 : if (exps->ht == NULL)
2926 : return res;
2927 :
2928 2181245 : for (en = exps->h; en; en = en->next ) {
2929 2050736 : sql_exp *e = en->data;
2930 2050736 : if (e->alias.name) {
2931 2050736 : int key = exp_key(e);
2932 :
2933 2050736 : if (hash_add(exps->ht, key, e) == NULL)
2934 : return res;
2935 : }
2936 : }
2937 : }
2938 1751769 : if (exps->ht) {
2939 1036812 : int key = hash_key(cname);
2940 1036812 : sql_hash_e *he = exps->ht->buckets[key&(exps->ht->size-1)];
2941 :
2942 2890766 : for (; he; he = he->chain) {
2943 1856066 : sql_exp *e = he->value;
2944 :
2945 1856066 : if (e && e->alias.name && e->alias.rname && strcmp(e->alias.name, cname) == 0 && strcmp(e->alias.rname, rname) == 0) {
2946 761265 : if (res && multiple)
2947 0 : *multiple = 1;
2948 761265 : if (!res)
2949 : res = e;
2950 761265 : if (res && has_label(res)) /* aliases maybe used multiple times without problems */
2951 2112 : return res;
2952 : }
2953 : }
2954 1034700 : return res;
2955 : }
2956 2439948 : for (en = exps->h; en; en = en->next ) {
2957 1732186 : sql_exp *e = en->data;
2958 :
2959 1732186 : if (e && e->alias.name && e->alias.rname && strcmp(e->alias.name, cname) == 0 && strcmp(e->alias.rname, rname) == 0) {
2960 491127 : if (res && multiple)
2961 1 : *multiple = 1;
2962 491127 : if (!res)
2963 : res = e;
2964 491127 : if (res && has_label(res)) /* aliases maybe used multiple times without problems */
2965 7195 : return res;
2966 : }
2967 : }
2968 : }
2969 : return res;
2970 : }
2971 :
2972 : /* find an column based on the original name, not the alias it got */
2973 : sql_exp *
2974 0 : exps_bind_alias( list *exps, const char *rname, const char *cname )
2975 : {
2976 0 : if (exps) {
2977 0 : node *en;
2978 :
2979 0 : for (en = exps->h; en; en = en->next ) {
2980 0 : sql_exp *e = en->data;
2981 :
2982 0 : if (e && is_column(e->type) && !rname && e->r && strcmp(e->r, cname) == 0)
2983 : {
2984 0 : assert(0);
2985 : return e;
2986 : }
2987 0 : if (e && e->type == e_column && rname && e->l && e->r && strcmp(e->r, cname) == 0 && strcmp(e->l, rname) == 0) {
2988 0 : assert(0);
2989 : return e;
2990 : }
2991 : }
2992 : }
2993 0 : return NULL;
2994 : }
2995 :
2996 : unsigned int
2997 3282291 : exps_card( list *l )
2998 : {
2999 3282291 : node *n;
3000 3282291 : unsigned int card = CARD_ATOM;
3001 :
3002 14686653 : if (l) for(n = l->h; n; n = n->next) {
3003 11404362 : sql_exp *e = n->data;
3004 :
3005 11404362 : if (e && card < e->card)
3006 11404362 : card = e->card;
3007 : }
3008 3282291 : return card;
3009 : }
3010 :
3011 : void
3012 43063 : exps_fix_card( list *exps, unsigned int card)
3013 : {
3014 43063 : if (exps)
3015 1069971 : for (node *n = exps->h; n; n = n->next) {
3016 1026908 : sql_exp *e = n->data;
3017 :
3018 1026908 : if (e && e->card > card)
3019 0 : e->card = card;
3020 : }
3021 43063 : }
3022 :
3023 : void
3024 6102 : exps_setcard( list *exps, unsigned int card)
3025 : {
3026 6102 : if (exps)
3027 31231 : for (node *n = exps->h; n; n = n->next) {
3028 25129 : sql_exp *e = n->data;
3029 :
3030 25129 : if (e && e->card != CARD_ATOM)
3031 25098 : e->card = card;
3032 : }
3033 6102 : }
3034 :
3035 : int
3036 0 : exps_intern(list *exps)
3037 : {
3038 0 : if (exps)
3039 0 : for (node *n=exps->h; n; n = n->next) {
3040 0 : sql_exp *e = n->data;
3041 :
3042 0 : if (is_intern(e))
3043 : return 1;
3044 : }
3045 : return 0;
3046 : }
3047 :
3048 : sql_exp *
3049 3689 : exps_find_one_multi_exp(list *exps)
3050 : {
3051 3689 : sql_exp *l = NULL;
3052 3689 : int skip = 0;
3053 :
3054 : /* Find one and only 1 expression with card > CARD_ATOM */
3055 3689 : if (!list_empty(exps)) {
3056 7469 : for (node *m = exps->h ; m && !skip ; m = m->next) {
3057 3780 : sql_exp *e = m->data;
3058 :
3059 3780 : if (e->card > CARD_ATOM) {
3060 3693 : skip |= l != NULL;
3061 3693 : l = e;
3062 : }
3063 : }
3064 : }
3065 3689 : if (skip)
3066 5 : l = NULL;
3067 3689 : return l;
3068 : }
3069 :
3070 : const char *
3071 130697 : compare_func( comp_type t, int anti )
3072 : {
3073 130697 : switch(t) {
3074 75510 : case cmp_equal:
3075 75510 : return anti?"<>":"=";
3076 8131 : case cmp_lt:
3077 8131 : return anti?">":"<";
3078 2106 : case cmp_lte:
3079 2106 : return anti?">=":"<=";
3080 1166 : case cmp_gte:
3081 1166 : return anti?"<=":">=";
3082 31716 : case cmp_gt:
3083 31716 : return anti?"<":">";
3084 12068 : case cmp_notequal:
3085 12068 : return anti?"=":"<>";
3086 : default:
3087 : return NULL;
3088 : }
3089 : }
3090 :
3091 : int
3092 9689238 : is_identity( sql_exp *e, sql_rel *r)
3093 : {
3094 9700114 : switch(e->type) {
3095 38029 : case e_column:
3096 38029 : if (r && is_project(r->op) && !is_set(r->op)) {
3097 13705 : sql_exp *re = NULL;
3098 13705 : assert(e->nid);
3099 13705 : re = exps_bind_nid(r->exps, e->nid);
3100 13705 : if (re)
3101 10876 : return is_identity(re, r->l);
3102 : }
3103 : return 0;
3104 9655043 : case e_func: {
3105 9655043 : sql_subfunc *f = e->f;
3106 9655043 : return !f->func->s && strcmp(f->func->base.name, "identity") == 0;
3107 : }
3108 : default:
3109 : return 0;
3110 : }
3111 : }
3112 :
3113 : list *
3114 16 : exps_alias(mvc *sql, list *exps)
3115 : {
3116 16 : list *nl = new_exp_list(sql->sa);
3117 :
3118 16 : if (exps)
3119 68 : for (node *n = exps->h; n; n = n->next) {
3120 52 : sql_exp *e = n->data, *ne;
3121 :
3122 52 : assert(exp_name(e));
3123 52 : ne = exp_ref(sql, e);
3124 52 : append(nl, ne);
3125 : }
3126 16 : return nl;
3127 : }
3128 :
3129 : list *
3130 143256 : exps_copy(mvc *sql, list *exps)
3131 : {
3132 143256 : list *nl;
3133 :
3134 143256 : if (mvc_highwater(sql))
3135 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3136 :
3137 143256 : if (!exps)
3138 : return NULL;
3139 124822 : nl = new_exp_list(sql->sa);
3140 572076 : for (node *n = exps->h; n; n = n->next) {
3141 447254 : sql_exp *arg = n->data;
3142 :
3143 447254 : arg = exp_copy(sql, arg);
3144 447254 : if (!arg)
3145 : return NULL;
3146 447254 : append(nl, arg);
3147 : }
3148 : return nl;
3149 : }
3150 :
3151 : sql_exp *
3152 2696977 : exp_copy(mvc *sql, sql_exp * e)
3153 : {
3154 2696977 : sql_exp *l, *r, *r2, *ne = NULL;
3155 :
3156 2696977 : if (mvc_highwater(sql))
3157 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3158 :
3159 2696977 : if (!e)
3160 : return NULL;
3161 2696977 : switch(e->type){
3162 2314960 : case e_column:
3163 2314960 : ne = exp_column(sql->sa, e->l, e->r, exp_subtype(e), e->card, has_nil(e), is_unique(e), is_intern(e));
3164 2314960 : ne->flag = e->flag;
3165 2314960 : ne->alias.label = e->alias.label;
3166 2314960 : ne->nid = e->nid;
3167 2314960 : break;
3168 42369 : case e_cmp:
3169 42369 : if (e->flag == cmp_or || e->flag == cmp_filter) {
3170 2683 : list *l = exps_copy(sql, e->l);
3171 2683 : list *r = exps_copy(sql, e->r);
3172 :
3173 2683 : if (e->flag == cmp_filter)
3174 688 : ne = exp_filter(sql->sa, l, r, e->f, is_anti(e));
3175 : else
3176 1995 : ne = exp_or(sql->sa, l, r, is_anti(e));
3177 39686 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
3178 1432 : sql_exp *l = exp_copy(sql, e->l);
3179 1432 : list *r = exps_copy(sql, e->r);
3180 :
3181 1432 : ne = exp_in(sql->sa, l, r, e->flag);
3182 : } else {
3183 38254 : l = exp_copy(sql, e->l);
3184 38254 : r = exp_copy(sql, e->r);
3185 :
3186 38254 : if (e->f) {
3187 691 : r2 = exp_copy(sql, e->f);
3188 691 : ne = exp_compare2(sql->sa, l, r, r2, e->flag, is_symmetric(e));
3189 : } else {
3190 37563 : ne = exp_compare(sql->sa, l, r, e->flag);
3191 : }
3192 : }
3193 : break;
3194 29096 : case e_convert:
3195 29096 : ne = exp_convert(sql, exp_copy(sql, e->l), exp_fromtype(e), exp_totype(e));
3196 29096 : break;
3197 13779 : case e_aggr:
3198 : case e_func: {
3199 13779 : list *l = exps_copy(sql, e->l);
3200 :
3201 13779 : if (e->type == e_func)
3202 11835 : ne = exp_op(sql->sa, l, e->f);
3203 : else
3204 1944 : ne = exp_aggr(sql->sa, l, e->f, need_distinct(e), need_no_nil(e), e->card, has_nil(e));
3205 13779 : if (e->r) { /* copy obe and gbe lists */
3206 1 : list *er = (list*) e->r;
3207 1 : assert(list_length(er) <= 2);
3208 1 : if (list_length(er) == 2)
3209 0 : ne->r = list_append(list_append(sa_list(sql->sa), exps_copy(sql, er->h->data)), exps_copy(sql, er->h->next->data));
3210 : else
3211 1 : ne->r = list_append(sa_list(sql->sa), exps_copy(sql, er->h->data));
3212 : }
3213 : break;
3214 : }
3215 296769 : case e_atom:
3216 296769 : if (e->l)
3217 291867 : ne = exp_atom(sql->sa, e->l);
3218 4902 : else if (e->r) {
3219 3586 : sql_var_name *vname = (sql_var_name*) e->r;
3220 3586 : ne = exp_param_or_declared(sql->sa, vname->sname, vname->name, &e->tpe, e->flag);
3221 1316 : } else if (e->f)
3222 759 : ne = exp_values(sql->sa, exps_copy(sql, e->f));
3223 : else
3224 557 : ne = exp_atom_ref(sql->sa, e->flag, &e->tpe);
3225 : break;
3226 4 : case e_psm:
3227 4 : if (e->flag & PSM_SET) {
3228 0 : ne = exp_set(sql->sa, e->alias.rname, e->alias.name, exp_copy(sql, e->l), GET_PSM_LEVEL(e->flag));
3229 4 : } else if (e->flag & PSM_VAR) {
3230 0 : if (e->f)
3231 0 : ne = exp_table(sql->sa, e->alias.name, e->f, GET_PSM_LEVEL(e->flag));
3232 : else
3233 0 : ne = exp_var(sql->sa, e->alias.rname, e->alias.name, &e->tpe, GET_PSM_LEVEL(e->flag));
3234 4 : } else if (e->flag & PSM_RETURN) {
3235 0 : ne = exp_return(sql->sa, exp_copy(sql, e->l), GET_PSM_LEVEL(e->flag));
3236 4 : } else if (e->flag & PSM_WHILE) {
3237 0 : ne = exp_while(sql->sa, exp_copy(sql, e->l), exps_copy(sql, e->r));
3238 4 : } else if (e->flag & PSM_IF) {
3239 0 : ne = exp_if(sql->sa, exp_copy(sql, e->l), exps_copy(sql, e->r), exps_copy(sql, e->f));
3240 4 : } else if (e->flag & PSM_REL) {
3241 4 : if (!e->alias.label)
3242 4 : exp_label(sql->sa, e, ++sql->label);
3243 4 : return exp_ref(sql, e);
3244 0 : } else if (e->flag & PSM_EXCEPTION) {
3245 0 : ne = exp_exception(sql->sa, exp_copy(sql, e->l), (const char *) e->r);
3246 : }
3247 : break;
3248 : }
3249 2696973 : if (!ne)
3250 0 : return ne;
3251 2696973 : if (e->alias.name)
3252 2473561 : exp_prop_alias(sql->sa, ne, e);
3253 2696973 : ne = exp_propagate(sql->sa, ne, e);
3254 2696973 : if (is_freevar(e))
3255 8333 : set_freevar(ne, is_freevar(e)-1);
3256 : return ne;
3257 : }
3258 :
3259 : /* scaling for the division operator */
3260 : static sql_exp *
3261 2613 : exp_scale_algebra(mvc *sql, sql_subfunc *f, sql_rel *rel, sql_exp *l, sql_exp *r)
3262 : {
3263 2613 : sql_subtype *lt = exp_subtype(l);
3264 2613 : sql_subtype *rt = exp_subtype(r);
3265 :
3266 2613 : if (!EC_INTERVAL(lt->type->eclass) && lt->type->scale == SCALE_FIX &&
3267 2561 : (lt->scale || rt->scale) && strcmp(sql_func_imp(f->func), "/") == 0) {
3268 170 : sql_subtype *res = f->res->h->data;
3269 170 : unsigned int scale, digits, digL, scaleL;
3270 170 : sql_subtype nlt;
3271 :
3272 : /* scale fixing may require a larger type ! */
3273 170 : scaleL = (lt->scale < sql->div_min_scale) ? sql->div_min_scale : lt->scale;
3274 170 : scaleL += (scaleL < rt->scale) ? rt->scale - scaleL : 0;
3275 170 : scale = scaleL;
3276 170 : scaleL += rt->scale;
3277 170 : digL = lt->digits + (scaleL - lt->scale);
3278 170 : digits = (digL > rt->digits) ? digL : rt->digits;
3279 :
3280 : /* HACK alert: digits should be less than max */
3281 : #ifdef HAVE_HGE
3282 170 : if (res->type->radix == 10 && digits > 38)
3283 170 : digits = 38;
3284 170 : if (res->type->radix == 2 && digits > 127)
3285 170 : digits = 127;
3286 : #else
3287 : if (res->type->radix == 10 && digits > 18)
3288 : digits = 18;
3289 : if (res->type->radix == 2 && digits > 63)
3290 : digits = 63;
3291 : #endif
3292 :
3293 170 : sql_find_subtype(&nlt, lt->type->base.name, digL, scaleL);
3294 170 : if (nlt.digits < scaleL)
3295 2 : return sql_error(sql, 01, SQLSTATE(42000) "Scale (%d) overflows type", scaleL);
3296 168 : l = exp_check_type(sql, &nlt, rel, l, type_equal);
3297 :
3298 168 : sql_find_subtype(res, lt->type->base.name, digits, scale);
3299 2443 : } else if (lt->type->scale == SCALE_FIX) {
3300 2244 : sql_subtype *res = f->res->h->data;
3301 2244 : if (res->type->eclass == EC_NUM)
3302 2223 : res->digits = MAX(lt->digits, rt->digits);
3303 : }
3304 : return l;
3305 : }
3306 :
3307 : sql_exp *
3308 2613 : exps_scale_algebra(mvc *sql, sql_subfunc *f, sql_rel *rel, list *exps)
3309 : {
3310 2613 : if (list_length(exps) != 2)
3311 : return NULL;
3312 2613 : sql_exp *e = exp_scale_algebra(sql, f, rel, exps->h->data, exps->h->next->data);
3313 2613 : if (e)
3314 2611 : exps->h->data = e;
3315 : return e;
3316 : }
3317 :
3318 : void
3319 186616 : exps_digits_add(sql_subfunc *f, list *exps)
3320 : {
3321 : /* concat and friends need larger results */
3322 186616 : if (!f->func->res)
3323 : return;
3324 186616 : int digits = 0;
3325 332051 : for(node *n = exps->h; n; n = n->next) {
3326 271866 : sql_subtype *t = exp_subtype(n->data);
3327 :
3328 271866 : if (!t->digits) {
3329 : digits = 0;
3330 : break;
3331 : }
3332 145435 : digits += t->digits;
3333 : }
3334 186616 : sql_subtype *res = f->res->h->data;
3335 186616 : res->digits = digits;
3336 : }
3337 :
3338 : void
3339 25254 : exps_sum_scales(sql_subfunc *f, list *exps)
3340 : {
3341 : /* sum scales and digits for multiply operation */
3342 25254 : sql_arg *ares = f->func->res->h->data;
3343 :
3344 25254 : if (ares->type.type->scale == SCALE_FIX && strcmp(sql_func_imp(f->func), "*") == 0) {
3345 23957 : unsigned int digits = 0, scale = 0;
3346 23957 : sql_type *largesttype = ares->type.type;
3347 :
3348 71871 : for(node *n = exps->h; n; n = n->next) {
3349 47914 : sql_exp *e = n->data;
3350 47914 : sql_subtype *t = exp_subtype(e);
3351 :
3352 47914 : scale += t->scale;
3353 47914 : digits += t->digits;
3354 47914 : if (largesttype->localtype < t->type->localtype)
3355 0 : largesttype = t->type;
3356 : }
3357 23957 : sql_subtype *res = f->res->h->data;
3358 :
3359 23957 : res->scale = scale;
3360 23957 : res->digits = digits;
3361 :
3362 : /* HACK alert: digits should be less than max */
3363 : #ifdef HAVE_HGE
3364 23957 : if (ares->type.type->radix == 10 && res->digits > 38) {
3365 2483 : res->digits = 38;
3366 2483 : res->scale = MIN(res->scale, res->digits - 1);
3367 : }
3368 23957 : if (ares->type.type->radix == 2 && res->digits > 127) {
3369 25 : res->digits = 127;
3370 25 : res->scale = MIN(res->scale, res->digits - 1);
3371 : }
3372 : #else
3373 : if (ares->type.type->radix == 10 && res->digits > 18) {
3374 : res->digits = 18;
3375 : res->scale = MIN(res->scale, res->digits - 1);
3376 : }
3377 : if (ares->type.type->radix == 2 && res->digits > 63) {
3378 : res->digits = 63;
3379 : res->scale = MIN(res->scale, res->digits - 1);
3380 : }
3381 : #endif
3382 :
3383 23957 : sql_subtype t;
3384 : /* numeric types are fixed length */
3385 23957 : if (ares->type.type->eclass == EC_NUM) {
3386 : #ifdef HAVE_HGE
3387 21186 : if (ares->type.type->localtype == TYPE_hge && res->digits == 127)
3388 25 : t = *sql_bind_localtype("hge");
3389 : else
3390 : #endif
3391 21161 : if (ares->type.type->localtype == TYPE_lng && res->digits == 63)
3392 3 : t = *sql_bind_localtype("lng");
3393 21158 : else if (res->type->digits >= res->digits)
3394 8856 : t = *res; /* we cannot reduce types! */
3395 : else
3396 12302 : sql_find_numeric(&t, ares->type.type->localtype, res->digits);
3397 : } else {
3398 2771 : if (res->digits > largesttype->digits)
3399 215 : sql_find_subtype(&t, largesttype->base.name, res->digits, res->scale);
3400 : else
3401 2556 : sql_init_subtype(&t, largesttype, res->digits, res->scale);
3402 : }
3403 23957 : *res = t;
3404 : }
3405 25254 : }
3406 :
3407 : void
3408 113665 : exps_max_bits(sql_subfunc *f, list *exps)
3409 : {
3410 : /* + and - have max_bits + 1 */
3411 113665 : if (!f->func->res)
3412 : return;
3413 113665 : unsigned int digits = 0;
3414 340995 : for(node *n = exps->h; n; n = n->next) {
3415 227330 : sql_subtype *t = exp_subtype(n->data);
3416 :
3417 227330 : if (!t)
3418 0 : continue;
3419 227330 : if (digits < t->digits)
3420 227330 : digits = t->digits;
3421 : }
3422 : /* + and - (because of negative numbers) could need one extra bit (or digit) */
3423 113665 : digits += 1;
3424 113665 : sql_subtype *res = f->res->h->data;
3425 113665 : if (digits > res->type->digits)
3426 49126 : res = sql_find_numeric(res, res->type->localtype, digits);
3427 : else
3428 64539 : res->digits = digits;
3429 : }
3430 :
3431 : void
3432 19444 : exps_inout(sql_subfunc *f, list *exps)
3433 : {
3434 : /* output == first input */
3435 19444 : if (!f->func->res)
3436 : return;
3437 19444 : sql_subtype *res = f->res->h->data;
3438 19444 : bool is_decimal = (res->type->eclass == EC_DEC);
3439 19444 : unsigned int digits = 0, scale = 0;
3440 19444 : sql_type *largesttype = NULL;
3441 19444 : for(node *n = exps->h; n; n = n->next) {
3442 19444 : sql_subtype *t = exp_subtype(n->data);
3443 :
3444 19444 : if (!t)
3445 0 : continue;
3446 :
3447 19444 : if (is_decimal && t->type->eclass == EC_DEC && (!largesttype || largesttype->localtype < t->type->localtype))
3448 390 : largesttype = t->type;
3449 390 : if (is_decimal && t->type->eclass == EC_NUM) {
3450 0 : unsigned int d = bits2digits(t->digits);
3451 0 : digits = d>digits?d:digits;
3452 19444 : } else if (digits < t->digits)
3453 : digits = t->digits;
3454 19444 : if (scale < t->scale)
3455 : scale = t->scale;
3456 : break;
3457 : }
3458 19444 : if (digits > res->digits || scale > res->scale) {
3459 9429 : if (largesttype)
3460 376 : sql_init_subtype(res, largesttype, digits, scale);
3461 : else
3462 9053 : sql_find_subtype(res, res->type->base.name, digits, scale);
3463 : } else
3464 10015 : res->digits = digits;
3465 : }
3466 :
3467 : /* for aggregates we can reduce the result types size based on real digits/bits used number of known input rows */
3468 : void
3469 9385 : exps_largest_int(sql_subfunc *f, list *exps, lng cnt)
3470 : {
3471 9385 : if (!f->func->res || cnt == 0)
3472 : return;
3473 568 : sql_subtype *res = f->res->h->data;
3474 568 : if (res->type->eclass != EC_DEC && res->type->eclass != EC_NUM)
3475 : return;
3476 492 : bool is_decimal = (res->type->eclass == EC_DEC);
3477 492 : unsigned int digits = 0, scale = 0, mdigits = is_decimal ? decimal_digits(cnt) : number_bits(cnt);
3478 492 : sql_type *largesttype = NULL;
3479 492 : for(node *n = exps->h; n; n = n->next) {
3480 492 : sql_subtype *t = exp_subtype(n->data);
3481 :
3482 492 : if (!t)
3483 0 : continue;
3484 :
3485 492 : largesttype = t->type;
3486 492 : if (is_decimal && t->type->eclass == EC_NUM) {
3487 0 : unsigned int d = bits2digits(t->digits);
3488 0 : digits = d>digits?d:digits;
3489 492 : } else if (digits < t->digits)
3490 : digits = t->digits;
3491 492 : if (scale < t->scale)
3492 : scale = t->scale;
3493 : break;
3494 : }
3495 492 : digits += mdigits;
3496 492 : if (largesttype && digits <= largesttype->digits)
3497 419 : sql_init_subtype(res, largesttype, digits, scale);
3498 73 : else if (is_decimal)
3499 8 : sql_find_subtype(res, res->type->base.name, digits, scale);
3500 : else
3501 65 : sql_find_numeric(res, 1, digits);
3502 : }
3503 :
3504 : #define is_addition(fname) (strcmp(fname, "sql_add") == 0)
3505 : #define is_subtraction(fname) (strcmp(fname, "sql_sub") == 0)
3506 : void
3507 269501 : exps_scale_fix(sql_subfunc *f, list *exps, sql_subtype *atp)
3508 : {
3509 269501 : if (!f->func->res)
3510 : return;
3511 :
3512 269501 : sql_subtype *res = f->res->h->data;
3513 269501 : if (res->type->eclass != EC_ANY && res->type->eclass != EC_DEC)
3514 : return;
3515 :
3516 61208 : unsigned int digits = 0, scale = 0;
3517 61208 : sql_type *largesttype = NULL;
3518 241771 : for(node *n = exps->h; n; n = n->next) {
3519 180563 : sql_subtype *t = exp_subtype(n->data);
3520 :
3521 180563 : if (!t)
3522 0 : continue;
3523 180563 : if (digits < t->digits)
3524 : digits = t->digits;
3525 180563 : if (scale < t->scale)
3526 : scale = t->scale;
3527 180563 : if (t->type->eclass == EC_DEC && (!largesttype || largesttype->localtype < t->type->localtype))
3528 180563 : largesttype = t->type;
3529 : }
3530 61208 : res->scale = scale;
3531 61208 : if (res->type->eclass == EC_DEC)
3532 646 : digits += (is_addition(f->func->base.name) || is_subtraction(f->func->base.name));
3533 61208 : if (digits > res->type->digits) {
3534 60886 : if (largesttype && largesttype->localtype > res->type->localtype)
3535 75 : sql_init_subtype(res, largesttype, digits, scale);
3536 : else
3537 60811 : sql_find_subtype(res, res->type->localtype?res->type->base.name:atp->type->base.name, digits, scale);
3538 322 : } else if (res->type->eclass == EC_DEC || res->type->eclass == EC_NUM)
3539 252 : res->digits = digits;
3540 : }
3541 :
3542 : int
3543 128935 : exp_aggr_is_count(sql_exp *e)
3544 : {
3545 128935 : if (e->type == e_aggr && !((sql_subfunc *)e->f)->func->s && strcmp(((sql_subfunc *)e->f)->func->base.name, "count") == 0)
3546 35174 : return 1;
3547 : return 0;
3548 : }
3549 :
3550 : list *
3551 68174 : check_distinct_exp_names(mvc *sql, list *exps)
3552 : {
3553 68174 : list *distinct_exps = NULL;
3554 68174 : bool duplicates = false;
3555 :
3556 68174 : if (list_length(exps) < 2) {
3557 : return exps; /* always true */
3558 66288 : } else if (list_length(exps) < 5) {
3559 15084 : distinct_exps = list_distinct(exps, (fcmp) exp_equal, (fdup) NULL);
3560 : } else { /* for longer lists, use hashing */
3561 51204 : sql_hash *ht = hash_new(sql->ta, list_length(exps), (fkeyvalue)&exp_key);
3562 :
3563 504984 : for (node *n = exps->h; n && !duplicates; n = n->next) {
3564 453781 : sql_exp *e = n->data;
3565 453781 : int key = ht->key(e);
3566 453781 : sql_hash_e *he = ht->buckets[key&(ht->size-1)];
3567 :
3568 586167 : for (; he && !duplicates; he = he->chain) {
3569 132385 : sql_exp *f = he->value;
3570 :
3571 132385 : if (!exp_equal(e, f))
3572 0 : duplicates = true;
3573 : }
3574 453782 : hash_add(ht, key, e);
3575 : }
3576 : }
3577 66287 : if ((distinct_exps && list_length(distinct_exps) != list_length(exps)) || duplicates)
3578 1 : return NULL;
3579 : return exps;
3580 : }
3581 :
3582 : static int rel_find_parameter(mvc *sql, sql_subtype *type, sql_rel *rel, int nid, const char *relname, const char *expname);
3583 :
3584 : static int
3585 1634 : set_exp_type(mvc *sql, sql_subtype *type, sql_rel *rel, sql_exp *e)
3586 : {
3587 1640 : if (mvc_highwater(sql)) {
3588 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3589 0 : return -1;
3590 : }
3591 1640 : if (e->type == e_column) {
3592 60 : const char *nrname = (const char*) e->l, *nename = (const char*) e->r;
3593 : /* find all the column references and set the type */
3594 60 : e->tpe = *type;
3595 60 : assert(e->nid);
3596 60 : return rel_find_parameter(sql, type, rel, e->nid, nrname, nename);
3597 1580 : } else if (e->type == e_atom && e->f) {
3598 25 : list *atoms = e->f;
3599 25 : if (!list_empty(atoms))
3600 61 : for (node *n = atoms->h; n; n = n->next)
3601 36 : if (set_exp_type(sql, type, rel, n->data) < 0) /* set recursively */
3602 : return -1;
3603 25 : e->tpe = *type;
3604 25 : return 1; /* on a list of atoms, everything should be found */
3605 1555 : } else if (e->type == e_atom && !e->l && !e->r && !e->f) {
3606 1549 : e->tpe = *type;
3607 1549 : return set_type_param(sql, type, e->flag) == 0 ? 1 : 0;
3608 6 : } else if (exp_is_rel(e)) { /* for relation expressions, restart cycle */
3609 6 : rel = (sql_rel*) e->l;
3610 : /* limiting to these cases */
3611 6 : if (!is_project(rel->op) || list_length(rel->exps) != 1)
3612 0 : return 0;
3613 6 : sql_exp *re = rel->exps->h->data;
3614 :
3615 6 : e->tpe = *type;
3616 6 : return set_exp_type(sql, type, rel, re); /* set recursively */
3617 : }
3618 : return 0;
3619 : }
3620 :
3621 : int
3622 1542 : rel_set_type_param(mvc *sql, sql_subtype *type, sql_rel *rel, sql_exp *exp, int upcast)
3623 : {
3624 1542 : if (!type || !exp || (exp->type != e_atom && exp->type != e_column && !exp_is_rel(exp)))
3625 0 : return -1;
3626 :
3627 : /* use largest numeric types */
3628 1542 : if (upcast && type->type->eclass == EC_NUM)
3629 : #ifdef HAVE_HGE
3630 9 : type = sql_bind_localtype("hge");
3631 : #else
3632 : type = sql_bind_localtype("lng");
3633 : #endif
3634 6 : else if (upcast && type->type->eclass == EC_FLT)
3635 1 : type = sql_bind_localtype("dbl");
3636 :
3637 : /* TODO we could use the sql_query* struct to set parameters used as freevars,
3638 : but it requires to change a lot of interfaces */
3639 : /* if (is_freevar(exp))
3640 : rel = query_fetch_outer(query, is_freevar(exp)-1); */
3641 1542 : return set_exp_type(sql, type, rel, exp);
3642 : }
3643 :
3644 : /* try to do an in-place conversion
3645 : *
3646 : * in-place conversion is only possible if the exp is a variable.
3647 : * This is only done to be able to map more cached queries onto the same
3648 : * interface.
3649 : */
3650 : sql_exp *
3651 5159411 : exp_convert_inplace(mvc *sql, sql_subtype *t, sql_exp *exp)
3652 : {
3653 5159411 : atom *a, *na;
3654 :
3655 : /* exclude named variables and variable lists */
3656 5159411 : if (exp->type != e_atom || exp->r /* named */ || exp->f /* list */ || !exp->l /* not direct atom */)
3657 : return NULL;
3658 :
3659 2964606 : a = exp->l;
3660 2964606 : if (!a->isnull && t->scale && t->type->eclass != EC_FLT)
3661 : return NULL;
3662 :
3663 2959307 : if ((na = atom_cast(sql->sa, a, t))) {
3664 2956190 : exp->l = na;
3665 2956190 : return exp;
3666 : }
3667 : return NULL;
3668 : }
3669 :
3670 : sql_exp *
3671 0 : exp_numeric_supertype(mvc *sql, sql_exp *e )
3672 : {
3673 0 : sql_subtype *tp = exp_subtype(e);
3674 :
3675 0 : if (tp->type->eclass == EC_DEC) {
3676 0 : sql_subtype *dtp = sql_bind_localtype("dbl");
3677 :
3678 0 : return exp_check_type(sql, dtp, NULL, e, type_cast);
3679 : }
3680 0 : if (tp->type->eclass == EC_NUM) {
3681 : #ifdef HAVE_HGE
3682 0 : sql_subtype *ltp = sql_bind_localtype("hge");
3683 : #else
3684 : sql_subtype *ltp = sql_bind_localtype("lng");
3685 : #endif
3686 :
3687 0 : return exp_check_type(sql, ltp, NULL, e, type_cast);
3688 : }
3689 : return e;
3690 : }
3691 :
3692 : sql_exp *
3693 5158763 : exp_check_type(mvc *sql, sql_subtype *t, sql_rel *rel, sql_exp *exp, check_type tpe)
3694 : {
3695 5158763 : int c, err = 0;
3696 5158763 : sql_exp* nexp = NULL;
3697 5158763 : sql_subtype *fromtype = exp_subtype(exp);
3698 :
3699 5159063 : if ((!fromtype || !fromtype->type) && rel_set_type_param(sql, t, rel, exp, 0) == 0)
3700 : return exp;
3701 :
3702 : /* first try cheap internal (in-place) conversions ! */
3703 5159062 : if ((nexp = exp_convert_inplace(sql, t, exp)) != NULL)
3704 : return nexp;
3705 :
3706 2203145 : if (fromtype && subtype_cmp(t, fromtype) != 0) {
3707 264745 : if (EC_INTERVAL(fromtype->type->eclass) && (t->type->eclass == EC_NUM || t->type->eclass == EC_POS) && t->digits < fromtype->digits) {
3708 : err = 1; /* conversion from interval to num depends on the number of digits */
3709 : } else {
3710 264745 : c = sql_type_convert(fromtype->type->eclass, t->type->eclass);
3711 264745 : if (!c || (c == 2 && tpe == type_set) || (c == 3 && tpe != type_cast)) {
3712 : err = 1;
3713 : } else {
3714 264231 : exp = exp_convert(sql, exp, fromtype, t);
3715 : }
3716 : }
3717 : }
3718 264231 : if (err) {
3719 514 : const char *name = (exp->type == e_column && !has_label(exp)) ? exp_name(exp) : "%";
3720 576 : sql_exp *res = sql_error( sql, 03, SQLSTATE(42000) "types %s(%u,%u) and %s(%u,%u) are not equal%s%s%s",
3721 514 : fromtype->type->base.name,
3722 : fromtype->digits,
3723 : fromtype->scale,
3724 514 : t->type->base.name,
3725 : t->digits,
3726 : t->scale,
3727 : (name[0] != '%' ? " for column '" : ""),
3728 : (name[0] != '%' ? name : ""),
3729 514 : (name[0] != '%' ? "'" : "")
3730 : );
3731 514 : return res;
3732 : }
3733 : return exp;
3734 : }
3735 :
3736 : sql_exp *
3737 7198 : exp_values_set_supertype(mvc *sql, sql_exp *values, sql_subtype *opt_super)
3738 : {
3739 7198 : assert(is_values(values));
3740 7198 : list *vals = exp_get_values(values), *nexps;
3741 7198 : sql_subtype *tpe = opt_super?opt_super:exp_subtype(vals->h->data);
3742 :
3743 7198 : if (!opt_super && tpe)
3744 7098 : values->tpe = *tpe;
3745 :
3746 31266 : for (node *m = vals->h; m; m = m->next) {
3747 24068 : sql_exp *e = m->data;
3748 24068 : sql_subtype super, *ttpe;
3749 :
3750 : /* if the expression is a parameter set its type */
3751 24068 : if (tpe && e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
3752 4 : if (set_type_param(sql, tpe, e->flag) == 0)
3753 4 : e->tpe = *tpe;
3754 : else
3755 0 : return NULL;
3756 : }
3757 24068 : ttpe = exp_subtype(e);
3758 24067 : if (tpe && ttpe) {
3759 24015 : supertype(&super, ttpe, tpe);
3760 24016 : values->tpe = super;
3761 24016 : tpe = &values->tpe;
3762 : } else {
3763 : tpe = ttpe;
3764 : }
3765 : }
3766 :
3767 7198 : if (tpe) {
3768 : /* if the expression is a parameter set its type */
3769 31180 : for (node *m = vals->h; m; m = m->next) {
3770 24020 : sql_exp *e = m->data;
3771 24020 : if (e->type == e_atom && !e->l && !e->r && !e->f && !e->tpe.type) {
3772 1 : if (set_type_param(sql, tpe, e->flag) == 0)
3773 1 : e->tpe = *tpe;
3774 : else
3775 : return NULL;
3776 : }
3777 : }
3778 7160 : values->tpe = *tpe;
3779 7160 : nexps = sa_list(sql->sa);
3780 31175 : for (node *m = vals->h; m; m = m->next) {
3781 24018 : sql_exp *e = m->data;
3782 24018 : e = exp_check_type(sql, &values->tpe, NULL, e, type_equal);
3783 24017 : if (!e)
3784 : return NULL;
3785 24014 : exp_label(sql->sa, e, ++sql->label);
3786 24015 : append(nexps, e);
3787 : }
3788 7157 : values->f = nexps;
3789 : }
3790 : return values;
3791 : }
3792 :
3793 : /* return -1 on error, 0 not found, 1 found */
3794 : static int
3795 86 : rel_find_parameter(mvc *sql, sql_subtype *type, sql_rel *rel, int nid, const char *relname, const char *expname)
3796 : {
3797 138 : int res = 0;
3798 :
3799 138 : if (mvc_highwater(sql)) {
3800 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
3801 0 : return -1;
3802 : }
3803 138 : if (!rel)
3804 : return 0;
3805 :
3806 135 : const char *nrname = relname, *nename = expname;
3807 135 : if (is_project(rel->op) && !list_empty(rel->exps)) {
3808 111 : sql_exp *e = NULL;
3809 :
3810 111 : assert(nid);
3811 111 : e = exps_bind_nid(rel->exps, nid);
3812 111 : if (!e)
3813 : return 0; /* not found */
3814 108 : if (is_mset(rel->op)) { /* TODO for set relations this needs further improvement */
3815 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Cannot set parameter types under set relations at the moment");
3816 0 : return -1;
3817 : }
3818 : /* set order by column types */
3819 108 : if (is_simple_project(rel->op) && !list_empty(rel->r)) {
3820 0 : sql_exp *ordere = NULL;
3821 0 : ordere = exps_bind_nid(rel->r, nid);
3822 0 : if (ordere && ordere->type == e_column)
3823 0 : ordere->tpe = *type;
3824 : }
3825 108 : if (e->type == e_column) {
3826 52 : nid = e->nid;
3827 52 : nrname = (const char*) e->l;
3828 52 : nename = (const char*) e->r;
3829 52 : e->tpe = *type;
3830 52 : res = 1; /* found */
3831 56 : } else if ((e->type == e_atom || exp_is_rel(e)) && (res = set_exp_type(sql, type, rel, e)) <= 0) {
3832 : return res; /* don't search further */
3833 : }
3834 : /* group by columns can have aliases! */
3835 108 : if (is_groupby(rel->op) && !list_empty(rel->r)) {
3836 0 : e = exps_bind_nid(rel->r, nid);
3837 0 : if (!e)
3838 : return res; /* don't search further */
3839 0 : if (e->type == e_column) {
3840 0 : nid = e->nid;
3841 0 : nrname = (const char*) e->l;
3842 0 : nename = (const char*) e->r;
3843 0 : e->tpe = *type;
3844 0 : } else if ((e->type == e_atom || exp_is_rel(e)) && (res = set_exp_type(sql, type, rel, e)) <= 0) {
3845 : return res; /* don't search further */
3846 : }
3847 : }
3848 108 : if (e->type != e_column)
3849 : return res; /* don't search further */
3850 : }
3851 :
3852 76 : switch (rel->op) {
3853 14 : case op_join:
3854 : case op_left:
3855 : case op_right:
3856 : case op_full:
3857 14 : if (rel->l)
3858 14 : res = rel_find_parameter(sql, type, rel->l, nid, nrname, nename);
3859 14 : if (rel->r && res <= 0) { /* try other relation if not found */
3860 12 : int err = sql->session->status, lres = res;
3861 12 : char buf[ERRSIZE];
3862 :
3863 12 : strcpy(buf, sql->errstr); /* keep error found and try other join relation */
3864 12 : sql->session->status = 0;
3865 12 : sql->errstr[0] = '\0';
3866 12 : res = rel_find_parameter(sql, type, rel->r, nid, nrname, nename);
3867 12 : if (res == 0) { /* parameter wasn't found, set error */
3868 1 : res = lres;
3869 1 : sql->session->status = err;
3870 1 : strcpy(sql->errstr, buf);
3871 : }
3872 : }
3873 : break;
3874 52 : case op_semi:
3875 : case op_anti:
3876 : case op_groupby:
3877 : case op_project:
3878 : case op_select:
3879 : case op_topn:
3880 : case op_sample:
3881 52 : if (rel->l)
3882 : res = rel_find_parameter(sql, type, rel->l, nid, nrname, nename);
3883 : break;
3884 0 : case op_union: /* TODO for set relations this needs further improvement */
3885 : case op_inter:
3886 : case op_except:
3887 : case op_munion: {
3888 0 : (void) sql_error(sql, 10, SQLSTATE(42000) "Cannot set parameter types under set relations at the moment");
3889 0 : return -1;
3890 : }
3891 : default: /* For table returning functions, the type must be set when the relation is created */
3892 : return 0;
3893 : }
3894 : return res;
3895 : }
3896 :
3897 : sql_exp *
3898 19662 : list_find_exp( list *exps, sql_exp *e)
3899 : {
3900 19662 : if (e->type != e_column)
3901 : return NULL;
3902 19622 : return exps_bind_nid(exps, e->nid);
3903 : }
|
