Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : #include "monetdb_config.h"
14 : #include "rel_psm.h"
15 : #include "rel_semantic.h"
16 : #include "rel_schema.h"
17 : #include "rel_select.h"
18 : #include "rel_rel.h"
19 : #include "rel_basetable.h"
20 : #include "rel_exp.h"
21 : #include "rel_updates.h"
22 : #include "sql_privileges.h"
23 :
24 : #define psm_zero_or_one(exp) \
25 : do { \
26 : if (exp && exp->card > CARD_AGGR) { \
27 : sql_subfunc *zero_or_one = sql_bind_func(sql, "sys", "zero_or_one", exp_subtype(exp), NULL, F_AGGR, true, true); \
28 : assert(zero_or_one); \
29 : exp = exp_aggr1(sql->sa, exp, zero_or_one, 0, 0, CARD_ATOM, has_nil(exp)); \
30 : } \
31 : } while(0)
32 :
33 : static list *sequential_block(sql_query *query, sql_subtype *restype, list *restypelist, dlist *blk, char *opt_name, int is_func);
34 :
35 : sql_rel *
36 23011 : rel_psm_block(allocator *sa, list *l)
37 : {
38 23011 : if (l) {
39 23009 : sql_rel *r = rel_create(sa);
40 23009 : if(!r)
41 : return NULL;
42 :
43 23009 : r->op = op_ddl;
44 23009 : r->flag = ddl_psm;
45 23009 : r->exps = l;
46 23009 : return r;
47 : }
48 : return NULL;
49 : }
50 :
51 : sql_rel *
52 9320 : rel_psm_stmt(allocator *sa, sql_exp *e)
53 : {
54 9320 : if (e) {
55 9282 : list *l = sa_list(sa);
56 9282 : if(!l)
57 : return NULL;
58 :
59 9282 : list_append(l, e);
60 9282 : return rel_psm_block(sa, l);
61 : }
62 : return NULL;
63 : }
64 :
65 : /* SET [ schema '.' ] variable = value and set ( [ schema1 '.' ] variable1, .., [ schemaN '.' ] variableN) = (query) */
66 : static sql_exp *
67 14697 : psm_set_exp(sql_query *query, dnode *n)
68 : {
69 14697 : mvc *sql = query->sql;
70 14697 : dlist *qname = n->data.lval;
71 14697 : symbol *val = n->next->data.sym;
72 14697 : sql_exp *res = NULL, *e = NULL;
73 14697 : int level = 0, single = (qname->h->type == type_string);
74 14697 : sql_rel *rel = NULL;
75 14697 : sql_subtype *tpe;
76 :
77 14697 : if (single) {
78 14691 : exp_kind ek = {type_value, card_value, FALSE};
79 14691 : const char *sname = qname_schema(qname);
80 14691 : const char *vname = qname_schema_object(qname);
81 14691 : sql_var *var = NULL;
82 14691 : sql_arg *a = NULL;
83 :
84 14691 : if (!find_variable_on_scope(sql, sname, vname, &var, &a, &tpe, &level, "SET"))
85 29 : return NULL;
86 14671 : if (!(e = rel_value_exp2(query, &rel, val, sql_sel | sql_psm, ek)))
87 : return NULL;
88 14663 : psm_zero_or_one(e);
89 :
90 14663 : if (!(e = exp_check_type(sql, tpe, rel, e, type_cast)))
91 : return NULL;
92 15521 : res = exp_set(sql->sa, var && var->sname ? sa_strdup(sql->sa, var->sname) : NULL, sa_strdup(sql->sa, vname), e, level);
93 : } else { /* multi assignment */
94 6 : exp_kind ek = {type_relation, card_value, FALSE};
95 6 : sql_rel *rel_val = rel_subquery(query, val, ek);
96 6 : dlist *vars = n->data.lval;
97 6 : dnode *m;
98 6 : node *n;
99 6 : list *b;
100 :
101 6 : if (!rel_val)
102 0 : return NULL;
103 6 : if (!is_project(rel_val->op))
104 0 : return sql_error(sql, 02, SQLSTATE(42000) "SET: The subquery is not a projection");
105 6 : if (dlist_length(vars) != list_length(rel_val->exps))
106 0 : return sql_error(sql, 02, SQLSTATE(42000) "SET: Number of variables not equal to number of supplied values");
107 6 : rel_val = rel_return_zero_or_one(sql, rel_val, ek);
108 :
109 6 : b = sa_list(sql->sa);
110 6 : append(b, exp_rel(sql, rel_val));
111 :
112 18 : for (m = vars->h, n = rel_val->exps->h; n && m; n = n->next, m = m->next) {
113 12 : dlist *nqname = m->data.lval;
114 12 : const char *sname = qname_schema(nqname);
115 12 : const char *vname = qname_schema_object(nqname);
116 12 : sql_exp *v = n->data;
117 12 : sql_var *var = NULL;
118 12 : sql_arg *a = NULL;
119 :
120 12 : if (!find_variable_on_scope(sql, sname, vname, &var, &a, &tpe, &level, "SET"))
121 0 : return NULL;
122 :
123 12 : v = exp_ref(sql, v);
124 12 : if (!(v = exp_check_type(sql, tpe, rel_val, v, type_cast)))
125 : return NULL;
126 12 : append(b, exp_set(sql->sa, var && var->sname ? sa_strdup(sql->sa, var->sname) : NULL, sa_strdup(sql->sa, vname), v, level));
127 : }
128 6 : res = exp_rel(sql, rel_psm_block(sql->sa, b));
129 : }
130 : return res;
131 : }
132 :
133 : static sql_exp*
134 10562 : rel_psm_call(sql_query * query, symbol *se)
135 : {
136 10562 : mvc *sql = query->sql;
137 10562 : sql_subtype *t;
138 10562 : sql_exp *res = NULL;
139 10562 : exp_kind ek = {type_value, card_none, FALSE};
140 10562 : sql_rel *rel = NULL;
141 :
142 10562 : res = rel_value_exp(query, &rel, se, sql_sel | psm_call, ek);
143 10562 : if (!res || rel || ((t=exp_subtype(res)) && t->type)) /* only procedures */
144 21 : return sql_error(sql, 01, SQLSTATE(42000) "Function calls are ignored");
145 : return res;
146 : }
147 :
148 : static list *
149 8323 : rel_psm_declare(mvc *sql, dnode *n)
150 : {
151 8323 : list *l = sa_list(sql->sa);
152 :
153 17797 : while (n) { /* list of 'identfiers with type' */
154 9477 : dnode *ids = n->data.sym->data.lval->h->data.lval->h;
155 9477 : sql_subtype *ctype = &n->data.sym->data.lval->h->next->data.typeval;
156 18972 : while (ids) {
157 9498 : dlist *qname = ids->data.lval;
158 9498 : const char *sname = qname_schema(qname);
159 9498 : const char *tname = qname_schema_object(qname);
160 9498 : sql_exp *r = NULL;
161 :
162 9498 : if (sname)
163 1 : return sql_error(sql, 01, SQLSTATE(42000) "DECLARE: Declared variables don't have a schema");
164 : /* find if there's a parameter with the same name */
165 9497 : if (sql->frame == 1 && sql_bind_param(sql, tname) >= 0)
166 2 : return sql_error(sql, 01, SQLSTATE(42000) "DECLARE: Variable '%s' declared as a parameter", tname);
167 : /* check if we overwrite a scope local variable declare x; declare x; */
168 9495 : if (frame_find_var(sql, tname))
169 0 : return sql_error(sql, 01, SQLSTATE(42000) "DECLARE: Variable '%s' already declared", tname);
170 : /* variables are put on stack, globals on a separate list */
171 9495 : if (!frame_push_var(sql, tname, ctype))
172 0 : return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
173 9495 : r = exp_var(sql->sa, NULL, sa_strdup(sql->sa, tname), ctype, sql->frame);
174 9495 : append(l, r);
175 9495 : ids = ids->next;
176 : }
177 9474 : n = n->next;
178 : }
179 : return l;
180 : }
181 :
182 : static sql_exp *
183 122 : rel_psm_declare_table(sql_query *query, dnode *n)
184 : {
185 122 : mvc *sql = query->sql;
186 122 : sql_rel *rel = NULL, *baset = NULL;
187 122 : dlist *qname = n->next->data.lval;
188 122 : const char *sname = qname_schema(qname);
189 122 : const char *name = qname_schema_object(qname);
190 122 : sql_table *t;
191 :
192 122 : if (sname)
193 1 : return sql_error(sql, 01, SQLSTATE(42000) "DECLARE TABLE: Declared tables don't have a schema");
194 :
195 121 : assert(n->next->next->next->type == type_int);
196 242 : rel = rel_create_table(query, SQL_DECLARED_TABLE, sname, name, false, n->next->next->data.sym,
197 : n->next->next->next->data.i_val, NULL, NULL, NULL, false, NULL,
198 121 : n->next->next->next->next->next->next->data.i_val);
199 :
200 121 : if (!rel)
201 : return NULL;
202 119 : if (rel->op == op_ddl) {
203 : baset = rel;
204 3 : } else if (rel->op == op_insert) {
205 3 : baset = rel->l;
206 : } else {
207 0 : assert(0);
208 : }
209 119 : assert(baset->flag == ddl_create_table);
210 119 : t = (sql_table*)((atom*)((sql_exp*)baset->exps->t->data)->l)->data.val.pval;
211 119 : if (!frame_push_table(sql, t))
212 0 : return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
213 119 : return exp_table(sql->sa, sa_strdup(sql->sa, name), t, sql->frame);
214 : }
215 :
216 : /* [ label: ]
217 : while (cond) do
218 : statement_list
219 : end [ label ]
220 : currently we only parse the labels, they cannot be used as there is no
221 :
222 : support for LEAVE and ITERATE (sql multi-level break and continue)
223 : */
224 : static sql_exp *
225 1019 : rel_psm_while_do( sql_query *query, sql_subtype *res, list *restypelist, dnode *w, int is_func )
226 : {
227 1019 : mvc *sql = query->sql;
228 1019 : if (!w)
229 : return NULL;
230 1019 : if (w->type == type_symbol) {
231 1019 : sql_exp *cond;
232 1019 : list *whilestmts;
233 1019 : dnode *n = w;
234 1019 : sql_rel *rel = NULL;
235 1019 : exp_kind ek = {type_value, card_value, FALSE};
236 :
237 1019 : if (!(cond = rel_logical_value_exp(query, &rel, n->data.sym, sql_sel | sql_psm, ek)))
238 : return NULL;
239 1019 : psm_zero_or_one(cond);
240 1019 : n = n->next;
241 1019 : if (!(whilestmts = sequential_block(query, res, restypelist, n->data.lval, n->next->data.sval, is_func)))
242 : return NULL;
243 :
244 1019 : return exp_while( sql->sa, cond, whilestmts );
245 : }
246 : return NULL;
247 : }
248 :
249 : /* if (cond) then statement_list
250 : [ elseif (cond) then statement_list ]*
251 : [ else statement_list ]
252 : end if
253 : */
254 : static list *
255 11563 : psm_if_then_else( sql_query *query, sql_subtype *res, list *restypelist, dnode *elseif, int is_func)
256 : {
257 11563 : mvc *sql = query->sql;
258 11563 : if (!elseif)
259 : return NULL;
260 11563 : assert(elseif->type == type_symbol);
261 11563 : if (elseif->data.sym && elseif->data.sym->token == SQL_IF) {
262 7 : sql_exp *cond;
263 7 : list *ifstmts, *elsestmts;
264 7 : dnode *n = elseif->data.sym->data.lval->h;
265 7 : sql_rel *rel = NULL;
266 7 : exp_kind ek = {type_value, card_value, FALSE};
267 :
268 7 : if (!(cond = rel_logical_value_exp(query, &rel, n->data.sym, sql_sel | sql_psm, ek)))
269 : return NULL;
270 7 : psm_zero_or_one(cond);
271 7 : n = n->next;
272 7 : if (!(ifstmts = sequential_block(query, res, restypelist, n->data.lval, NULL, is_func)))
273 : return NULL;
274 7 : n = n->next;
275 7 : elsestmts = psm_if_then_else( query, res, restypelist, n, is_func);
276 7 : if (sql->session->status)
277 : return NULL;
278 :
279 7 : return append(sa_list(sql->sa), exp_if( sql->sa, cond, ifstmts, elsestmts));
280 : } else { /* else */
281 11556 : symbol *e = elseif->data.sym;
282 :
283 11556 : if (e==NULL || (e->token != SQL_ELSE))
284 : return NULL;
285 1424 : return sequential_block(query, res, restypelist, e->data.lval, NULL, is_func);
286 : }
287 : }
288 :
289 : static sql_exp *
290 11557 : rel_psm_if_then_else( sql_query *query, sql_subtype *res, list *restypelist, dnode *elseif, int is_func)
291 : {
292 11557 : mvc *sql = query->sql;
293 11557 : if (!elseif)
294 : return NULL;
295 11557 : if (elseif->next && elseif->type == type_symbol) { /* if or elseif */
296 11557 : sql_exp *cond;
297 11557 : list *ifstmts, *elsestmts;
298 11557 : dnode *n = elseif;
299 11557 : sql_rel *rel = NULL;
300 11557 : exp_kind ek = {type_value, card_value, FALSE};
301 :
302 11557 : if (!(cond = rel_logical_value_exp(query, &rel, n->data.sym, sql_sel | sql_psm, ek)))
303 : return NULL;
304 11557 : psm_zero_or_one(cond);
305 11557 : n = n->next;
306 11557 : if (!(ifstmts = sequential_block(query, res, restypelist, n->data.lval, NULL, is_func)))
307 : return NULL;
308 11556 : n = n->next;
309 11556 : elsestmts = psm_if_then_else( query, res, restypelist, n, is_func);
310 11556 : if (sql->session->status)
311 : return NULL;
312 :
313 11556 : return exp_if( sql->sa, cond, ifstmts, elsestmts);
314 : }
315 : return NULL;
316 : }
317 :
318 : /* 1
319 : CASE
320 : WHEN search_condition THEN statements
321 : [ WHEN search_condition THEN statements ]
322 : [ ELSE statements ]
323 : END CASE
324 :
325 : 2
326 : CASE case_value
327 : WHEN when_value THEN statements
328 : [ WHEN when_value THEN statements ]
329 : [ ELSE statements ]
330 : END CASE
331 : */
332 : static sql_exp *
333 59 : rel_psm_case( sql_query *query, sql_subtype *res, list *restypelist, dnode *case_when, int is_func )
334 : {
335 59 : mvc *sql = query->sql;
336 59 : sql_exp *case_stmt = NULL, *last_if = NULL, *ifst = NULL;
337 59 : list *else_stmt = NULL;
338 :
339 59 : if (!case_when)
340 : return NULL;
341 :
342 : /* case 1 */
343 59 : if (case_when->type == type_symbol) {
344 12 : dnode *n = case_when;
345 12 : symbol *case_value = n->data.sym;
346 12 : dlist *when_statements = n->next->data.lval;
347 12 : dlist *else_statements = n->next->next->data.lval;
348 12 : sql_rel *rel = NULL;
349 12 : exp_kind ek = {type_value, card_value, FALSE};
350 12 : sql_exp *v = rel_value_exp(query, &rel, case_value, sql_sel | sql_psm, ek);
351 :
352 12 : psm_zero_or_one(v);
353 0 : if (!v)
354 0 : return NULL;
355 12 : if (else_statements && !(else_stmt = sequential_block(query, res, restypelist, else_statements, NULL, is_func)))
356 : return NULL;
357 :
358 12 : n = when_statements->h;
359 60 : while(n) {
360 48 : dnode *m = n->data.sym->data.lval->h;
361 48 : sql_exp *cond=0, *when_value = rel_value_exp(query, &rel, m->data.sym, sql_sel | sql_psm, ek);
362 48 : list *if_stmts = NULL;
363 :
364 48 : psm_zero_or_one(when_value);
365 0 : if (!when_value ||
366 48 : (cond = rel_binop_(sql, rel, v, when_value, "sys", "=", card_value, false)) == NULL ||
367 48 : (if_stmts = sequential_block(query, res, restypelist, m->next->data.lval, NULL, is_func)) == NULL ) {
368 0 : return NULL;
369 : }
370 48 : psm_zero_or_one(cond);
371 48 : ifst = exp_if(sql->sa, cond, if_stmts, NULL);
372 48 : if (last_if) { /* chain if statements for case, keep the last if */
373 36 : last_if->f = list_append(sa_list(sql->sa), ifst);
374 36 : last_if = ifst;
375 : } else {
376 : case_stmt = last_if = ifst;
377 : }
378 48 : n = n->next;
379 : }
380 : } else {
381 : /* case 2 */
382 47 : dnode *n = case_when;
383 47 : dlist *whenlist = n->data.lval;
384 47 : dlist *else_statements = n->next->data.lval;
385 :
386 47 : if (else_statements && !(else_stmt = sequential_block(query, res, restypelist, else_statements, NULL, is_func)))
387 : return NULL;
388 :
389 47 : n = whenlist->h;
390 97 : while(n) {
391 50 : dnode *m = n->data.sym->data.lval->h;
392 50 : sql_rel *rel = NULL;
393 50 : exp_kind ek = {type_value, card_value, FALSE};
394 50 : sql_exp *cond = rel_logical_value_exp(query, &rel, m->data.sym, sql_sel | sql_psm, ek);
395 50 : list *if_stmts = NULL;
396 :
397 50 : psm_zero_or_one(cond);
398 0 : if (!cond ||
399 50 : (if_stmts = sequential_block(query, res, restypelist, m->next->data.lval, NULL, is_func)) == NULL ) {
400 0 : return NULL;
401 : }
402 50 : ifst = exp_if(sql->sa, cond, if_stmts, NULL);
403 50 : if (last_if) { /* chain if statements for case, keep the last if */
404 3 : last_if->f = list_append(sa_list(sql->sa), ifst);
405 3 : last_if = ifst;
406 : } else {
407 : case_stmt = last_if = ifst;
408 : }
409 50 : n = n->next;
410 : }
411 : }
412 59 : if (else_stmt) {
413 51 : assert(case_stmt && last_if && !last_if->f);
414 51 : last_if->f = else_stmt;
415 : }
416 : return case_stmt;
417 : }
418 :
419 : /* return val;
420 : */
421 : static sql_exp *
422 23172 : rel_psm_return( sql_query *query, sql_subtype *restype, list *restypelist, symbol *return_sym )
423 : {
424 23172 : mvc *sql = query->sql;
425 23172 : exp_kind ek = {type_value, card_value, FALSE};
426 23172 : sql_exp *res = NULL;
427 23172 : sql_rel *rel = NULL;
428 23172 : bool requires_proj = false;
429 :
430 23172 : if (restypelist)
431 : ek.card = card_relation;
432 20338 : else if (return_sym->token == SQL_TABLE)
433 2 : return sql_error(sql, 02, SQLSTATE(42000) "RETURN: TABLE return not allowed for non table returning functions");
434 23170 : if (return_sym->token == SQL_COLUMN && restypelist) { /* RETURN x; where x is a reference to a table */
435 538 : dlist *l = return_sym->data.lval;
436 538 : const char *sname = qname_schema(l);
437 538 : const char *tname = qname_schema_object(l);
438 538 : sql_table *t = NULL;
439 :
440 538 : if (!(t = find_table_or_view_on_scope(sql, NULL, sname, tname, "RETURN", false)))
441 : return NULL;
442 537 : if (isDeclaredTable(t)) {
443 60 : rel = rel_table(sql, ddl_create_table, "sys", t, SQL_DECLARED_TABLE);
444 : } else {
445 477 : rel = rel_basetable(sql, t, t->base.name);
446 477 : rel = rel_base_add_columns(sql, rel);
447 : }
448 : } else { /* other cases */
449 22632 : res = rel_value_exp2(query, &rel, return_sym, sql_sel, ek);
450 22632 : if (!res)
451 : return NULL;
452 22622 : if (!rel && exp_is_rel(res)) {
453 6381 : rel = exp_rel_get_rel(sql->sa, res);
454 6381 : if (rel && !restypelist && !is_groupby(rel->op)) { /* On regular functions return zero or 1 rows for every row */
455 4303 : rel->card = CARD_MULTI;
456 4303 : rel = rel_return_zero_or_one(sql, rel, ek);
457 4303 : if (list_length(rel->exps) != 1)
458 0 : return sql_error(sql, 02, SQLSTATE(42000) "RETURN: must return a single column");
459 4303 : res = exp_ref(sql, (sql_exp*) rel->exps->t->data);
460 4303 : requires_proj = true;
461 : }
462 : }
463 : }
464 :
465 23159 : if (ek.card != card_relation && (!restype || (res = exp_check_type(sql, restype, rel, res, type_equal)) == NULL))
466 0 : return (!restype)?sql_error(sql, 02, SQLSTATE(42000) "RETURN: return type does not match"):NULL;
467 23159 : else if (ek.card == card_relation && !rel)
468 : return NULL;
469 :
470 23159 : if (requires_proj) {
471 4303 : rel = rel_project(sql->sa, rel, list_append(sa_list(sql->sa), res));
472 4303 : res = exp_rel(sql, rel);
473 : }
474 :
475 25926 : if (rel && !is_ddl(rel->op) && ek.card == card_relation) {
476 2768 : list *exps = sa_list(sql->sa), *oexps = rel->exps;
477 2768 : node *n, *m;
478 2768 : int isproject = (rel->op == op_project);
479 2768 : sql_rel *l = rel->l, *oexps_rel = rel;
480 :
481 2768 : if (is_topn(rel->op) || is_sample(rel->op)) {
482 14 : oexps_rel = l;
483 14 : oexps = l->exps;
484 : }
485 2768 : if (list_length(oexps) != list_length(restypelist))
486 1 : return sql_error(sql, 02, SQLSTATE(42000) "RETURN: number of columns do not match");
487 14000 : for (n = oexps->h, m = restypelist->h; n && m; n = n->next, m = m->next) {
488 11233 : sql_exp *e = n->data;
489 11233 : sql_arg *ce = m->data;
490 11233 : const char *cname = exp_name(e);
491 11233 : char name[16];
492 :
493 11233 : if (!cname)
494 106 : cname = sa_strdup(sql->sa, number2name(name, sizeof(name), ++sql->label));
495 11233 : if (!isproject)
496 1055 : e = exp_ref(sql, e);
497 11233 : e = exp_check_type(sql, &ce->type, oexps_rel, e, type_equal);
498 11233 : if (!e)
499 0 : return NULL;
500 11233 : append(exps, e);
501 : }
502 2767 : if (isproject)
503 2231 : rel->exps = exps;
504 : else
505 536 : rel = rel_project(sql->sa, rel, exps);
506 2767 : res = exp_rel(sql, rel);
507 20391 : } else if (rel && restypelist) { /* handle return table-var */
508 60 : list *exps = sa_list(sql->sa);
509 60 : sql_rel *bt = rel_ddl_basetable_get(rel);
510 60 : sql_table *t = rel_ddl_table_get(rel);
511 60 : node *n, *m;
512 60 : const char *tname = t->base.name;
513 :
514 60 : if (ol_length(t->columns) != list_length(restypelist))
515 1 : return sql_error(sql, 02, SQLSTATE(42000) "RETURN: number of columns do not match");
516 188 : for (n = ol_first_node(t->columns), m = restypelist->h; n && m; n = n->next, m = m->next) {
517 129 : sql_column *c = n->data;
518 129 : sql_arg *ce = m->data;
519 129 : sql_exp *e = exp_column(sql->sa, tname, c->base.name, &c->type, CARD_MULTI, c->null, is_column_unique(c), 0);
520 129 : e->nid = rel_base_nid(bt, c);
521 129 : e->alias.label = e->nid;
522 :
523 129 : e = exp_check_type(sql, &ce->type, rel, e, type_equal);
524 129 : if (!e)
525 : return NULL;
526 129 : append(exps, e);
527 : }
528 59 : rel = rel_project(sql->sa, rel, exps);
529 59 : res = exp_rel(sql, rel);
530 : }
531 23157 : res = exp_return(sql->sa, res, stack_nr_of_declared_tables(sql));
532 23157 : if (ek.card != card_relation)
533 20331 : res->card = CARD_ATOM;
534 : else
535 2826 : res->card = CARD_MULTI;
536 : return res;
537 : }
538 :
539 : static list *
540 1469 : rel_select_into( sql_query *query, symbol *sq, exp_kind ek)
541 : {
542 1469 : mvc *sql = query->sql;
543 1469 : SelectNode *sn = (SelectNode*)sq;
544 1469 : dlist *into = sn->into;
545 1469 : node *m;
546 1469 : dnode *n;
547 1469 : sql_rel *r;
548 1469 : list *nl = NULL;
549 :
550 : /* SELECT ... INTO var_list */
551 1469 : sn->into = NULL;
552 1469 : r = rel_subquery(query, sq, ek);
553 1469 : if (!r)
554 : return NULL;
555 1469 : if (!is_project(r->op))
556 0 : return sql_error(sql, 02, SQLSTATE(42000) "SELECT INTO: The subquery is not a projection");
557 1469 : if (list_length(r->exps) != dlist_length(into))
558 2 : return sql_error(sql, 02, SQLSTATE(21S01) "SELECT INTO: number of values doesn't match number of variables to set");
559 1467 : r = rel_return_zero_or_one(sql, r, ek);
560 1467 : nl = sa_list(sql->sa);
561 1467 : append(nl, exp_rel(sql, r));
562 2941 : for (m = r->exps->h, n = into->h; m && n; m = m->next, n = n->next) {
563 1474 : dlist *qname = n->data.lval;
564 1474 : const char *sname = qname_schema(qname);
565 1474 : const char *vname = qname_schema_object(qname);
566 1474 : sql_exp *v = m->data;
567 1474 : int level;
568 1474 : sql_var *var;
569 1474 : sql_subtype *tpe;
570 1474 : sql_arg *a = NULL;
571 :
572 1474 : if (!find_variable_on_scope(sql, sname, vname, &var, &a, &tpe, &level, "SELECT INTO"))
573 0 : return NULL;
574 :
575 1474 : v = exp_ref(sql, v);
576 1474 : if (!(v = exp_check_type(sql, tpe, r, v, type_equal)))
577 : return NULL;
578 1474 : v = exp_set(sql->sa, var && var->sname ? sa_strdup(sql->sa, var->sname) : NULL, sa_strdup(sql->sa, vname), v, level);
579 1474 : list_append(nl, v);
580 : }
581 : return nl;
582 : }
583 :
584 : extern sql_rel *
585 1 : rel_select_with_into(sql_query *query, symbol *sq)
586 : {
587 1 : exp_kind ek = {type_relation, card_value, TRUE};
588 1 : list *reslist = rel_select_into(query, sq, ek);
589 1 : if (!reslist)
590 : return NULL;
591 0 : return rel_psm_block(query->sql->sa, reslist);
592 : }
593 :
594 : static int has_return( list *l );
595 :
596 : static int
597 20395 : exp_has_return(sql_exp *e)
598 : {
599 20395 : if (e->type == e_psm) {
600 19919 : if (e->flag & PSM_RETURN)
601 : return 1;
602 4236 : if (e->flag & PSM_IF) /* for if, both sides must exist and both must have a return */
603 5066 : return has_return(e->r) && e->f && has_return(e->f);
604 : }
605 : return 0;
606 : }
607 :
608 : static int
609 20395 : has_return( list *l )
610 : {
611 20395 : node *n = l->t;
612 :
613 : /* last statement of sequential block */
614 20395 : if (n && exp_has_return(n->data))
615 : return 1;
616 : return 0;
617 : }
618 :
619 : static list *
620 60 : psm_analyze(sql_query *query, dlist *qname, dlist *columns)
621 : {
622 60 : mvc *sql = query->sql;
623 60 : const char *sname = qname_schema(qname), *tname = qname_schema_object(qname);
624 60 : list *tl = sa_list(sql->sa), *exps = sa_list(sql->sa), *analyze_calls = sa_list(sql->sa);
625 60 : sql_subfunc *f = NULL;
626 60 : sql_subtype tpe;
627 :
628 60 : if (!sql_find_subtype(&tpe, "varchar", 1024, 0))
629 0 : return sql_error(sql, 02, SQLSTATE(HY013) "varchar type missing?");
630 :
631 60 : if (sname && tname) {
632 53 : sql_table *t = NULL;
633 :
634 53 : if (!(t = find_table_or_view_on_scope(sql, NULL, sname, tname, "ANALYZE", false)))
635 : return NULL;
636 53 : if (isDeclaredTable(t))
637 0 : return sql_error(sql, 02, SQLSTATE(42000) "Cannot analyze a declared table");
638 53 : sname = t->s->base.name;
639 : }
640 : /* call analyze( [schema, [ table ]] ) */
641 60 : if (sname) {
642 53 : sql_exp *sname_exp = exp_atom_str(sql->sa, sname, &tpe);
643 :
644 53 : list_append(exps, sname_exp);
645 53 : list_append(tl, exp_subtype(sname_exp));
646 : }
647 60 : if (tname) {
648 60 : sql_exp *tname_exp = exp_atom_str(sql->sa, tname, &tpe);
649 :
650 60 : list_append(exps, tname_exp);
651 60 : list_append(tl, exp_subtype(tname_exp));
652 :
653 60 : if (columns)
654 7 : list_append(tl, exp_subtype(tname_exp));
655 : }
656 60 : if (!(f = sql_bind_func_(sql, "sys", "analyze", tl, F_PROC, true, false)))
657 0 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "Analyze procedure missing");
658 60 : if (!execute_priv(sql, f->func))
659 0 : return sql_error(sql, 02, SQLSTATE(42000) "No privilege to call analyze procedure");
660 60 : if (!columns) {
661 53 : list_append(analyze_calls, exp_op(sql->sa, exps, f));
662 : } else {
663 7 : if (!sname || !tname)
664 2 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "Analyze schema or table name missing");
665 17 : for(dnode *n = columns->h; n; n = n->next) {
666 12 : const char *cname = n->data.sval;
667 12 : list *nexps = list_dup(exps, NULL);
668 12 : sql_exp *cname_exp = exp_atom_str(sql->sa, cname, &tpe);
669 :
670 12 : list_append(nexps, cname_exp);
671 : /* call analyze(sname, tname, cname) */
672 12 : list_append(analyze_calls, exp_op(sql->sa, nexps, f));
673 : }
674 : }
675 : return analyze_calls;
676 : }
677 :
678 : static list *
679 35428 : sequential_block(sql_query *query, sql_subtype *restype, list *restypelist, dlist *blk, char *opt_label, int is_func)
680 : {
681 35428 : mvc *sql = query->sql;
682 35428 : list *l=0;
683 35428 : dnode *n;
684 :
685 35428 : assert(!restype || !restypelist);
686 :
687 35428 : if (mvc_highwater(sql))
688 0 : return sql_error(sql, 10, SQLSTATE(42000) "Query too complex: running out of stack space");
689 :
690 35428 : if (blk->h)
691 35428 : l = sa_list(sql->sa);
692 35428 : if (!stack_push_frame(sql, opt_label))
693 0 : return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
694 115703 : for (n = blk->h; n; n = n->next ) {
695 80318 : sql_exp *res = NULL;
696 80318 : list *reslist = NULL;
697 80318 : symbol *s = n->data.sym;
698 :
699 80318 : switch (s->token) {
700 14304 : case SQL_SET:
701 14304 : res = psm_set_exp(query, s->data.lval->h);
702 14304 : break;
703 8323 : case SQL_DECLARE:
704 8323 : reslist = rel_psm_declare(sql, s->data.lval->h);
705 8323 : break;
706 122 : case SQL_DECLARE_TABLE:
707 : case SQL_CREATE_TABLE:
708 122 : res = rel_psm_declare_table(query, s->data.lval->h);
709 122 : break;
710 1019 : case SQL_WHILE:
711 1019 : res = rel_psm_while_do(query, restype, restypelist, s->data.lval->h, is_func);
712 1019 : break;
713 11557 : case SQL_IF:
714 11557 : res = rel_psm_if_then_else(query, restype, restypelist, s->data.lval->h, is_func);
715 11557 : break;
716 59 : case SQL_CASE:
717 59 : res = rel_psm_case(query, restype, restypelist, s->data.lval->h, is_func);
718 59 : break;
719 20 : case SQL_ANALYZE: {
720 20 : dlist *l = s->data.lval;
721 :
722 20 : reslist = psm_analyze(query, l->h->data.lval /* qualified table name */, l->h->next->data.lval /* opt list of column */);
723 20 : } break;
724 1841 : case SQL_CALL:
725 1841 : assert(s->type == type_symbol);
726 1841 : res = rel_psm_call(query, s->data.sym);
727 1841 : break;
728 23172 : case SQL_RETURN:
729 : /*If it is not a function it cannot have a return statement*/
730 23172 : if (!is_func)
731 0 : res = sql_error(sql, 01, SQLSTATE(42000) "Return statement in the procedure body");
732 23172 : else if (n->next) /* should be last statement of a sequential_block */
733 0 : res = sql_error(sql, 01, SQLSTATE(42000) "Statement after return");
734 : else
735 23172 : res = rel_psm_return(query, restype, restypelist, s->data.sym);
736 : break;
737 1468 : case SQL_SELECT: { /* row selections (into variables) */
738 1468 : exp_kind ek = {type_value, card_row, TRUE};
739 1468 : reslist = rel_select_into(query, s, ek);
740 1468 : } break;
741 18433 : case SQL_COPYFROM:
742 : case SQL_BINCOPYFROM:
743 : case SQL_INSERT:
744 : case SQL_UPDATE:
745 : case SQL_DELETE:
746 : case SQL_TRUNCATE:
747 : case SQL_MERGE: {
748 18433 : sql_rel *r = rel_updates(query, s);
749 18433 : if (!r) {
750 8 : stack_pop_frame(sql);
751 8 : return NULL;
752 : }
753 18425 : res = exp_rel(sql, r);
754 18425 : } break;
755 0 : default:
756 0 : res = sql_error(sql, 01, SQLSTATE(42000) "Statement '%s' is not a valid flow control statement",
757 : token2string(s->token));
758 : }
759 80310 : if (!res && !reslist) {
760 : l = NULL;
761 : break;
762 : }
763 80275 : if (res)
764 70468 : list_append(l, res);
765 : else
766 9807 : list_merge(l, reslist, NULL);
767 : }
768 35420 : stack_pop_frame(sql);
769 35420 : return l;
770 : }
771 :
772 : static int
773 630682 : arg_cmp(void *A, void *N)
774 : {
775 630682 : sql_arg *a = A;
776 630682 : char *name = N;
777 630682 : return strcmp(a->name, name);
778 : }
779 :
780 : static list *
781 204823 : result_type(mvc *sql, symbol *res)
782 : {
783 204823 : if (res->token == SQL_TYPE) {
784 179845 : sql_subtype *st = &res->data.lval->h->data.typeval;
785 179845 : sql_arg *a = sql_create_arg(sql->sa, "result", st, ARG_OUT);
786 :
787 179845 : return list_append(sa_list(sql->sa), a);
788 24978 : } else if (res->token == SQL_TABLE) {
789 24978 : sql_arg *a;
790 24978 : dnode *n = res->data.lval->h;
791 24978 : list *types = sa_list(sql->sa);
792 :
793 185474 : for(;n; n = n->next->next) {
794 135519 : sql_subtype *ct = &n->next->data.typeval;
795 :
796 135519 : if (list_find(types, n->data.sval, &arg_cmp) != NULL)
797 1 : return sql_error(sql, ERR_AMBIGUOUS, SQLSTATE(42000) "CREATE FUNC: identifier '%s' ambiguous", n->data.sval);
798 :
799 135518 : a = sql_create_arg(sql->sa, n->data.sval, ct, ARG_OUT);
800 135518 : list_append(types, a);
801 : }
802 : return types;
803 : }
804 : return NULL;
805 : }
806 :
807 : static list *
808 338506 : create_type_list(mvc *sql, dlist *params, int param)
809 : {
810 338506 : sql_subtype *par_subtype;
811 338506 : list * type_list = sa_list(sql->sa);
812 338506 : dnode * n = NULL;
813 :
814 338506 : if (params) {
815 858009 : for (n = params->h; n; n = n->next) {
816 537373 : dnode *an = n;
817 :
818 537373 : if (param) {
819 381001 : an = n->data.lval->h;
820 381001 : par_subtype = &an->next->data.typeval;
821 381001 : if (par_subtype && !par_subtype->type) /* var arg */
822 : return type_list;
823 380997 : list_append(type_list, par_subtype);
824 : } else {
825 156372 : par_subtype = &an->data.typeval;
826 156372 : list_prepend(type_list, par_subtype);
827 : }
828 : }
829 : }
830 : return type_list;
831 : }
832 :
833 : static sql_rel*
834 234687 : rel_create_function(allocator *sa, const char *sname, sql_func *f, int replace)
835 : {
836 234687 : sql_rel *rel = rel_create(sa);
837 234687 : list *exps = new_exp_list(sa);
838 234687 : if(!rel || !exps)
839 : return NULL;
840 :
841 234687 : append(exps, exp_atom_clob(sa, sname));
842 234687 : if (f)
843 234687 : append(exps, exp_atom_clob(sa, f->base.name));
844 234687 : append(exps, exp_atom_ptr(sa, f));
845 234687 : append(exps, exp_atom_int(sa, replace));
846 234687 : rel->l = NULL;
847 234687 : rel->r = NULL;
848 234687 : rel->op = op_ddl;
849 234687 : rel->flag = ddl_create_function;
850 234687 : rel->exps = exps;
851 234687 : rel->card = 0;
852 234687 : rel->nrcols = 0;
853 234687 : return rel;
854 : }
855 :
856 : static bool
857 234 : has_generic_decimal(list *types)
858 : {
859 234 : if (!list_empty(types)) {
860 439 : for(node *n = types->h; n; n = n->next) {
861 269 : sql_subtype *st = n->data;
862 :
863 269 : if (st->type->eclass == EC_DEC && !st->digits && !st->scale)
864 : return true;
865 : }
866 : }
867 : return false;
868 : }
869 :
870 : static bool
871 232 : has_generic_decimal_result(list *types)
872 : {
873 232 : if (!list_empty(types)) {
874 508 : for(node *n = types->h; n; n = n->next) {
875 289 : sql_arg *a = n->data;
876 :
877 289 : if (a->type.type->eclass == EC_DEC && !a->type.digits && !a->type.scale)
878 : return true;
879 : }
880 : }
881 : return false;
882 : }
883 :
884 :
885 : static sql_rel *
886 242896 : rel_create_func(sql_query *query, dlist *qname, dlist *params, symbol *res, dlist *ext_name, dlist *body, sql_ftype type, sql_flang lang, int replace)
887 : {
888 242896 : mvc *sql = query->sql;
889 242896 : const char *fname = qname_schema_object(qname);
890 242896 : const char *sname = qname_schema(qname);
891 242896 : sql_schema *s = cur_schema(sql);
892 242896 : sql_func *f = NULL;
893 242896 : sql_subfunc *sf = NULL;
894 242896 : dnode *n;
895 242896 : list *type_list = NULL, *restype = NULL, *l = NULL;
896 242896 : int instantiate = (sql->emode == m_instantiate);
897 242896 : int deps = (sql->emode == m_deps);
898 242896 : int create = (!instantiate && !deps);
899 242896 : bit vararg = FALSE, union_err = 0;
900 242896 : char *F = NULL, *fn = NULL, is_func, *q = QUERY(sql->scanner);
901 :
902 242896 : if (res && res->token == SQL_TABLE) {
903 24980 : if (type == F_FUNC)
904 : type = F_UNION;
905 : else
906 : union_err = 1;
907 : }
908 :
909 217917 : FUNC_TYPE_STR(type, F, fn)
910 :
911 242896 : is_func = (type != F_PROC && type != F_LOADER);
912 242896 : assert(lang != FUNC_LANG_INT);
913 :
914 242896 : if (create && store_readonly(sql->session->tr->store))
915 0 : return sql_error(sql, 06, SQLSTATE(42000) "Schema statements cannot be executed on a readonly database.");
916 :
917 242896 : if (union_err)
918 1 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: %ss cannot return tables", F, fn);
919 242895 : else if (res && type == F_PROC)
920 0 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: procedures cannot have return parameters", F);
921 242895 : else if (res && (type == F_FILT || type == F_LOADER))
922 0 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: %s functions don't have to specify a return type", F, fn);
923 38060 : else if (!res && !(type == F_PROC || type == F_FILT || type == F_LOADER))
924 0 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: %ss require a return type", F, fn);
925 242895 : else if (lang == FUNC_LANG_MAL && type == F_LOADER)
926 0 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: %s functions creation via MAL not supported", F, fn);
927 242895 : else if (lang == FUNC_LANG_SQL && !(type == F_FUNC || type == F_PROC || type == F_UNION))
928 0 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: %s functions creation via SQL not supported", F, fn);
929 242895 : else if (LANG_EXT(lang) && !(type == F_FUNC || type == F_AGGR || type == F_UNION || type == F_LOADER))
930 0 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: %ss creation via external programming languages not supported", F, fn);
931 :
932 242895 : if (sname && !(s = mvc_bind_schema(sql, sname)))
933 0 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(3F000) "CREATE %s: no such schema '%s'", F, sname);
934 242895 : if (create && !mvc_schema_privs(sql, s))
935 5 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: insufficient privileges for user '%s' in schema '%s'", F,
936 : get_string_global_var(sql, "current_user"), s->base.name);
937 :
938 242890 : type_list = create_type_list(sql, params, 1);
939 :
940 242890 : if ((sf = sql_bind_func_(sql, s->base.name, fname, type_list, type, true, true)) != NULL && create) {
941 31 : if (sf->func->private) { /* cannot create a function using a private name or replace a existing one */
942 2 : list_destroy(type_list);
943 2 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: name '%s' cannot be used", F, fname);
944 : }
945 29 : if (!replace && params) {
946 0 : char *arg_list = NULL;
947 0 : node *n;
948 :
949 0 : for (n = type_list->h; n; n = n->next) {
950 0 : char *tpe = sql_subtype_string(sql->ta, (sql_subtype *) n->data);
951 :
952 0 : if (arg_list) {
953 0 : arg_list = sa_message(sql->ta, "%s, %s", arg_list, tpe);
954 : } else {
955 : arg_list = tpe;
956 : }
957 : }
958 0 : (void)sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: name '%s' (%s) already in use", F, fname, arg_list ? arg_list : "");
959 0 : list_destroy(type_list);
960 0 : return NULL;
961 29 : } else if (!replace) {
962 2 : list_destroy(type_list);
963 2 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: name '%s' already in use", F, fname);
964 27 : } else if (replace && !sf->func->s) {
965 0 : list_destroy(type_list);
966 0 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: cannot replace system function '%s'", F, fname);
967 : }
968 : } else {
969 242859 : sql->session->status = 0; /* if the function was not found clean the error */
970 242859 : sql->errstr[0] = '\0';
971 : }
972 :
973 242886 : if (create && (type == F_FUNC || type == F_AGGR || type == F_FILT)) {
974 81720 : sql_subfunc *found = NULL;
975 108112 : if ((found = sql_bind_func_(sql, s->base.name, fname, type_list, (type == F_FUNC || type == F_FILT) ? F_AGGR : F_FUNC, true, true))) {
976 2 : list_destroy(type_list);
977 2 : if (found->func->private) /* cannot create a function using a private name or replace a existing one */
978 0 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: name '%s' cannot be used", F, fname);
979 2 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: there's %s with the name '%s' and the same parameters, which causes ambiguous calls", F,
980 2 : IS_AGGR(found->func) ? "an aggregate" : IS_FILT(found->func) ? "a filter function" : "a function", fname);
981 : }
982 81718 : sql->session->status = 0; /* if the function was not found clean the error */
983 81718 : sql->errstr[0] = '\0';
984 : }
985 242884 : if (lang > FUNC_LANG_SQL && has_generic_decimal(type_list))
986 2 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: the function '%s' uses a generic DECIMAL type, UDFs require precision and scale", F, fname);
987 :
988 242882 : list_destroy(type_list);
989 :
990 242882 : if (params) {
991 606011 : for (n = params->h; n; n = n->next) {
992 380993 : dnode *an = n->data.lval->h;
993 380993 : sql_add_param(sql, an->data.sval, &an->next->data.typeval);
994 : }
995 225018 : l = sql->params;
996 225018 : if (l && list_length(l) == 1) {
997 107492 : sql_arg *a = l->h->data;
998 :
999 107492 : if (strcmp(a->name, "*") == 0) {
1000 : l = NULL;
1001 : vararg = TRUE;
1002 : }
1003 : }
1004 : }
1005 : if (!l)
1006 17868 : l = sa_list(sql->sa);
1007 242882 : if (res && !(restype = result_type(sql, res)))
1008 1 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: failed to get restype", F);
1009 :
1010 242881 : if (lang > FUNC_LANG_SQL && has_generic_decimal_result(restype))
1011 2 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE %s: the function '%s' returns a generic DECIMAL type, UDFs require precision and scale", F, fname);
1012 242879 : if (body && LANG_EXT(lang)) {
1013 230 : const char *lang_body = body->h->data.sval, *mod = "unknown", *slang = "Unknown", *imp = "Unknown";
1014 230 : switch (lang) {
1015 : case FUNC_LANG_R:
1016 : mod = "rapi";
1017 : slang = "R";
1018 : break;
1019 43 : case FUNC_LANG_C:
1020 43 : mod = "capi";
1021 43 : slang = "C";
1022 43 : break;
1023 1 : case FUNC_LANG_CPP:
1024 1 : mod = "capi";
1025 1 : slang = "CPP";
1026 1 : break;
1027 0 : case FUNC_LANG_J:
1028 0 : mod = "japi";
1029 0 : slang = "Javascript";
1030 0 : break;
1031 149 : case FUNC_LANG_PY:
1032 : case FUNC_LANG_PY3:
1033 149 : mod = "pyapi3";
1034 149 : slang = "Python";
1035 149 : break;
1036 0 : default:
1037 0 : return sql_error(sql, 01, SQLSTATE(42000) "Function language without a MAL backend");
1038 : }
1039 230 : switch(type) {
1040 : case F_AGGR:
1041 : imp = "eval_aggr";
1042 : break;
1043 : case F_LOADER:
1044 11 : imp = "eval_loader";
1045 11 : break;
1046 : default: /* for every other function type at the moment */
1047 187 : imp = "eval";
1048 : }
1049 :
1050 198 : if (type == F_LOADER && !(lang == FUNC_LANG_PY || lang == FUNC_LANG_PY3))
1051 0 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: Language name \"Python[3]\" expected", F);
1052 :
1053 230 : sql->params = NULL;
1054 230 : if (create) {
1055 230 : bit side_effect = (list_empty(restype) || (!vararg && list_empty(l))); /* TODO make this more precise? */
1056 230 : switch (mvc_create_func(&f, sql, sql->sa, s, fname, l, restype, type, lang, mod, imp, lang_body, (type == F_LOADER)?TRUE:FALSE, vararg, FALSE, side_effect)) {
1057 0 : case -1:
1058 0 : return sql_error(sql, 01, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1059 0 : case -2:
1060 : case -3:
1061 0 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: transaction conflict detected", F);
1062 : default:
1063 : break;
1064 : }
1065 0 : } else if (!sf) {
1066 0 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: %s function %s.%s not bound", F, slang, s->base.name, fname);
1067 : }
1068 242649 : } else if (body) { /* SQL implementation */
1069 15797 : sql_arg *ra = (restype && type != F_UNION)?restype->h->data:NULL;
1070 15797 : list *b = NULL;
1071 15797 : sql_schema *os = cur_schema(sql);
1072 :
1073 15797 : if (create) { /* needed for recursive functions */
1074 7647 : bit side_effect = list_empty(restype) == 1; /* TODO make this more precise? */
1075 7647 : q = query_cleaned(sql->ta, q);
1076 7647 : switch (mvc_create_func(&f, sql, sql->sa, s, fname, l, restype, type, lang, sql_shared_module_name, NULL, q, FALSE, vararg, FALSE, side_effect)) {
1077 0 : case -1:
1078 0 : return sql_error(sql, 01, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1079 0 : case -2:
1080 : case -3:
1081 0 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: transaction conflict detected", F);
1082 : default:
1083 7647 : break;
1084 : }
1085 7647 : sql->forward = f;
1086 8150 : } else if (!sf) {
1087 0 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: SQL function %s.%s not bound", F, s->base.name, fname);
1088 : }
1089 15797 : sql->session->schema = s;
1090 15797 : b = sequential_block(query, (ra)?&ra->type:NULL, ra?NULL:restype, body, NULL, is_func);
1091 15797 : sql->forward = NULL;
1092 15797 : sql->session->schema = os;
1093 15797 : sql->params = NULL;
1094 15797 : if (!b)
1095 : return NULL;
1096 :
1097 : /* check if we have a return statement */
1098 15761 : if (is_func && restype && !has_return(b))
1099 4 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: missing return statement", F);
1100 15757 : if (!is_func && !restype && has_return(b))
1101 0 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: %ss cannot have return statements", F, fn);
1102 : /* in execute mode we instantiate the function */
1103 15757 : if (instantiate || deps)
1104 8148 : return rel_psm_block(sql->sa, b);
1105 : } else { /* MAL implementation */
1106 226852 : int clientid = sql->clientid;
1107 226852 : char *fmod = qname_module(ext_name);
1108 226852 : char *fnme = qname_schema_object(ext_name);
1109 :
1110 226852 : if (!fmod || !fnme)
1111 4 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: MAL module or function name missing", F);
1112 226852 : if (strlen(fmod) >= IDLENGTH)
1113 0 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: MAL module name '%s' too large for the backend", F, fmod);
1114 226852 : if (strlen(fnme) >= IDLENGTH)
1115 0 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: MAL function name '%s' too large for the backend", F, fnme);
1116 226852 : sql->params = NULL;
1117 226852 : if (create) {
1118 113428 : q = query_cleaned(sql->ta, q);
1119 113428 : switch (mvc_create_func(&f, sql, sql->sa, s, fname, l, restype, type, lang, fmod, fnme, q, FALSE, vararg, FALSE, FALSE)) {
1120 0 : case -1:
1121 4 : return sql_error(sql, 01, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1122 0 : case -2:
1123 : case -3:
1124 0 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: transaction conflict detected", F);
1125 : default:
1126 113428 : break;
1127 : }
1128 : /* instantiate MAL functions while being created. This also sets the side-effects flag */
1129 113428 : bool se = f->side_effect;
1130 113428 : if (!backend_resolve_function(&clientid, f, fnme, &se))
1131 4 : return sql_error(sql, 02, SQLSTATE(3F000) "CREATE %s: external name %s.%s not bound (%s.%s)", F, fmod, fnme, s->base.name, fname );
1132 113424 : f->side_effect = se;
1133 113424 : f->instantiated = TRUE;
1134 113424 : } else if (!sf) {
1135 0 : return sql_error(sql, 01, SQLSTATE(42000) "CREATE %s: external name %s.%s not bound (%s.%s)", F, fmod, fnme, s->base.name, fname );
1136 : }
1137 226848 : if (!f)
1138 113424 : f = sf->func;
1139 226848 : assert(f);
1140 : }
1141 234687 : return rel_create_function(sql->sa, s->base.name, f, replace);
1142 : }
1143 :
1144 : static sql_rel*
1145 670 : rel_drop_function(allocator *sa, const char *sname, const char *name, int nr, sql_ftype type, int action)
1146 : {
1147 670 : sql_rel *rel = rel_create(sa);
1148 670 : list *exps = new_exp_list(sa);
1149 670 : if(!rel || !exps)
1150 : return NULL;
1151 :
1152 670 : append(exps, exp_atom_clob(sa, sname));
1153 670 : append(exps, exp_atom_clob(sa, name));
1154 670 : append(exps, exp_atom_int(sa, nr));
1155 670 : append(exps, exp_atom_int(sa, (int) type));
1156 670 : append(exps, exp_atom_int(sa, action));
1157 670 : rel->l = NULL;
1158 670 : rel->r = NULL;
1159 670 : rel->op = op_ddl;
1160 670 : rel->flag = ddl_drop_function;
1161 670 : rel->exps = exps;
1162 670 : rel->card = 0;
1163 670 : rel->nrcols = 0;
1164 670 : return rel;
1165 : }
1166 :
1167 : sql_func *
1168 99955 : resolve_func(mvc *sql, const char *sname, const char *name, dlist *typelist, sql_ftype type, const char *op, int if_exists)
1169 : {
1170 99955 : sql_func *func = NULL;
1171 99955 : list *list_func = NULL, *type_list = NULL;
1172 99955 : char is_func = (type != F_PROC && type != F_LOADER), *F = NULL, *fn = NULL;
1173 :
1174 99955 : FUNC_TYPE_STR(type, F, fn)
1175 :
1176 99955 : if (typelist) {
1177 95616 : sql_subfunc *sub_func;
1178 :
1179 95616 : type_list = create_type_list(sql, typelist, 0);
1180 95616 : sub_func = sql_bind_func_(sql, sname, name, type_list, type, false, true);
1181 95616 : if (!sub_func && type == F_FUNC) {
1182 6037 : sql->session->status = 0; /* if the function was not found clean the error */
1183 6037 : sql->errstr[0] = '\0';
1184 6037 : sub_func = sql_bind_func_(sql, sname, name, type_list, F_UNION, false, true);
1185 6037 : type = sub_func?F_UNION:F_FUNC;
1186 : }
1187 95597 : if ( sub_func && sub_func->func->type == type)
1188 95593 : func = sub_func->func;
1189 : } else {
1190 4339 : list_func = sql_find_funcs_by_name(sql, sname, name, type, false);
1191 4339 : if (!list_func && type == F_FUNC) {
1192 1245 : sql->session->status = 0; /* if the function was not found clean the error */
1193 1245 : sql->errstr[0] = '\0';
1194 1245 : list_func = sql_find_funcs_by_name(sql, sname, name, F_UNION, false);
1195 : }
1196 4339 : if (list_func && list_func->cnt > 1) {
1197 3 : list_destroy(list_func);
1198 3 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "%s %s: there are more than one %s called '%s', please use the full signature", op, F, fn, name);
1199 : }
1200 4329 : if (list_func && list_func->cnt == 1)
1201 4329 : func = (sql_func*) list_func->h->data;
1202 : }
1203 :
1204 99952 : if (!func) {
1205 30 : void *e = NULL;
1206 30 : if (typelist) {
1207 23 : char *arg_list = NULL;
1208 23 : node *n;
1209 :
1210 23 : if (type_list->cnt > 0) {
1211 49 : for (n = type_list->h; n; n = n->next) {
1212 30 : char *tpe = sql_subtype_string(sql->ta, (sql_subtype *) n->data);
1213 :
1214 30 : if (arg_list) {
1215 11 : arg_list = sa_message(sql->ta, "%s, %s", arg_list, tpe);
1216 : } else {
1217 : arg_list = tpe;
1218 : }
1219 : }
1220 19 : list_destroy(list_func);
1221 19 : list_destroy(type_list);
1222 19 : if (!if_exists)
1223 16 : e = sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "%s %s: no such %s '%s' (%s)", op, F, fn, name, arg_list);
1224 19 : return e;
1225 : }
1226 4 : list_destroy(list_func);
1227 4 : list_destroy(type_list);
1228 4 : if (!if_exists)
1229 2 : e = sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "%s %s: no such %s '%s' ()", op, F, fn, name);
1230 4 : return e;
1231 : } else {
1232 7 : if (!if_exists)
1233 5 : e = sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "%s %s: no such %s '%s'", op, F, fn, name);
1234 7 : return e;
1235 : }
1236 99922 : } else if (((is_func && type != F_FILT) && !func->res) || (!is_func && func->res)) {
1237 0 : list_destroy(list_func);
1238 0 : list_destroy(type_list);
1239 0 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42000) "%s %s: cannot drop %s '%s'", op, F, fn, name);
1240 : }
1241 :
1242 99922 : list_destroy(list_func);
1243 99922 : list_destroy(type_list);
1244 99922 : return func;
1245 : }
1246 :
1247 : static sql_rel*
1248 670 : rel_drop_func(mvc *sql, dlist *qname, dlist *typelist, int drop_action, sql_ftype type, int if_exists)
1249 : {
1250 670 : const char *name = qname_schema_object(qname);
1251 670 : const char *sname = qname_schema(qname);
1252 670 : sql_func *func = NULL;
1253 670 : char *F = NULL, *fn = NULL;
1254 :
1255 670 : FUNC_TYPE_STR(type, F, fn)
1256 :
1257 670 : if (!(func = resolve_func(sql, sname, name, typelist, type, "DROP", if_exists))) {
1258 32 : if (if_exists) {
1259 7 : sql->errstr[0] = '\0'; /* reset function not found error */
1260 7 : sql->session->status = 0;
1261 7 : return rel_psm_block(sql->sa, new_exp_list(sql->sa));
1262 : }
1263 : return NULL;
1264 : }
1265 638 : if (!func->s) /* attempting to drop a system function */
1266 0 : return sql_error(sql, 02, SQLSTATE(42000) "DROP %s: cannot drop system %s '%s'", F, fn, name);
1267 638 : if (!mvc_schema_privs(sql, func->s))
1268 0 : return sql_error(sql, 02, SQLSTATE(42000) "DROP %s: insufficient privileges for user '%s' in schema '%s'", F, get_string_global_var(sql, "current_user"), func->s->base.name);
1269 638 : return rel_drop_function(sql->sa, func->s->base.name, name, func->base.id, type, drop_action);
1270 : }
1271 :
1272 : static sql_rel*
1273 110 : rel_drop_all_func(mvc *sql, dlist *qname, int drop_action, sql_ftype type)
1274 : {
1275 110 : const char *name = qname_schema_object(qname);
1276 110 : const char *sname = qname_schema(qname);
1277 110 : sql_schema *s = cur_schema(sql);
1278 110 : list *list_func = NULL;
1279 110 : char *F = NULL, *fn = NULL;
1280 :
1281 110 : FUNC_TYPE_STR(type, F, fn)
1282 :
1283 110 : if (sname && !(s = mvc_bind_schema(sql, sname)))
1284 0 : return sql_error(sql, 02, SQLSTATE(3F000) "DROP ALL %s: no such schema '%s'", F, sname);
1285 110 : if (!mvc_schema_privs(sql, s))
1286 0 : return sql_error(sql, 02, SQLSTATE(42000) "DROP ALL %s: insufficient privileges for user '%s' in schema '%s'", F, get_string_global_var(sql, "current_user"), s->base.name);
1287 :
1288 110 : if (!(list_func = sql_find_funcs_by_name(sql, s->base.name, name, type, false)) || list_empty(list_func)) {
1289 78 : list_destroy(list_func);
1290 78 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(3F000) "DROP ALL %s: no such %s '%s'", F, fn, name);
1291 : }
1292 32 : list_destroy(list_func);
1293 32 : return rel_drop_function(sql->sa, s->base.name, name, -1, type, drop_action);
1294 : }
1295 :
1296 : static sql_rel *
1297 345 : rel_create_trigger(mvc *sql, const char *sname, const char *tname, const char *triggername, int time, int orientation, int event, const char *old_name, const char *new_name, symbol *condition, const char *query, int replace)
1298 : {
1299 345 : sql_rel *rel = rel_create(sql->sa);
1300 345 : list *exps = new_exp_list(sql->sa);
1301 345 : if(!rel || !exps)
1302 : return NULL;
1303 :
1304 345 : append(exps, exp_atom_str(sql->sa, sname, sql_bind_localtype("str") ));
1305 345 : append(exps, exp_atom_str(sql->sa, tname, sql_bind_localtype("str") ));
1306 345 : append(exps, exp_atom_str(sql->sa, triggername, sql_bind_localtype("str") ));
1307 345 : append(exps, exp_atom_int(sql->sa, time));
1308 345 : append(exps, exp_atom_int(sql->sa, orientation));
1309 345 : append(exps, exp_atom_int(sql->sa, event));
1310 345 : append(exps, exp_atom_str(sql->sa, old_name, sql_bind_localtype("str") ));
1311 345 : append(exps, exp_atom_str(sql->sa, new_name, sql_bind_localtype("str") ));
1312 345 : (void)condition;
1313 345 : append(exps, exp_atom_str(sql->sa, NULL, sql_bind_localtype("str") ));
1314 345 : append(exps, exp_atom_str(sql->sa, query, sql_bind_localtype("str") ));
1315 345 : append(exps, exp_atom_int(sql->sa, replace));
1316 345 : rel->l = NULL;
1317 345 : rel->r = NULL;
1318 345 : rel->op = op_ddl;
1319 345 : rel->flag = ddl_create_trigger;
1320 345 : rel->exps = exps;
1321 345 : rel->card = CARD_MULTI;
1322 345 : rel->nrcols = 0;
1323 345 : return rel;
1324 : }
1325 :
1326 : static sql_rel_view*
1327 67 : _stack_push_table(mvc *sql, const char *tname, sql_table *t)
1328 : {
1329 67 : sql_rel *r = rel_basetable(sql, t, tname );
1330 67 : rel_base_use_all(sql, r);
1331 67 : r = rewrite_basetable(sql, r);
1332 67 : return stack_push_rel_view(sql, tname, r);
1333 : }
1334 :
1335 : static sql_rel *
1336 5831 : create_trigger(sql_query *query, dlist *qname, int time, symbol *trigger_event, dlist *tqname, dlist *opt_ref, dlist *triggered_action, int replace)
1337 : {
1338 5831 : mvc *sql = query->sql;
1339 5831 : const char *triggerschema = qname_schema(qname);
1340 5831 : const char *triggername = qname_schema_object(qname);
1341 5831 : char *sname = tqname? qname_schema(tqname) : NULL;
1342 5822 : char *tname = tqname? qname_schema_object(tqname) : NULL;
1343 5831 : int instantiate = (sql->emode == m_instantiate);
1344 5831 : int create = (!instantiate && sql->emode != m_deps), event, orientation;
1345 5831 : sql_schema *ss = cur_schema(sql), *old_schema = cur_schema(sql);
1346 5831 : sql_table *t = NULL;
1347 5831 : list *sq = NULL;
1348 5831 : sql_rel *r = NULL;
1349 5831 : char *q, *base = replace ? "CREATE OR REPLACE TRIGGER" : "CREATE TRIGGER";
1350 5831 : dlist *columns = trigger_event->data.lval;
1351 5831 : const char *old_name = NULL, *new_name = NULL;
1352 5831 : dlist *stmts = triggered_action->h->next->next->data.lval;
1353 5831 : symbol *condition = triggered_action->h->next->data.sym;
1354 5831 : bool old_useviews = sql->use_views;
1355 :
1356 5831 : if (opt_ref) {
1357 178 : dnode *dl = opt_ref->h;
1358 401 : for ( ; dl; dl = dl->next) {
1359 : /* list (new(1)/old(0)), char */
1360 223 : char *n = dl->data.lval->h->next->data.sval;
1361 :
1362 223 : assert(dl->data.lval->h->type == type_int);
1363 223 : if (!dl->data.lval->h->data.i_val) /*?l_val?*/
1364 : old_name = n;
1365 : else
1366 143 : new_name = n;
1367 : }
1368 : }
1369 :
1370 5831 : if (sname && !(ss = mvc_bind_schema(sql, sname)))
1371 0 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(3F000) "%s: no such schema '%s'", base, sname);
1372 :
1373 5831 : if (create) {
1374 354 : if (triggerschema)
1375 2 : return sql_error(sql, 02, SQLSTATE(42000) "%s: a trigger will be placed on the respective table's schema, specify the schema on the table reference, ie ON clause instead", base);
1376 352 : if (tname) {
1377 348 : if (!(t = mvc_bind_table(sql, ss, tname)))
1378 4 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42S02) "%s: no such table %s%s%s'%s'", base, sname ? "'":"", sname ? sname : "", sname ? "'.":"", tname);
1379 346 : if (isView(t))
1380 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: cannot create trigger on view '%s'", base, tname);
1381 345 : sname = t->s->base.name;
1382 345 : tname = t->base.name;
1383 : }
1384 349 : if (!mvc_schema_privs(sql, ss))
1385 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: access denied for %s to schema '%s'", base, get_string_global_var(sql, "current_user"), ss->base.name);
1386 348 : if (!replace && mvc_bind_trigger(sql, ss, triggername) != NULL)
1387 0 : return sql_error(sql, 02, SQLSTATE(42000) "%s: name '%s' already in use", base, triggername);
1388 348 : switch (trigger_event->token) {
1389 43 : case SQL_INSERT: {
1390 43 : if (old_name)
1391 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: old name not allowed at insert events", base);
1392 : event = 0;
1393 : } break;
1394 29 : case SQL_DELETE: {
1395 29 : if (new_name)
1396 0 : return sql_error(sql, 02, SQLSTATE(42000) "%s: new name not allowed at delete events", base);
1397 : event = 1;
1398 : } break;
1399 1 : case SQL_TRUNCATE: {
1400 1 : if (new_name)
1401 0 : return sql_error(sql, 02, SQLSTATE(42000) "%s: new name not allowed at truncate events", base);
1402 : event = 3;
1403 : } break;
1404 271 : case SQL_UPDATE: {
1405 271 : if (old_name && new_name && !strcmp(old_name, new_name))
1406 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: old and new names cannot be the same", base);
1407 270 : if (!old_name && new_name && !strcmp("old", new_name))
1408 1 : return sql_error(sql, 02, SQLSTATE(42000) "%s: old and new names cannot be the same", base);
1409 269 : if (!new_name && old_name && !strcmp("new", old_name))
1410 0 : return sql_error(sql, 02, SQLSTATE(42000) "%s: old and new names cannot be the same", base);
1411 : event = 2;
1412 : } break;
1413 : case SQL_LOGIN:
1414 : // TODO any checks here?
1415 : event = LOGIN_EVENT;
1416 : break;
1417 0 : default:
1418 0 : return sql_error(sql, 02, SQLSTATE(42000) "%s: invalid event: %s", base, token2string(trigger_event->token));
1419 : }
1420 :
1421 345 : assert(triggered_action->h->type == type_int);
1422 345 : orientation = triggered_action->h->data.i_val;
1423 345 : q = query_cleaned(sql->ta, QUERY(sql->scanner));
1424 345 : return rel_create_trigger(sql, sname, tname, triggername, time, orientation, event, old_name, new_name, condition, q, replace);
1425 : }
1426 :
1427 5477 : if (!instantiate) {
1428 344 : if (!stack_push_frame(sql, "%OLD-NEW"))
1429 0 : return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1430 344 : if (tname) {
1431 339 : if (!(t = mvc_bind_table(sql, ss, tname)))
1432 0 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(42S02) "%s: no such table %s%s%s'%s'", base, sname ? "'":"", sname ? sname : "", sname ? "'.":"", tname);
1433 : /* we need to add the old and new tables */
1434 339 : if (new_name && !_stack_push_table(sql, new_name, t)) {
1435 0 : stack_pop_frame(sql);
1436 0 : return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1437 : }
1438 339 : if (old_name && !_stack_push_table(sql, old_name, t)) {
1439 0 : stack_pop_frame(sql);
1440 0 : return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1441 : }
1442 : }
1443 : }
1444 5477 : if (condition) {
1445 8 : sql_rel *rel = NULL;
1446 :
1447 8 : if (new_name) /* in case of updates same relations is available via both names */
1448 6 : rel = stack_find_rel_view(sql, new_name);
1449 8 : if (!rel && old_name)
1450 0 : rel = stack_find_rel_view(sql, old_name);
1451 8 : if (!rel)
1452 2 : rel = stack_find_rel_view(sql, "old");
1453 2 : if (!rel)
1454 2 : rel = stack_find_rel_view(sql, "new");
1455 8 : rel = rel_logical_exp(query, rel, condition, sql_where);
1456 8 : if (!rel) {
1457 2 : if (!instantiate)
1458 2 : stack_pop_frame(sql);
1459 2 : return NULL;
1460 : }
1461 : /* transition tables */
1462 : /* insert: rel_select(table [new], searchcondition) */
1463 : /* delete: rel_select(table [old], searchcondition) */
1464 : /* update: rel_select(table [old,new]), searchcondition) */
1465 6 : if (new_name)
1466 6 : stack_update_rel_view(sql, new_name, rel);
1467 6 : if (old_name)
1468 0 : stack_update_rel_view(sql, old_name, new_name?rel_dup(rel):rel);
1469 : }
1470 5475 : sql->use_views = true; /* leave the 'use_views' hack to where it belongs */
1471 5475 : sql->session->schema = ss;
1472 5475 : sq = sequential_block(query, NULL, NULL, stmts, NULL, 1);
1473 5475 : sql->session->schema = old_schema;
1474 5475 : sql->use_views = old_useviews;
1475 5475 : if (!sq) {
1476 6 : if (!instantiate)
1477 3 : stack_pop_frame(sql);
1478 6 : return NULL;
1479 : }
1480 5469 : r = rel_psm_block(sql->sa, sq);
1481 :
1482 5469 : if (!instantiate)
1483 339 : stack_pop_frame(sql);
1484 : /* todo trigger_columns */
1485 : (void)columns;
1486 : return r;
1487 : }
1488 :
1489 : static sql_rel *
1490 84 : rel_drop_trigger(mvc *sql, const char *sname, const char *tname, int if_exists)
1491 : {
1492 84 : sql_rel *rel = rel_create(sql->sa);
1493 84 : list *exps = new_exp_list(sql->sa);
1494 84 : if(!rel || !exps)
1495 : return NULL;
1496 :
1497 84 : append(exps, exp_atom_str(sql->sa, sname, sql_bind_localtype("str") ));
1498 84 : append(exps, exp_atom_str(sql->sa, tname, sql_bind_localtype("str") ));
1499 84 : append(exps, exp_atom_int(sql->sa, if_exists));
1500 84 : rel->l = NULL;
1501 84 : rel->r = NULL;
1502 84 : rel->op = op_ddl;
1503 84 : rel->flag = ddl_drop_trigger;
1504 84 : rel->exps = exps;
1505 84 : rel->card = CARD_MULTI;
1506 84 : rel->nrcols = 0;
1507 84 : return rel;
1508 : }
1509 :
1510 : static sql_rel *
1511 96 : drop_trigger(mvc *sql, dlist *qname, int if_exists)
1512 : {
1513 96 : const char *sname = qname_schema(qname);
1514 96 : const char *tname = qname_schema_object(qname);
1515 96 : sql_trigger *tr = NULL;
1516 :
1517 96 : if (!(tr = find_trigger_on_scope(sql, sname, tname, "DROP TRIGGER"))) {
1518 12 : if (if_exists) {
1519 1 : sql->errstr[0] = '\0'; /* reset trigger not found error */
1520 1 : sql->session->status = 0;
1521 1 : return rel_psm_block(sql->sa, new_exp_list(sql->sa));
1522 : }
1523 : return NULL;
1524 : }
1525 84 : if (tr->t && !mvc_schema_privs(sql, tr->t->s))
1526 0 : return sql_error(sql, 02, SQLSTATE(3F000) "DROP TRIGGER: access denied for %s to schema '%s'", get_string_global_var(sql, "current_user"), tr->t->s->base.name);
1527 84 : return rel_drop_trigger(sql, tr->t?tr->t->s->base.name:NULL, tname, if_exists);
1528 : }
1529 :
1530 : static sql_rel*
1531 2 : create_table_from_loader(sql_query *query, dlist *qname, symbol *fcall)
1532 : {
1533 2 : mvc *sql = query->sql;
1534 2 : sql_schema *s = cur_schema(sql);
1535 2 : char *sname = qname_schema(qname);
1536 2 : char *tname = qname_schema_object(qname);
1537 2 : sql_subfunc *loader = NULL;
1538 2 : sql_rel *rel = NULL;
1539 2 : sql_table *t = NULL;
1540 :
1541 2 : if (sname && !(s = mvc_bind_schema(sql, sname)))
1542 0 : return sql_error(sql, ERR_NOTFOUND, SQLSTATE(3F000) "CREATE TABLE FROM LOADER: no such schema '%s'", sname);
1543 2 : if ((t = mvc_bind_table(sql, s, tname)))
1544 0 : return sql_error(sql, 02, SQLSTATE(42S01) "CREATE TABLE FROM LOADER: name '%s' already in use", tname);
1545 2 : if (!mvc_schema_privs(sql, s))
1546 0 : return sql_error(sql, 02, SQLSTATE(42000) "CREATE TABLE FROM LOADER: insufficient privileges for user '%s' in schema '%s'", get_string_global_var(sql, "current_user"), s->base.name);
1547 :
1548 2 : rel = rel_loader_function(query, fcall, new_exp_list(sql->sa), &loader);
1549 2 : if (!rel || !loader)
1550 : return NULL;
1551 :
1552 1 : loader->sname = s ? sa_strdup(sql->sa, s->base.name) : NULL;
1553 1 : loader->tname = tname ? sa_strdup(sql->sa, tname) : NULL;
1554 :
1555 1 : return rel;
1556 : }
1557 :
1558 : static list *
1559 4 : rel_paramlist( sql_query *query, symbol *nop)
1560 : {
1561 4 : dnode *ops = nop->data.lval->h->next->next->data.lval->h;
1562 4 : list *exps = sa_list(query->sql->sa);
1563 4 : exp_kind iek = {type_value, card_column, FALSE};
1564 :
1565 9 : for (; ops; ops = ops->next) {
1566 6 : sql_exp *e = rel_value_exp(query, NULL, ops->data.sym, sql_farg, iek);
1567 6 : if (!e)
1568 : return NULL;
1569 6 : ops = ops->next;
1570 6 : sql_arg *a = sql_find_param(query->sql, ops->data.sval);
1571 6 : if (!a)
1572 1 : return sql_error(query->sql, 06, SQLSTATE(42000) "Named placeholder ('%s') not used in the query.", ops->data.sval);
1573 5 : a->type = *exp_subtype(e);
1574 5 : append(exps, e);
1575 : }
1576 : return exps;
1577 : }
1578 :
1579 :
1580 : sql_rel *
1581 258771 : rel_psm(sql_query *query, symbol *s)
1582 : {
1583 258771 : mvc *sql = query->sql;
1584 258771 : sql_rel *ret = NULL;
1585 :
1586 258771 : switch (s->token) {
1587 242896 : case SQL_CREATE_FUNC:
1588 : {
1589 242896 : dlist *l = s->data.lval;
1590 242896 : sql_ftype type = (sql_ftype) l->h->next->next->next->next->next->data.i_val;
1591 242896 : sql_flang lang = (sql_flang) l->h->next->next->next->next->next->next->data.i_val;
1592 242896 : int repl = l->h->next->next->next->next->next->next->next->data.i_val;
1593 :
1594 242896 : ret = rel_create_func(query, l->h->data.lval, l->h->next->data.lval, l->h->next->next->data.sym, l->h->next->next->next->data.lval, l->h->next->next->next->next->data.lval, type, lang, repl);
1595 242896 : sql->type = Q_SCHEMA;
1596 242896 : } break;
1597 780 : case SQL_DROP_FUNC:
1598 : {
1599 780 : dlist *l = s->data.lval;
1600 780 : dlist *qname = l->h->data.lval;
1601 780 : dlist *typelist = l->h->next->data.lval;
1602 780 : sql_ftype type = (sql_ftype) l->h->next->next->data.i_val;
1603 780 : int if_exists = l->h->next->next->next->data.i_val;
1604 780 : int all = l->h->next->next->next->next->data.i_val;
1605 780 : int drop_action = l->h->next->next->next->next->next->data.i_val;
1606 :
1607 780 : if (store_readonly(sql->session->tr->store))
1608 0 : return sql_error(sql, 06, SQLSTATE(42000) "Schema statements cannot be executed on a readonly database.");
1609 :
1610 780 : if (all)
1611 110 : ret = rel_drop_all_func(sql, qname, drop_action, type);
1612 : else
1613 670 : ret = rel_drop_func(sql, qname, typelist, drop_action, type, if_exists);
1614 :
1615 780 : sql->type = Q_SCHEMA;
1616 780 : } break;
1617 393 : case SQL_SET:
1618 393 : ret = rel_psm_stmt(sql->sa, psm_set_exp(query, s->data.lval->h));
1619 393 : sql->type = Q_SCHEMA;
1620 393 : break;
1621 11 : case SQL_DECLARE:
1622 11 : return sql_error(sql, 02, SQLSTATE(42000) "Variables cannot be declared on the global scope");
1623 8722 : case SQL_CALL:
1624 8722 : sql->type = Q_UPDATE;
1625 8722 : if (s->type == type_list) {
1626 4 : list *params = rel_paramlist( query, s->data.lval->h->next->data.sym);
1627 4 : if (!params)
1628 : return NULL;
1629 3 : ret = rel_semantic(query, s->data.lval->h->data.sym);
1630 3 : query->last_rel = ret;
1631 3 : if (ret)
1632 3 : ret = rel_psm_stmt(sql->sa, rel_psm_call(query, s->data.lval->h->next->data.sym));
1633 3 : ret = rel_list(sql->sa, query->last_rel, ret);
1634 : } else
1635 8718 : ret = rel_psm_stmt(sql->sa, rel_psm_call(query, s->data.sym));
1636 : break;
1637 2 : case SQL_CREATE_TABLE_LOADER:
1638 : {
1639 2 : dlist *l = s->data.lval;
1640 2 : dlist *qname = l->h->data.lval;
1641 2 : symbol *sym = l->h->next->data.sym;
1642 :
1643 2 : ret = create_table_from_loader(query, qname, sym);
1644 2 : if (ret == NULL)
1645 : return NULL;
1646 1 : ret = rel_psm_stmt(sql->sa, exp_rel(sql, ret));
1647 1 : sql->type = Q_SCHEMA;
1648 1 : } break;
1649 5831 : case SQL_CREATE_TRIGGER:
1650 : {
1651 5831 : dlist *l = s->data.lval;
1652 :
1653 5831 : assert(l->h->next->type == type_int);
1654 5831 : ret = create_trigger(query, l->h->data.lval, l->h->next->data.i_val, l->h->next->next->data.sym, l->h->next->next->next->data.lval, l->h->next->next->next->next->data.lval, l->h->next->next->next->next->next->data.lval, l->h->next->next->next->next->next->next->data.i_val);
1655 5831 : sql->type = Q_SCHEMA;
1656 5831 : } break;
1657 96 : case SQL_DROP_TRIGGER:
1658 : {
1659 96 : dlist *l = s->data.lval;
1660 96 : dlist *qname = l->h->data.lval;
1661 96 : int if_exists = l->h->next->data.i_val;
1662 :
1663 96 : ret = drop_trigger(sql, qname, if_exists);
1664 96 : sql->type = Q_SCHEMA;
1665 96 : } break;
1666 40 : case SQL_ANALYZE: {
1667 40 : dlist *l = s->data.lval;
1668 :
1669 : /* Jan2022 update: The 'sample' and 'minmax' parameters are now ignored because they are no longer used in the backend */
1670 40 : list *calls = psm_analyze(query, l->h->data.lval /* qualified table name */, l->h->next->data.lval /* opt list of column */);
1671 40 : ret = rel_psm_block(sql->sa, calls);
1672 40 : sql->type = Q_UPDATE;
1673 40 : } break;
1674 0 : default:
1675 0 : return sql_error(sql, 01, SQLSTATE(42000) "Schema statement unknown symbol(%p)->token = %s", s, token2string(s->token));
1676 : }
1677 : return ret;
1678 : }
|
