Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024, 2025 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : /*
14 : * @f sql_gencode
15 : * @t SQL to MAL code generation.
16 : * @a N. Nes, M. Kersten
17 : * @+ MAL Code generation
18 : * This module contains the actions to construct a MAL program, ready for
19 : * optimization and execution by the Monet V5 kernel.
20 : *
21 : * The code base is modeled directly after its MIL variant, replacing
22 : * each IO request by instructions to initialize the corresponding MAL data
23 : * structure.
24 : * To speed up the compilation, we may consider keeping a cache of pre-compiled
25 : * statements.
26 : *
27 : * MAL extensions needed. A temporary variable used as an argument
28 : * should be printed (done). Consider replacing modname/fcnname by
29 : * an integer constant and a global lookup table. This should
30 : * reduce the cost to prepare MAL statements significantly.
31 : *
32 : * A dummy module is needed to load properly.
33 : */
34 : #include "monetdb_config.h"
35 : #include "sql_gencode.h"
36 : #include "sql_optimizer.h"
37 : #include "sql_scenario.h"
38 : #include "sql_mvc.h"
39 : #include "sql_qc.h"
40 : #include "mal_namespace.h"
41 : #include "opt_support.h"
42 : #include "querylog.h"
43 : #include "mal_builder.h"
44 :
45 : #include "rel_select.h"
46 : #include "rel_prop.h"
47 : #include "rel_rel.h"
48 : #include "rel_exp.h"
49 : #include "rel_psm.h"
50 : #include "rel_bin.h"
51 : #include "rel_dump.h"
52 :
53 : #include "msabaoth.h" /* msab_getUUID */
54 : #include "muuid.h"
55 : #include "rel_remote.h"
56 : #include "rel_physical.h"
57 : #include "sql_user.h"
58 :
59 : int
60 3341540 : constantAtom(backend *sql, MalBlkPtr mb, atom *a)
61 : {
62 3341540 : int idx;
63 3341540 : ValPtr vr = (ValPtr) &a->data;
64 3341540 : ValRecord cst;
65 :
66 3341540 : (void) sql;
67 3341540 : cst.vtype = 0;
68 3341540 : if (VALcopy(&cst, vr) == NULL)
69 : return -1;
70 3341511 : idx = defConstant(mb, vr->vtype, &cst);
71 3341511 : return idx;
72 : }
73 :
74 : InstrPtr
75 2808 : table_func_create_result(MalBlkPtr mb, InstrPtr q, sql_func *f, list *restypes)
76 : {
77 2808 : node *n;
78 2808 : int i;
79 :
80 2808 : if (q == NULL)
81 : return NULL;
82 2808 : if (f->varres) {
83 11512 : for (i = 0, n = restypes->h; n; n = n->next, i++) {
84 10379 : sql_subtype *st = n->data;
85 10379 : int type = st->type->localtype;
86 :
87 10379 : type = newBatType(type);
88 10379 : if (i) {
89 9246 : if ((q = pushReturn(mb, q, newTmpVariable(mb, type))) == NULL)
90 : return NULL;
91 : } else
92 1133 : setVarType(mb, getArg(q, 0), type);
93 : }
94 : } else {
95 15473 : for (i = 0, n = f->res->h; n; n = n->next, i++) {
96 13798 : sql_arg *a = n->data;
97 13798 : int type = a->type.type->localtype;
98 :
99 13798 : type = newBatType(type);
100 13798 : if (i) {
101 12123 : if ((q = pushReturn(mb, q, newTmpVariable(mb, type))) == NULL)
102 : return NULL;
103 : } else
104 1675 : setVarType(mb, getArg(q, 0), type);
105 : }
106 : }
107 : return q;
108 : }
109 :
110 : sql_rel *
111 559 : relational_func_create_result_part1(mvc *sql, sql_rel *r, int *nargs)
112 : {
113 559 : if (is_topn(r->op) || is_sample(r->op))
114 0 : r = r->l;
115 559 : if (!is_project(r->op))
116 0 : r = rel_project(sql->sa, r, rel_projections(sql, r, NULL, 1, 1));
117 559 : *nargs = list_length(r->exps);
118 558 : return r;
119 : }
120 :
121 : InstrPtr
122 559 : relational_func_create_result_part2(MalBlkPtr mb, InstrPtr q, sql_rel *r)
123 : {
124 559 : node *n;
125 559 : int i;
126 :
127 559 : if (q == NULL)
128 : return NULL;
129 559 : q->argc = q->retc = 0;
130 4826 : for (i = 0, n = r->exps->h; n; n = n->next, i++) {
131 4267 : sql_exp *e = n->data;
132 4267 : int type = exp_subtype(e)->type->localtype;
133 :
134 4267 : type = newBatType(type);
135 4267 : q = pushReturn(mb, q, newTmpVariable(mb, type));
136 : }
137 : return q;
138 : }
139 :
140 : static int
141 183 : _create_relational_function_body(mvc *m, sql_rel *r, stmt *call, list *rel_ops, int inline_func)
142 : {
143 183 : Client c = MCgetClient(m->clientid);
144 183 : backend *be = (backend *) c->sqlcontext;
145 183 : MalBlkPtr curBlk = 0;
146 183 : InstrPtr curInstr = 0;
147 183 : int res = 0, added_to_cache = 0;
148 183 : str msg = MAL_SUCCEED;
149 :
150 183 : curBlk = c->curprg->def;
151 183 : curInstr = getInstrPtr(curBlk, 0);
152 :
153 183 : curInstr = relational_func_create_result_part2(curBlk, curInstr, r);
154 183 : if( curInstr == NULL) {
155 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
156 0 : res = -1;
157 0 : goto cleanup;
158 : }
159 :
160 : /* ops */
161 183 : if (call && call->type == st_list) {
162 0 : list *ops = call->op4.lval;
163 :
164 0 : for (node *n = ops->h; n && !curBlk->errors; n = n->next) {
165 0 : stmt *op = n->data;
166 0 : sql_subtype *t = tail_type(op);
167 0 : int type = t->type->localtype;
168 0 : int varid = 0;
169 0 : const char *nme = (op->op3)?op->op3->op4.aval->data.val.sval:op->cname;
170 0 : char *buf;
171 :
172 0 : if (nme[0] != 'A') {
173 0 : buf = SA_NEW_ARRAY(m->sa, char, strlen(nme) + 2);
174 0 : if (buf)
175 0 : stpcpy(stpcpy(buf, "A"), nme);
176 : } else {
177 0 : buf = sa_strdup(m->sa, nme);
178 : }
179 0 : if (!buf) {
180 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
181 0 : res = -1;
182 0 : goto cleanup;
183 : }
184 0 : if ((varid = newVariable(curBlk, buf, strlen(buf), type)) < 0) {
185 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: variable id too long");
186 0 : res = -1;
187 0 : goto cleanup;
188 : }
189 0 : curInstr = pushArgument(curBlk, curInstr, varid);
190 0 : setVarType(curBlk, varid, type);
191 : }
192 183 : } else if (rel_ops) {
193 211 : for (node *n = rel_ops->h; n && !curBlk->errors; n = n->next) {
194 28 : sql_exp *e = n->data;
195 28 : sql_subtype *t = exp_subtype(e);
196 28 : int type = t->type->localtype;
197 28 : int varid = 0;
198 28 : char *buf;
199 :
200 28 : if (e->type == e_atom) {
201 0 : buf = SA_NEW_ARRAY(m->sa, char, IDLENGTH);
202 0 : if (buf)
203 0 : snprintf(buf, IDLENGTH, "A%u", e->flag);
204 : } else {
205 28 : const char *nme = exp_name(e);
206 28 : buf = SA_NEW_ARRAY(m->sa, char, strlen(nme) + 2);
207 28 : if (buf)
208 28 : stpcpy(stpcpy(buf, "A"), nme);
209 : }
210 28 : if (!buf) {
211 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
212 0 : res = -1;
213 0 : goto cleanup;
214 : }
215 28 : if ((varid = newVariable(curBlk, (char *)buf, strlen(buf), type)) < 0) {
216 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: variable id too long");
217 0 : res = -1;
218 0 : goto cleanup;
219 : }
220 28 : curInstr = pushArgument(curBlk, curInstr, varid);
221 28 : setVarType(curBlk, varid, type);
222 : }
223 : }
224 183 : if (curBlk->errors) {
225 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: %s", curBlk->errors);
226 0 : res = -1;
227 0 : goto cleanup;
228 : }
229 :
230 : /* add return statement */
231 183 : sql_exp *e;
232 183 : r = rel_psm_stmt(m->sa, e = exp_return(m->sa, exp_rel(m, r), 0));
233 183 : e->card = CARD_MULTI;
234 183 : if ((res = backend_dumpstmt(be, curBlk, r, 0, 1, NULL) < 0))
235 0 : goto cleanup;
236 : /* SQL function definitions meant for inlining should not be optimized before */
237 183 : if (inline_func)
238 0 : curBlk->inlineProp = 1;
239 : /* optimize the code */
240 183 : SQLaddQueryToCache(c);
241 183 : added_to_cache = 1;
242 183 : if (curBlk->inlineProp == 0 && !c->curprg->def->errors) {
243 183 : msg = SQLoptimizeQuery(c, c->curprg->def);
244 0 : } else if (curBlk->inlineProp != 0) {
245 0 : if( msg == MAL_SUCCEED)
246 0 : msg = chkProgram(c->usermodule, c->curprg->def);
247 0 : if (msg == MAL_SUCCEED && !c->curprg->def->errors)
248 0 : msg = SQLoptimizeFunction(c,c->curprg->def);
249 : }
250 183 : if (msg) {
251 0 : if (c->curprg->def->errors)
252 0 : freeException(msg);
253 : else
254 0 : c->curprg->def->errors = msg;
255 : }
256 183 : if (c->curprg->def->errors) {
257 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: %s", c->curprg->def->errors);
258 0 : res = -1;
259 : }
260 :
261 183 : cleanup:
262 0 : if (res < 0) {
263 0 : if (!added_to_cache)
264 0 : freeSymbol(c->curprg);
265 : else
266 0 : SQLremoveQueryFromCache(c);
267 : }
268 183 : return res;
269 : }
270 :
271 : static int
272 183 : _create_relational_function(mvc *m, const char *mod, const char *name, sql_rel *r, stmt *call, list *rel_ops, int inline_func)
273 : {
274 183 : Client c = MCgetClient(m->clientid);
275 181 : backend *be = (backend *) c->sqlcontext;
276 181 : Symbol symbackup = c->curprg;
277 181 : backend bebackup = *be; /* backup current backend */
278 181 : exception_buffer ebsave = m->sa->eb;
279 :
280 181 : if (strlen(mod) >= IDLENGTH) {
281 0 : (void) sql_error(m, 10, SQLSTATE(42000) "Module name '%s' too large for the backend", mod);
282 0 : goto bailout;
283 : }
284 181 : if (strlen(name) >= IDLENGTH) {
285 0 : (void) sql_error(m, 10, SQLSTATE(42000) "Function name '%s' too large for the backend", name);
286 0 : goto bailout;
287 : }
288 :
289 181 : backend_reset(be);
290 :
291 183 : int nargs;
292 183 : sql_rel *nr = relational_func_create_result_part1(m, r, &nargs);
293 183 : nargs += (call && call->type == st_list) ? list_length(call->op4.lval) : rel_ops ? list_length(rel_ops) : 0;
294 :
295 183 : c->curprg = newFunctionArgs(putName(mod), putName(name), FUNCTIONsymbol, nargs);
296 183 : if (c->curprg == NULL) {
297 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
298 0 : goto bailout;
299 183 : } else if (eb_savepoint(&m->sa->eb)) {
300 0 : sql_error(m, 10, "%s", m->sa->eb.msg);
301 0 : freeSymbol(c->curprg);
302 0 : goto bailout;
303 183 : } else if (_create_relational_function_body(m, nr, call, rel_ops, inline_func) < 0) {
304 0 : goto bailout;
305 : }
306 183 : *be = bebackup;
307 183 : c->curprg = symbackup;
308 183 : m->sa->eb = ebsave;
309 183 : return 0;
310 0 : bailout:
311 0 : *be = bebackup;
312 0 : c->curprg = symbackup;
313 0 : m->sa->eb = ebsave;
314 0 : if (m->sa->eb.enabled)
315 0 : eb_error(&m->sa->eb, m->errstr[0] ? m->errstr : be->mb->errors ? be->mb->errors : *GDKerrbuf ? GDKerrbuf : "out of memory", 1000);
316 : return -1;
317 : }
318 :
319 :
320 : /* stub and remote function */
321 : static int
322 188 : _create_relational_remote_body(mvc *m, const char *mod, const char *name, sql_rel *rel, sql_rel *rel2, stmt *call, prop *prp)
323 : {
324 188 : Client c = MCgetClient(m->clientid);
325 188 : MalBlkPtr curBlk = 0;
326 188 : InstrPtr curInstr = 0, p, o;
327 188 : tid_uri *tu = ((list*)prp->value.pval)->h->data;
328 188 : sqlid table_id = tu->id;
329 188 : assert(table_id);
330 188 : node *n;
331 188 : int i, q, v, res = -1, added_to_cache = 0, *lret, *rret;
332 188 : size_t len = 1024, nr, pwlen = 0;
333 188 : char *lname = NULL, *rel_str, *buf = NULL, *mal_session_uuid, *err = NULL, *pwhash = NULL;
334 188 : str username = NULL, password = NULL, msg = NULL;
335 188 : sql_rel *r = rel;
336 188 : bool temp = 0;
337 :
338 188 : lname = sa_strdup(m->ta, name);
339 188 : if (lname == NULL) {
340 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
341 0 : goto cleanup;
342 : }
343 :
344 188 : if (is_topn(r->op) || is_sample(r->op))
345 0 : r = r->l;
346 188 : if (!is_project(r->op))
347 0 : r = rel_project(m->sa, r, rel_projections(m, r, NULL, 1, 1));
348 188 : lret = SA_NEW_ARRAY(m->sa, int, list_length(r->exps));
349 188 : if (lret == NULL) {
350 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
351 0 : goto cleanup;
352 : }
353 188 : rret = SA_NEW_ARRAY(m->sa, int, list_length(r->exps));
354 188 : if (rret == NULL) {
355 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
356 0 : goto cleanup;
357 : }
358 :
359 188 : lname[0] = 'l';
360 188 : curBlk = c->curprg->def;
361 188 : curInstr = getInstrPtr(curBlk, 0);
362 :
363 188 : sql_table *rt = sql_trans_find_table(m->session->tr, table_id);
364 188 : if (!rt) {
365 2 : if (is_project(rel->op)) {
366 2 : sql_rel *b = rel->l;
367 2 : if (is_basetable(b->op)) {
368 2 : rt = b->l;
369 2 : temp = true;
370 : }
371 : }
372 : }
373 2 : if (!rt) {
374 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
375 0 : goto cleanup;
376 : }
377 188 : const char *uri = mapiuri_uri(rt->query, m->sa);
378 : // fprintf(stderr, "\n::\n\trt->query=%s\n\turi=%s\n\ttu->uri=%s\n", rt->query, uri, tu->uri);
379 188 : assert(strcmp(tu->uri, uri) == 0);
380 188 : if (!rt) {
381 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
382 : goto cleanup;
383 : }
384 188 : curInstr = relational_func_create_result_part2(curBlk, curInstr, rel2);
385 188 : if( curInstr == NULL) {
386 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
387 0 : goto cleanup;
388 : }
389 :
390 : /* ops */
391 188 : if (call && call->type == st_list) {
392 186 : char nbuf[IDLENGTH];
393 186 : int i = 0;
394 :
395 208 : for (node *n = call->op4.lval->h; n; n = n->next) {
396 22 : stmt *op = n->data;
397 22 : sql_subtype *t = tail_type(op);
398 22 : int type = t->type->localtype, varid = 0;
399 :
400 22 : sprintf(nbuf, "A%d", i++);
401 22 : if ((varid = newVariable(curBlk, nbuf, strlen(nbuf), type)) < 0) {
402 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: variable id too long");
403 0 : goto cleanup;
404 : }
405 22 : curInstr = pushArgument(curBlk, curInstr, varid);
406 22 : setVarType(curBlk, varid, type);
407 : }
408 : }
409 :
410 : /* declare return variables */
411 188 : if (!list_empty(r->exps)) {
412 1612 : for (i = 0, n = r->exps->h; n; n = n->next, i++) {
413 1424 : sql_exp *e = n->data;
414 1424 : int type = exp_subtype(e)->type->localtype;
415 :
416 1424 : type = newBatType(type);
417 1424 : p = newFcnCall(curBlk, batRef, newRef);
418 1424 : if (p == NULL) {
419 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
420 0 : goto cleanup;
421 : }
422 1424 : p = pushType(curBlk, p, getBatType(type));
423 1424 : setArgType(curBlk, p, 0, type);
424 1424 : lret[i] = getArg(p, 0);
425 1424 : pushInstruction(curBlk, p);
426 : }
427 : }
428 :
429 : /* get username / password */
430 188 : if (!temp) {
431 186 : msg = remote_get(m, table_id, &username, &password);
432 186 : if (msg) {
433 0 : sql_error(m, 10, "%s", msg);
434 0 : freeException(msg);
435 0 : msg = NULL;
436 0 : goto cleanup;
437 : }
438 : } else {
439 2 : username = "monetdb";
440 2 : password = "monetdb";
441 : }
442 : /* q := remote.connect("uri", "username", "password", "msql"); */
443 188 : p = newStmt(curBlk, remoteRef, connectRef);
444 188 : if (p == NULL) {
445 0 : if (!temp) {
446 0 : GDKfree(username);
447 0 : GDKfree(password);
448 : }
449 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
450 0 : goto cleanup;
451 : }
452 188 : p = pushStr(curBlk, p, uri);
453 188 : p = pushStr(curBlk, p, username);
454 188 : if (!temp)
455 186 : GDKfree(username);
456 188 : pwlen = strlen(password);
457 188 : pwhash = (char*)GDKmalloc(pwlen + 2);
458 188 : if (pwhash == NULL) {
459 0 : if (!temp)
460 0 : GDKfree(password);
461 0 : goto cleanup;
462 : }
463 188 : if (!temp) {
464 186 : strconcat_len(pwhash, pwlen + 2, "\1", password, NULL);
465 186 : GDKfree(password);
466 : } else {
467 2 : strconcat_len(pwhash, pwlen + 2, "", password, NULL);
468 : }
469 188 : p = pushStr(curBlk, p, pwhash);
470 188 : GDKfree(pwhash);
471 188 : p = pushStr(curBlk, p, "msql");
472 188 : q = getArg(p, 0);
473 188 : pushInstruction(curBlk, p);
474 :
475 : /* remote.exec(q, "sql", "register", "mod", "name", "relational_plan", "signature"); */
476 188 : p = newInstructionArgs(curBlk, remoteRef, execRef, 10);
477 188 : if (p == NULL) {
478 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
479 0 : goto cleanup;
480 : }
481 188 : p = pushArgument(curBlk, p, q);
482 188 : p = pushStr(curBlk, p, sqlRef);
483 188 : p = pushStr(curBlk, p, registerRef);
484 :
485 188 : o = newFcnCall(curBlk, remoteRef, putRef);
486 188 : if (o == NULL) {
487 0 : freeInstruction(p);
488 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
489 0 : goto cleanup;
490 : }
491 188 : o = pushArgument(curBlk, o, q);
492 188 : o = pushInt(curBlk, o, TYPE_str); /* dummy result type */
493 188 : pushInstruction(curBlk, o);
494 188 : p = pushReturn(curBlk, p, getArg(o, 0));
495 :
496 188 : o = newFcnCall(curBlk, remoteRef, putRef);
497 188 : if (o == NULL) {
498 0 : freeInstruction(p);
499 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
500 0 : goto cleanup;
501 : }
502 188 : o = pushArgument(curBlk, o, q);
503 188 : o = pushStr(curBlk, o, mod);
504 188 : pushInstruction(curBlk, o);
505 188 : p = pushArgument(curBlk, p, getArg(o,0));
506 :
507 188 : o = newFcnCall(curBlk, remoteRef, putRef);
508 188 : if (o == NULL) {
509 0 : freeInstruction(p);
510 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
511 0 : goto cleanup;
512 : }
513 188 : o = pushArgument(curBlk, o, q);
514 188 : o = pushStr(curBlk, o, lname);
515 188 : pushInstruction(curBlk, o);
516 188 : p = pushArgument(curBlk, p, getArg(o,0));
517 :
518 188 : if (!(rel_str = rel2str(m, rel))) {
519 0 : freeInstruction(p);
520 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
521 0 : goto cleanup;
522 : }
523 188 : o = newFcnCall(curBlk, remoteRef, putRef);
524 188 : if (o == NULL) {
525 0 : freeInstruction(p);
526 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
527 0 : goto cleanup;
528 : }
529 188 : o = pushArgument(curBlk, o, q);
530 188 : o = pushStr(curBlk, o, rel_str); /* relational plan */
531 188 : pushInstruction(curBlk, o);
532 188 : p = pushArgument(curBlk, p, getArg(o,0));
533 :
534 188 : if (!(buf = sa_alloc(m->ta, len))) {
535 0 : freeInstruction(p);
536 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
537 0 : goto cleanup;
538 : }
539 :
540 188 : buf[0] = 0;
541 188 : if (call && call->type == st_list) { /* Send existing variables in the plan */
542 186 : char dbuf[32], sbuf[32];
543 :
544 186 : nr = 0;
545 208 : for (node *n = call->op4.lval->h; n; n = n->next) {
546 22 : stmt *op = n->data;
547 22 : sql_subtype *t = tail_type(op);
548 22 : const char *nme = (op->op3)?op->op3->op4.aval->data.val.sval:op->cname;
549 :
550 22 : sprintf(dbuf, "%u", t->digits);
551 22 : sprintf(sbuf, "%u", t->scale);
552 22 : size_t nlen = strlen(nme) + strlen(t->type->base.name) + strlen(dbuf) + strlen(sbuf) + 6;
553 :
554 22 : if ((nr + nlen) > len) {
555 0 : buf = sa_realloc(m->ta, buf, (len + nlen) * 2, len);
556 0 : if (buf == NULL) {
557 0 : freeInstruction(p);
558 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
559 0 : goto cleanup;
560 : }
561 : len = (len + nlen) * 2;
562 : }
563 :
564 32 : nr += snprintf(buf+nr, len-nr, "%s %s(%s,%s)%c", nme, t->type->base.name, dbuf, sbuf, n->next?',':' ');
565 : }
566 : }
567 188 : o = newFcnCall(curBlk, remoteRef, putRef);
568 188 : if (o == NULL) {
569 0 : freeInstruction(p);
570 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
571 0 : goto cleanup;
572 : }
573 188 : o = pushArgument(curBlk, o, q);
574 188 : o = pushStr(curBlk, o, buf); /* signature */
575 188 : pushInstruction(curBlk, o);
576 188 : p = pushArgument(curBlk, p, getArg(o,0));
577 :
578 188 : buf[0] = 0;
579 188 : if (!list_empty(r->exps)) {
580 188 : nr = 0;
581 1612 : for (n = r->exps->h; n; n = n->next) { /* Send SQL types of the projection's expressions */
582 1424 : sql_exp *e = n->data;
583 1424 : sql_subtype *t = exp_subtype(e);
584 1424 : str next = sql_subtype_string(m->ta, t);
585 :
586 1424 : if (!next) {
587 0 : freeInstruction(p);
588 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
589 0 : goto cleanup;
590 : }
591 :
592 1424 : size_t nlen = strlen(next) + 2;
593 1424 : if ((nr + nlen) > len) {
594 2 : buf = sa_realloc(m->ta, buf, (len + nlen) * 2, len);
595 2 : if (buf == NULL) {
596 0 : freeInstruction(p);
597 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
598 0 : goto cleanup;
599 : }
600 : len = (len + nlen) * 2;
601 : }
602 :
603 1612 : nr += snprintf(buf+nr, len-nr, "%s%s", next, n->next?"%":"");
604 : }
605 : }
606 188 : o = newFcnCall(curBlk, remoteRef, putRef);
607 188 : if (o == NULL) {
608 0 : freeInstruction(p);
609 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
610 0 : goto cleanup;
611 : }
612 188 : o = pushArgument(curBlk, o, q);
613 188 : o = pushStr(curBlk, o, buf); /* SQL types as a single string */
614 188 : pushInstruction(curBlk, o);
615 188 : p = pushArgument(curBlk, p, getArg(o,0));
616 188 : pushInstruction(curBlk, p);
617 :
618 376 : if (!GDKinmemory(0) && !GDKembedded() && (err = msab_getUUID(&mal_session_uuid)) == NULL) {
619 188 : str lsupervisor_session = GDKstrdup(mal_session_uuid);
620 188 : str rsupervisor_session = GDKstrdup(mal_session_uuid);
621 188 : free(mal_session_uuid);
622 188 : if (lsupervisor_session == NULL || rsupervisor_session == NULL) {
623 0 : GDKfree(lsupervisor_session);
624 0 : GDKfree(rsupervisor_session);
625 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
626 0 : goto cleanup;
627 : }
628 :
629 188 : str rworker_plan_uuid = generateUUID();
630 188 : str lworker_plan_uuid = GDKstrdup(rworker_plan_uuid);
631 :
632 : /* remote.supervisor_register(connection, supervisor_uuid, plan_uuid) */
633 188 : p = newInstruction(curBlk, remoteRef, execRef);
634 188 : if (rworker_plan_uuid == NULL || lworker_plan_uuid == NULL || p == NULL) {
635 0 : free(rworker_plan_uuid);
636 0 : GDKfree(lworker_plan_uuid);
637 0 : freeInstruction(p);
638 0 : GDKfree(lsupervisor_session);
639 0 : GDKfree(rsupervisor_session);
640 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
641 0 : goto cleanup;
642 : }
643 188 : p = pushArgument(curBlk, p, q);
644 188 : p = pushStr(curBlk, p, remoteRef);
645 188 : p = pushStr(curBlk, p, register_supervisorRef);
646 188 : getArg(p, 0) = -1;
647 :
648 : /* We don't really care about the return value of supervisor_register,
649 : * but I have not found a good way to remotely execute a void mal function
650 : */
651 188 : o = newFcnCall(curBlk, remoteRef, putRef);
652 188 : if (o == NULL) {
653 0 : freeInstruction(p);
654 0 : free(rworker_plan_uuid);
655 0 : GDKfree(lworker_plan_uuid);
656 0 : GDKfree(lsupervisor_session);
657 0 : GDKfree(rsupervisor_session);
658 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
659 0 : goto cleanup;
660 : }
661 188 : o = pushArgument(curBlk, o, q);
662 188 : o = pushInt(curBlk, o, TYPE_int);
663 188 : pushInstruction(curBlk, o);
664 188 : p = pushReturn(curBlk, p, getArg(o, 0));
665 :
666 188 : o = newFcnCall(curBlk, remoteRef, putRef);
667 188 : if (o == NULL) {
668 0 : freeInstruction(p);
669 0 : free(rworker_plan_uuid);
670 0 : GDKfree(lworker_plan_uuid);
671 0 : GDKfree(lsupervisor_session);
672 0 : GDKfree(rsupervisor_session);
673 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
674 0 : goto cleanup;
675 : }
676 188 : o = pushArgument(curBlk, o, q);
677 188 : o = pushStr(curBlk, o, rsupervisor_session);
678 188 : pushInstruction(curBlk, o);
679 188 : p = pushArgument(curBlk, p, getArg(o, 0));
680 :
681 188 : o = newFcnCall(curBlk, remoteRef, putRef);
682 188 : if (o == NULL) {
683 0 : freeInstruction(p);
684 0 : free(rworker_plan_uuid);
685 0 : GDKfree(lworker_plan_uuid);
686 0 : GDKfree(lsupervisor_session);
687 0 : GDKfree(rsupervisor_session);
688 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
689 0 : goto cleanup;
690 : }
691 188 : o = pushArgument(curBlk, o, q);
692 188 : o = pushStr(curBlk, o, rworker_plan_uuid);
693 188 : pushInstruction(curBlk, o);
694 188 : p = pushArgument(curBlk, p, getArg(o, 0));
695 :
696 188 : pushInstruction(curBlk, p);
697 :
698 : /* Execute the same instruction locally */
699 188 : p = newStmt(curBlk, remoteRef, register_supervisorRef);
700 188 : if (p == NULL) {
701 0 : free(rworker_plan_uuid);
702 0 : GDKfree(lworker_plan_uuid);
703 0 : GDKfree(lsupervisor_session);
704 0 : GDKfree(rsupervisor_session);
705 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
706 0 : goto cleanup;
707 : }
708 188 : p = pushStr(curBlk, p, lsupervisor_session);
709 188 : p = pushStr(curBlk, p, lworker_plan_uuid);
710 188 : pushInstruction(curBlk, p);
711 :
712 188 : GDKfree(lworker_plan_uuid);
713 188 : free(rworker_plan_uuid); /* This was created with strdup */
714 188 : GDKfree(lsupervisor_session);
715 188 : GDKfree(rsupervisor_session);
716 0 : } else if (err)
717 0 : free(err);
718 :
719 : /* (x1, x2, ..., xn) := remote.exec(q, "mod", "fcn"); */
720 188 : p = newInstructionArgs(curBlk, remoteRef, execRef, list_length(r->exps) + curInstr->argc - curInstr->retc + 4);
721 188 : if (p == NULL) {
722 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
723 0 : goto cleanup;
724 : }
725 188 : p = pushArgument(curBlk, p, q);
726 188 : p = pushStr(curBlk, p, mod);
727 188 : p = pushStr(curBlk, p, lname);
728 188 : getArg(p, 0) = -1;
729 :
730 188 : if (!list_empty(r->exps)) {
731 1612 : for (i = 0, n = r->exps->h; n; n = n->next, i++) {
732 : /* x1 := remote.put(q, :type) */
733 1424 : o = newFcnCall(curBlk, remoteRef, putRef);
734 1424 : if (o == NULL) {
735 0 : freeInstruction(p);
736 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
737 0 : goto cleanup;
738 : }
739 1424 : o = pushArgument(curBlk, o, q);
740 1424 : o = pushArgument(curBlk, o, lret[i]);
741 1424 : pushInstruction(curBlk, o);
742 1424 : v = getArg(o, 0);
743 1424 : p = pushReturn(curBlk, p, v);
744 1424 : rret[i] = v;
745 : }
746 : }
747 :
748 : /* send arguments to remote */
749 210 : for (i = curInstr->retc; i < curInstr->argc; i++) {
750 : /* x1 := remote.put(q, A0); */
751 22 : o = newStmt(curBlk, remoteRef, putRef);
752 22 : if (o == NULL) {
753 0 : freeInstruction(p);
754 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
755 0 : goto cleanup;
756 : }
757 22 : o = pushArgument(curBlk, o, q);
758 22 : o = pushArgument(curBlk, o, getArg(curInstr, i));
759 22 : pushInstruction(curBlk, o);
760 22 : p = pushArgument(curBlk, p, getArg(o, 0));
761 : }
762 188 : pushInstruction(curBlk, p);
763 :
764 : /* return results */
765 1800 : for (i = 0; i < curInstr->retc; i++) {
766 : /* y1 := remote.get(q, x1); */
767 1424 : p = newFcnCall(curBlk, remoteRef, getRef);
768 1424 : if (p == NULL) {
769 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
770 0 : goto cleanup;
771 : }
772 1424 : p = pushArgument(curBlk, p, q);
773 1424 : p = pushArgument(curBlk, p, rret[i]);
774 1424 : pushInstruction(curBlk, p);
775 1424 : getArg(p, 0) = lret[i];
776 : }
777 :
778 : /* end remote transaction */
779 188 : p = newInstruction(curBlk, remoteRef, execRef);
780 188 : if (p == NULL) {
781 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
782 0 : goto cleanup;
783 : }
784 188 : p = pushArgument(curBlk, p, q);
785 188 : p = pushStr(curBlk, p, sqlRef);
786 188 : p = pushStr(curBlk, p, deregisterRef);
787 188 : getArg(p, 0) = -1;
788 :
789 188 : o = newFcnCall(curBlk, remoteRef, putRef);
790 188 : if (o == NULL) {
791 0 : freeInstruction(p);
792 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
793 0 : goto cleanup;
794 : }
795 188 : o = pushArgument(curBlk, o, q);
796 188 : o = pushInt(curBlk, o, TYPE_int);
797 188 : pushInstruction(curBlk, o);
798 188 : p = pushReturn(curBlk, p, getArg(o, 0));
799 188 : pushInstruction(curBlk, p);
800 :
801 : /* remote.disconnect(q); */
802 188 : p = newStmt(curBlk, remoteRef, disconnectRef);
803 188 : if (p == NULL) {
804 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
805 0 : goto cleanup;
806 : }
807 188 : p = pushArgument(curBlk, p, q);
808 188 : pushInstruction(curBlk, p);
809 :
810 188 : p = newInstructionArgs(curBlk, NULL, NULL, 2 * curInstr->retc);
811 188 : if (p == NULL) {
812 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
813 0 : goto cleanup;
814 : }
815 188 : p->barrier= RETURNsymbol;
816 188 : p->retc = p->argc = 0;
817 1612 : for (i = 0; i < curInstr->retc; i++)
818 1424 : p = pushArgument(curBlk, p, lret[i]);
819 188 : p->retc = p->argc;
820 : /* assignment of return */
821 1612 : for (i = 0; i < curInstr->retc; i++)
822 1424 : p = pushArgument(curBlk, p, lret[i]);
823 188 : pushInstruction(curBlk, p);
824 :
825 : /* catch exceptions */
826 188 : p = newCatchStmt(curBlk, "ANYexception");
827 188 : if (p == NULL) {
828 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
829 0 : goto cleanup;
830 : }
831 188 : pushInstruction(curBlk, p);
832 188 : p = newExitStmt(curBlk, "ANYexception");
833 188 : if (p == NULL) {
834 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
835 0 : goto cleanup;
836 : }
837 188 : pushInstruction(curBlk, p);
838 :
839 : /* end remote transaction */
840 188 : p = newInstruction(curBlk, remoteRef, execRef);
841 188 : if (p == NULL) {
842 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
843 0 : goto cleanup;
844 : }
845 188 : p = pushArgument(curBlk, p, q);
846 188 : p = pushStr(curBlk, p, sqlRef);
847 188 : p = pushStr(curBlk, p, deregisterRef);
848 188 : getArg(p, 0) = -1;
849 :
850 188 : o = newFcnCall(curBlk, remoteRef, putRef);
851 188 : if (o == NULL) {
852 0 : freeInstruction(p);
853 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
854 0 : goto cleanup;
855 : }
856 188 : o = pushArgument(curBlk, o, q);
857 188 : o = pushInt(curBlk, o, TYPE_int);
858 188 : pushInstruction(curBlk, o);
859 188 : p = pushReturn(curBlk, p, getArg(o, 0));
860 188 : pushInstruction(curBlk, p);
861 :
862 : /* remote.disconnect(q); */
863 188 : p = newStmt(curBlk, remoteRef, disconnectRef);
864 188 : if (p == NULL) {
865 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
866 0 : goto cleanup;
867 : }
868 188 : p = pushArgument(curBlk, p, q);
869 188 : pushInstruction(curBlk, p);
870 :
871 : /* the connection may not start (eg bad credentials),
872 : so calling 'disconnect' on the catch block may throw another exception, add another catch */
873 188 : p = newCatchStmt(curBlk, "ANYexception");
874 188 : if (p == NULL) {
875 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
876 0 : goto cleanup;
877 : }
878 188 : pushInstruction(curBlk, p);
879 188 : p = newExitStmt(curBlk, "ANYexception");
880 188 : if (p == NULL) {
881 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
882 0 : goto cleanup;
883 : }
884 188 : pushInstruction(curBlk, p);
885 :
886 : /* throw the exception back */
887 188 : p = newRaiseStmt(curBlk, "RemoteException");
888 188 : if (p == NULL) {
889 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
890 0 : goto cleanup;
891 : }
892 188 : p = pushStr(curBlk, p, "Exception occurred in the remote server, please check the log there");
893 188 : pushInstruction(curBlk, p);
894 :
895 188 : pushEndInstruction(curBlk);
896 :
897 : /* SQL function definitions meant for inlineing should not be optimized before */
898 : //for now no inline of the remote function, this gives garbage collection problems
899 : //curBlk->inlineProp = 1;
900 :
901 188 : SQLaddQueryToCache(c);
902 188 : added_to_cache = 1;
903 : // (str) chkProgram(c->usermodule, c->curprg->def);
904 188 : if (!c->curprg->def->errors)
905 188 : c->curprg->def->errors = SQLoptimizeFunction(c, c->curprg->def);
906 188 : if (c->curprg->def->errors) {
907 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: %s", c->curprg->def->errors);
908 : } else {
909 : res = 0;
910 : }
911 :
912 : cleanup:
913 0 : if (res < 0 && c->curprg) {
914 0 : if (!added_to_cache) /* on error, remove generated symbol from cache */
915 0 : freeSymbol(c->curprg);
916 : else
917 0 : SQLremoveQueryFromCache(c);
918 : }
919 188 : return res;
920 : }
921 :
922 : static int
923 188 : _create_relational_remote(mvc *m, const char *mod, const char *name, sql_rel *rel, stmt *call, prop *prp)
924 : {
925 188 : Client c = MCgetClient(m->clientid);
926 188 : backend *be = (backend *) c->sqlcontext;
927 188 : Symbol symbackup = c->curprg;
928 188 : exception_buffer ebsave = m->sa->eb;
929 :
930 188 : if (list_empty(prp->value.pval)) {
931 0 : sql_error(m, 003, SQLSTATE(42000) "Missing REMOTE property on the input relation");
932 0 : goto bailout;
933 : }
934 188 : if (list_length(prp->value.pval) != 1) {
935 0 : sql_error(m, 003, SQLSTATE(42000) "REMOTE property on the input relation is NOT unique");
936 0 : goto bailout;
937 : }
938 188 : if (strlen(mod) >= IDLENGTH) {
939 0 : (void) sql_error(m, 10, SQLSTATE(42000) "Module name '%s' too large for the backend", mod);
940 0 : goto bailout;
941 : }
942 188 : if (strlen(name) >= IDLENGTH) {
943 0 : (void) sql_error(m, 10, SQLSTATE(42000) "Function name '%s' too large for the backend", name);
944 0 : goto bailout;
945 : }
946 :
947 : /* create stub */
948 188 : int nargs;
949 188 : sql_rel *rel2 = relational_func_create_result_part1(m, rel, &nargs);
950 188 : if (call && call->type == st_list)
951 186 : nargs += list_length(call->op4.lval);
952 188 : c->curprg = newFunctionArgs(putName(mod), putName(name), FUNCTIONsymbol, nargs);
953 188 : if (c->curprg == NULL) {
954 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
955 0 : goto bailout;
956 188 : } else if (eb_savepoint(&m->sa->eb)) {
957 0 : sql_error(m, 10, "%s", m->sa->eb.msg);
958 0 : freeSymbol(c->curprg);
959 0 : goto bailout;
960 188 : } else if (_create_relational_remote_body(m, mod, name, rel, rel2, call, prp) < 0) {
961 0 : goto bailout;
962 : }
963 188 : sa_reset(m->ta);
964 188 : c->curprg = symbackup;
965 188 : m->sa->eb = ebsave;
966 188 : return 0;
967 0 : bailout:
968 0 : sa_reset(m->ta);
969 0 : c->curprg = symbackup;
970 0 : m->sa->eb = ebsave;
971 0 : if (m->sa->eb.enabled)
972 0 : eb_error(&m->sa->eb, m->errstr[0] ? m->errstr : be->mb->errors ? be->mb->errors : *GDKerrbuf ? GDKerrbuf : "out of memory", 1000);
973 : return -1;
974 : }
975 :
976 : int
977 371 : monet5_create_relational_function(mvc *m, const char *mod, const char *name, sql_rel *rel, stmt *call, list *rel_ops, int inline_func)
978 : {
979 371 : prop *p = NULL;
980 :
981 371 : if (rel && (p = find_prop(rel->p, PROP_REMOTE)) != NULL)
982 188 : return _create_relational_remote(m, mod, name, rel, call, p);
983 : else
984 182 : return _create_relational_function(m, mod, name, rel, call, rel_ops, inline_func);
985 : }
986 :
987 : /*
988 : * The kernel uses two calls to procedures defined in SQL.
989 : * They have to be initialized, which is currently hacked
990 : * by using the SQLstatment.
991 : */
992 : static stmt *
993 613295 : sql_relation2stmt(backend *be, sql_rel *r, int top)
994 : {
995 613295 : mvc *c = be->mvc;
996 613295 : stmt *s = NULL;
997 :
998 613295 : if (!r) {
999 0 : sql_error(c, 003, SQLSTATE(42000) "Missing relation to convert into statements");
1000 0 : return NULL;
1001 : } else {
1002 613295 : if (c->emode == m_plan) {
1003 337 : rel_print(c, r, 0);
1004 : } else {
1005 612958 : s = output_rel_bin(be, r, top);
1006 : }
1007 : }
1008 : return s;
1009 : }
1010 :
1011 : static int
1012 : #if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 8
1013 : /* bug on CentOS 7 (gnuc 4.8.5) where this function gets inlined and
1014 : * the compiler then complains about query getting modified after the
1015 : * setjmp call; fix is to explicitly prevent inlining */
1016 : __attribute__((__noinline__))
1017 : #endif
1018 613296 : backend_dumpstmt_body(backend *be, MalBlkPtr mb, sql_rel *r, int top, int add_end, const char *query)
1019 : {
1020 613296 : mvc *m = be->mvc;
1021 613296 : InstrPtr q, querylog = NULL;
1022 613296 : int old_mv = be->mvc_var;
1023 613296 : MalBlkPtr old_mb = be->mb;
1024 :
1025 : /* Always keep the SQL query around for monitoring */
1026 613296 : if (query) {
1027 289209 : while (*query && isspace((unsigned char) *query))
1028 0 : query++;
1029 :
1030 289209 : querylog = q = newStmt(mb, querylogRef, defineRef);
1031 289209 : if (q == NULL) {
1032 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1033 0 : return -1;
1034 : }
1035 289209 : setVarType(mb, getArg(q, 0), TYPE_void);
1036 289209 : q = pushStr(mb, q, query);
1037 289207 : q = pushStr(mb, q, getSQLoptimizer(be->mvc));
1038 289207 : pushInstruction(mb, q);
1039 : }
1040 :
1041 : /* announce the transaction mode */
1042 613295 : q = newStmt(mb, sqlRef, mvcRef);
1043 613296 : if (q == NULL) {
1044 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1045 0 : return -1;
1046 : }
1047 613296 : pushInstruction(mb, q);
1048 613295 : be->mvc_var = getDestVar(q);
1049 613295 : be->mb = mb;
1050 613295 : if (!sql_relation2stmt(be, r, top)) {
1051 345 : if (querylog)
1052 345 : (void) pushInt(mb, querylog, mb->stop);
1053 345 : return (be->mvc->errstr[0] == '\0') ? 0 : -1;
1054 : }
1055 :
1056 612948 : be->mvc_var = old_mv;
1057 612948 : be->mb = old_mb;
1058 612948 : if (top && !be->depth && (m->type == Q_SCHEMA || m->type == Q_TRANS) && !GDKembedded()) {
1059 19922 : q = newStmt(mb, sqlRef, exportOperationRef);
1060 19922 : if (q == NULL) {
1061 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1062 0 : return -1;
1063 : }
1064 19922 : pushInstruction(mb, q);
1065 : }
1066 612948 : if (add_end)
1067 324086 : pushEndInstruction(mb);
1068 612948 : if (querylog)
1069 288862 : (void) pushInt(mb, querylog, mb->stop);
1070 : return 0;
1071 : }
1072 :
1073 : int
1074 613296 : backend_dumpstmt(backend *be, MalBlkPtr mb, sql_rel *r, int top, int add_end, const char *query)
1075 : {
1076 613296 : mvc *m = be->mvc;
1077 613296 : exception_buffer ebsave = {.enabled = 0};
1078 :
1079 613296 : if (m->sa) {
1080 613296 : ebsave = m->sa->eb;
1081 613299 : if (eb_savepoint(&m->sa->eb)) {
1082 3 : (void) sql_error(m, 10, "%s", m->sa->eb.msg);
1083 3 : goto bailout;
1084 : }
1085 : }
1086 613296 : if (backend_dumpstmt_body(be, mb, r, top, add_end, query) < 0)
1087 5 : goto bailout;
1088 613282 : if (m->sa)
1089 613282 : m->sa->eb = ebsave;
1090 : return 0;
1091 8 : bailout:
1092 8 : if (m->sa)
1093 8 : m->sa->eb = ebsave;
1094 : return -1;
1095 : }
1096 :
1097 : /* SQL procedures, functions and PREPARE statements are compiled into a parameterised plan */
1098 : static int
1099 334 : backend_dumpproc_body(backend *be, Client c, sql_rel *r)
1100 : {
1101 334 : mvc *m = be->mvc;
1102 334 : MalBlkPtr mb = 0;
1103 334 : InstrPtr curInstr = 0;
1104 334 : char arg[IDLENGTH];
1105 334 : int res = -1, added_to_cache = 0;
1106 :
1107 334 : backend_reset(be);
1108 :
1109 334 : mb = c->curprg->def;
1110 334 : curInstr = getInstrPtr(mb, 0);
1111 : /* we do not return anything */
1112 334 : setVarType(mb, 0, TYPE_void);
1113 :
1114 334 : if (m->params) { /* needed for prepare statements */
1115 243 : int argc = 0;
1116 1796 : for (node *n = m->params->h; n; n = n->next, argc++) {
1117 1554 : sql_arg *a = n->data;
1118 1554 : sql_type *tpe = a->type.type;
1119 1554 : int type, varid = 0;
1120 :
1121 1554 : if (!tpe || tpe->eclass == EC_ANY) {
1122 1 : sql_error(m, 10, SQLSTATE(42000) "Could not determine type for argument number %d", argc+1);
1123 1 : goto cleanup;
1124 : }
1125 1553 : type = tpe->localtype;
1126 1553 : snprintf(arg, IDLENGTH, "A%d", argc);
1127 1553 : if ((varid = newVariable(mb, arg,strlen(arg), type)) < 0) {
1128 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: variable id too long");
1129 0 : goto cleanup;
1130 : }
1131 1553 : curInstr = pushArgument(mb, curInstr, varid);
1132 1553 : if (c->curprg == NULL) {
1133 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1134 0 : goto cleanup;
1135 : }
1136 1553 : if (mb->errors) {
1137 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: %s", mb->errors);
1138 0 : goto cleanup;
1139 : }
1140 1553 : setVarType(mb, varid, type);
1141 : }
1142 : }
1143 :
1144 333 : if ((res = backend_dumpstmt(be, mb, r, m->emode == m_prepare, 1, be->q ? be->q->f->query : NULL)) < 0)
1145 0 : goto cleanup;
1146 :
1147 333 : SQLaddQueryToCache(c);
1148 333 : added_to_cache = 1;
1149 : // optimize this code the 'old' way
1150 333 : if (m->emode == m_prepare && !c->curprg->def->errors)
1151 333 : c->curprg->def->errors = SQLoptimizeFunction(c,c->curprg->def);
1152 333 : if (c->curprg->def->errors) {
1153 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: %s", c->curprg->def->errors);
1154 : } else {
1155 : res = 0; /* success */
1156 : }
1157 :
1158 0 : cleanup:
1159 2 : if (res < 0 && c->curprg) {
1160 1 : if (!added_to_cache)
1161 1 : freeSymbol(c->curprg);
1162 : else
1163 : SQLremoveQueryFromCache(c);
1164 : }
1165 334 : return res;
1166 : }
1167 :
1168 : int
1169 334 : backend_dumpproc(backend *be, Client c, cq *cq, sql_rel *r)
1170 : {
1171 334 : mvc *m = be->mvc;
1172 334 : Symbol symbackup = c->curprg;
1173 334 : backend bebackup = *be; /* backup current backend */
1174 334 : exception_buffer ebsave = m->sa->eb;
1175 334 : int argc = 1;
1176 334 : const char *sql_private_module = putName(sql_private_module_name);
1177 :
1178 334 : if (m->params)
1179 243 : argc += list_length(m->params);
1180 243 : if (argc < MAXARG)
1181 : argc = MAXARG;
1182 334 : assert(cq && strlen(cq->name) < IDLENGTH);
1183 334 : c->curprg = newFunctionArgs(sql_private_module, cq->name = putName(cq->name), FUNCTIONsymbol, argc);
1184 334 : if (c->curprg == NULL) {
1185 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1186 0 : goto bailout;
1187 334 : } else if (eb_savepoint(&m->sa->eb)) {
1188 0 : sql_error(m, 10, "%s", m->sa->eb.msg);
1189 0 : freeSymbol(c->curprg);
1190 0 : goto bailout;
1191 334 : } else if (backend_dumpproc_body(be, c, r) < 0) {
1192 1 : goto bailout;
1193 : }
1194 333 : *be = bebackup;
1195 333 : c->curprg = symbackup;
1196 333 : m->sa->eb = ebsave;
1197 333 : return 0;
1198 1 : bailout:
1199 1 : *be = bebackup;
1200 1 : c->curprg = symbackup;
1201 1 : m->sa->eb = ebsave;
1202 1 : return -1;
1203 : }
1204 :
1205 : int
1206 590 : monet5_has_module(ptr M, char *module)
1207 : {
1208 590 : Client c;
1209 590 : int clientID = *(int*) M;
1210 590 : c = MCgetClient(clientID);
1211 :
1212 590 : Module m = findModule(c->usermodule, putName(module));
1213 590 : if (m && m != c->usermodule)
1214 578 : return 1;
1215 : return 0;
1216 : }
1217 :
1218 : static MT_Lock sql_gencodeLock = MT_LOCK_INITIALIZER(sql_gencodeLock);
1219 :
1220 : static str
1221 675 : monet5_cache_remove(Module m, const char *nme)
1222 : {
1223 : /* Warning, this function doesn't do any locks, so be careful with concurrent symbol insert/deletes */
1224 675 : Symbol s = findSymbolInModule(m, nme);
1225 675 : if (s == NULL)
1226 162 : throw(MAL, "cache.remove", SQLSTATE(42000) "internal error, symbol missing\n");
1227 513 : deleteSymbol(m, s);
1228 513 : return MAL_SUCCEED;
1229 : }
1230 :
1231 : /* if 'mod' not NULL, use it otherwise get the module from the client id */
1232 : void
1233 800 : monet5_freecode(const char *mod, int clientid, const char *name)
1234 : {
1235 800 : Module m = NULL;
1236 800 : str msg = MAL_SUCCEED;
1237 :
1238 800 : if (mod) {
1239 305 : m = getModule(putName(mod));
1240 : } else {
1241 495 : Client c = MCgetClient(clientid);
1242 495 : if (c)
1243 495 : m = c->usermodule;
1244 : }
1245 800 : if (m) {
1246 675 : if (mod)
1247 180 : MT_lock_set(&sql_gencodeLock);
1248 675 : msg = monet5_cache_remove(m, name);
1249 675 : if (mod)
1250 180 : MT_lock_unset(&sql_gencodeLock);
1251 675 : freeException(msg); /* do something with error? */
1252 : }
1253 800 : }
1254 :
1255 : /* the function 'f' may not have the 'imp' field set yet */
1256 : int
1257 447238 : monet5_resolve_function(ptr M, sql_func *f, const char *fimp, bool *side_effect)
1258 : {
1259 447238 : Client c;
1260 447238 : Module m;
1261 447238 : int clientID = *(int*) M;
1262 447238 : const char *mname = putName(sql_func_mod(f)), *fname = putName(fimp);
1263 :
1264 447238 : if (!mname || !fname)
1265 : return 0;
1266 :
1267 : /* Some SQL functions MAL mapping such as count(*) aggregate, the number of arguments don't match */
1268 447238 : if (mname == calcRef && fname == getName("=")) {
1269 356 : *side_effect = 0;
1270 356 : return 1;
1271 : }
1272 446882 : if (mname == aggrRef && (fname == countRef || fname == count_no_nilRef)) {
1273 712 : *side_effect = 0;
1274 712 : return 1;
1275 : }
1276 446170 : if (f->type == F_ANALYTIC) {
1277 50896 : *side_effect = 0;
1278 50896 : return 1;
1279 : }
1280 395274 : if (strcmp(fname, "timestamp_to_str") == 0 ||
1281 395045 : strcmp(fname, "time_to_str") == 0 ||
1282 394808 : strcmp(fname, "str_to_timestamp") == 0 ||
1283 394578 : strcmp(fname, "str_to_time") == 0 ||
1284 394348 : strcmp(fname, "str_to_date") == 0) {
1285 1155 : *side_effect = 0;
1286 1155 : return 1;
1287 : }
1288 :
1289 394119 : c = MCgetClient(clientID);
1290 394119 : MT_lock_set(&sql_gencodeLock);
1291 394123 : for (m = findModule(c->usermodule, mname); m; m = m->link) {
1292 3930768 : for (Symbol s = findSymbolInModule(m, fname); s; s = s->peer) {
1293 3930764 : int argc = 0, retc = 0, varargs = 0, unsafe = 0;
1294 3930764 : if (s->kind == FUNCTIONsymbol) {
1295 0 : InstrPtr sig = getSignature(s);
1296 0 : retc = sig->retc;
1297 0 : argc = sig->argc - sig->retc;
1298 0 : varargs = (sig->varargs & VARARGS) == VARARGS;
1299 0 : unsafe = s->def->unsafeProp;
1300 : } else {
1301 3930764 : retc = s->func->retc;
1302 3930764 : argc = s->func->argc - s->func->retc;
1303 3930764 : varargs = s->func->vargs;
1304 3930764 : unsafe = s->func->unsafe;
1305 : }
1306 3930764 : int nfargs = list_length(f->ops), nfres = list_length(f->res);
1307 :
1308 3930764 : if (varargs || f->vararg || f->varres) {
1309 1425 : *side_effect = (bool) unsafe;
1310 1425 : MT_lock_unset(&sql_gencodeLock);
1311 1425 : return 1;
1312 3929339 : } else if (nfargs == argc && (nfres == retc || (retc == 1 && (IS_FILT(f) || IS_PROC(f))))) {
1313 : /* I removed this code because, it was triggering many errors on the SQL <-> MAL translation */
1314 : /* Check for types of inputs and outputs. SQL procedures and filter functions always return 1 value in the MAL implementation
1315 : bool all_match = true;
1316 : if (nfres != 0) { if function has output variables, test types are equivalent
1317 : int i = 0;
1318 : for (node *n = f->res->h; n && all_match; n = n->next, i++) {
1319 : sql_arg *arg = (sql_arg *) n->data;
1320 : int nsql_tpe = arg->type.type->localtype;
1321 : int nmal_tpe = getArgType(s->def, sig, i);
1322 : if (isaBatType(nmal_tpe) || (nmal_tpe & 0377) == TYPE_any) any type is excluded from isaBatType
1323 : nmal_tpe = getBatType(nmal_tpe);
1324 :
1325 : any/void types always match
1326 : if (nsql_tpe != TYPE_any && nmal_tpe != TYPE_any && nsql_tpe != TYPE_void && nmal_tpe != TYPE_void)
1327 : all_match = nsql_tpe == nmal_tpe;
1328 : }
1329 : }
1330 :
1331 : if (all_match && nfargs != 0) { if function has arguments, test types are equivalent
1332 : int i = sig->retc;
1333 : for (node *n = f->ops->h; n && all_match; n = n->next, i++) {
1334 : sql_arg *arg = (sql_arg *) n->data;
1335 : int nsql_tpe = arg->type.type->localtype;
1336 : int nmal_tpe = getArgType(s->def, sig, i);
1337 : if (isaBatType(nmal_tpe) || (nmal_tpe & 0377) == TYPE_any) any type is excluded from isaBatType
1338 : nmal_tpe = getBatType(nmal_tpe);
1339 :
1340 : any/void types always match
1341 : if (nsql_tpe != TYPE_any && nmal_tpe != TYPE_any && nsql_tpe != TYPE_void && nmal_tpe != TYPE_void)
1342 : all_match = nsql_tpe == nmal_tpe;
1343 : }
1344 : }
1345 : if (all_match)*/
1346 392690 : *side_effect = (bool) unsafe;
1347 392690 : MT_lock_unset(&sql_gencodeLock);
1348 392690 : return 1;
1349 : }
1350 : }
1351 : }
1352 4 : MT_lock_unset(&sql_gencodeLock);
1353 4 : return 0;
1354 : }
1355 :
1356 : /* Parse the SQL query from the function, and extract the MAL function from the generated abstract syntax tree */
1357 : static str
1358 346 : mal_function_find_implementation_address(mvc *m, sql_func *f)
1359 : {
1360 346 : buffer *b = NULL;
1361 346 : bstream *bs = NULL;
1362 346 : stream *buf = NULL;
1363 346 : char *n = NULL;
1364 346 : int len = _strlen(f->query);
1365 346 : dlist *l, *ext_name;
1366 346 : str fimp = NULL;
1367 :
1368 346 : if (!(b = (buffer*)malloc(sizeof(buffer))))
1369 0 : return sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1370 346 : if (!(n = malloc(len + 2))) {
1371 0 : free(b);
1372 0 : return sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1373 : }
1374 346 : snprintf(n, len + 2, "%s\n", f->query);
1375 346 : len++;
1376 346 : buffer_init(b, n, len);
1377 346 : if (!(buf = buffer_rastream(b, "sqlstatement"))) {
1378 0 : buffer_destroy(b);
1379 0 : return sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1380 : }
1381 346 : if (!(bs = bstream_create(buf, b->len))) {
1382 0 : buffer_destroy(b);
1383 0 : return sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1384 : }
1385 346 : mvc o = *m;
1386 346 : scanner_init(&m->scanner, bs, NULL);
1387 346 : m->scanner.mode = LINE_1;
1388 346 : bstream_next(m->scanner.rs);
1389 :
1390 346 : m->type = Q_PARSE;
1391 346 : m->user_id = m->role_id = USER_MONETDB;
1392 346 : m->params = NULL;
1393 346 : m->sym = NULL;
1394 346 : m->errstr[0] = '\0';
1395 346 : m->session->status = 0;
1396 346 : (void) sqlparse(m);
1397 346 : if (m->session->status || m->errstr[0] || !m->sym || m->sym->token != SQL_CREATE_FUNC) {
1398 0 : if (m->errstr[0] == '\0')
1399 0 : (void) sql_error(m, 10, SQLSTATE(42000) "Could not parse CREATE SQL MAL function statement");
1400 : } else {
1401 346 : l = m->sym->data.lval;
1402 346 : ext_name = l->h->next->next->next->data.lval;
1403 346 : const char *imp = qname_schema_object(ext_name);
1404 :
1405 346 : if (strlen(imp) >= IDLENGTH)
1406 0 : (void) sql_error(m, 10, SQLSTATE(42000) "MAL function name '%s' too large for the backend", imp);
1407 346 : else if (!(fimp = _STRDUP(imp))) /* found the implementation, set it */
1408 0 : (void) sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1409 : }
1410 :
1411 346 : buffer_destroy(b);
1412 346 : bstream_destroy(m->scanner.rs);
1413 :
1414 346 : m->sym = NULL;
1415 346 : o.frames = m->frames; /* may have been realloc'ed */
1416 346 : o.sizeframes = m->sizeframes;
1417 346 : if (m->session->status || m->errstr[0]) {
1418 0 : int status = m->session->status;
1419 :
1420 0 : strcpy(o.errstr, m->errstr);
1421 0 : *m = o;
1422 0 : m->session->status = status;
1423 : } else {
1424 346 : unsigned int label = m->label;
1425 :
1426 346 : while (m->topframes > o.topframes)
1427 0 : clear_frame(m, m->frames[--m->topframes]);
1428 346 : *m = o;
1429 346 : m->label = label;
1430 : }
1431 : return fimp;
1432 : }
1433 :
1434 : int
1435 80887 : backend_create_mal_func(mvc *m, sql_subfunc *sf)
1436 : {
1437 80887 : char *F = NULL, *fn = NULL;
1438 80887 : sql_func *f = sf->func;
1439 80887 : bool old_side_effect = f->side_effect, new_side_effect = 0;
1440 80887 : int clientid = m->clientid;
1441 80887 : str fimp = NULL;
1442 :
1443 80887 : if (f->instantiated)
1444 : return 0;
1445 346 : FUNC_TYPE_STR(f->type, F, fn)
1446 346 : (void) F;
1447 346 : if (strlen(f->mod) >= IDLENGTH) {
1448 0 : (void) sql_error(m, 10, SQLSTATE(42000) "MAL module name '%s' too large for the backend", f->mod);
1449 0 : return -1;
1450 : }
1451 346 : if (!(fimp = mal_function_find_implementation_address(m, f)))
1452 : return -1;
1453 346 : if (!backend_resolve_function(&clientid, f, fimp, &new_side_effect)) {
1454 0 : (void) sql_error(m, 10, SQLSTATE(3F000) "MAL external name %s.%s not bound (%s.%s)", f->mod, fimp, f->s->base.name, f->base.name);
1455 0 : return -1;
1456 : }
1457 346 : if (old_side_effect != new_side_effect) {
1458 0 : (void) sql_error(m, 10, SQLSTATE(42000) "Side-effect value from the SQL %s %s.%s doesn't match the MAL definition %s.%s\n"
1459 0 : "Either re-create the %s, or fix the MAL definition and restart the database", fn, f->s->base.name, f->base.name, f->mod, fimp, fn);
1460 0 : return -1;
1461 : }
1462 346 : MT_lock_set(&sql_gencodeLock);
1463 346 : if (!f->instantiated) {
1464 346 : f->imp = fimp;
1465 346 : f->instantiated = TRUE; /* make sure 'instantiated' gets set after 'imp' */
1466 : } else {
1467 0 : _DELETE(fimp);
1468 : }
1469 346 : MT_lock_unset(&sql_gencodeLock);
1470 346 : return 0;
1471 : }
1472 :
1473 : static int
1474 307 : backend_create_sql_func_body(backend *be, sql_func *f, list *restypes, list *ops, Module mod, char *fimp, bool prepare)
1475 : {
1476 307 : mvc *m = be->mvc;
1477 307 : Client c = be->client;
1478 307 : MalBlkPtr curBlk = c->curprg->def;
1479 307 : InstrPtr curInstr = getInstrPtr(curBlk, 0);
1480 307 : int res = -1, i, retseen = 0, sideeffects = 0, no_inline = 0, added_to_cache = 0;
1481 307 : str msg = MAL_SUCCEED;
1482 307 : sql_func *pf = NULL;
1483 307 : sql_rel *r;
1484 :
1485 613 : r = rel_parse(m, f->s, f->query, prepare?m_prepare:m_instantiate);
1486 307 : if (r) {
1487 306 : r = sql_processrelation(m, r, 0, 1, 1, 0);
1488 306 : r = rel_physical(m, r);
1489 : }
1490 306 : if (!r) {
1491 1 : goto cleanup;
1492 : }
1493 :
1494 306 : backend_reset(be);
1495 :
1496 306 : if (f->res && !prepare) {
1497 276 : sql_arg *fres = f->res->h->data;
1498 276 : if (f->type == F_UNION) {
1499 23 : curInstr = table_func_create_result(curBlk, curInstr, f, restypes);
1500 23 : if( curInstr == NULL) {
1501 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1502 0 : goto cleanup;
1503 : }
1504 : } else {
1505 253 : setArgType(curBlk, curInstr, 0, fres->type.type->localtype);
1506 : }
1507 : } else {
1508 30 : setArgType(curBlk, curInstr, 0, TYPE_void);
1509 : }
1510 :
1511 306 : if (f->vararg && ops) {
1512 0 : int argc = 0;
1513 :
1514 0 : for (node *n = ops->h; n; n = n->next, argc++) {
1515 0 : stmt *s = n->data;
1516 0 : int type = tail_type(s)->type->localtype;
1517 0 : int varid = 0;
1518 0 : char buf[IDLENGTH];
1519 :
1520 0 : (void) snprintf(buf, IDLENGTH, "A%d", argc);
1521 0 : if ((varid = newVariable(curBlk, buf, strlen(buf), type)) < 0) {
1522 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: variable id too long");
1523 0 : goto cleanup;
1524 : }
1525 0 : curInstr = pushArgument(curBlk, curInstr, varid);
1526 0 : setVarType(curBlk, varid, type);
1527 : }
1528 306 : } else if (f->ops) {
1529 306 : int argc = 0;
1530 :
1531 788 : for (node *n = f->ops->h; n; n = n->next, argc++) {
1532 482 : sql_arg *a = n->data;
1533 482 : int type = a->type.type->localtype;
1534 482 : int varid = 0;
1535 482 : char *buf;
1536 :
1537 482 : if (a->name) {
1538 482 : buf = SA_NEW_ARRAY(m->sa, char, strlen(a->name) + 4);
1539 482 : if (buf)
1540 482 : stpcpy(stpcpy(buf, "A1%"), a->name); /* mangle variable name */
1541 : } else {
1542 0 : buf = SA_NEW_ARRAY(m->sa, char, IDLENGTH);
1543 0 : if (buf)
1544 0 : (void) snprintf(buf, IDLENGTH, "A%d", argc);
1545 : }
1546 482 : if (!buf) {
1547 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1548 0 : goto cleanup;
1549 : }
1550 482 : if ((varid = newVariable(curBlk, buf, strlen(buf), type)) < 0) {
1551 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: variable id too long");
1552 0 : goto cleanup;
1553 : }
1554 482 : curInstr = pushArgument(curBlk, curInstr, varid);
1555 482 : setVarType(curBlk, varid, type);
1556 : }
1557 : }
1558 : /* for recursive functions, avoid infinite loops */
1559 306 : pf = m->forward;
1560 306 : m->forward = f;
1561 306 : be->fimp = fimp; /* for recursive functions keep the generated name */
1562 306 : res = backend_dumpstmt(be, curBlk, r, prepare, 1, NULL);
1563 306 : m->forward = pf;
1564 306 : if (res < 0)
1565 1 : goto cleanup;
1566 : /* selectively make functions available for inlineing */
1567 : /* for the time being we only inline scalar functions */
1568 : /* and only if we see a single return value */
1569 : /* check the function for side effects and make that explicit */
1570 305 : sideeffects = f->side_effect;
1571 37874 : for (i = 1; i < curBlk->stop; i++) {
1572 37569 : InstrPtr p = getInstrPtr(curBlk, i);
1573 37569 : if (getFunctionId(p) == bindRef || getFunctionId(p) == bindidxRef)
1574 3882 : continue;
1575 33687 : sideeffects = sideeffects || hasSideEffects(curBlk, p, FALSE);
1576 33687 : no_inline |= (getModuleId(p) == malRef && getFunctionId(p) == multiplexRef);
1577 33687 : if (p->token == RETURNsymbol || p->barrier == RETURNsymbol)
1578 481 : retseen++;
1579 : }
1580 305 : if (i == curBlk->stop && retseen == 1 && f->type != F_UNION && !no_inline)
1581 171 : curBlk->inlineProp = 1;
1582 305 : if (sideeffects)
1583 101 : curBlk->unsafeProp = 1;
1584 : /* optimize the code, but beforehand add it to the cache, so recursive functions will be found */
1585 : /* 'sql' module is shared, so acquire mal context lock to avoid race conditions while adding new function symbols */
1586 305 : MT_lock_set(&sql_gencodeLock);
1587 305 : if (!f->instantiated) {
1588 305 : insertSymbol(mod, c->curprg);
1589 305 : added_to_cache = 1;
1590 305 : if (curBlk->inlineProp == 0 && !c->curprg->def->errors) {
1591 134 : msg = SQLoptimizeFunction(c, c->curprg->def);
1592 171 : } else if (curBlk->inlineProp != 0) {
1593 171 : if( msg == MAL_SUCCEED)
1594 171 : msg = chkProgram(c->usermodule, c->curprg->def);
1595 171 : if (msg == MAL_SUCCEED && !c->curprg->def->errors)
1596 171 : msg = SQLoptimizeFunction(c,c->curprg->def);
1597 : }
1598 305 : if (msg) {
1599 0 : if (c->curprg->def->errors)
1600 0 : freeException(msg);
1601 : else
1602 0 : c->curprg->def->errors = msg;
1603 : }
1604 305 : if (c->curprg->def->errors) {
1605 0 : MT_lock_unset(&sql_gencodeLock);
1606 0 : sql_error(m, 10, SQLSTATE(42000) "Internal error while compiling statement: %s", c->curprg->def->errors);
1607 0 : res = -1;
1608 0 : goto cleanup;
1609 : }
1610 305 : f->imp = fimp;
1611 305 : f->instantiated = TRUE; /* make sure 'instantiated' gets set after 'imp' */
1612 : }
1613 305 : MT_lock_unset(&sql_gencodeLock);
1614 :
1615 305 : cleanup:
1616 307 : if (res < 0) {
1617 2 : if (!added_to_cache) {
1618 2 : freeSymbol(c->curprg);
1619 : } else {
1620 0 : MT_lock_set(&sql_gencodeLock);
1621 0 : deleteSymbol(mod, c->curprg);
1622 0 : MT_lock_unset(&sql_gencodeLock);
1623 : }
1624 : }
1625 307 : return res;
1626 : }
1627 :
1628 : static int
1629 7030 : backend_create_sql_func(backend *be, sql_subfunc *sf, list *restypes, list *ops)
1630 : {
1631 7030 : mvc *m = be->mvc;
1632 7030 : Client c = be->client;
1633 7030 : Symbol symbackup = c->curprg;
1634 7030 : backend bebackup = *be; /* backup current backend */
1635 7030 : sql_func *f = sf->func;
1636 7030 : bool prepare = f->imp;
1637 7030 : const char *sql_shared_module = putName(sql_shared_module_name);
1638 7030 : const char *sql_private_module = putName(sql_private_module_name);
1639 7030 : const char *modname = prepare?sql_private_module:sql_shared_module;
1640 7030 : exception_buffer ebsave = m->sa->eb;
1641 7030 : char befname[IDLENGTH];
1642 7030 : int nargs;
1643 7030 : char *fimp;
1644 :
1645 : /* already instantiated or instantiating a recursive function */
1646 7030 : if (f->instantiated || (m->forward && m->forward->base.id == f->base.id))
1647 : return 0;
1648 :
1649 307 : (void) snprintf(befname, IDLENGTH, "f_" LLFMT, store_function_counter(m->store));
1650 307 : TRC_INFO(SQL_PARSER, "Mapping SQL name '%s' to MAL name '%s'\n", f->base.name, befname);
1651 307 : nargs = (f->res && f->type == F_UNION ? list_length(f->res) : 1) + (f->vararg && ops ? list_length(ops) : f->ops ? list_length(f->ops) : 0);
1652 307 : c->curprg = newFunctionArgs(modname, putName(befname), FUNCTIONsymbol, nargs);
1653 :
1654 307 : if ((fimp = _STRDUP(befname)) == NULL) {
1655 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1656 0 : goto bailout;
1657 307 : } else if (c->curprg == NULL) {
1658 0 : sql_error(m, 10, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1659 0 : goto bailout;
1660 307 : } else if (eb_savepoint(&m->sa->eb)) {
1661 0 : sql_error(m, 10, "%s", m->sa->eb.msg);
1662 0 : freeSymbol(c->curprg);
1663 0 : goto bailout;
1664 307 : } else if (backend_create_sql_func_body(be, f, restypes, ops, prepare ? c->usermodule : getModule(modname), fimp, prepare) < 0) {
1665 2 : goto bailout;
1666 : }
1667 305 : *be = bebackup;
1668 305 : c->curprg = symbackup;
1669 305 : m->sa->eb = ebsave;
1670 305 : return 0;
1671 2 : bailout:
1672 2 : _DELETE(fimp);
1673 2 : *be = bebackup;
1674 2 : c->curprg = symbackup;
1675 2 : m->sa->eb = ebsave;
1676 2 : return -1;
1677 : }
1678 :
1679 : static int
1680 377062 : backend_create_func(backend *be, sql_subfunc *sf, list *restypes, list *ops)
1681 : {
1682 377062 : switch(sf->func->lang) {
1683 : case FUNC_LANG_INT:
1684 : case FUNC_LANG_R:
1685 : case FUNC_LANG_PY:
1686 : case FUNC_LANG_PY3:
1687 : case FUNC_LANG_C:
1688 : case FUNC_LANG_CPP:
1689 : return 0; /* these languages don't require internal instantiation */
1690 40744 : case FUNC_LANG_MAL:
1691 40744 : return backend_create_mal_func(be->mvc, sf);
1692 7030 : case FUNC_LANG_SQL:
1693 7030 : return backend_create_sql_func(be, sf, restypes, ops);
1694 0 : default:
1695 0 : sql_error(be->mvc, 10, SQLSTATE(42000) "Function language without a MAL backend");
1696 0 : return -1;
1697 : }
1698 : }
1699 :
1700 : int
1701 377062 : backend_create_subfunc(backend *be, sql_subfunc *f, list *ops)
1702 : {
1703 377062 : return backend_create_func(be, f, f->res, ops);
1704 : }
1705 :
1706 : void
1707 0 : _rel_print(mvc *sql, sql_rel *rel)
1708 : {
1709 0 : list *refs = sa_list(sql->sa);
1710 0 : rel_print_refs(sql, GDKstdout, rel, 0, refs, 1);
1711 0 : rel_print_(sql, GDKstdout, rel, 0, refs, 1);
1712 0 : mnstr_printf(GDKstdout, "\n");
1713 0 : }
1714 :
1715 : void
1716 0 : _exp_print(mvc *sql, sql_exp *e) {
1717 0 : exp_print(sql, GDKstdout, e, 0, NULL, 1, 0, 1);
1718 0 : mnstr_printf(GDKstdout, "\n");
1719 0 : }
1720 :
1721 : void
1722 0 : _exps_print(mvc *sql, list *l) {
1723 0 : if (l)
1724 0 : for (node *n = l->h; n; n = n->next)
1725 0 : _exp_print(sql, n->data);
1726 0 : }
1727 :
1728 : void
1729 337 : rel_print(mvc *sql, sql_rel *rel, int depth)
1730 : {
1731 337 : list *refs = sa_list(sql->sa);
1732 337 : size_t pos;
1733 337 : size_t nl = 0;
1734 337 : size_t len = 0, lastpos = 0;
1735 337 : stream *fd = sql->scanner.ws;
1736 337 : stream *s;
1737 337 : buffer *b = buffer_create(16364); /* hopefully enough */
1738 337 : if (!b)
1739 : return; /* signal somehow? */
1740 337 : s = buffer_wastream(b, "SQL Plan");
1741 337 : if (!s) {
1742 0 : buffer_destroy(b);
1743 0 : return; /* signal somehow? */
1744 : }
1745 :
1746 337 : rel_print_refs(sql, s, rel, depth, refs, 1);
1747 337 : rel_print_(sql, s, rel, depth, refs, 1);
1748 337 : mnstr_printf(s, "\n");
1749 :
1750 : /* count the number of lines in the output, skip the leading \n */
1751 176724 : for (pos = 1; pos < b->pos; pos++) {
1752 176050 : if (b->buf[pos] == '\n') {
1753 2879 : nl++;
1754 2879 : if (len < pos - lastpos)
1755 : len = pos - lastpos;
1756 2879 : lastpos = pos + 1;
1757 : }
1758 : }
1759 337 : b->buf[b->pos - 1] = '\0'; /* should always end with a \n, can overwrite */
1760 :
1761 : /* craft a semi-professional header */
1762 337 : mnstr_printf(fd, "&1 0 %zu 1 %zu\n", /* type id rows columns tuples */
1763 : nl, nl);
1764 337 : mnstr_printf(fd, "%% .plan # table_name\n");
1765 337 : mnstr_printf(fd, "%% rel # name\n");
1766 337 : mnstr_printf(fd, "%% varchar # type\n");
1767 337 : mnstr_printf(fd, "%% %zu # length\n", len - 1 /* remove = */);
1768 :
1769 : /* output the data */
1770 337 : mnstr_printf(fd, "%s\n", b->buf + 1 /* omit starting \n */);
1771 :
1772 337 : close_stream(s);
1773 337 : buffer_destroy(b);
1774 : }
|
