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 "rel_optimizer_private.h"
15 : #include "rel_exp.h"
16 : #include "rel_select.h"
17 :
18 : static void
19 72 : rel_no_rename_exps( list *exps )
20 : {
21 443 : for (node *n = exps->h; n; n = n->next) {
22 371 : sql_exp *e = n->data;
23 :
24 371 : exp_setalias(e, e->l, e->r);
25 : }
26 72 : list_hash_clear(exps);
27 72 : }
28 :
29 : void
30 75107 : rel_rename_exps( mvc *sql, list *exps1, list *exps2)
31 : {
32 75107 : int pos = 0;
33 75107 : node *n, *m;
34 :
35 75107 : (void)sql;
36 : /* check if a column uses an alias earlier in the list */
37 626805 : for (n = exps1->h, m = exps2->h; n && m; n = n->next, m = m->next, pos++) {
38 551698 : sql_exp *e2 = m->data;
39 :
40 551698 : if (e2->type == e_column) {
41 515499 : sql_exp *ne = NULL;
42 :
43 515499 : if (e2->l)
44 477965 : ne = exps_bind_column2(exps2, e2->l, e2->r, NULL);
45 515499 : if (!ne && !e2->l)
46 37534 : ne = exps_bind_column(exps2, e2->r, NULL, NULL, 1);
47 333862 : if (ne) {
48 181884 : int p = list_position(exps2, ne);
49 :
50 181884 : if (p < pos) {
51 24 : ne = list_fetch(exps1, p);
52 24 : if (e2->l)
53 24 : e2->l = (void *) exp_relname(ne);
54 24 : e2->r = (void *) exp_name(ne);
55 : }
56 : }
57 : }
58 : }
59 :
60 75107 : assert(list_length(exps1) <= list_length(exps2));
61 626805 : for (n = exps1->h, m = exps2->h; n && m; n = n->next, m = m->next) {
62 551698 : sql_exp *e1 = n->data;
63 551698 : sql_exp *e2 = m->data;
64 551698 : const char *rname = exp_relname(e1);
65 :
66 551698 : if (!rname && e1->type == e_column && e1->l && exp_relname(e2) &&
67 0 : strcmp(e1->l, exp_relname(e2)) == 0)
68 0 : rname = exp_relname(e2);
69 551698 : exp_setalias(e2, rname, exp_name(e1));
70 : }
71 75107 : list_hash_clear(exps2);
72 75107 : }
73 :
74 : sql_rel *
75 130210 : rel_find_ref( sql_rel *r)
76 : {
77 11542634 : while (!rel_is_ref(r) && r->l &&
78 11538156 : (is_project(r->op) || is_select(r->op) /*|| is_join(r->op)*/))
79 : r = r->l;
80 130210 : if (rel_is_ref(r))
81 3217 : return r;
82 : return NULL;
83 : }
84 :
85 : /* merge projection */
86 :
87 : /* push an expression through a projection.
88 : * The result should again used in a projection.
89 : */
90 : static list *
91 54688 : exps_push_down_prj(mvc *sql, list *exps, sql_rel *f, sql_rel *t, bool keepalias)
92 : {
93 54688 : node *n;
94 54688 : list *nl = new_exp_list(sql->sa);
95 :
96 175906 : for(n = exps->h; n; n = n->next) {
97 129167 : sql_exp *arg = n->data, *narg = NULL;
98 :
99 129167 : narg = exp_push_down_prj(sql, arg, f, t);
100 129167 : if (!narg)
101 : return NULL;
102 121218 : narg = exp_propagate(sql->sa, narg, arg);
103 121218 : if (!keepalias && narg->type == e_column)
104 32610 : exp_setalias(narg, narg->l, narg->r);
105 121218 : append(nl, narg);
106 : }
107 : return nl;
108 : }
109 :
110 : sql_exp *
111 1849358 : exp_push_down_prj(mvc *sql, sql_exp *e, sql_rel *f, sql_rel *t)
112 : {
113 1849358 : sql_exp *ne = NULL, *l = NULL, *r = NULL, *r2 = NULL;
114 :
115 1849358 : assert(is_project(f->op));
116 :
117 1849358 : switch(e->type) {
118 1527265 : case e_column:
119 1527265 : if (e->l)
120 1465477 : ne = exps_bind_column2(f->exps, e->l, e->r, NULL);
121 1527265 : if (!ne && !e->l)
122 61788 : ne = exps_bind_column(f->exps, e->r, NULL, NULL, 1);
123 1527265 : if (!ne || (ne->type != e_column && (ne->type != e_atom || ne->f)))
124 211138 : return NULL;
125 1316140 : while (ne && (has_label(ne) || is_selfref(ne) /*inside this list */) && is_simple_project(f->op) && ne->type == e_column) {
126 16577 : sql_exp *oe = e, *one = ne;
127 :
128 16577 : e = ne;
129 16577 : ne = NULL;
130 16577 : if (e->l)
131 16565 : ne = exps_bind_column2(f->exps, e->l, e->r, NULL);
132 16577 : if (!ne && !e->l)
133 12 : ne = exps_bind_column(f->exps, e->r, NULL, NULL, 1);
134 16577 : if (ne && ne != one && list_position(f->exps, ne) >= list_position(f->exps, one))
135 16577 : ne = NULL;
136 16577 : if (!ne || ne == one) {
137 : ne = one;
138 : e = oe;
139 : break;
140 : }
141 357 : if (ne->type != e_column && (ne->type != e_atom || ne->f))
142 : return NULL;
143 : }
144 : /* possibly a groupby/project column is renamed */
145 1315783 : if (is_groupby(f->op) && !list_empty(f->r) && ne->type == e_column) {
146 131 : sql_exp *gbe = NULL;
147 131 : if (ne->l)
148 130 : gbe = exps_bind_column2(f->r, ne->l, ne->r, NULL);
149 131 : if (!gbe && !e->l)
150 1 : gbe = exps_bind_column(f->r, ne->r, NULL, NULL, 1);
151 132 : ne = gbe;
152 131 : if (!ne || (ne->type != e_column && (ne->type != e_atom || ne->f)))
153 16 : return NULL;
154 : }
155 1315767 : if (ne->type == e_atom)
156 26784 : e = exp_copy(sql, ne);
157 : else
158 1288983 : e = exp_alias(sql->sa, exp_relname(e), exp_name(e), ne->l, ne->r, exp_subtype(e), e->card, has_nil(e), is_unique(e), is_intern(e));
159 1315767 : return exp_propagate(sql->sa, e, ne);
160 59007 : case e_cmp:
161 59007 : if (e->flag == cmp_or || e->flag == cmp_filter) {
162 4236 : list *l = NULL, *r = NULL;
163 :
164 4236 : if (!(l = exps_push_down_prj(sql, e->l, f, t, true)) || !(r = exps_push_down_prj(sql, e->r, f, t, true)))
165 1173 : return NULL;
166 3063 : if (e->flag == cmp_filter) {
167 1043 : ne = exp_filter(sql->sa, l, r, e->f, is_anti(e));
168 : } else {
169 2020 : ne = exp_or(sql->sa, l, r, is_anti(e));
170 : }
171 54771 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
172 4148 : list *r = NULL;
173 :
174 4148 : if (!(l = exp_push_down_prj(sql, e->l, f, t)) || !(r = exps_push_down_prj(sql, e->r, f, t, true)))
175 3698 : return NULL;
176 450 : ne = exp_in(sql->sa, l, r, e->flag);
177 : } else {
178 50623 : if (!(l = exp_push_down_prj(sql, e->l, f, t)) || !(r = exp_push_down_prj(sql, e->r, f, t)) || (e->f && !(r2 = exp_push_down_prj(sql, e->f, f, t))))
179 23391 : return NULL;
180 27232 : if (e->f) {
181 693 : ne = exp_compare2(sql->sa, l, r, r2, e->flag, is_symmetric(e));
182 : } else {
183 26539 : ne = exp_compare(sql->sa, l, r, e->flag);
184 : }
185 : }
186 30745 : if (!ne)
187 : return NULL;
188 30745 : return exp_propagate(sql->sa, ne, e);
189 124971 : case e_convert:
190 124971 : if (!(l = exp_push_down_prj(sql, e->l, f, t)))
191 : return NULL;
192 90266 : ne = exp_convert(sql->sa, l, exp_fromtype(e), exp_totype(e));
193 90266 : return exp_propagate(sql->sa, ne, e);
194 46805 : case e_aggr:
195 : case e_func: {
196 46805 : list *l = e->l, *nl = NULL;
197 46805 : sql_exp *ne = NULL;
198 :
199 46805 : if (e->type == e_func && exp_unsafe(e,0))
200 : return NULL;
201 46781 : if (!list_empty(l)) {
202 46781 : nl = exps_push_down_prj(sql, l, f, t, false);
203 46781 : if (!nl)
204 : return NULL;
205 : }
206 40005 : if (e->type == e_func)
207 40005 : ne = exp_op(sql->sa, nl, e->f);
208 : else
209 0 : ne = exp_aggr(sql->sa, nl, e->f, need_distinct(e), need_no_nil(e), e->card, has_nil(e));
210 40005 : return exp_propagate(sql->sa, ne, e);
211 : }
212 91310 : case e_atom: {
213 91310 : list *l = e->f, *nl = NULL;
214 :
215 91310 : if (!list_empty(l)) {
216 0 : nl = exps_push_down_prj(sql, l, f, t, false);
217 0 : if (!nl)
218 : return NULL;
219 0 : ne = exp_values(sql->sa, nl);
220 : } else {
221 91310 : ne = exp_copy(sql, e);
222 : }
223 91310 : return exp_propagate(sql->sa, ne, e);
224 : }
225 : case e_psm:
226 : if (e->type == e_atom && e->f) /* value list */
227 : return NULL;
228 : return e;
229 : }
230 : return NULL;
231 : }
232 :
233 : atom *
234 1102 : exp_flatten(mvc *sql, bool value_based_opt, sql_exp *e)
235 : {
236 1102 : if (e->type == e_atom) {
237 770 : return value_based_opt ? exp_value(sql, e) : (atom *) e->l;
238 332 : } else if (e->type == e_convert) {
239 69 : atom *v = exp_flatten(sql, value_based_opt, e->l);
240 :
241 69 : if (v)
242 34 : return atom_cast(sql->sa, v, exp_subtype(e));
243 263 : } else if (e->type == e_func) {
244 231 : sql_subfunc *f = e->f;
245 231 : list *l = e->l;
246 231 : sql_arg *res = (f->func->res)?(f->func->res->h->data):NULL;
247 :
248 : /* TODO handle date + x months */
249 231 : if (!f->func->s && strcmp(f->func->base.name, "sql_add") == 0 && list_length(l) == 2 && res && EC_NUMBER(res->type.type->eclass)) {
250 26 : atom *l1 = exp_flatten(sql, value_based_opt, l->h->data);
251 26 : atom *l2 = exp_flatten(sql, value_based_opt, l->h->next->data);
252 26 : if (l1 && l2)
253 3 : return atom_add(sql->sa, l1, l2);
254 205 : } else if (!f->func->s && strcmp(f->func->base.name, "sql_sub") == 0 && list_length(l) == 2 && res && EC_NUMBER(res->type.type->eclass)) {
255 18 : atom *l1 = exp_flatten(sql, value_based_opt, l->h->data);
256 18 : atom *l2 = exp_flatten(sql, value_based_opt, l->h->next->data);
257 18 : if (l1 && l2)
258 17 : return atom_sub(sql->sa, l1, l2);
259 : }
260 : }
261 : return NULL;
262 : }
263 :
264 : int
265 200 : exp_range_overlap(atom *min, atom *max, atom *emin, atom *emax, bool min_exclusive, bool max_exclusive)
266 : {
267 200 : if (!min || !max || !emin || !emax || min->isnull || max->isnull || emin->isnull || emax->isnull)
268 : return 0;
269 :
270 200 : if ((!min_exclusive && VALcmp(&(emax->data), &(min->data)) < 0) || (min_exclusive && VALcmp(&(emax->data), &(min->data)) <= 0))
271 29 : return 0;
272 171 : if ((!max_exclusive && VALcmp(&(emin->data), &(max->data)) > 0) || (max_exclusive && VALcmp(&(emin->data), &(max->data)) >= 0))
273 36 : return 0;
274 : return 1;
275 : }
276 :
277 :
278 : /* if local_proj is >= -1, the current expression is from the same projection
279 : if local_proj is -1, then we don't care about self references (eg used to check for order by exps) */
280 : static int exp_mark_used(sql_rel *subrel, sql_exp *e, int local_proj);
281 :
282 : static int
283 728265 : exps_mark_used(sql_rel *subrel, list *l, int local_proj)
284 : {
285 728265 : int nr = 0;
286 728265 : if (list_empty(l))
287 : return nr;
288 :
289 2359451 : for (node *n = l->h; n != NULL; n = n->next)
290 1631251 : nr += exp_mark_used(subrel, n->data, local_proj);
291 : return nr;
292 : }
293 :
294 : static int
295 6365973 : exp_mark_used(sql_rel *subrel, sql_exp *e, int local_proj)
296 : {
297 6530532 : int nr = 0;
298 6530532 : sql_exp *ne = NULL;
299 :
300 6530532 : switch(e->type) {
301 4382095 : case e_column:
302 4382095 : ne = rel_find_exp(subrel, e);
303 : /* if looking in the same projection, make sure 'ne' is projected before the searched column */
304 4382102 : if (ne && local_proj > -1 && list_position(subrel->exps, ne) >= local_proj)
305 5467594 : ne = NULL;
306 : break;
307 164559 : case e_convert:
308 164559 : return exp_mark_used(subrel, e->l, local_proj);
309 670852 : case e_aggr:
310 : case e_func: {
311 670852 : if (e->l)
312 658269 : nr += exps_mark_used(subrel, e->l, local_proj);
313 670852 : assert(!e->r);
314 : break;
315 : }
316 414639 : case e_cmp:
317 414639 : if (e->flag == cmp_or || e->flag == cmp_filter) {
318 23040 : nr += exps_mark_used(subrel, e->l, local_proj);
319 23040 : nr += exps_mark_used(subrel, e->r, local_proj);
320 391599 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
321 19526 : nr += exp_mark_used(subrel, e->l, local_proj);
322 19526 : nr += exps_mark_used(subrel, e->r, local_proj);
323 : } else {
324 372073 : nr += exp_mark_used(subrel, e->l, local_proj);
325 372073 : nr += exp_mark_used(subrel, e->r, local_proj);
326 372073 : if (e->f)
327 6419 : nr += exp_mark_used(subrel, e->f, local_proj);
328 : }
329 : break;
330 898387 : case e_atom:
331 : /* atoms are used in e_cmp */
332 898387 : e->used = 1;
333 : /* return 0 as constants may require a full column ! */
334 898387 : if (e->f)
335 4390 : nr += exps_mark_used(subrel, e->f, local_proj);
336 : return nr;
337 0 : case e_psm:
338 0 : if (e->flag & PSM_SET || e->flag & PSM_RETURN || e->flag & PSM_EXCEPTION) {
339 0 : nr += exp_mark_used(subrel, e->l, local_proj);
340 0 : } else if (e->flag & PSM_WHILE || e->flag & PSM_IF) {
341 0 : nr += exp_mark_used(subrel, e->l, local_proj);
342 0 : nr += exps_mark_used(subrel, e->r, local_proj);
343 0 : if (e->flag == PSM_IF && e->f)
344 0 : nr += exps_mark_used(subrel, e->f, local_proj);
345 : }
346 0 : e->used = 1;
347 0 : break;
348 : }
349 5467594 : if (ne && e != ne) {
350 2374672 : if (local_proj == -2 || ne->type != e_column || (has_label(ne) || (ne->alias.rname && ne->alias.rname[0] == '%')) || (subrel->l && !rel_find_exp(subrel->l, e)))
351 2278410 : ne->used = 1;
352 2374673 : return ne->used;
353 : }
354 : return nr;
355 : }
356 :
357 : static void
358 40600 : positional_exps_mark_used( sql_rel *rel, sql_rel *subrel )
359 : {
360 40600 : assert(rel->exps);
361 :
362 40600 : if ((is_topn(subrel->op) || is_sample(subrel->op)) && subrel->l)
363 40600 : subrel = subrel->l;
364 : /* everything is used within the set operation */
365 40600 : if (rel->exps && subrel->exps) {
366 40600 : node *m;
367 343684 : for (m=subrel->exps->h; m; m = m->next) {
368 303084 : sql_exp *se = m->data;
369 :
370 303084 : se->used = 1;
371 : }
372 : }
373 40600 : }
374 :
375 : static void
376 674347 : rel_exps_mark_used(allocator *sa, sql_rel *rel, sql_rel *subrel)
377 : {
378 674347 : int nr = 0;
379 :
380 674347 : if (rel->r && (is_simple_project(rel->op) || is_groupby(rel->op))) {
381 30780 : list *l = rel->r;
382 30780 : node *n;
383 :
384 106682 : for (n=l->h; n; n = n->next) {
385 75899 : sql_exp *e = n->data;
386 :
387 75899 : e->used = 1;
388 75899 : exp_mark_used(rel, e, -1);
389 : }
390 : }
391 674350 : if (rel->attr) {
392 25504 : for (node *n = rel->attr->h; n; n = n->next) {
393 12752 : sql_exp *e = n->data;
394 :
395 12752 : if (e->type != e_aggr) /* keep all group by's */
396 12752 : e->used = 1;
397 12752 : if (e->used)
398 12752 : nr += exp_mark_used(subrel, e, -2);
399 : }
400 : }
401 674350 : if (rel->exps) {
402 645487 : node *n;
403 645487 : int len = list_length(rel->exps), i;
404 645485 : sql_exp **exps = SA_NEW_ARRAY(sa, sql_exp*, len);
405 :
406 3274493 : for (n=rel->exps->h, i = 0; n; n = n->next, i++) {
407 2629008 : sql_exp *e = exps[i] = n->data;
408 :
409 2629008 : nr += e->used;
410 : }
411 :
412 645485 : if (!nr && is_project(rel->op) && len > 0) /* project at least one column if exists */
413 4965 : exps[0]->used = 1;
414 :
415 3274483 : for (i = len-1; i >= 0; i--) {
416 2629002 : sql_exp *e = exps[i];
417 :
418 2629002 : if (!is_project(rel->op) || e->used) {
419 2093290 : if (is_project(rel->op))
420 1706680 : nr += exp_mark_used(rel, e, i);
421 2093290 : nr += exp_mark_used(subrel, e, -2);
422 : }
423 : }
424 : }
425 : /* for count/rank we need atleast one column */
426 674344 : if (!nr && subrel && (is_project(subrel->op) || is_base(subrel->op)) && !list_empty(subrel->exps) &&
427 13028 : (is_simple_project(rel->op) && project_unsafe(rel, 0))) {
428 47 : sql_exp *e = subrel->exps->h->data;
429 47 : e->used = 1;
430 : }
431 674344 : if (rel->r && (is_simple_project(rel->op) || is_groupby(rel->op))) {
432 30779 : list *l = rel->r;
433 30779 : node *n;
434 :
435 106679 : for (n=l->h; n; n = n->next) {
436 75900 : sql_exp *e = n->data;
437 :
438 75900 : e->used = 1;
439 : /* possibly project/groupby uses columns from the inner */
440 75900 : exp_mark_used(subrel, e, -2);
441 : }
442 : }
443 674344 : }
444 :
445 : static void exps_used(list *l);
446 :
447 : static void
448 3304091 : exp_used(sql_exp *e)
449 : {
450 3322080 : if (e) {
451 3303927 : e->used = 1;
452 :
453 3303927 : switch (e->type) {
454 16790 : case e_convert:
455 16790 : exp_used(e->l);
456 16790 : break;
457 114988 : case e_func:
458 : case e_aggr:
459 114988 : exps_used(e->l);
460 114988 : break;
461 7958 : case e_cmp:
462 7958 : if (e->flag == cmp_or || e->flag == cmp_filter) {
463 1040 : exps_used(e->l);
464 1040 : exps_used(e->r);
465 6918 : } else if (e->flag == cmp_in || e->flag == cmp_notin) {
466 241 : exp_used(e->l);
467 241 : exps_used(e->r);
468 : } else {
469 6677 : exp_used(e->l);
470 6677 : exp_used(e->r);
471 6677 : if (e->f)
472 : exp_used(e->f);
473 : }
474 : break;
475 : default:
476 : break;
477 : }
478 : }
479 3304091 : }
480 :
481 : static void
482 888844 : exps_used(list *l)
483 : {
484 888844 : if (l) {
485 4176808 : for (node *n = l->h; n; n = n->next)
486 3289459 : exp_used(n->data);
487 : }
488 888840 : }
489 :
490 : static void
491 779661 : rel_used(sql_rel *rel)
492 : {
493 779661 : if (!rel)
494 : return;
495 736349 : if (is_join(rel->op) || is_set(rel->op) || is_semi(rel->op) || is_modify(rel->op)) {
496 71440 : rel_used(rel->l);
497 71439 : rel_used(rel->r);
498 : } else if (is_topn(rel->op) || is_select(rel->op) || is_sample(rel->op)) {
499 20796 : rel_used(rel->l);
500 20796 : rel = rel->l;
501 : } else if (is_ddl(rel->op)) {
502 417810 : if (rel->flag == ddl_output || rel->flag == ddl_create_seq || rel->flag == ddl_alter_seq || rel->flag == ddl_alter_table || rel->flag == ddl_create_table || rel->flag == ddl_create_view) {
503 34401 : rel_used(rel->l);
504 : } else if (rel->flag == ddl_list || rel->flag == ddl_exception) {
505 281 : rel_used(rel->l);
506 281 : rel_used(rel->r);
507 : } else if (rel->flag == ddl_psm) {
508 22304 : exps_used(rel->exps);
509 : }
510 : } else if (rel->op == op_table) {
511 1041 : if (IS_TABLE_PROD_FUNC(rel->flag) || rel->flag == TABLE_FROM_RELATION)
512 1041 : rel_used(rel->l);
513 1041 : exp_used(rel->r);
514 : }
515 865814 : if (rel && rel->exps) {
516 730440 : exps_used(rel->exps);
517 730436 : if (rel->r && (is_simple_project(rel->op) || is_groupby(rel->op)))
518 18791 : exps_used(rel->r);
519 : }
520 : }
521 :
522 : static void
523 1163646 : rel_mark_used(mvc *sql, sql_rel *rel, int proj)
524 : {
525 1727605 : if (proj && (need_distinct(rel)))
526 10130 : rel_used(rel);
527 :
528 1727605 : switch(rel->op) {
529 : case op_basetable:
530 : case op_truncate:
531 : case op_insert:
532 : break;
533 :
534 12275 : case op_table:
535 :
536 12275 : if (rel->l && rel->flag != TRIGGER_WRAPPER) {
537 122 : rel_used(rel);
538 122 : if (rel->r)
539 122 : exp_mark_used(rel->l, rel->r, -2);
540 122 : rel_mark_used(sql, rel->l, proj);
541 : }
542 : break;
543 :
544 16719 : case op_topn:
545 : case op_sample:
546 16719 : if (proj) {
547 16650 : rel = rel ->l;
548 16650 : rel_mark_used(sql, rel, proj);
549 16650 : break;
550 : }
551 : /* fall through */
552 : case op_project:
553 : case op_groupby:
554 430596 : if (proj && rel->l) {
555 247019 : rel_exps_mark_used(sql->sa, rel, rel->l);
556 247016 : rel_mark_used(sql, rel->l, 0);
557 7679 : } else if (proj) {
558 7610 : rel_exps_mark_used(sql->sa, rel, NULL);
559 : }
560 : break;
561 7309 : case op_update:
562 : case op_delete:
563 7309 : if (proj && rel->r) {
564 5999 : sql_rel *r = rel->r;
565 :
566 5999 : if (!list_empty(r->exps)) {
567 7099 : for (node *n = r->exps->h; n; n = n->next) {
568 6000 : sql_exp *e = n->data;
569 6000 : const char *nname = exp_name(e);
570 :
571 6000 : if (nname && nname[0] == '%' && strcmp(nname, TID) == 0) { /* TID is used */
572 4900 : e->used = 1;
573 4900 : break;
574 : }
575 : }
576 : }
577 5999 : rel_exps_mark_used(sql->sa, rel, rel->r);
578 5999 : rel_mark_used(sql, rel->r, 0);
579 : }
580 : break;
581 :
582 416428 : case op_ddl:
583 416428 : if (rel->flag == ddl_output || rel->flag == ddl_create_seq || rel->flag == ddl_alter_seq || rel->flag == ddl_alter_table || rel->flag == ddl_create_table || rel->flag == ddl_create_view) {
584 33019 : if (rel->l)
585 : rel_mark_used(sql, rel->l, 0);
586 : } else if (rel->flag == ddl_list || rel->flag == ddl_exception) {
587 281 : if (rel->l)
588 281 : rel_mark_used(sql, rel->l, 0);
589 281 : if (rel->r)
590 : rel_mark_used(sql, rel->r, 0);
591 : }
592 : break;
593 :
594 100245 : case op_select:
595 100245 : if (rel->l) {
596 100245 : rel_exps_mark_used(sql->sa, rel, rel->l);
597 100245 : rel_mark_used(sql, rel->l, 0);
598 : }
599 : break;
600 :
601 49474 : case op_union:
602 : case op_inter:
603 : case op_except:
604 : /* For now we mark all union expression as used */
605 :
606 : /* Later we should (in case of union all) remove unused
607 : * columns from the projection.
608 : *
609 : * Project part of union is based on column position.
610 : */
611 49474 : if (proj && (need_distinct(rel) || !rel->exps)) {
612 4283 : rel_used(rel);
613 4283 : if (!rel->exps) {
614 0 : rel_used(rel->l);
615 0 : rel_used(rel->r);
616 : }
617 4283 : rel_mark_used(sql, rel->l, 0);
618 4283 : rel_mark_used(sql, rel->r, 0);
619 20300 : } else if (proj && !need_distinct(rel)) {
620 20300 : sql_rel *l = rel->l;
621 :
622 20300 : positional_exps_mark_used(rel, l);
623 20300 : rel_exps_mark_used(sql->sa, rel, l);
624 20300 : rel_mark_used(sql, rel->l, 0);
625 : /* based on child check set expression list */
626 20300 : if (is_project(l->op) && need_distinct(l))
627 0 : positional_exps_mark_used(l, rel);
628 20300 : positional_exps_mark_used(rel, rel->r);
629 20300 : rel_exps_mark_used(sql->sa, rel, rel->r);
630 20300 : rel_mark_used(sql, rel->r, 0);
631 : }
632 : break;
633 :
634 136437 : case op_join:
635 : case op_left:
636 : case op_right:
637 : case op_full:
638 : case op_semi:
639 : case op_anti:
640 : case op_merge:
641 136437 : rel_exps_mark_used(sql->sa, rel, rel->l);
642 136437 : rel_exps_mark_used(sql->sa, rel, rel->r);
643 136437 : rel_mark_used(sql, rel->l, 0);
644 136437 : rel_mark_used(sql, rel->r, 0);
645 136437 : break;
646 : }
647 1163643 : }
648 :
649 : static sql_rel * rel_dce_sub(mvc *sql, sql_rel *rel);
650 :
651 : static sql_rel *
652 1058200 : rel_remove_unused(mvc *sql, sql_rel *rel)
653 : {
654 1058200 : int needed = 0;
655 :
656 1058200 : if (!rel)
657 : return rel;
658 :
659 1051895 : switch(rel->op) {
660 280388 : case op_basetable: {
661 280388 : sql_table *t = rel->l;
662 :
663 280388 : if (t && isReplicaTable(t)) /* TODO fix rewriting in rel_distribute.c */
664 : return rel;
665 : }
666 : /* fall through */
667 : case op_table:
668 286652 : if (rel->exps && (rel->op != op_table || !IS_TABLE_PROD_FUNC(rel->flag))) {
669 1255768 : for(node *n=rel->exps->h; n && !needed; n = n->next) {
670 975421 : sql_exp *e = n->data;
671 :
672 975421 : if (!e->used)
673 204389 : needed = 1;
674 : }
675 :
676 280347 : if (!needed)
677 : return rel;
678 :
679 1253254 : for(node *n=rel->exps->h; n;) {
680 1048865 : node *next = n->next;
681 1048865 : sql_exp *e = n->data;
682 :
683 : /* atleast one (needed for crossproducts, count(*), rank() and single value projections) !, handled by rel_exps_mark_used */
684 1048865 : if (!e->used && list_length(rel->exps) > 1)
685 359163 : list_remove_node(rel->exps, NULL, n);
686 : n = next;
687 : }
688 : }
689 210694 : if (rel->op == op_table && (IS_TABLE_PROD_FUNC(rel->flag) || rel->flag == TABLE_FROM_RELATION))
690 6305 : rel->l = rel_remove_unused(sql, rel->l);
691 : return rel;
692 :
693 16650 : case op_topn:
694 : case op_sample:
695 :
696 16650 : if (rel->l)
697 16650 : rel->l = rel_remove_unused(sql, rel->l);
698 : return rel;
699 :
700 254659 : case op_project:
701 : case op_groupby:
702 :
703 254659 : if (/*rel->l &&*/ rel->exps) {
704 1716812 : for(node *n=rel->exps->h; n && !needed; n = n->next) {
705 1462153 : sql_exp *e = n->data;
706 :
707 1462153 : if (!e->used)
708 24027 : needed = 1;
709 : }
710 254659 : if (!needed)
711 : return rel;
712 :
713 561109 : for(node *n=rel->exps->h; n;) {
714 537082 : node *next = n->next;
715 537082 : sql_exp *e = n->data;
716 :
717 : /* atleast one (needed for crossproducts, count(*), rank() and single value projections) */
718 537082 : if (!e->used && list_length(rel->exps) > 1)
719 415157 : list_remove_node(rel->exps, NULL, n);
720 : n = next;
721 : }
722 : }
723 : return rel;
724 :
725 3061 : case op_join:
726 : case op_left:
727 : case op_right:
728 : case op_full:
729 3061 : if (list_length(rel->attr) > 1) {
730 0 : for(node *n=rel->attr->h; n && !needed; n = n->next) {
731 0 : sql_exp *e = n->data;
732 :
733 0 : if (!e->used)
734 0 : needed = 1;
735 : }
736 0 : if (!needed)
737 : return rel;
738 :
739 0 : for(node *n=rel->attr->h; n;) {
740 0 : node *next = n->next;
741 0 : sql_exp *e = n->data;
742 :
743 0 : if (!e->used)
744 0 : list_remove_node(rel->attr, NULL, n);
745 : n = next;
746 : }
747 : }
748 : return rel;
749 :
750 : case op_union:
751 : case op_inter:
752 : case op_except:
753 :
754 : case op_insert:
755 : case op_update:
756 : case op_delete:
757 : case op_truncate:
758 : case op_merge:
759 :
760 : case op_select:
761 :
762 : case op_semi:
763 : case op_anti:
764 : return rel;
765 416154 : case op_ddl:
766 416154 : if (rel->flag == ddl_output || rel->flag == ddl_create_seq || rel->flag == ddl_alter_seq || rel->flag == ddl_alter_table || rel->flag == ddl_create_table || rel->flag == ddl_create_view) {
767 32789 : if (rel->l)
768 32430 : rel->l = rel_remove_unused(sql, rel->l);
769 : } else if (rel->flag == ddl_list || rel->flag == ddl_exception) {
770 237 : if (rel->l)
771 237 : rel->l = rel_remove_unused(sql, rel->l);
772 237 : if (rel->r)
773 237 : rel->r = rel_remove_unused(sql, rel->r);
774 : }
775 : return rel;
776 : }
777 : return rel;
778 : }
779 :
780 : static void
781 1251672 : rel_dce_refs(mvc *sql, sql_rel *rel, list *refs)
782 : {
783 1251672 : if (!rel || (rel_is_ref(rel) && list_find(refs, rel, NULL)))
784 12726 : return ;
785 :
786 1238946 : switch(rel->op) {
787 361447 : case op_table:
788 : case op_topn:
789 : case op_sample:
790 : case op_project:
791 : case op_groupby:
792 : case op_select:
793 :
794 361447 : if (rel->l && (rel->op != op_table || rel->flag != TRIGGER_WRAPPER))
795 348832 : rel_dce_refs(sql, rel->l, refs);
796 : break;
797 :
798 : case op_basetable:
799 : case op_insert:
800 : case op_truncate:
801 : break;
802 :
803 6116 : case op_update:
804 : case op_delete:
805 :
806 6116 : if (rel->r)
807 5999 : rel_dce_refs(sql, rel->r, refs);
808 : break;
809 :
810 155618 : case op_union:
811 : case op_inter:
812 : case op_except:
813 : case op_join:
814 : case op_left:
815 : case op_right:
816 : case op_full:
817 : case op_semi:
818 : case op_anti:
819 : case op_merge:
820 :
821 155618 : if (rel->l)
822 155618 : rel_dce_refs(sql, rel->l, refs);
823 155618 : if (rel->r)
824 155618 : rel_dce_refs(sql, rel->r, refs);
825 : break;
826 417527 : case op_ddl:
827 :
828 417527 : if (rel->flag == ddl_output || rel->flag == ddl_create_seq || rel->flag == ddl_alter_seq || rel->flag == ddl_alter_table || rel->flag == ddl_create_table || rel->flag == ddl_create_view) {
829 34118 : if (rel->l)
830 33759 : rel_dce_refs(sql, rel->l, refs);
831 : } else if (rel->flag == ddl_list || rel->flag == ddl_exception) {
832 281 : if (rel->l)
833 281 : rel_dce_refs(sql, rel->l, refs);
834 281 : if (rel->r)
835 247 : rel_dce_refs(sql, rel->r, refs);
836 : } break;
837 : }
838 :
839 1238948 : if (rel_is_ref(rel) && !list_find(refs, rel, NULL))
840 11919 : list_prepend(refs, rel);
841 : }
842 :
843 : static sql_rel *
844 1712421 : rel_dce_down(mvc *sql, sql_rel *rel, int skip_proj)
845 : {
846 1712421 : if (!rel)
847 : return rel;
848 :
849 1712421 : if (!skip_proj && rel_is_ref(rel))
850 : return rel;
851 :
852 1687565 : switch(rel->op) {
853 508332 : case op_basetable:
854 : case op_table:
855 :
856 508332 : if (skip_proj && rel->l && rel->op == op_table && rel->flag != TRIGGER_WRAPPER)
857 61 : rel->l = rel_dce_down(sql, rel->l, 0);
858 253932 : if (!skip_proj)
859 253932 : rel_dce_sub(sql, rel);
860 : /* fall through */
861 :
862 : case op_truncate:
863 : return rel;
864 :
865 2211 : case op_insert:
866 2211 : rel_used(rel->r);
867 2211 : rel_dce_sub(sql, rel->r);
868 2211 : return rel;
869 :
870 7309 : case op_update:
871 : case op_delete:
872 :
873 7309 : if (skip_proj && rel->r)
874 5999 : rel->r = rel_dce_down(sql, rel->r, 0);
875 1193 : if (!skip_proj)
876 1193 : rel_dce_sub(sql, rel);
877 : return rel;
878 :
879 439436 : case op_topn:
880 : case op_sample:
881 : case op_project:
882 : case op_groupby:
883 :
884 439436 : if (skip_proj && rel->l)
885 263627 : rel->l = rel_dce_down(sql, rel->l, is_topn(rel->op) || is_sample(rel->op));
886 168199 : if (!skip_proj)
887 168199 : rel_dce_sub(sql, rel);
888 : return rel;
889 :
890 47013 : case op_union:
891 : case op_inter:
892 : case op_except:
893 47013 : if (skip_proj) {
894 24581 : if (rel->l)
895 24581 : rel->l = rel_dce_down(sql, rel->l, 0);
896 24581 : if (rel->r)
897 24581 : rel->r = rel_dce_down(sql, rel->r, 0);
898 : }
899 22432 : if (!skip_proj)
900 22432 : rel_dce_sub(sql, rel);
901 : return rel;
902 :
903 92641 : case op_select:
904 92641 : if (rel->l)
905 92641 : rel->l = rel_dce_down(sql, rel->l, 0);
906 : return rel;
907 :
908 132700 : case op_join:
909 : case op_left:
910 : case op_right:
911 : case op_full:
912 : case op_semi:
913 : case op_anti:
914 : case op_merge:
915 132700 : if (rel->l)
916 132700 : rel->l = rel_dce_down(sql, rel->l, 0);
917 132700 : if (rel->r)
918 132700 : rel->r = rel_dce_down(sql, rel->r, 0);
919 132700 : if (!skip_proj && !list_empty(rel->attr))
920 3061 : rel_dce_sub(sql, rel);
921 : return rel;
922 :
923 416234 : case op_ddl:
924 416234 : if (rel->flag == ddl_output || rel->flag == ddl_create_seq || rel->flag == ddl_alter_seq || rel->flag == ddl_alter_table || rel->flag == ddl_create_table || rel->flag == ddl_create_view) {
925 32825 : if (rel->l)
926 32659 : rel->l = rel_dce_down(sql, rel->l, 0);
927 : } else if (rel->flag == ddl_list || rel->flag == ddl_exception) {
928 281 : if (rel->l)
929 281 : rel->l = rel_dce_down(sql, rel->l, 0);
930 281 : if (rel->r)
931 247 : rel->r = rel_dce_down(sql, rel->r, 0);
932 : }
933 : return rel;
934 : }
935 : return rel;
936 : }
937 :
938 : /* DCE
939 : *
940 : * Based on top relation expressions mark sub expressions as used.
941 : * Then recurse down until the projections. Clean them up and repeat.
942 : */
943 :
944 : static sql_rel *
945 1002343 : rel_dce_sub(mvc *sql, sql_rel *rel)
946 : {
947 1002343 : if (!rel)
948 : return rel;
949 :
950 : /*
951 : * Mark used up until the next project
952 : * For setops we need to first mark, then remove
953 : * because of positional dependency
954 : */
955 1002343 : rel_mark_used(sql, rel, 1);
956 1002342 : rel = rel_remove_unused(sql, rel);
957 1002344 : rel_dce_down(sql, rel, 1);
958 1002344 : return rel;
959 : }
960 :
961 : /* add projects under set ops */
962 : static sql_rel *
963 2025290 : rel_add_projects(mvc *sql, sql_rel *rel)
964 : {
965 2025290 : if (!rel)
966 : return rel;
967 :
968 2025290 : switch(rel->op) {
969 : case op_basetable:
970 : case op_truncate:
971 : return rel;
972 8327 : case op_insert:
973 : case op_update:
974 : case op_delete:
975 8327 : if (rel->r)
976 8210 : rel->r = rel_add_projects(sql, rel->r);
977 : return rel;
978 83924 : case op_union:
979 : case op_inter:
980 : case op_except:
981 : /* We can only reduce the list of expressions of an set op
982 : * if the projection under it can also be reduced.
983 : */
984 83924 : if (rel->l) {
985 83924 : sql_rel *l = rel->l;
986 :
987 83924 : if (!is_project(l->op) && !need_distinct(rel))
988 2 : l = rel_project(sql->sa, l, rel_projections(sql, l, NULL, 1, 1));
989 83924 : rel->l = rel_add_projects(sql, l);
990 : }
991 83924 : if (rel->r) {
992 83924 : sql_rel *r = rel->r;
993 :
994 83924 : if (!is_project(r->op) && !need_distinct(rel))
995 19 : r = rel_project(sql->sa, r, rel_projections(sql, r, NULL, 1, 1));
996 83924 : rel->r = rel_add_projects(sql, r);
997 : }
998 : return rel;
999 722653 : case op_topn:
1000 : case op_sample:
1001 : case op_project:
1002 : case op_groupby:
1003 : case op_select:
1004 : case op_table:
1005 722653 : if (rel->l && (rel->op != op_table || rel->flag != TRIGGER_WRAPPER))
1006 697119 : rel->l = rel_add_projects(sql, rel->l);
1007 : return rel;
1008 283120 : case op_join:
1009 : case op_left:
1010 : case op_right:
1011 : case op_full:
1012 : case op_semi:
1013 : case op_anti:
1014 : case op_merge:
1015 283120 : if (rel->l)
1016 283120 : rel->l = rel_add_projects(sql, rel->l);
1017 283120 : if (rel->r)
1018 283120 : rel->r = rel_add_projects(sql, rel->r);
1019 : return rel;
1020 417795 : case op_ddl:
1021 417795 : if (rel->flag == ddl_output || rel->flag == ddl_create_seq || rel->flag == ddl_alter_seq || rel->flag == ddl_alter_table || rel->flag == ddl_create_table || rel->flag == ddl_create_view) {
1022 34386 : if (rel->l)
1023 34027 : rel->l = rel_add_projects(sql, rel->l);
1024 : } else if (rel->flag == ddl_list || rel->flag == ddl_exception) {
1025 281 : if (rel->l)
1026 281 : rel->l = rel_add_projects(sql, rel->l);
1027 281 : if (rel->r)
1028 247 : rel->r = rel_add_projects(sql, rel->r);
1029 : }
1030 : return rel;
1031 : }
1032 : return rel;
1033 : }
1034 :
1035 : static sql_rel *
1036 551316 : rel_dce_(mvc *sql, sql_rel *rel)
1037 : {
1038 551316 : list *refs = sa_list(sql->sa);
1039 :
1040 551314 : rel_dce_refs(sql, rel, refs);
1041 551318 : if (refs) {
1042 563237 : for(node *n = refs->h; n; n = n->next) {
1043 11919 : sql_rel *i = n->data;
1044 :
1045 11919 : while (!rel_is_ref(i) && i->l && !is_base(i->op))
1046 : i = i->l;
1047 11919 : if (i)
1048 11919 : rel_used(i);
1049 : }
1050 : }
1051 551318 : rel = rel_add_projects(sql, rel);
1052 551318 : rel_used(rel);
1053 551314 : rel_dce_sub(sql, rel);
1054 551316 : return rel;
1055 : }
1056 :
1057 : /* Remove unused expressions */
1058 : static sql_rel *
1059 551316 : rel_dce(visitor *v, global_props *gp, sql_rel *rel)
1060 : {
1061 551316 : (void) gp;
1062 551316 : return rel_dce_(v->sql, rel);
1063 : }
1064 :
1065 : run_optimizer
1066 620627 : bind_dce(visitor *v, global_props *gp)
1067 : {
1068 620627 : int flag = v->sql->sql_optimizer;
1069 620627 : return gp->opt_cycle == 0 && gp->opt_level == 1 && (flag & dce) ? rel_dce : NULL;
1070 : }
1071 :
1072 :
1073 : static int
1074 85565 : topn_sample_safe_exps( list *exps, bool nil_limit )
1075 : {
1076 : /* Limit only expression lists are always save */
1077 85565 : if (list_length(exps) == 1)
1078 : return 1;
1079 1352 : for (node *n = exps->h; n; n = n->next ) {
1080 921 : sql_exp *e = n->data;
1081 :
1082 921 : if (!e || e->type != e_atom || (!nil_limit && exp_is_null(e)))
1083 59 : return 0;
1084 : }
1085 : return 1;
1086 : }
1087 :
1088 : static list *
1089 309 : sum_limit_offset(mvc *sql, sql_rel *rel)
1090 : {
1091 : /* for sample we always propagate, or if the expression list only consists of a limit expression, we copy it */
1092 309 : if (is_sample(rel->op) || list_length(rel->exps) == 1)
1093 304 : return exps_copy(sql, rel->exps);
1094 5 : assert(list_length(rel->exps) == 2);
1095 5 : sql_subtype *lng = sql_bind_localtype("lng");
1096 5 : sql_exp *add = rel_binop_(sql, NULL, exp_copy(sql, rel->exps->h->data), exp_copy(sql, rel->exps->h->next->data), "sys", "sql_add", card_value, true);
1097 : /* for remote plans, make sure the output type is a bigint */
1098 5 : if (subtype_cmp(lng, exp_subtype(add)) != 0)
1099 5 : add = exp_convert(sql->sa, add, exp_subtype(add), lng);
1100 5 : return list_append(sa_list(sql->sa), add);
1101 : }
1102 :
1103 : /*
1104 : * Push TopN (only LIMIT, no ORDER BY) down through projections underneath crossproduct, i.e.,
1105 : *
1106 : * topn( topn(
1107 : * project( project(
1108 : * crossproduct( crossproduct(
1109 : * L, => topn( L )[ n ],
1110 : * R topn( R )[ n ]
1111 : * ) )
1112 : * )[ Cs ]* )[ Cs ]*
1113 : * )[ n ] )[ n ]
1114 : *
1115 : * (TODO: in case of n==1 we can omit the original top-level TopN)
1116 : *
1117 : * also push topn under (non reordering) projections.
1118 : */
1119 : static sql_rel *
1120 134268 : rel_push_topn_and_sample_down_(visitor *v, sql_rel *rel)
1121 : {
1122 134268 : sql_rel *rp = NULL, *r = rel->l, *rpp = NULL;
1123 :
1124 134268 : if (is_topn(rel->op) && !rel_is_ref(rel) &&
1125 50914 : r && r->op == op_table && r->flag != TRIGGER_WRAPPER && !rel_is_ref(r) && r->r) {
1126 3 : sql_exp *op = r->r;
1127 3 : sql_subfunc *f = op->f;
1128 :
1129 3 : if (is_func(op->type) && strcmp(f->func->base.name, "file_loader") == 0 && !sql_func_mod(f->func)[0] && !sql_func_imp(f->func)[0]) {
1130 : /* push limit, to arguments of file_loader */
1131 0 : list *args = op->l;
1132 0 : if (list_length(args) == 2) {
1133 0 : sql_exp *topN = rel->exps->h->data;
1134 0 : sql_exp *offset = rel->exps->h->next? rel->exps->h->next->data:NULL;
1135 0 : atom *topn = topN->l;
1136 0 : if (offset) {
1137 0 : atom *b1 = (atom *)offset->l, *c = atom_add(v->sql->sa, b1, topn);
1138 :
1139 0 : if (!c)
1140 : return rel;
1141 0 : if (atom_cmp(c, topn) < 0) /* overflow */
1142 : return rel;
1143 : topn = c;
1144 : }
1145 0 : append(args, exp_atom(v->sql->sa, topn));
1146 0 : v->changes++;
1147 : }
1148 : }
1149 : }
1150 :
1151 134268 : if ((is_topn(rel->op) || is_sample(rel->op)) && topn_sample_safe_exps(rel->exps, true)) {
1152 50997 : sql_rel *(*func) (allocator *, sql_rel *, list *) = is_topn(rel->op) ? rel_topn : rel_sample;
1153 :
1154 : /* nested topN relations */
1155 50997 : if (r && is_topn(rel->op) && is_topn(r->op) && !rel_is_ref(r)) {
1156 0 : sql_exp *topN1 = rel->exps->h->data, *topN2 = r->exps->h->data;
1157 0 : sql_exp *offset1 = list_length(rel->exps) > 1 ? rel->exps->h->next->data : NULL;
1158 0 : sql_exp *offset2 = list_length(r->exps) > 1 ? r->exps->h->next->data : NULL;
1159 :
1160 0 : if (topN1->l && topN2->l && (!offset1 || offset1->l) && (!offset2 || offset2->l)) { /* no parameters */
1161 0 : bool changed = false;
1162 :
1163 0 : if ((!offset1 || (offset1->type == e_atom && offset1->l)) && (!offset2 || (offset2->type == e_atom && offset2->l))) { /* only atoms */
1164 0 : if (!offset1 && offset2) {
1165 0 : list_append(rel->exps, exp_copy(v->sql, offset2));
1166 0 : changed = true;
1167 0 : } else if (offset1 && offset2) { /* sum offsets */
1168 0 : atom *b1 = (atom *)offset1->l, *b2 = (atom *)offset2->l, *c = atom_add(v->sql->sa, b1, b2);
1169 :
1170 0 : if (!c) /* error, don't apply optimization, WARNING because of this the offset optimization must come before the limit one */
1171 : return rel;
1172 0 : if (atom_cmp(c, b2) < 0) /* overflow */
1173 0 : c = atom_int(v->sql->sa, sql_bind_localtype("lng"), GDK_lng_max);
1174 0 : offset1->l = c;
1175 0 : changed = true;
1176 : }
1177 : }
1178 :
1179 0 : if (topN1->type == e_atom && topN1->l && topN2->type == e_atom && topN2->l) { /* only atoms */
1180 0 : atom *a1 = (atom *)topN1->l, *a2 = (atom *)topN2->l;
1181 :
1182 0 : if (!a2->isnull && (a1->isnull || atom_cmp(a1, a2) >= 0)) { /* topN1 is not set or is larger than topN2 */
1183 0 : rel->exps->h->data = exp_copy(v->sql, topN2);
1184 0 : changed = true;
1185 : }
1186 : }
1187 :
1188 0 : if (changed) {
1189 0 : rel->l = r->l;
1190 0 : r->l = NULL;
1191 0 : rel_destroy(r);
1192 0 : v->changes++;
1193 0 : return rel;
1194 : }
1195 : }
1196 : }
1197 :
1198 50997 : if (r && is_simple_project(r->op) && need_distinct(r))
1199 : return rel;
1200 :
1201 : /* push topn/sample under projections */
1202 50992 : if (!rel_is_ref(rel) && r && is_simple_project(r->op) && !need_distinct(r) && !rel_is_ref(r) && r->l && list_empty(r->r)) {
1203 : sql_rel *x = r, *px = x;
1204 :
1205 32880 : while (is_simple_project(x->op) && !need_distinct(x) && !rel_is_ref(x) && x->l && list_empty(x->r)) {
1206 16459 : px = x;
1207 16459 : x = x->l;
1208 : }
1209 : /* only push topn once */
1210 16421 : if (x && x->op == rel->op)
1211 : return rel;
1212 :
1213 16408 : rel->l = x;
1214 16408 : px->l = rel;
1215 16408 : rel = r;
1216 16408 : v->changes++;
1217 16408 : return rel;
1218 : }
1219 :
1220 34571 : if (!topn_sample_safe_exps(rel->exps, false))
1221 : return rel;
1222 :
1223 : /* duplicate topn/sample direct under union or crossproduct */
1224 34512 : if (r && !rel_is_ref(r) && r->l && r->r && ((is_union(r->op) && r->exps) || (r->op == op_join && list_empty(r->exps)))) {
1225 198 : sql_rel *u = r, *x;
1226 198 : sql_rel *ul = u->l;
1227 198 : sql_rel *ur = u->r;
1228 198 : bool changed = false;
1229 :
1230 198 : x = ul;
1231 260 : while (is_simple_project(x->op) && !need_distinct(x) && !rel_is_ref(x) && x->l && list_empty(x->r))
1232 62 : x = x->l;
1233 198 : if (x && x->op != rel->op) { /* only push topn once */
1234 79 : ul = func(v->sql->sa, ul, sum_limit_offset(v->sql, rel));
1235 79 : set_processed(ul);
1236 79 : u->l = ul;
1237 79 : changed = true;
1238 : }
1239 :
1240 198 : x = ur;
1241 253 : while (is_simple_project(x->op) && !need_distinct(x) && !rel_is_ref(x) && x->l && list_empty(x->r))
1242 55 : x = x->l;
1243 198 : if (x && x->op != rel->op) { /* only push topn once */
1244 78 : ur = func(v->sql->sa, ur, sum_limit_offset(v->sql, rel));
1245 78 : set_processed(ur);
1246 78 : u->r = ur;
1247 78 : changed = true;
1248 : }
1249 :
1250 198 : if (changed)
1251 80 : v->changes++;
1252 198 : return rel;
1253 : }
1254 :
1255 : /* duplicate topn/sample + [ project-order ] under union */
1256 : if (r && !rp)
1257 34314 : rp = r->l;
1258 34314 : if (r && r->exps && is_simple_project(r->op) && !rel_is_ref(r) && !list_empty(r->r) && r->l && is_union(rp->op)) {
1259 178 : sql_rel *u = rp, *ou = u, *x, *ul = u->l, *ur = u->r;
1260 178 : list *rcopy = NULL;
1261 :
1262 : /* only push topn/sample once */
1263 178 : x = ul;
1264 223 : while (is_simple_project(x->op) && !need_distinct(x) && !rel_is_ref(x) && x->l && list_empty(x->r))
1265 45 : x = x->l;
1266 178 : if (x && x->op == rel->op)
1267 : return rel;
1268 : x = ur;
1269 161 : while (is_simple_project(x->op) && !need_distinct(x) && !rel_is_ref(x) && x->l && list_empty(x->r))
1270 89 : x = x->l;
1271 72 : if (x && x->op == rel->op)
1272 : return rel;
1273 :
1274 72 : rcopy = exps_copy(v->sql, r->r);
1275 239 : for (node *n = rcopy->h ; n ; n = n->next) {
1276 167 : sql_exp *e = n->data;
1277 167 : set_descending(e); /* remove ordering properties for projected columns */
1278 167 : set_nulls_first(e);
1279 : }
1280 72 : ul = rel_dup(ul);
1281 72 : ur = rel_dup(ur);
1282 72 : if (!is_project(ul->op))
1283 1 : ul = rel_project(v->sql->sa, ul,
1284 : rel_projections(v->sql, ul, NULL, 1, 1));
1285 72 : if (!is_project(ur->op))
1286 1 : ur = rel_project(v->sql->sa, ur,
1287 : rel_projections(v->sql, ur, NULL, 1, 1));
1288 72 : rel_rename_exps(v->sql, u->exps, ul->exps);
1289 72 : rel_rename_exps(v->sql, u->exps, ur->exps);
1290 :
1291 : /* introduce projects under the set */
1292 72 : ul = rel_project(v->sql->sa, ul, NULL);
1293 72 : ul->exps = exps_copy(v->sql, r->exps);
1294 : /* possibly add order by column */
1295 72 : ul->exps = list_distinct(list_merge(ul->exps, exps_copy(v->sql, rcopy), NULL), (fcmp) exp_equal, (fdup) NULL);
1296 72 : ul->nrcols = list_length(ul->exps);
1297 72 : ul->r = exps_copy(v->sql, r->r);
1298 72 : set_processed(ul);
1299 72 : ul = func(v->sql->sa, ul, sum_limit_offset(v->sql, rel));
1300 72 : set_processed(ul);
1301 :
1302 72 : ur = rel_project(v->sql->sa, ur, NULL);
1303 72 : ur->exps = exps_copy(v->sql, r->exps);
1304 : /* possibly add order by column */
1305 72 : ur->exps = list_distinct(list_merge(ur->exps, exps_copy(v->sql, rcopy), NULL), (fcmp) exp_equal, (fdup) NULL);
1306 72 : ur->nrcols = list_length(ur->exps);
1307 72 : ur->r = exps_copy(v->sql, r->r);
1308 72 : set_processed(ur);
1309 72 : ur = func(v->sql->sa, ur, sum_limit_offset(v->sql, rel));
1310 72 : set_processed(ur);
1311 :
1312 72 : u = rel_setop(v->sql->sa, ul, ur, op_union);
1313 72 : u->exps = exps_alias(v->sql, r->exps);
1314 72 : u->nrcols = list_length(u->exps);
1315 72 : set_processed(u);
1316 : /* possibly add order by column */
1317 72 : u->exps = list_distinct(list_merge(u->exps, rcopy, NULL), (fcmp) exp_equal, (fdup) NULL);
1318 72 : if (need_distinct(r)) {
1319 0 : set_distinct(ul);
1320 0 : set_distinct(ur);
1321 : }
1322 :
1323 : /* zap names */
1324 72 : rel_no_rename_exps(u->exps);
1325 72 : rel_destroy(ou);
1326 :
1327 72 : ur = rel_project(v->sql->sa, u, exps_alias(v->sql, r->exps));
1328 72 : ur->r = r->r;
1329 72 : r->l = NULL;
1330 :
1331 72 : if (need_distinct(r))
1332 0 : set_distinct(ur);
1333 :
1334 72 : rel_destroy(r);
1335 72 : rel->l = ur;
1336 72 : v->changes++;
1337 72 : return rel;
1338 : }
1339 : /* a left outer join b order by a.* limit L, can be copied into a */
1340 : /* topn ( project (orderby)( optional project ( left ())
1341 : * rel r rp */
1342 34136 : if (r && !rp)
1343 64 : rp = r->l;
1344 34136 : if (r && rp && is_simple_project(rp->op) && !rp->r && rp->l)
1345 34136 : rpp = rp->l;
1346 34136 : if (r && r->exps && is_simple_project(r->op) && !rel_is_ref(r) && r->r && r->l && ((!rpp && is_left(rp->op)) ||
1347 544 : (rpp && is_left(rpp->op)))) {
1348 23 : sql_rel *lj = rpp?rpp:rp;
1349 23 : sql_rel *l = lj->l;
1350 23 : list *obes = r->r, *nobes = sa_list(v->sql->sa);
1351 23 : int fnd = 1;
1352 63 : for (node *n = obes->h; n && fnd; n = n->next) {
1353 40 : sql_exp *obe = n->data;
1354 40 : int asc = is_ascending(obe);
1355 40 : int nl = nulls_last(obe);
1356 : /* only simple rename expressions */
1357 40 : sql_exp *pe = exps_find_exp(r->exps, obe);
1358 40 : if (pe && rpp)
1359 32 : pe = exps_find_exp(rp->exps, pe);
1360 40 : if (pe)
1361 40 : pe = rel_find_exp(l, pe);
1362 40 : if (pe) {
1363 40 : pe = exp_ref(v->sql, pe);
1364 40 : if (asc)
1365 30 : set_ascending(pe);
1366 40 : if (nl)
1367 5 : set_nulls_last(pe);
1368 40 : append(nobes, pe);
1369 : }
1370 : else
1371 : fnd = 0;
1372 : }
1373 23 : if (fnd && ((is_topn(rel->op) && !is_topn(l->op)) || (is_sample(rel->op) && !is_sample(l->op)))) {
1374 : /* inject topn */
1375 : /* Todo add order by */
1376 8 : sql_rel *ob = lj->l = rel_project(v->sql->sa, lj->l, rel_projections(v->sql, lj->l, NULL, 1, 1));
1377 8 : ob->r = nobes;
1378 8 : lj->l = func(v->sql->sa, lj->l, sum_limit_offset(v->sql, rel));
1379 8 : v->changes++;
1380 8 : return rel;
1381 : }
1382 : }
1383 : }
1384 : return rel;
1385 : }
1386 :
1387 : static sql_rel *
1388 33594 : rel_push_topn_and_sample_down(visitor *v, global_props *gp, sql_rel *rel)
1389 : {
1390 33594 : (void) gp;
1391 33594 : return rel_visitor_topdown(v, rel, &rel_push_topn_and_sample_down_);
1392 : }
1393 :
1394 : run_optimizer
1395 620626 : bind_push_topn_and_sample_down(visitor *v, global_props *gp)
1396 : {
1397 620626 : int flag = v->sql->sql_optimizer;
1398 620430 : return gp->opt_level == 1 && (gp->cnt[op_topn] || gp->cnt[op_sample]) &&
1399 654220 : (flag & push_topn_and_sample_down) ? rel_push_topn_and_sample_down : NULL;
1400 : }
|
