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 : /* multi version catalog */
14 :
15 : #include "monetdb_config.h"
16 : #include "gdk.h"
17 :
18 : #include "sql_mvc.h"
19 : #include "sql_qc.h"
20 : #include "sql_types.h"
21 : #include "sql_storage.h"
22 : #include "sql_env.h"
23 : #include "sql_semantic.h"
24 : #include "sql_partition.h"
25 : #include "sql_privileges.h"
26 : #include "mapi_querytype.h"
27 : #include "rel_rel.h"
28 : #include "rel_exp.h"
29 : #include "rel_semantic.h"
30 : #include "rel_unnest.h"
31 : #include "rel_optimizer.h"
32 : #include "rel_statistics.h"
33 : #include "rel_remote.h"
34 :
35 : #include "mal_authorize.h"
36 : #include "mal_profiler.h"
37 : #include "mal_exception.h"
38 : #include "mal_interpreter.h"
39 :
40 : static void
41 229 : sql_create_comments(mvc *m, sql_schema *s)
42 : {
43 229 : sql_table *t = NULL;
44 229 : sql_column *c = NULL;
45 229 : sql_key *k = NULL;
46 :
47 229 : mvc_create_table(&t, m, s, "comments", tt_table, 1, SQL_PERSIST, 0, -1, 0);
48 229 : mvc_create_column_(&c, m, t, "id", "int", 32);
49 229 : sql_trans_create_ukey(&k, m->session->tr, t, "comments_id_pkey", pkey, NULL);
50 229 : sql_trans_create_kc(m->session->tr, k, c);
51 229 : sql_trans_key_done(m->session->tr, k);
52 229 : sql_trans_create_dependency(m->session->tr, c->base.id, k->idx->base.id, INDEX_DEPENDENCY);
53 229 : mvc_create_column_(&c, m, t, "remark", "varchar", 65000);
54 229 : sql_trans_alter_null(m->session->tr, c, 0);
55 229 : }
56 :
57 : static sql_table *
58 490 : mvc_init_create_view(mvc *m, sql_schema *s, const char *name, const char *query)
59 : {
60 490 : sql_table *t = NULL;
61 :
62 490 : mvc_create_view(&t, m, s, name, SQL_PERSIST, query, 1);
63 490 : if (t) {
64 490 : char *buf;
65 490 : sql_rel *r = NULL;
66 :
67 490 : if (!(buf = sa_strdup(m->ta, t->query))) {
68 0 : (void) sql_error(m, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
69 0 : return NULL;
70 : }
71 :
72 490 : r = rel_parse(m, s, buf, m_deps);
73 490 : if (r)
74 490 : r = sql_processrelation(m, r, 0, 0, 0, 0);
75 490 : if (r) {
76 490 : list *blist = rel_dependencies(m, r);
77 490 : if (mvc_create_dependencies(m, blist, t->base.id, VIEW_DEPENDENCY)) {
78 0 : sa_reset(m->ta);
79 0 : (void) sql_error(m, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
80 0 : return NULL;
81 : }
82 : }
83 490 : sa_reset(m->ta);
84 490 : assert(r);
85 : }
86 490 : return t;
87 : }
88 :
89 : #define MVC_INIT_DROP_TABLE(SQLID, TNAME, VIEW, NCOL) \
90 : do { \
91 : str output; \
92 : t = mvc_bind_table(m, s, TNAME); \
93 : SQLID = t->base.id; \
94 : for (int i = 0; i < NCOL; i++) { \
95 : sql_column *col = mvc_bind_column(m, t, VIEW[i].name); \
96 : VIEW[i].oldid = col->base.id; \
97 : } \
98 : if ((output = mvc_drop_table(m, s, t, 0)) != MAL_SUCCEED) { \
99 : mvc_destroy(m); \
100 : mvc_exit(store); \
101 : TRC_CRITICAL(SQL_TRANS, \
102 : "Initialization error: %s\n", output); \
103 : freeException(output); \
104 : return NULL; \
105 : } \
106 : } while (0)
107 :
108 : struct view_t {
109 : const char *name;
110 : const char *type;
111 : unsigned int digits;
112 : sqlid oldid;
113 : sqlid newid;
114 : };
115 :
116 : static void
117 64 : mvc_fix_depend(mvc *m, sql_column *depids, struct view_t *v, int n)
118 : {
119 64 : sqlstore *store = m->store;
120 64 : oid rid;
121 64 : rids *rs;
122 :
123 736 : for (int i = 0; i < n; i++) {
124 1344 : rs = store->table_api.rids_select(m->session->tr, depids,
125 672 : &v[i].oldid, &v[i].oldid, NULL);
126 672 : if (rs) {
127 4288 : while ((rid = store->table_api.rids_next(rs)), !is_oid_nil(rid)) {
128 3616 : store->table_api.column_update_value(m->session->tr, depids, rid, &v[i].newid);
129 : }
130 672 : store->table_api.rids_destroy(rs);
131 : }
132 : }
133 64 : }
134 :
135 : sql_store
136 358 : mvc_init(int debug, store_type store_tpe, int ro, int su, const char *initpasswd)
137 : {
138 358 : sqlstore *store = NULL;
139 358 : sql_schema *s;
140 358 : sql_table *t;
141 358 : mvc *m;
142 358 : str msg;
143 :
144 358 : TRC_DEBUG(SQL_TRANS, "Initialization\n");
145 358 : keyword_init();
146 358 : if (scanner_init_keywords() != 0) {
147 0 : TRC_CRITICAL(SQL_TRANS, "Malloc failure\n");
148 0 : return NULL;
149 : }
150 :
151 358 : if ((store = store_init(debug, store_tpe, ro, su)) == NULL) {
152 1 : keyword_exit();
153 1 : TRC_CRITICAL(SQL_TRANS, "Unable to create system tables\n");
154 1 : return NULL;
155 : }
156 :
157 357 : initialize_sql_functions_lookup(store->sa);
158 :
159 357 : m = mvc_create((sql_store)store, store->sa, 0, 0, NULL, NULL);
160 357 : if (!m) {
161 0 : mvc_exit(store);
162 0 : TRC_CRITICAL(SQL_TRANS, "Malloc failure\n");
163 0 : return NULL;
164 : }
165 :
166 357 : assert(m->sa == NULL);
167 357 : m->sa = sa_create(m->pa);
168 357 : if (!m->sa) {
169 0 : mvc_destroy(m);
170 0 : mvc_exit(store);
171 0 : TRC_CRITICAL(SQL_TRANS, "Malloc failure\n");
172 0 : return NULL;
173 : }
174 :
175 357 : if (store->first || store->catalog_version) {
176 245 : sqlid tid = 0, cid = 0;
177 245 : struct view_t tview[10] = {
178 : {
179 : .name = "id",
180 : .type = "int",
181 : .digits = 32,
182 : },
183 : {
184 : .name = "name",
185 : .type = "varchar",
186 : .digits = 1024,
187 : },
188 : {
189 : .name = "schema_id",
190 : .type = "int",
191 : .digits = 32,
192 : },
193 : {
194 : .name = "query",
195 : .type = "varchar",
196 : .digits = 1 << 20,
197 : },
198 : {
199 : .name = "type",
200 : .type = "smallint",
201 : .digits = 16,
202 : },
203 : {
204 : .name = "system",
205 : .type = "boolean",
206 : .digits = 1,
207 : },
208 : {
209 : .name = "commit_action",
210 : .type = "smallint",
211 : .digits = 16,
212 : },
213 : {
214 : .name = "access",
215 : .type = "smallint",
216 : .digits = 16,
217 : },
218 : {
219 : .name = "temporary",
220 : .type = "smallint",
221 : .digits = 16,
222 : },
223 : {
224 : 0
225 : },
226 245 : }, cview[11] = {
227 : {
228 : .name = "id",
229 : .type = "int",
230 : .digits = 32,
231 : },
232 : {
233 : .name = "name",
234 : .type = "varchar",
235 : .digits = 1024,
236 : },
237 : {
238 : .name = "type",
239 : .type = "varchar",
240 : .digits = 1024,
241 : },
242 : {
243 : .name = "type_digits",
244 : .type = "int",
245 : .digits = 32,
246 : },
247 : {
248 : .name = "type_scale",
249 : .type = "int",
250 : .digits = 32,
251 : },
252 : {
253 : .name = "table_id",
254 : .type = "int",
255 : .digits = 32,
256 : },
257 : {
258 : .name = "default",
259 : .type = "varchar",
260 : .digits = STORAGE_MAX_VALUE_LENGTH,
261 : },
262 : {
263 : .name = "null",
264 : .type = "boolean",
265 : .digits = 1,
266 : },
267 : {
268 : .name = "number",
269 : .type = "int",
270 : .digits = 32,
271 : },
272 : {
273 : .name = "storage",
274 : .type = "varchar",
275 : .digits = 2048,
276 : },
277 : {
278 : 0
279 : },
280 : };
281 245 : if (mvc_trans(m) < 0) {
282 0 : mvc_destroy(m);
283 0 : mvc_exit(store);
284 0 : TRC_CRITICAL(SQL_TRANS, "Failed to start transaction\n");
285 0 : return NULL;
286 : }
287 245 : s = m->session->schema = mvc_bind_schema(m, "sys");
288 245 : assert(m->session->schema != NULL);
289 :
290 245 : if (!store->first) {
291 160 : MVC_INIT_DROP_TABLE(tid, "tables", tview, 9);
292 176 : MVC_INIT_DROP_TABLE(cid, "columns", cview, 10);
293 : }
294 :
295 245 : t = mvc_init_create_view(m, s, "tables", "SELECT \"id\", \"name\", \"schema_id\", \"query\", CAST(CASE WHEN \"system\" THEN \"type\" + 10 /* system table/view */ ELSE (CASE WHEN \"commit_action\" = 0 THEN \"type\" /* table/view */ ELSE \"type\" + 20 /* global temp table */ END) END AS SMALLINT) AS \"type\", \"system\", \"commit_action\", \"access\", CASE WHEN (NOT \"system\" AND \"commit_action\" > 0) THEN 1 ELSE 0 END AS \"temporary\" FROM \"sys\".\"_tables\" WHERE \"type\" <> 2 UNION ALL SELECT \"id\", \"name\", \"schema_id\", \"query\", CAST(\"type\" + 30 /* local temp table */ AS SMALLINT) AS \"type\", \"system\", \"commit_action\", \"access\", 1 AS \"temporary\" FROM \"tmp\".\"_tables\";");
296 245 : if (!t) {
297 0 : mvc_destroy(m);
298 0 : mvc_exit(store);
299 0 : TRC_CRITICAL(SQL_TRANS, "Failed to create 'tables' view\n");
300 0 : return NULL;
301 : }
302 :
303 2450 : for (int i = 0; i < 9; i++) {
304 2205 : sql_column *col = NULL;
305 :
306 2205 : mvc_create_column_(&col, m, t, tview[i].name, tview[i].type, tview[i].digits);
307 2205 : if (col == NULL) {
308 0 : mvc_destroy(m);
309 0 : mvc_exit(store);
310 0 : TRC_CRITICAL(SQL_TRANS,
311 : "Initialization: creation of sys.tables column %s failed\n", tview[i].name);
312 0 : return NULL;
313 : }
314 2205 : tview[i].newid = col->base.id;
315 : }
316 :
317 245 : if (!store->first) {
318 16 : int pub = ROLE_PUBLIC;
319 16 : int p = PRIV_SELECT;
320 16 : int zero = 0;
321 16 : sql_table *privs = find_sql_table(m->session->tr, s, "privileges");
322 16 : sql_table *deps = find_sql_table(m->session->tr, s, "dependencies");
323 16 : store->table_api.table_insert(m->session->tr, privs, &t->base.id, &pub, &p, &zero, &zero);
324 16 : assert(tview[9].name == NULL);
325 16 : tview[9].oldid = tid;
326 16 : tview[9].newid = t->base.id;
327 16 : mvc_fix_depend(m, find_sql_column(deps, "id"), tview, 10);
328 16 : mvc_fix_depend(m, find_sql_column(deps, "depend_id"), tview, 10);
329 : }
330 :
331 245 : t = mvc_init_create_view(m, s, "columns", "SELECT * FROM (SELECT p.* FROM \"sys\".\"_columns\" AS p UNION ALL SELECT t.* FROM \"tmp\".\"_columns\" AS t) AS columns;");
332 245 : if (!t) {
333 0 : mvc_destroy(m);
334 0 : mvc_exit(store);
335 0 : TRC_CRITICAL(SQL_TRANS, "Failed to create 'columns' view\n");
336 0 : return NULL;
337 : }
338 2695 : for (int i = 0; i < 10; i++) {
339 2450 : sql_column *col = NULL;
340 :
341 2450 : mvc_create_column_(&col, m, t, cview[i].name, cview[i].type, cview[i].digits);
342 2450 : if (col == NULL) {
343 0 : mvc_destroy(m);
344 0 : mvc_exit(store);
345 0 : TRC_CRITICAL(SQL_TRANS,
346 : "Initialization: creation of sys.tables column %s failed\n", cview[i].name);
347 0 : return NULL;
348 : }
349 2450 : cview[i].newid = col->base.id;
350 : }
351 :
352 245 : if (!store->first) {
353 16 : int pub = ROLE_PUBLIC;
354 16 : int p = PRIV_SELECT;
355 16 : int zero = 0;
356 16 : sql_table *privs = find_sql_table(m->session->tr, s, "privileges");
357 16 : sql_table *deps = find_sql_table(m->session->tr, s, "dependencies");
358 16 : store->table_api.table_insert(m->session->tr, privs, &t->base.id, &pub, &p, &zero, &zero);
359 16 : assert(cview[10].name == NULL);
360 16 : cview[10].oldid = cid;
361 16 : cview[10].newid = t->base.id;
362 16 : mvc_fix_depend(m, find_sql_column(deps, "id"), cview, 11);
363 16 : mvc_fix_depend(m, find_sql_column(deps, "depend_id"), cview, 11);
364 : } else {
365 229 : sql_create_env(m, s);
366 229 : sql_create_comments(m, s);
367 229 : sql_create_privileges(m, s, initpasswd);
368 : }
369 :
370 245 : if ((msg = mvc_commit(m, 0, NULL, false)) != MAL_SUCCEED) {
371 0 : TRC_CRITICAL(SQL_TRANS, "Unable to commit system tables: %s\n", (msg + 6));
372 0 : freeException(msg);
373 0 : mvc_destroy(m);
374 0 : mvc_exit(store);
375 0 : return NULL;
376 : }
377 : }
378 :
379 357 : if (mvc_trans(m) < 0) {
380 0 : mvc_destroy(m);
381 0 : mvc_exit(store);
382 0 : TRC_CRITICAL(SQL_TRANS, "Failed to start transaction\n");
383 0 : return NULL;
384 : }
385 :
386 : //as the sql_parser is not yet initialized in the storage, we determine the sql type of the sql_parts here
387 :
388 357 : struct os_iter si;
389 357 : os_iterator(&si, m->session->tr->cat->schemas, m->session->tr, NULL);
390 1973 : for(sql_base *b = oi_next(&si); b; b = oi_next(&si)) {
391 1616 : sql_schema *ss = (sql_schema*)b;
392 1616 : struct os_iter oi;
393 1616 : os_iterator(&oi, ss->tables, m->session->tr, NULL);
394 27058 : for(sql_base *b = oi_next(&oi); b; b = oi_next(&oi)) {
395 25442 : sql_table *tt = (sql_table*)b;
396 25442 : if (isPartitionedByColumnTable(tt) || isPartitionedByExpressionTable(tt)) {
397 51 : char *err;
398 51 : if ((err = parse_sql_parts(m, tt)) != NULL) {
399 0 : TRC_CRITICAL(SQL_TRANS, "Unable to start partitioned table: %s.%s: %s\n", ss->base.name, tt->base.name, err);
400 0 : freeException(err);
401 0 : mvc_destroy(m);
402 0 : mvc_exit(store);
403 0 : return NULL;
404 : }
405 : }
406 : }
407 : }
408 357 : if (sql_trans_convert_partitions(m->session->tr) < 0) {
409 0 : TRC_CRITICAL(SQL_TRANS, "Unable to start partitioned tables\n");
410 0 : mvc_destroy(m);
411 0 : mvc_exit(store);
412 0 : return NULL;
413 : }
414 :
415 357 : if ((msg = mvc_commit(m, 0, NULL, false)) != MAL_SUCCEED) {
416 0 : TRC_CRITICAL(SQL_TRANS, "Unable to commit system tables: %s\n", (msg + 6));
417 0 : freeException(msg);
418 0 : mvc_destroy(m);
419 0 : mvc_exit(store);
420 0 : return NULL;
421 : }
422 357 : mvc_destroy(m);
423 357 : return store;
424 : }
425 :
426 : void
427 356 : mvc_exit(sql_store store)
428 : {
429 356 : TRC_DEBUG(SQL_TRANS, "MVC exit\n");
430 356 : store_exit(store);
431 356 : keyword_exit();
432 356 : }
433 :
434 : void
435 356 : mvc_logmanager(sql_store store)
436 : {
437 356 : store_manager(store);
438 355 : }
439 :
440 : int
441 1612356 : mvc_status(mvc *m)
442 : {
443 1612356 : int res = m->session->status;
444 :
445 1612356 : return res;
446 : }
447 :
448 : int
449 0 : mvc_error_retry(mvc *m)
450 : {
451 0 : int res = m->session->status;
452 :
453 0 : if (!res || res == -ERR_AMBIGUOUS || res == -ERR_GROUPBY)
454 0 : return 0;
455 : return res;
456 : }
457 :
458 : int
459 0 : mvc_type(mvc *m)
460 : {
461 0 : int res = m->type;
462 :
463 0 : m->type = Q_PARSE;
464 0 : return res;
465 : }
466 :
467 : int
468 30966 : mvc_debug_on(mvc *m, int flg)
469 : {
470 :
471 30966 : if (m->debug & flg)
472 0 : return 1;
473 :
474 : return 0;
475 : }
476 :
477 : void
478 0 : mvc_cancel_session(mvc *m)
479 : {
480 0 : (void)sql_trans_end(m->session, SQL_ERR);
481 0 : }
482 :
483 : void
484 1403659 : mvc_query_processed(mvc *m)
485 : {
486 1403659 : scanner_query_processed(&(m->scanner));
487 1403664 : }
488 :
489 : int
490 256064 : mvc_trans(mvc *m)
491 : {
492 256064 : int res = 0, err = m->session->status;
493 256064 : assert(!m->session->tr->active); /* can only start a new transaction */
494 :
495 256064 : TRC_INFO(SQL_TRANS, "Starting transaction\n");
496 256064 : res = sql_trans_begin(m->session);
497 256217 : if (m->qc && (res || err))
498 29343 : qc_restart(m->qc);
499 256217 : return res;
500 : }
501 :
502 : str
503 194341 : mvc_commit(mvc *m, int chain, const char *name, bool enabling_auto_commit)
504 : {
505 194341 : sql_trans *tr = m->session->tr;
506 194341 : int ok = SQL_OK;
507 194341 : str msg = MAL_SUCCEED, other;
508 194341 : char operation[BUFSIZ];
509 :
510 194341 : assert(tr);
511 194341 : assert(m->session->tr->active); /* only commit an active transaction */
512 194341 : TRC_DEBUG(SQL_TRANS,"Commit: %s\n", (name) ? name : "");
513 194342 : if(enabling_auto_commit)
514 1 : snprintf(operation, BUFSIZ, "Commit failed while enabling auto_commit: ");
515 194341 : else if(name)
516 46 : snprintf(operation, BUFSIZ, "SAVEPOINT: (%s)", name);
517 : else
518 194295 : snprintf(operation, BUFSIZ, "COMMIT:");
519 :
520 194342 : if (m->session->status < 0) {
521 12 : msg = createException(SQL, "sql.commit", SQLSTATE(40000) "%s transaction is aborted, will ROLLBACK instead", operation);
522 12 : if ((other = mvc_rollback(m, chain, name, false)) != MAL_SUCCEED)
523 0 : freeException(other);
524 12 : return msg;
525 : }
526 :
527 : /* savepoint, simply make a new sub transaction */
528 194330 : if (name && name[0] != '\0') {
529 46 : sql_trans *tr = m->session->tr;
530 46 : TRC_DEBUG(SQL_TRANS, "Savepoint\n");
531 46 : if (!(m->session->tr = sql_trans_create(m->store, tr, name)))
532 0 : return createException(SQL, "sql.commit", SQLSTATE(HY013) "%s allocation failure while creating savepoint", operation);
533 :
534 46 : if (!(m->session->schema = find_sql_schema(m->session->tr, m->session->schema_name))) {
535 0 : m->session->tr = sql_trans_destroy(m->session->tr);
536 0 : return createException(SQL, "sql.commit", SQLSTATE(40000) "%s finished successfully, but the session's schema could not be found on the current transaction", operation);
537 : }
538 46 : m->type = Q_TRANS;
539 46 : TRC_INFO(SQL_TRANS, "Savepoint commit '%s' done\n", name);
540 46 : return msg;
541 : }
542 :
543 194284 : if (!tr->parent && !name) {
544 194279 : lng Tbegin = 0;
545 194279 : ulng ts_start = 0;
546 194279 : bool log_usec = profilerMode == 0 || m->session->auto_commit;
547 194279 : if(profilerStatus > 0) {
548 0 : if (log_usec) Tbegin = GDKusec();
549 0 : ts_start = m->session->tr->ts;
550 : }
551 :
552 194279 : const int state = sql_trans_end(m->session, ok);
553 :
554 194284 : if(profilerStatus > 0) {
555 0 : lng Tend = GDKusec();
556 0 : Client c = mal_clients+m->clientid;
557 0 : profilerEvent(NULL,
558 : &(struct NonMalEvent)
559 0 : { state == SQL_CONFLICT ? CONFLICT : COMMIT , c, Tend, &ts_start, &m->session->tr->ts, state == SQL_ERR, log_usec?Tend-Tbegin:0});
560 : }
561 194284 : switch (state) {
562 0 : case SQL_ERR:
563 0 : GDKfatal("%s transaction commit failed; exiting (kernel error: %s)", operation, GDKerrbuf);
564 728 : break;
565 728 : case SQL_CONFLICT:
566 :
567 : /* transaction conflict */
568 728 : return createException(SQL, "sql.commit", SQLSTATE(40001) "%s transaction is aborted because of concurrency conflicts, will ROLLBACK instead", operation);
569 : default:
570 193556 : break;
571 : }
572 193556 : if (chain) {
573 2 : if (sql_trans_begin(m->session) < 0)
574 0 : return createException(SQL, "sql.commit", SQLSTATE(40000) "%s finished successfully, but the session's schema could not be found while starting the next transaction", operation);
575 2 : m->session->auto_commit = 0; /* disable auto-commit while chaining */
576 : }
577 193556 : m->type = Q_TRANS;
578 193556 : TRC_INFO(SQL_TRANS,
579 : "Commit done\n");
580 193556 : return msg;
581 : }
582 :
583 : /* save points only */
584 : assert(name || tr->parent);
585 :
586 : /* commit and cleanup nested transactions */
587 5 : if (tr->parent) {
588 12 : while (tr->parent != NULL && ok == SQL_OK) {
589 7 : if ((ok = sql_trans_commit(tr)) == SQL_ERR)
590 0 : GDKfatal("%s transaction commit failed; exiting (kernel error: %s)", operation, GDKerrbuf);
591 7 : m->session->tr = tr = sql_trans_destroy(tr);
592 : }
593 5 : while (tr->parent != NULL)
594 0 : m->session->tr = tr = sql_trans_destroy(tr);
595 5 : if (ok != SQL_OK)
596 0 : msg = createException(SQL, "sql.commit", SQLSTATE(40001) "%s transaction is aborted because of concurrency conflicts, will ROLLBACK instead", operation);
597 : }
598 :
599 : /* if there is nothing to commit reuse the current transaction */
600 5 : if (list_empty(tr->changes)) {
601 0 : if (!chain) {
602 0 : switch (sql_trans_end(m->session, ok)) {
603 0 : case SQL_ERR:
604 0 : GDKfatal("%s transaction commit failed; exiting (kernel error: %s)", operation, GDKerrbuf);
605 0 : break;
606 0 : case SQL_CONFLICT:
607 0 : if (!msg)
608 0 : msg = createException(SQL, "sql.commit", SQLSTATE(40001) "%s transaction is aborted because of concurrency conflicts, will ROLLBACK instead", operation);
609 : break;
610 : default:
611 : break;
612 : }
613 : }
614 0 : m->type = Q_TRANS;
615 0 : TRC_INFO(SQL_TRANS,
616 : "Commit done (no changes)\n");
617 0 : return msg;
618 : }
619 :
620 5 : switch (sql_trans_end(m->session, ok)) {
621 0 : case SQL_ERR:
622 0 : GDKfatal("%s transaction commit failed; exiting (kernel error: %s)", operation, GDKerrbuf);
623 0 : break;
624 0 : case SQL_CONFLICT:
625 0 : if (!msg)
626 0 : msg = createException(SQL, "sql.commit", SQLSTATE(40001) "%s transaction is aborted because of concurrency conflicts, will ROLLBACK instead", operation);
627 : return msg;
628 : default:
629 5 : break;
630 : }
631 5 : if (chain) {
632 0 : if (sql_trans_begin(m->session) < 0) {
633 0 : if (!msg)
634 0 : msg = createException(SQL, "sql.commit", SQLSTATE(40000) "%s finished successfully, but the session's schema could not be found while starting the next transaction", operation);
635 0 : return msg;
636 : }
637 0 : m->session->auto_commit = 0; /* disable auto-commit while chaining */
638 : }
639 5 : m->type = Q_TRANS;
640 5 : TRC_INFO(SQL_TRANS,
641 : "Commit done\n");
642 : return msg;
643 : }
644 :
645 : str
646 61769 : mvc_rollback(mvc *m, int chain, const char *name, bool disabling_auto_commit)
647 : {
648 61769 : str msg = MAL_SUCCEED;
649 :
650 61769 : TRC_DEBUG(SQL_TRANS, "Rollback: %s\n", (name) ? name : "");
651 61769 : (void) disabling_auto_commit;
652 :
653 61769 : sql_trans *tr = m->session->tr;
654 61769 : assert(m->session->tr && m->session->tr->active); /* only abort an active transaction */
655 61769 : if (name && name[0] != '\0') {
656 38 : while (tr && (!tr->name || strcmp(tr->name, name) != 0))
657 20 : tr = tr->parent;
658 18 : if (!tr || !tr->name || strcmp(tr->name, name) != 0) {
659 2 : msg = createException(SQL, "sql.rollback", SQLSTATE(42000) "ROLLBACK TO SAVEPOINT: no such savepoint: '%s'", name);
660 2 : m->session->status = -1;
661 2 : return msg;
662 : }
663 : tr = m->session->tr;
664 34 : while (!tr->name || strcmp(tr->name, name) != 0) {
665 : /* make sure we do not reuse changed data */
666 18 : if (!list_empty(tr->changes))
667 9 : tr->status = 1;
668 18 : m->session->tr = tr = sql_trans_destroy(tr);
669 : }
670 : /* start a new transaction after rolling back */
671 16 : if (!(m->session->tr = tr = sql_trans_create(m->store, tr, name))) {
672 0 : msg = createException(SQL, "sql.rollback", SQLSTATE(HY013) "ROLLBACK TO SAVEPOINT: allocation failure while restarting savepoint");
673 0 : m->session->status = -1;
674 0 : return msg;
675 : }
676 16 : m->session->status = tr->parent->status;
677 16 : if (!(m->session->schema = find_sql_schema(tr, m->session->schema_name))) {
678 1 : msg = createException(SQL, "sql.rollback", SQLSTATE(40000) "ROLLBACK TO SAVEPOINT: finished successfully, but the session's schema could not be found on the current transaction");
679 1 : m->session->status = -1;
680 1 : return msg;
681 : }
682 : } else {
683 : /* first release all intermediate savepoints */
684 61767 : while (tr->parent != NULL)
685 15 : m->session-> tr = tr = sql_trans_destroy(tr);
686 : /* make sure we do not reuse changed data */
687 61752 : if (!list_empty(tr->changes))
688 1120 : tr->status = 1;
689 :
690 :
691 61751 : lng Tbegin = 0;
692 61751 : ulng ts_start = 0;
693 61751 : bool log_usec = profilerMode == 0 || m->session->auto_commit;
694 61751 : if(profilerStatus > 0) {
695 0 : if (log_usec) Tbegin = GDKusec();
696 0 : ts_start = m->session->tr->ts;
697 : }
698 61751 : (void) sql_trans_end(m->session, SQL_ERR);
699 :
700 61752 : if(profilerStatus > 0) {
701 0 : lng Tend = GDKusec();
702 0 : Client c = mal_clients+m->clientid;
703 0 : profilerEvent(NULL,
704 : &(struct NonMalEvent)
705 0 : { ROLLBACK , c, Tend, &ts_start, &m->session->tr->ts, 0, log_usec?Tend-Tbegin:0});
706 : }
707 61752 : if (chain) {
708 2 : if (sql_trans_begin(m->session) < 0) {
709 1 : msg = createException(SQL, "sql.rollback", SQLSTATE(40000) "ROLLBACK: finished successfully, but the session's schema could not be found while starting the next transaction");
710 1 : m->session->status = -1;
711 1 : return msg;
712 : }
713 1 : m->session->auto_commit = 0; /* disable auto-commit while chaining */
714 : }
715 : }
716 61766 : if (msg != MAL_SUCCEED) {
717 : m->session->status = -1;
718 : return msg;
719 : }
720 61766 : m->type = Q_TRANS;
721 61766 : TRC_INFO(SQL_TRANS,
722 : "Commit%s%s rolled back%s\n",
723 : name ? " " : "", name ? name : "",
724 : list_empty(tr->changes) ? " (no changes)" : "");
725 : return msg;
726 : }
727 :
728 : /* release all savepoints up including the given named savepoint
729 : * but keep the current changes.
730 : * */
731 : str
732 12 : mvc_release(mvc *m, const char *name)
733 : {
734 12 : sql_trans *tr = m->session->tr;
735 12 : str msg = MAL_SUCCEED;
736 :
737 12 : assert(tr && tr->active); /* only release active transactions */
738 :
739 12 : TRC_DEBUG(SQL_TRANS, "Release: %s\n", (name) ? name : "");
740 :
741 12 : if (!name && (msg = mvc_rollback(m, 0, name, false)) != MAL_SUCCEED) {
742 0 : m->session->status = -1;
743 0 : return msg;
744 : }
745 :
746 33 : while (tr && (!tr->name || strcmp(tr->name, name) != 0))
747 21 : tr = tr->parent;
748 12 : if (!tr || !tr->name || strcmp(tr->name, name) != 0) {
749 0 : msg = createException(SQL, "sql.release", SQLSTATE(42000) "RELEASE: no such savepoint: '%s'", name);
750 0 : m->session->status = -1;
751 0 : return msg;
752 : }
753 12 : tr = m->session->tr;
754 33 : while (!tr->name || strcmp(tr->name, name) != 0) {
755 : /* commit all intermediate savepoints */
756 21 : if (sql_trans_commit(tr) != SQL_OK)
757 0 : GDKfatal("release savepoints should not fail");
758 21 : m->session->tr = tr = sql_trans_destroy(tr);
759 : }
760 12 : _DELETE(m->session->tr->name); /* name will no longer be used */
761 12 : m->session->status = tr->status;
762 12 : if (!(m->session->schema = find_sql_schema(m->session->tr, m->session->schema_name))) {
763 0 : msg = createException(SQL, "sql.release", SQLSTATE(40000) "RELEASE: finished successfully, but the session's schema could not be found on the current transaction");
764 0 : m->session->status = -1;
765 0 : return msg;
766 : }
767 :
768 12 : m->type = Q_TRANS;
769 12 : return msg;
770 : }
771 :
772 : static void
773 75214 : _free(void *dummy, void *data)
774 : {
775 75214 : (void)dummy;
776 75214 : GDKfree(data);
777 75227 : }
778 :
779 : mvc *
780 37989 : mvc_create(sql_store *store, allocator *pa, int clientid, int debug, bstream *rs, stream *ws)
781 : {
782 37989 : mvc *m;
783 37989 : str sys_str = NULL;
784 :
785 37989 : assert(pa);
786 37989 : m = SA_ZNEW(pa, mvc);
787 37989 : if (!m)
788 : return NULL;
789 :
790 37989 : TRC_DEBUG(SQL_TRANS, "MVC create\n");
791 :
792 37989 : m->errstr[0] = '\0';
793 : /* if an error exceeds the buffer we don't want garbage at the end */
794 37989 : m->errstr[ERRSIZE-1] = '\0';
795 :
796 37989 : m->qc = qc_create(pa, clientid, 0);
797 37989 : if (!m->qc) {
798 : return NULL;
799 : }
800 37989 : m->pa = pa;
801 37989 : m->sa = NULL;
802 37989 : m->ta = sa_create(m->pa);
803 : #ifdef __has_builtin
804 : #if __has_builtin(__builtin_frame_address)
805 37989 : m->sp = (uintptr_t) __builtin_frame_address(0);
806 : #define BUILTIN_USED
807 : #endif
808 : #endif
809 : #ifndef BUILTIN_USED
810 : m->sp = (uintptr_t)(&m);
811 : #endif
812 : #undef BUILTIN_USED
813 :
814 37989 : m->params = NULL;
815 37989 : m->sizeframes = MAXPARAMS;
816 37989 : m->frames = SA_NEW_ARRAY(pa, sql_frame*, m->sizeframes);
817 37989 : m->topframes = 0;
818 37989 : m->frame = 0;
819 :
820 37989 : m->use_views = false;
821 37989 : if (!m->frames) {
822 0 : qc_destroy(m->qc);
823 0 : return NULL;
824 : }
825 :
826 37989 : m->sym = NULL;
827 :
828 37989 : m->role_id = m->user_id = -1;
829 37989 : m->timezone = 0;
830 37989 : m->sql_optimizer = INT_MAX;
831 37989 : m->clientid = clientid;
832 37989 : m->div_min_scale = 3;
833 :
834 37989 : m->emode = m_normal;
835 37989 : m->emod = mod_none;
836 37989 : m->reply_size = 100;
837 37989 : m->debug = debug;
838 :
839 37989 : m->label = 0;
840 37989 : m->nid = 1;
841 37989 : m->cascade_action = NULL;
842 37989 : m->runs = NULL;
843 :
844 37989 : if (init_global_variables(m) < 0) {
845 0 : qc_destroy(m->qc);
846 0 : list_destroy(m->global_vars);
847 0 : return NULL;
848 : }
849 :
850 37989 : if (!(m->schema_path = list_create((fdestroy)_free))) {
851 0 : qc_destroy(m->qc);
852 0 : list_destroy(m->global_vars);
853 0 : return NULL;
854 : }
855 37989 : if (!(sys_str = _STRDUP("sys")) || !list_append(m->schema_path, sys_str)) {
856 0 : _DELETE(sys_str);
857 0 : qc_destroy(m->qc);
858 0 : list_destroy(m->global_vars);
859 0 : list_destroy(m->schema_path);
860 0 : return NULL;
861 : }
862 37989 : m->schema_path_has_sys = true;
863 37989 : m->schema_path_has_tmp = false;
864 37989 : m->no_int128 = false;
865 37989 : m->store = store;
866 :
867 37989 : m->session = sql_session_create(m->store, m->pa, 1 /*autocommit on*/);
868 37989 : if (!m->session) {
869 0 : qc_destroy(m->qc);
870 0 : list_destroy(m->global_vars);
871 0 : list_destroy(m->schema_path);
872 0 : return NULL;
873 : }
874 :
875 37989 : m->type = Q_PARSE;
876 :
877 37989 : scanner_init(&m->scanner, rs, ws);
878 37989 : return m;
879 : }
880 :
881 : void
882 37989 : mvc_destroy(mvc *m)
883 : {
884 37989 : sql_trans *tr;
885 :
886 37989 : TRC_DEBUG(SQL_TRANS, "MVC destroy\n");
887 37989 : tr = m->session->tr;
888 37989 : if (tr) {
889 37989 : if (m->session->tr->active)
890 0 : (void)sql_trans_end(m->session, SQL_ERR);
891 37989 : while (tr->parent)
892 0 : m->session->tr = tr = sql_trans_destroy(tr);
893 : }
894 37989 : sql_session_destroy(m->session);
895 :
896 37989 : list_destroy(m->global_vars);
897 37989 : list_destroy(m->schema_path);
898 37989 : stack_pop_until(m, 0);
899 :
900 37989 : if (m->scanner.log) /* close and destroy stream */
901 0 : close_stream(m->scanner.log);
902 :
903 37989 : m->sa = NULL;
904 37989 : m->ta = NULL;
905 37989 : if (m->qc)
906 37989 : qc_destroy(m->qc);
907 37989 : m->qc = NULL;
908 37989 : }
909 :
910 : sql_type *
911 38834 : mvc_bind_type(mvc *sql, const char *name)
912 : {
913 38834 : sql_type *t = sql_trans_bind_type(sql->session->tr, NULL, name);
914 38834 : TRC_DEBUG(SQL_TRANS, "Bind type: %s\n", name);
915 38834 : return t;
916 : }
917 :
918 : sql_type *
919 2007 : schema_bind_type(mvc *sql, sql_schema *s, const char *name)
920 : {
921 2007 : sql_type *t = find_sql_type(sql->session->tr, s, name);
922 :
923 2007 : (void) sql;
924 2007 : if (!t)
925 : return NULL;
926 81 : TRC_DEBUG(SQL_TRANS, "Schema bind type: %s\n", name);
927 : return t;
928 : }
929 :
930 : sql_schema *
931 9252102 : mvc_bind_schema(mvc *m, const char *sname)
932 : {
933 9252102 : sql_trans *tr = m->session->tr;
934 9252102 : sql_schema *s;
935 :
936 9252102 : if (!tr)
937 : return NULL;
938 :
939 9252102 : s = find_sql_schema(tr, sname);
940 9265473 : if (!s)
941 : return NULL;
942 9195107 : TRC_DEBUG(SQL_TRANS, "Bind schema: %s\n", sname);
943 : return s;
944 : }
945 :
946 : sql_table *
947 5653012 : mvc_bind_table(mvc *m, sql_schema *s, const char *tname)
948 : {
949 5653012 : sql_table *t = find_sql_table(m->session->tr, s, tname);
950 :
951 5675990 : (void) m;
952 5675990 : if (!t)
953 : return NULL;
954 :
955 5396877 : TRC_DEBUG(SQL_TRANS, "Bind table: %s.%s\n", s->base.name, tname);
956 : return t;
957 : }
958 :
959 : sql_column *
960 4159531 : mvc_bind_column(mvc *m, sql_table *t, const char *cname)
961 : {
962 4159531 : sql_column *c;
963 :
964 4159531 : (void)m;
965 4159531 : c = find_sql_column(t, cname);
966 4198222 : if (!c)
967 : return NULL;
968 3989848 : TRC_DEBUG(SQL_TRANS, "Bind column: %s.%s\n", t->base.name, cname);
969 : return c;
970 : }
971 :
972 : static sql_column *
973 0 : first_column(sql_table *t)
974 : {
975 0 : node *n = ol_first_node(t->columns);
976 :
977 0 : if (n)
978 0 : return n->data;
979 : return NULL;
980 : }
981 :
982 : sql_column *
983 0 : mvc_first_column(mvc *m, sql_table *t)
984 : {
985 0 : sql_column *c = first_column(t);
986 :
987 0 : (void) m;
988 0 : if (!c)
989 : return NULL;
990 0 : TRC_DEBUG(SQL_TRANS, "First column: %s.%s\n", t->base.name, c->base.name);
991 : return c;
992 : }
993 :
994 : sql_key *
995 7402 : mvc_bind_key(mvc *m, sql_schema *s, const char *kname)
996 : {
997 7402 : sql_key *k = schema_find_key(m->session->tr, s, kname);
998 :
999 7402 : if (!k)
1000 : return NULL;
1001 53 : TRC_DEBUG(SQL_TRANS, "Bind key: %s.%s\n", s->base.name, kname);
1002 : return k;
1003 : }
1004 :
1005 : sql_idx *
1006 21061 : mvc_bind_idx(mvc *m, sql_schema *s, const char *iname)
1007 : {
1008 21061 : sql_idx *i = schema_find_idx(m->session->tr, s, iname);
1009 :
1010 21166 : if (!i)
1011 : return NULL;
1012 13605 : TRC_DEBUG(SQL_TRANS, "Bind index: %s.%s\n", s->base.name, iname);
1013 : return i;
1014 : }
1015 :
1016 : static int
1017 915 : uniqueKey(sql_key *k)
1018 : {
1019 915 : return (k->type == pkey || k->type == ukey);
1020 : }
1021 :
1022 : sql_key *
1023 905 : mvc_bind_ukey(sql_table *t, list *colnames)
1024 : {
1025 905 : node *cn;
1026 905 : node *cur;
1027 905 : sql_key *res = NULL;
1028 905 : int len = list_length(colnames);
1029 :
1030 905 : if (ol_length(t->keys))
1031 917 : for (cur = ol_first_node(t->keys); cur; cur = cur->next) {
1032 915 : node *cc;
1033 915 : sql_key *k = cur->data;
1034 :
1035 915 : if (uniqueKey(k) && list_length(k->columns) == len) {
1036 905 : res = k;
1037 1835 : for (cc = k->columns->h, cn = colnames->h; cc && cn; cc = cc->next, cn = cn->next) {
1038 935 : sql_kc *c = cc->data;
1039 935 : char *n = cn->data;
1040 :
1041 935 : if (strcmp(c->c->base.name, n) != 0) {
1042 : res = NULL;
1043 : break;
1044 : }
1045 : }
1046 905 : if (res)
1047 : break;
1048 : }
1049 : }
1050 905 : return res;
1051 : }
1052 :
1053 : sql_trigger *
1054 958 : mvc_bind_trigger(mvc *m, sql_schema *s, const char *tname)
1055 : {
1056 958 : sql_trigger *t = schema_find_trigger(m->session->tr, s, tname);
1057 :
1058 958 : if (!t)
1059 : return NULL;
1060 173 : TRC_DEBUG(SQL_TRANS, "Bind trigger: %s.%s\n", s->base.name, tname);
1061 : return t;
1062 : }
1063 :
1064 : int
1065 944 : mvc_create_type(mvc *sql, sql_schema *s, const char *name, unsigned int digits, unsigned int scale, int radix, const char *impl, list *fields)
1066 : {
1067 944 : TRC_DEBUG(SQL_TRANS, "Create type: %s\n", name);
1068 944 : return sql_trans_create_type(sql->session->tr, s, name, digits, scale, radix, impl, fields);
1069 : }
1070 :
1071 : int
1072 35 : mvc_drop_type(mvc *m, sql_schema *s, sql_type *t, int drop_action)
1073 : {
1074 35 : TRC_DEBUG(SQL_TRANS, "Drop type: %s %s\n", s->base.name, t->base.name);
1075 35 : if (t)
1076 69 : return sql_trans_drop_type(m->session->tr, s, t->base.id, drop_action ? DROP_CASCADE_START : DROP_RESTRICT);
1077 : return 0;
1078 : }
1079 :
1080 : int
1081 248798 : mvc_create_func(sql_func **f, mvc *m, allocator *sa, sql_schema *s, const char *name, list *args, list *res, sql_ftype type, sql_flang lang,
1082 : const char *mod, const char *impl, const char *query, bit varres, bit vararg, bit system, bit side_effect, bit order_required, bit opt_order)
1083 : {
1084 248798 : int lres = LOG_OK;
1085 :
1086 248798 : TRC_DEBUG(SQL_TRANS, "Create function: %s\n", name);
1087 248798 : if (sa) {
1088 124194 : *f = create_sql_func(m->store, sa, name, args, res, type, lang, mod, impl, query, varres, vararg, system, side_effect, order_required, opt_order);
1089 124194 : (*f)->s = s;
1090 : } else
1091 124604 : lres = sql_trans_create_func(f, m->session->tr, s, name, args, res, type, lang, mod, impl, query, varres, vararg, system, side_effect, order_required, opt_order);
1092 248798 : return lres;
1093 : }
1094 :
1095 : int
1096 662 : mvc_drop_func(mvc *m, sql_schema *s, sql_func *f, int drop_action)
1097 : {
1098 662 : TRC_DEBUG(SQL_TRANS, "Drop function: %s %s\n", s->base.name, f->base.name);
1099 1266 : return sql_trans_drop_func(m->session->tr, s, f->base.id, drop_action ? DROP_CASCADE_START : DROP_RESTRICT);
1100 : }
1101 :
1102 : int
1103 34 : mvc_drop_all_func(mvc *m, sql_schema *s, list *list_func, int drop_action)
1104 : {
1105 34 : TRC_DEBUG(SQL_TRANS, "Drop all functions: %s %s\n", s->base.name, ((sql_func *) list_func->h->data)->base.name);
1106 68 : return sql_trans_drop_all_func(m->session->tr, s, list_func, drop_action ? DROP_CASCADE_START : DROP_RESTRICT);
1107 : }
1108 :
1109 : int
1110 1100 : mvc_create_schema(mvc *m, const char *name, sqlid auth_id, sqlid owner)
1111 : {
1112 1100 : TRC_DEBUG(SQL_TRANS, "Create schema: %s %d %d\n", name, auth_id, owner);
1113 1100 : return sql_trans_create_schema(m->session->tr, name, auth_id, owner, NULL);
1114 : }
1115 :
1116 : int
1117 161 : mvc_drop_schema(mvc *m, sql_schema * s, int drop_action)
1118 : {
1119 161 : TRC_DEBUG(SQL_TRANS, "Drop schema: %s\n", s->base.name);
1120 241 : return sql_trans_drop_schema(m->session->tr, s->base.id, drop_action ? DROP_CASCADE_START : DROP_RESTRICT);
1121 : }
1122 :
1123 : int
1124 6053 : mvc_create_ukey(sql_key **kres, mvc *m, sql_table *t, const char *name, key_type kt, const char* check)
1125 : {
1126 6053 : int res = LOG_OK;
1127 :
1128 6053 : TRC_DEBUG(SQL_TRANS, "Create ukey: %s %u\n", t->base.name, (unsigned) kt);
1129 6053 : if (t->persistence == SQL_DECLARED_TABLE)
1130 6053 : *kres = create_sql_ukey(m->store, m->sa, t, name, kt, check);
1131 : else
1132 0 : res = sql_trans_create_ukey(kres, m->session->tr, t, name, kt, check);
1133 6053 : return res;
1134 : }
1135 :
1136 : int
1137 6975 : mvc_create_key_done(mvc *m, sql_key *k)
1138 : {
1139 6975 : int res = LOG_OK;
1140 :
1141 6975 : if (k->t->persistence == SQL_DECLARED_TABLE)
1142 6975 : key_create_done(m->session->tr, m->sa, k);
1143 : else
1144 0 : res = sql_trans_key_done(m->session->tr, k);
1145 6975 : return res;
1146 : }
1147 :
1148 : int
1149 941 : mvc_create_fkey(sql_fkey **kres, mvc *m, sql_table *t, const char *name, key_type kt, sql_key *rkey, int on_delete, int on_update)
1150 : {
1151 941 : int res = LOG_OK;
1152 :
1153 941 : TRC_DEBUG(SQL_TRANS, "Create fkey: %s %u %p\n", t->base.name, (unsigned) kt, rkey);
1154 941 : if (t->persistence == SQL_DECLARED_TABLE)
1155 941 : *kres = create_sql_fkey(m->store, m->sa, t, name, kt, rkey, on_delete, on_update);
1156 : else
1157 0 : res = sql_trans_create_fkey(kres, m->session->tr, t, name, kt, rkey, on_delete, on_update);
1158 941 : return res;
1159 : }
1160 :
1161 : int
1162 6664 : mvc_create_kc(mvc *m, sql_key *k, sql_column *c)
1163 : {
1164 6664 : int res = LOG_OK;
1165 :
1166 6664 : if (k->t->persistence == SQL_DECLARED_TABLE)
1167 6664 : create_sql_kc(m->store, m->sa, k, c);
1168 : else
1169 0 : res = sql_trans_create_kc(m->session->tr, k, c);
1170 6664 : return res;
1171 : }
1172 :
1173 : int
1174 962 : mvc_create_fkc(mvc *m, sql_fkey *fk, sql_column *c)
1175 : {
1176 962 : int res = LOG_OK;
1177 962 : sql_key *k = (sql_key*)fk;
1178 :
1179 962 : if (k->t->persistence == SQL_DECLARED_TABLE)
1180 962 : create_sql_kc(m->store, m->sa, k, c);
1181 : else
1182 0 : res = sql_trans_create_fkc(m->session->tr, fk, c);
1183 962 : return res;
1184 : }
1185 :
1186 : int
1187 146 : mvc_drop_key(mvc *m, sql_schema *s, sql_key *k, int drop_action)
1188 : {
1189 146 : TRC_DEBUG(SQL_TRANS, "Drop key: %s %s\n", s->base.name, k->base.name);
1190 146 : if (k->t->persistence == SQL_DECLARED_TABLE) {
1191 0 : drop_sql_key(k->t, k->base.id, drop_action);
1192 0 : return 0;
1193 : } else
1194 291 : return sql_trans_drop_key(m->session->tr, s, k->base.id, drop_action ? DROP_CASCADE_START : DROP_RESTRICT);
1195 : }
1196 :
1197 : int
1198 337 : mvc_create_idx(sql_idx **i, mvc *m, sql_table *t, const char *name, idx_type it)
1199 : {
1200 337 : int res = LOG_OK;
1201 :
1202 337 : TRC_DEBUG(SQL_TRANS, "Create index: %s %u\n", t->base.name, (unsigned) it);
1203 337 : if (t->persistence == SQL_DECLARED_TABLE)
1204 : /* declared tables should not end up in the catalog */
1205 337 : *i = create_sql_idx(m->store, m->sa, t, name, it);
1206 : else
1207 0 : res = sql_trans_create_idx(i, m->session->tr, t, name, it);
1208 337 : return res;
1209 : }
1210 :
1211 : int
1212 431 : mvc_create_ic(mvc *m, sql_idx *i, sql_column *c)
1213 : {
1214 431 : int res = LOG_OK;
1215 :
1216 431 : if (i->t->persistence == SQL_DECLARED_TABLE)
1217 : /* declared tables should not end up in the catalog */
1218 431 : create_sql_ic(m->store, m->sa, i, c);
1219 : else
1220 0 : res = sql_trans_create_ic(m->session->tr, i, c);
1221 431 : return res;
1222 : }
1223 :
1224 : int
1225 335 : mvc_create_idx_done(mvc *m, sql_idx *i)
1226 : {
1227 335 : int res = LOG_OK;
1228 :
1229 335 : (void) m;
1230 335 : (void) create_sql_idx_done(m->session->tr, i);
1231 335 : return res;
1232 : }
1233 :
1234 : int
1235 159 : mvc_drop_idx(mvc *m, sql_schema *s, sql_idx *i)
1236 : {
1237 159 : TRC_DEBUG(SQL_TRANS, "Drop index: %s %s\n", s->base.name, i->base.name);
1238 159 : if (i->t->persistence == SQL_DECLARED_TABLE) {
1239 : /* declared tables should not end up in the catalog */
1240 0 : drop_sql_idx(i->t, i->base.id);
1241 0 : return 0;
1242 : } else
1243 159 : return sql_trans_drop_idx(m->session->tr, s, i->base.id, DROP_RESTRICT);
1244 : }
1245 :
1246 : int
1247 347 : mvc_create_trigger(sql_trigger **tri, mvc *m, sql_table *t, const char *name, sht time, sht orientation, sht event, const char *old_name,
1248 : const char *new_name, const char *condition, const char *statement)
1249 : {
1250 347 : TRC_DEBUG(SQL_TRANS, "Create trigger: %s %d %d %d\n", t->base.name, time, orientation, event);
1251 347 : return sql_trans_create_trigger(tri, m->session->tr, t, name, time, orientation, event, old_name, new_name, condition, statement);
1252 : }
1253 :
1254 : int
1255 89 : mvc_drop_trigger(mvc *m, sql_schema *s, sql_trigger *tri)
1256 : {
1257 89 : TRC_DEBUG(SQL_TRANS, "Drop trigger: %s %s\n", s->base.name, tri->base.name);
1258 89 : return sql_trans_drop_trigger(m->session->tr, s, tri->base.id, DROP_RESTRICT);
1259 : }
1260 :
1261 : int
1262 11717 : mvc_create_table(sql_table **t, mvc *m, sql_schema *s, const char *name, int tt, bit system, int persistence, int commit_action, int sz, bit properties)
1263 : {
1264 11717 : char *err = NULL;
1265 11717 : int res = LOG_OK;
1266 :
1267 11717 : assert(s);
1268 11717 : TRC_DEBUG(SQL_TRANS, "Create table: %s %s %d %d %d %d %d\n", s->base.name, name, tt, system, persistence, commit_action, (int)properties);
1269 11717 : if (persistence == SQL_DECLARED_TABLE) {
1270 10343 : *t = create_sql_table(m->store, m->sa, name, tt, system, persistence, commit_action, properties);
1271 10344 : (*t)->s = s;
1272 : } else {
1273 1374 : res = sql_trans_create_table(t, m->session->tr, s, name, NULL, tt, system, persistence, commit_action, sz, properties);
1274 1374 : if (res == LOG_OK && isPartitionedByExpressionTable(*t) && (err = bootstrap_partition_expression(m, *t, 1))) {
1275 0 : (void) sql_error(m, 02, "%s", err);
1276 0 : return -5;
1277 : }
1278 1374 : if (res == LOG_OK)
1279 1374 : res = sql_trans_set_partition_table(m->session->tr, *t);
1280 : }
1281 : return res;
1282 : }
1283 :
1284 : int
1285 23402 : mvc_create_view(sql_table **t, mvc *m, sql_schema *s, const char *name, int persistence, const char *sql, bit system)
1286 : {
1287 23402 : int res = LOG_OK;
1288 :
1289 23402 : TRC_DEBUG(SQL_TRANS, "Create view: %s %s %s\n", s->base.name, name, sql);
1290 23402 : if (persistence == SQL_DECLARED_TABLE) {
1291 22912 : *t = create_sql_table(m->store, m->sa, name, tt_view, system, persistence, 0, 0);
1292 22912 : (*t)->s = s;
1293 22912 : (*t)->query = sa_strdup(m->sa, sql);
1294 : } else {
1295 490 : res = sql_trans_create_table(t, m->session->tr, s, name, sql, tt_view, system, SQL_PERSIST, 0, 0, 0);
1296 : }
1297 23402 : return res;
1298 : }
1299 :
1300 : int
1301 101 : mvc_create_remote(sql_table **t, mvc *m, sql_schema *s, const char *name, int persistence, const char *loc)
1302 : {
1303 101 : int res = LOG_OK;
1304 :
1305 : // verify and normalize url
1306 101 : msettings *mp = sa_msettings_create(m->sa);
1307 101 : if (mp == NULL) {
1308 0 : (void) sql_error(m, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
1309 0 : return LOG_ERR;
1310 : }
1311 101 : msettings_error err = msettings_parse_url(mp, loc);
1312 101 : if (err != NULL) {
1313 0 : (void) sql_error(m, 02, SQLSTATE(42000) "invalid remote table url: %s", err);
1314 0 : return LOG_ERR;
1315 : }
1316 101 : char *url = sa_msettings_to_string(mp, m->sa, strlen(loc));
1317 :
1318 101 : TRC_DEBUG(SQL_TRANS, "Create remote: %s %s %s\n", s->base.name, name, url);
1319 101 : if (persistence == SQL_DECLARED_TABLE) {
1320 101 : *t = create_sql_table(m->store, m->sa, name, tt_remote, 0, persistence, 0, 0);
1321 101 : (*t)->s = s;
1322 101 : (*t)->query = url;
1323 : } else {
1324 0 : res = sql_trans_create_table(t, m->session->tr, s, name, url, tt_remote, 0, SQL_REMOTE, 0, 0, 0);
1325 : }
1326 : return res;
1327 : }
1328 :
1329 : static str
1330 35 : remote_drop(mvc *m, sql_table *t)
1331 : {
1332 35 : sqlid id = t->base.id;
1333 35 : int log_res = 0;
1334 35 : sql_trans *tr = m->session->tr;
1335 35 : sqlstore *store = tr->store;
1336 35 : sql_schema *sys = find_sql_schema(tr, "sys");
1337 35 : sql_table *remote_user_info = find_sql_table(tr, sys, REMOTE_USER_INFO);
1338 35 : sql_column *remote_user_info_id = find_sql_column(remote_user_info, "table_id");
1339 35 : oid rid = store->table_api.column_find_row(tr, remote_user_info_id, &id, NULL);
1340 35 : if (is_oid_nil(rid)) {
1341 1 : TRC_WARNING(SQL_TRANS, "Drop table: %s %s no remote info\n", t->s->base.name, t->base.name);
1342 34 : } else if ((log_res = store->table_api.table_delete(tr, remote_user_info, rid)) != 0)
1343 0 : throw(SQL, "sql.drop_table", SQLSTATE(42000) "Drop table failed%s", log_res == LOG_CONFLICT ? " due to conflict with another transaction" : "");
1344 : return MAL_SUCCEED;
1345 : }
1346 :
1347 : str
1348 4250 : mvc_drop_table(mvc *m, sql_schema *s, sql_table *t, int drop_action)
1349 : {
1350 4250 : char *msg = NULL;
1351 4250 : TRC_DEBUG(SQL_TRANS, "Drop table: %s %s\n", s->base.name, t->base.name);
1352 :
1353 4250 : if (isRemote(t) && (msg = remote_drop(m, t)) != NULL)
1354 : return msg;
1355 :
1356 7819 : switch (sql_trans_drop_table(m->session->tr, s, t->base.name, drop_action ? DROP_CASCADE_START : DROP_RESTRICT)) {
1357 0 : case -1:
1358 0 : throw(SQL,"sql.mvc_drop_table",SQLSTATE(HY013) MAL_MALLOC_FAIL);
1359 0 : case -2:
1360 : case -3:
1361 0 : throw(SQL, "sql.mvc_drop_table", SQLSTATE(42000) "Transaction conflict while dropping table %s.%s", s->base.name, t->base.name);
1362 : default:
1363 : break;
1364 : }
1365 : return MAL_SUCCEED;
1366 : }
1367 :
1368 : BUN
1369 41803 : mvc_clear_table(mvc *m, sql_table *t)
1370 : {
1371 41803 : return sql_trans_clear_table(m->session->tr, t);
1372 : }
1373 :
1374 : int
1375 10151 : mvc_create_column_(sql_column **col, mvc *m, sql_table *t, const char *name, const char *type, unsigned int digits)
1376 : {
1377 10151 : sql_subtype tpe;
1378 :
1379 10151 : if (!sql_find_subtype(&tpe, type, digits, 0))
1380 : return -1;
1381 :
1382 10151 : return sql_trans_create_column(col, m->session->tr, t, name, &tpe);
1383 : }
1384 :
1385 : int
1386 261966 : mvc_create_column(sql_column **col, mvc *m, sql_table *t, const char *name, sql_subtype *tpe)
1387 : {
1388 261966 : int res = LOG_OK;
1389 :
1390 261966 : TRC_DEBUG(SQL_TRANS, "Create column: %s %s %s\n", t->base.name, name, tpe->type->base.name);
1391 261966 : if (t->persistence == SQL_DECLARED_TABLE)
1392 : /* declared tables should not end up in the catalog */
1393 261966 : *col = create_sql_column(m->store, m->sa, t, name, tpe);
1394 : else
1395 0 : res = sql_trans_create_column(col, m->session->tr, t, name, tpe);
1396 261966 : return res;
1397 : }
1398 :
1399 : int
1400 136 : mvc_drop_column(mvc *m, sql_table *t, sql_column *col, int drop_action)
1401 : {
1402 136 : TRC_DEBUG(SQL_TRANS, "Drop column: %s %s\n", t->base.name, col->base.name);
1403 136 : if (col->t->persistence == SQL_DECLARED_TABLE) {
1404 68 : drop_sql_column(t, col->base.id, drop_action);
1405 68 : return 0;
1406 : } else
1407 128 : return sql_trans_drop_column(m->session->tr, t, col->base.id, drop_action ? DROP_CASCADE_START : DROP_RESTRICT);
1408 : }
1409 :
1410 : int
1411 378436 : mvc_create_dependency(mvc *m, sql_base *b, sqlid depend_id, sql_dependency depend_type)
1412 : {
1413 378436 : int res = LOG_OK;
1414 :
1415 378436 : TRC_DEBUG(SQL_TRANS, "Create dependency: %d %d %d\n", b->id, depend_id, (int) depend_type);
1416 378436 : if ( (b->id != depend_id) || (depend_type == BEDROPPED_DEPENDENCY) ) {
1417 378435 : if (!b->new)
1418 227096 : res = sql_trans_add_dependency(m->session->tr, b->id, ddl);
1419 227096 : if (res == LOG_OK)
1420 378435 : res = sql_trans_create_dependency(m->session->tr, b->id, depend_id, depend_type);
1421 : }
1422 378436 : return res;
1423 : }
1424 :
1425 : int
1426 148863 : mvc_create_dependencies(mvc *m, list *blist, sqlid depend_id, sql_dependency dep_type)
1427 : {
1428 148863 : int res = LOG_OK;
1429 :
1430 148863 : TRC_DEBUG(SQL_TRANS, "Create dependencies on '%d' of type: %d\n", depend_id, (int) dep_type);
1431 148863 : if (!list_empty(blist)) {
1432 392654 : for (node *n = blist->h ; n && res == LOG_OK ; n = n->next) {
1433 364425 : sql_base *b = n->data;
1434 364425 : if (!b->new) /* only add old objects to the transaction dependency list */
1435 227052 : res = sql_trans_add_dependency(m->session->tr, b->id, ddl);
1436 364425 : if (res == LOG_OK)
1437 364425 : res = mvc_create_dependency(m, b, depend_id, dep_type);
1438 : }
1439 : }
1440 148863 : return res;
1441 : }
1442 :
1443 : int
1444 4738 : mvc_check_dependency(mvc *m, sqlid id, sql_dependency type, list *ignore_ids)
1445 : {
1446 4738 : list *dep_list = NULL;
1447 :
1448 4738 : TRC_DEBUG(SQL_TRANS, "Check dependency on: %d\n", id);
1449 4738 : switch (type) {
1450 107 : case OWNER_DEPENDENCY:
1451 107 : dep_list = sql_trans_owner_schema_dependencies(m->session->tr, id);
1452 107 : break;
1453 17 : case SCHEMA_DEPENDENCY:
1454 17 : dep_list = sql_trans_schema_user_dependencies(m->session->tr, id);
1455 17 : if (!dep_list)
1456 17 : dep_list = sql_trans_get_dependents(m->session->tr, id, SCHEMA_DEPENDENCY, NULL);
1457 : break;
1458 3327 : case TABLE_DEPENDENCY:
1459 3327 : dep_list = sql_trans_get_dependents(m->session->tr, id, TABLE_DEPENDENCY, NULL);
1460 3327 : break;
1461 327 : case VIEW_DEPENDENCY:
1462 327 : dep_list = sql_trans_get_dependents(m->session->tr, id, TABLE_DEPENDENCY, NULL);
1463 327 : break;
1464 654 : case FUNC_DEPENDENCY:
1465 : case PROC_DEPENDENCY:
1466 654 : dep_list = sql_trans_get_dependents(m->session->tr, id, FUNC_DEPENDENCY, ignore_ids);
1467 654 : break;
1468 306 : default:
1469 306 : dep_list = sql_trans_get_dependents(m->session->tr, id, COLUMN_DEPENDENCY, NULL);
1470 : }
1471 :
1472 4738 : if (!dep_list)
1473 : return DEPENDENCY_CHECK_ERROR;
1474 :
1475 4738 : if (list_length(dep_list) >= 2) {
1476 49 : list_destroy(dep_list);
1477 49 : return HAS_DEPENDENCY;
1478 : }
1479 :
1480 4689 : list_destroy(dep_list);
1481 4689 : return NO_DEPENDENCY;
1482 : }
1483 :
1484 : int
1485 17315 : mvc_null(mvc *m, sql_column *col, int isnull)
1486 : {
1487 17315 : TRC_DEBUG(SQL_TRANS, "Null: %s %d\n", col->base.name, isnull);
1488 17315 : if (col->t->persistence == SQL_DECLARED_TABLE) {
1489 17218 : col->null = isnull;
1490 17218 : return 0;
1491 : }
1492 97 : return sql_trans_alter_null(m->session->tr, col, isnull);
1493 : }
1494 :
1495 : int
1496 1442 : mvc_default(mvc *m, sql_column *col, char *val)
1497 : {
1498 1442 : TRC_DEBUG(SQL_TRANS, "Default: %s %s\n", col->base.name, val);
1499 1442 : if (col->t->persistence == SQL_DECLARED_TABLE) {
1500 1419 : col->def = val?sa_strdup(m->sa, val):NULL;
1501 1419 : return 0;
1502 : } else {
1503 23 : return sql_trans_alter_default(m->session->tr, col, val);
1504 : }
1505 : }
1506 :
1507 : int
1508 6 : mvc_drop_default(mvc *m, sql_column *col)
1509 : {
1510 6 : TRC_DEBUG(SQL_TRANS, "Drop default: %s\n", col->base.name);
1511 6 : if (col->t->persistence == SQL_DECLARED_TABLE) {
1512 6 : col->def = NULL;
1513 6 : return 0;
1514 : } else {
1515 0 : return sql_trans_alter_default(m->session->tr, col, NULL);
1516 : }
1517 : }
1518 :
1519 : int
1520 0 : mvc_storage(mvc *m, sql_column *col, char *storage)
1521 : {
1522 0 : TRC_DEBUG(SQL_TRANS, "Storage: %s %s\n", col->base.name, storage);
1523 0 : if (col->t->persistence == SQL_DECLARED_TABLE) {
1524 0 : col->storage_type = storage?sa_strdup(m->sa, storage):NULL;
1525 0 : return 0;
1526 : } else {
1527 0 : return sql_trans_alter_storage(m->session->tr, col, storage);
1528 : }
1529 : }
1530 :
1531 : int
1532 2349 : mvc_access(mvc *m, sql_table *t, sht access)
1533 : {
1534 2349 : TRC_DEBUG(SQL_TRANS, "Access: %s %d\n", t->base.name, access);
1535 2349 : if (t->persistence == SQL_DECLARED_TABLE) {
1536 0 : t->access = access;
1537 0 : return 0;
1538 : }
1539 2349 : return sql_trans_alter_access(m->session->tr, t, access);
1540 : }
1541 :
1542 : int
1543 18797 : mvc_is_sorted(mvc *m, sql_column *col)
1544 : {
1545 18797 : TRC_DEBUG(SQL_TRANS, "Is sorted: %s\n", col->base.name);
1546 18797 : return sql_trans_is_sorted(m->session->tr, col);
1547 : }
1548 :
1549 : int
1550 6810 : mvc_is_unique(mvc *m, sql_column *col)
1551 : {
1552 6810 : TRC_DEBUG(SQL_TRANS, "Is unique: %s\n", col->base.name);
1553 6810 : return sql_trans_is_unique(m->session->tr, col);
1554 : }
1555 :
1556 : int
1557 1868 : mvc_is_duplicate_eliminated(mvc *m, sql_column *col)
1558 : {
1559 1868 : TRC_DEBUG(SQL_TRANS, "Is duplicate eliminated: %s\n", col->base.name);
1560 1868 : return sql_trans_is_duplicate_eliminated(m->session->tr, col);
1561 : }
1562 :
1563 : int
1564 4375730 : mvc_col_stats(mvc *m, sql_column *col, bool *nonil, bool *unique, double *unique_est, ValPtr min, ValPtr max)
1565 : {
1566 4375730 : TRC_DEBUG(SQL_TRANS, "Retrieving column stats for: %s\n", col->base.name);
1567 4375730 : return sql_trans_col_stats(m->session->tr, col, nonil, unique, unique_est, min, max);
1568 : }
1569 :
1570 : int
1571 261521 : mvc_copy_column(mvc *m, sql_table *t, sql_column *c, sql_column **cres)
1572 : {
1573 261521 : return sql_trans_copy_column(m->session->tr, t, c, cres);
1574 : }
1575 :
1576 : int
1577 6952 : mvc_copy_key(mvc *m, sql_table *t, sql_key *k, sql_key **kres)
1578 : {
1579 6952 : return sql_trans_copy_key(m->session->tr, t, k, kres);
1580 : }
1581 :
1582 : int
1583 7249 : mvc_copy_idx(mvc *m, sql_table *t, sql_idx *i, sql_idx **ires)
1584 : {
1585 7249 : return sql_trans_copy_idx(m->session->tr, t, i, ires);
1586 : }
1587 :
1588 : int
1589 0 : mvc_copy_trigger(mvc *m, sql_table *t, sql_trigger *tr, sql_trigger **tres)
1590 : {
1591 0 : return sql_trans_copy_trigger(m->session->tr, t, tr, tres);
1592 : }
1593 :
1594 : sql_rel *
1595 768590 : sql_processrelation(mvc *sql, sql_rel *rel, int profile, int instantiate, int value_based_opt, int storage_based_opt)
1596 : {
1597 768590 : int emode = sql->emode;
1598 768590 : if (!instantiate)
1599 147845 : sql->emode = m_deps;
1600 768590 : if (rel)
1601 768590 : rel = rel_unnest(sql, rel);
1602 769017 : sql->emode = emode;
1603 769017 : if (rel)
1604 769000 : rel = rel_optimizer(sql, rel, profile, instantiate, value_based_opt, storage_based_opt);
1605 769036 : return rel;
1606 : }
1607 :
1608 : static inline int dlist_cmp(mvc *sql, dlist *l1, dlist *l2);
1609 :
1610 : static inline int
1611 457 : dnode_cmp(mvc *sql, dnode *d1, dnode *d2)
1612 : {
1613 457 : if (d1 == d2)
1614 : return 0;
1615 :
1616 457 : if (!d1 || !d2)
1617 : return -1;
1618 :
1619 457 : if (d1->type == d2->type) {
1620 457 : switch (d1->type) {
1621 37 : case type_int:
1622 37 : return (d1->data.i_val - d2->data.i_val);
1623 0 : case type_lng: {
1624 0 : lng c = d1->data.l_val - d2->data.l_val;
1625 0 : assert((lng) GDK_int_min <= c && c <= (lng) GDK_int_max);
1626 0 : return (int) c;
1627 : }
1628 225 : case type_string:
1629 225 : if (d1->data.sval == d2->data.sval)
1630 : return 0;
1631 225 : if (!d1->data.sval || !d2->data.sval)
1632 : return -1;
1633 225 : return strcmp(d1->data.sval, d2->data.sval);
1634 95 : case type_list:
1635 95 : return dlist_cmp(sql, d1->data.lval, d2->data.lval);
1636 100 : case type_symbol:
1637 100 : return symbol_cmp(sql, d1->data.sym, d2->data.sym);
1638 0 : case type_type:
1639 0 : return subtype_cmp(&d1->data.typeval, &d2->data.typeval);
1640 : default:
1641 0 : assert(0);
1642 : }
1643 : }
1644 : return -1;
1645 : }
1646 :
1647 : static inline int
1648 349 : dlist_cmp(mvc *sql, dlist *l1, dlist *l2)
1649 : {
1650 349 : int res = 0;
1651 349 : dnode *d1, *d2;
1652 :
1653 349 : if (l1 == l2)
1654 : return 0;
1655 :
1656 349 : if (!l1 || !l2 || dlist_length(l1) != dlist_length(l2))
1657 48 : return -1;
1658 :
1659 758 : for (d1 = l1->h, d2 = l2->h; !res && d1; d1 = d1->next, d2 = d2->next) {
1660 457 : res = dnode_cmp(sql, d1, d2);
1661 : }
1662 : return res;
1663 : }
1664 :
1665 : static inline int
1666 32 : AtomNodeCmp(AtomNode *a1, AtomNode *a2)
1667 : {
1668 32 : if (a1 == a2)
1669 : return 0;
1670 32 : if (!a1 || !a2)
1671 : return -1;
1672 32 : if (a1->a && a2->a)
1673 32 : return atom_cmp(a1->a, a2->a);
1674 : return -1;
1675 : }
1676 :
1677 : static inline int
1678 0 : SelectNodeCmp(mvc *sql, SelectNode *s1, SelectNode *s2)
1679 : {
1680 0 : if (s1 == s2)
1681 : return 0;
1682 0 : if (!s1 || !s2)
1683 : return -1;
1684 :
1685 0 : if (symbol_cmp(sql, s1->limit, s2->limit) == 0 &&
1686 0 : symbol_cmp(sql, s1->offset, s2->offset) == 0 &&
1687 0 : symbol_cmp(sql, s1->sample, s2->sample) == 0 &&
1688 0 : symbol_cmp(sql, s1->seed, s2->seed) == 0 &&
1689 0 : s1->distinct == s2->distinct &&
1690 0 : s1->lateral == s2->lateral &&
1691 0 : symbol_cmp(sql, s1->name, s2->name) == 0 &&
1692 0 : symbol_cmp(sql, s1->orderby, s2->orderby) == 0 &&
1693 0 : symbol_cmp(sql, s1->having, s2->having) == 0 &&
1694 0 : symbol_cmp(sql, s1->groupby, s2->groupby) == 0 &&
1695 0 : symbol_cmp(sql, s1->where, s2->where) == 0 &&
1696 0 : symbol_cmp(sql, s1->from, s2->from) == 0 &&
1697 0 : symbol_cmp(sql, s1->window, s2->window) == 0 &&
1698 0 : dlist_cmp(sql, s1->selection, s2->selection) == 0)
1699 : return 0;
1700 : return -1;
1701 : }
1702 :
1703 : static inline int
1704 301 : _symbol_cmp(mvc *sql, symbol *s1, symbol *s2)
1705 : {
1706 301 : if (s1 == s2)
1707 : return 0;
1708 290 : if (!s1 || !s2)
1709 : return -1;
1710 290 : if (s1->token != s2->token || s1->type != s2->type)
1711 : return -1;
1712 286 : switch (s1->type) {
1713 0 : case type_int:
1714 0 : return (s1->data.i_val - s2->data.i_val);
1715 0 : case type_lng: {
1716 0 : lng c = s1->data.l_val - s2->data.l_val;
1717 0 : assert((lng) GDK_int_min <= c && c <= (lng) GDK_int_max);
1718 0 : return (int) c;
1719 : }
1720 0 : case type_string:
1721 0 : if (s1->data.sval == s2->data.sval)
1722 : return 0;
1723 0 : if (!s1->data.sval || !s2->data.sval)
1724 : return -1;
1725 0 : return strcmp(s1->data.sval, s2->data.sval);
1726 254 : case type_list: {
1727 254 : return dlist_cmp(sql, s1->data.lval, s2->data.lval);
1728 : }
1729 0 : case type_type:
1730 0 : return subtype_cmp(&s1->data.typeval, &s2->data.typeval);
1731 32 : case type_symbol:
1732 32 : if (s1->token == SQL_SELECT) {
1733 0 : if (s2->token != SQL_SELECT)
1734 : return -1;
1735 0 : return SelectNodeCmp(sql, (SelectNode *) s1, (SelectNode *) s2);
1736 32 : } else if (s1->token == SQL_ATOM) {
1737 32 : if (s2->token != SQL_ATOM)
1738 : return -1;
1739 32 : return AtomNodeCmp((AtomNode *) s1, (AtomNode *) s2);
1740 : } else {
1741 0 : return symbol_cmp(sql, s1->data.sym, s2->data.sym);
1742 : }
1743 : default:
1744 0 : assert(0);
1745 : }
1746 : return 0; /* never reached, just to pacify compilers */
1747 : }
1748 :
1749 : int
1750 301 : symbol_cmp(mvc *sql, symbol *s1, symbol *s2)
1751 : {
1752 301 : return _symbol_cmp(sql, s1, s2);
1753 : }
|
