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 : * SQL execution
15 : * N. Nes, M.L. Kersten
16 : */
17 : /*
18 : * Execution of SQL instructions.
19 : * Before we are can process SQL statements the global catalog should be initialized.
20 : */
21 : #include "monetdb_config.h"
22 : #include "mal_backend.h"
23 : #include "sql_scenario.h"
24 : #include "sql_result.h"
25 : #include "sql_gencode.h"
26 : #include "sql_assert.h"
27 : #include "sql_execute.h"
28 : #include "sql_env.h"
29 : #include "sql_mvc.h"
30 : #include "sql_user.h"
31 : #include "sql_optimizer.h"
32 : #include "sql_datetime.h"
33 : #include "rel_select.h"
34 : #include "rel_rel.h"
35 : #include "rel_exp.h"
36 : #include "rel_dump.h"
37 : #include "gdk_time.h"
38 : #include "optimizer.h"
39 : #include "opt_inline.h"
40 : #include <unistd.h>
41 :
42 : /* #define _SQL_COMPILE */
43 :
44 : /*
45 : * BEWARE: SQLstatementIntern only commits after all statements found
46 : * in expr are executed, when autocommit mode is enabled.
47 : *
48 : * The tricky part for this statement is to ensure that the SQL statement
49 : * is executed within the client context specified. This leads to context juggling.
50 : */
51 :
52 : /*
53 : * The trace operation collects the events in the BATs
54 : * and creates a secondary result set upon termination
55 : * of the query.
56 : *
57 : * SQLsetTrace extends the MAL plan with code to collect the events.
58 : * from the profile cache and returns it as a secondary resultset.
59 : */
60 : static str
61 4 : SQLsetTrace(Client cntxt, MalBlkPtr mb)
62 : {
63 4 : InstrPtr q, resultset;
64 4 : InstrPtr tbls, cols, types, clen, scale, multiset;
65 4 : str msg = MAL_SUCCEED;
66 4 : int k;
67 :
68 4 : if((msg = startTrace(cntxt)) != MAL_SUCCEED)
69 : return msg;
70 4 : clearTrace(cntxt);
71 :
72 126 : for(k = mb->stop-1; k>0; k--)
73 126 : if( getInstrPtr(mb,k)->token ==ENDsymbol)
74 : break;
75 4 : mb->stop = k;
76 :
77 4 : q = newStmt(mb, profilerRef, stoptraceRef);
78 4 : if (q == NULL) {
79 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
80 : }
81 4 : pushInstruction(mb, q);
82 :
83 : /* cook a new resultSet instruction */
84 4 : resultset = newInstruction(mb,sqlRef, resultSetRef);
85 4 : if (resultset == NULL) {
86 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
87 : }
88 4 : getArg(resultset,0) = newTmpVariable(mb, TYPE_int);
89 :
90 : /* build table defs */
91 4 : tbls = newStmt(mb,batRef, newRef);
92 4 : if (tbls == NULL) {
93 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
94 : }
95 4 : setVarType(mb, getArg(tbls,0), newBatType(TYPE_str));
96 4 : tbls = pushType(mb, tbls, TYPE_str);
97 4 : pushInstruction(mb, tbls);
98 :
99 4 : q = newStmt(mb,batRef,appendRef);
100 4 : if (q == NULL) {
101 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
102 : }
103 4 : q = pushArgument(mb,q,getArg(tbls,0));
104 4 : q = pushStr(mb,q,".trace");
105 4 : k = getArg(q,0);
106 4 : pushInstruction(mb, q);
107 :
108 4 : q = newStmt(mb,batRef,appendRef);
109 4 : if (q == NULL) {
110 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
111 : }
112 4 : q = pushArgument(mb,q,k);
113 4 : q = pushStr(mb,q,".trace");
114 4 : pushInstruction(mb, q);
115 :
116 4 : resultset = pushArgument(mb,resultset, getArg(q,0));
117 :
118 : /* build column defs */
119 4 : cols = newStmt(mb,batRef, newRef);
120 4 : if (cols == NULL) {
121 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
122 : }
123 4 : setVarType(mb, getArg(cols,0), newBatType(TYPE_str));
124 4 : cols = pushType(mb, cols, TYPE_str);
125 4 : pushInstruction(mb, cols);
126 :
127 4 : q = newStmt(mb,batRef,appendRef);
128 4 : if (q == NULL) {
129 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
130 : }
131 4 : q = pushArgument(mb,q,getArg(cols,0));
132 4 : q = pushStr(mb,q,"usec");
133 4 : k = getArg(q,0);
134 4 : pushInstruction(mb, q);
135 :
136 4 : q = newStmt(mb,batRef,appendRef);
137 4 : if (q == NULL) {
138 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
139 : }
140 4 : q = pushArgument(mb,q, k);
141 4 : q = pushStr(mb,q,"statement");
142 4 : pushInstruction(mb, q);
143 :
144 4 : resultset = pushArgument(mb,resultset, getArg(q,0));
145 :
146 : /* build type defs */
147 4 : types = newStmt(mb,batRef, newRef);
148 4 : if (types == NULL) {
149 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
150 : }
151 4 : setVarType(mb, getArg(types,0), newBatType(TYPE_str));
152 4 : types = pushType(mb, types, TYPE_str);
153 4 : pushInstruction(mb, types);
154 :
155 4 : q = newStmt(mb,batRef,appendRef);
156 4 : if (q == NULL) {
157 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
158 : }
159 4 : q = pushArgument(mb,q, getArg(types,0));
160 4 : q = pushStr(mb,q,"bigint");
161 4 : k = getArg(q,0);
162 4 : pushInstruction(mb, q);
163 :
164 4 : q = newStmt(mb,batRef,appendRef);
165 4 : if (q == NULL) {
166 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
167 : }
168 4 : q = pushArgument(mb,q, k);
169 4 : q = pushStr(mb,q,"varchar");
170 4 : pushInstruction(mb, q);
171 :
172 4 : resultset = pushArgument(mb,resultset, getArg(q,0));
173 :
174 : /* build scale defs */
175 4 : clen = newStmt(mb,batRef, newRef);
176 4 : if (clen == NULL) {
177 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
178 : }
179 4 : setVarType(mb, getArg(clen,0), newBatType(TYPE_int));
180 4 : clen = pushType(mb, clen, TYPE_int);
181 4 : pushInstruction(mb, clen);
182 :
183 4 : q = newStmt(mb,batRef,appendRef);
184 4 : if (q == NULL) {
185 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
186 : }
187 4 : q = pushArgument(mb,q, getArg(clen,0));
188 4 : q = pushInt(mb,q,64);
189 4 : k = getArg(q,0);
190 4 : pushInstruction(mb, q);
191 :
192 4 : q = newStmt(mb,batRef,appendRef);
193 4 : if (q == NULL) {
194 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
195 : }
196 4 : q = pushArgument(mb,q, k);
197 4 : q = pushInt(mb,q,0);
198 4 : pushInstruction(mb, q);
199 :
200 4 : resultset = pushArgument(mb,resultset, getArg(q,0));
201 :
202 : /* build scale defs */
203 4 : scale = newStmt(mb,batRef, newRef);
204 4 : if (scale == NULL) {
205 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
206 : }
207 4 : setVarType(mb, getArg(scale,0), newBatType(TYPE_int));
208 4 : scale = pushType(mb, scale, TYPE_int);
209 4 : pushInstruction(mb, scale);
210 :
211 4 : q = newStmt(mb,batRef,appendRef);
212 4 : if (q == NULL) {
213 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
214 : }
215 4 : q = pushArgument(mb,q, getArg(scale,0));
216 4 : q = pushInt(mb,q,0);
217 4 : k = getArg(q,0);
218 4 : pushInstruction(mb, q);
219 :
220 4 : q = newStmt(mb,batRef,appendRef);
221 4 : if (q == NULL) {
222 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
223 : }
224 4 : q = pushArgument(mb, q, k);
225 4 : q = pushInt(mb,q,0);
226 4 : pushInstruction(mb, q);
227 :
228 4 : resultset = pushArgument(mb,resultset, getArg(q,0));
229 :
230 : /* build multiset defs */
231 4 : multiset = newStmt(mb,batRef, newRef);
232 4 : if (multiset == NULL) {
233 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
234 : }
235 4 : setVarType(mb, getArg(multiset,0), newBatType(TYPE_int));
236 4 : multiset = pushType(mb, multiset, TYPE_int);
237 4 : pushInstruction(mb, multiset);
238 :
239 4 : q = newStmt(mb,batRef,appendRef);
240 4 : if (q == NULL) {
241 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
242 : }
243 4 : q = pushArgument(mb,q, getArg(multiset,0));
244 4 : q = pushInt(mb,q,0);
245 4 : k = getArg(q,0);
246 4 : pushInstruction(mb, q);
247 :
248 4 : q = newStmt(mb,batRef,appendRef);
249 4 : if (q == NULL) {
250 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
251 : }
252 4 : q = pushArgument(mb, q, k);
253 4 : q = pushInt(mb,q,0);
254 4 : pushInstruction(mb, q);
255 :
256 4 : resultset = pushArgument(mb,resultset, getArg(q,0));
257 :
258 : /* add the ticks column */
259 :
260 4 : q = newStmt(mb, profilerRef, getTraceRef);
261 4 : if (q == NULL) {
262 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
263 : }
264 4 : q = pushStr(mb, q, putName("usec"));
265 4 : resultset = pushArgument(mb,resultset, getArg(q,0));
266 4 : pushInstruction(mb, q);
267 :
268 : /* add the stmt column */
269 4 : q = newStmt(mb, profilerRef, getTraceRef);
270 4 : if (q == NULL) {
271 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
272 : }
273 4 : q = pushStr(mb, q, putName("stmt"));
274 4 : resultset = pushArgument(mb,resultset, getArg(q,0));
275 4 : pushInstruction(mb, q);
276 :
277 4 : pushInstruction(mb,resultset);
278 4 : pushEndInstruction(mb);
279 4 : msg = chkTypes(cntxt->usermodule, mb, TRUE);
280 4 : return msg;
281 : }
282 :
283 : str
284 616161 : SQLrun(Client c, mvc *m)
285 : {
286 616161 : str msg = MAL_SUCCEED;
287 616161 : MalBlkPtr mb = c->curprg->def;
288 :
289 616161 : assert(!*m->errstr);
290 :
291 616161 : TRC_INFO(SQL_EXECUTION, "Executing: %s", c->query);
292 616650 : MT_thread_setworking(c->query);
293 :
294 616912 : if (m->emod & mod_explain) {
295 54 : if (c->curprg->def)
296 54 : printFunction(c->fdout, mb, 0, LIST_MAL_NAME | LIST_MAL_VALUE | LIST_MAL_TYPE | LIST_MAL_MAPI);
297 : } else {
298 616858 : if (m->emod & mod_trace){
299 4 : if((msg = SQLsetTrace(c,mb)) == MAL_SUCCEED) {
300 4 : setVariableScope(mb);
301 4 : MT_lock_set(&mal_contextLock);
302 4 : c->idle = 0;
303 4 : c->lastcmd = time(0);
304 4 : MT_lock_unset(&mal_contextLock);
305 4 : msg = runMAL(c, mb, 0, 0);
306 4 : stopTrace(c);
307 : }
308 : } else {
309 616854 : setVariableScope(mb);
310 616851 : MT_lock_set(&mal_contextLock);
311 616855 : c->idle = 0;
312 616855 : c->lastcmd = time(0);
313 616855 : MT_lock_unset(&mal_contextLock);
314 616855 : msg = runMAL(c, mb, 0, 0);
315 : }
316 616789 : resetMalBlk(mb);
317 : }
318 : /* after the query has been finished we enter the idle state */
319 616809 : MT_lock_set(&mal_contextLock);
320 616913 : c->idle = time(0);
321 616913 : c->lastcmd = 0;
322 616913 : MT_lock_unset(&mal_contextLock);
323 616912 : MT_thread_setworking(NULL);
324 616912 : return msg;
325 : }
326 :
327 : /*
328 : * Escape single quotes and backslashes. This is important to do before calling
329 : * SQLstatementIntern, if we are pasting user provided strings into queries
330 : * passed to the SQLstatementIntern. Otherwise we open ourselves to SQL
331 : * injection attacks.
332 : *
333 : * It returns the input string with all the single quotes(') and the backslashes
334 : * (\) doubled, or NULL, if it could not allocate enough space.
335 : *
336 : * The caller is responsible to free the returned value.
337 : */
338 : str
339 0 : SQLescapeString(str s)
340 : {
341 0 : str ret = NULL;
342 0 : char *p, *q;
343 0 : size_t len = 0;
344 :
345 0 : if(!s) {
346 : return NULL;
347 : }
348 :
349 : /* At most we will need 2*strlen(s) + 1 characters */
350 0 : len = strlen(s);
351 0 : ret = (str)GDKmalloc(2*len + 1);
352 0 : if (!ret) {
353 : return NULL;
354 : }
355 :
356 0 : for (p = s, q = ret; *p != '\0'; p++, q++) {
357 0 : *q = *p;
358 0 : if (*p == '\'') {
359 0 : *(++q) = '\'';
360 : }
361 0 : else if (*p == '\\') {
362 0 : *(++q) = '\\';
363 : }
364 : }
365 :
366 0 : *q = '\0';
367 0 : return ret;
368 : }
369 :
370 : str
371 11489 : SQLstatementIntern(Client c, const char *expr, const char *nme, bit execute, bit output, res_table **result)
372 : {
373 11489 : int status = 0, err = 0, oldvtop, oldstop = 1, inited = 0, ac, sizeframes, topframes;
374 11489 : unsigned int label;
375 11489 : mvc *o = NULL, *m = NULL;
376 11489 : sql_frame **frames;
377 11489 : list *global_vars;
378 11489 : buffer *b = NULL;
379 11489 : char *n = NULL;
380 11489 : bstream *bs = NULL;
381 11489 : stream *buf = NULL;
382 11489 : str msg = MAL_SUCCEED;
383 11489 : backend *be = NULL, *sql = (backend *) c->sqlcontext;
384 11489 : Symbol backup = NULL;
385 11489 : size_t len = strlen(expr);
386 :
387 11489 : if (!sql) {
388 9 : inited = 1;
389 9 : msg = SQLinitClient(c, NULL, NULL, NULL);
390 9 : sql = (backend *) c->sqlcontext;
391 : }
392 11489 : if (msg){
393 0 : freeException(msg);
394 0 : throw(SQL, "sql.statement", SQLSTATE(HY002) "Catalogue not available");
395 : }
396 :
397 11489 : m = sql->mvc;
398 11489 : ac = m->session->auto_commit;
399 11489 : o = MNEW(mvc);
400 11489 : if (!o) {
401 0 : if (inited) {
402 0 : msg = SQLresetClient(c);
403 0 : freeException(msg);
404 : }
405 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
406 : }
407 11489 : *o = *m;
408 :
409 : /* create private allocator */
410 11489 : m->sa = NULL;
411 11489 : if ((msg = SQLtrans(m)) != MAL_SUCCEED) {
412 0 : be = sql;
413 0 : sql = NULL;
414 0 : goto endofcompile;
415 : }
416 11489 : status = m->session->status;
417 :
418 11489 : m->type = Q_PARSE;
419 11489 : be = sql;
420 11489 : sql = backend_create(m, c);
421 11489 : if (sql == NULL) {
422 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
423 0 : goto endofcompile;
424 : }
425 11489 : sql->output_format = be->output_format;
426 11489 : if (!output) {
427 11477 : sql->output_format = OFMT_NONE;
428 : }
429 11489 : sql->depth++;
430 :
431 11489 : m->user_id = m->role_id = USER_MONETDB;
432 11489 : if (result)
433 1885 : m->reply_size = -2; /* do not clean up result tables */
434 :
435 : /* mimic a client channel on which the query text is received */
436 11489 : b = malloc(sizeof(buffer));
437 11489 : if (b == NULL) {
438 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
439 0 : goto endofcompile;
440 : }
441 11489 : n = malloc(len + 1 + 1);
442 11489 : if (n == NULL) {
443 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
444 0 : goto endofcompile;
445 : }
446 11489 : strcpy_len(n, expr, len + 1);
447 11489 : n[len] = '\n';
448 11489 : n[len + 1] = 0;
449 11489 : len++;
450 11489 : buffer_init(b, n, len);
451 11489 : buf = buffer_rastream(b, "sqlstatement");
452 11489 : if (buf == NULL) {
453 0 : buffer_destroy(b); /* n and b will be freed by the buffer */
454 0 : b = NULL;
455 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
456 0 : goto endofcompile;
457 : }
458 11489 : bs = bstream_create(buf, b->len);
459 11489 : if (bs == NULL) {
460 0 : mnstr_destroy(buf);
461 0 : buffer_destroy(b);
462 0 : b = NULL;
463 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
464 0 : goto endofcompile;
465 : }
466 11489 : scanner_init(&m->scanner, bs, NULL);
467 11489 : m->scanner.mode = LINE_N;
468 11489 : bstream_next(m->scanner.rs);
469 :
470 11489 : m->params = NULL;
471 11489 : m->session->auto_commit = 0;
472 11489 : if (!m->sa && !(m->sa = sa_create(m->pa)) ) {
473 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
474 0 : goto endofcompile;
475 : }
476 :
477 : /*
478 : * System has been prepared to parse it and generate code.
479 : * Scan the complete string for SQL statements, stop at the first error.
480 : */
481 11489 : c->sqlcontext = sql;
482 11489 : if (c->curprg) {
483 11467 : backup = c->curprg;
484 11467 : c->curprg = NULL;
485 : }
486 :
487 336353 : while (msg == MAL_SUCCEED && m->scanner.rs->pos < m->scanner.rs->len) {
488 324867 : sql_rel *r;
489 :
490 324867 : m->sym = NULL;
491 649734 : if ((err = sqlparse(m)) ||
492 : /* Only forget old errors on transaction boundaries */
493 649734 : (mvc_status(m) && m->type != Q_TRANS) || !m->sym) {
494 2 : if (!err)
495 2 : err = mvc_status(m);
496 2 : if (*m->errstr){
497 0 : if (strlen(m->errstr) > 6 && m->errstr[5] == '!')
498 0 : msg = createException(PARSE, "SQLparser", "%s", m->errstr);
499 : else
500 0 : msg = createException(PARSE, "SQLparser", SQLSTATE(42000) "%s", m->errstr);
501 0 : *m->errstr = 0;
502 : }
503 2 : sqlcleanup(sql, err);
504 2 : execute = 0;
505 2 : if (!err)
506 2 : continue;
507 0 : goto endofcompile;
508 : }
509 :
510 : /*
511 : * We have dealt with the first parsing step and advanced the input reader
512 : * to the next statement (if any).
513 : * Now is the time to also perform the semantic analysis,
514 : * optimize and produce code.
515 : * We don't search the cache for a previous incarnation yet.
516 : */
517 324865 : if((msg = MSinitClientPrg(c, sql_private_module_name, nme)) != MAL_SUCCEED) {
518 0 : goto endofcompile;
519 : }
520 324865 : oldvtop = c->curprg->def->vtop;
521 324865 : oldstop = c->curprg->def->stop;
522 324865 : r = sql_symbol2relation(sql, m->sym);
523 :
524 324865 : assert(m->emode != m_prepare);
525 324865 : mvc_query_processed(m);
526 324865 : if ((err = mvc_status(m)) ) {
527 3 : if (strlen(m->errstr) > 6 && m->errstr[5] == '!')
528 3 : msg = createException(PARSE, "SQLparser", "%s", m->errstr);
529 : else
530 0 : msg = createException(PARSE, "SQLparser", SQLSTATE(42000) "%s", m->errstr);
531 3 : *m->errstr = 0;
532 3 : msg = handle_error(m, status, msg);
533 3 : sqlcleanup(sql, err);
534 : /* restore the state */
535 3 : MSresetInstructions(c->curprg->def, oldstop);
536 3 : freeVariables(c, c->curprg->def, c->glb, oldvtop);
537 3 : c->curprg->def->errors = 0;
538 3 : goto endofcompile;
539 : }
540 : /* generate MAL code */
541 324862 : be->depth++;
542 324862 : setVarType(c->curprg->def, 0, 0);
543 324862 : if (backend_dumpstmt(be, c->curprg->def, r, 1, 1, NULL) < 0)
544 0 : err = 1;
545 324862 : be->depth--;
546 :
547 324862 : if (err == 0) {
548 324862 : if (msg == MAL_SUCCEED)
549 324862 : msg = SQLoptimizeQuery(c, c->curprg->def);
550 324862 : if (msg)
551 : err = 1;
552 : }
553 :
554 324862 : if (err) {
555 0 : status = -10;
556 0 : if (msg)
557 0 : msg = handle_error(m, status, msg);
558 0 : sqlcleanup(sql, err);
559 : /* restore the state */
560 0 : MSresetInstructions(c->curprg->def, oldstop);
561 0 : freeVariables(c, c->curprg->def, c->glb, oldvtop);
562 0 : c->curprg->def->errors = 0;
563 0 : goto endofcompile;
564 : }
565 :
566 324862 : if (execute) {
567 324862 : if (!output)
568 324850 : sql->out = NULL; /* no output stream */
569 324862 : be->depth++;
570 324862 : msg = SQLrun(c, m);
571 324862 : be->depth--;
572 324862 : assert (c->curprg->def->stop <= 1);
573 324862 : sqlcleanup(sql, 0);
574 324862 : if (!execute)
575 : goto endofcompile;
576 : }
577 324862 : if (sql->results) {
578 1845 : if (result) { /* return all results sets */
579 1844 : *result = sql->results;
580 : } else {
581 1 : if (sql->results == be->results)
582 0 : be->results = NULL;
583 1 : res_tables_destroy(sql->results);
584 : }
585 1845 : sql->results = NULL;
586 : }
587 : }
588 : /*
589 : * We are done; a MAL procedure resides in the cache.
590 : */
591 11486 : endofcompile:
592 11489 : if (execute)
593 11487 : MSresetInstructions(c->curprg->def, 1);
594 :
595 11489 : if (backup)
596 11467 : c->curprg = backup;
597 :
598 11489 : c->sqlcontext = be;
599 11489 : backend_destroy(sql);
600 11489 : buffer_destroy(b);
601 11489 : bstream_destroy(m->scanner.rs);
602 11489 : if (m->sa)
603 11489 : sa_destroy(m->sa);
604 11489 : m->sa = NULL;
605 11489 : m->sym = NULL;
606 11489 : m->runs = NULL;
607 : /* variable stack maybe resized, ie we need to keep the new stack */
608 11489 : label = m->label;
609 11489 : status = m->session->status;
610 11489 : global_vars = m->global_vars;
611 11489 : sizeframes = m->sizeframes;
612 11489 : topframes = m->topframes;
613 11489 : frames = m->frames;
614 11489 : *m = *o;
615 11489 : _DELETE(o);
616 11489 : m->label = label;
617 11489 : m->global_vars = global_vars;
618 11489 : m->sizeframes = sizeframes;
619 11489 : m->topframes = topframes;
620 11489 : m->frames = frames;
621 11489 : m->session->status = status;
622 11489 : m->session->auto_commit = ac;
623 11489 : if (inited) {
624 9 : str other = SQLresetClient(c);
625 9 : freeException(other);
626 : }
627 : return msg;
628 : }
629 :
630 : void
631 33 : SQLdestroyResult(res_table *destroy)
632 : {
633 33 : res_table_destroy(destroy);
634 33 : }
635 :
636 : static str
637 186 : RAcommit_statement(backend *be, str msg)
638 : {
639 186 : mvc *m = be->mvc;
640 : /* if an error already exists set the session status to dirty */
641 186 : if (msg != MAL_SUCCEED && m->session->tr->active && !m->session->status)
642 0 : m->session->status = -1;
643 186 : return msg;
644 : }
645 :
646 : /* a hook is provided to execute relational algebra expressions */
647 : str
648 0 : RAstatement(Client c, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
649 : {
650 0 : int pos = 0;
651 0 : str *expr = getArgReference_str(stk, pci, 1);
652 0 : bit *opt = getArgReference_bit(stk, pci, 2);
653 0 : backend *be = NULL;
654 0 : mvc *m = NULL;
655 0 : str msg = MAL_SUCCEED;
656 0 : sql_rel *rel;
657 0 : list *refs;
658 :
659 0 : if ((msg = getSQLContext(c, mb, &m, &be)) != NULL)
660 : return msg;
661 0 : if ((msg = checkSQLContext(c)) != NULL)
662 : return msg;
663 0 : if ((msg = SQLtrans(m)) != MAL_SUCCEED)
664 : return msg;
665 0 : if (!m->sa)
666 0 : m->sa = sa_create(m->pa);
667 0 : if (!m->sa)
668 0 : return RAcommit_statement(be, createException(SQL,"RAstatement",SQLSTATE(HY013) MAL_MALLOC_FAIL));
669 0 : refs = sa_list(m->sa);
670 0 : rel = rel_read(m, *expr, &pos, refs);
671 0 : if (*opt && rel)
672 0 : rel = sql_processrelation(m, rel, 0, 1, 0, 0);
673 0 : if (!rel) {
674 0 : if (strlen(m->errstr) > 6 && m->errstr[5] == '!')
675 0 : msg = createException(SQL, "RAstatement", "%s", m->errstr);
676 : else
677 0 : msg = createException(SQL, "RAstatement", SQLSTATE(42000) "%s", m->errstr);
678 : } else {
679 0 : if ((msg = MSinitClientPrg(c, sql_private_module_name, "test")) != MAL_SUCCEED)
680 0 : return RAcommit_statement(be, msg);
681 :
682 : /* generate MAL code, ignoring any code generation error */
683 0 : setVarType(c->curprg->def, 0, 0);
684 0 : if (backend_dumpstmt(be, c->curprg->def, rel, 0, 1, NULL) < 0) {
685 0 : msg = createException(SQL,"RAstatement","Program contains errors"); // TODO: use macro definition.
686 : } else {
687 0 : msg = SQLoptimizeFunction(c, c->curprg->def);
688 0 : if (msg == MAL_SUCCEED)
689 0 : msg = SQLrun(c,m);
690 0 : resetMalBlk(c->curprg->def);
691 : }
692 0 : rel_destroy(rel);
693 : }
694 0 : return RAcommit_statement(be, msg);
695 : }
696 :
697 : static char *
698 31 : parseIdent(char *in, char *out)
699 : {
700 242 : while (*in && *in != '"') {
701 211 : if (*in == '\\' && (*(in + 1) == '\\' || *(in + 1) == '"')) {
702 3 : *out++ = *(in + 1);
703 3 : in+=2;
704 : } else {
705 208 : *out++ = *in++;
706 : }
707 : }
708 31 : *out++ = '\0';
709 31 : return in;
710 : }
711 :
712 : struct local_var_entry {
713 : char *vname;
714 : sql_subtype tpe;
715 : } local_var_entry;
716 :
717 : struct global_var_entry {
718 : char *vname;
719 : sql_schema *s;
720 : } global_var_entry;
721 :
722 : static str
723 186 : RAstatement2_return(backend *be, mvc *m, int nlevels, struct global_var_entry *gvars, int gentries, str msg)
724 : {
725 202 : while (nlevels) { /* clean added frames */
726 15 : stack_pop_frame(m);
727 16 : nlevels--;
728 : }
729 187 : for (int i = 0 ; i < gentries ; i++) { /* clean any added global variables */
730 1 : struct global_var_entry gv = gvars[i];
731 1 : (void) remove_global_var(m, gv.s, gv.vname);
732 : }
733 186 : sa_reset(m->ta);
734 186 : return RAcommit_statement(be, msg);
735 : }
736 :
737 : static void
738 1408 : subtype_from_string(mvc *sql, sql_subtype *st, char *type)
739 : {
740 1408 : unsigned digits = 0, scale = 0;
741 :
742 1408 : char *end = strchr(type, '(');
743 1408 : if (end) {
744 55 : end[0] = 0;
745 55 : digits = strtol(end+1, &end, 10);
746 55 : if (end && end[0] == ',')
747 5 : scale = strtol(end+1, NULL, 10);
748 : }
749 1408 : if (!sql_find_subtype(st, type, digits, scale)) {
750 2 : sql_type *t = mvc_bind_type(sql, type);
751 2 : if (t)
752 2 : sql_init_subtype(st, t, 0, 0);
753 : }
754 1408 : }
755 :
756 : str
757 187 : RAstatement2(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
758 : {
759 187 : int pos = 0, nlevels = 0, *lkeys = NULL, lcap = 0, lentries = 0, gcap = 0, gentries = 0;
760 187 : str mod = *getArgReference_str(stk, pci, 1);
761 187 : str nme = *getArgReference_str(stk, pci, 2);
762 187 : str expr = *getArgReference_str(stk, pci, 3);
763 187 : str sig = *getArgReference_str(stk, pci, 4);
764 187 : str types = pci->argc == 6 ? *getArgReference_str(stk, pci, 5) : NULL;
765 187 : backend *be = NULL;
766 187 : mvc *m = NULL;
767 187 : str msg = MAL_SUCCEED;
768 187 : sql_rel *rel;
769 187 : list *refs, *ops;
770 187 : struct local_var_entry *lvars = NULL;
771 187 : struct global_var_entry *gvars = NULL;
772 :
773 187 : if ((msg = getSQLContext(cntxt, mb, &m, &be)) != NULL)
774 : return msg;
775 187 : if ((msg = checkSQLContext(cntxt)) != NULL)
776 : return msg;
777 187 : if ((msg = SQLtrans(m)) != MAL_SUCCEED)
778 : return msg;
779 187 : if (!m->sa)
780 187 : m->sa = sa_create(m->pa);
781 187 : if (!m->sa)
782 0 : return RAstatement2_return(be, m, nlevels, gvars, gentries, createException(SQL,"RAstatement2",SQLSTATE(HY013) MAL_MALLOC_FAIL));
783 :
784 187 : ops = sa_list(m->sa);
785 215 : while (sig && *sig) {
786 28 : sql_schema *sh = NULL;
787 28 : sql_type *t = NULL;
788 28 : sql_subtype tpe;
789 28 : char *p, *vtype = NULL, *sch = NULL, *var = NULL;
790 28 : int d, s, level = strtol(sig, &p, 10);
791 :
792 28 : var = p+1;
793 28 : assert(*p == '"');
794 28 : p = parseIdent(p+1, var);
795 28 : p++;
796 28 : if (*p == '"') { /* global variable, parse schema and name */
797 3 : sch = var;
798 3 : var = p+1;
799 3 : p = parseIdent(p+1, var);
800 3 : p++;
801 : }
802 :
803 28 : assert(*p == ' ');
804 28 : p++; /* skip space and get type */
805 28 : vtype = p;
806 28 : p = strchr(p, '(');
807 28 : *p++ = '\0';
808 :
809 : /* get digits and scale */
810 28 : d = strtol(p, &p, 10);
811 28 : p++; /* skip , */
812 28 : s = strtol(p, &p, 10);
813 28 : p+=2; /* skip ) and , or ' ' */
814 28 : sig = p;
815 :
816 28 : if (!sql_find_subtype(&tpe, vtype, d, s)) {
817 6 : if (!(t = mvc_bind_type(m, vtype))) /* try an external type */
818 0 : return RAstatement2_return(be, m, nlevels, gvars, gentries, createException(SQL,"RAstatement2",SQLSTATE(42000) "SQL type %s(%d, %d) not found\n", vtype, d, s));
819 6 : sql_init_subtype(&tpe, t, d, s);
820 : }
821 :
822 28 : if (sch) {
823 3 : assert(level == 0);
824 3 : if (!(sh = mvc_bind_schema(m, sch)))
825 0 : return RAstatement2_return(be, m, nlevels, gvars, gentries, createException(SQL,"RAstatement2",SQLSTATE(3F000) "No such schema '%s'", sch));
826 3 : if (!find_global_var(m, sh, var)) { /* don't add the same global variable again */
827 0 : if (!push_global_var(m, sch, var, &tpe)) /* if doesn't exist, add it, then remove it before returning */
828 0 : return RAstatement2_return(be, m, nlevels, gvars, gentries, createException(SQL,"RAstatement2",SQLSTATE(HY013) MAL_MALLOC_FAIL));
829 0 : if (gentries == gcap) {
830 0 : if (gcap == 0) {
831 0 : gcap = 8;
832 0 : gvars = SA_NEW_ARRAY(m->ta, struct global_var_entry, gcap);
833 : } else {
834 0 : int ngcap = gcap * 4;
835 0 : gvars = SA_RENEW_ARRAY(m->ta, struct global_var_entry, gvars, ngcap, gcap);
836 : gcap = ngcap;
837 : }
838 0 : gvars[gentries++] = (struct global_var_entry) {.s = sh, .vname = var,};
839 : }
840 : }
841 3 : list_append(ops, exp_var(m->sa, sa_strdup(m->sa, sch), sa_strdup(m->sa, var), &tpe, 0));
842 : } else {
843 25 : char opname[BUFSIZ];
844 :
845 25 : if (lentries == lcap) {
846 13 : if (lcap == 0) {
847 13 : lcap = 8;
848 13 : lkeys = SA_NEW_ARRAY(m->ta, int, lcap);
849 13 : lvars = SA_NEW_ARRAY(m->ta, struct local_var_entry, lcap);
850 : } else {
851 0 : int nlcap = lcap * 4;
852 0 : lkeys = SA_RENEW_ARRAY(m->ta, int, lkeys, nlcap, lcap);
853 0 : lvars = SA_RENEW_ARRAY(m->ta, struct local_var_entry, lvars, nlcap, lcap);
854 : lcap = nlcap;
855 : }
856 : }
857 25 : lkeys[lentries] = level;
858 25 : lvars[lentries] = (struct local_var_entry) {.tpe = tpe, .vname = var,};
859 25 : lentries++;
860 :
861 25 : snprintf(opname, BUFSIZ, "%d%%%s", level, var); /* engineering trick */
862 25 : list_append(ops, exp_var(m->sa, NULL, sa_strdup(m->sa, opname), &tpe, level));
863 : }
864 : }
865 187 : if (lentries) {
866 13 : GDKqsort(lkeys, lvars, NULL, lentries, sizeof(int), sizeof(struct local_var_entry), TYPE_int, false, false);
867 :
868 38 : for (int i = 0 ; i < lentries ; i++) {
869 25 : int next_level = lkeys[i];
870 25 : struct local_var_entry next_val = lvars[i];
871 :
872 25 : assert(next_level != 0); /* no global variables here */
873 41 : while (nlevels < next_level) { /* add gap levels */
874 16 : if (!stack_push_frame(m, NULL))
875 0 : return RAstatement2_return(be, m, nlevels, gvars, gentries, createException(SQL,"RAstatement2",SQLSTATE(HY013) MAL_MALLOC_FAIL));
876 16 : nlevels++;
877 : }
878 25 : if (!frame_push_var(m, next_val.vname, &next_val.tpe))
879 0 : return RAstatement2_return(be, m, nlevels, gvars, gentries, createException(SQL,"RAstatement2",SQLSTATE(HY013) MAL_MALLOC_FAIL));
880 : }
881 : }
882 :
883 187 : refs = sa_list(m->sa);
884 187 : rel = rel_read(m, expr, &pos, refs);
885 185 : if (rel)
886 181 : rel = sql_processrelation(m, rel, 0, 1, 0, 0);
887 181 : if (!rel) {
888 4 : if (strlen(m->errstr) > 6 && m->errstr[5] == '!')
889 4 : msg = createException(SQL, "RAstatement2", "%s", m->errstr);
890 : else
891 0 : msg = createException(SQL, "RAstatement2", SQLSTATE(42000) "%s", m->errstr);
892 181 : } else if (rel && types && is_simple_project(rel->op)) { /* Test if types match */
893 180 : list *types_list = sa_list(m->sa);
894 180 : str token, rest;
895 :
896 1587 : for (token = strtok_r(types, "%", &rest); token; token = strtok_r(NULL, "%", &rest))
897 1410 : list_append(types_list, token);
898 :
899 181 : if (list_length(types_list) != list_length(rel->exps))
900 0 : msg = createException(SQL, "RAstatement2", SQLSTATE(42000) "The number of projections don't match between the generated plan and the expected one: %d != %d",
901 : list_length(types_list), list_length(rel->exps));
902 : else {
903 182 : int i = 1;
904 1590 : for (node *n = rel->exps->h, *m = types_list->h ; n && m && !msg ; n = n->next, m = m->next) {
905 1410 : sql_exp *e = n->data, *ne = NULL;
906 1410 : sql_subtype *t = exp_subtype(e), et;
907 :
908 1409 : subtype_from_string(be->mvc, &et, m->data);
909 1409 : if (!is_subtype(t, &et) && (ne = exp_check_type(be->mvc, &et, rel, e, type_equal)) == NULL) {
910 0 : str got = sql_subtype_string(be->mvc->ta, t), expected = (str) m->data;
911 0 : if (!got)
912 0 : msg = createException(SQL, "RAstatement2", SQLSTATE(HY013) MAL_MALLOC_FAIL);
913 0 : msg = createException(SQL, "RAstatement2", SQLSTATE(42000) "Parameter %d has wrong SQL type, expected %s, but got %s instead", i, expected, got);
914 : }
915 0 : if (ne) {
916 3 : exp_setname(be->mvc, ne, exp_relname(e), exp_name(e));
917 3 : n->data = ne;
918 : }
919 1408 : i++;
920 : }
921 : }
922 : }
923 185 : if (!msg && monet5_create_relational_function(m, mod, nme, rel, NULL, ops, 0) < 0)
924 0 : msg = createException(SQL, "RAstatement2", "%s", m->errstr);
925 186 : rel_destroy(rel);
926 186 : return RAstatement2_return(be, m, nlevels, gvars, gentries, msg);
927 : }
928 :
929 : str
930 187 : RAstatementEnd(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
931 : {
932 187 : backend *be = NULL;
933 187 : mvc *m = NULL;
934 187 : str msg = MAL_SUCCEED;
935 :
936 187 : (void) stk;
937 187 : (void) pci;
938 187 : if ((msg = getSQLContext(cntxt, mb, &m, &be)) != NULL)
939 : return msg;
940 187 : if ((msg = checkSQLContext(cntxt)) != NULL)
941 : return msg;
942 :
943 187 : sqlcleanup(be, 0);
944 187 : return SQLautocommit(m);
945 : }
|
