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 "opt_mergetable.h"
15 :
16 : typedef enum mat_type_t {
17 : mat_none = 0, /* Simple mat aligned operations (ie batcalc etc) */
18 : mat_grp = 1, /* result of phase one of a mat - group.new/derive */
19 : mat_ext = 2, /* mat_grp extend */
20 : mat_cnt = 3, /* mat_grp count */
21 : mat_tpn = 4, /* Phase one of topn on a mat */
22 : mat_slc = 5, /* Last phase of topn (or just slice) on a mat */
23 : mat_rdr = 6 /* Phase one of sorting, ie sorted the parts so far */
24 : } mat_type_t;
25 :
26 : typedef struct mat {
27 : InstrPtr mi; /* mat instruction */
28 : InstrPtr org; /* orignal instruction */
29 : int mv; /* mat variable */
30 : int im; /* input mat, for attribute of sub relations */
31 : int pm; /* parent mat, for sub relations */
32 : mat_type_t type; /* type of operation */
33 : int packed;
34 : int pushed; /* set if instruction pushed and shouldn't be freed */
35 : } mat_t;
36 :
37 : typedef struct matlist {
38 : mat_t *v;
39 : int *vars; /* result variable is a mat */
40 : int top;
41 : int size;
42 :
43 : int *horigin;
44 : int *torigin;
45 : int vsize;
46 : } matlist_t;
47 :
48 : static inline mat_type_t
49 : mat_type(mat_t *mat, int n)
50 : {
51 251394 : mat_type_t type = mat_none;
52 : (void) mat;
53 : (void) n;
54 : return type;
55 : }
56 :
57 : static inline int
58 28455836 : is_a_mat(int idx, const matlist_t *ml)
59 : {
60 28455836 : if (ml->vars[idx] >= 0 && !ml->v[ml->vars[idx]].packed)
61 8071389 : return ml->vars[idx];
62 : return -1;
63 : }
64 :
65 : static int
66 5749795 : nr_of_mats(InstrPtr p, const matlist_t *ml)
67 : {
68 5749795 : int j, cnt = 0;
69 27121652 : for (j = p->retc; j < p->argc; j++)
70 21371857 : if (is_a_mat(getArg(p, j), ml) >= 0)
71 2285408 : cnt++;
72 5749795 : return cnt;
73 : }
74 :
75 : static int
76 1195611 : nr_of_bats(MalBlkPtr mb, InstrPtr p)
77 : {
78 1195611 : int j, cnt = 0;
79 4378542 : for (j = p->retc; j < p->argc; j++)
80 3182931 : if (isaBatType(getArgType(mb, p, j))
81 2743760 : && !isVarConstant(mb, getArg(p, j)))
82 2568971 : cnt++;
83 1195611 : return cnt;
84 : }
85 :
86 : static int
87 1195611 : nr_of_nilbats(MalBlkPtr mb, InstrPtr p)
88 : {
89 1195611 : int j, cnt = 0;
90 4378542 : for (j = p->retc; j < p->argc; j++)
91 3182931 : if (isaBatType(getArgType(mb, p, j))
92 3182931 : && isVarConstant(mb, getArg(p, j))
93 174789 : && getVarConstant(mb, getArg(p, j)).val.bval == bat_nil)
94 174789 : cnt++;
95 1195611 : return cnt;
96 : }
97 :
98 : /* some mat's have intermediates (with intermediate result variables),
99 : * therefore we pass the old output mat variable */
100 : inline static int
101 1398958 : mat_add_var(matlist_t *ml, InstrPtr q, InstrPtr p, int var, mat_type_t type,
102 : int inputmat, int parentmat, int pushed)
103 : {
104 1398958 : if (ml->top == ml->size) {
105 0 : int s = ml->size * 2;
106 0 : mat_t *v = (mat_t *) GDKzalloc(s * sizeof(mat_t));
107 0 : if (!v)
108 : return -1;
109 0 : memcpy(v, ml->v, ml->top * sizeof(mat_t));
110 0 : GDKfree(ml->v);
111 0 : ml->size = s;
112 0 : ml->v = v;
113 : }
114 1398958 : mat_t *dst = &ml->v[ml->top];
115 1398958 : dst->mi = q;
116 1398958 : dst->org = p;
117 1398958 : dst->mv = var;
118 1398958 : dst->type = type;
119 1398958 : dst->im = inputmat;
120 1398958 : dst->pm = parentmat;
121 1398958 : dst->packed = 0;
122 1398958 : dst->pushed = pushed;
123 1398958 : if (ml->vars[var] < 0 || dst->type != mat_ext) {
124 1388747 : if (ml->vars[var] >= 0) {
125 0 : ml->v[ml->vars[var]].packed = 1;
126 : }
127 1388747 : ml->vars[var] = ml->top;
128 : }
129 1398958 : ++ml->top;
130 1398958 : return 0;
131 : }
132 :
133 : inline static int
134 879848 : mat_add(matlist_t *ml, InstrPtr q, mat_type_t type, const char *func)
135 : {
136 879848 : (void) func;
137 : //printf (" ml.top %d %s\n", ml.top, func);
138 879848 : return mat_add_var(ml, q, NULL, getArg(q, 0), type, -1, -1, 0);
139 : }
140 :
141 : static void
142 156217 : matlist_pack(matlist_t *ml, int m)
143 : {
144 156217 : int i, idx = ml->v[m].mv;
145 :
146 156217 : assert(ml->v[m].packed == 0);
147 156217 : ml->v[m].packed = 1;
148 156217 : ml->vars[idx] = -1;
149 :
150 34486180 : for (i = 0; i < ml->top; i++)
151 34329963 : if (!ml->v[i].packed && ml->v[i].mv == idx) {
152 0 : ml->vars[idx] = i;
153 0 : break;
154 : }
155 156217 : }
156 :
157 : static str
158 156217 : mat_pack(MalBlkPtr mb, matlist_t *ml, int m)
159 : {
160 156217 : InstrPtr r;
161 :
162 156217 : if (ml->v[m].packed)
163 : return MAL_SUCCEED;
164 :
165 156217 : if ((ml->v[m].mi->argc - ml->v[m].mi->retc) == 1) {
166 : /* simple assignment is sufficient */
167 0 : r = newInstruction(mb, NULL, NULL);
168 0 : if (r == NULL) {
169 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
170 : }
171 0 : getArg(r, 0) = getArg(ml->v[m].mi, 0);
172 0 : getArg(r, 1) = getArg(ml->v[m].mi, 1);
173 0 : r->retc = 1;
174 0 : r->argc = 2;
175 : } else {
176 156217 : int l;
177 :
178 156217 : r = newInstructionArgs(mb, matRef, packRef, ml->v[m].mi->argc);
179 156217 : if (r == NULL) {
180 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
181 : }
182 156217 : getArg(r, 0) = getArg(ml->v[m].mi, 0);
183 769557 : for (l = ml->v[m].mi->retc; l < ml->v[m].mi->argc; l++)
184 613340 : r = pushArgument(mb, r, getArg(ml->v[m].mi, l));
185 156217 : if (mb->errors) {
186 0 : freeInstruction(r);
187 0 : char *msg = mb->errors;
188 0 : mb->errors = NULL;
189 0 : return msg;
190 : }
191 : }
192 156217 : matlist_pack(ml, m);
193 156217 : pushInstruction(mb, r);
194 156217 : return MAL_SUCCEED;
195 : }
196 :
197 : static int
198 25917894 : checksize(matlist_t *ml, int v)
199 : {
200 25917894 : if (v >= ml->vsize) {
201 9266 : int sz = ml->vsize, i, *nhorigin, *ntorigin, *nvars;
202 :
203 9266 : int nvsize = ml->vsize * 2;
204 9266 : assert(v < nvsize);
205 9266 : if (v >= nvsize)
206 : nvsize = v + 10;
207 9266 : nhorigin = (int *) GDKrealloc(ml->horigin, sizeof(int) * nvsize);
208 9266 : if (nhorigin == NULL)
209 : return -1;
210 9266 : ml->horigin = nhorigin;
211 9266 : ntorigin = (int *) GDKrealloc(ml->torigin, sizeof(int) * nvsize);
212 9266 : if (ntorigin == NULL)
213 : return -1;
214 9266 : ml->torigin = ntorigin;
215 9266 : nvars = (int *) GDKrealloc(ml->vars, sizeof(int) * nvsize);
216 9266 : if (nvars == NULL)
217 : return -1;
218 9266 : ml->vars = nvars;
219 9266 : ml->vsize = nvsize;
220 :
221 8380210 : for (i = sz; i < ml->vsize; i++) {
222 8370944 : ml->horigin[i] = ml->torigin[i] = -1;
223 8370944 : ml->vars[i] = -1;
224 : }
225 : }
226 : return 0;
227 : }
228 :
229 : static int
230 5125078 : setPartnr(matlist_t *ml, int ivar, int ovar, int pnr)
231 : {
232 5125078 : int tpnr = -1;
233 :
234 5125078 : if (checksize(ml, ivar) || checksize(ml, ovar))
235 0 : return -1;
236 5125078 : if (ivar >= 0)
237 3292747 : tpnr = ml->torigin[ivar];
238 3292747 : if (tpnr >= 0)
239 110802 : ml->torigin[ovar] = tpnr;
240 5125078 : assert(ovar < ml->vsize);
241 5125078 : ml->horigin[ovar] = pnr;
242 : //printf("%d %d ", pnr, tpnr);
243 5125078 : return 0;
244 : }
245 :
246 : static int
247 397868 : propagatePartnr(matlist_t *ml, int ivar, int ovar, int pnr)
248 : {
249 : /* prop head ids to tail */
250 397868 : int tpnr = -1;
251 :
252 397868 : if (checksize(ml, ivar) || checksize(ml, ovar))
253 0 : return -1;
254 397868 : if (ivar >= 0)
255 397868 : tpnr = ml->horigin[ivar];
256 397868 : if (tpnr >= 0)
257 208388 : ml->torigin[ovar] = tpnr;
258 397868 : assert(ovar < ml->vsize);
259 397868 : ml->horigin[ovar] = pnr;
260 : //printf("%d %d ", pnr, tpnr);
261 397868 : return 0;
262 : }
263 :
264 : static int
265 355197 : propagateMirror(matlist_t *ml, int ivar, int ovar)
266 : {
267 : /* prop head ids to head and tail */
268 355197 : int tpnr;
269 :
270 355197 : if (checksize(ml, ivar) || checksize(ml, ovar))
271 0 : return -1;
272 355197 : tpnr = ml->horigin[ivar];
273 355197 : if (tpnr >= 0) {
274 355197 : assert(ovar < ml->vsize);
275 355197 : ml->horigin[ovar] = tpnr;
276 355197 : ml->torigin[ovar] = tpnr;
277 : }
278 : return 0;
279 : }
280 :
281 : static int
282 7080804 : overlap(matlist_t *ml, int lv, int rv, int lnr, int rnr, int ontails)
283 : {
284 7080804 : int lpnr, rpnr;
285 :
286 7080804 : if (checksize(ml, lv) || checksize(ml, rv))
287 0 : return -1;
288 7080804 : lpnr = ml->torigin[lv];
289 7080804 : rpnr = (ontails) ? ml->torigin[rv] : ml->horigin[rv];
290 :
291 7080804 : if (lpnr < 0 && rpnr < 0)
292 0 : return lnr == rnr;
293 7080804 : if (rpnr < 0)
294 36908 : return lpnr == rnr;
295 7043896 : if (lpnr < 0)
296 521343 : return rpnr == lnr;
297 6522553 : return lpnr == rpnr;
298 : }
299 :
300 : static int
301 242631 : mat_set_prop(matlist_t *ml, MalBlkPtr mb, InstrPtr p)
302 : {
303 242631 : int k, tpe = getArgType(mb, p, 0);
304 :
305 242631 : tpe = getBatType(tpe);
306 1182424 : for (k = 1; k < p->argc; k++) {
307 939793 : if (setPartnr(ml, -1, getArg(p, k), k))
308 : return -1;
309 939793 : if (tpe == TYPE_oid && propagateMirror(ml, getArg(p, k), getArg(p, k)))
310 : return -1;
311 : }
312 : return 0;
313 : }
314 :
315 : static InstrPtr
316 92515 : mat_delta(matlist_t *ml, MalBlkPtr mb, InstrPtr p, mat_t *mat, int m, int n,
317 : int o, int e, int mvar, int nvar, int ovar, int evar)
318 : {
319 92515 : int tpe, k, j, is_subdelta = (getFunctionId(p) == subdeltaRef),
320 92515 : is_projectdelta = (getFunctionId(p) == projectdeltaRef);
321 92515 : InstrPtr r = NULL;
322 92515 : int pushed = 0;
323 :
324 : //printf("# %s.%s(%d,%d,%d,%d)", getModuleId(p), getFunctionId(p), m, n, o, e);
325 :
326 92515 : if ((r = newInstructionArgs(mb, matRef, packRef, mat[m].mi->argc)) == NULL)
327 : return NULL;
328 92515 : getArg(r, 0) = getArg(p, 0);
329 92515 : tpe = getArgType(mb, p, 0);
330 :
331 : /* Handle like mat_projection, ie overlapping partitions */
332 92515 : if (evar == 1 && mat[e].mi->argc != mat[m].mi->argc) {
333 : int nr = 1;
334 0 : for (k = 1; k < mat[e].mi->argc; k++) {
335 0 : for (j = 1; j < mat[m].mi->argc; j++) {
336 0 : InstrPtr q;
337 0 : switch (overlap(ml, getArg(mat[e].mi, k), getArg(mat[m].mi, j), k, j, 0)) {
338 0 : case 0:
339 0 : continue;
340 : case -1:
341 : return NULL;
342 0 : case 1:
343 0 : q = copyInstruction(p);
344 0 : if (!q) {
345 0 : freeInstruction(r);
346 0 : return NULL;
347 : }
348 0 : getArg(q, 0) = newTmpVariable(mb, tpe);
349 0 : getArg(q, mvar) = getArg(mat[m].mi, j);
350 0 : getArg(q, nvar) = getArg(mat[n].mi, j);
351 0 : getArg(q, ovar) = getArg(mat[o].mi, j);
352 0 : getArg(q, evar) = getArg(mat[e].mi, k);
353 0 : pushInstruction(mb, q);
354 0 : if (mb->errors) {
355 0 : freeInstruction(r);
356 0 : return NULL;
357 : }
358 0 : if (setPartnr(ml, getArg(mat[m].mi, j), getArg(q, 0), nr)) {
359 0 : freeInstruction(r);
360 0 : return NULL;
361 : }
362 0 : r = pushArgument(mb, r, getArg(q, 0));
363 :
364 0 : nr++;
365 0 : break;
366 : }
367 : }
368 : }
369 : } else {
370 432695 : for (k = 1; k < mat[m].mi->argc; k++) {
371 340180 : InstrPtr q = copyInstruction(p);
372 340180 : if (!q) {
373 0 : freeInstruction(r);
374 0 : return NULL;
375 : }
376 340180 : getArg(q, 0) = newTmpVariable(mb, tpe);
377 340180 : getArg(q, mvar) = getArg(mat[m].mi, k);
378 340180 : getArg(q, nvar) = getArg(mat[n].mi, k);
379 340180 : getArg(q, ovar) = getArg(mat[o].mi, k);
380 340180 : if (e >= 0)
381 113029 : getArg(q, evar) = getArg(mat[e].mi, k);
382 340180 : pushInstruction(mb, q);
383 340180 : if (mb->errors) {
384 0 : freeInstruction(r);
385 0 : return NULL;
386 : }
387 340180 : if (setPartnr(ml, is_subdelta ? getArg(mat[m].mi, k) : -1, getArg(q, 0), k)) {
388 0 : freeInstruction(r);
389 0 : return NULL;
390 : }
391 340180 : r = pushArgument(mb, r, getArg(q, 0));
392 : }
393 92515 : if (evar == 1 && e >= 0 && mat[e].type == mat_slc && is_projectdelta) {
394 0 : InstrPtr q = newInstruction(mb, algebraRef, projectionRef);
395 0 : if (q == NULL) {
396 0 : freeInstruction(r);
397 0 : return NULL;
398 : }
399 0 : getArg(q, 0) = getArg(r, 0);
400 0 : q = pushArgument(mb, q, getArg(mat[e].mi, 0));
401 0 : getArg(r, 0) = newTmpVariable(mb, tpe);
402 0 : q = pushArgument(mb, q, getArg(r, 0));
403 0 : pushInstruction(mb, r);
404 0 : pushInstruction(mb, q);
405 0 : if (mb->errors)
406 : return NULL;
407 : pushed = 1;
408 : r = q;
409 : }
410 : }
411 92515 : if (mat_add_var(ml, r, NULL, getArg(r, 0), mat_type(mat, m), -1, -1, pushed)) {
412 0 : freeInstruction(r);
413 0 : return NULL;
414 : }
415 92515 : if (pushed)
416 0 : matlist_pack(ml, ml->top - 1);
417 : return r;
418 : }
419 :
420 : static InstrPtr
421 3 : mat_assign(MalBlkPtr mb, InstrPtr p, matlist_t *ml)
422 : {
423 3 : InstrPtr r = NULL;
424 3 : mat_t *mat = ml->v;
425 :
426 9 : for (int i = 0; i < p->retc; i++) {
427 6 : int m = is_a_mat(getArg(p, p->retc + i), ml);
428 6 : assert(is_a_mat(getArg(p, i), ml) < 0 && m >= 0);
429 :
430 6 : if ((r = newInstructionArgs(mb, matRef, packRef, mat[m].mi->argc)) == NULL)
431 : return NULL;
432 6 : getArg(r, 0) = getArg(p, i);
433 30 : for (int k = 1; k < mat[m].mi->argc; k++) {
434 : /* reuse inputs of old mat */
435 24 : r = pushArgument(mb, r, getArg(mat[m].mi, k));
436 24 : if (setPartnr(ml, -1, getArg(mat[m].mi, k), k)) {
437 0 : freeInstruction(r);
438 0 : return NULL;
439 : }
440 : }
441 6 : if (mat_add(ml, r, mat_none, getFunctionId(p))) {
442 0 : freeInstruction(r);
443 0 : return NULL;
444 : }
445 : }
446 : return r;
447 : }
448 :
449 : static int
450 6418 : mat_apply1(MalBlkPtr mb, InstrPtr p, matlist_t *ml, int m, int var)
451 : {
452 6418 : int tpe, k, is_select = isSelect(p),
453 6418 : is_mirror = (getFunctionId(p) == mirrorRef);
454 12836 : int is_identity = (getFunctionId(p) == identityRef
455 6418 : && getModuleId(p) == batcalcRef);
456 6418 : int ident_var = 0, is_assign = (getFunctionId(p) == NULL), n = 0;
457 6418 : InstrPtr r = NULL, q;
458 6418 : mat_t *mat = ml->v;
459 :
460 6418 : assert(!is_assign);
461 :
462 6418 : assert(p->retc == 1);
463 :
464 : /* Find the mat we overwrite */
465 6418 : if (is_assign) {
466 : n = is_a_mat(getArg(p, 0), ml);
467 : is_assign = (n >= 0);
468 : }
469 :
470 6418 : if (m < 0
471 6418 : || (r = newInstructionArgs(mb, matRef, packRef, mat[m].mi->argc)) == NULL)
472 0 : return -1;
473 6418 : getArg(r, 0) = getArg(p, 0);
474 6418 : tpe = getArgType(mb, p, 0);
475 :
476 6418 : if (is_identity) {
477 1 : if ((q = newInstruction(mb, NULL, NULL)) == NULL) {
478 0 : freeInstruction(r);
479 0 : return -1;
480 : }
481 1 : getArg(q, 0) = newTmpVariable(mb, TYPE_oid);
482 1 : q->retc = 1;
483 1 : q->argc = 1;
484 1 : q = pushOid(mb, q, 0);
485 1 : ident_var = getArg(q, 0);
486 1 : pushInstruction(mb, q);
487 1 : if (mb->errors) {
488 0 : freeInstruction(r);
489 0 : return -1;
490 : }
491 : }
492 31933 : for (k = 1; k < mat[m].mi->argc; k++) {
493 25515 : int res = 0;
494 25515 : if ((q = copyInstruction(p)) == NULL) {
495 0 : freeInstruction(r);
496 0 : return -1;
497 : }
498 :
499 25515 : if (is_assign)
500 : getArg(q, 0) = getArg(mat[n].mi, k);
501 : else
502 25515 : getArg(q, 0) = newTmpVariable(mb, tpe);
503 25515 : if (is_identity)
504 4 : getArg(q, 1) = newTmpVariable(mb, TYPE_oid);
505 25515 : getArg(q, var +is_identity) = getArg(mat[m].mi, k);
506 25515 : if (is_identity) {
507 4 : getArg(q, 3) = ident_var;
508 4 : q->retc = 2;
509 4 : q->argc = 4;
510 : /* make sure to resolve again */
511 4 : q->token = ASSIGNsymbol;
512 4 : q->typeresolved = false;
513 4 : q->fcn = NULL;
514 4 : q->blk = NULL;
515 : }
516 25515 : ident_var = getArg(q, 1);
517 25515 : pushInstruction(mb, q);
518 25515 : if (mb->errors) {
519 0 : freeInstruction(r);
520 0 : return -1;
521 : }
522 25515 : if (is_mirror || is_identity) {
523 25499 : res = propagateMirror(ml, getArg(mat[m].mi, k), getArg(q, 0));
524 16 : } else if (is_select)
525 16 : res = propagatePartnr(ml, getArg(mat[m].mi, k), getArg(q, 0), k);
526 : else
527 0 : res = setPartnr(ml, -1, getArg(q, 0), k);
528 25515 : if (res) {
529 0 : freeInstruction(r);
530 0 : return -1;
531 : }
532 25515 : r = pushArgument(mb, r, getArg(q, 0));
533 : }
534 6418 : if (mb->errors) {
535 0 : freeInstruction(r);
536 0 : return -1;
537 : }
538 6418 : if (!r || mat_add(ml, r, mat_type(ml->v, m), getFunctionId(p))) {
539 0 : freeInstruction(r);
540 0 : return -1;
541 : }
542 : return 0;
543 : }
544 :
545 : static int
546 158875 : mat_apply(MalBlkPtr mb, InstrPtr p, matlist_t *ml, int nrmats)
547 : {
548 158875 : int matvar[8], fargument[8], k, l, parts = 0;
549 :
550 158875 : if (nrmats == 1
551 75015 : && ((getModuleId(p) == batcalcRef && getFunctionId(p) == identityRef)
552 75014 : || (getModuleId(p) == batRef && getFunctionId(p) == mirrorRef)))
553 6414 : return mat_apply1(mb, p, ml, is_a_mat(getArg(p, 1), ml), 1);
554 152461 : assert(nrmats <= 8);
555 :
556 152461 : assert(p->retc < p->argc); /* i.e. matvar[0] gets initialized */
557 701489 : for (k = p->retc, l = 0; k < p->argc; k++) {
558 549028 : int mv = is_a_mat(getArg(p, k), ml);
559 549028 : if (mv >= 0) {
560 253256 : matvar[l] = mv;
561 253256 : fargument[l] = k;
562 253256 : l++;
563 253256 : if (parts == 0)
564 152461 : parts = ml->v[mv].mi->argc;
565 253256 : if (parts != ml->v[mv].mi->argc)
566 : return -1;
567 : }
568 : }
569 :
570 152461 : InstrPtr *r = (InstrPtr *) GDKmalloc(sizeof(InstrPtr) * p->retc);
571 152461 : if (!r)
572 : return -1;
573 304922 : for (k = 0; k < p->retc; k++) {
574 152461 : if ((r[k] = newInstructionArgs(mb, matRef, packRef, parts)) == NULL) {
575 0 : while (k > 0)
576 0 : freeInstruction(r[--k]);
577 0 : GDKfree(r);
578 0 : return -1;
579 : }
580 152461 : getArg(r[k], 0) = getArg(p, k);
581 : }
582 :
583 738030 : for (k = 1; k < ml->v[matvar[0]].mi->argc; k++) {
584 585569 : int tpe;
585 585569 : InstrPtr q = copyInstruction(p);
586 585569 : if (q == NULL) {
587 0 : for (k = 0; k < p->retc; k++)
588 0 : freeInstruction(r[k]);
589 0 : GDKfree(r);
590 0 : return -1;
591 : }
592 :
593 1171138 : for (l = 0; l < p->retc; l++) {
594 585569 : tpe = getArgType(mb, p, l);
595 585569 : getArg(q, l) = newTmpVariable(mb, tpe);
596 : }
597 1562507 : for (l = 0; l < nrmats; l++)
598 976938 : getArg(q, fargument[l]) = getArg(ml->v[matvar[l]].mi, k);
599 585569 : pushInstruction(mb, q);
600 1756707 : for (l = 0; l < p->retc; l++) {
601 585569 : if (setPartnr(ml, -1, getArg(q, l), k)) {
602 0 : for (k = 0; k < p->retc; k++)
603 0 : freeInstruction(r[k]);
604 0 : GDKfree(r);
605 0 : return -1;
606 : }
607 585569 : r[l] = pushArgument(mb, r[l], getArg(q, l));
608 : }
609 585569 : if (mb->errors) {
610 0 : for (k = 0; k < p->retc; k++)
611 0 : freeInstruction(r[k]);
612 0 : GDKfree(r);
613 0 : return -1;
614 : }
615 : }
616 304922 : for (k = 0; k < p->retc; k++) {
617 152461 : if (mat_add_var(ml, r[k], NULL, getArg(r[k], 0),
618 : mat_type(ml->v, matvar[0]), -1, -1, 0)) {
619 0 : for (l = k; l < p->retc; l++)
620 0 : freeInstruction(r[l]);
621 0 : GDKfree(r);
622 0 : return -1;
623 : }
624 : }
625 152461 : GDKfree(r);
626 152461 : return 0;
627 : }
628 :
629 :
630 : static int
631 10576 : mat_setop(MalBlkPtr mb, InstrPtr p, matlist_t *ml, int m, int n, int o)
632 : {
633 10576 : int tpe = getArgType(mb, p, 0), k, j;
634 10576 : mat_t *mat = ml->v;
635 10576 : InstrPtr r = newInstructionArgs(mb, matRef, packRef, mat[m].mi->argc);
636 :
637 10576 : if (!r)
638 : return -1;
639 :
640 10576 : getArg(r, 0) = getArg(p, 0);
641 :
642 : //printf("# %s.%s(%d,%d)", getModuleId(p), getFunctionId(p), m, n);
643 10576 : assert(m >= 0 || n >= 0);
644 10576 : if (m >= 0 && n >= 0) {
645 10341 : int nr = 1;
646 :
647 10341 : assert(o < 0 || mat[m].mi->argc == mat[o].mi->argc);
648 :
649 51529 : for (k = 1; mb->errors == NULL && k < mat[m].mi->argc; k++) {
650 41188 : InstrPtr q = copyInstruction(p);
651 82376 : InstrPtr s = newInstructionArgs(mb, matRef, packRef,
652 41188 : mat[n].mi->argc);
653 41188 : int ttpe = 0;
654 :
655 41188 : if (q == NULL
656 41188 : || s == NULL
657 41188 : || (getArg(s, 0) = newTmpVariable(mb, getArgType(mb, mat[n].mi, k))) < 0) {
658 0 : freeInstruction(q);
659 0 : freeInstruction(s);
660 0 : freeInstruction(r);
661 0 : return -1;
662 : }
663 :
664 41188 : ttpe = getArgType(mb, mat[n].mi, 0);
665 229286 : for (j = 1; j < mat[n].mi->argc; j++) {
666 188098 : int ov = 0;
667 188098 : if (getBatType(ttpe) != TYPE_oid
668 187778 : || (ov = overlap(ml, getArg(mat[m].mi, k),
669 : getArg(mat[n].mi, j), k, j, 1)) == 1) {
670 47396 : s = pushArgument(mb, s, getArg(mat[n].mi, j));
671 : }
672 188098 : if (ov == -1) {
673 0 : freeInstruction(q);
674 0 : freeInstruction(s);
675 0 : freeInstruction(r);
676 0 : return -1;
677 : }
678 : }
679 41188 : if (s->retc == 1 && s->argc == 2) { /* only one input, change into an assignment */
680 39102 : getFunctionId(s) = NULL;
681 39102 : getModuleId(s) = NULL;
682 39102 : s->token = ASSIGNsymbol;
683 39102 : s->typeresolved = false;
684 39102 : s->fcn = NULL;
685 39102 : s->blk = NULL;
686 : }
687 41188 : pushInstruction(mb, s);
688 :
689 41188 : getArg(q, 0) = newTmpVariable(mb, tpe);
690 41188 : getArg(q, 1) = getArg(mat[m].mi, k);
691 41188 : getArg(q, 2) = getArg(s, 0);
692 41188 : if (o >= 0)
693 791 : getArg(q, 3) = getArg(mat[o].mi, k);
694 41188 : if (setPartnr(ml, getArg(mat[m].mi, k), getArg(q, 0), nr)) {
695 0 : freeInstruction(q);
696 0 : freeInstruction(r);
697 0 : return -1;
698 : }
699 41188 : pushInstruction(mb, q);
700 :
701 41188 : r = pushArgument(mb, r, getArg(q, 0));
702 41188 : nr++;
703 : }
704 : } else {
705 235 : assert(m >= 0);
706 235 : assert(o < 0 || mat[m].mi->argc == mat[o].mi->argc);
707 :
708 1175 : for (k = 1; mb->errors == NULL && k < mat[m].mi->argc; k++) {
709 940 : InstrPtr q = copyInstruction(p);
710 940 : if (!q) {
711 0 : freeInstruction(r);
712 0 : return -1;
713 : }
714 :
715 940 : getArg(q, 0) = newTmpVariable(mb, tpe);
716 940 : getArg(q, 1) = getArg(mat[m].mi, k);
717 940 : if (o >= 0)
718 32 : getArg(q, 3) = getArg(mat[o].mi, k);
719 940 : pushInstruction(mb, q);
720 :
721 940 : if (setPartnr(ml, getArg(q, 2), getArg(q, 0), k)) {
722 0 : freeInstruction(r);
723 0 : return -1;
724 : }
725 940 : r = pushArgument(mb, r, getArg(q, 0));
726 : }
727 : }
728 :
729 10576 : if (mb->errors || mat_add(ml, r, mat_none, getFunctionId(p))) {
730 0 : freeInstruction(r);
731 0 : return -1;
732 : }
733 : return 0;
734 : }
735 :
736 : static int
737 766720 : mat_projection(MalBlkPtr mb, InstrPtr p, matlist_t *ml, int m, int n)
738 : {
739 766720 : int tpe = getArgType(mb, p, 0), k, j;
740 766720 : mat_t *mat = ml->v;
741 766720 : InstrPtr r;
742 :
743 : //printf("# %s.%s(%d,%d)", getModuleId(p), getFunctionId(p), m, n);
744 766720 : assert(m >= 0 || n >= 0);
745 766720 : if (m >= 0 && n >= 0) {
746 685617 : int nr = 1;
747 1371234 : r = newInstructionArgs(mb, matRef, packRef,
748 685617 : mat[m].mi->argc * mat[n].mi->argc);
749 :
750 685617 : if (!r)
751 : return -1;
752 :
753 685617 : getArg(r, 0) = getArg(p, 0);
754 :
755 3433017 : for (k = 1; mb->errors == NULL && k < mat[m].mi->argc; k++) {
756 6893026 : for (j = 1; j < mat[n].mi->argc; j++) {
757 6893026 : InstrPtr q;
758 6893026 : switch (overlap(ml, getArg(mat[m].mi, k),
759 : getArg(mat[n].mi, j), k, j, 0)) {
760 4145626 : case 0:
761 4145626 : continue;
762 0 : case -1:
763 0 : freeInstruction(r);
764 0 : return -1;
765 2747400 : case 1:
766 2747400 : q = copyInstruction(p);
767 :
768 2747400 : if (!q) {
769 0 : freeInstruction(r);
770 0 : return -1;
771 : }
772 :
773 2747400 : getArg(q, 0) = newTmpVariable(mb, tpe);
774 2747400 : getArg(q, 1) = getArg(mat[m].mi, k);
775 2747400 : getArg(q, 2) = getArg(mat[n].mi, j);
776 2747400 : pushInstruction(mb, q);
777 :
778 2747400 : if (mb->errors || setPartnr(ml, getArg(mat[n].mi, j), getArg(q, 0), nr)) {
779 0 : freeInstruction(r);
780 0 : return -1;
781 : }
782 2747400 : r = pushArgument(mb, r, getArg(q, 0));
783 :
784 2747400 : nr++;
785 2747400 : break;
786 : }
787 : break; /* only in case of overlap */
788 : }
789 : }
790 : } else {
791 81103 : assert(m >= 0);
792 81103 : r = newInstructionArgs(mb, matRef, packRef, mat[m].mi->argc);
793 :
794 81103 : if (!r)
795 : return -1;
796 :
797 81103 : getArg(r, 0) = getArg(p, 0);
798 :
799 405090 : for (k = 1; mb->errors == NULL && k < mat[m].mi->argc; k++) {
800 323987 : InstrPtr q = copyInstruction(p);
801 :
802 323987 : if (!q) {
803 0 : freeInstruction(r);
804 0 : return -1;
805 : }
806 :
807 323987 : getArg(q, 0) = newTmpVariable(mb, tpe);
808 323987 : getArg(q, 1) = getArg(mat[m].mi, k);
809 323987 : pushInstruction(mb, q);
810 :
811 323987 : if (mb->errors || setPartnr(ml, getArg(q, 2), getArg(q, 0), k)) {
812 0 : freeInstruction(r);
813 0 : return -1;
814 : }
815 323987 : r = pushArgument(mb, r, getArg(q, 0));
816 : }
817 : }
818 :
819 766720 : if (mb->errors || mat_add(ml, r, mat_none, getFunctionId(p))) {
820 0 : freeInstruction(r);
821 0 : return -1;
822 : }
823 : return 0;
824 : }
825 :
826 : static int
827 48009 : mat_join2(MalBlkPtr mb, InstrPtr p, matlist_t *ml, int m, int n, int lc, int rc)
828 : {
829 48009 : int tpe1 = getArgType(mb, p, 0), tpe2 = getArgType(mb, p, 1), j, k, nr = 1;
830 48009 : mat_t *mat = ml->v;
831 48009 : InstrPtr l;
832 48009 : InstrPtr r;
833 :
834 : //printf("# %s.%s(%d,%d)", getModuleId(p), getFunctionId(p), m, n);
835 :
836 48009 : assert(m >= 0 || n >= 0);
837 48009 : if (m >= 0 && n >= 0) {
838 1188 : l = newInstructionArgs(mb, matRef, packRef,
839 594 : mat[m].mi->argc * mat[n].mi->argc);
840 1188 : r = newInstructionArgs(mb, matRef, packRef,
841 594 : mat[m].mi->argc * mat[n].mi->argc);
842 594 : if (!l || !r) {
843 0 : freeInstruction(l);
844 0 : freeInstruction(r);
845 0 : return -1;
846 : }
847 :
848 594 : getArg(l, 0) = getArg(p, 0);
849 594 : getArg(r, 0) = getArg(p, 1);
850 :
851 2956 : for (k = 1; k < mat[m].mi->argc; k++) {
852 11772 : for (j = 1; j < mat[n].mi->argc; j++) {
853 9410 : InstrPtr q = copyInstruction(p);
854 :
855 9410 : if (!q) {
856 0 : freeInstruction(l);
857 0 : freeInstruction(r);
858 0 : return -1;
859 : }
860 :
861 9410 : getArg(q, 0) = newTmpVariable(mb, tpe1);
862 9410 : getArg(q, 1) = newTmpVariable(mb, tpe2);
863 9410 : getArg(q, 2) = getArg(mat[m].mi, k);
864 9410 : getArg(q, 3) = getArg(mat[n].mi, j);
865 9410 : if (lc >= 0)
866 161 : getArg(q, 4) = getArg(mat[lc].mi, k);
867 9410 : if (rc >= 0)
868 0 : getArg(q, 5) = getArg(mat[rc].mi, j);
869 9410 : pushInstruction(mb, q);
870 :
871 9410 : if (mb->errors
872 9410 : || propagatePartnr(ml, getArg(mat[m].mi, k), getArg(q, 0),
873 : nr)
874 9410 : || propagatePartnr(ml, getArg(mat[n].mi, j), getArg(q, 1),
875 : nr)) {
876 0 : freeInstruction(r);
877 0 : freeInstruction(l);
878 0 : return -1;
879 : }
880 :
881 : /* add result to mat */
882 9410 : l = pushArgument(mb, l, getArg(q, 0));
883 9410 : r = pushArgument(mb, r, getArg(q, 1));
884 9410 : nr++;
885 : }
886 : }
887 : } else {
888 47415 : int mv = (m >= 0) ? m : n;
889 47415 : int av = (m < 0);
890 47415 : int bv = (m >= 0);
891 47415 : int mc = (lc >= 0) ? lc : rc;
892 :
893 47415 : l = newInstructionArgs(mb, matRef, packRef, mat[mv].mi->argc);
894 47415 : r = newInstructionArgs(mb, matRef, packRef, mat[mv].mi->argc);
895 47415 : if (!l || !r) {
896 0 : freeInstruction(l);
897 0 : freeInstruction(r);
898 0 : return -1;
899 : }
900 :
901 47415 : getArg(l, 0) = getArg(p, 0);
902 47415 : getArg(r, 0) = getArg(p, 1);
903 :
904 236722 : for (k = 1; k < mat[mv].mi->argc; k++) {
905 189307 : InstrPtr q = copyInstruction(p);
906 :
907 189307 : if (!q) {
908 0 : freeInstruction(l);
909 0 : freeInstruction(r);
910 0 : return -1;
911 : }
912 :
913 189307 : getArg(q, 0) = newTmpVariable(mb, tpe1);
914 189307 : getArg(q, 1) = newTmpVariable(mb, tpe2);
915 189307 : getArg(q, p->retc + av) = getArg(mat[mv].mi, k);
916 189307 : if (mc >= 0)
917 667 : getArg(q, p->retc + 2 + av) = getArg(mat[mc].mi, k);
918 189307 : pushInstruction(mb, q);
919 :
920 189307 : if (mb->errors
921 189307 : || propagatePartnr(ml, getArg(mat[mv].mi, k), getArg(q, av), k)
922 189307 : || propagatePartnr(ml, getArg(p, p->retc + bv), getArg(q, bv),
923 : k)) {
924 0 : freeInstruction(l);
925 0 : freeInstruction(r);
926 0 : return -1;
927 : }
928 :
929 : /* add result to mat */
930 189307 : l = pushArgument(mb, l, getArg(q, 0));
931 189307 : r = pushArgument(mb, r, getArg(q, 1));
932 : }
933 : }
934 48009 : if (mb->errors || mat_add(ml, l, mat_none, getFunctionId(p))) {
935 0 : freeInstruction(l);
936 0 : freeInstruction(r);
937 0 : return -1;
938 : }
939 48009 : if (mat_add(ml, r, mat_none, getFunctionId(p))) {
940 0 : freeInstruction(r);
941 0 : return -1;
942 : }
943 : return 0;
944 : }
945 :
946 : static int
947 4 : join_split(Client cntxt, InstrPtr p, int args)
948 : {
949 4 : char *name = NULL;
950 4 : size_t len;
951 4 : int i, res = 0;
952 4 : Symbol sym;
953 4 : MalBlkPtr mb;
954 4 : InstrPtr q;
955 :
956 4 : if (args <= 3) /* we asume there are no 2x1 joins! */
957 : return 1;
958 :
959 0 : len = strlen(getFunctionId(p));
960 0 : name = GDKmalloc(len + 3);
961 0 : if (!name)
962 : return -2;
963 0 : strncpy(name, getFunctionId(p), len - 7);
964 0 : strcpy(name + len - 7, "join");
965 :
966 0 : sym = findSymbol(cntxt->usermodule, getModuleId(p), name);
967 0 : assert(sym);
968 0 : mb = sym->def;
969 :
970 0 : assert(0);
971 : q = mb->stmt[0];
972 : for (i = q->retc; i < q->argc; i++) {
973 : if (isaBatType(getArgType(mb, q, i)))
974 : res++;
975 : else
976 : break;
977 : }
978 : GDKfree(name);
979 : return res - 1;
980 : }
981 :
982 : /* 1 or 2 mat lists:
983 : * in case of one take the second half of the code
984 : * in case of two we need to detect the list lengths.
985 : *
986 : * input is one list of arguments (just total length of mats)
987 : */
988 : static int
989 55 : mat_joinNxM(Client cntxt, MalBlkPtr mb, InstrPtr p, matlist_t *ml, int args)
990 : {
991 55 : int tpe1 = getArgType(mb, p, 0), tpe2 = getArgType(mb, p, 1), j, k, nr = 1;
992 55 : InstrPtr l;
993 55 : InstrPtr r;
994 55 : mat_t *mat = ml->v;
995 55 : int *mats = (int *) GDKzalloc(sizeof(int) * args);
996 55 : int nr_mats = 0, first = -1, res = 0;
997 :
998 55 : if (!mats) {
999 : return -1;
1000 : }
1001 :
1002 231 : for (j = 0; j < args; j++) {
1003 176 : mats[j] = is_a_mat(getArg(p, p->retc + j), ml);
1004 176 : if (mats[j] != -1) {
1005 65 : nr_mats++;
1006 65 : if (first < 0)
1007 55 : first = j;
1008 : }
1009 : }
1010 :
1011 : //printf("# %s.%s(%d,%d)", getModuleId(p), getFunctionId(p), m, n);
1012 :
1013 55 : if (args == nr_mats) {
1014 4 : int mv1 = mats[0], i;
1015 4 : int mv2 = mats[args - 1];
1016 4 : int split = join_split(cntxt, p, args);
1017 4 : int nr_mv1 = split;
1018 :
1019 4 : if (split == -2) {
1020 0 : GDKfree(mats);
1021 0 : return -1;
1022 : }
1023 4 : if (split < 0) {
1024 0 : GDKfree(mats);
1025 0 : mb->errors = createException(MAL, "mergetable.join",
1026 : SQLSTATE(42000) " incorrect split level");
1027 0 : return 0;
1028 : }
1029 :
1030 8 : l = newInstructionArgs(mb, matRef, packRef,
1031 4 : mat[mv1].mi->argc * mat[mv2].mi->argc);
1032 8 : r = newInstructionArgs(mb, matRef, packRef,
1033 4 : mat[mv1].mi->argc * mat[mv2].mi->argc);
1034 4 : if (l == NULL || r == NULL) {
1035 0 : freeInstruction(l);
1036 0 : freeInstruction(r);
1037 0 : GDKfree(mats);
1038 0 : return -1;
1039 : }
1040 4 : getArg(l, 0) = getArg(p, 0);
1041 4 : getArg(r, 0) = getArg(p, 1);
1042 :
1043 : /* now detect split point */
1044 16 : for (k = 1; k < mat[mv1].mi->argc; k++) {
1045 48 : for (j = 1; j < mat[mv2].mi->argc; j++) {
1046 36 : InstrPtr q = copyInstruction(p);
1047 36 : if (!q) {
1048 0 : freeInstruction(r);
1049 0 : freeInstruction(l);
1050 0 : GDKfree(mats);
1051 0 : return -1;
1052 : }
1053 :
1054 36 : getArg(q, 0) = newTmpVariable(mb, tpe1);
1055 36 : getArg(q, 1) = newTmpVariable(mb, tpe2);
1056 72 : for (i = 0; i < nr_mv1; i++)
1057 36 : getArg(q, q->retc + i) = getArg(mat[mats[i]].mi, k);
1058 108 : for (; i < nr_mats; i++)
1059 72 : getArg(q, q->retc + i) = getArg(mat[mats[i]].mi, j);
1060 36 : pushInstruction(mb, q);
1061 :
1062 36 : if (mb->errors
1063 36 : || propagatePartnr(ml, getArg(mat[mv1].mi, k), getArg(q, 0),
1064 : nr)
1065 36 : || propagatePartnr(ml, getArg(mat[mv2].mi, j), getArg(q, 1),
1066 : nr)) {
1067 0 : freeInstruction(r);
1068 0 : freeInstruction(l);
1069 0 : GDKfree(mats);
1070 0 : return -1;
1071 : }
1072 :
1073 : /* add result to mat */
1074 36 : l = pushArgument(mb, l, getArg(q, 0));
1075 36 : r = pushArgument(mb, r, getArg(q, 1));
1076 36 : nr++;
1077 : }
1078 : }
1079 : } else {
1080 : /* only one side
1081 : * mats from first..first+nr_mats
1082 : */
1083 51 : int mv = mats[first];
1084 :
1085 51 : l = newInstructionArgs(mb, matRef, packRef, mat[mv].mi->argc);
1086 51 : r = newInstructionArgs(mb, matRef, packRef, mat[mv].mi->argc);
1087 51 : if (l == NULL || r == NULL) {
1088 0 : freeInstruction(l);
1089 0 : freeInstruction(r);
1090 0 : GDKfree(mats);
1091 0 : return -1;
1092 : }
1093 51 : getArg(l, 0) = getArg(p, 0);
1094 51 : getArg(r, 0) = getArg(p, 1);
1095 :
1096 224 : for (k = 1; k < mat[mv].mi->argc; k++) {
1097 173 : InstrPtr q = copyInstruction(p);
1098 173 : if (!q) {
1099 0 : freeInstruction(r);
1100 0 : freeInstruction(l);
1101 0 : GDKfree(mats);
1102 0 : return -1;
1103 : }
1104 :
1105 173 : getArg(q, 0) = newTmpVariable(mb, tpe1);
1106 173 : getArg(q, 1) = newTmpVariable(mb, tpe2);
1107 352 : for (j = 0; j < nr_mats; j++) {
1108 179 : assert(mat[mats[first]].mi->argc == mat[mats[first + j]].mi->argc);
1109 179 : getArg(q, p->retc + first + j) = getArg(mat[mats[first + j]].mi, k);
1110 : }
1111 173 : if (mb->errors
1112 173 : || propagatePartnr(ml, getArg(mat[mv].mi, k),
1113 173 : getArg(q, (first != 0)), k)
1114 173 : || propagatePartnr(ml,
1115 173 : getArg(p, p->retc + (first) ? nr_mats : 0),
1116 173 : getArg(q, (first == 0)), k)) {
1117 0 : freeInstruction(q);
1118 0 : freeInstruction(r);
1119 0 : freeInstruction(l);
1120 0 : GDKfree(mats);
1121 0 : return -1;
1122 : }
1123 173 : pushInstruction(mb, q);
1124 :
1125 : /* add result to mat */
1126 173 : l = pushArgument(mb, l, getArg(q, 0));
1127 173 : r = pushArgument(mb, r, getArg(q, 1));
1128 : }
1129 : }
1130 55 : if (mb->errors || mat_add(ml, l, mat_none, getFunctionId(p))) {
1131 0 : freeInstruction(l);
1132 0 : freeInstruction(r);
1133 0 : res = -1;
1134 55 : } else if (mat_add(ml, r, mat_none, getFunctionId(p))) {
1135 0 : freeInstruction(r);
1136 0 : res = -1;
1137 : }
1138 55 : GDKfree(mats);
1139 55 : return res;
1140 : }
1141 :
1142 :
1143 : static const char *
1144 4782 : aggr_phase2(const char *aggr, int type_dbl)
1145 : {
1146 4782 : if (aggr == countRef || aggr == count_no_nilRef
1147 4488 : || (aggr == avgRef && type_dbl))
1148 1298 : return sumRef;
1149 3484 : if (aggr == subcountRef || (aggr == subavgRef && type_dbl))
1150 2723 : return subsumRef;
1151 : /* min/max/sum/prod and unique are fine */
1152 : return aggr;
1153 : }
1154 :
1155 : static str
1156 1631 : mat_aggr(MalBlkPtr mb, InstrPtr p, mat_t *mat, int m)
1157 : {
1158 1631 : int tp = getArgType(mb, p, 0), k, tp2 = TYPE_lng, i;
1159 1631 : int battp = (getModuleId(p) == aggrRef) ? newBatType(tp) : tp, battp2 = 0;
1160 1631 : int isAvg = (getFunctionId(p) == avgRef);
1161 1631 : InstrPtr r = NULL, s = NULL, q = NULL, u = NULL, v = NULL;
1162 :
1163 : /* we pack the partitial result */
1164 1631 : r = newInstructionArgs(mb, matRef, packRef, mat[m].mi->argc);
1165 1631 : if (r == NULL)
1166 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1167 1631 : getArg(r, 0) = newTmpVariable(mb, battp);
1168 :
1169 1631 : if (isAvg) { /* remainders or counts */
1170 1027 : battp2 = newBatType(tp2);
1171 1027 : u = newInstructionArgs(mb, matRef, packRef, mat[m].mi->argc);
1172 1027 : if (u == NULL) {
1173 0 : freeInstruction(r);
1174 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1175 : }
1176 1027 : getArg(u, 0) = newTmpVariable(mb, battp2);
1177 : }
1178 1631 : if (isAvg && tp != TYPE_dbl) { /* counts */
1179 23 : battp2 = newBatType(tp2);
1180 23 : v = newInstructionArgs(mb, matRef, packRef, mat[m].mi->argc);
1181 23 : if (v == NULL) {
1182 0 : freeInstruction(r);
1183 0 : freeInstruction(u);
1184 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1185 : }
1186 23 : getArg(v, 0) = newTmpVariable(mb, battp2);
1187 : }
1188 8220 : for (k = 1; mb->errors == NULL && k < mat[m].mi->argc; k++) {
1189 6589 : q = newInstruction(mb, NULL, NULL);
1190 6589 : if (q == NULL) {
1191 0 : freeInstruction(r);
1192 0 : freeInstruction(u);
1193 0 : freeInstruction(v);
1194 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1195 : }
1196 6589 : if (isAvg && tp == TYPE_dbl)
1197 3995 : setModuleId(q, batcalcRef);
1198 : else
1199 2594 : setModuleId(q, getModuleId(p));
1200 6589 : setFunctionId(q, getFunctionId(p));
1201 6589 : getArg(q, 0) = newTmpVariable(mb, tp);
1202 6589 : if (isAvg)
1203 4086 : q = pushReturn(mb, q, newTmpVariable(mb, tp2));
1204 6589 : if (isAvg && tp != TYPE_dbl)
1205 91 : q = pushReturn(mb, q, newTmpVariable(mb, tp2));
1206 6589 : q = pushArgument(mb, q, getArg(mat[m].mi, k));
1207 6996 : for (i = q->argc; i < p->argc; i++)
1208 407 : q = pushArgument(mb, q, getArg(p, i));
1209 6589 : pushInstruction(mb, q);
1210 :
1211 6589 : r = pushArgument(mb, r, getArg(q, 0));
1212 6589 : if (isAvg)
1213 4086 : u = pushArgument(mb, u, getArg(q, 1));
1214 6589 : if (isAvg && tp != TYPE_dbl)
1215 91 : v = pushArgument(mb, v, getArg(q, 2));
1216 : }
1217 1631 : pushInstruction(mb, r);
1218 1631 : if (isAvg)
1219 1027 : pushInstruction(mb, u);
1220 1631 : if (isAvg && tp != TYPE_dbl)
1221 23 : pushInstruction(mb, v);
1222 :
1223 : /* Filter empty partitions */
1224 1631 : if (mb->errors == NULL && getModuleId(p) == aggrRef && !isAvg) {
1225 604 : s = newInstruction(mb, algebraRef, selectNotNilRef);
1226 604 : if (s == NULL) {
1227 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1228 : }
1229 604 : getArg(s, 0) = newTmpVariable(mb, battp);
1230 604 : s = pushArgument(mb, s, getArg(r, 0));
1231 604 : pushInstruction(mb, s);
1232 604 : r = s;
1233 : }
1234 :
1235 : /* for avg we do sum (avg*(count/sumcount) ) */
1236 1631 : if (mb->errors == NULL && isAvg && tp == TYPE_dbl) {
1237 1004 : InstrPtr v, w, x, y, cond;
1238 :
1239 : /* lng w = sum counts */
1240 1004 : w = newInstruction(mb, aggrRef, sumRef);
1241 1004 : if (w == NULL) {
1242 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1243 : }
1244 1004 : getArg(w, 0) = newTmpVariable(mb, tp2);
1245 1004 : w = pushArgument(mb, w, getArg(u, 0));
1246 1004 : pushInstruction(mb, w);
1247 :
1248 : /* y=count = ifthenelse(w=count==0,NULL,w=count) */
1249 1004 : cond = newInstruction(mb, calcRef, eqRef);
1250 1004 : if (cond == NULL) {
1251 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1252 : }
1253 1004 : getArg(cond, 0) = newTmpVariable(mb, TYPE_bit);
1254 1004 : cond = pushArgument(mb, cond, getArg(w, 0));
1255 1004 : cond = pushLng(mb, cond, 0);
1256 1004 : pushInstruction(mb, cond);
1257 :
1258 1004 : y = newInstruction(mb, calcRef, ifthenelseRef);
1259 1004 : if (y == NULL) {
1260 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1261 : }
1262 1004 : getArg(y, 0) = newTmpVariable(mb, tp2);
1263 1004 : y = pushArgument(mb, y, getArg(cond, 0));
1264 1004 : y = pushNil(mb, y, tp2);
1265 1004 : y = pushArgument(mb, y, getArg(w, 0));
1266 1004 : pushInstruction(mb, y);
1267 :
1268 : /* dbl v = double(count) */
1269 1004 : v = newInstruction(mb, batcalcRef, dblRef);
1270 1004 : if (v == NULL) {
1271 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1272 : }
1273 1004 : getArg(v, 0) = newTmpVariable(mb, newBatType(TYPE_dbl));
1274 1004 : v = pushArgument(mb, v, getArg(u, 0));
1275 1004 : pushInstruction(mb, v);
1276 :
1277 : /* dbl x = v / y */
1278 1004 : x = newInstruction(mb, batcalcRef, divRef);
1279 1004 : if (x == NULL) {
1280 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1281 : }
1282 1004 : getArg(x, 0) = newTmpVariable(mb, newBatType(TYPE_dbl));
1283 1004 : x = pushArgument(mb, x, getArg(v, 0));
1284 1004 : x = pushArgument(mb, x, getArg(y, 0));
1285 1004 : if (isaBatType(getArgType(mb, x, 0)))
1286 1004 : x = pushNilBat(mb, x);
1287 1004 : if (isaBatType(getArgType(mb, y, 0)))
1288 0 : x = pushNilBat(mb, x);
1289 1004 : pushInstruction(mb, x);
1290 :
1291 : /* dbl w = avg * x */
1292 1004 : w = newInstruction(mb, batcalcRef, mulRef);
1293 1004 : if (w == NULL) {
1294 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1295 : }
1296 1004 : getArg(w, 0) = newTmpVariable(mb, battp);
1297 1004 : w = pushArgument(mb, w, getArg(r, 0));
1298 1004 : w = pushArgument(mb, w, getArg(x, 0));
1299 1004 : if (isaBatType(getArgType(mb, r, 0)))
1300 1004 : w = pushNilBat(mb, w);
1301 1004 : if (isaBatType(getArgType(mb, x, 0)))
1302 1004 : w = pushNilBat(mb, w);
1303 1004 : pushInstruction(mb, w);
1304 :
1305 1004 : r = w;
1306 :
1307 : /* filter nils */
1308 1004 : s = newInstruction(mb, algebraRef, selectNotNilRef);
1309 1004 : if (s == NULL) {
1310 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1311 : }
1312 1004 : getArg(s, 0) = newTmpVariable(mb, battp);
1313 1004 : s = pushArgument(mb, s, getArg(r, 0));
1314 1004 : pushInstruction(mb, s);
1315 1004 : r = s;
1316 : }
1317 :
1318 1631 : if (mb->errors == NULL) {
1319 1631 : s = newInstruction(mb, getModuleId(p),
1320 : aggr_phase2(getFunctionId(p), tp == TYPE_dbl));
1321 1631 : if (s == NULL) {
1322 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1323 : }
1324 1631 : getArg(s, 0) = getArg(p, 0);
1325 1631 : s = pushArgument(mb, s, getArg(r, 0));
1326 1631 : if (isAvg && tp != TYPE_dbl) {
1327 23 : s = pushArgument(mb, s, getArg(u, 0));
1328 23 : s = pushArgument(mb, s, getArg(v, 0));
1329 : }
1330 1631 : pushInstruction(mb, s);
1331 : }
1332 1631 : if (mb->errors) {
1333 0 : str msg = mb->errors;
1334 0 : mb->errors = NULL;
1335 0 : return msg;
1336 : }
1337 : return MAL_SUCCEED;
1338 : }
1339 :
1340 : static int
1341 7134 : chain_by_length(mat_t *mat, int g)
1342 : {
1343 7134 : int cnt = 0;
1344 17471 : while (g >= 0) {
1345 10337 : g = mat[g].pm;
1346 10337 : cnt++;
1347 : }
1348 4751 : return cnt;
1349 : }
1350 :
1351 : static int
1352 3181 : walk_n_back(mat_t *mat, int g, int cnt)
1353 : {
1354 15679 : while (cnt > 0) {
1355 5342 : g = mat[g].pm;
1356 5342 : cnt--;
1357 : }
1358 3307 : return g;
1359 : }
1360 :
1361 : static int
1362 3181 : group_by_ext(matlist_t *ml, int g)
1363 : {
1364 3181 : int i;
1365 :
1366 13392 : for (i = g; i < ml->top; i++) {
1367 20422 : if (ml->v[i].pm == g)
1368 : return i;
1369 : }
1370 : return 0;
1371 : }
1372 :
1373 : /* In some cases we have non groupby attribute columns, these require
1374 : * gext.projection(mat.pack(per partition ext.projections(x)))
1375 : */
1376 :
1377 : static int
1378 6917 : mat_group_project(MalBlkPtr mb, InstrPtr p, matlist_t *ml, int e, int a)
1379 : {
1380 6917 : int tp = getArgType(mb, p, 0), k;
1381 6917 : mat_t *mat = ml->v;
1382 6917 : InstrPtr ai1 = newInstructionArgs(mb, matRef, packRef, mat[a].mi->argc), r;
1383 :
1384 6917 : if (!ai1)
1385 : return -1;
1386 :
1387 6917 : getArg(ai1, 0) = newTmpVariable(mb, tp);
1388 6917 : if (mb->errors) {
1389 0 : freeInstruction(ai1);
1390 0 : return -1;
1391 : }
1392 :
1393 6917 : assert(mat[e].mi->argc == mat[a].mi->argc);
1394 35858 : for (k = 1; k < mat[a].mi->argc; k++) {
1395 28941 : InstrPtr q = copyInstruction(p);
1396 28941 : if (!q) {
1397 0 : freeInstruction(ai1);
1398 0 : return -1;
1399 : }
1400 :
1401 28941 : getArg(q, 0) = newTmpVariable(mb, tp);
1402 28941 : getArg(q, 1) = getArg(mat[e].mi, k);
1403 28941 : getArg(q, 2) = getArg(mat[a].mi, k);
1404 28941 : pushInstruction(mb, q);
1405 28941 : if (mb->errors) {
1406 0 : freeInstruction(ai1);
1407 0 : return -1;
1408 : }
1409 28941 : if (setPartnr(ml, getArg(mat[a].mi, k), getArg(q, 0), k)) {
1410 0 : freeInstruction(ai1);
1411 0 : return -1;
1412 : }
1413 :
1414 : /* pack the result into a mat */
1415 28941 : ai1 = pushArgument(mb, ai1, getArg(q, 0));
1416 : }
1417 6917 : pushInstruction(mb, ai1);
1418 6917 : if (mb->errors) {
1419 : return -1;
1420 : }
1421 :
1422 6917 : if ((r = copyInstruction(p)) == NULL)
1423 : return -1;
1424 6917 : getArg(r, 1) = mat[e].mv;
1425 6917 : getArg(r, 2) = getArg(ai1, 0);
1426 6917 : pushInstruction(mb, r);
1427 6917 : return mb->errors ? -1 : 0;
1428 : }
1429 :
1430 : /* Per partition aggregates are merged and aggregated together. For
1431 : * most (handled) aggregates thats relatively simple. AVG is somewhat
1432 : * more complex. */
1433 : static int
1434 3151 : mat_group_aggr(MalBlkPtr mb, InstrPtr p, mat_t *mat, int b, int g, int e)
1435 : {
1436 3151 : int tp = getArgType(mb, p, 0), k, tp2 = 0, tpe = getBatType(tp);
1437 3151 : const char *aggr2 = aggr_phase2(getFunctionId(p), tpe == TYPE_dbl);
1438 3151 : int isAvg = (getFunctionId(p) == subavgRef);
1439 3151 : InstrPtr ai1 = newInstructionArgs(mb, matRef, packRef, mat[b].mi->argc),
1440 3151 : ai10 = NULL, ai11 = NULL, ai2;
1441 :
1442 3151 : if (!ai1)
1443 : return -1;
1444 :
1445 3151 : getArg(ai1, 0) = newTmpVariable(mb, tp);
1446 :
1447 3151 : if (mb->errors == NULL && isAvg) { /* remainders or counts */
1448 51 : tp2 = newBatType(TYPE_lng);
1449 51 : ai10 = newInstructionArgs(mb, matRef, packRef, mat[b].mi->argc);
1450 51 : if (!ai10) {
1451 0 : freeInstruction(ai1);
1452 0 : return -1;
1453 : }
1454 51 : getArg(ai10, 0) = newTmpVariable(mb, tp2);
1455 : }
1456 3151 : if (mb->errors == NULL && isAvg && tpe != TYPE_dbl) { /* counts */
1457 19 : tp2 = newBatType(TYPE_lng);
1458 19 : ai11 = newInstructionArgs(mb, matRef, packRef, mat[b].mi->argc);
1459 19 : if (!ai11) {
1460 0 : freeInstruction(ai1);
1461 0 : freeInstruction(ai10);
1462 0 : return -1;
1463 : }
1464 19 : getArg(ai11, 0) = newTmpVariable(mb, tp2);
1465 : }
1466 :
1467 16775 : for (k = 1; mb->errors == NULL && k < mat[b].mi->argc; k++) {
1468 13624 : int off = 0;
1469 13624 : InstrPtr q = copyInstructionArgs(p, p->argc + (isAvg && tpe == TYPE_dbl));
1470 13624 : if (!q) {
1471 0 : freeInstruction(ai1);
1472 0 : freeInstruction(ai10);
1473 0 : return -1;
1474 : }
1475 :
1476 13624 : getArg(q, 0) = newTmpVariable(mb, tp);
1477 13624 : if (isAvg && tpe == TYPE_dbl) {
1478 121 : off = 1;
1479 121 : getArg(q, 1) = newTmpVariable(mb, tp2);
1480 121 : q = pushArgument(mb, q, getArg(q, 1)); /* push at end, create space */
1481 121 : q->retc = 2;
1482 121 : getArg(q, q->argc - 1) = getArg(q, q->argc - 2);
1483 121 : getArg(q, q->argc - 2) = getArg(q, q->argc - 3);
1484 13503 : } else if (isAvg) {
1485 76 : getArg(q, 1) = newTmpVariable(mb, tp2);
1486 76 : getArg(q, 2) = newTmpVariable(mb, tp2);
1487 76 : off = 2;
1488 : }
1489 13624 : getArg(q, 1 + off) = getArg(mat[b].mi, k);
1490 13624 : getArg(q, 2 + off) = getArg(mat[g].mi, k);
1491 13624 : getArg(q, 3 + off) = getArg(mat[e].mi, k);
1492 13624 : pushInstruction(mb, q);
1493 :
1494 : /* pack the result into a mat */
1495 13624 : ai1 = pushArgument(mb, ai1, getArg(q, 0));
1496 13624 : if (isAvg)
1497 197 : ai10 = pushArgument(mb, ai10, getArg(q, 1));
1498 13624 : if (isAvg && tpe != TYPE_dbl)
1499 76 : ai11 = pushArgument(mb, ai11, getArg(q, 2));
1500 : }
1501 3151 : pushInstruction(mb, ai1);
1502 3151 : if (isAvg)
1503 51 : pushInstruction(mb, ai10);
1504 3151 : if (isAvg && tpe != TYPE_dbl)
1505 19 : pushInstruction(mb, ai11);
1506 :
1507 : /* for avg we do sum (avg*(count/sumcount) ) */
1508 3151 : if (mb->errors == NULL && isAvg && tpe == TYPE_dbl) {
1509 32 : InstrPtr r, s, v, w, cond;
1510 :
1511 : /* lng s = sum counts */
1512 32 : s = newInstruction(mb, aggrRef, subsumRef);
1513 32 : if (s == NULL)
1514 : return -1;
1515 32 : getArg(s, 0) = newTmpVariable(mb, tp2);
1516 32 : s = pushArgument(mb, s, getArg(ai10, 0));
1517 32 : s = pushArgument(mb, s, mat[g].mv);
1518 32 : s = pushArgument(mb, s, mat[e].mv);
1519 32 : s = pushBit(mb, s, 1); /* skip nils */
1520 32 : pushInstruction(mb, s);
1521 :
1522 : /* w=count = ifthenelse(s=count==0,NULL,s=count) */
1523 32 : cond = newInstruction(mb, batcalcRef, eqRef);
1524 32 : if (cond == NULL)
1525 : return -1;
1526 32 : getArg(cond, 0) = newTmpVariable(mb, newBatType(TYPE_bit));
1527 32 : cond = pushArgument(mb, cond, getArg(s, 0));
1528 32 : cond = pushLng(mb, cond, 0);
1529 32 : pushInstruction(mb, cond);
1530 :
1531 32 : w = newInstruction(mb, batcalcRef, ifthenelseRef);
1532 32 : if (w == NULL)
1533 : return -1;
1534 32 : getArg(w, 0) = newTmpVariable(mb, tp2);
1535 32 : w = pushArgument(mb, w, getArg(cond, 0));
1536 32 : w = pushNil(mb, w, TYPE_lng);
1537 32 : w = pushArgument(mb, w, getArg(s, 0));
1538 32 : pushInstruction(mb, w);
1539 :
1540 : /* fetchjoin with groups */
1541 32 : r = newInstruction(mb, algebraRef, projectionRef);
1542 32 : if (r == NULL)
1543 : return -1;
1544 32 : getArg(r, 0) = newTmpVariable(mb, tp2);
1545 32 : r = pushArgument(mb, r, mat[g].mv);
1546 32 : r = pushArgument(mb, r, getArg(w, 0));
1547 32 : pushInstruction(mb, r);
1548 32 : s = r;
1549 :
1550 : /* dbl v = double(count) */
1551 32 : v = newInstruction(mb, batcalcRef, dblRef);
1552 32 : if (v == NULL)
1553 : return -1;
1554 32 : getArg(v, 0) = newTmpVariable(mb, newBatType(TYPE_dbl));
1555 32 : v = pushArgument(mb, v, getArg(ai10, 0));
1556 32 : pushInstruction(mb, v);
1557 :
1558 : /* dbl r = v / s */
1559 32 : r = newInstruction(mb, batcalcRef, divRef);
1560 32 : if (r == NULL)
1561 : return -1;
1562 32 : getArg(r, 0) = newTmpVariable(mb, newBatType(TYPE_dbl));
1563 32 : r = pushArgument(mb, r, getArg(v, 0));
1564 32 : r = pushArgument(mb, r, getArg(s, 0));
1565 32 : if (isaBatType(getArgType(mb, v, 0)))
1566 32 : r = pushNilBat(mb, r);
1567 32 : if (isaBatType(getArgType(mb, s, 0)))
1568 32 : r = pushNilBat(mb, r);
1569 32 : pushInstruction(mb, r);
1570 :
1571 : /* dbl s = avg * r */
1572 32 : s = newInstruction(mb, batcalcRef, mulRef);
1573 32 : if (s == NULL)
1574 : return -1;
1575 32 : getArg(s, 0) = newTmpVariable(mb, tp);
1576 32 : s = pushArgument(mb, s, getArg(ai1, 0));
1577 32 : s = pushArgument(mb, s, getArg(r, 0));
1578 32 : if (isaBatType(getArgType(mb, ai1, 0)))
1579 32 : s = pushNilBat(mb, s);
1580 32 : if (isaBatType(getArgType(mb, r, 0)))
1581 32 : s = pushNilBat(mb, s);
1582 32 : pushInstruction(mb, s);
1583 :
1584 32 : ai1 = s;
1585 : }
1586 3151 : ai2 = newInstruction(mb, aggrRef, aggr2);
1587 3151 : if (ai2 == NULL)
1588 : return -1;
1589 3151 : getArg(ai2, 0) = getArg(p, 0);
1590 3151 : if (isAvg && tpe != TYPE_dbl) {
1591 19 : getArg(ai2, 1) = getArg(p, 1);
1592 19 : getArg(ai2, 2) = getArg(p, 2);
1593 : }
1594 3151 : ai2 = pushArgument(mb, ai2, getArg(ai1, 0));
1595 3151 : if (isAvg && tpe != TYPE_dbl) {
1596 19 : ai2 = pushArgument(mb, ai2, getArg(ai10, 0));
1597 19 : ai2 = pushArgument(mb, ai2, getArg(ai11, 0));
1598 : }
1599 3151 : ai2 = pushArgument(mb, ai2, mat[g].mv);
1600 3151 : ai2 = pushArgument(mb, ai2, mat[e].mv);
1601 3151 : ai2 = pushBit(mb, ai2, 1); /* skip nils */
1602 3151 : pushInstruction(mb, ai2);
1603 3151 : if (mb->errors)
1604 : return -1;
1605 : return 0;
1606 : }
1607 :
1608 : /* The mat_group_{new,derive} keep an ext,attr1..attrn table.
1609 : * This is the input for the final second phase group by.
1610 : */
1611 : static int
1612 4647 : mat_pack_group(MalBlkPtr mb, matlist_t *ml, int g)
1613 : {
1614 4647 : mat_t *mat = ml->v;
1615 4647 : int cnt = chain_by_length(mat, g), i;
1616 4647 : InstrPtr cur = NULL;
1617 :
1618 11677 : for (i = cnt - 1; i >= 0; i--) {
1619 : /* if cur is non-NULL, it's a subgroup; if i is zero, it's "done" */
1620 14060 : InstrPtr grp = newInstruction(mb, groupRef,
1621 2383 : cur ? i ? subgroupRef : subgroupdoneRef : i ?
1622 4647 : groupRef : groupdoneRef);
1623 7030 : if (grp == NULL)
1624 : return -1;
1625 14060 : int ogrp = walk_n_back(mat, g, i);
1626 7030 : int oext = group_by_ext(ml, ogrp);
1627 7030 : int attr = mat[oext].im;
1628 :
1629 7030 : getArg(grp, 0) = mat[ogrp].mv;
1630 7030 : grp = pushReturn(mb, grp, mat[oext].mv);
1631 7030 : grp = pushReturn(mb, grp, newTmpVariable(mb, newBatType(TYPE_lng)));
1632 7030 : grp = pushArgument(mb, grp, getArg(mat[attr].mi, 0));
1633 7030 : if (cur)
1634 2383 : grp = pushArgument(mb, grp, getArg(cur, 0));
1635 7030 : pushInstruction(mb, grp);
1636 7030 : cur = grp;
1637 7030 : if (mb->errors)
1638 : return -1;
1639 : }
1640 4647 : mat[g].im = -1; /* only pack once */
1641 4647 : return 0;
1642 : }
1643 :
1644 : /*
1645 : * foreach parent subgroup, do the
1646 : * e2.projection(grp.projection((ext.projection(b)))
1647 : * and one for the current group
1648 : */
1649 : static int
1650 2383 : mat_group_attr(MalBlkPtr mb, matlist_t *ml, int g, InstrPtr cext, int push)
1651 : {
1652 2383 : int cnt = chain_by_length(ml->v, g), i; /* number of attributes */
1653 : int ogrp = g; /* previous group */
1654 :
1655 5564 : for (i = 0; i < cnt; i++) {
1656 3181 : int agrp = walk_n_back(ml->v, ogrp, i);
1657 3181 : int b = ml->v[agrp].im;
1658 3181 : int aext = group_by_ext(ml, agrp);
1659 3181 : int a = ml->v[aext].im;
1660 3181 : int atp = getArgType(mb, ml->v[a].mi, 0), k;
1661 3181 : InstrPtr attr = newInstructionArgs(mb, matRef, packRef, ml->v[a].mi->argc);
1662 3181 : if (attr == NULL) {
1663 : return -1;
1664 : }
1665 :
1666 : //getArg(attr,0) = newTmpVariable(mb, atp);
1667 3181 : getArg(attr, 0) = getArg(ml->v[b].mi, 0);
1668 :
1669 16381 : for (k = 1; mb->errors == NULL && k < ml->v[a].mi->argc; k++) {
1670 13200 : InstrPtr r = newInstruction(mb, algebraRef, projectionRef);
1671 13200 : InstrPtr q = newInstruction(mb, algebraRef, projectionRef);
1672 13200 : if (r == NULL || q == NULL) {
1673 0 : freeInstruction(attr);
1674 0 : freeInstruction(r);
1675 0 : freeInstruction(q);
1676 0 : return -1;
1677 : }
1678 :
1679 13200 : getArg(r, 0) = newTmpVariable(mb, newBatType(TYPE_oid));
1680 13200 : r = pushArgument(mb, r, getArg(cext, k));
1681 13200 : r = pushArgument(mb, r, getArg(ml->v[ogrp].mi, k));
1682 13200 : pushInstruction(mb, r);
1683 :
1684 13200 : getArg(q, 0) = newTmpVariable(mb, atp);
1685 13200 : q = pushArgument(mb, q, getArg(r, 0));
1686 13200 : q = pushArgument(mb, q, getArg(ml->v[a].mi, k));
1687 13200 : pushInstruction(mb, q);
1688 :
1689 13200 : attr = pushArgument(mb, attr, getArg(q, 0));
1690 : }
1691 3181 : if (push)
1692 2383 : pushInstruction(mb, attr);
1693 3181 : if (mb->errors || mat_add_var(ml, attr, NULL, getArg(attr, 0), mat_ext,
1694 : -1, -1, push)) {
1695 0 : if (!push)
1696 0 : freeInstruction(attr);
1697 0 : return -1;
1698 : }
1699 : /* keep new attribute with the group extend */
1700 3181 : ml->v[aext].im = ml->top - 1;
1701 : }
1702 : return 0;
1703 : }
1704 :
1705 : static int
1706 4647 : mat_group_new(MalBlkPtr mb, InstrPtr p, matlist_t *ml, int b)
1707 : {
1708 4647 : int tp0 = getArgType(mb, p, 0);
1709 4647 : int tp1 = getArgType(mb, p, 1);
1710 4647 : int tp2 = getArgType(mb, p, 2);
1711 4647 : int atp = getArgType(mb, p, 3), i, a, g, push = 0;
1712 4647 : InstrPtr r0, r1, r2, attr;
1713 :
1714 4647 : if (getFunctionId(p) == subgroupdoneRef || getFunctionId(p) == groupdoneRef)
1715 2565 : push = 1;
1716 :
1717 4647 : r0 = newInstructionArgs(mb, matRef, packRef, ml->v[b].mi->argc);
1718 4647 : if (r0 == NULL)
1719 : return -1;
1720 4647 : getArg(r0, 0) = newTmpVariable(mb, tp0);
1721 :
1722 4647 : r1 = newInstructionArgs(mb, matRef, packRef, ml->v[b].mi->argc);
1723 4647 : if (r1 == NULL) {
1724 0 : freeInstruction(r0);
1725 0 : return -1;
1726 : }
1727 4647 : getArg(r1, 0) = newTmpVariable(mb, tp1);
1728 :
1729 4647 : r2 = newInstructionArgs(mb, matRef, packRef, ml->v[b].mi->argc);
1730 4647 : if (r2 == NULL) {
1731 0 : freeInstruction(r0);
1732 0 : freeInstruction(r1);
1733 0 : return -1;
1734 : }
1735 4647 : getArg(r2, 0) = newTmpVariable(mb, tp2);
1736 :
1737 : /* we keep an extend, attr table result, which will later be used
1738 : * when we pack the group result */
1739 4647 : attr = newInstructionArgs(mb, matRef, packRef, ml->v[b].mi->argc);
1740 4647 : if (attr == NULL) {
1741 0 : freeInstruction(r0);
1742 0 : freeInstruction(r1);
1743 0 : freeInstruction(r2);
1744 0 : return -1;
1745 : }
1746 4647 : getArg(attr, 0) = getArg(ml->v[b].mi, 0);
1747 :
1748 24237 : for (i = 1; mb->errors == NULL && i < ml->v[b].mi->argc; i++) {
1749 19590 : InstrPtr q = copyInstruction(p), r;
1750 19590 : if (!q) {
1751 0 : freeInstruction(r0);
1752 0 : freeInstruction(r1);
1753 0 : freeInstruction(r2);
1754 0 : freeInstruction(attr);
1755 0 : return -1;
1756 : }
1757 :
1758 19590 : getArg(q, 0) = newTmpVariable(mb, tp0);
1759 19590 : getArg(q, 1) = newTmpVariable(mb, tp1);
1760 19590 : getArg(q, 2) = newTmpVariable(mb, tp2);
1761 19590 : getArg(q, 3) = getArg(ml->v[b].mi, i);
1762 19590 : pushInstruction(mb, q);
1763 19590 : if (setPartnr(ml, getArg(ml->v[b].mi, i), getArg(q, 0), i)
1764 19590 : || setPartnr(ml, getArg(ml->v[b].mi, i), getArg(q, 1), i)
1765 19590 : || setPartnr(ml, getArg(ml->v[b].mi, i), getArg(q, 2), i)) {
1766 0 : freeInstruction(r0);
1767 0 : freeInstruction(r1);
1768 0 : freeInstruction(r2);
1769 0 : freeInstruction(attr);
1770 0 : return -1;
1771 : }
1772 :
1773 : /* add result to mats */
1774 19590 : r0 = pushArgument(mb, r0, getArg(q, 0));
1775 19590 : r1 = pushArgument(mb, r1, getArg(q, 1));
1776 19590 : r2 = pushArgument(mb, r2, getArg(q, 2));
1777 :
1778 19590 : r = newInstruction(mb, algebraRef, projectionRef);
1779 19590 : if (r == NULL) {
1780 0 : freeInstruction(r0);
1781 0 : freeInstruction(r1);
1782 0 : freeInstruction(r2);
1783 0 : freeInstruction(attr);
1784 0 : return -1;
1785 : }
1786 19590 : getArg(r, 0) = newTmpVariable(mb, atp);
1787 19590 : r = pushArgument(mb, r, getArg(q, 1));
1788 19590 : r = pushArgument(mb, r, getArg(ml->v[b].mi, i));
1789 19590 : if (setPartnr(ml, getArg(ml->v[b].mi, i), getArg(r, 0), i)) {
1790 0 : freeInstruction(r0);
1791 0 : freeInstruction(r1);
1792 0 : freeInstruction(r2);
1793 0 : freeInstruction(attr);
1794 0 : freeInstruction(r);
1795 0 : return -1;
1796 : }
1797 19590 : pushInstruction(mb, r);
1798 :
1799 19590 : attr = pushArgument(mb, attr, getArg(r, 0));
1800 : }
1801 4647 : pushInstruction(mb, r0);
1802 4647 : pushInstruction(mb, r1);
1803 4647 : pushInstruction(mb, r2);
1804 4647 : if (push)
1805 2565 : pushInstruction(mb, attr);
1806 :
1807 : /* create mat's for the intermediates */
1808 4647 : a = ml->top;
1809 4647 : if (mb->errors || mat_add_var(ml, attr, NULL, getArg(attr, 0), mat_ext,
1810 : -1, -1, push)) {
1811 0 : if (!push)
1812 0 : freeInstruction(attr);
1813 0 : return -1;
1814 : }
1815 4647 : g = ml->top;
1816 4647 : if (mat_add_var(ml, r0, p, getArg(p, 0), mat_grp, b, -1, 1)
1817 4647 : || mat_add_var(ml, r1, p, getArg(p, 1), mat_ext, a, ml->top - 1, 1) /* point back at group */
1818 4647 : || mat_add_var(ml, r2, p, getArg(p, 2), mat_cnt, -1, ml->top - 1, 1)) /* point back at ext */
1819 0 : return -1;
1820 4647 : if (push)
1821 2565 : return mat_pack_group(mb, ml, g);
1822 : return 0;
1823 : }
1824 :
1825 : static int
1826 2383 : mat_group_derive(MalBlkPtr mb, InstrPtr p, matlist_t *ml, int b, int g)
1827 : {
1828 2383 : int tp0 = getArgType(mb, p, 0);
1829 2383 : int tp1 = getArgType(mb, p, 1);
1830 2383 : int tp2 = getArgType(mb, p, 2);
1831 2383 : int atp = getArgType(mb, p, 3), i, a, push = 0;
1832 2383 : InstrPtr r0, r1, r2, attr;
1833 :
1834 2383 : if (getFunctionId(p) == subgroupdoneRef || getFunctionId(p) == groupdoneRef)
1835 2082 : push = 1;
1836 :
1837 2383 : if (ml->v[g].im == -1) { /* already packed */
1838 0 : InstrPtr q = copyInstruction(p);
1839 0 : if (!q)
1840 : return -1;
1841 0 : pushInstruction(mb, q);
1842 0 : return 0;
1843 : }
1844 :
1845 2383 : r0 = newInstructionArgs(mb, matRef, packRef, ml->v[b].mi->argc);
1846 2383 : if (r0 == NULL)
1847 : return -1;
1848 2383 : getArg(r0, 0) = newTmpVariable(mb, tp0);
1849 :
1850 2383 : r1 = newInstructionArgs(mb, matRef, packRef, ml->v[b].mi->argc);
1851 2383 : if (r1 == NULL) {
1852 0 : freeInstruction(r0);
1853 0 : return -1;
1854 : }
1855 2383 : getArg(r1, 0) = newTmpVariable(mb, tp1);
1856 :
1857 2383 : r2 = newInstructionArgs(mb, matRef, packRef, ml->v[b].mi->argc);
1858 2383 : if (r2 == NULL) {
1859 0 : freeInstruction(r0);
1860 0 : freeInstruction(r1);
1861 0 : return -1;
1862 : }
1863 2383 : getArg(r2, 0) = newTmpVariable(mb, tp2);
1864 :
1865 : /* we keep an extend, attr table result, which will later be used
1866 : * when we pack the group result */
1867 2383 : attr = newInstructionArgs(mb, matRef, packRef, ml->v[b].mi->argc);
1868 2383 : if (attr == NULL) {
1869 0 : freeInstruction(r0);
1870 0 : freeInstruction(r1);
1871 0 : freeInstruction(r2);
1872 0 : return -1;
1873 : }
1874 2383 : getArg(attr, 0) = getArg(ml->v[b].mi, 0);
1875 :
1876 : /* we need overlapping ranges */
1877 12057 : for (i = 1; mb->errors == NULL && i < ml->v[b].mi->argc; i++) {
1878 9674 : InstrPtr q = copyInstruction(p), r;
1879 9674 : if (!q) {
1880 0 : freeInstruction(r0);
1881 0 : freeInstruction(r1);
1882 0 : freeInstruction(r2);
1883 0 : freeInstruction(attr);
1884 0 : return -1;
1885 : }
1886 :
1887 9674 : getArg(q, 0) = newTmpVariable(mb, tp0);
1888 9674 : getArg(q, 1) = newTmpVariable(mb, tp1);
1889 9674 : getArg(q, 2) = newTmpVariable(mb, tp2);
1890 9674 : getArg(q, 3) = getArg(ml->v[b].mi, i);
1891 9674 : getArg(q, 4) = getArg(ml->v[g].mi, i);
1892 9674 : pushInstruction(mb, q);
1893 9674 : if (setPartnr(ml, getArg(ml->v[b].mi, i), getArg(q, 0), i)
1894 9674 : || setPartnr(ml, getArg(ml->v[b].mi, i), getArg(q, 1), i)
1895 9674 : || setPartnr(ml, getArg(ml->v[b].mi, i), getArg(q, 2), i)) {
1896 0 : freeInstruction(r0);
1897 0 : freeInstruction(r1);
1898 0 : freeInstruction(r2);
1899 0 : freeInstruction(attr);
1900 0 : return -1;
1901 : }
1902 :
1903 : /* add result to mats */
1904 9674 : r0 = pushArgument(mb, r0, getArg(q, 0));
1905 9674 : r1 = pushArgument(mb, r1, getArg(q, 1));
1906 9674 : r2 = pushArgument(mb, r2, getArg(q, 2));
1907 :
1908 9674 : r = newInstruction(mb, algebraRef, projectionRef);
1909 9674 : if (r == NULL) {
1910 0 : freeInstruction(r0);
1911 0 : freeInstruction(r1);
1912 0 : freeInstruction(r2);
1913 0 : freeInstruction(attr);
1914 0 : return -1;
1915 : }
1916 9674 : getArg(r, 0) = newTmpVariable(mb, atp);
1917 9674 : r = pushArgument(mb, r, getArg(q, 1));
1918 9674 : r = pushArgument(mb, r, getArg(ml->v[b].mi, i));
1919 9674 : if (setPartnr(ml, getArg(ml->v[b].mi, i), getArg(r, 0), i)) {
1920 0 : freeInstruction(r0);
1921 0 : freeInstruction(r1);
1922 0 : freeInstruction(r2);
1923 0 : freeInstruction(attr);
1924 0 : freeInstruction(r);
1925 0 : return -1;
1926 : }
1927 9674 : pushInstruction(mb, r);
1928 :
1929 9674 : attr = pushArgument(mb, attr, getArg(r, 0));
1930 : }
1931 2383 : pushInstruction(mb, r0);
1932 2383 : pushInstruction(mb, r1);
1933 2383 : pushInstruction(mb, r2);
1934 2383 : if (push)
1935 2082 : pushInstruction(mb, attr);
1936 :
1937 2383 : if (mb->errors || mat_group_attr(mb, ml, g, r1, push))
1938 0 : return -1;
1939 :
1940 : /* create mat's for the intermediates */
1941 2383 : a = ml->top;
1942 2383 : if (mat_add_var(ml, attr, NULL, getArg(attr, 0), mat_ext, -1, -1, push)) {
1943 0 : if (!push)
1944 0 : freeInstruction(attr);
1945 0 : return -1;
1946 : }
1947 2383 : if (mat_add_var(ml, r0, p, getArg(p, 0), mat_grp, b, g, 1))
1948 : return -1;
1949 2383 : g = ml->top - 1;
1950 4766 : if (mat_add_var(ml, r1, p, getArg(p, 1), mat_ext, a, ml->top - 1, 1) || /* point back at group */
1951 2383 : mat_add_var(ml, r2, p, getArg(p, 2), mat_cnt, -1, ml->top - 1, 1)) /* point back at ext */
1952 0 : return -1;
1953 2383 : if (push)
1954 2082 : return mat_pack_group(mb, ml, g);
1955 : return 0;
1956 : }
1957 :
1958 : static int
1959 591 : mat_topn_project(MalBlkPtr mb, InstrPtr p, mat_t *mat, int m, int n)
1960 : {
1961 591 : int tpe = getArgType(mb, p, 0), k;
1962 591 : InstrPtr pck, q;
1963 :
1964 591 : pck = newInstructionArgs(mb, matRef, packRef, mat[m].mi->argc);
1965 591 : if (pck == NULL)
1966 : return -1;
1967 591 : getArg(pck, 0) = newTmpVariable(mb, tpe);
1968 :
1969 4626 : for (k = 1; mb->errors == NULL && k < mat[m].mi->argc; k++) {
1970 4035 : InstrPtr q = copyInstruction(p);
1971 4035 : if (!q) {
1972 0 : freeInstruction(pck);
1973 0 : return -1;
1974 : }
1975 :
1976 4035 : getArg(q, 0) = newTmpVariable(mb, tpe);
1977 4035 : getArg(q, 1) = getArg(mat[m].mi, k);
1978 4035 : getArg(q, 2) = getArg(mat[n].mi, k);
1979 4035 : pushInstruction(mb, q);
1980 :
1981 4035 : pck = pushArgument(mb, pck, getArg(q, 0));
1982 : }
1983 591 : pushInstruction(mb, pck);
1984 :
1985 591 : if (mb->errors || (q = copyInstruction(p)) == NULL)
1986 0 : return -1;
1987 591 : getArg(q, 2) = getArg(pck, 0);
1988 591 : pushInstruction(mb, q);
1989 591 : if (mb->errors)
1990 : return -1;
1991 : return 0;
1992 : }
1993 :
1994 : static int
1995 104 : mat_pack_topn(MalBlkPtr mb, InstrPtr slc, mat_t *mat, int m)
1996 : {
1997 : /* find chain of topn's */
1998 104 : int cnt = chain_by_length(mat, m), i;
1999 104 : InstrPtr cur = NULL;
2000 :
2001 230 : for (i = cnt - 1; mb->errors == NULL && i >= 0; i--) {
2002 126 : int otpn = walk_n_back(mat, m, i), var = 1, k;
2003 126 : int attr = mat[otpn].im;
2004 126 : int tpe = getVarType(mb, getArg(mat[attr].mi, 0));
2005 126 : InstrPtr pck, tpn, otopn = mat[otpn].org, a;
2006 :
2007 126 : pck = newInstructionArgs(mb, matRef, packRef, mat[attr].mi->argc);
2008 126 : if (pck == NULL)
2009 : return -1;
2010 126 : getArg(pck, 0) = newTmpVariable(mb, tpe);
2011 :
2012 : /* m.projection(attr); */
2013 689 : for (k = 1; mb->errors == NULL && k < mat[attr].mi->argc; k++) {
2014 563 : InstrPtr q = newInstruction(mb, algebraRef, projectionRef);
2015 563 : if (q == NULL) {
2016 0 : freeInstruction(pck);
2017 0 : return -1;
2018 : }
2019 563 : getArg(q, 0) = newTmpVariable(mb, tpe);
2020 :
2021 563 : q = pushArgument(mb, q, getArg(slc, k));
2022 563 : q = pushArgument(mb, q, getArg(mat[attr].mi, k));
2023 563 : pushInstruction(mb, q);
2024 :
2025 563 : pck = pushArgument(mb, pck, getArg(q, 0));
2026 : }
2027 126 : pushInstruction(mb, pck);
2028 :
2029 126 : a = pck;
2030 :
2031 126 : if (mb->errors || (tpn = copyInstruction(otopn)) == NULL)
2032 0 : return -1;
2033 126 : var = 1;
2034 126 : if (cur) {
2035 22 : getArg(tpn, tpn->retc + var) = getArg(cur, 0);
2036 22 : var ++;
2037 22 : if (cur->retc == 2) {
2038 22 : getArg(tpn, tpn->retc + var) = getArg(cur, 1);
2039 22 : var ++;
2040 : }
2041 : }
2042 126 : getArg(tpn, tpn->retc) = getArg(a, 0);
2043 126 : pushInstruction(mb, tpn);
2044 126 : cur = tpn;
2045 : }
2046 104 : if (mb->errors)
2047 : return -1;
2048 : return 0;
2049 : }
2050 :
2051 : static int
2052 180 : mat_topn(MalBlkPtr mb, InstrPtr p, matlist_t *ml, int m, int n, int o)
2053 : {
2054 180 : int tpe = getArgType(mb, p, 0), k, is_slice = isSlice(p), zero = -1;
2055 180 : InstrPtr pck, gpck = NULL, q, r;
2056 180 : int with_groups = (p->retc == 2), piv = 0, topn2 = (n >= 0);
2057 :
2058 180 : assert(topn2 || o < 0);
2059 : /* dummy mat instruction (needed to share result of p) */
2060 180 : pck = newInstructionArgs(mb, matRef, packRef, ml->v[m].mi->argc);
2061 180 : if (pck == NULL)
2062 : return -1;
2063 180 : getArg(pck, 0) = getArg(p, 0);
2064 :
2065 180 : if (with_groups) {
2066 22 : gpck = newInstructionArgs(mb, matRef, packRef, ml->v[m].mi->argc);
2067 22 : if (gpck == NULL) {
2068 0 : freeInstruction(pck);
2069 0 : return -1;
2070 : }
2071 22 : getArg(gpck, 0) = getArg(p, 1);
2072 : }
2073 :
2074 180 : if (is_slice) {
2075 54 : ValRecord cst;
2076 54 : cst.vtype = getArgType(mb, p, 2);
2077 54 : cst.val.lval = 0;
2078 54 : cst.len = 0;
2079 54 : zero = defConstant(mb, cst.vtype, &cst);
2080 54 : if (zero < 0) {
2081 0 : freeInstruction(pck);
2082 0 : return -1;
2083 : }
2084 : }
2085 180 : assert((n < 0 && o < 0)
2086 : || (ml->v[m].mi->argc == ml->v[n].mi->argc
2087 : && ml->v[m].mi->argc == ml->v[o].mi->argc));
2088 :
2089 1097 : for (k = 1; mb->errors == NULL && k < ml->v[m].mi->argc; k++) {
2090 917 : if ((q = copyInstruction(p)) == NULL) {
2091 0 : freeInstruction(gpck);
2092 0 : freeInstruction(pck);
2093 0 : return -1;
2094 : }
2095 917 : getArg(q, 0) = newTmpVariable(mb, tpe);
2096 917 : if (with_groups)
2097 117 : getArg(q, 1) = newTmpVariable(mb, tpe);
2098 917 : getArg(q, q->retc) = getArg(ml->v[m].mi, k);
2099 917 : if (is_slice) /* lower bound should always be 0 on partial slices */
2100 354 : getArg(q, q->retc + 1) = zero;
2101 563 : else if (topn2) {
2102 117 : getArg(q, q->retc + 1) = getArg(ml->v[n].mi, k);
2103 117 : getArg(q, q->retc + 2) = getArg(ml->v[o].mi, k);
2104 : }
2105 917 : pushInstruction(mb, q);
2106 :
2107 917 : pck = pushArgument(mb, pck, getArg(q, 0));
2108 917 : if (with_groups)
2109 117 : gpck = pushArgument(mb, gpck, getArg(q, 1));
2110 : }
2111 :
2112 180 : piv = ml->top;
2113 306 : if (mb->errors || mat_add_var(ml, pck, p, getArg(p, 0), is_slice ? mat_slc : mat_tpn, m, n, 0)) {
2114 0 : freeInstruction(pck);
2115 0 : freeInstruction(gpck);
2116 0 : return -1;
2117 : }
2118 180 : if (with_groups
2119 22 : && mat_add_var(ml, gpck, p, getArg(p, 1), is_slice ? mat_slc : mat_tpn,
2120 : m, piv, 0)) {
2121 0 : freeInstruction(gpck);
2122 0 : return -1;
2123 : }
2124 :
2125 180 : if (is_slice || p->retc == 1 /* single result, ie last of the topn's */ ) {
2126 158 : if (ml->v[m].type == mat_tpn || !is_slice) {
2127 104 : if (mat_pack_topn(mb, pck, ml->v, (!is_slice) ? piv : m))
2128 : return -1;
2129 : }
2130 :
2131 : /* topn/slice over merged parts */
2132 104 : if (is_slice) {
2133 : /* real instruction */
2134 54 : r = newInstructionArgs(mb, matRef, packRef, pck->argc);
2135 54 : if (r == NULL)
2136 : return -1;
2137 54 : getArg(r, 0) = newTmpVariable(mb, tpe);
2138 :
2139 408 : for (k = 1; k < pck->argc; k++)
2140 354 : r = pushArgument(mb, r, getArg(pck, k));
2141 54 : pushInstruction(mb, r);
2142 :
2143 54 : if ((q = copyInstruction(p)) == NULL)
2144 : return -1;
2145 54 : setFunctionId(q, subsliceRef);
2146 54 : if (ml->v[m].type != mat_tpn || is_slice)
2147 54 : getArg(q, 1) = getArg(r, 0);
2148 54 : pushInstruction(mb, q);
2149 : }
2150 :
2151 158 : ml->v[piv].type = mat_slc;
2152 : }
2153 180 : if (mb->errors)
2154 : return -1;
2155 : return 0;
2156 : }
2157 :
2158 : static int
2159 0 : mat_sample(MalBlkPtr mb, InstrPtr p, matlist_t *ml, int m)
2160 : {
2161 : /* transform
2162 : * a := sample.subuniform(b,n);
2163 : * into
2164 : * t1 := sample.subuniform(b1,n);
2165 : * t2 := sample.subuniform(b2,n);
2166 : * ...
2167 : * t0 := mat.pack(t1,t2,...);
2168 : * tn := sample.subuniform(t0,n);
2169 : * a := algebra.projection(tn,t0);
2170 : *
2171 : * Note that this does *not* give a uniform sample of the original
2172 : * bat b!
2173 : */
2174 :
2175 0 : int tpe = getArgType(mb, p, 0), k, piv;
2176 0 : InstrPtr pck, q, r;
2177 :
2178 0 : pck = newInstructionArgs(mb, matRef, packRef, ml->v[m].mi->argc);
2179 0 : if (pck == NULL)
2180 : return -1;
2181 0 : getArg(pck, 0) = newTmpVariable(mb, tpe);
2182 :
2183 0 : for (k = 1; mb->errors == NULL && k < ml->v[m].mi->argc; k++) {
2184 0 : if ((q = copyInstruction(p)) == NULL) {
2185 0 : freeInstruction(pck);
2186 0 : return -1;
2187 : }
2188 0 : getArg(q, 0) = newTmpVariable(mb, tpe);
2189 0 : getArg(q, q->retc) = getArg(ml->v[m].mi, k);
2190 0 : pushInstruction(mb, q);
2191 0 : pck = pushArgument(mb, pck, getArg(q, 0));
2192 : }
2193 :
2194 0 : piv = ml->top;
2195 0 : if (mb->errors || mat_add_var(ml, pck, p, getArg(p, 0), mat_slc, m, -1, 1)) {
2196 0 : freeInstruction(pck);
2197 0 : return -1;
2198 : }
2199 0 : pushInstruction(mb, pck);
2200 :
2201 0 : if ((q = copyInstruction(p)) == NULL)
2202 : return -1;
2203 0 : getArg(q, 0) = newTmpVariable(mb, tpe);
2204 0 : getArg(q, q->retc) = getArg(pck, 0);
2205 0 : pushInstruction(mb, q);
2206 :
2207 0 : r = newInstruction(mb, algebraRef, projectionRef);
2208 0 : if (r == NULL)
2209 : return -1;
2210 0 : getArg(r, 0) = getArg(p, 0);
2211 0 : r = pushArgument(mb, r, getArg(q, 0));
2212 0 : r = pushArgument(mb, r, getArg(pck, 0));
2213 0 : pushInstruction(mb, r);
2214 :
2215 0 : matlist_pack(ml, piv);
2216 0 : ml->v[piv].type = mat_slc;
2217 0 : if (mb->errors)
2218 : return -1;
2219 : return 0;
2220 : }
2221 :
2222 : str
2223 487570 : OPTmergetableImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk,
2224 : InstrPtr pci)
2225 : {
2226 487570 : InstrPtr p, *old;
2227 487570 : matlist_t ml;
2228 487570 : int oldtop, fm, fn, fo, fe, i, k, m, n, o, e, slimit, bailout = 0;
2229 487570 : int size = 0, match, actions = 0, distinct_topn = 0, /*topn_res = 0, */ groupdone = 0, *vars; //, maxvars;
2230 487570 : char *group_input;
2231 487570 : str msg = MAL_SUCCEED;
2232 :
2233 487570 : if (isOptimizerUsed(mb, pci, mitosisRef) <= 0)
2234 33771 : goto cleanup2;
2235 453800 : old = mb->stmt;
2236 453800 : oldtop = mb->stop;
2237 :
2238 453800 : vars = (int *) GDKmalloc(sizeof(int) * mb->vtop);
2239 : //maxvars = mb->vtop;
2240 453800 : group_input = (char *) GDKzalloc(sizeof(char) * mb->vtop);
2241 453799 : if (vars == NULL || group_input == NULL) {
2242 0 : if (vars)
2243 0 : GDKfree(vars);
2244 0 : throw(MAL, "optimizer.mergetable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2245 : }
2246 : /* check for bailout conditions */
2247 20077429 : for (i = 1; i < oldtop && !bailout; i++) {
2248 19623635 : int j;
2249 :
2250 19623635 : p = old[i];
2251 :
2252 39387214 : for (j = 0; j < p->retc; j++) {
2253 19763579 : int res = getArg(p, j);
2254 19763579 : vars[res] = i;
2255 : }
2256 :
2257 : /* pack if there is a group statement following a groupdone (ie aggr(distinct)) */
2258 19623635 : if (getModuleId(p) == groupRef && p->argc == 5
2259 5285 : && (getFunctionId(p) == subgroupRef
2260 3616 : || getFunctionId(p) == subgroupdoneRef
2261 0 : || getFunctionId(p) == groupRef
2262 0 : || getFunctionId(p) == groupdoneRef)) {
2263 5285 : InstrPtr q = old[vars[getArg(p, p->argc - 1)]]; /* group result from a previous group(done) */
2264 :
2265 5285 : if (getFunctionId(q) == subgroupdoneRef
2266 5280 : || getFunctionId(q) == groupdoneRef)
2267 19623635 : groupdone = 1;
2268 : }
2269 : /* bail out if there is a input for a group, which has been used for a group already (solves problems with cube like groupings) */
2270 19623635 : if (getModuleId(p) == groupRef
2271 26070 : && (getFunctionId(p) == subgroupRef
2272 24401 : || getFunctionId(p) == subgroupdoneRef
2273 20785 : || getFunctionId(p) == groupRef
2274 17139 : || getFunctionId(p) == groupdoneRef)) {
2275 26070 : int input = getArg(p, p->retc); /* argument one is first input */
2276 :
2277 26070 : if (group_input[input]) {
2278 114 : TRC_INFO(MAL_OPTIMIZER,
2279 : "Mergetable bailout on group input reuse in group statement\n");
2280 : bailout = 1;
2281 : }
2282 :
2283 26070 : group_input[input] = 1;
2284 : }
2285 19623635 : if (getModuleId(p) == algebraRef && getFunctionId(p) == selectNotNilRef) {
2286 0 : TRC_INFO(MAL_OPTIMIZER, "Mergetable bailout not nil ref\n");
2287 : bailout = 1;
2288 : }
2289 19623635 : if (getModuleId(p) == algebraRef && getFunctionId(p) == semijoinRef) {
2290 181 : TRC_INFO(MAL_OPTIMIZER, "Mergetable bailout semijoin ref\n");
2291 : bailout = 1;
2292 : }
2293 19623635 : if (getModuleId(p) == algebraRef && getFunctionId(p) == thetajoinRef) {
2294 2607 : assert(p->argc == 9);
2295 2607 : if (p->argc == 9
2296 2607 : && getVarConstant(mb,
2297 : getArg(p,
2298 2607 : 6)).val.ival == 6 /* op == '<>' */ ) {
2299 0 : TRC_INFO(MAL_OPTIMIZER, "Mergetable bailout thetajoin ref\n");
2300 : bailout = 1;
2301 : }
2302 : }
2303 19623635 : if (isSample(p)) {
2304 21 : bailout = 1;
2305 : }
2306 : /*
2307 : if (isTopn(p))
2308 : topn_res = getArg(p, 0);
2309 : */
2310 : /* not idea how to detect this yet */
2311 : //distinct_topn = 1;
2312 : }
2313 453794 : GDKfree(group_input);
2314 :
2315 453800 : ml.horigin = 0;
2316 453800 : ml.torigin = 0;
2317 453800 : ml.v = 0;
2318 453800 : ml.vars = 0;
2319 453800 : if (bailout)
2320 316 : goto cleanup;
2321 :
2322 : /* the number of MATs is limited to the variable stack */
2323 453484 : ml.size = mb->vtop;
2324 453484 : ml.top = 0;
2325 453484 : ml.v = (mat_t *) GDKzalloc(ml.size * sizeof(mat_t));
2326 453484 : ml.vsize = mb->vsize;
2327 453484 : ml.horigin = (int *) GDKmalloc(sizeof(int) * ml.vsize);
2328 453480 : ml.torigin = (int *) GDKmalloc(sizeof(int) * ml.vsize);
2329 453482 : ml.vars = (int *) GDKmalloc(sizeof(int) * ml.vsize);
2330 453480 : if (ml.v == NULL || ml.horigin == NULL || ml.torigin == NULL
2331 453480 : || ml.vars == NULL) {
2332 0 : goto cleanup;
2333 : }
2334 124370024 : for (i = 0; i < ml.vsize; i++) {
2335 123916544 : ml.horigin[i] = ml.torigin[i] = -1;
2336 123916544 : ml.vars[i] = -1;
2337 : }
2338 :
2339 453480 : slimit = mb->ssize;
2340 453480 : size = (mb->stop * 1.2 < mb->ssize) ? mb->ssize : (int) (mb->stop * 1.2);
2341 453480 : mb->stmt = (InstrPtr *) GDKzalloc(size * sizeof(InstrPtr));
2342 453484 : if (mb->stmt == NULL) {
2343 0 : mb->stmt = old;
2344 0 : msg = createException(MAL, "optimizer.mergetable",
2345 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2346 0 : goto cleanup;
2347 : }
2348 453484 : mb->ssize = size;
2349 453484 : mb->stop = 0;
2350 :
2351 6445878 : for (i = 0; i < oldtop; i++) {
2352 6445878 : int bats = 0, nilbats = 0;
2353 6445878 : InstrPtr r, cp;
2354 :
2355 6445878 : p = old[i];
2356 :
2357 6445878 : if (p->token == ENDsymbol) /* don't copy the optimizer pipeline added after final instruction */
2358 : break;
2359 5992396 : if (getModuleId(p) == matRef
2360 242631 : && (getFunctionId(p) == newRef || getFunctionId(p) == packRef)) {
2361 242631 : if (mat_set_prop(&ml, mb, p)
2362 242631 : || mat_add_var(&ml, p, NULL, getArg(p, 0), mat_none, -1, -1,
2363 : 1)) {
2364 0 : msg = createException(MAL, "optimizer.mergetable",
2365 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2366 0 : goto cleanup;
2367 : }
2368 242631 : continue;
2369 : }
2370 :
2371 : /*
2372 : * If the instruction does not contain MAT references it can simply be added.
2373 : * Otherwise we have to decide on either packing them or replacement.
2374 : */
2375 5749765 : if ((match = nr_of_mats(p, &ml)) == 0) {
2376 4554154 : cp = copyInstruction(p);
2377 4554184 : if (!cp) {
2378 0 : msg = createException(MAL, "optimizer.mergetable",
2379 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2380 0 : goto cleanup;
2381 : }
2382 4554184 : pushInstruction(mb, cp);
2383 4554188 : continue;
2384 : }
2385 1195611 : bats = nr_of_bats(mb, p);
2386 1195611 : nilbats = nr_of_nilbats(mb, p);
2387 :
2388 : /* left joins can match at isMatJoinOp, so run this check beforehand */
2389 1195611 : if (match > 0 && isMatLeftJoinOp(p) && p->argc >= 5 && p->retc == 2
2390 302 : && (match == 1 || match == 2) && bats + nilbats == 4) {
2391 302 : m = is_a_mat(getArg(p, p->retc), &ml);
2392 302 : o = is_a_mat(getArg(p, p->retc + 2), &ml);
2393 :
2394 302 : if ((match == 1 && m >= 0) || (match == 2 && m >= 0 && o >= 0)) {
2395 294 : if (mat_join2(mb, p, &ml, m, -1, o, -1)) {
2396 0 : msg = createException(MAL, "optimizer.mergetable",
2397 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2398 0 : goto cleanup;
2399 : }
2400 294 : actions++;
2401 294 : continue;
2402 : }
2403 : }
2404 :
2405 : /* (l,r) Join (L, R, ..)
2406 : * 2 -> (l,r) equi/theta joins (l,r)
2407 : * 3 -> (l,r) range-joins (l,r1,r2)
2408 : * NxM -> (l,r) filter-joins (l1,..,ln,r1,..,rm)
2409 : */
2410 1195317 : if (match > 0 && isMatJoinOp(p) && !isMatLeftJoinOp(p) && p->argc >= 5
2411 49396 : && p->retc == 2 && bats + nilbats >= 4) {
2412 42619 : if (bats + nilbats == 4) {
2413 42564 : m = is_a_mat(getArg(p, p->retc), &ml);
2414 42564 : n = is_a_mat(getArg(p, p->retc + 1), &ml);
2415 42564 : o = is_a_mat(getArg(p, p->retc + 2), &ml);
2416 42564 : e = is_a_mat(getArg(p, p->retc + 3), &ml);
2417 42564 : if (mat_join2(mb, p, &ml, m, n, o, e)) {
2418 0 : msg = createException(MAL, "optimizer.mergetable",
2419 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2420 0 : goto cleanup;
2421 : }
2422 : } else {
2423 55 : if (mat_joinNxM(cntxt, mb, p, &ml, bats)) {
2424 0 : msg = createException(MAL, "optimizer.mergetable",
2425 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2426 0 : goto cleanup;
2427 : }
2428 : }
2429 42619 : actions++;
2430 42619 : continue;
2431 : }
2432 1152698 : if (match > 0 && getModuleId(p) == algebraRef
2433 902907 : && getFunctionId(p) == crossRef && p->argc == 5 && p->retc == 2
2434 6777 : && bats == 2) {
2435 1159475 : int max_one = (isVarConstant(mb, getArg(p, 4))
2436 6777 : && getVarConstant(mb, getArg(p, 4)).val.btval);
2437 10302 : if (!max_one) {
2438 5151 : m = is_a_mat(getArg(p, p->retc), &ml);
2439 5151 : n = is_a_mat(getArg(p, p->retc + 1), &ml);
2440 5151 : if (mat_join2(mb, p, &ml, m, n, -1, -1)) {
2441 0 : msg = createException(MAL, "optimizer.mergetable",
2442 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2443 0 : goto cleanup;
2444 : }
2445 5151 : actions++;
2446 5151 : continue;
2447 : }
2448 : }
2449 : /*
2450 : * Aggregate handling is a prime target for optimization.
2451 : * The simple cases are dealt with first.
2452 : * Handle the rewrite v:=aggr.count(b) and sum()
2453 : * And the min/max is as easy
2454 : */
2455 1147547 : if (match == 1 && p->argc >= 2 &&
2456 245052 : ((getModuleId(p) == aggrRef &&
2457 1747 : (getFunctionId(p) == countRef
2458 1453 : || getFunctionId(p) == count_no_nilRef
2459 1453 : || getFunctionId(p) == minRef || getFunctionId(p) == maxRef
2460 1359 : || getFunctionId(p) == avgRef || getFunctionId(p) == sumRef
2461 121 : || getFunctionId(p) == prodRef)))
2462 1631 : && (m = is_a_mat(getArg(p, p->retc + 0), &ml)) >= 0) {
2463 1631 : if ((msg = mat_aggr(mb, p, ml.v, m)) != MAL_SUCCEED)
2464 0 : goto cleanup;
2465 1631 : actions++;
2466 1631 : continue;
2467 : }
2468 :
2469 1145916 : if (match == 1 && bats == 1 && p->argc == 4 && isSlice(p)
2470 54 : && ((m = is_a_mat(getArg(p, p->retc), &ml)) >= 0)) {
2471 54 : if (mat_topn(mb, p, &ml, m, -1, -1)) {
2472 0 : msg = createException(MAL, "optimizer.mergetable",
2473 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2474 0 : goto cleanup;
2475 : }
2476 54 : actions++;
2477 54 : continue;
2478 : }
2479 :
2480 1145862 : if (match == 1 && bats == 1 && p->argc == 3 && isSample(p)
2481 0 : && ((m = is_a_mat(getArg(p, p->retc), &ml)) >= 0)) {
2482 0 : if (mat_sample(mb, p, &ml, m)) {
2483 0 : msg = createException(MAL, "optimizer.mergetable",
2484 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2485 0 : goto cleanup;
2486 : }
2487 0 : actions++;
2488 0 : continue;
2489 : }
2490 :
2491 1145862 : if (!distinct_topn && match == 1 && bats == 1 && isTopn(p)
2492 104 : && ((m = is_a_mat(getArg(p, p->retc), &ml)) >= 0)) {
2493 104 : if (mat_topn(mb, p, &ml, m, -1, -1)) {
2494 0 : msg = createException(MAL, "optimizer.mergetable",
2495 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2496 0 : goto cleanup;
2497 : }
2498 104 : actions++;
2499 104 : continue;
2500 : }
2501 1145758 : if (!distinct_topn && match == 3 && bats == 3 && isTopn(p)
2502 22 : && ((m = is_a_mat(getArg(p, p->retc), &ml)) >= 0)
2503 22 : && ((n = is_a_mat(getArg(p, p->retc + 1), &ml)) >= 0)
2504 22 : && ((o = is_a_mat(getArg(p, p->retc + 2), &ml)) >= 0)) {
2505 22 : if (mat_topn(mb, p, &ml, m, n, o)) {
2506 0 : msg = createException(MAL, "optimizer.mergetable",
2507 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2508 0 : goto cleanup;
2509 : }
2510 22 : actions++;
2511 22 : continue;
2512 : }
2513 :
2514 : /* Now we handle subgroup and aggregation statements. */
2515 1145736 : if (!groupdone && match == 1 && bats == 1 && p->argc == 4
2516 15089 : && getModuleId(p) == groupRef &&
2517 4647 : (getFunctionId(p) == subgroupRef
2518 4647 : || getFunctionId(p) == subgroupdoneRef
2519 4647 : || getFunctionId(p) == groupRef
2520 2565 : || getFunctionId(p) == groupdoneRef)
2521 4647 : && ((m = is_a_mat(getArg(p, p->retc), &ml)) >= 0)) {
2522 4647 : if (mat_group_new(mb, p, &ml, m)) {
2523 0 : msg = createException(MAL, "optimizer.mergetable",
2524 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2525 0 : goto cleanup;
2526 : }
2527 4647 : actions++;
2528 4647 : continue;
2529 : }
2530 1141089 : if (!groupdone && match == 2 && bats == 2 && p->argc == 5
2531 34162 : && getModuleId(p) == groupRef &&
2532 2383 : (getFunctionId(p) == subgroupRef
2533 2082 : || getFunctionId(p) == subgroupdoneRef
2534 0 : || getFunctionId(p) == groupRef
2535 0 : || getFunctionId(p) == groupdoneRef)
2536 2383 : && ((m = is_a_mat(getArg(p, p->retc), &ml)) >= 0)
2537 2383 : && ((n = is_a_mat(getArg(p, p->retc + 1), &ml)) >= 0)
2538 2383 : && ml.v[n].im >= 0 /* not packed */ ) {
2539 2383 : if (mat_group_derive(mb, p, &ml, m, n)) {
2540 0 : msg = createException(MAL, "optimizer.mergetable",
2541 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2542 0 : goto cleanup;
2543 : }
2544 2383 : actions++;
2545 2383 : continue;
2546 : }
2547 : /* TODO sub'aggr' with cand list */
2548 1138706 : if (match == 3 && bats == 3 && getModuleId(p) == aggrRef && p->argc >= 4
2549 3151 : && (getFunctionId(p) == subcountRef
2550 460 : || getFunctionId(p) == subminRef
2551 406 : || getFunctionId(p) == submaxRef
2552 350 : || getFunctionId(p) == subavgRef
2553 299 : || getFunctionId(p) == subsumRef
2554 3 : || getFunctionId(p) == subprodRef)
2555 3151 : && ((m = is_a_mat(getArg(p, p->retc + 0), &ml)) >= 0)
2556 3151 : && ((n = is_a_mat(getArg(p, p->retc + 1), &ml)) >= 0)
2557 3151 : && ((o = is_a_mat(getArg(p, p->retc + 2), &ml)) >= 0)) {
2558 3151 : if (mat_group_aggr(mb, p, ml.v, m, n, o)) {
2559 0 : msg = createException(MAL, "optimizer.mergetable",
2560 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2561 0 : goto cleanup;
2562 : }
2563 3151 : actions++;
2564 3151 : continue;
2565 : }
2566 : /* Handle cases of ext.projection and .projection(grp) */
2567 1135555 : if (match == 2 && getModuleId(p) == algebraRef
2568 732010 : && getFunctionId(p) == projectionRef
2569 693125 : && (m = is_a_mat(getArg(p, 1), &ml)) >= 0
2570 693125 : && (n = is_a_mat(getArg(p, 2), &ml)) >= 0
2571 693125 : && (ml.v[m].type == mat_ext || ml.v[n].type == mat_grp)) {
2572 6917 : assert(ml.v[m].pushed);
2573 6917 : if (!ml.v[n].pushed) {
2574 6917 : if (mat_group_project(mb, p, &ml, m, n)) {
2575 0 : msg = createException(MAL, "optimizer.mergetable",
2576 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2577 0 : goto cleanup;
2578 : }
2579 : } else {
2580 0 : cp = copyInstruction(p);
2581 0 : if (!cp) {
2582 0 : msg = createException(MAL, "optimizer.mergetable",
2583 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2584 0 : goto cleanup;
2585 : }
2586 0 : pushInstruction(mb, cp);
2587 : }
2588 6917 : continue;
2589 : }
2590 1128638 : if (match == 1 && getModuleId(p) == algebraRef
2591 165350 : && getFunctionId(p) == projectRef
2592 15958 : && (m = is_a_mat(getArg(p, 1), &ml)) >= 0
2593 15958 : && (ml.v[m].type == mat_ext)) {
2594 0 : assert(ml.v[m].pushed);
2595 0 : cp = copyInstruction(p);
2596 0 : if (!cp) {
2597 0 : msg = createException(MAL, "optimizer.mergetable",
2598 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2599 0 : goto cleanup;
2600 : }
2601 0 : pushInstruction(mb, cp);
2602 0 : continue;
2603 : }
2604 :
2605 : /* Handle cases of slice.projection */
2606 1128638 : if (match == 2 && getModuleId(p) == algebraRef
2607 725093 : && getFunctionId(p) == projectionRef
2608 686208 : && (m = is_a_mat(getArg(p, 1), &ml)) >= 0
2609 686208 : && (n = is_a_mat(getArg(p, 2), &ml)) >= 0
2610 686208 : && (ml.v[m].type == mat_slc)) {
2611 591 : if (mat_topn_project(mb, p, ml.v, m, n)) {
2612 0 : msg = createException(MAL, "optimizer.mergetable",
2613 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2614 0 : goto cleanup;
2615 : }
2616 591 : actions++;
2617 591 : continue;
2618 : }
2619 :
2620 : /* Handle projection */
2621 1128047 : if (match > 0
2622 1128047 : &&
2623 1128047 : ((getModuleId(p) == algebraRef && getFunctionId(p) == projectionRef)
2624 342311 : || ((getModuleId(p) == dictRef || getModuleId(p) == forRef)
2625 125 : && getFunctionId(p) == decompressRef))
2626 785804 : && (m = is_a_mat(getArg(p, 1), &ml)) >= 0) {
2627 766720 : n = is_a_mat(getArg(p, 2), &ml);
2628 766720 : if (mat_projection(mb, p, &ml, m, n)) {
2629 0 : msg = createException(MAL, "optimizer.mergetable",
2630 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2631 0 : goto cleanup;
2632 : }
2633 766720 : actions++;
2634 766720 : continue;
2635 : }
2636 : /* Handle setops */
2637 361327 : if (match > 0 && getModuleId(p) == algebraRef
2638 123416 : && (getFunctionId(p) == differenceRef
2639 112953 : || getFunctionId(p) == intersectRef)
2640 11463 : && (m = is_a_mat(getArg(p, 1), &ml)) >= 0) {
2641 10576 : n = is_a_mat(getArg(p, 2), &ml);
2642 10576 : o = is_a_mat(getArg(p, 3), &ml);
2643 10576 : if (mat_setop(mb, p, &ml, m, n, o)) {
2644 0 : msg = createException(MAL, "optimizer.mergetable",
2645 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2646 0 : goto cleanup;
2647 : }
2648 10576 : actions++;
2649 10576 : continue;
2650 : }
2651 :
2652 350751 : if (match == p->retc && p->argc == (p->retc * 2)
2653 9659 : && getFunctionId(p) == NULL) {
2654 3 : if ((r = mat_assign(mb, p, &ml)) == NULL) {
2655 0 : msg = createException(MAL, "optimizer.mergetable",
2656 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2657 0 : goto cleanup;
2658 : }
2659 3 : actions++;
2660 3 : continue;
2661 : }
2662 :
2663 350748 : m = n = o = e = -1;
2664 738464 : for (fm = p->argc - 1; fm >= p->retc; fm--)
2665 738464 : if ((m = is_a_mat(getArg(p, fm), &ml)) >= 0)
2666 : break;
2667 :
2668 447980 : for (fn = fm - 1; fn >= p->retc; fn--)
2669 290694 : if ((n = is_a_mat(getArg(p, fn), &ml)) >= 0)
2670 : break;
2671 :
2672 366791 : for (fo = fn - 1; fo >= p->retc; fo--)
2673 136022 : if ((o = is_a_mat(getArg(p, fo), &ml)) >= 0)
2674 : break;
2675 :
2676 370308 : for (fe = fo - 1; fe >= p->retc; fe--)
2677 57370 : if ((e = is_a_mat(getArg(p, fe), &ml)) >= 0)
2678 : break;
2679 :
2680 : /* delta* operator */
2681 350748 : if (match == 3 && bats == 3 && isDelta(p)
2682 58790 : && (m = is_a_mat(getArg(p, fm), &ml)) >= 0
2683 58790 : && (n = is_a_mat(getArg(p, fn), &ml)) >= 0
2684 58790 : && (o = is_a_mat(getArg(p, fo), &ml)) >= 0) {
2685 58790 : if ((r = mat_delta(&ml, mb, p, ml.v, m, n, o, -1, fm, fn, fo, 0)) != NULL) {
2686 58790 : actions++;
2687 : } else {
2688 0 : msg = createException(MAL, "optimizer.mergetable",
2689 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2690 0 : goto cleanup;
2691 : }
2692 :
2693 58790 : continue;
2694 : }
2695 291958 : if (match == 4 && bats == 4 && isDelta(p)
2696 33725 : && (m = is_a_mat(getArg(p, fm), &ml)) >= 0
2697 33725 : && (n = is_a_mat(getArg(p, fn), &ml)) >= 0
2698 33725 : && (o = is_a_mat(getArg(p, fo), &ml)) >= 0
2699 33725 : && (e = is_a_mat(getArg(p, fe), &ml)) >= 0) {
2700 33725 : if ((r = mat_delta(&ml, mb, p, ml.v, m, n, o, e, fm, fn, fo, fe)) != NULL) {
2701 33725 : actions++;
2702 : } else {
2703 0 : msg = createException(MAL, "optimizer.mergetable",
2704 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2705 0 : goto cleanup;
2706 : }
2707 33725 : continue;
2708 : }
2709 :
2710 : /* select on insert, should use last tid only */
2711 : #if 0
2712 : if (match == 1 && fm == 2 && isSelect(p) && p->retc == 1 && (m = is_a_mat(getArg(p, fm), &ml)) >= 0 && !ml.v[m].packed && /* not packed yet */
2713 : (getArg(p, fm - 1) > maxvars
2714 : || getModuleId(old[vars[getArg(p, fm - 1)]]) == sqlRef)) {
2715 : if ((r = copyInstruction(p)) == NULL) {
2716 : msg = createException(MAL, "optimizer.mergetable",
2717 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2718 : goto cleanup;
2719 : }
2720 : getArg(r, fm) = getArg(ml.v[m].mi, ml.v[m].mi->argc - 1);
2721 : pushInstruction(mb, r);
2722 : actions++;
2723 : continue;
2724 : }
2725 : #endif
2726 :
2727 : /* select on update, with nil bat */
2728 258233 : if (match == 1 && fm == 1 && isSelect(p) && p->retc == 1
2729 39148 : && (m = is_a_mat(getArg(p, fm), &ml)) >= 0 && bats == 2
2730 7639 : && isaBatType(getArgType(mb, p, 2))
2731 7639 : && isVarConstant(mb, getArg(p, 2))
2732 4 : && is_bat_nil(getVarConstant(mb, getArg(p, 2)).val.bval)) {
2733 4 : if (mat_apply1(mb, p, &ml, m, fm)) {
2734 0 : msg = createException(MAL, "optimizer.mergetable",
2735 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2736 0 : goto cleanup;
2737 : }
2738 4 : actions++;
2739 4 : continue;
2740 : }
2741 :
2742 : /* handle dict select */
2743 258229 : if ((match == 1 || match == bats - 1) && p->retc == 1 && isSelect(p)
2744 39197 : && getModuleId(p) == dictRef) {
2745 49 : if (mat_apply(mb, p, &ml, match)) {
2746 0 : msg = createException(MAL, "optimizer.mergetable",
2747 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2748 0 : goto cleanup;
2749 : }
2750 49 : actions++;
2751 49 : continue;
2752 : }
2753 : /* handle dict renumber */
2754 258180 : if (match == 1 && match == bats - 1 && p->retc == 1
2755 65765 : && getFunctionId(p) == renumberRef && getModuleId(p) == dictRef) {
2756 4 : if (mat_apply(mb, p, &ml, match)) {
2757 0 : msg = createException(MAL, "optimizer.mergetable",
2758 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2759 0 : goto cleanup;
2760 : }
2761 4 : actions++;
2762 4 : continue;
2763 : }
2764 :
2765 258176 : if (match == bats && p->retc == 1
2766 158998 : && (isMap2Op(p) || isMapOp(p) || isFragmentGroup(p)
2767 18325 : || isFragmentGroup2(p))) {
2768 158822 : if (mat_apply(mb, p, &ml, match)) {
2769 0 : msg = createException(MAL, "optimizer.mergetable",
2770 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2771 0 : goto cleanup;
2772 : }
2773 158822 : actions++;
2774 158822 : continue;
2775 : }
2776 :
2777 : /*
2778 : * All other instructions should be checked for remaining MAT dependencies.
2779 : * It requires MAT materialization.
2780 : */
2781 :
2782 492845 : for (k = p->retc; msg == MAL_SUCCEED && k < p->argc; k++) {
2783 393491 : if ((m = is_a_mat(getArg(p, k), &ml)) >= 0) {
2784 156217 : msg = mat_pack(mb, &ml, m);
2785 156217 : if (msg)
2786 : break;
2787 : }
2788 : }
2789 99354 : if (msg)
2790 : break;
2791 :
2792 99354 : cp = copyInstruction(p);
2793 99354 : if (!cp) {
2794 0 : msg = createException(MAL, "optimizer.mergetable",
2795 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
2796 0 : goto cleanup;
2797 : }
2798 99354 : pushInstruction(mb, cp);
2799 : }
2800 : (void) stk;
2801 :
2802 14510298 : for (; i < oldtop; i++) { /* add optimizer pipeline back again */
2803 14056820 : pushInstruction(mb, old[i]);
2804 : }
2805 :
2806 453478 : if (mb->errors == MAL_SUCCEED) {
2807 6445948 : for (i = 0; i < slimit; i++) {
2808 6445948 : if (old[i] && old[i]->token == ENDsymbol) /* don't free optimizer calls */
2809 : break;
2810 5992465 : freeInstruction(old[i]);
2811 : }
2812 453483 : GDKfree(old);
2813 : }
2814 1852442 : for (i = 0; i < ml.top; i++) {
2815 1398958 : if (ml.v[i].mi && !ml.v[i].pushed)
2816 1128207 : freeInstruction(ml.v[i].mi);
2817 : }
2818 453484 : cleanup:
2819 453800 : if (vars)
2820 453800 : GDKfree(vars);
2821 453800 : if (ml.v)
2822 453484 : GDKfree(ml.v);
2823 453800 : if (ml.horigin)
2824 453484 : GDKfree(ml.horigin);
2825 453799 : if (ml.torigin)
2826 453483 : GDKfree(ml.torigin);
2827 453800 : if (ml.vars)
2828 453484 : GDKfree(ml.vars);
2829 453800 : if (mb->errors) {
2830 0 : freeException(msg);
2831 0 : msg = mb->errors;
2832 0 : mb->errors = NULL;
2833 : }
2834 : /* Defense line against incorrect plans */
2835 453800 : if (actions > 0 && msg == MAL_SUCCEED) {
2836 30010 : msg = chkTypes(cntxt->usermodule, mb, FALSE);
2837 30010 : if (!msg)
2838 30010 : msg = chkFlow(mb);
2839 30010 : if (!msg)
2840 30010 : msg = chkDeclarations(mb);
2841 : }
2842 423790 : cleanup2:
2843 : /* keep actions taken as a fake argument */
2844 487571 : if (msg == MAL_SUCCEED) {
2845 487571 : (void) pushInt(mb, pci, actions);
2846 487566 : msg = mb->errors; /* may well be NULL */
2847 487566 : mb->errors = NULL;
2848 : }
2849 :
2850 : #ifndef NDEBUG
2851 487566 : if (bailout)
2852 316 : TRC_INFO(MAL_OPTIMIZER, "Merge table bailout\n");
2853 : #endif
2854 : return msg;
2855 : }
|
