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;
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 : /* add the ticks column */
231 :
232 4 : q = newStmt(mb, profilerRef, getTraceRef);
233 4 : if (q == NULL) {
234 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
235 : }
236 4 : q = pushStr(mb, q, putName("usec"));
237 4 : resultset = pushArgument(mb,resultset, getArg(q,0));
238 4 : pushInstruction(mb, q);
239 :
240 : /* add the stmt column */
241 4 : q = newStmt(mb, profilerRef, getTraceRef);
242 4 : if (q == NULL) {
243 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
244 : }
245 4 : q = pushStr(mb, q, putName("stmt"));
246 4 : resultset = pushArgument(mb,resultset, getArg(q,0));
247 4 : pushInstruction(mb, q);
248 :
249 4 : pushInstruction(mb,resultset);
250 4 : pushEndInstruction(mb);
251 4 : msg = chkTypes(cntxt->usermodule, mb, TRUE);
252 4 : return msg;
253 : }
254 :
255 : str
256 614766 : SQLrun(Client c, mvc *m)
257 : {
258 614766 : str msg = MAL_SUCCEED;
259 614766 : MalBlkPtr mb = c->curprg->def;
260 :
261 614766 : assert(!*m->errstr);
262 :
263 614766 : TRC_INFO(SQL_EXECUTION, "Executing: %s", c->query);
264 614916 : MT_thread_setworking(c->query);
265 :
266 614932 : if (m->emod & mod_explain) {
267 54 : if (c->curprg->def)
268 54 : printFunction(c->fdout, mb, 0, LIST_MAL_NAME | LIST_MAL_VALUE | LIST_MAL_TYPE | LIST_MAL_MAPI);
269 : } else {
270 614878 : if (m->emod & mod_trace){
271 4 : if((msg = SQLsetTrace(c,mb)) == MAL_SUCCEED) {
272 4 : setVariableScope(mb);
273 4 : MT_lock_set(&mal_contextLock);
274 4 : c->idle = 0;
275 4 : c->lastcmd = time(0);
276 4 : MT_lock_unset(&mal_contextLock);
277 4 : msg = runMAL(c, mb, 0, 0);
278 4 : stopTrace(c);
279 : }
280 : } else {
281 614874 : setVariableScope(mb);
282 614872 : MT_lock_set(&mal_contextLock);
283 614876 : c->idle = 0;
284 614876 : c->lastcmd = time(0);
285 614876 : MT_lock_unset(&mal_contextLock);
286 614876 : msg = runMAL(c, mb, 0, 0);
287 : }
288 614832 : resetMalBlk(mb);
289 : }
290 : /* after the query has been finished we enter the idle state */
291 614811 : MT_lock_set(&mal_contextLock);
292 614934 : c->idle = time(0);
293 614934 : c->lastcmd = 0;
294 614934 : MT_lock_unset(&mal_contextLock);
295 614934 : MT_thread_setworking(NULL);
296 614934 : return msg;
297 : }
298 :
299 : /*
300 : * Escape single quotes and backslashes. This is important to do before calling
301 : * SQLstatementIntern, if we are pasting user provided strings into queries
302 : * passed to the SQLstatementIntern. Otherwise we open ourselves to SQL
303 : * injection attacks.
304 : *
305 : * It returns the input string with all the single quotes(') and the backslashes
306 : * (\) doubled, or NULL, if it could not allocate enough space.
307 : *
308 : * The caller is responsible to free the returned value.
309 : */
310 : str
311 0 : SQLescapeString(str s)
312 : {
313 0 : str ret = NULL;
314 0 : char *p, *q;
315 0 : size_t len = 0;
316 :
317 0 : if(!s) {
318 : return NULL;
319 : }
320 :
321 : /* At most we will need 2*strlen(s) + 1 characters */
322 0 : len = strlen(s);
323 0 : ret = (str)GDKmalloc(2*len + 1);
324 0 : if (!ret) {
325 : return NULL;
326 : }
327 :
328 0 : for (p = s, q = ret; *p != '\0'; p++, q++) {
329 0 : *q = *p;
330 0 : if (*p == '\'') {
331 0 : *(++q) = '\'';
332 : }
333 0 : else if (*p == '\\') {
334 0 : *(++q) = '\\';
335 : }
336 : }
337 :
338 0 : *q = '\0';
339 0 : return ret;
340 : }
341 :
342 : str
343 11221 : SQLstatementIntern(Client c, const char *expr, const char *nme, bit execute, bit output, res_table **result)
344 : {
345 11221 : int status = 0, err = 0, oldvtop, oldstop = 1, inited = 0, ac, sizeframes, topframes;
346 11221 : unsigned int label;
347 11221 : mvc *o = NULL, *m = NULL;
348 11221 : sql_frame **frames;
349 11221 : list *global_vars;
350 11221 : buffer *b = NULL;
351 11221 : char *n = NULL;
352 11221 : bstream *bs = NULL;
353 11221 : stream *buf = NULL;
354 11221 : str msg = MAL_SUCCEED;
355 11221 : backend *be = NULL, *sql = (backend *) c->sqlcontext;
356 11221 : Symbol backup = NULL;
357 11221 : size_t len = strlen(expr);
358 :
359 11221 : if (!sql) {
360 9 : inited = 1;
361 9 : msg = SQLinitClient(c, NULL, NULL, NULL);
362 9 : sql = (backend *) c->sqlcontext;
363 : }
364 11221 : if (msg){
365 0 : freeException(msg);
366 0 : throw(SQL, "sql.statement", SQLSTATE(HY002) "Catalogue not available");
367 : }
368 :
369 11221 : m = sql->mvc;
370 11221 : ac = m->session->auto_commit;
371 11221 : o = MNEW(mvc);
372 11221 : if (!o) {
373 0 : if (inited) {
374 0 : msg = SQLresetClient(c);
375 0 : freeException(msg);
376 : }
377 0 : throw(SQL, "sql.statement", SQLSTATE(HY013) MAL_MALLOC_FAIL);
378 : }
379 11221 : *o = *m;
380 :
381 : /* create private allocator */
382 11221 : m->sa = NULL;
383 11221 : if ((msg = SQLtrans(m)) != MAL_SUCCEED) {
384 0 : be = sql;
385 0 : sql = NULL;
386 0 : goto endofcompile;
387 : }
388 11221 : status = m->session->status;
389 :
390 11221 : m->type = Q_PARSE;
391 11221 : be = sql;
392 11221 : sql = backend_create(m, c);
393 11221 : if (sql == NULL) {
394 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
395 0 : goto endofcompile;
396 : }
397 11221 : sql->output_format = be->output_format;
398 11221 : if (!output) {
399 11209 : sql->output_format = OFMT_NONE;
400 : }
401 11221 : sql->depth++;
402 :
403 11221 : m->user_id = m->role_id = USER_MONETDB;
404 11221 : if (result)
405 1885 : m->reply_size = -2; /* do not clean up result tables */
406 :
407 : /* mimic a client channel on which the query text is received */
408 11221 : b = malloc(sizeof(buffer));
409 11221 : if (b == NULL) {
410 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
411 0 : goto endofcompile;
412 : }
413 11221 : n = malloc(len + 1 + 1);
414 11221 : if (n == NULL) {
415 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
416 0 : goto endofcompile;
417 : }
418 11221 : strcpy_len(n, expr, len + 1);
419 11221 : n[len] = '\n';
420 11221 : n[len + 1] = 0;
421 11221 : len++;
422 11221 : buffer_init(b, n, len);
423 11221 : buf = buffer_rastream(b, "sqlstatement");
424 11221 : if (buf == NULL) {
425 0 : buffer_destroy(b); /* n and b will be freed by the buffer */
426 0 : b = NULL;
427 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
428 0 : goto endofcompile;
429 : }
430 11221 : bs = bstream_create(buf, b->len);
431 11221 : if (bs == NULL) {
432 0 : mnstr_destroy(buf);
433 0 : buffer_destroy(b);
434 0 : b = NULL;
435 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
436 0 : goto endofcompile;
437 : }
438 11221 : scanner_init(&m->scanner, bs, NULL);
439 11221 : m->scanner.mode = LINE_N;
440 11221 : bstream_next(m->scanner.rs);
441 :
442 11221 : m->params = NULL;
443 11221 : m->session->auto_commit = 0;
444 11221 : if (!m->sa && !(m->sa = sa_create(m->pa)) ) {
445 0 : msg = createException(SQL,"sql.statement",SQLSTATE(HY013) MAL_MALLOC_FAIL);
446 0 : goto endofcompile;
447 : }
448 :
449 : /*
450 : * System has been prepared to parse it and generate code.
451 : * Scan the complete string for SQL statements, stop at the first error.
452 : */
453 11221 : c->sqlcontext = sql;
454 11221 : if (c->curprg) {
455 11199 : backup = c->curprg;
456 11199 : c->curprg = NULL;
457 : }
458 :
459 334487 : while (msg == MAL_SUCCEED && m->scanner.rs->pos < m->scanner.rs->len) {
460 323269 : sql_rel *r;
461 :
462 323269 : m->sym = NULL;
463 646538 : if ((err = sqlparse(m)) ||
464 : /* Only forget old errors on transaction boundaries */
465 646538 : (mvc_status(m) && m->type != Q_TRANS) || !m->sym) {
466 2 : if (!err)
467 2 : err = mvc_status(m);
468 2 : if (*m->errstr){
469 0 : if (strlen(m->errstr) > 6 && m->errstr[5] == '!')
470 0 : msg = createException(PARSE, "SQLparser", "%s", m->errstr);
471 : else
472 0 : msg = createException(PARSE, "SQLparser", SQLSTATE(42000) "%s", m->errstr);
473 0 : *m->errstr = 0;
474 : }
475 2 : sqlcleanup(sql, err);
476 2 : execute = 0;
477 2 : if (!err)
478 2 : continue;
479 0 : goto endofcompile;
480 : }
481 :
482 : /*
483 : * We have dealt with the first parsing step and advanced the input reader
484 : * to the next statement (if any).
485 : * Now is the time to also perform the semantic analysis,
486 : * optimize and produce code.
487 : * We don't search the cache for a previous incarnation yet.
488 : */
489 323267 : if((msg = MSinitClientPrg(c, sql_private_module_name, nme)) != MAL_SUCCEED) {
490 0 : goto endofcompile;
491 : }
492 323267 : oldvtop = c->curprg->def->vtop;
493 323267 : oldstop = c->curprg->def->stop;
494 323267 : r = sql_symbol2relation(sql, m->sym);
495 :
496 323267 : assert(m->emode != m_prepare);
497 323267 : mvc_query_processed(m);
498 323267 : if ((err = mvc_status(m)) ) {
499 3 : if (strlen(m->errstr) > 6 && m->errstr[5] == '!')
500 3 : msg = createException(PARSE, "SQLparser", "%s", m->errstr);
501 : else
502 0 : msg = createException(PARSE, "SQLparser", SQLSTATE(42000) "%s", m->errstr);
503 3 : *m->errstr = 0;
504 3 : msg = handle_error(m, status, msg);
505 3 : sqlcleanup(sql, err);
506 : /* restore the state */
507 3 : MSresetInstructions(c->curprg->def, oldstop);
508 3 : freeVariables(c, c->curprg->def, c->glb, oldvtop);
509 3 : c->curprg->def->errors = 0;
510 3 : goto endofcompile;
511 : }
512 : /* generate MAL code */
513 323264 : be->depth++;
514 323264 : setVarType(c->curprg->def, 0, 0);
515 323264 : if (backend_dumpstmt(be, c->curprg->def, r, 1, 1, NULL) < 0)
516 0 : err = 1;
517 323264 : be->depth--;
518 :
519 323264 : if (err == 0) {
520 323264 : if (msg == MAL_SUCCEED)
521 323264 : msg = SQLoptimizeQuery(c, c->curprg->def);
522 323264 : if (msg)
523 : err = 1;
524 : }
525 :
526 323264 : if (err) {
527 0 : status = -10;
528 0 : if (msg)
529 0 : msg = handle_error(m, status, msg);
530 0 : sqlcleanup(sql, err);
531 : /* restore the state */
532 0 : MSresetInstructions(c->curprg->def, oldstop);
533 0 : freeVariables(c, c->curprg->def, c->glb, oldvtop);
534 0 : c->curprg->def->errors = 0;
535 0 : goto endofcompile;
536 : }
537 :
538 323264 : if (execute) {
539 323264 : if (!output)
540 323252 : sql->out = NULL; /* no output stream */
541 323264 : be->depth++;
542 323264 : msg = SQLrun(c, m);
543 323264 : be->depth--;
544 323264 : assert (c->curprg->def->stop <= 1);
545 323264 : sqlcleanup(sql, 0);
546 323264 : if (!execute)
547 : goto endofcompile;
548 : }
549 323264 : if (sql->results) {
550 1845 : if (result) { /* return all results sets */
551 1844 : *result = sql->results;
552 : } else {
553 1 : if (sql->results == be->results)
554 0 : be->results = NULL;
555 1 : res_tables_destroy(sql->results);
556 : }
557 1845 : sql->results = NULL;
558 : }
559 : }
560 : /*
561 : * We are done; a MAL procedure resides in the cache.
562 : */
563 11218 : endofcompile:
564 11221 : if (execute)
565 11219 : MSresetInstructions(c->curprg->def, 1);
566 :
567 11221 : if (backup)
568 11199 : c->curprg = backup;
569 :
570 11221 : c->sqlcontext = be;
571 11221 : backend_destroy(sql);
572 11221 : buffer_destroy(b);
573 11221 : bstream_destroy(m->scanner.rs);
574 11221 : if (m->sa)
575 11221 : sa_destroy(m->sa);
576 11221 : m->sa = NULL;
577 11221 : m->sym = NULL;
578 11221 : m->runs = NULL;
579 : /* variable stack maybe resized, ie we need to keep the new stack */
580 11221 : label = m->label;
581 11221 : status = m->session->status;
582 11221 : global_vars = m->global_vars;
583 11221 : sizeframes = m->sizeframes;
584 11221 : topframes = m->topframes;
585 11221 : frames = m->frames;
586 11221 : *m = *o;
587 11221 : _DELETE(o);
588 11221 : m->label = label;
589 11221 : m->global_vars = global_vars;
590 11221 : m->sizeframes = sizeframes;
591 11221 : m->topframes = topframes;
592 11221 : m->frames = frames;
593 11221 : m->session->status = status;
594 11221 : m->session->auto_commit = ac;
595 11221 : if (inited) {
596 9 : str other = SQLresetClient(c);
597 9 : freeException(other);
598 : }
599 : return msg;
600 : }
601 :
602 : void
603 33 : SQLdestroyResult(res_table *destroy)
604 : {
605 33 : res_table_destroy(destroy);
606 33 : }
607 :
608 : static str
609 185 : RAcommit_statement(backend *be, str msg)
610 : {
611 185 : mvc *m = be->mvc;
612 : /* if an error already exists set the session status to dirty */
613 185 : if (msg != MAL_SUCCEED && m->session->tr->active && !m->session->status)
614 0 : m->session->status = -1;
615 185 : return msg;
616 : }
617 :
618 : /* a hook is provided to execute relational algebra expressions */
619 : str
620 0 : RAstatement(Client c, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
621 : {
622 0 : int pos = 0;
623 0 : str *expr = getArgReference_str(stk, pci, 1);
624 0 : bit *opt = getArgReference_bit(stk, pci, 2);
625 0 : backend *be = NULL;
626 0 : mvc *m = NULL;
627 0 : str msg = MAL_SUCCEED;
628 0 : sql_rel *rel;
629 0 : list *refs;
630 :
631 0 : if ((msg = getSQLContext(c, mb, &m, &be)) != NULL)
632 : return msg;
633 0 : if ((msg = checkSQLContext(c)) != NULL)
634 : return msg;
635 0 : if ((msg = SQLtrans(m)) != MAL_SUCCEED)
636 : return msg;
637 0 : if (!m->sa)
638 0 : m->sa = sa_create(m->pa);
639 0 : if (!m->sa)
640 0 : return RAcommit_statement(be, createException(SQL,"RAstatement",SQLSTATE(HY013) MAL_MALLOC_FAIL));
641 0 : refs = sa_list(m->sa);
642 0 : rel = rel_read(m, *expr, &pos, refs);
643 0 : if (*opt && rel)
644 0 : rel = sql_processrelation(m, rel, 0, 1, 0, 0);
645 0 : if (!rel) {
646 0 : if (strlen(m->errstr) > 6 && m->errstr[5] == '!')
647 0 : msg = createException(SQL, "RAstatement", "%s", m->errstr);
648 : else
649 0 : msg = createException(SQL, "RAstatement", SQLSTATE(42000) "%s", m->errstr);
650 : } else {
651 0 : if ((msg = MSinitClientPrg(c, sql_private_module_name, "test")) != MAL_SUCCEED)
652 0 : return RAcommit_statement(be, msg);
653 :
654 : /* generate MAL code, ignoring any code generation error */
655 0 : setVarType(c->curprg->def, 0, 0);
656 0 : if (backend_dumpstmt(be, c->curprg->def, rel, 0, 1, NULL) < 0) {
657 0 : msg = createException(SQL,"RAstatement","Program contains errors"); // TODO: use macro definition.
658 : } else {
659 0 : msg = SQLoptimizeFunction(c, c->curprg->def);
660 0 : if (msg == MAL_SUCCEED)
661 0 : msg = SQLrun(c,m);
662 0 : resetMalBlk(c->curprg->def);
663 : }
664 0 : rel_destroy(rel);
665 : }
666 0 : return RAcommit_statement(be, msg);
667 : }
668 :
669 : static char *
670 31 : parseIdent(char *in, char *out)
671 : {
672 242 : while (*in && *in != '"') {
673 211 : if (*in == '\\' && (*(in + 1) == '\\' || *(in + 1) == '"')) {
674 3 : *out++ = *(in + 1);
675 3 : in+=2;
676 : } else {
677 208 : *out++ = *in++;
678 : }
679 : }
680 31 : *out++ = '\0';
681 31 : return in;
682 : }
683 :
684 : struct local_var_entry {
685 : char *vname;
686 : sql_subtype tpe;
687 : } local_var_entry;
688 :
689 : struct global_var_entry {
690 : char *vname;
691 : sql_schema *s;
692 : } global_var_entry;
693 :
694 : static str
695 185 : RAstatement2_return(backend *be, mvc *m, int nlevels, struct global_var_entry *gvars, int gentries, str msg)
696 : {
697 201 : while (nlevels) { /* clean added frames */
698 16 : stack_pop_frame(m);
699 16 : nlevels--;
700 : }
701 185 : for (int i = 0 ; i < gentries ; i++) { /* clean any added global variables */
702 0 : struct global_var_entry gv = gvars[i];
703 0 : (void) remove_global_var(m, gv.s, gv.vname);
704 : }
705 185 : sa_reset(m->ta);
706 185 : return RAcommit_statement(be, msg);
707 : }
708 :
709 : static void
710 1408 : subtype_from_string(mvc *sql, sql_subtype *st, char *type)
711 : {
712 1408 : unsigned digits = 0, scale = 0;
713 :
714 1408 : char *end = strchr(type, '(');
715 1408 : if (end) {
716 55 : end[0] = 0;
717 55 : digits = strtol(end+1, &end, 10);
718 55 : if (end && end[0] == ',')
719 5 : scale = strtol(end+1, NULL, 10);
720 : }
721 1408 : if (!sql_find_subtype(st, type, digits, scale)) {
722 2 : sql_type *t = mvc_bind_type(sql, type);
723 2 : if (t)
724 2 : sql_init_subtype(st, t, 0, 0);
725 : }
726 1409 : }
727 :
728 : str
729 187 : RAstatement2(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
730 : {
731 187 : int pos = 0, nlevels = 0, *lkeys = NULL, lcap = 0, lentries = 0, gcap = 0, gentries = 0;
732 187 : str mod = *getArgReference_str(stk, pci, 1);
733 187 : str nme = *getArgReference_str(stk, pci, 2);
734 187 : str expr = *getArgReference_str(stk, pci, 3);
735 187 : str sig = *getArgReference_str(stk, pci, 4);
736 187 : str types = pci->argc == 6 ? *getArgReference_str(stk, pci, 5) : NULL;
737 187 : backend *be = NULL;
738 187 : mvc *m = NULL;
739 187 : str msg = MAL_SUCCEED;
740 187 : sql_rel *rel;
741 187 : list *refs, *ops;
742 187 : struct local_var_entry *lvars = NULL;
743 187 : struct global_var_entry *gvars = NULL;
744 :
745 187 : if ((msg = getSQLContext(cntxt, mb, &m, &be)) != NULL)
746 : return msg;
747 187 : if ((msg = checkSQLContext(cntxt)) != NULL)
748 : return msg;
749 187 : if ((msg = SQLtrans(m)) != MAL_SUCCEED)
750 : return msg;
751 187 : if (!m->sa)
752 187 : m->sa = sa_create(m->pa);
753 187 : if (!m->sa)
754 0 : return RAstatement2_return(be, m, nlevels, gvars, gentries, createException(SQL,"RAstatement2",SQLSTATE(HY013) MAL_MALLOC_FAIL));
755 :
756 187 : ops = sa_list(m->sa);
757 215 : while (sig && *sig) {
758 29 : sql_schema *sh = NULL;
759 29 : sql_type *t = NULL;
760 29 : sql_subtype tpe;
761 29 : char *p, *vtype = NULL, *sch = NULL, *var = NULL;
762 29 : int d, s, level = strtol(sig, &p, 10);
763 :
764 28 : var = p+1;
765 28 : assert(*p == '"');
766 28 : p = parseIdent(p+1, var);
767 28 : p++;
768 28 : if (*p == '"') { /* global variable, parse schema and name */
769 3 : sch = var;
770 3 : var = p+1;
771 3 : p = parseIdent(p+1, var);
772 3 : p++;
773 : }
774 :
775 28 : assert(*p == ' ');
776 28 : p++; /* skip space and get type */
777 28 : vtype = p;
778 28 : p = strchr(p, '(');
779 28 : *p++ = '\0';
780 :
781 : /* get digits and scale */
782 28 : d = strtol(p, &p, 10);
783 28 : p++; /* skip , */
784 28 : s = strtol(p, &p, 10);
785 28 : p+=2; /* skip ) and , or ' ' */
786 28 : sig = p;
787 :
788 28 : if (!sql_find_subtype(&tpe, vtype, d, s)) {
789 6 : if (!(t = mvc_bind_type(m, vtype))) /* try an external type */
790 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));
791 6 : sql_init_subtype(&tpe, t, d, s);
792 : }
793 :
794 28 : if (sch) {
795 3 : assert(level == 0);
796 3 : if (!(sh = mvc_bind_schema(m, sch)))
797 0 : return RAstatement2_return(be, m, nlevels, gvars, gentries, createException(SQL,"RAstatement2",SQLSTATE(3F000) "No such schema '%s'", sch));
798 3 : if (!find_global_var(m, sh, var)) { /* don't add the same global variable again */
799 0 : if (!push_global_var(m, sch, var, &tpe)) /* if doesn't exist, add it, then remove it before returning */
800 0 : return RAstatement2_return(be, m, nlevels, gvars, gentries, createException(SQL,"RAstatement2",SQLSTATE(HY013) MAL_MALLOC_FAIL));
801 0 : if (gentries == gcap) {
802 0 : if (gcap == 0) {
803 0 : gcap = 8;
804 0 : gvars = SA_NEW_ARRAY(m->ta, struct global_var_entry, gcap);
805 : } else {
806 0 : int ngcap = gcap * 4;
807 0 : gvars = SA_RENEW_ARRAY(m->ta, struct global_var_entry, gvars, ngcap, gcap);
808 : gcap = ngcap;
809 : }
810 0 : gvars[gentries++] = (struct global_var_entry) {.s = sh, .vname = var,};
811 : }
812 : }
813 3 : list_append(ops, exp_var(m->sa, sa_strdup(m->sa, sch), sa_strdup(m->sa, var), &tpe, 0));
814 : } else {
815 25 : char opname[BUFSIZ];
816 :
817 25 : if (lentries == lcap) {
818 13 : if (lcap == 0) {
819 13 : lcap = 8;
820 13 : lkeys = SA_NEW_ARRAY(m->ta, int, lcap);
821 13 : lvars = SA_NEW_ARRAY(m->ta, struct local_var_entry, lcap);
822 : } else {
823 0 : int nlcap = lcap * 4;
824 0 : lkeys = SA_RENEW_ARRAY(m->ta, int, lkeys, nlcap, lcap);
825 0 : lvars = SA_RENEW_ARRAY(m->ta, struct local_var_entry, lvars, nlcap, lcap);
826 : lcap = nlcap;
827 : }
828 : }
829 25 : lkeys[lentries] = level;
830 25 : lvars[lentries] = (struct local_var_entry) {.tpe = tpe, .vname = var,};
831 25 : lentries++;
832 :
833 25 : snprintf(opname, BUFSIZ, "%d%%%s", level, var); /* engineering trick */
834 25 : list_append(ops, exp_var(m->sa, NULL, sa_strdup(m->sa, opname), &tpe, level));
835 : }
836 : }
837 186 : if (lentries) {
838 13 : GDKqsort(lkeys, lvars, NULL, lentries, sizeof(int), sizeof(struct local_var_entry), TYPE_int, false, false);
839 :
840 38 : for (int i = 0 ; i < lentries ; i++) {
841 25 : int next_level = lkeys[i];
842 25 : struct local_var_entry next_val = lvars[i];
843 :
844 25 : assert(next_level != 0); /* no global variables here */
845 41 : while (nlevels < next_level) { /* add gap levels */
846 16 : if (!stack_push_frame(m, NULL))
847 0 : return RAstatement2_return(be, m, nlevels, gvars, gentries, createException(SQL,"RAstatement2",SQLSTATE(HY013) MAL_MALLOC_FAIL));
848 16 : nlevels++;
849 : }
850 25 : if (!frame_push_var(m, next_val.vname, &next_val.tpe))
851 0 : return RAstatement2_return(be, m, nlevels, gvars, gentries, createException(SQL,"RAstatement2",SQLSTATE(HY013) MAL_MALLOC_FAIL));
852 : }
853 : }
854 :
855 186 : refs = sa_list(m->sa);
856 186 : rel = rel_read(m, expr, &pos, refs);
857 185 : if (rel)
858 181 : rel = sql_processrelation(m, rel, 0, 1, 0, 0);
859 181 : if (!rel) {
860 4 : if (strlen(m->errstr) > 6 && m->errstr[5] == '!')
861 4 : msg = createException(SQL, "RAstatement2", "%s", m->errstr);
862 : else
863 0 : msg = createException(SQL, "RAstatement2", SQLSTATE(42000) "%s", m->errstr);
864 181 : } else if (rel && types && is_simple_project(rel->op)) { /* Test if types match */
865 181 : list *types_list = sa_list(m->sa);
866 180 : str token, rest;
867 :
868 1589 : for (token = strtok_r(types, "%", &rest); token; token = strtok_r(NULL, "%", &rest))
869 1410 : list_append(types_list, token);
870 :
871 182 : if (list_length(types_list) != list_length(rel->exps))
872 0 : msg = createException(SQL, "RAstatement2", SQLSTATE(42000) "The number of projections don't match between the generated plan and the expected one: %d != %d",
873 : list_length(types_list), list_length(rel->exps));
874 : else {
875 180 : int i = 1;
876 1588 : for (node *n = rel->exps->h, *m = types_list->h ; n && m && !msg ; n = n->next, m = m->next) {
877 1408 : sql_exp *e = n->data, *ne = NULL;
878 1408 : sql_subtype *t = exp_subtype(e), et;
879 :
880 1408 : subtype_from_string(be->mvc, &et, m->data);
881 1409 : if (!is_subtype(t, &et) && (ne = exp_check_type(be->mvc, &et, rel, e, type_equal)) == NULL) {
882 0 : str got = sql_subtype_string(be->mvc->ta, t), expected = (str) m->data;
883 0 : if (!got)
884 0 : msg = createException(SQL, "RAstatement2", SQLSTATE(HY013) MAL_MALLOC_FAIL);
885 0 : msg = createException(SQL, "RAstatement2", SQLSTATE(42000) "Parameter %d has wrong SQL type, expected %s, but got %s instead", i, expected, got);
886 : }
887 0 : if (ne) {
888 3 : exp_setname(be->mvc, ne, exp_relname(e), exp_name(e));
889 3 : n->data = ne;
890 : }
891 1408 : i++;
892 : }
893 : }
894 : }
895 184 : if (!msg && monet5_create_relational_function(m, mod, nme, rel, NULL, ops, 0) < 0)
896 0 : msg = createException(SQL, "RAstatement2", "%s", m->errstr);
897 185 : rel_destroy(rel);
898 186 : return RAstatement2_return(be, m, nlevels, gvars, gentries, msg);
899 : }
900 :
901 : str
902 187 : RAstatementEnd(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
903 : {
904 187 : backend *be = NULL;
905 187 : mvc *m = NULL;
906 187 : str msg = MAL_SUCCEED;
907 :
908 187 : (void) stk;
909 187 : (void) pci;
910 187 : if ((msg = getSQLContext(cntxt, mb, &m, &be)) != NULL)
911 : return msg;
912 187 : if ((msg = checkSQLContext(cntxt)) != NULL)
913 : return msg;
914 :
915 187 : sqlcleanup(be, 0);
916 187 : return SQLautocommit(m);
917 : }
|
