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, 2025 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 "rel_optimizer_private.h"
15 : #include "rel_select.h"
16 : #include "rel_exp.h"
17 : #include "rel_rewriter.h"
18 :
19 : static inline int
20 51275 : str_ends_with(const char *s, const char *suffix)
21 : {
22 51275 : size_t slen = strlen(s), suflen = strlen(suffix);
23 51275 : if (suflen > slen)
24 : return 1;
25 556 : return strncmp(s + slen - suflen, suffix, suflen);
26 : }
27 :
28 : static sql_exp *
29 399158 : exp_simplify_math( mvc *sql, sql_exp *e, int *changes)
30 : {
31 399158 : if (e->type == e_func || e->type == e_aggr) {
32 86689 : list *l = e->l;
33 86689 : sql_subfunc *f = e->f;
34 86689 : node *n;
35 86689 : sql_exp *le;
36 :
37 86689 : if (list_length(l) < 1)
38 : return e;
39 :
40 : /* if the function has no null semantics we can return NULL if one of the arguments is NULL */
41 86615 : if (!f->func->semantics && f->func->type != F_PROC) {
42 155700 : for (node *n = l->h ; n ; n = n->next) {
43 102526 : sql_exp *arg = n->data;
44 :
45 102526 : if (exp_is_atom(arg) && exp_is_null(arg)) {
46 47 : sql_exp *ne = exp_null(sql->sa, exp_subtype(e));
47 47 : (*changes)++;
48 47 : if (exp_name(e))
49 18 : exp_prop_alias(sql->sa, ne, e);
50 47 : return ne;
51 : }
52 : }
53 : }
54 86568 : if (!f->func->s && list_length(l) == 2 && str_ends_with(sql_func_imp(f->func), "_no_nil") == 0) {
55 106 : sql_exp *le = l->h->data;
56 106 : sql_exp *re = l->h->next->data;
57 :
58 : /* if "_no_nil" is in the name of the
59 : * implementation function (currently either
60 : * min_no_nil or max_no_nil), in which case we
61 : * ignore the NULL and return the other value */
62 :
63 106 : if (exp_is_atom(le) && exp_is_null(le)) {
64 1 : (*changes)++;
65 1 : if (exp_name(e))
66 1 : exp_prop_alias(sql->sa, re, e);
67 1 : return re;
68 : }
69 105 : if (exp_is_atom(re) && exp_is_null(re)) {
70 0 : (*changes)++;
71 0 : if (exp_name(e))
72 0 : exp_prop_alias(sql->sa, le, e);
73 0 : return le;
74 : }
75 : }
76 :
77 86567 : le = l->h->data;
78 86567 : if (!EC_COMPUTE(exp_subtype(le)->type->eclass) && exp_subtype(le)->type->eclass != EC_DEC)
79 : return e;
80 :
81 56347 : if (!f->func->s && !strcmp(f->func->base.name, "sql_mul") && list_length(l) == 2) {
82 11124 : sql_exp *le = l->h->data;
83 11124 : sql_exp *re = l->h->next->data;
84 11124 : sql_subtype *et = exp_subtype(e);
85 :
86 : /* 0*a = 0 */
87 11124 : if (exp_is_atom(le) && exp_is_zero(le) && exp_is_atom(re) && !has_nil(re)) {
88 0 : (*changes)++;
89 0 : le = exp_zero(sql->sa, et);
90 0 : if (subtype_cmp(exp_subtype(e), exp_subtype(le)) != 0)
91 0 : le = exp_convert(sql, le, exp_subtype(le), exp_subtype(e));
92 0 : if (exp_name(e))
93 0 : exp_prop_alias(sql->sa, le, e);
94 0 : return le;
95 : }
96 : /* a*0 = 0 */
97 11124 : if (exp_is_atom(re) && exp_is_zero(re) && exp_is_atom(le) && !has_nil(le)) {
98 2 : (*changes)++;
99 2 : re = exp_zero(sql->sa, et);
100 2 : if (subtype_cmp(exp_subtype(e), exp_subtype(re)) != 0)
101 0 : re = exp_convert(sql, re, exp_subtype(re), exp_subtype(e));
102 2 : if (exp_name(e))
103 1 : exp_prop_alias(sql->sa, re, e);
104 2 : return re;
105 : }
106 11122 : if (exp_is_atom(le) && exp_is_atom(re)) {
107 83 : atom *la = exp_flatten(sql, true, le);
108 83 : atom *ra = exp_flatten(sql, true, re);
109 :
110 83 : if (la && ra && subtype_cmp(atom_type(la), atom_type(ra)) == 0 && subtype_cmp(atom_type(la), exp_subtype(e)) == 0) {
111 10 : atom *a = atom_mul(sql->sa, la, ra);
112 :
113 10 : if (a && (a = atom_cast(sql->sa, a, exp_subtype(e)))) {
114 4 : sql_exp *ne = exp_atom(sql->sa, a);
115 4 : if (subtype_cmp(exp_subtype(e), exp_subtype(ne)) != 0)
116 0 : ne = exp_convert(sql, ne, exp_subtype(ne), exp_subtype(e));
117 4 : (*changes)++;
118 4 : if (exp_name(e))
119 0 : exp_prop_alias(sql->sa, ne, e);
120 4 : return ne;
121 : }
122 : }
123 : }
124 : /* change a*pow(a,n) or pow(a,n)*a into pow(a,n+1) */
125 11118 : if (is_func(le->type)) {
126 97 : list *l = le->l;
127 97 : sql_subfunc *f = le->f;
128 :
129 97 : if (!f->func->s && !strcmp(f->func->base.name, "power") && list_length(l) == 2) {
130 0 : sql_exp *lle = l->h->data;
131 0 : sql_exp *lre = l->h->next->data;
132 0 : if (exp_equal(re, lle)==0) {
133 0 : atom *a = exp_value(sql, lre);
134 0 : if (a && (a = atom_inc(sql->sa, a))) {
135 0 : lre->l = a;
136 0 : lre->r = NULL;
137 0 : if (subtype_cmp(exp_subtype(e), exp_subtype(le)) != 0)
138 0 : le = exp_convert(sql, le, exp_subtype(le), exp_subtype(e));
139 0 : (*changes)++;
140 0 : if (exp_name(e))
141 0 : exp_prop_alias(sql->sa, le, e);
142 0 : return le;
143 : }
144 : }
145 : }
146 97 : if (!f->func->s && !strcmp(f->func->base.name, "sql_mul") && list_length(l) == 2) {
147 29 : sql_exp *lle = l->h->data;
148 29 : sql_exp *lre = l->h->next->data;
149 29 : if (!exp_is_atom(lle) && exp_is_atom(lre) && exp_is_atom(re)) {
150 : /* (x*c1)*c2 -> x * (c1*c2) */
151 5 : sql_exp *ne = NULL;
152 :
153 5 : if (!(le = rel_binop_(sql, NULL, lre, re, "sys", "sql_mul", card_value, true))) {
154 0 : sql->session->status = 0;
155 0 : sql->errstr[0] = '\0';
156 0 : return e; /* error, fallback to original expression */
157 : }
158 5 : if (!(ne = rel_binop_(sql, NULL, lle, le, "sys", "sql_mul", card_value, true))) {
159 0 : sql->session->status = 0;
160 0 : sql->errstr[0] = '\0';
161 0 : return e; /* error, fallback to original expression */
162 : }
163 5 : if (subtype_cmp(exp_subtype(e), exp_subtype(ne)) != 0)
164 0 : ne = exp_convert(sql, ne, exp_subtype(ne), exp_subtype(e));
165 5 : (*changes)++;
166 5 : if (exp_name(e))
167 1 : exp_prop_alias(sql->sa, ne, e);
168 5 : return ne;
169 : }
170 : }
171 : }
172 : }
173 56336 : if (!f->func->s && !strcmp(f->func->base.name, "sql_add") && list_length(l) == 2) {
174 23357 : sql_exp *le = l->h->data;
175 23357 : sql_exp *re = l->h->next->data;
176 23357 : if (exp_is_atom(le) && exp_is_zero(le)) {
177 1 : if (subtype_cmp(exp_subtype(e), exp_subtype(re)) != 0)
178 0 : re = exp_convert(sql, re, exp_subtype(re), exp_subtype(e));
179 1 : (*changes)++;
180 1 : if (exp_name(e))
181 1 : exp_prop_alias(sql->sa, re, e);
182 1 : return re;
183 : }
184 23356 : if (exp_is_atom(re) && exp_is_zero(re)) {
185 4 : if (subtype_cmp(exp_subtype(e), exp_subtype(le)) != 0)
186 0 : le = exp_convert(sql, le, exp_subtype(le), exp_subtype(e));
187 4 : (*changes)++;
188 4 : if (exp_name(e))
189 4 : exp_prop_alias(sql->sa, le, e);
190 4 : return le;
191 : }
192 23352 : if (exp_is_atom(le) && exp_is_atom(re)) {
193 56 : atom *la = exp_flatten(sql, true, le);
194 56 : atom *ra = exp_flatten(sql, true, re);
195 :
196 56 : if (la && ra) {
197 20 : atom *a = atom_add(sql->sa, la, ra);
198 :
199 20 : if (a) {
200 8 : sql_exp *ne = exp_atom(sql->sa, a);
201 8 : if (subtype_cmp(exp_subtype(e), exp_subtype(ne)) != 0)
202 2 : ne = exp_convert(sql, ne, exp_subtype(ne), exp_subtype(e));
203 8 : (*changes)++;
204 8 : if (exp_name(e))
205 1 : exp_prop_alias(sql->sa, ne, e);
206 8 : return ne;
207 : }
208 : }
209 : }
210 23344 : if (is_func(le->type)) {
211 5363 : list *ll = le->l;
212 5363 : sql_subfunc *f = le->f;
213 5363 : if (!f->func->s && !strcmp(f->func->base.name, "sql_add") && list_length(ll) == 2) {
214 4911 : sql_exp *lle = ll->h->data;
215 4911 : sql_exp *lre = ll->h->next->data;
216 :
217 4911 : if (exp_is_atom(lle) && exp_is_atom(lre))
218 : return e;
219 4894 : if (!exp_is_atom(re) && exp_is_atom(lre)) {
220 : /* (x+c1)+y -> (x+y) + c1 */
221 390 : ll->h->next->data = re;
222 390 : l->h->next->data = lre;
223 390 : if (!(l->h->data = exp_simplify_math(sql, le, changes)))
224 : return NULL;
225 390 : (*changes)++;
226 390 : return e;
227 : }
228 4504 : if (exp_is_atom(re) && exp_is_atom(lre)) {
229 : /* (x+c1)+c2 -> (c2+c1) + x */
230 3 : ll->h->data = re;
231 3 : l->h->next->data = lle;
232 3 : if (!(l->h->data = exp_simplify_math(sql, le, changes)))
233 : return NULL;
234 3 : (*changes)++;
235 3 : return e;
236 : }
237 : }
238 : }
239 : }
240 55913 : if (!f->func->s && !strcmp(f->func->base.name, "sql_sub") && list_length(l) == 2) {
241 5478 : sql_exp *le = l->h->data;
242 5478 : sql_exp *re = l->h->next->data;
243 :
244 5478 : if (exp_is_atom(le) && exp_is_atom(re)) {
245 22 : atom *la = exp_flatten(sql, true, le);
246 22 : atom *ra = exp_flatten(sql, true, re);
247 :
248 22 : if (la && ra) {
249 7 : atom *a = atom_sub(sql->sa, la, ra);
250 :
251 7 : if (a) {
252 7 : sql_exp *ne = exp_atom(sql->sa, a);
253 7 : if (subtype_cmp(exp_subtype(e), exp_subtype(ne)) != 0)
254 5 : ne = exp_convert(sql, ne, exp_subtype(ne), exp_subtype(e));
255 7 : (*changes)++;
256 7 : if (exp_name(e))
257 3 : exp_prop_alias(sql->sa, ne, e);
258 7 : return ne;
259 : }
260 : }
261 : }
262 5471 : if (!has_nil(le) && !has_nil(re) && exp_equal(le,re) == 0) { /* a - a = 0 */
263 0 : atom *a;
264 0 : sql_exp *ne;
265 :
266 0 : if (exp_subtype(le)->type->eclass == EC_NUM) {
267 0 : a = atom_int(sql->sa, exp_subtype(le), 0);
268 0 : } else if (exp_subtype(le)->type->eclass == EC_FLT) {
269 0 : a = atom_float(sql->sa, exp_subtype(le), 0);
270 : } else {
271 : return e;
272 : }
273 0 : ne = exp_atom(sql->sa, a);
274 0 : if (subtype_cmp(exp_subtype(e), exp_subtype(ne)) != 0)
275 0 : ne = exp_convert(sql, ne, exp_subtype(ne), exp_subtype(e));
276 0 : (*changes)++;
277 0 : if (exp_name(e))
278 0 : exp_prop_alias(sql->sa, ne, e);
279 0 : return ne;
280 : }
281 5471 : if (is_func(le->type)) {
282 52 : list *ll = le->l;
283 52 : sql_subfunc *f = le->f;
284 52 : if (!f->func->s && !strcmp(f->func->base.name, "sql_add") && list_length(ll) == 2) {
285 8 : sql_exp *lle = ll->h->data;
286 8 : sql_exp *lre = ll->h->next->data;
287 8 : if (exp_equal(re, lre) == 0) {
288 : /* (x+a)-a = x*/
289 0 : if (subtype_cmp(exp_subtype(e), exp_subtype(lle)) != 0)
290 0 : lle = exp_convert(sql, lle, exp_subtype(lle), exp_subtype(e));
291 0 : if (exp_name(e))
292 0 : exp_prop_alias(sql->sa, lle, e);
293 0 : (*changes)++;
294 0 : return lle;
295 : }
296 8 : if (exp_is_atom(lle) && exp_is_atom(lre))
297 : return e;
298 8 : if (!exp_is_atom(re) && exp_is_atom(lre)) {
299 : /* (x+c1)-y -> (x-y) + c1 */
300 3 : ll->h->next->data = re;
301 3 : l->h->next->data = lre;
302 3 : le->f = e->f;
303 3 : e->f = f;
304 3 : if (!(l->h->data = exp_simplify_math(sql, le, changes)))
305 : return NULL;
306 3 : (*changes)++;
307 3 : return e;
308 : }
309 5 : if (exp_is_atom(re) && exp_is_atom(lre)) {
310 : /* (x+c1)-c2 -> (c1-c2) + x */
311 0 : ll->h->data = lre;
312 0 : ll->h->next->data = re;
313 0 : l->h->next->data = lle;
314 0 : le->f = e->f;
315 0 : e->f = f;
316 0 : if (!(l->h->data = exp_simplify_math(sql, le, changes)))
317 : return NULL;
318 0 : (*changes)++;
319 0 : return e;
320 : }
321 : }
322 : }
323 : }
324 55903 : if (l)
325 176687 : for (n = l->h; n; n = n->next)
326 120784 : if (!(n->data = exp_simplify_math(sql, n->data, changes)))
327 : return NULL;
328 : }
329 368372 : if (e->type == e_convert)
330 27935 : if (!(e->l = exp_simplify_math(sql, e->l, changes)))
331 : return NULL;
332 : return e;
333 : }
334 :
335 : static inline sql_rel *
336 1194278 : rel_simplify_math_(visitor *v, sql_rel *rel)
337 : {
338 1194278 : if ((is_simple_project(rel->op) || (rel->op == op_ddl && rel->flag == ddl_psm)) && rel->exps) {
339 287159 : int needed = 0, ochanges = 0;
340 :
341 1609656 : for (node *n = rel->exps->h; n && !needed; n = n->next) {
342 1322497 : sql_exp *e = n->data;
343 :
344 1322497 : if (e->type == e_func || e->type == e_convert || e->type == e_aggr || e->type == e_psm)
345 39068 : needed = 1;
346 : }
347 287159 : if (!needed)
348 248091 : return rel;
349 :
350 289111 : for (node *n = rel->exps->h; n; n = n->next) {
351 250043 : sql_exp *ne = exp_simplify_math(v->sql, n->data, &ochanges);
352 :
353 250043 : if (!ne)
354 : return NULL;
355 250043 : n->data = ne;
356 : }
357 39068 : v->changes += ochanges;
358 : }
359 : return rel;
360 : }
361 :
362 : static sql_rel *
363 366616 : rel_simplify_math(visitor *v, global_props *gp, sql_rel *rel)
364 : {
365 366616 : (void) gp;
366 366616 : return rel_visitor_bottomup(v, rel, &rel_simplify_math_);
367 : }
368 :
369 : run_optimizer
370 638407 : bind_simplify_math(visitor *v, global_props *gp)
371 : {
372 638407 : int flag = v->sql->sql_optimizer;
373 561147 : return gp->opt_cycle == 0 && gp->opt_level == 1 && v->value_based_opt && (gp->cnt[op_project]
374 1047320 : || gp->cnt[op_ddl] || gp->cnt[ddl_psm]) && (flag & simplify_math) ? rel_simplify_math : NULL;
375 : }
376 :
377 :
378 : /*
379 : * Casting decimal values on both sides of a compare expression is expensive,
380 : * both in performance (cpu cost) and memory requirements (need for large
381 : * types).
382 : */
383 :
384 : #define reduce_scale_tpe(tpe, uval) \
385 : do { \
386 : tpe v = uval; \
387 : if (v != 0) { \
388 : while( (v/10)*10 == v ) { \
389 : i++; \
390 : v /= 10; \
391 : } \
392 : nval = v; \
393 : } \
394 : } while (0)
395 :
396 : atom *
397 6 : reduce_scale(mvc *sql, atom *a)
398 : {
399 6 : int i = 0;
400 6 : atom *na = a;
401 : #ifdef HAVE_HGE
402 6 : hge nval = 0;
403 : #else
404 : lng nval = 0;
405 : #endif
406 :
407 : #ifdef HAVE_HGE
408 6 : if (a->data.vtype == TYPE_hge) {
409 0 : reduce_scale_tpe(hge, a->data.val.hval);
410 : } else
411 : #endif
412 : if (a->data.vtype == TYPE_lng) {
413 0 : reduce_scale_tpe(lng, a->data.val.lval);
414 : } else if (a->data.vtype == TYPE_int) {
415 7 : reduce_scale_tpe(int, a->data.val.ival);
416 : } else if (a->data.vtype == TYPE_sht) {
417 0 : reduce_scale_tpe(sht, a->data.val.shval);
418 : } else if (a->data.vtype == TYPE_bte) {
419 9 : reduce_scale_tpe(bte, a->data.val.btval);
420 : }
421 6 : if (i) {
422 4 : na = atom_int(sql->sa, &a->tpe, nval);
423 4 : if (na->tpe.scale)
424 3 : na->tpe.scale -= i;
425 : else
426 : return NULL;
427 : }
428 : return na;
429 : }
430 :
431 : static inline sql_exp *
432 408526 : simplify_isnull_isnotnull_equals_bool(visitor *v, sql_exp *e)
433 : {
434 : /* rewrite isnull/isnotnull(x) = TRUE/FALSE => x =/<> NULL */
435 408526 : if (!(is_compare(e->type) && (e->flag == cmp_equal || e->flag == cmp_notequal)))
436 : return e;
437 358967 : sql_exp *l = e->l;
438 358967 : sql_exp *r = e->r;
439 :
440 : /*if (is_atom(r->type) && r->l &&*/
441 : /*strcmp(((atom*)r->l)->tpe.type->base.name, "boolean") != 0)*/
442 : /*return e;*/
443 :
444 358967 : if (!is_func(l->type))
445 : return e;
446 :
447 9490 : sql_subfunc *f = l->f;
448 9490 : if (f->func->s || (!is_isnull_func(f) && !is_isnotnull_func(f)))
449 : return e;
450 :
451 1019 : list *args = l->l;
452 1019 : sql_exp *ie = args->h->data;
453 :
454 1019 : if (!has_nil(ie) || exp_is_not_null(ie)) {
455 311 : if (is_isnull_func(f)) {
456 : /* is null on something that is never null, is always false */
457 309 : ie = exp_atom_bool(v->sql->sa, 0);
458 2 : } else if (is_isnotnull_func(f)) {
459 : /* is NOT null on something that is never null, is always true */
460 2 : ie = exp_atom_bool(v->sql->sa, 1);
461 : }
462 311 : v->changes++;
463 311 : e->l = ie;
464 708 : } else if (exp_is_null(ie)) {
465 7 : if (is_isnull_func(f)) {
466 : /* is null on something that is always null, is always true */
467 5 : ie = exp_atom_bool(v->sql->sa, 1);
468 2 : } else if (is_isnotnull_func(f)) {
469 : /* is NOT null on something that is always null, is always false */
470 2 : ie = exp_atom_bool(v->sql->sa, 0);
471 : }
472 7 : v->changes++;
473 7 : e->l = ie;
474 701 : } else if (is_atom(r->type) && r->l) {
475 : /* direct literal */
476 685 : atom *a = r->l;
477 :
478 685 : if (a->isnull) {
479 0 : if (is_semantics(e)) {
480 : /* isnull/isnotnull(x) = NULL -> false,
481 : * isnull/isnotnull(x) <> NULL -> true */
482 0 : int flag = e->flag == cmp_notequal;
483 0 : if (is_anti(e))
484 0 : flag = !flag;
485 0 : e = exp_atom_bool(v->sql->sa, flag);
486 : } else {
487 : /* always NULL */
488 0 : e = exp_null(v->sql->sa, sql_bind_localtype("bit"));
489 : }
490 0 : v->changes++;
491 : } else {
492 : /* case isnull(x) = TRUE => x = NULL */
493 : /* case isnull(x) != TRUE => x != NULL */
494 : /* case isnull(x) = FALSE => x != NULL <-- op switch */
495 : /* case isnull(x) != FALSE => x = NULL <-- op switch */
496 : /* case isnotnull(x) = TRUE => x != NULL <-- op switch */
497 : /* case isnotnull(x) != TRUE => x = NULL <-- op switch */
498 : /* case isnotnull(x) = FALSE => x = NULL */
499 : /* case isnotnull(x) != FALSE => x != NULL */
500 685 : bool bval = a->data.val.bval;
501 :
502 685 : assert(list_length(args) == 1);
503 :
504 685 : l = ie;
505 685 : if (exp_subtype(l)->type) {
506 685 : r = exp_atom(v->sql->sa, atom_general(v->sql->sa, exp_subtype(l), NULL, 0));
507 685 : e = exp_compare(v->sql->sa, l, r, e->flag);
508 685 : if (e) {
509 685 : if (bval == false && is_isnull_func(f))
510 282 : set_anti(e);
511 394 : if (bval == true && is_isnotnull_func(f))
512 10 : set_anti(e);
513 : }
514 10 : if (e)
515 685 : set_semantics(e);
516 685 : v->changes++;
517 : }
518 : }
519 : }
520 : return e;
521 : }
522 :
523 : static inline sql_exp *
524 408526 : simplify_not_over_equality_exp(visitor *v, sql_exp *e) {
525 408526 : if (!(is_compare(e->type) && (e->flag == cmp_equal || e->flag == cmp_notequal)))
526 : return e;
527 358967 : sql_exp *l = e->l;
528 358967 : sql_exp *r = e->r;
529 :
530 358967 : if (!is_func(l->type))
531 : return e;
532 8491 : sql_subfunc *f = l->f;
533 :
534 8491 : if (f->func->s || !is_not_func(f))
535 : return e;
536 :
537 12 : if (is_atom(r->type) && r->l) {
538 : /* direct literal */
539 12 : atom *a = r->l;
540 12 : list *args = l->l;
541 12 : sql_exp *inner = args->h->data;
542 12 : sql_subfunc *inf = inner->f;
543 :
544 12 : assert(list_length(args) == 1);
545 :
546 12 : if (is_func(inner->type) && !inf->func->s && is_not_func(inf)) {
547 : /* not(not(x)) = TRUE/FALSE => x = TRUE/FALSE */
548 0 : int anti = is_anti(e), is_semantics = is_semantics(e);
549 :
550 0 : args = inner->l;
551 0 : assert(list_length(args) == 1);
552 0 : l = args->h->data;
553 0 : e = exp_compare(v->sql->sa, l, r, e->flag);
554 0 : if (anti) set_anti(e);
555 0 : if (is_semantics) set_semantics(e);
556 0 : v->changes++;
557 12 : } else if (is_func(inner->type) && !inf->func->s &&
558 5 : (!strcmp(inf->func->base.name, "=") || !strcmp(inf->func->base.name, "<>"))) {
559 : /* rewrite not(=/<>(a,b)) = TRUE/FALSE => a=b / a<>b */
560 1 : int flag = a->data.val.bval;
561 1 : sql_exp *ne;
562 1 : args = inner->l;
563 :
564 1 : if (!strcmp(inf->func->base.name, "<>"))
565 0 : flag = !flag;
566 1 : if (e->flag == cmp_notequal)
567 0 : flag = !flag;
568 1 : assert(list_length(args) == 2);
569 1 : l = args->h->data;
570 1 : r = args->h->next->data;
571 1 : ne = exp_compare(v->sql->sa, l, r, (!flag)?cmp_equal:cmp_notequal);
572 1 : if (a->isnull)
573 0 : e->l = ne;
574 : else
575 : e = ne;
576 1 : v->changes++;
577 11 : } else if (a && a->data.vtype == TYPE_bit) {
578 11 : int anti = is_anti(e), is_semantics = is_semantics(e);
579 :
580 : /* change atom's value on right */
581 11 : l = args->h->data;
582 11 : if (!a->isnull)
583 11 : r = exp_atom_bool(v->sql->sa, !a->data.val.bval);
584 11 : e = exp_compare(v->sql->sa, l, r, e->flag);
585 11 : if (anti) set_anti(e);
586 11 : if (is_semantics) set_semantics(e);
587 11 : v->changes++;
588 : }
589 : }
590 : return e;
591 : }
592 :
593 : static inline sql_exp *
594 7209035 : rel_simplify_predicates(visitor *v, sql_rel *rel, sql_exp *e)
595 : {
596 7209035 : if (is_func(e->type) && list_length(e->l) == 3 && is_case_func((sql_subfunc*)e->f)) {
597 35779 : list *args = e->l;
598 35779 : sql_exp *ie = args->h->data;
599 :
600 35779 : if (exp_is_true(ie)) { /* ifthenelse(true, x, y) -> x */
601 14 : sql_exp *res = args->h->next->data;
602 14 : if (exp_name(e))
603 6 : exp_prop_alias(v->sql->sa, res, e);
604 14 : v->changes++;
605 14 : return res;
606 35765 : } else if (exp_is_false(ie) || exp_is_null(ie)) { /* ifthenelse(false or null, x, y) -> y */
607 12 : sql_exp *res = args->h->next->next->data;
608 12 : if (exp_name(e))
609 7 : exp_prop_alias(v->sql->sa, res, e);
610 12 : v->changes++;
611 12 : return res;
612 : }
613 : }
614 7209009 : if (is_func(e->type) && list_length(e->l) == 4 && is_casewhen_func((sql_subfunc*)e->f)) {
615 : /* case x when y then a else b */
616 421 : list *args = e->l;
617 421 : node *n = args->h;
618 421 : sql_exp *le = n->data;
619 421 : sql_exp *re = n->next->data;
620 :
621 421 : if (exp_is_atom(le) && exp_is_not_null(le) && exp_is_atom(re) && le->type == e_atom && le->l && re->type == e_atom && re->l) {
622 56 : n = n->next->next;
623 56 : if (exp_match_exp(le, re)) { /* x==y -> a */
624 9 : sql_exp *res = n->data;
625 9 : if (exp_name(e))
626 7 : exp_prop_alias(v->sql->sa, res, e);
627 9 : v->changes++;
628 9 : return res;
629 : } else { /* -> b */
630 47 : sql_exp *res = n->next->data;
631 47 : if (exp_name(e))
632 11 : exp_prop_alias(v->sql->sa, res, e);
633 47 : v->changes++;
634 47 : return res;
635 : }
636 : }
637 : }
638 7208953 : if (is_select(rel->op) || is_join(rel->op) || is_semi(rel->op)) {
639 : /* simplify like expressions */
640 1719254 : if (is_compare(e->type) && e->flag == cmp_filter && !((sql_subfunc*)e->f)->func->s && strcmp(((sql_subfunc*)e->f)->func->base.name, "like") == 0 &&
641 13716 : list_length((list *)e->l) == 1 && list_length((list *)e->r) == 3) {
642 6858 : list *r = e->r;
643 6858 : sql_exp *fmt = r->h->data;
644 6858 : sql_exp *esc = r->h->next->data;
645 6858 : sql_exp *isen = r->h->next->next->data;
646 6858 : int rewrite = 0, isnull = 0;
647 :
648 6858 : if (fmt->type == e_convert)
649 103 : fmt = fmt->l;
650 : /* check for simple like expression */
651 6858 : if (exp_is_null(fmt)) {
652 : isnull = 1;
653 6857 : } else if (is_atom(fmt->type)) {
654 6726 : atom *fa = NULL;
655 :
656 6726 : if (fmt->l)
657 6726 : fa = fmt->l;
658 6726 : if (fa && fa->data.vtype == TYPE_str && !strchr(fa->data.val.sval, '%') && !strchr(fa->data.val.sval, '_'))
659 6858 : rewrite = 1;
660 : }
661 6858 : if (rewrite && !isnull) { /* check escape flag */
662 141 : if (exp_is_null(esc)) {
663 : isnull = 1;
664 : } else {
665 141 : atom *ea = esc->l;
666 :
667 141 : if (!is_atom(esc->type) || !ea)
668 : rewrite = 0;
669 141 : else if (ea->data.vtype != TYPE_str || strlen(ea->data.val.sval) != 0)
670 69 : rewrite = 0;
671 : }
672 : }
673 6858 : if (rewrite && !isnull) { /* check insensitive flag */
674 72 : if (exp_is_null(isen)) {
675 : isnull = 1;
676 : } else {
677 72 : atom *ia = isen->l;
678 :
679 72 : if (!is_atom(isen->type) || !ia)
680 : rewrite = 0;
681 72 : else if (ia->data.vtype != TYPE_bit || ia->data.val.btval == 1)
682 17 : rewrite = 0;
683 : }
684 : }
685 6858 : if (isnull) {
686 1 : e = exp_null(v->sql->sa, sql_bind_localtype("bit"));
687 1 : v->changes++;
688 1 : return e;
689 6857 : } else if (rewrite) { /* rewrite to cmp_equal ! */
690 55 : list *l = e->l;
691 55 : list *r = e->r;
692 107 : e = exp_compare(v->sql->sa, l->h->data, r->h->data, is_anti(e) ? cmp_notequal : cmp_equal);
693 55 : v->changes++;
694 : }
695 : }
696 : /* rewrite e if left or right is a cast */
697 1712395 : if (is_compare(e->type) && !e->f && is_theta_exp(e->flag) && (((sql_exp*)e->l)->type == e_convert || ((sql_exp*)e->r)->type == e_convert)) {
698 11437 : sql_rel *r = rel->r;
699 11437 : sql_exp *le = e->l, *re = e->r;
700 :
701 : /* if convert on left then find mul or div on right which increased scale! */
702 11437 : if (le->type == e_convert && re->type == e_column && (e->flag == cmp_lt || e->flag == cmp_gt) && r && is_project(r->op)) {
703 73 : sql_exp *nre = rel_find_exp(r, re);
704 73 : sql_subtype *tt = exp_totype(le), *ft = exp_fromtype(le);
705 :
706 73 : if (nre && nre->type == e_func) {
707 3 : sql_subfunc *f = nre->f;
708 :
709 3 : if (!f->func->s && !strcmp(f->func->base.name, "sql_mul")) {
710 3 : list *args = nre->l;
711 3 : sql_exp *ce = args->t->data;
712 3 : sql_subtype *fst = exp_subtype(args->h->data);
713 :
714 3 : if (fst->scale && fst->scale == ft->scale && is_atom(ce->type) && ce->l) {
715 1 : atom *a = ce->l;
716 1 : int anti = is_anti(e);
717 1 : sql_exp *arg1, *arg2;
718 1 : sql_subfunc *f;
719 : #ifdef HAVE_HGE
720 1 : hge val = 1;
721 : #else
722 : lng val = 1;
723 : #endif
724 : /* multiply with smallest value, then scale and (round) */
725 1 : int scale = (int) tt->scale - (int) ft->scale, rs = 0;
726 1 : atom *na = reduce_scale(v->sql, a);
727 :
728 1 : if (na != a) {
729 1 : rs = a->tpe.scale - na->tpe.scale;
730 1 : ce->l = na;
731 : }
732 1 : scale -= rs;
733 :
734 3 : while (scale > 0) {
735 2 : scale--;
736 2 : val *= 10;
737 : }
738 1 : arg1 = re;
739 : #ifdef HAVE_HGE
740 1 : arg2 = exp_atom_hge(v->sql->sa, val);
741 : #else
742 : arg2 = exp_atom_lng(v->sql->sa, val);
743 : #endif
744 1 : if ((f = sql_bind_func(v->sql, "sys", "scale_down", exp_subtype(arg1), exp_subtype(arg2), F_FUNC, true, true))) {
745 1 : e = exp_compare(v->sql->sa, le->l, exp_binop(v->sql->sa, arg1, arg2, f), e->flag);
746 1 : if (anti) set_anti(e);
747 1 : v->changes++;
748 : } else {
749 0 : v->sql->session->status = 0;
750 0 : v->sql->errstr[0] = '\0';
751 : }
752 : }
753 : }
754 : }
755 : }
756 : }
757 1712395 : if (is_compare(e->type) && is_semantics(e) && (e->flag == cmp_equal || e->flag == cmp_notequal) && exp_is_null(e->r)) {
758 : /* simplify 'is null' predicates on constants */
759 7317 : if (exp_is_null(e->l)) {
760 23 : int nval = e->flag == cmp_equal;
761 23 : if (is_anti(e)) nval = !nval;
762 23 : e = exp_atom_bool(v->sql->sa, nval);
763 23 : v->changes++;
764 23 : return e;
765 7294 : } else if (exp_is_not_null(e->l)) {
766 2503 : int nval = e->flag == cmp_notequal;
767 2503 : if (is_anti(e)) nval = !nval;
768 2503 : e = exp_atom_bool(v->sql->sa, nval);
769 2503 : v->changes++;
770 2503 : return e;
771 : }
772 : }
773 1709869 : if (is_atom(e->type) && ((!e->l && !e->r && !e->f) || e->r)) /* prepared statement parameter or argument */
774 : return e;
775 1709500 : if (is_atom(e->type) && e->l) { /* direct literal */
776 438818 : atom *a = e->l;
777 438818 : int flag = a->data.val.bval;
778 :
779 : /* remove simple select true expressions */
780 438818 : if (flag)
781 : return e;
782 : }
783 1311582 : if (is_compare(e->type) && is_theta_exp(e->flag)) {
784 408526 : sql_exp *l = e->l;
785 408526 : sql_exp *r = e->r;
786 :
787 408526 : e = simplify_isnull_isnotnull_equals_bool(v, e);
788 408526 : e = simplify_not_over_equality_exp(v, e);
789 :
790 408526 : if (is_atom(l->type) && is_atom(r->type) && !is_semantics(e) && !is_any(e) && !e->f) {
791 : /* compute comparisons on atoms */
792 651 : if (exp_is_null(l) || exp_is_null(r)) {
793 41 : e = exp_null(v->sql->sa, sql_bind_localtype("bit"));
794 41 : v->changes++;
795 610 : } else if (l->l && r->l) {
796 610 : int res = atom_cmp(l->l, r->l);
797 610 : bool flag = !is_anti(e);
798 :
799 610 : if (res == 0)
800 68 : e = exp_atom_bool(v->sql->sa, (e->flag == cmp_equal || e->flag == cmp_gte || e->flag == cmp_lte) ? flag : !flag);
801 542 : else if (res > 0)
802 62 : e = exp_atom_bool(v->sql->sa, (e->flag == cmp_gt || e->flag == cmp_gte || e->flag == cmp_notequal) ? flag : !flag);
803 : else
804 480 : e = exp_atom_bool(v->sql->sa, (e->flag == cmp_lt || e->flag == cmp_lte || e->flag == cmp_notequal) ? flag : !flag);
805 610 : v->changes++;
806 : }
807 : }
808 : }
809 : }
810 : return e;
811 : }
812 :
813 : static inline sql_exp *
814 14967332 : rel_remove_alias(visitor *v, sql_rel *rel, sql_exp *e)
815 : {
816 14967332 : if (e->type != e_column)
817 : return e;
818 10960960 : if (!rel_is_ref(rel) && rel->op == op_project && rel->l && list_length(rel->exps) > 1) {
819 4737525 : sql_rel *l = rel->l;
820 4737525 : if (l->op == op_project) {
821 1161166 : sql_exp *ne = rel_find_exp(l, e);
822 1161166 : if (ne && ne->type == e_column && is_selfref(ne)) {
823 : /* found ne in projection, try to find reference in the same list */
824 992 : sql_exp *nne = exps_bind_nid(l->exps, ne->nid);
825 992 : if (nne && nne != ne && list_position(l->exps, nne) < list_position(l->exps, ne)) {
826 992 : e->l = (char*)exp_relname(nne);
827 992 : e->r = (char*)exp_name(nne);
828 992 : e->nid = nne->alias.label;
829 992 : v->changes++;
830 : }
831 : }
832 : }
833 : }
834 10960960 : if (!rel_is_ref(rel) && rel->op != op_project) {
835 5563819 : bool found = false;
836 5563819 : if ((is_select(rel->op) || is_join(rel->op)) && rel->l && list_length(rel->exps) > 1) {
837 324279 : sql_rel *l = rel->l;
838 324279 : if (l->op == op_project) {
839 17171 : sql_exp *ne = rel_find_exp(l, e);
840 17171 : found = true;
841 17171 : if (ne && ne->type == e_column && is_selfref(ne)) {
842 3 : sql_exp *nne = exps_bind_nid(l->exps, ne->nid);
843 3 : if (nne && nne != ne && list_position(l->exps, nne) < list_position(l->exps, ne)) {
844 3 : e->l = (char*)exp_relname(nne);
845 3 : e->r = (char*)exp_name(nne);
846 3 : e->nid = nne->alias.label;
847 3 : v->changes++;
848 : }
849 : }
850 : }
851 : }
852 5546651 : if (!found && is_join(rel->op) && rel->r && list_length(rel->exps) > 1 && !is_semi(rel->op)) {
853 179320 : sql_rel *l = rel->r;
854 179320 : if (l->op == op_project) {
855 11857 : sql_exp *ne = rel_find_exp(l, e);
856 11857 : found = true;
857 11857 : if (ne && ne->type == e_column && is_selfref(ne)) {
858 29 : sql_exp *nne = exps_bind_nid(l->exps, ne->nid);
859 29 : if (nne && nne != ne && list_position(l->exps, nne) < list_position(l->exps, ne)) {
860 29 : e->l = (char*)exp_relname(nne);
861 29 : e->r = (char*)exp_name(nne);
862 29 : e->nid = nne->alias.label;
863 29 : v->changes++;
864 : }
865 : }
866 : }
867 : }
868 : }
869 : return e;
870 : }
871 :
872 : static inline sql_exp *
873 14967333 : rel_merge_project_rse(visitor *v, sql_rel *rel, sql_exp *e)
874 : {
875 14967333 : if (is_simple_project(rel->op) && is_func(e->type) && e->l) {
876 713288 : list *fexps = e->l;
877 713288 : sql_subfunc *f = e->f;
878 :
879 : /* is and function */
880 713288 : if (!f->func->s && strcmp(f->func->base.name, "and") == 0 && list_length(fexps) == 2) {
881 18115 : sql_exp *l = list_fetch(fexps, 0), *r = list_fetch(fexps, 1);
882 :
883 : /* check merge into single between */
884 18115 : if (is_func(l->type) && is_func(r->type)) {
885 14635 : list *lfexps = l->l, *rfexps = r->l;
886 14635 : sql_subfunc *lff = l->f, *rff = r->f;
887 :
888 14635 : if (((strcmp(lff->func->base.name, ">=") == 0 || strcmp(lff->func->base.name, ">") == 0) && list_length(lfexps) == 2) &&
889 601 : ((strcmp(rff->func->base.name, "<=") == 0 || strcmp(rff->func->base.name, "<") == 0) && list_length(rfexps) == 2)) {
890 130 : sql_exp *le = list_fetch(lfexps, 0), *lf = list_fetch(rfexps, 0);
891 130 : int c_le = is_numeric_upcast(le), c_lf = is_numeric_upcast(lf);
892 :
893 130 : if (exp_equal(c_le?le->l:le, c_lf?lf->l:lf) == 0) {
894 99 : sql_exp *re = list_fetch(lfexps, 1), *rf = list_fetch(rfexps, 1), *ne = NULL;
895 99 : sql_subtype super;
896 :
897 99 : supertype(&super, exp_subtype(le), exp_subtype(lf)); /* le/re and lf/rf must have the same type */
898 99 : if (!(le = exp_check_type(v->sql, &super, rel, le, type_equal)) ||
899 99 : !(re = exp_check_type(v->sql, &super, rel, re, type_equal)) ||
900 99 : !(rf = exp_check_type(v->sql, &super, rel, rf, type_equal))) {
901 0 : v->sql->session->status = 0;
902 0 : v->sql->errstr[0] = 0;
903 0 : return e;
904 : }
905 99 : if ((ne = exp_compare2(v->sql->sa, le, re, rf, compare_funcs2range(lff->func->base.name, rff->func->base.name), 0))) {
906 99 : if (exp_name(e))
907 0 : exp_prop_alias(v->sql->sa, ne, e);
908 99 : e = ne;
909 99 : v->changes++;
910 : }
911 : }
912 : }
913 : }
914 : }
915 : }
916 : return e;
917 : }
918 :
919 : static sql_exp *
920 14967320 : rel_optimize_exps_(visitor *v, sql_rel *rel, sql_exp *e, int depth)
921 : {
922 14967320 : (void) depth;
923 14967320 : if (v->value_based_opt)
924 7209029 : e = rel_simplify_predicates(v, rel, e);
925 14967329 : e = rel_merge_project_rse(v, rel, e);
926 14967327 : e = rel_remove_alias(v, rel, e);
927 14967326 : return e;
928 : }
929 :
930 : static sql_rel *
931 171951 : rel_optimize_exps(visitor *v, global_props *gp, sql_rel *rel)
932 : {
933 171951 : (void) gp;
934 171951 : return rel_exp_visitor_bottomup(v, rel, &rel_optimize_exps_, false);
935 : }
936 :
937 : run_optimizer
938 638406 : bind_optimize_exps(visitor *v, global_props *gp)
939 : {
940 638406 : int flag = v->sql->sql_optimizer;
941 622947 : return gp->opt_cycle < 2 && gp->opt_level == 1 && (gp->cnt[op_project] || gp->cnt[op_join]
942 451263 : || gp->cnt[op_left] || gp->cnt[op_right] || gp->cnt[op_full] || gp->cnt[op_semi]
943 1261157 : || gp->cnt[op_anti] || gp->cnt[op_select]) && (flag & optimize_exps) ? rel_optimize_exps : NULL;
944 : }
|
