Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024, 2025 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : /*
14 : * authors M Kersten, N Nes
15 : * SQL support implementation
16 : * This module contains the wrappers around the SQL
17 : * multi-version-catalog and support routines copied
18 : * from the Version 4 code base.
19 : */
20 : #include "monetdb_config.h"
21 : #include "sql.h"
22 : #include "mapi_prompt.h"
23 : #include "sql_result.h"
24 : #include "sql_storage.h"
25 : #include "sql_scenario.h"
26 : #include "store_sequence.h"
27 : #include "sql_partition.h"
28 : #include "rel_partition.h"
29 : #include "rel_basetable.h"
30 : #include "rel_rel.h"
31 : #include "rel_exp.h"
32 : #include "rel_dump.h"
33 : #include "rel_physical.h"
34 : #include "rel_remote.h"
35 : #include "mal.h"
36 : #include "mal_client.h"
37 : #include "mal_interpreter.h"
38 : #include "mal_resolve.h"
39 : #include "mal_client.h"
40 : #include "mal_interpreter.h"
41 : #include "mal_scenario.h"
42 : #include "mal_profiler.h"
43 : #include "bat5.h"
44 : #include "opt_pipes.h"
45 : #include "clients.h"
46 : #include "mal_instruction.h"
47 : #include "mal_resource.h"
48 : #include "mal_authorize.h"
49 : #include "json.h"
50 :
51 : static inline void
52 0 : BBPnreclaim(int nargs, ...)
53 : {
54 0 : va_list valist;
55 0 : va_start(valist, nargs);
56 0 : for (int i = 0; i < nargs; i++) {
57 0 : BAT *b = va_arg(valist, BAT *);
58 0 : BBPreclaim(b);
59 : }
60 0 : va_end(valist);
61 0 : }
62 :
63 : static int
64 22800 : rel_is_table(sql_rel *rel)
65 : {
66 22800 : if (!rel || is_base(rel->op))
67 15137 : return 1;
68 : return 0;
69 : }
70 :
71 : static int
72 15137 : exp_is_point_select(sql_exp *e)
73 : {
74 15137 : if (!e)
75 : return 1;
76 15137 : if (e->type == e_cmp && !e->f && e->flag == (int) cmp_equal) {
77 7765 : sql_exp *r = e->r;
78 7765 : sql_exp *l = e->l;
79 :
80 7765 : if (!is_func(l->type) && r->card <= CARD_AGGR)
81 7631 : return 1;
82 : }
83 : return 0;
84 : }
85 :
86 : static int
87 614879 : rel_no_mitosis(mvc *sql, sql_rel *rel)
88 : {
89 1428204 : if (mvc_highwater(sql))
90 : return 0;
91 1046210 : if (!rel || is_basetable(rel->op))
92 : return 1;
93 : /* use mitosis on order topn */
94 862465 : if (is_topn(rel->op)) {
95 16637 : sql_rel *l = rel->l;
96 16637 : if (l && is_simple_project(l->op) && l->r)
97 : return 0;
98 : }
99 862181 : if (is_topn(rel->op) || is_sample(rel->op) || is_simple_project(rel->op))
100 328598 : return rel_no_mitosis(sql, rel->l);
101 533583 : if (is_ddl(rel->op) && rel->flag == ddl_output) {
102 : // COPY SELECT ... INTO
103 74 : return rel_no_mitosis(sql, rel->l);
104 : }
105 533509 : if ((is_delete(rel->op) || is_truncate(rel->op)) && rel->card <= CARD_AGGR)
106 : return 1;
107 491938 : if ((is_insert(rel->op) || is_update(rel->op)) && rel->card <= CARD_AGGR)
108 102481 : return rel_no_mitosis(sql, rel->r);
109 404594 : if (is_select(rel->op) && rel_is_table(rel->l) && !list_empty(rel->exps)) {
110 : /* just one point expression makes this a point query */
111 15137 : if (exp_is_point_select(rel->exps->h->data))
112 : return 1;
113 : }
114 : return 0;
115 : }
116 :
117 : static int
118 382128 : rel_need_distinct_query(sql_rel *rel)
119 : {
120 382128 : int need_distinct = 0;
121 :
122 427623 : while (rel && is_simple_project(rel->op))
123 45495 : rel = rel->l;
124 382128 : if (rel && is_groupby(rel->op) && !list_empty(rel->exps) && list_empty(rel->r)) {
125 2085 : for (node *n = rel->exps->h; n && !need_distinct; n = n->next) {
126 1122 : sql_exp *e = n->data;
127 :
128 1122 : if (e->type == e_aggr && need_distinct(e))
129 1122 : need_distinct = 1;
130 : }
131 : }
132 382128 : return need_distinct;
133 : }
134 :
135 : sql_rel *
136 617817 : sql_symbol2relation(backend *be, symbol *sym)
137 : {
138 617817 : sql_rel *rel;
139 617817 : sql_query *query = query_create(be->mvc);
140 617982 : lng Tbegin, Tend;
141 617982 : int value_based_opt = be->mvc->emode != m_prepare, storage_based_opt;
142 617982 : int profile = be->mvc->emode == m_plan;
143 617982 : Client c = be->client;
144 :
145 617982 : Tbegin = GDKusec();
146 618116 : rel = rel_semantic(query, sym);
147 617525 : Tend = GDKusec();
148 617704 : if(profilerStatus > 0 )
149 0 : profilerEvent(NULL,
150 : &(struct NonMalEvent)
151 0 : {SQL_TO_REL, c, Tend, NULL, NULL, rel?0:1, Tend-Tbegin});
152 :
153 617704 : storage_based_opt = value_based_opt && rel && !is_ddl(rel->op);
154 335532 : Tbegin = Tend;
155 2686 : if (rel)
156 615365 : rel = sql_processrelation(be->mvc, rel, profile, 1, value_based_opt, storage_based_opt);
157 615421 : if (rel)
158 615399 : rel = rel_partition(be->mvc, rel);
159 614893 : if (rel && (rel_no_mitosis(be->mvc, rel) || rel_need_distinct_query(rel)))
160 233360 : be->no_mitosis = 1;
161 615452 : if (rel /*&& (be->mvc->emode != m_plan || (ATOMIC_GET(&GDKdebug) & FORCEMITOMASK) == 0)*/)
162 615452 : rel = rel_physical(be->mvc, rel);
163 617768 : Tend = GDKusec();
164 617971 : be->reloptimizer = Tend - Tbegin;
165 :
166 617971 : if(profilerStatus > 0)
167 0 : profilerEvent(NULL,
168 : &(struct NonMalEvent)
169 0 : {REL_OPT, c, Tend, NULL, NULL, rel?0:1, be->reloptimizer});
170 617971 : return rel;
171 : }
172 :
173 : /*
174 : * After the SQL statement has been executed, its data structures
175 : * should be garbage collected. For successful actions we have to finish
176 : * the transaction as well, e.g. commit or rollback.
177 : */
178 : int
179 787801 : sqlcleanup(backend *be, int err)
180 : {
181 787801 : sql_destroy_params(be->mvc);
182 :
183 : /* some statements dynamically disable caching */
184 787974 : be->mvc->sym = NULL;
185 787974 : be->mvc->runs = NULL;
186 787974 : if (be->mvc->ta)
187 787882 : be->mvc->ta = sa_reset(be->mvc->ta);
188 787970 : if (be->mvc->sa)
189 787603 : be->mvc->sa = sa_reset(be->mvc->sa);
190 788015 : if (err >0)
191 382 : be->mvc->session->status = -err;
192 788015 : if (err <0)
193 34980 : be->mvc->session->status = err;
194 788015 : be->mvc->label = 0;
195 788015 : be->mvc->nid = 1;
196 788015 : be->no_mitosis = 0;
197 788015 : mvc_query_processed(be->mvc);
198 787940 : return err;
199 : }
200 :
201 : /*
202 : * The internal administration of the MAL compiler and execution state
203 : * is administered by a state descriptor accessible in each phase.
204 : * Failure to find the state descriptor aborts the session.
205 : */
206 :
207 : str
208 9042162 : checkSQLContext(Client cntxt)
209 : {
210 9042162 : backend *be;
211 :
212 9042162 : if (cntxt == NULL)
213 0 : throw(SQL, "mvc", SQLSTATE(42005) "No client record");
214 9042162 : if (cntxt->sqlcontext == NULL)
215 0 : throw(SQL, "mvc", SQLSTATE(42006) "SQL module not initialized");
216 9042162 : be = (backend *) cntxt->sqlcontext;
217 9042162 : if (be->mvc == NULL)
218 0 : throw(SQL, "mvc", SQLSTATE(42006) "SQL module not initialized, mvc struct missing");
219 : return MAL_SUCCEED;
220 : }
221 :
222 : str
223 129771 : getBackendContext(Client cntxt, backend **be)
224 : {
225 129771 : str msg;
226 :
227 129771 : if ((msg = checkSQLContext(cntxt)) != MAL_SUCCEED)
228 : return msg;
229 129775 : *be = (backend *) cntxt->sqlcontext;
230 129775 : return MAL_SUCCEED;
231 : }
232 :
233 : str
234 4402484 : getSQLContext(Client cntxt, MalBlkPtr mb, mvc **c, backend **b)
235 : {
236 4402484 : backend *be;
237 4402484 : (void) mb;
238 4402484 : str msg;
239 :
240 4402484 : if ((msg = checkSQLContext(cntxt)) != MAL_SUCCEED)
241 : return msg;
242 4410723 : be = (backend *) cntxt->sqlcontext;
243 4410723 : if (c)
244 4410723 : *c = be->mvc;
245 4410723 : if (b)
246 54 : *b = be;
247 : return MAL_SUCCEED;
248 : }
249 :
250 : str
251 390439 : SQLmvc(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
252 : {
253 390439 : mvc *sql = NULL;
254 390439 : str msg;
255 390439 : int *res = getArgReference_int(stk, pci, 0);
256 :
257 390439 : if ((msg = getSQLContext(cntxt, mb, &sql, NULL)) != NULL)
258 : return msg;
259 390448 : if ((msg = checkSQLContext(cntxt)) != NULL)
260 : return msg;
261 390446 : *res = 0;
262 390446 : return MAL_SUCCEED;
263 : }
264 :
265 : static str
266 2 : SQLshutdown_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
267 : {
268 2 : str msg;
269 :
270 2 : if ((msg = CLTshutdown(cntxt, mb, stk, pci)) == MAL_SUCCEED) {
271 : /* administer the shutdown in the system log */
272 2 : TRC_INFO(SQL_TRANS, "Shutdown: %s\n", *getArgReference_str(stk, pci, 0));
273 : }
274 2 : return msg;
275 : }
276 :
277 : static str
278 1 : SQLset_protocol(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
279 : {
280 1 : const int protocol = *getArgReference_int(stk, pci, 1);
281 :
282 1 : (void) mb;
283 1 : (void) stk;
284 :
285 1 : if (!(
286 1 : protocol == PROTOCOL_AUTO ||
287 : protocol == PROTOCOL_9 ||
288 1 : protocol == PROTOCOL_COLUMNAR))
289 : {
290 0 : return createException(SQL, "sql.set_protocol", "unknown protocol: %d", protocol);
291 : }
292 :
293 1 : *getArgReference_int(stk, pci, 0) = (cntxt->protocol = (protocol_version) protocol);
294 :
295 1 : return MAL_SUCCEED;
296 : }
297 :
298 : str
299 33146 : create_table_or_view(mvc *sql, char *sname, char *tname, sql_table *t, int temp, int replace)
300 : {
301 33146 : allocator *osa;
302 33146 : sql_schema *s = mvc_bind_schema(sql, sname);
303 33146 : sql_table *nt = NULL, *ot;
304 33146 : node *n;
305 33146 : int check = 0;
306 33146 : const char *action = (temp == SQL_DECLARED_TABLE) ? "DECLARE" : (replace ? "CREATE OR REPLACE" : "CREATE");
307 33146 : const char *obj = t->query ? "VIEW" : "TABLE";
308 33146 : str msg = MAL_SUCCEED;
309 :
310 33146 : if (store_readonly(sql->session->tr->store))
311 0 : throw(SQL, "sql.catalog", SQLSTATE(25006) "schema statements cannot be executed on a readonly database.");
312 :
313 33146 : if (!s)
314 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "%s %s: schema '%s' doesn't exist", action, obj, sname);
315 33146 : if (temp != SQL_DECLARED_TABLE && (!mvc_schema_privs(sql, s) && !(isTempSchema(s) && temp == SQL_LOCAL_TEMP)))
316 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: insufficient privileges for user '%s' in schema '%s'",
317 : action, obj, get_string_global_var(sql, "current_user"), s->base.name);
318 33146 : if ((ot = mvc_bind_table(sql, s, t->base.name))) {
319 19 : if (replace) {
320 19 : if (ot->type != t->type)
321 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: unable to drop %s '%s': is a %s",
322 0 : action, obj, obj, t->base.name, TABLE_TYPE_DESCRIPTION(ot->type, ot->properties));
323 19 : if (ot->system)
324 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: cannot replace system %s '%s'", action, obj, obj, t->base.name);
325 19 : if (mvc_check_dependency(sql, ot->base.id, isView(ot) ? VIEW_DEPENDENCY : TABLE_DEPENDENCY, NULL))
326 2 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: cannot replace %s '%s', there are database objects which depend on it",
327 : action, obj, obj, t->base.name);
328 17 : if ((msg = mvc_drop_table(sql, s, ot, 0)) != MAL_SUCCEED)
329 : return msg;
330 : } else {
331 0 : throw(SQL, "sql.catalog", SQLSTATE(42S01) "%s %s: name '%s' already in use", action, obj, t->base.name);
332 : }
333 : }
334 33144 : if (temp == SQL_DECLARED_TABLE && ol_length(t->keys))
335 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: '%s' cannot have constraints", action, obj, t->base.name);
336 :
337 33144 : switch (sql_trans_create_table(&nt, sql->session->tr, s, tname, t->query, t->type, t->system, temp, t->commit_action, t->sz, t->properties)) {
338 0 : case -1:
339 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
340 4 : case -2:
341 : case -3:
342 4 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: '%s' name conflicts", action, obj, t->base.name);
343 : default:
344 33140 : break;
345 : }
346 33140 : osa = sql->sa;
347 33140 : allocator *nsa = sql->sa = sa_create(NULL);
348 : /* first check default values */
349 294551 : for (n = ol_first_node(t->columns); n; n = n->next) {
350 261412 : sql_column *c = n->data;
351 :
352 261412 : if (c->def) {
353 : /* TODO please don't place an auto incremented sequence in the default value */
354 1393 : const char next_value_for[] = "next value for \"sys\".\"seq_";
355 1393 : sql_rel *r = NULL;
356 :
357 1393 : sa_reset(nsa);
358 1393 : sql->sa = nsa;
359 1393 : r = rel_parse(sql, s, sa_message(sql->ta, "select %s;", c->def), m_deps);
360 2786 : if (!r || !is_project(r->op) || !r->exps || list_length(r->exps) != 1 ||
361 1393 : exp_check_type(sql, &c->type, r, r->exps->h->data, type_equal) == NULL) {
362 1 : if (r)
363 1 : rel_destroy(r);
364 1 : sa_destroy(nsa);
365 1 : sql->sa = osa;
366 1 : if (strlen(sql->errstr) > 6 && sql->errstr[5] == '!')
367 1 : throw(SQL, "sql.catalog", "%s", sql->errstr);
368 : else
369 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s", sql->errstr);
370 : }
371 : /* For a self incremented column, it's sequence will get a BEDROPPED_DEPENDENCY,
372 : so no additional dependencies are needed */
373 1392 : if (strncmp(c->def, next_value_for, strlen(next_value_for)) != 0) {
374 1183 : list *blist = rel_dependencies(sql, r);
375 1183 : if (mvc_create_dependencies(sql, blist, nt->base.id, FUNC_DEPENDENCY)) {
376 0 : sa_destroy(nsa);
377 0 : sql->sa = osa;
378 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
379 : }
380 : }
381 1392 : sa_reset(sql->sa);
382 : }
383 : }
384 :
385 294550 : for (n = ol_first_node(t->columns); n; n = n->next) {
386 261411 : sql_column *c = n->data, *copied = NULL;
387 :
388 261411 : switch (mvc_copy_column(sql, nt, c, &copied)) {
389 0 : case -1:
390 0 : sa_destroy(nsa);
391 0 : sql->sa = osa;
392 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
393 0 : case -2:
394 : case -3:
395 0 : sa_destroy(nsa);
396 0 : sql->sa = osa;
397 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s_%s conflicts", s->base.name, t->base.name, c->base.name);
398 : default:
399 261411 : break;
400 : }
401 261411 : if (isPartitionedByColumnTable(t) && c->base.id == t->part.pcol->base.id)
402 80 : nt->part.pcol = copied;
403 : }
404 33139 : if (isPartitionedByExpressionTable(t)) {
405 27 : char *err = NULL;
406 :
407 27 : _DELETE(nt->part.pexp->exp);
408 27 : nt->part.pexp->exp = _STRDUP(t->part.pexp->exp);
409 27 : err = bootstrap_partition_expression(sql, nt, 1);
410 27 : if (err) {
411 3 : sa_destroy(nsa);
412 3 : sql->sa = osa;
413 3 : return err;
414 : }
415 24 : sa_reset(nsa);
416 : }
417 33136 : check = sql_trans_set_partition_table(sql->session->tr, nt);
418 33136 : if (check == -4) {
419 0 : sa_destroy(nsa);
420 0 : sql->sa = osa;
421 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s: the partition's expression is too long", s->base.name, t->base.name);
422 33136 : } else if (check) {
423 0 : sa_destroy(nsa);
424 0 : sql->sa = osa;
425 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s: an internal error occurred", s->base.name, t->base.name);
426 : }
427 :
428 33136 : if (t->idxs) {
429 39290 : for (n = ol_first_node(t->idxs); n; n = n->next) {
430 6154 : sql_idx *i = n->data;
431 :
432 6154 : switch (mvc_copy_idx(sql, nt, i, NULL)) {
433 0 : case -1:
434 0 : sa_destroy(nsa);
435 0 : sql->sa = osa;
436 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
437 0 : case -2:
438 : case -3:
439 0 : sa_destroy(nsa);
440 0 : sql->sa = osa;
441 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s_%s index conflicts", s->base.name, t->base.name, i->base.name);
442 : default:
443 6154 : break;
444 : }
445 : }
446 : }
447 33136 : if (t->keys) {
448 39301 : for (n = ol_first_node(t->keys); n; n = n->next) {
449 6172 : sql_key *k = n->data;
450 6172 : char *err = NULL;
451 :
452 6172 : err = sql_partition_validate_key(sql, nt, k, "CREATE");
453 6172 : if (err) {
454 6 : sa_destroy(nsa);
455 6 : sql->sa = osa;
456 6 : return err;
457 : }
458 6166 : sa_reset(sql->sa);
459 6166 : switch (mvc_copy_key(sql, nt, k, NULL)) {
460 1 : case -1:
461 1 : sa_destroy(nsa);
462 1 : sql->sa = osa;
463 1 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
464 0 : case -2:
465 : case -3:
466 0 : sa_destroy(nsa);
467 0 : sql->sa = osa;
468 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s_%s constraint conflicts", s->base.name, t->base.name, k->base.name);
469 : default:
470 6165 : break;
471 : }
472 6165 : sa_reset(sql->sa);
473 : }
474 : }
475 33129 : if (t->triggers) {
476 33129 : for (n = ol_first_node(t->triggers); n; n = n->next) {
477 0 : sql_trigger *tr = n->data;
478 :
479 0 : switch (mvc_copy_trigger(sql, nt, tr, NULL)) {
480 0 : case -1:
481 0 : sa_destroy(nsa);
482 0 : sql->sa = osa;
483 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
484 0 : case -2:
485 : case -3:
486 0 : sa_destroy(nsa);
487 0 : sql->sa = osa;
488 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s_%s trigger conflicts", s->base.name, t->base.name, nt->base.name);
489 : default:
490 0 : break;
491 : }
492 : }
493 : }
494 : /* also create dependencies when not renaming */
495 33129 : if (nt->query && isView(nt)) {
496 22908 : sql_rel *r = NULL;
497 :
498 22908 : sa_reset(nsa);
499 22908 : r = rel_parse(sql, s, nt->query, m_deps);
500 22908 : if (r)
501 22908 : r = sql_processrelation(sql, r, 0, 0, 0, 0);
502 22908 : if (r) {
503 22908 : list *blist = rel_dependencies(sql, r);
504 22908 : if (mvc_create_dependencies(sql, blist, nt->base.id, VIEW_DEPENDENCY)) {
505 0 : sa_destroy(nsa);
506 0 : sql->sa = osa;
507 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
508 : }
509 : }
510 22908 : sql->sa = osa;
511 22908 : if (!r) {
512 0 : sa_destroy(nsa);
513 0 : if (strlen(sql->errstr) > 6 && sql->errstr[5] == '!')
514 0 : throw(SQL, "sql.catalog", "%s", sql->errstr);
515 : else
516 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s", sql->errstr);
517 : }
518 : }
519 33129 : sa_destroy(nsa);
520 33129 : sql->sa = osa;
521 33129 : return MAL_SUCCEED;
522 : }
523 :
524 : static int
525 109544 : mvc_claim_slots(sql_trans *tr, sql_table *t, size_t cnt, BUN *offset, BAT **pos)
526 : {
527 109544 : sqlstore *store = tr->store;
528 109544 : return store->storage_api.claim_tab(tr, t, cnt, offset, pos);
529 : }
530 :
531 : str
532 109276 : mvc_claim_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
533 : {
534 109276 : BUN *offset = (BUN*)getArgReference_oid(stk, pci, 0);
535 109276 : bat *res = getArgReference_bat(stk, pci, 1);
536 109276 : mvc *m = NULL;
537 109276 : str msg;
538 109276 : const char *sname = *getArgReference_str(stk, pci, 3);
539 109276 : const char *tname = *getArgReference_str(stk, pci, 4);
540 109276 : lng cnt = *getArgReference_lng(stk, pci, 5);
541 109276 : BAT *pos = NULL;
542 109276 : sql_schema *s;
543 109276 : sql_table *t;
544 :
545 109276 : *res = 0;
546 109276 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
547 : return msg;
548 109421 : if ((msg = checkSQLContext(cntxt)) != NULL)
549 : return msg;
550 :
551 109416 : s = mvc_bind_schema(m, sname);
552 109375 : if (s == NULL)
553 0 : throw(SQL, "sql.claim", SQLSTATE(3F000) "Schema missing %s", sname);
554 109375 : t = mvc_bind_table(m, s, tname);
555 109531 : if (t == NULL)
556 0 : throw(SQL, "sql.claim", SQLSTATE(42S02) "Table missing %s.%s", sname, tname);
557 109531 : if (!isTable(t))
558 0 : throw(SQL, "sql.claim", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
559 109531 : if (mvc_claim_slots(m->session->tr, t, (size_t)cnt, offset, &pos) == LOG_OK) {
560 109394 : *res = bat_nil;
561 109394 : if (pos) {
562 7 : *res = pos->batCacheid;
563 7 : BBPkeepref(pos);
564 : }
565 109435 : return MAL_SUCCEED;
566 : }
567 0 : throw(SQL, "sql.claim", SQLSTATE(3F000) "Could not claim slots");
568 : }
569 :
570 : str
571 138416 : mvc_add_dependency_change(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
572 : {
573 138416 : str msg;
574 138416 : mvc *m = NULL;
575 138416 : const char *sname = *getArgReference_str(stk, pci, 1);
576 138416 : const char *tname = *getArgReference_str(stk, pci, 2);
577 138416 : lng cnt = *getArgReference_lng(stk, pci, 3);
578 138416 : sql_schema *s;
579 138416 : sql_table *t;
580 :
581 138416 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
582 : return msg;
583 138584 : if ((msg = checkSQLContext(cntxt)) != NULL)
584 : return msg;
585 :
586 138641 : if ((s = mvc_bind_schema(m, sname)) == NULL)
587 0 : throw(SQL, "sql.dependency_change", SQLSTATE(3F000) "Schema missing %s", sname);
588 138661 : if ((t = mvc_bind_table(m, s, tname)) == NULL)
589 0 : throw(SQL, "sql.dependency_change", SQLSTATE(42S02) "Table missing %s.%s", sname, tname);
590 138569 : if (!isTable(t))
591 0 : throw(SQL, "sql.dependency_change", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
592 138569 : if (cnt > 0 && !isNew(t) && isGlobal(t) && !isGlobalTemp(t) && sql_trans_add_dependency_change(m->session->tr, t->base.id, dml) != LOG_OK)
593 0 : throw(SQL, "sql.dependency_change", SQLSTATE(HY013) MAL_MALLOC_FAIL);
594 : return MAL_SUCCEED;
595 : }
596 :
597 : str
598 13393 : mvc_add_column_predicate(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
599 : {
600 13393 : str msg;
601 13393 : mvc *m = NULL;
602 13393 : const char *sname = *getArgReference_str(stk, pci, 1);
603 13393 : const char *tname = *getArgReference_str(stk, pci, 2);
604 13393 : const char *cname = *getArgReference_str(stk, pci, 3);
605 13393 : sql_schema *s;
606 13393 : sql_table *t;
607 13393 : sql_column *c;
608 :
609 13393 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
610 : return msg;
611 13394 : if ((msg = checkSQLContext(cntxt)) != NULL)
612 : return msg;
613 :
614 13395 : if ((s = mvc_bind_schema(m, sname)) == NULL)
615 0 : throw(SQL, "sql.column_predicate", SQLSTATE(3F000) "Schema missing %s", sname);
616 13395 : if ((t = mvc_bind_table(m, s, tname)) == NULL)
617 0 : throw(SQL, "sql.column_predicate", SQLSTATE(42S02) "Table missing %s.%s", sname, tname);
618 13395 : if ((c = mvc_bind_column(m, t, cname)) == NULL)
619 0 : throw(SQL, "sql.column_predicate", SQLSTATE(42S22) "Column not found in %s.%s.%s",sname,tname,cname);
620 :
621 13395 : if ((m->session->level & tr_snapshot) == tr_snapshot || isNew(c) || !isGlobal(c->t) || isGlobalTemp(c->t))
622 : return MAL_SUCCEED;
623 6296 : if (sql_trans_add_predicate(m->session->tr, c, 0, NULL, NULL, false, false) != LOG_OK)
624 0 : throw(SQL, "sql.column_predicate", SQLSTATE(HY013) MAL_MALLOC_FAIL);
625 : return MAL_SUCCEED;
626 : }
627 :
628 : str
629 1 : create_table_from_emit(Client cntxt, char *sname, char *tname, sql_emit_col *columns, size_t ncols)
630 : {
631 1 : size_t i;
632 1 : sql_table *t = NULL;
633 1 : sql_schema *s = NULL;
634 1 : mvc *sql = NULL;
635 1 : str msg = MAL_SUCCEED;
636 :
637 1 : if ((msg = getSQLContext(cntxt, NULL, &sql, NULL)) != NULL)
638 : return msg;
639 1 : if ((msg = checkSQLContext(cntxt)) != NULL)
640 : return msg;
641 :
642 1 : if (!sname)
643 0 : sname = "sys";
644 1 : if (!(s = mvc_bind_schema(sql, sname)))
645 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "CREATE TABLE: no such schema '%s'", sname);
646 1 : if (!mvc_schema_privs(sql, s))
647 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: Access denied for %s to schema '%s'", get_string_global_var(sql, "current_user"), s->base.name);
648 1 : switch (mvc_create_table(&t, sql, s, tname, tt_table, 0, SQL_DECLARED_TABLE, CA_COMMIT, -1, 0)) {
649 0 : case -1:
650 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
651 0 : case -2:
652 : case -3:
653 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: transaction conflict detected");
654 : default:
655 : break;
656 : }
657 :
658 3 : for (i = 0; i < ncols; i++) {
659 2 : BAT *b = columns[i].b;
660 2 : const char *atomname = ATOMname(b->ttype);
661 2 : sql_subtype tpe;
662 2 : sql_column *col = NULL;
663 :
664 2 : if (!strcmp(atomname, "str"))
665 2 : sql_find_subtype(&tpe, "varchar", 0, 0);
666 : else {
667 0 : sql_subtype *t = sql_bind_localtype(atomname);
668 0 : if (!t)
669 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "CREATE TABLE: could not find type for column");
670 0 : tpe = *t;
671 : }
672 :
673 2 : if (columns[i].name && columns[i].name[0] == '%')
674 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: generated labels not allowed in column names, use an alias instead");
675 2 : if (tpe.type->eclass == EC_ANY)
676 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: any type (plain null value) not allowed as a column type, use an explicit cast");
677 2 : switch (mvc_create_column(&col, sql, t, columns[i].name, &tpe)) {
678 0 : case -1:
679 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
680 0 : case -2:
681 : case -3:
682 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: transaction conflict detected");
683 : default:
684 2 : break;
685 : }
686 : }
687 1 : if ((msg = create_table_or_view(sql, sname, t->base.name, t, 0, 0)) != MAL_SUCCEED)
688 : return msg;
689 1 : if (!(t = mvc_bind_table(sql, s, tname)))
690 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "CREATE TABLE: could not bind table %s", tname);
691 1 : BUN offset;
692 1 : BAT *pos = NULL;
693 1 : if (mvc_claim_slots(sql->session->tr, t, BATcount(columns[0].b), &offset, &pos) != LOG_OK)
694 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "CREATE TABLE: Could not insert data");
695 3 : for (i = 0; i < ncols; i++) {
696 2 : BAT *b = columns[i].b;
697 2 : sql_column *col = NULL;
698 :
699 2 : if (!(col = mvc_bind_column(sql, t, columns[i].name))) {
700 0 : bat_destroy(pos);
701 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "CREATE TABLE: could not bind column %s", columns[i].name);
702 : }
703 2 : if ((msg = mvc_append_column(sql->session->tr, col, offset, pos, b)) != MAL_SUCCEED) {
704 0 : bat_destroy(pos);
705 0 : return msg;
706 : }
707 : }
708 1 : bat_destroy(pos);
709 1 : return msg;
710 : }
711 :
712 : str
713 12 : append_to_table_from_emit(Client cntxt, char *sname, char *tname, sql_emit_col *columns, size_t ncols)
714 : {
715 12 : size_t i;
716 12 : sql_table *t;
717 12 : sql_schema *s;
718 12 : mvc *sql = NULL;
719 12 : str msg = MAL_SUCCEED;
720 :
721 12 : if ((msg = getSQLContext(cntxt, NULL, &sql, NULL)) != NULL)
722 : return msg;
723 12 : if ((msg = checkSQLContext(cntxt)) != NULL)
724 : return msg;
725 :
726 12 : if (!sname)
727 0 : sname = "sys";
728 12 : if (!(s = mvc_bind_schema(sql, sname)))
729 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "APPEND TABLE: no such schema '%s'", sname);
730 12 : if (!(t = mvc_bind_table(sql, s, tname)))
731 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "APPEND TABLE: could not bind table %s", tname);
732 12 : if (!isTable(t))
733 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "APPEND TABLE: %s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
734 12 : BUN offset;
735 12 : BAT *pos = NULL;
736 12 : if (mvc_claim_slots(sql->session->tr, t, BATcount(columns[0].b), &offset, &pos) != LOG_OK)
737 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "APPEND TABLE: Could not append data");
738 62 : for (i = 0; i < ncols; i++) {
739 50 : BAT *b = columns[i].b;
740 50 : sql_column *col = NULL;
741 :
742 50 : if (!(col = mvc_bind_column(sql, t, columns[i].name))) {
743 0 : bat_destroy(pos);
744 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "APPEND TABLE: could not bind column %s", columns[i].name);
745 : }
746 50 : if ((msg = mvc_append_column(sql->session->tr, col, offset, pos, b)) != MAL_SUCCEED) {
747 0 : bat_destroy(pos);
748 0 : return msg;
749 : }
750 : }
751 12 : bat_destroy(pos);
752 16 : if (BATcount(columns[0].b) > 0 && !isNew(t) && isGlobal(t) && !isGlobalTemp(t) &&
753 4 : sql_trans_add_dependency_change(sql->session->tr, t->base.id, dml) != LOG_OK)
754 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
755 : return msg;
756 : }
757 :
758 : BAT *
759 257 : mvc_bind(mvc *m, const char *sname, const char *tname, const char *cname, int access)
760 : {
761 257 : sql_trans *tr = m->session->tr;
762 257 : BAT *b = NULL;
763 257 : sql_schema *s = NULL;
764 257 : sql_table *t = NULL;
765 257 : sql_column *c = NULL;
766 :
767 257 : s = mvc_bind_schema(m, sname);
768 257 : if (s == NULL)
769 : return NULL;
770 257 : t = mvc_bind_table(m, s, tname);
771 257 : if (t == NULL || !isTable(t))
772 : return NULL;
773 257 : c = mvc_bind_column(m, t, cname);
774 257 : if (c == NULL)
775 : return NULL;
776 :
777 257 : sqlstore *store = tr->store;
778 257 : b = store->storage_api.bind_col(tr, c, access);
779 257 : return b;
780 : }
781 :
782 : /* setVariable(int *ret, str *sname, str *name, any value) */
783 : str
784 384 : setVariable(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
785 : {
786 384 : int *res = getArgReference_int(stk, pci, 0);
787 384 : mvc *m = NULL;
788 384 : str msg;
789 384 : const char *sname = *getArgReference_str(stk, pci, 2);
790 384 : const char *varname = *getArgReference_str(stk, pci, 3);
791 384 : int mtype = getArgType(mb, pci, 4);
792 384 : sql_schema *s;
793 384 : sql_var *var;
794 :
795 384 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
796 : return msg;
797 384 : if ((msg = checkSQLContext(cntxt)) != NULL)
798 : return msg;
799 :
800 384 : if (!(s = mvc_bind_schema(m, sname)))
801 0 : throw(SQL, "sql.setVariable", SQLSTATE(3F000) "Cannot find the schema '%s'", sname);
802 :
803 384 : *res = 0;
804 384 : if (mtype < 0 || mtype >= 255)
805 0 : throw(SQL, "sql.setVariable", SQLSTATE(42100) "Variable type error");
806 :
807 384 : if ((var = find_global_var(m, s, varname))) {
808 524 : if (!strcmp("sys", s->base.name) && !strcmp("optimizer", varname)) {
809 167 : const char *newopt = *getArgReference_str(stk, pci, 4);
810 167 : char buf[18];
811 :
812 167 : if (strNil(newopt))
813 27 : throw(SQL, "sql.setVariable", SQLSTATE(42000) "Variable '%s.%s' cannot be NULL", sname, varname);
814 167 : if (!isOptimizerPipe(newopt) && strchr(newopt, (int) ';') == 0)
815 5 : throw(SQL, "sql.setVariable", SQLSTATE(42100) "optimizer '%s' unknown", newopt);
816 162 : (void) snprintf(buf, sizeof(buf), "user_%d", cntxt->idx); /* should always suffice */
817 162 : if (!isOptimizerPipe(newopt) || strcmp(buf, newopt) == 0) {
818 23 : if ((msg = addPipeDefinition(cntxt, buf, newopt)))
819 : return msg;
820 1 : if (!sqlvar_set_string(find_global_var(m, s, varname), buf))
821 0 : throw(SQL, "sql.setVariable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
822 139 : } else if (!sqlvar_set_string(find_global_var(m, s, varname), newopt))
823 0 : throw(SQL, "sql.setVariable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
824 : } else {
825 217 : ValPtr ptr = &stk->stk[getArg(pci, 4)];
826 :
827 217 : if ((msg = sql_update_var(m, s, varname, ptr)))
828 : return msg;
829 202 : if (!sqlvar_set(var, ptr))
830 0 : throw(SQL, "sql.setVariable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
831 : }
832 342 : return MAL_SUCCEED;
833 : }
834 0 : throw(SQL, "sql.setVariable", SQLSTATE(42100) "Variable '%s.%s' unknown", sname, varname);
835 : }
836 :
837 : /* getVariable(int *ret, str *name) */
838 : str
839 435 : getVariable(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
840 : {
841 435 : int mtype = getArgType(mb, pci, 0);
842 435 : mvc *m = NULL;
843 435 : str msg;
844 435 : const char *sname = *getArgReference_str(stk, pci, 2);
845 435 : const char *varname = *getArgReference_str(stk, pci, 3);
846 435 : ValRecord *dst, *src;
847 435 : sql_schema *s;
848 435 : sql_var *var;
849 :
850 435 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
851 : return msg;
852 435 : if ((msg = checkSQLContext(cntxt)) != NULL)
853 : return msg;
854 :
855 435 : if (!(s = mvc_bind_schema(m, sname)))
856 0 : throw(SQL, "sql.getVariable", SQLSTATE(3F000) "Cannot find the schema '%s'", sname);
857 435 : if (mtype < 0 || mtype >= 255)
858 0 : throw(SQL, "sql.getVariable", SQLSTATE(42100) "Variable type error");
859 435 : if (!(var = find_global_var(m, s, varname)))
860 0 : throw(SQL, "sql.getVariable", SQLSTATE(42100) "Variable '%s.%s' unknown", sname, varname);
861 435 : src = &(var->var.data);
862 435 : dst = &stk->stk[getArg(pci, 0)];
863 435 : if (VALcopy(dst, src) == NULL)
864 0 : throw(MAL, "sql.getVariable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
865 : return MAL_SUCCEED;
866 : }
867 :
868 : str
869 1 : sql_variables(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
870 : {
871 1 : mvc *m = NULL;
872 1 : BAT *schemas, *names, *types, *values;
873 1 : str msg = MAL_SUCCEED;
874 1 : bat *s = getArgReference_bat(stk,pci,0);
875 1 : bat *n = getArgReference_bat(stk,pci,1);
876 1 : bat *t = getArgReference_bat(stk,pci,2);
877 1 : bat *v = getArgReference_bat(stk,pci,3);
878 1 : int nvars;
879 :
880 1 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
881 : return msg;
882 1 : if ((msg = checkSQLContext(cntxt)) != NULL)
883 : return msg;
884 :
885 1 : nvars = list_length(m->global_vars);
886 1 : schemas = COLnew(0, TYPE_str, nvars, TRANSIENT);
887 1 : names = COLnew(0, TYPE_str, nvars, TRANSIENT);
888 1 : types = COLnew(0, TYPE_str, nvars, TRANSIENT);
889 1 : values = COLnew(0, TYPE_str, nvars, TRANSIENT);
890 1 : if (!schemas || !names || !types || !values) {
891 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) MAL_MALLOC_FAIL);
892 0 : goto bailout;
893 : }
894 :
895 1 : if (m->global_vars) {
896 11 : for (node *n = m->global_vars->h; n ; n = n->next) {
897 10 : sql_var *var = (sql_var*) n->data;
898 10 : atom value = var->var;
899 10 : ValPtr myptr = &(value.data);
900 10 : ValRecord val = (ValRecord) {.vtype = TYPE_void,};
901 10 : gdk_return res;
902 :
903 10 : if (value.tpe.type->localtype != TYPE_str) {
904 6 : ptr ok = VALcopy(&val, myptr);
905 6 : if (ok)
906 6 : ok = VALconvert(TYPE_str, &val);
907 6 : if (!ok) {
908 0 : VALclear(&val);
909 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) "Failed to convert variable '%s.%s' into a string", var->sname, var->name);
910 0 : goto bailout;
911 : }
912 : myptr = &val;
913 : }
914 10 : res = BUNappend(values, VALget(myptr), false);
915 10 : VALclear(&val);
916 10 : if (res != GDK_SUCCEED) {
917 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) MAL_MALLOC_FAIL);
918 0 : goto bailout;
919 : }
920 10 : if (BUNappend(schemas, var->sname, false) != GDK_SUCCEED) {
921 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) MAL_MALLOC_FAIL);
922 0 : goto bailout;
923 : }
924 10 : if (BUNappend(names, var->name, false) != GDK_SUCCEED) {
925 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) MAL_MALLOC_FAIL);
926 0 : goto bailout;
927 : }
928 10 : if (BUNappend(types, value.tpe.type->base.name, false) != GDK_SUCCEED) {
929 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) MAL_MALLOC_FAIL);
930 0 : goto bailout;
931 : }
932 : }
933 : }
934 :
935 1 : bailout:
936 0 : if (msg) {
937 0 : BBPreclaim(schemas);
938 0 : BBPreclaim(names);
939 0 : BBPreclaim(types);
940 0 : BBPreclaim(values);
941 : } else {
942 1 : *s = schemas->batCacheid;
943 1 : BBPkeepref(schemas);
944 1 : *n = names->batCacheid;
945 1 : BBPkeepref(names);
946 1 : *t = types->batCacheid;
947 1 : BBPkeepref(types);
948 1 : *v = values->batCacheid;
949 1 : BBPkeepref(values);
950 : }
951 : return msg;
952 : }
953 :
954 : /* str mvc_logfile(int *d, str *filename); */
955 : str
956 0 : mvc_logfile(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
957 : {
958 0 : mvc *m = NULL;
959 0 : str msg;
960 0 : const char *filename = *getArgReference_str(stk, pci, 1);
961 :
962 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
963 : return msg;
964 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
965 : return msg;
966 0 : if (m->scanner.log) {
967 0 : close_stream(m->scanner.log);
968 0 : m->scanner.log = NULL;
969 : }
970 :
971 0 : if (!strNil(filename)) {
972 0 : if((m->scanner.log = open_wastream(filename)) == NULL)
973 0 : throw(SQL, "sql.logfile", SQLSTATE(HY013) "%s", mnstr_peek_error(NULL));
974 : }
975 : return MAL_SUCCEED;
976 : }
977 :
978 : /* str mvc_next_value(lng *res, str *sname, str *seqname); */
979 : str
980 974 : mvc_next_value(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
981 : {
982 974 : backend *be = NULL;
983 974 : str msg;
984 974 : sql_schema *s;
985 974 : sql_sequence *seq;
986 974 : lng *res = getArgReference_lng(stk, pci, 0);
987 974 : const char *sname = *getArgReference_str(stk, pci, 1);
988 974 : const char *seqname = *getArgReference_str(stk, pci, 2);
989 :
990 974 : (void)mb;
991 974 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
992 : return msg;
993 974 : if (!(s = mvc_bind_schema(be->mvc, sname)))
994 0 : throw(SQL, "sql.next_value", SQLSTATE(3F000) "Cannot find the schema %s", sname);
995 974 : if (!mvc_schema_privs(be->mvc, s))
996 0 : throw(SQL, "sql.next_value", SQLSTATE(42000) "Access denied for %s to schema '%s'", get_string_global_var(be->mvc, "current_user"), s->base.name);
997 974 : if (!(seq = find_sql_sequence(be->mvc->session->tr, s, seqname)))
998 0 : throw(SQL, "sql.next_value", SQLSTATE(HY050) "Cannot find the sequence %s.%s", sname, seqname);
999 :
1000 974 : if (seq_next_value(be->mvc->session->tr->store, seq, res)) {
1001 973 : be->last_id = *res;
1002 973 : sqlvar_set_number(find_global_var(be->mvc, mvc_bind_schema(be->mvc, "sys"), "last_id"), be->last_id);
1003 973 : return MAL_SUCCEED;
1004 : }
1005 1 : throw(SQL, "sql.next_value", SQLSTATE(HY050) "Cannot generate next sequence value %s.%s", sname, seqname);
1006 : }
1007 :
1008 : static str
1009 0 : mvc_renumber(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1010 : {
1011 0 : (void)cntxt;
1012 0 : (void)mb;
1013 0 : (void)stk;
1014 0 : (void)pci;
1015 0 : assert(0);
1016 : return MAL_SUCCEED;
1017 : }
1018 :
1019 : static str
1020 35 : mvc_renumber_bulk(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1021 : {
1022 35 : bat *res = getArgReference_bat(stk, pci, 0);
1023 35 : bat *input = getArgReference_bat(stk, pci, 1);
1024 35 : bat *old_id = getArgReference_bat(stk, pci, 2);
1025 35 : bat *new_id = getArgReference_bat(stk, pci, 3);
1026 35 : (void)cntxt;
1027 35 : (void)mb;
1028 :
1029 35 : BAT *r, *i, *bo, *bn;
1030 :
1031 35 : i = BATdescriptor(*input);
1032 35 : bo = BATdescriptor(*old_id);
1033 35 : bn = BATdescriptor(*new_id);
1034 35 : if (!i || !bo || !bn) {
1035 0 : BBPreclaim(bo);
1036 0 : BBPreclaim(bn);
1037 0 : return createException(SQL, "sql.renumber", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1038 : }
1039 :
1040 35 : BUN cnt = BATcount(i);
1041 35 : BUN bcnt = BATcount(bo);
1042 35 : int *ii = Tloc(i,0);
1043 35 : int *oi = Tloc(bo,0);
1044 35 : int *ni = Tloc(bn,0);
1045 : /* TODO handle nils */
1046 : /* if oi is dense, use offset based renumbers */
1047 37 : if (!bo->tsorted || !BATtkey(bo) || (bcnt && (oi[0] + (int)(bcnt-1)) != oi[bcnt-1]) ) {
1048 2 : BAT *lo = NULL;
1049 2 : if (BATleftjoin(&lo, NULL, bo, i, NULL, NULL, false, cnt) != GDK_SUCCEED) {
1050 0 : BBPreclaim(i);
1051 0 : BBPreclaim(bo);
1052 0 : BBPreclaim(bn);
1053 0 : throw(SQL, "sql.renumber", SQLSTATE(42000) "renumber failed\n");
1054 : }
1055 2 : r = BATproject(lo, bn);
1056 2 : BBPreclaim(lo);
1057 2 : if (!r) {
1058 0 : BBPreclaim(i);
1059 0 : BBPreclaim(bo);
1060 0 : BBPreclaim(bn);
1061 0 : throw(SQL, "sql.renumber", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1062 : }
1063 : } else {
1064 33 : if (!(r = COLnew(0, TYPE_int, cnt, TRANSIENT))) {
1065 0 : BBPreclaim(i);
1066 0 : BBPreclaim(bo);
1067 0 : BBPreclaim(bn);
1068 0 : throw(SQL, "sql.renumber", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1069 : }
1070 33 : int *ri = Tloc(r,0);
1071 33 : int base = oi[0];
1072 150 : for (BUN j = 0; j<cnt; j++){
1073 117 : ri[j] = ni[ii[j]-base];
1074 : }
1075 33 : BATsetcount(r, cnt);
1076 : }
1077 35 : r->tnonil = i->tnonil;
1078 35 : r->tnil = i->tnil;
1079 35 : r->tsorted = i->tsorted;
1080 35 : r->trevsorted = i->trevsorted;
1081 35 : r->tkey = i->tkey;
1082 35 : BBPreclaim(i);
1083 35 : BBPreclaim(bo);
1084 35 : BBPreclaim(bn);
1085 35 : *res = r->batCacheid;
1086 35 : BBPkeepref(r);
1087 35 : return MAL_SUCCEED;
1088 : }
1089 :
1090 : str
1091 125 : mvc_next_value_bulk(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1092 : {
1093 125 : backend *be = NULL;
1094 125 : str msg;
1095 125 : sql_schema *s;
1096 125 : sql_sequence *seq;
1097 125 : bat *res = getArgReference_bat(stk, pci, 0);
1098 125 : BUN card = 0;
1099 125 : if (getArgType(mb, pci,1) == TYPE_lng)
1100 90 : card = (BUN)*getArgReference_lng(stk, pci, 1);
1101 : else {
1102 35 : bat bid = *getArgReference_bat(stk, pci, 1);
1103 35 : BAT *b = BATdescriptor(bid);
1104 35 : if (!b)
1105 0 : return createException(SQL, "sql.next_value", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1106 35 : card = BATcount(b);
1107 35 : BBPreclaim(b);
1108 : }
1109 125 : const char *sname = *getArgReference_str(stk, pci, 2);
1110 125 : const char *seqname = *getArgReference_str(stk, pci, 3);
1111 125 : BAT *r = NULL;
1112 :
1113 125 : (void)mb;
1114 125 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
1115 : return msg;
1116 125 : if (!(s = mvc_bind_schema(be->mvc, sname)))
1117 0 : throw(SQL, "sql.next_value", SQLSTATE(3F000) "Cannot find the schema %s", sname);
1118 125 : if (!mvc_schema_privs(be->mvc, s))
1119 0 : throw(SQL, "sql.next_value", SQLSTATE(42000) "Access denied for %s to schema '%s'", get_string_global_var(be->mvc, "current_user"), s->base.name);
1120 125 : if (!(seq = find_sql_sequence(be->mvc->session->tr, s, seqname)))
1121 0 : throw(SQL, "sql.next_value", SQLSTATE(HY050) "Cannot find the sequence %s.%s", sname, seqname);
1122 125 : if (!(r = COLnew(0, TYPE_lng, card, TRANSIENT)))
1123 0 : throw(SQL, "sql.next_value", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1124 :
1125 125 : lng *restrict rb = Tloc(r, 0);
1126 :
1127 125 : if (seqbulk_next_value(be->mvc->session->tr->store, seq, card, rb)) {
1128 125 : be->last_id = rb[card-1];
1129 125 : sqlvar_set_number(find_global_var(be->mvc, mvc_bind_schema(be->mvc, "sys"), "last_id"), be->last_id);
1130 125 : BATsetcount(r, card);
1131 125 : r->tnonil = true;
1132 125 : r->tnil = false;
1133 : /* TODO set the min/max, tsorted/trevsorted and tkey properties based on the sequence values */
1134 125 : r->tsorted = r->trevsorted = r->tkey = BATcount(r) <= 1;
1135 125 : *res = r->batCacheid;
1136 125 : BBPkeepref(r);
1137 125 : return MAL_SUCCEED;
1138 : }
1139 0 : BBPreclaim(r);
1140 0 : throw(SQL, "sql.next_value", SQLSTATE(HY050) "Cannot generate next sequence value %s.%s", sname, seqname);
1141 : }
1142 :
1143 : /* str mvc_get_value(lng *res, str *sname, str *seqname); */
1144 : str
1145 26 : mvc_get_value(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1146 : {
1147 26 : mvc *m = NULL;
1148 26 : str msg;
1149 26 : sql_schema *s;
1150 26 : sql_sequence *seq;
1151 26 : lng *res = getArgReference_lng(stk, pci, 0);
1152 26 : const char *sname = *getArgReference_str(stk, pci, 1);
1153 26 : const char *seqname = *getArgReference_str(stk, pci, 2);
1154 :
1155 26 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1156 : return msg;
1157 26 : if ((msg = checkSQLContext(cntxt)) != NULL)
1158 : return msg;
1159 26 : if (!(s = mvc_bind_schema(m, sname)))
1160 0 : throw(SQL, "sql.get_value", SQLSTATE(3F000) "Cannot find the schema %s", sname);
1161 26 : if (!(seq = find_sql_sequence(m->session->tr, s, seqname)))
1162 0 : throw(SQL, "sql.get_value", SQLSTATE(HY050) "Cannot find the sequence %s.%s", sname, seqname);
1163 :
1164 26 : if (seq_get_value(m->session->tr->store, seq, res))
1165 : return MAL_SUCCEED;
1166 :
1167 0 : throw(SQL, "sql.get_value", SQLSTATE(HY050) "Cannot get sequence value %s.%s", sname, seqname);
1168 : }
1169 :
1170 : /* needed for msqldump and describe_sequences view */
1171 : static str
1172 235 : mvc_get_value_bulk(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1173 : {
1174 235 : mvc *m = NULL;
1175 235 : sql_schema *s;
1176 235 : sql_sequence *seq;
1177 235 : BATiter schi, seqi;
1178 235 : BAT *bn = NULL, *scheb = NULL, *sches = NULL, *seqb = NULL, *seqs = NULL;
1179 235 : lng *restrict vals;
1180 235 : str msg = MAL_SUCCEED;
1181 235 : bool nils = false;
1182 235 : struct canditer ci1 = {0}, ci2 = {0};
1183 235 : oid off1, off2;
1184 235 : bat *res = getArgReference_bat(stk, pci, 0), *l = getArgReference_bat(stk, pci, 1), *r = getArgReference_bat(stk, pci, 2),
1185 235 : *sid1 = pci->argc == 5 ? getArgReference_bat(stk, pci, 3) : NULL, *sid2 = pci->argc == 5 ? getArgReference_bat(stk, pci, 4) : NULL;
1186 :
1187 235 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1188 : return msg;
1189 235 : if ((msg = checkSQLContext(cntxt)) != NULL)
1190 : return msg;
1191 235 : if (!(scheb = BATdescriptor(*l)) || !(seqb = BATdescriptor(*r))) {
1192 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1193 0 : goto bailout;
1194 : }
1195 235 : if ((sid1 && !is_bat_nil(*sid1) && !(sches = BATdescriptor(*sid1))) || (sid2 && !is_bat_nil(*sid2) && !(seqs = BATdescriptor(*sid2)))) {
1196 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1197 0 : goto bailout;
1198 : }
1199 235 : canditer_init(&ci1, scheb, sches);
1200 235 : canditer_init(&ci2, seqb, seqs);
1201 235 : if (ci2.ncand != ci1.ncand || ci1.hseq != ci2.hseq) {
1202 0 : msg = createException(SQL, "sql.get_value", ILLEGAL_ARGUMENT " Requires bats of identical size");
1203 0 : goto bailout;
1204 : }
1205 235 : if (!(bn = COLnew(ci1.hseq, TYPE_lng, ci1.ncand, TRANSIENT))) {
1206 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1207 0 : goto bailout;
1208 : }
1209 :
1210 235 : off1 = scheb->hseqbase;
1211 235 : off2 = seqb->hseqbase;
1212 235 : schi = bat_iterator(scheb);
1213 235 : seqi = bat_iterator(seqb);
1214 235 : vals = Tloc(bn, 0);
1215 275 : for (BUN i = 0; i < ci1.ncand; i++) {
1216 40 : oid p1 = canditer_next(&ci1) - off1, p2 = canditer_next(&ci2) - off2;
1217 40 : const char *sname = BUNtvar(schi, p1);
1218 40 : const char *seqname = BUNtvar(seqi, p2);
1219 :
1220 80 : if (strNil(sname) || strNil(seqname)) {
1221 0 : vals[i] = lng_nil;
1222 0 : nils = true;
1223 : } else {
1224 40 : if (!(s = mvc_bind_schema(m, sname))) {
1225 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(3F000) "Cannot find the schema %s", sname);
1226 0 : goto bailout1;
1227 : }
1228 40 : if (!(seq = find_sql_sequence(m->session->tr, s, seqname))) {
1229 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(HY050) "Cannot find the sequence %s.%s", sname, seqname);
1230 0 : goto bailout1;
1231 : }
1232 40 : if (!seq_get_value(m->session->tr->store, seq, &(vals[i]))) {
1233 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(HY050) "Cannot get the next sequence value %s.%s", sname, seqname);
1234 0 : goto bailout1;
1235 : }
1236 : }
1237 : }
1238 :
1239 235 : bailout1:
1240 235 : bat_iterator_end(&schi);
1241 235 : bat_iterator_end(&seqi);
1242 235 : bailout:
1243 235 : BBPreclaim(scheb);
1244 235 : BBPreclaim(sches);
1245 235 : BBPreclaim(seqb);
1246 235 : BBPreclaim(seqs);
1247 235 : if (bn && !msg) {
1248 235 : BATsetcount(bn, ci1.ncand);
1249 235 : bn->tnil = nils;
1250 235 : bn->tnonil = !nils;
1251 235 : bn->tkey = BATcount(bn) <= 1;
1252 235 : bn->tsorted = BATcount(bn) <= 1;
1253 235 : bn->trevsorted = BATcount(bn) <= 1;
1254 235 : *res = bn->batCacheid;
1255 235 : BBPkeepref(bn);
1256 0 : } else if (bn)
1257 0 : BBPreclaim(bn);
1258 : return msg;
1259 : }
1260 :
1261 : str
1262 0 : mvc_getVersion(lng *version, const int *clientid)
1263 : {
1264 0 : mvc *m = NULL;
1265 0 : Client cntxt = MCgetClient(*clientid);
1266 0 : str msg;
1267 :
1268 0 : if ((msg = getSQLContext(cntxt, NULL, &m, NULL)) != NULL)
1269 : return msg;
1270 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
1271 : return msg;
1272 0 : *version = -1;
1273 0 : if (m->session->tr)
1274 0 : *version = (lng)m->session->tr->ts;
1275 : return MAL_SUCCEED;
1276 : }
1277 :
1278 : /* str mvc_restart_seq(lng *res, str *sname, str *seqname, lng *start); */
1279 : str
1280 2 : mvc_restart_seq(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1281 : {
1282 2 : mvc *m = NULL;
1283 2 : str msg;
1284 2 : sql_schema *s;
1285 2 : sql_sequence *seq;
1286 2 : lng *res = getArgReference_lng(stk, pci, 0);
1287 2 : const char *sname = *getArgReference_str(stk, pci, 1);
1288 2 : const char *seqname = *getArgReference_str(stk, pci, 2);
1289 2 : lng start = *getArgReference_lng(stk, pci, 3);
1290 :
1291 2 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1292 : return msg;
1293 2 : if ((msg = checkSQLContext(cntxt)) != NULL)
1294 : return msg;
1295 2 : if (!(s = mvc_bind_schema(m, sname)))
1296 0 : throw(SQL, "sql.restart", SQLSTATE(3F000) "Cannot find the schema %s", sname);
1297 2 : if (!mvc_schema_privs(m, s))
1298 0 : throw(SQL, "sql.restart", SQLSTATE(42000) "Access denied for %s to schema '%s'", get_string_global_var(m, "current_user"), s->base.name);
1299 2 : if (!(seq = find_sql_sequence(m->session->tr, s, seqname)))
1300 0 : throw(SQL, "sql.restart", SQLSTATE(HY050) "Failed to fetch sequence %s.%s", sname, seqname);
1301 2 : if (is_lng_nil(start))
1302 0 : throw(SQL, "sql.restart", SQLSTATE(HY050) "Cannot (re)start sequence %s.%s with NULL", sname, seqname);
1303 2 : if (start < seq->minvalue)
1304 0 : throw(SQL, "sql.restart", SQLSTATE(HY050) "Cannot set sequence %s.%s start to a value less than the minimum ("LLFMT" < "LLFMT")", sname, seqname, start, seq->minvalue);
1305 2 : if (start > seq->maxvalue)
1306 0 : throw(SQL, "sql.restart", SQLSTATE(HY050) "Cannot set sequence %s.%s start to a value higher than the maximum ("LLFMT" > "LLFMT")", sname, seqname, start, seq->maxvalue);
1307 2 : switch (sql_trans_sequence_restart(m->session->tr, seq, start)) {
1308 0 : case -1:
1309 0 : throw(SQL,"sql.restart",SQLSTATE(HY013) MAL_MALLOC_FAIL);
1310 0 : case -2:
1311 : case -3:
1312 0 : throw(SQL,"sql.restart",SQLSTATE(42000) "RESTART SEQUENCE: transaction conflict detected");
1313 0 : case -4:
1314 0 : throw(SQL,"sql.restart",SQLSTATE(HY050) "Cannot (re)start sequence %s.%s", sname, seqname);
1315 2 : default:
1316 2 : *res = start;
1317 : }
1318 2 : return MAL_SUCCEED;
1319 : }
1320 :
1321 : BAT *
1322 0 : mvc_bind_idxbat(mvc *m, const char *sname, const char *tname, const char *iname, int access)
1323 : {
1324 0 : sql_trans *tr = m->session->tr;
1325 0 : BAT *b = NULL;
1326 0 : sql_schema *s = NULL;
1327 0 : sql_idx *i = NULL;
1328 :
1329 0 : s = mvc_bind_schema(m, sname);
1330 0 : if (s == NULL)
1331 : return NULL;
1332 0 : i = mvc_bind_idx(m, s, iname);
1333 0 : if (i == NULL || !isTable(i->t))
1334 : return NULL;
1335 :
1336 0 : (void) tname;
1337 0 : sqlstore *store = tr->store;
1338 0 : b = store->storage_api.bind_idx(tr, i, access);
1339 0 : return b;
1340 : }
1341 :
1342 : /* str mvc_bind_wrap(int *bid, str *sname, str *tname, str *cname, int *access); */
1343 : str
1344 2211246 : mvc_bind_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1345 : {
1346 2211246 : int upd = (pci->argc == 7 || pci->argc == 9);
1347 2211246 : BAT *b = NULL;
1348 2211246 : bat *bid = getArgReference_bat(stk, pci, 0);
1349 2211246 : mvc *m = NULL;
1350 2211246 : str msg;
1351 2211246 : const char *sname = *getArgReference_str(stk, pci, 2 + upd);
1352 2211246 : const char *tname = *getArgReference_str(stk, pci, 3 + upd);
1353 2211246 : const char *cname = NULL;
1354 2211246 : sqlid colid = 0;
1355 2211246 : const int access = *getArgReference_int(stk, pci, 5 + upd);
1356 :
1357 2211246 : if (getArgType(mb, pci, 4 + upd) == TYPE_int)
1358 0 : colid = *getArgReference_int(stk, pci, 4 + upd);
1359 : else
1360 2211246 : cname = *getArgReference_str(stk, pci, 4 + upd);
1361 :
1362 2211246 : const bool partitioned_access = pci->argc == (8 + upd) && getArgType(mb, pci, 6 + upd) == TYPE_int;
1363 :
1364 : /* This doesn't work with quick access for now... */
1365 2211246 : assert(access != QUICK);
1366 2211246 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1367 : return msg;
1368 2210397 : if ((msg = checkSQLContext(cntxt)) != NULL)
1369 : return msg;
1370 2212964 : sqlstore *store = m->store;
1371 2212964 : sql_schema *s = mvc_bind_schema(m, sname);
1372 2211883 : sql_table *t = mvc_bind_table(m, s, tname);
1373 2195029 : if (t && !isTable(t))
1374 0 : throw(SQL, "sql.bind", SQLSTATE(42000) "%s '%s' is not persistent",
1375 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
1376 2195029 : sql_column *c = (colid)?find_sql_column_id(t, colid):mvc_bind_column(m, t, cname);
1377 :
1378 2216098 : if (partitioned_access) {
1379 : /* partitioned access */
1380 1833496 : int part_nr = *getArgReference_int(stk, pci, 6 + upd);
1381 1833496 : int nr_parts = *getArgReference_int(stk, pci, 7 + upd);
1382 1833496 : BUN cnt = store->storage_api.count_col(m->session->tr, c, 0), psz;
1383 1845604 : oid l, h;
1384 1845604 : psz = cnt ? (cnt / nr_parts) : 0;
1385 1845604 : l = part_nr * psz;
1386 1845604 : if (l > cnt)
1387 0 : l = cnt;
1388 1845604 : h = (part_nr + 1 == nr_parts) ? cnt : ((part_nr + 1) * psz);
1389 1845604 : if (h > cnt)
1390 0 : h = cnt;
1391 :
1392 1845604 : if (upd) {
1393 468712 : BAT *ui = NULL, *uv = NULL;
1394 468712 : if (store->storage_api.bind_updates(m->session->tr, c, &ui, &uv) == LOG_ERR)
1395 0 : throw(SQL,"sql.bind",SQLSTATE(HY005) "Cannot access the update columns");
1396 :
1397 468215 : h--;
1398 468215 : BAT* bn = BATselect(ui, NULL, &l, &h, true, true, false, false);
1399 467940 : if(bn == NULL) {
1400 0 : BBPunfix(ui->batCacheid);
1401 0 : BBPunfix(uv->batCacheid);
1402 0 : throw(SQL, "sql.bind", GDK_EXCEPTION);
1403 : }
1404 :
1405 467940 : bat *uvl = getArgReference_bat(stk, pci, 1);
1406 :
1407 467940 : if (BATcount(bn)) {
1408 3 : BAT *id;
1409 3 : BAT *vl;
1410 3 : if (ui == NULL || uv == NULL) {
1411 0 : bat_destroy(uv);
1412 0 : bat_destroy(ui);
1413 0 : BBPunfix(bn->batCacheid);
1414 0 : throw(SQL,"sql.bind",SQLSTATE(HY005) "Cannot access the insert column %s.%s.%s",
1415 : sname, tname, cname);
1416 : }
1417 3 : assert(uv->batCount == ui->batCount);
1418 3 : id = BATproject(bn, ui);
1419 3 : vl = BATproject(bn, uv);
1420 3 : bat_destroy(ui);
1421 3 : bat_destroy(uv);
1422 3 : if (id == NULL || vl == NULL) {
1423 0 : BBPunfix(bn->batCacheid);
1424 0 : bat_destroy(id);
1425 0 : bat_destroy(vl);
1426 0 : throw(SQL, "sql.bind", GDK_EXCEPTION);
1427 : }
1428 3 : if ( BATcount(id) != BATcount(vl)){
1429 0 : BBPunfix(bn->batCacheid);
1430 0 : bat_destroy(id);
1431 0 : bat_destroy(vl);
1432 0 : throw(SQL, "sql.bind", SQLSTATE(0000) "Inconsistent BAT count");
1433 : }
1434 3 : BBPkeepref(id);
1435 3 : BBPkeepref(vl);
1436 3 : *bid = id->batCacheid;
1437 3 : *uvl = vl->batCacheid;
1438 : } else {
1439 467937 : *bid = e_bat(TYPE_oid);
1440 468449 : *uvl = e_bat(c->type.type->localtype);
1441 468591 : if (*bid == BID_NIL || *uvl == BID_NIL) {
1442 0 : if (*bid)
1443 0 : BBPunfix(*bid);
1444 0 : if (*uvl)
1445 0 : BBPunfix(*uvl);
1446 0 : BBPunfix(b->batCacheid);
1447 0 : throw(SQL, "sql.bind", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1448 : }
1449 : }
1450 : } else {
1451 1376892 : int coltype = getBatType(getArgType(mb, pci, 0));
1452 1376892 : b = store->storage_api.bind_col(m->session->tr, c, access);
1453 1372117 : if (b == NULL)
1454 0 : throw(SQL, "sql.bind", SQLSTATE(42000) "Cannot bind column %s.%s.%s", sname, tname, cname);
1455 :
1456 1372117 : if (b->ttype && b->ttype != coltype) {
1457 0 : BBPunfix(b->batCacheid);
1458 0 : throw(SQL,"sql.bind",SQLSTATE(42000) "Column type mismatch %s.%s.%s",sname,tname,cname);
1459 : }
1460 :
1461 1372117 : BAT* bn = BATslice(b, l, h);
1462 1368451 : if(bn == NULL) {
1463 0 : BBPunfix(b->batCacheid);
1464 0 : throw(SQL, "sql.bind", GDK_EXCEPTION);
1465 : }
1466 1368451 : BAThseqbase(bn, l);
1467 1364689 : BBPunfix(b->batCacheid);
1468 1369336 : BBPkeepref(bn);
1469 1373632 : *bid = bn->batCacheid;
1470 : }
1471 : }
1472 382602 : else if (upd) { /*unpartitioned access to update bats*/
1473 119950 : BAT *ui = NULL, *uv = NULL;
1474 119950 : if (store->storage_api.bind_updates(m->session->tr, c, &ui, &uv) == LOG_ERR)
1475 0 : throw(SQL,"sql.bind",SQLSTATE(HY005) "Cannot access the update columns");
1476 :
1477 120089 : bat *uvl = getArgReference_bat(stk, pci, 1);
1478 120089 : BBPkeepref(ui);
1479 120090 : BBPkeepref(uv);
1480 120094 : *bid = ui->batCacheid;
1481 120094 : *uvl = uv->batCacheid;
1482 : }
1483 : else { /*unpartitioned access to base column*/
1484 262652 : int coltype = getBatType(getArgType(mb, pci, 0));
1485 262652 : b = store->storage_api.bind_col(m->session->tr, c, access);
1486 262079 : if (b == NULL)
1487 0 : throw(SQL, "sql.bin", "Couldn't bind column");
1488 :
1489 262079 : if (b->ttype && b->ttype != coltype) {
1490 0 : BBPunfix(b->batCacheid);
1491 0 : throw(SQL,"sql.bind",SQLSTATE(42000) "Column type mismatch %s.%s.%s",sname,tname,cname);
1492 : }
1493 262079 : BBPkeepref(b);
1494 262422 : *bid = b->batCacheid;
1495 : }
1496 : return MAL_SUCCEED;
1497 : }
1498 :
1499 : /* The output of this function are 7 columns:
1500 : * - The sqlid of the column
1501 : * - Number of values of the column.
1502 : * - Number of segments, indication of the fragmentation
1503 : * - Number of inserted rows during the current transaction.
1504 : * - Number of updated rows during the current transaction.
1505 : * - Number of deletes of the column's table.
1506 : * - the number in the transaction chain (.i.e for each savepoint a new transaction is added in the chain)
1507 : */
1508 :
1509 : static str
1510 17 : mvc_insert_delta_values(mvc *m, BAT *col1, BAT *col2, BAT *col3, BAT *col4, BAT *col5, BAT *col6, BAT *col7, sql_column *c, lng segments, lng deletes)
1511 : {
1512 17 : int level = 0;
1513 17 : sqlstore *store = m->session->tr->store;
1514 :
1515 17 : lng inserted = (lng) store->storage_api.count_col(m->session->tr, c, 1);
1516 17 : lng all = (lng) store->storage_api.count_col(m->session->tr, c, 0);
1517 17 : lng updates = (lng) store->storage_api.count_col(m->session->tr, c, 2);
1518 :
1519 17 : if (BUNappend(col1, &c->base.id, false) != GDK_SUCCEED) {
1520 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1521 : }
1522 17 : if (BUNappend(col2, &segments, false) != GDK_SUCCEED) {
1523 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1524 : }
1525 17 : if (BUNappend(col3, &all, false) != GDK_SUCCEED) {
1526 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1527 : }
1528 17 : if (BUNappend(col4, &inserted, false) != GDK_SUCCEED) {
1529 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1530 : }
1531 17 : if (BUNappend(col5, &updates, false) != GDK_SUCCEED) {
1532 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1533 : }
1534 17 : if (BUNappend(col6, &deletes, false) != GDK_SUCCEED) {
1535 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1536 : }
1537 : /* compute level using global transaction */
1538 17 : if (c) {
1539 34 : for(sql_delta *d = ATOMIC_PTR_GET(&c->data); d; d = d->next)
1540 17 : level++;
1541 : }
1542 17 : if (BUNappend(col7, &level, false) != GDK_SUCCEED) {
1543 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1544 : }
1545 : return MAL_SUCCEED;
1546 : }
1547 :
1548 : str
1549 17 : mvc_delta_values(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1550 : {
1551 17 : const char *sname = *getArgReference_str(stk, pci, 7),
1552 17 : *tname = (pci->argc > 8) ? *getArgReference_str(stk, pci, 8) : NULL,
1553 17 : *cname = (pci->argc > 9) ? *getArgReference_str(stk, pci, 9) : NULL;
1554 17 : mvc *m;
1555 17 : str msg = MAL_SUCCEED;
1556 17 : BAT *col1 = NULL, *col2 = NULL, *col3 = NULL, *col4 = NULL, *col5 = NULL, *col6 = NULL, *col7 = NULL;
1557 17 : bat *b1 = getArgReference_bat(stk, pci, 0),
1558 17 : *b2 = getArgReference_bat(stk, pci, 1),
1559 17 : *b3 = getArgReference_bat(stk, pci, 2),
1560 17 : *b4 = getArgReference_bat(stk, pci, 3),
1561 17 : *b5 = getArgReference_bat(stk, pci, 4),
1562 17 : *b6 = getArgReference_bat(stk, pci, 5),
1563 17 : *b7 = getArgReference_bat(stk, pci, 6);
1564 17 : sql_schema *s = NULL;
1565 17 : sql_table *t = NULL;
1566 17 : sql_column *c = NULL;
1567 17 : node *n;
1568 17 : BUN nrows = 0;
1569 17 : lng deletes, segments;
1570 :
1571 17 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1572 : return msg;
1573 :
1574 17 : sqlstore *store = m->store;
1575 17 : sql_trans *tr = m->session->tr;
1576 17 : if ((msg = checkSQLContext(cntxt)) != NULL)
1577 0 : goto cleanup;
1578 :
1579 17 : if (!(s = mvc_bind_schema(m, sname)))
1580 0 : throw(SQL, "sql.delta", SQLSTATE(3F000) "No such schema '%s'", sname);
1581 :
1582 17 : if (tname) {
1583 17 : if (!(t = mvc_bind_table(m, s, tname)))
1584 0 : throw(SQL, "sql.delta", SQLSTATE(3F000) "No such table '%s' in schema '%s'", tname, s->base.name);
1585 17 : if (!isTable(t))
1586 0 : throw(SQL, "sql.delta", SQLSTATE(42000) "%s doesn't have delta values", TABLE_TYPE_DESCRIPTION(t->type, t->properties));
1587 17 : if (cname) {
1588 0 : if (!(c = mvc_bind_column(m, t, cname)))
1589 0 : throw(SQL, "sql.delta", SQLSTATE(3F000) "No such column '%s' in table '%s'", cname, t->base.name);
1590 : nrows = 1;
1591 : } else {
1592 17 : nrows = (BUN) ol_length(t->columns);
1593 : }
1594 0 : } else if (s->tables) {
1595 0 : struct os_iter oi;
1596 0 : os_iterator(&oi, s->tables, tr, NULL);
1597 0 : for (sql_base *b = oi_next(&oi); b; b = oi_next(&oi)) {
1598 0 : t = (sql_table *)b;
1599 0 : if (isTable(t))
1600 0 : nrows += (BUN) ol_length(t->columns);
1601 : }
1602 : }
1603 :
1604 17 : if ((col1 = COLnew(0, TYPE_int, nrows, TRANSIENT)) == NULL) {
1605 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1606 0 : goto cleanup;
1607 : }
1608 17 : if ((col2 = COLnew(0, TYPE_lng, nrows, TRANSIENT)) == NULL) {
1609 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1610 0 : goto cleanup;
1611 : }
1612 17 : if ((col3 = COLnew(0, TYPE_lng, nrows, TRANSIENT)) == NULL) {
1613 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1614 0 : goto cleanup;
1615 : }
1616 17 : if ((col4 = COLnew(0, TYPE_lng, nrows, TRANSIENT)) == NULL) {
1617 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1618 0 : goto cleanup;
1619 : }
1620 17 : if ((col5 = COLnew(0, TYPE_lng, nrows, TRANSIENT)) == NULL) {
1621 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1622 0 : goto cleanup;
1623 : }
1624 17 : if ((col6 = COLnew(0, TYPE_lng, nrows, TRANSIENT)) == NULL) {
1625 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1626 0 : goto cleanup;
1627 : }
1628 17 : if ((col7 = COLnew(0, TYPE_int, nrows, TRANSIENT)) == NULL) {
1629 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1630 0 : goto cleanup;
1631 : }
1632 :
1633 17 : if (nrows) {
1634 17 : if (tname) {
1635 17 : deletes = (lng) store->storage_api.count_del(m->session->tr, t, 0);
1636 17 : segments = (lng) store->storage_api.count_del(m->session->tr, t, CNT_SEGS);
1637 17 : if (cname) {
1638 0 : if ((msg=mvc_insert_delta_values(m, col1, col2, col3, col4, col5, col6, col7, c, segments, deletes)) != NULL)
1639 0 : goto cleanup;
1640 : } else {
1641 34 : for (n = ol_first_node(t->columns); n ; n = n->next) {
1642 17 : c = (sql_column*) n->data;
1643 17 : if ((msg=mvc_insert_delta_values(m, col1, col2, col3, col4, col5, col6, col7, c, segments, deletes)) != NULL)
1644 0 : goto cleanup;
1645 : }
1646 : }
1647 0 : } else if (s->tables) {
1648 0 : struct os_iter oi;
1649 0 : os_iterator(&oi, s->tables, tr, NULL);
1650 0 : for (sql_base *b = oi_next(&oi); b; b = oi_next(&oi)) {
1651 0 : t = (sql_table *)b;
1652 0 : if (isTable(t)) {
1653 0 : deletes = (lng) store->storage_api.count_del(m->session->tr, t, 0);
1654 0 : segments = (lng) store->storage_api.count_del(m->session->tr, t, CNT_SEGS);
1655 :
1656 0 : for (node *nn = ol_first_node(t->columns); nn ; nn = nn->next) {
1657 0 : c = (sql_column*) nn->data;
1658 :
1659 0 : if ((msg=mvc_insert_delta_values(m, col1, col2, col3, col4, col5, col6, col7, c, segments, deletes)) != NULL)
1660 0 : goto cleanup;
1661 : }
1662 : }
1663 : }
1664 : }
1665 : }
1666 :
1667 0 : cleanup:
1668 17 : if (msg) {
1669 0 : if (col1)
1670 0 : BBPreclaim(col1);
1671 0 : if (col2)
1672 0 : BBPreclaim(col2);
1673 0 : if (col3)
1674 0 : BBPreclaim(col3);
1675 0 : if (col4)
1676 0 : BBPreclaim(col4);
1677 0 : if (col5)
1678 0 : BBPreclaim(col5);
1679 0 : if (col6)
1680 0 : BBPreclaim(col6);
1681 0 : if (col7)
1682 0 : BBPreclaim(col7);
1683 : } else {
1684 17 : *b1 = col1->batCacheid;
1685 17 : BBPkeepref(col1);
1686 17 : *b2 = col2->batCacheid;
1687 17 : BBPkeepref(col2);
1688 17 : *b3 = col3->batCacheid;
1689 17 : BBPkeepref(col3);
1690 17 : *b4 = col4->batCacheid;
1691 17 : BBPkeepref(col4);
1692 17 : *b5 = col5->batCacheid;
1693 17 : BBPkeepref(col5);
1694 17 : *b6 = col6->batCacheid;
1695 17 : BBPkeepref(col6);
1696 17 : *b7 = col7->batCacheid;
1697 17 : BBPkeepref(col7);
1698 : }
1699 : return msg;
1700 : }
1701 :
1702 : /* str mvc_bind_idxbat_wrap(int *bid, str *sname, str *tname, str *iname, int *access); */
1703 : str
1704 3799 : mvc_bind_idxbat_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1705 : {
1706 3799 : int upd = (pci->argc == 7 || pci->argc == 9);
1707 3799 : BAT *b = NULL;
1708 3799 : bat *bid = getArgReference_bat(stk, pci, 0);
1709 3799 : mvc *m = NULL;
1710 3799 : str msg;
1711 3799 : const char *sname = *getArgReference_str(stk, pci, 2 + upd);
1712 3799 : const char *tname = *getArgReference_str(stk, pci, 3 + upd);
1713 3799 : const char *iname = *getArgReference_str(stk, pci, 4 + upd);
1714 3799 : const int access = *getArgReference_int(stk, pci, 5 + upd);
1715 :
1716 3799 : const bool partitioned_access = pci->argc == (8 + upd) && getArgType(mb, pci, 6 + upd) == TYPE_int;
1717 :
1718 : /* This doesn't work with quick access for now... */
1719 3799 : assert(access != QUICK);
1720 3799 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1721 : return msg;
1722 3789 : if ((msg = checkSQLContext(cntxt)) != NULL)
1723 : return msg;
1724 3802 : sqlstore *store = m->store;
1725 3802 : sql_schema *s = mvc_bind_schema(m, sname);
1726 3785 : sql_table *t = mvc_bind_table(m, s, tname);
1727 3810 : if (t && !isTable(t))
1728 0 : throw(SQL, "sql.bindidx", SQLSTATE(42000) "%s '%s' is not persistent",
1729 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
1730 3810 : sql_idx *i = mvc_bind_idx(m, s, iname);
1731 :
1732 3754 : if (partitioned_access) {
1733 : /* partitioned access */
1734 2673 : int part_nr = *getArgReference_int(stk, pci, 6 + upd);
1735 2673 : int nr_parts = *getArgReference_int(stk, pci, 7 + upd);
1736 2673 : BUN cnt = store->storage_api.count_idx(m->session->tr, i, 0), psz;
1737 2733 : oid l, h;
1738 2733 : psz = cnt ? (cnt / nr_parts) : 0;
1739 2733 : l = part_nr * psz;
1740 2733 : if (l > cnt)
1741 0 : l = cnt;
1742 2733 : h = (part_nr + 1 == nr_parts) ? cnt : ((part_nr + 1) * psz);
1743 2733 : if (h > cnt)
1744 0 : h = cnt;
1745 :
1746 2733 : if (upd) {
1747 0 : BAT *ui = NULL, *uv = NULL;
1748 0 : if (store->storage_api.bind_updates_idx(m->session->tr, i, &ui, &uv) == LOG_ERR)
1749 0 : throw(SQL,"sql.bindidx",SQLSTATE(HY005) "Cannot access the update columns");
1750 :
1751 0 : h--;
1752 0 : BAT* bn = BATselect(ui, NULL, &l, &h, true, true, false, false);
1753 0 : if(bn == NULL) {
1754 0 : BBPunfix(ui->batCacheid);
1755 0 : BBPunfix(uv->batCacheid);
1756 0 : throw(SQL, "sql.bindidx", GDK_EXCEPTION);
1757 : }
1758 :
1759 0 : bat *uvl = getArgReference_bat(stk, pci, 1);
1760 :
1761 0 : if (BATcount(bn)) {
1762 0 : BAT *id;
1763 0 : BAT *vl;
1764 0 : if (ui == NULL || uv == NULL) {
1765 0 : bat_destroy(uv);
1766 0 : bat_destroy(ui);
1767 0 : BBPunfix(bn->batCacheid);
1768 0 : throw(SQL,"sql.bindidx",SQLSTATE(42000) "Cannot access index column %s.%s.%s",sname,tname,iname);
1769 : }
1770 0 : assert(uv->batCount == ui->batCount);
1771 0 : id = BATproject(bn, ui);
1772 0 : vl = BATproject(bn, uv);
1773 0 : bat_destroy(ui);
1774 0 : bat_destroy(uv);
1775 0 : if (id == NULL || vl == NULL) {
1776 0 : BBPunfix(bn->batCacheid);
1777 0 : bat_destroy(id);
1778 0 : bat_destroy(vl);
1779 0 : throw(SQL, "sql.bindidx", GDK_EXCEPTION);
1780 : }
1781 0 : if ( BATcount(id) != BATcount(vl)){
1782 0 : BBPunfix(bn->batCacheid);
1783 0 : bat_destroy(id);
1784 0 : bat_destroy(vl);
1785 0 : throw(SQL, "sql.bindidx", SQLSTATE(0000) "Inconsistent BAT count");
1786 : }
1787 0 : BBPkeepref(id);
1788 0 : BBPkeepref(vl);
1789 0 : *bid = id->batCacheid;
1790 0 : *uvl = vl->batCacheid;
1791 : } else {
1792 0 : *bid = e_bat(TYPE_oid);
1793 0 : *uvl = e_bat((i->type==join_idx)?TYPE_oid:TYPE_lng);
1794 0 : if (*bid == BID_NIL || *uvl == BID_NIL) {
1795 0 : if (*bid)
1796 0 : BBPunfix(*bid);
1797 0 : if (*uvl)
1798 0 : BBPunfix(*uvl);
1799 0 : BBPunfix(b->batCacheid);
1800 0 : throw(SQL, "sql.bindidx", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1801 : }
1802 : }
1803 : } else {
1804 2733 : int idxtype = getBatType(getArgType(mb, pci, 0));
1805 2733 : b = store->storage_api.bind_idx(m->session->tr, i, access);
1806 :
1807 2730 : if (b && b->ttype && b->ttype != idxtype) {
1808 0 : BBPunfix(b->batCacheid);
1809 0 : throw(SQL,"sql.bindidx",SQLSTATE(42000) "Index type mismatch %s.%s.%s",sname,tname,iname);
1810 : }
1811 :
1812 2730 : BAT* bn = BATslice(b, l, h);
1813 2727 : if(bn == NULL) {
1814 0 : BBPunfix(b->batCacheid);
1815 0 : throw(SQL, "sql.bindidx", GDK_EXCEPTION);
1816 : }
1817 2727 : BAThseqbase(bn, l);
1818 2723 : BBPunfix(b->batCacheid);
1819 2728 : BBPkeepref(bn);
1820 2724 : *bid = bn->batCacheid;
1821 : }
1822 : }
1823 1081 : else if (upd) { /*unpartitioned access to update bats*/
1824 23 : BAT *ui = NULL, *uv = NULL;
1825 23 : if (store->storage_api.bind_updates_idx(m->session->tr, i, &ui, &uv) == LOG_ERR)
1826 0 : throw(SQL,"sql.bindidx",SQLSTATE(HY005) "Cannot access the update columns");
1827 :
1828 23 : bat *uvl = getArgReference_bat(stk, pci, 1);
1829 23 : BBPkeepref(ui);
1830 23 : BBPkeepref(uv);
1831 23 : *bid = ui->batCacheid;
1832 23 : *uvl = uv->batCacheid;
1833 : }
1834 : else { /*unpartitioned access to base index*/
1835 1058 : int idxtype = getBatType(getArgType(mb, pci, 0));
1836 1058 : b = store->storage_api.bind_idx(m->session->tr, i, access);
1837 1061 : if (b == NULL)
1838 0 : throw(SQL,"sql.bindidx", "Couldn't bind index");
1839 :
1840 1061 : if (b->ttype && b->ttype != idxtype) {
1841 0 : BBPunfix(b->batCacheid);
1842 0 : throw(SQL,"sql.bindidx",SQLSTATE(42000) "Index type mismatch %s.%s.%s",sname,tname,iname);
1843 : }
1844 1061 : BBPkeepref(b);
1845 1062 : *bid = b->batCacheid;
1846 : }
1847 : return MAL_SUCCEED;
1848 : }
1849 :
1850 : str
1851 52 : mvc_append_column(sql_trans *t, sql_column *c, BUN offset, BAT *pos, BAT *ins)
1852 : {
1853 52 : sqlstore *store = t->store;
1854 52 : int res = store->storage_api.append_col(t, c, offset, pos, ins, BATcount(ins), true, ins->ttype);
1855 52 : if (res != LOG_OK) /* the conflict case should never happen, but leave it here */
1856 0 : throw(SQL, "sql.append", SQLSTATE(42000) "Append failed %s", res == LOG_CONFLICT ? "due to conflict with another transaction" : GDKerrbuf);
1857 : return MAL_SUCCEED;
1858 : }
1859 :
1860 : /*mvc_grow_wrap(int *bid, str *sname, str *tname, str *cname, ptr d) */
1861 : str
1862 341 : mvc_grow_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1863 : {
1864 341 : int *res = getArgReference_int(stk, pci, 0);
1865 341 : bat Tid = *getArgReference_bat(stk, pci, 1);
1866 341 : ptr Ins = getArgReference(stk, pci, 2);
1867 341 : int tpe = getArgType(mb, pci, 2);
1868 341 : bool isbat = false;
1869 341 : BAT *tid = 0, *ins = 0;
1870 341 : size_t cnt = 1;
1871 341 : oid v = 0;
1872 :
1873 341 : (void)cntxt;
1874 341 : *res = 0;
1875 341 : if ((tid = BATdescriptor(Tid)) == NULL)
1876 0 : throw(SQL, "sql.grow", SQLSTATE(HY005) "Cannot access descriptor");
1877 341 : if (isaBatType(tpe))
1878 8 : isbat = true;
1879 8 : if (isbat && (ins = BATdescriptor(*(bat *) Ins)) == NULL) {
1880 0 : BBPunfix(Tid);
1881 0 : throw(SQL, "sql.grow", SQLSTATE(HY005) "Cannot access descriptor");
1882 : }
1883 8 : if (ins) {
1884 8 : cnt = BATcount(ins);
1885 8 : BBPunfix(ins->batCacheid);
1886 : }
1887 341 : if (BATcount(tid)) {
1888 311 : (void)BATmax(tid, &v);
1889 311 : v++;
1890 : }
1891 691 : for(;cnt>0; cnt--, v++) {
1892 350 : if (BUNappend(tid, &v, false) != GDK_SUCCEED) {
1893 0 : BBPunfix(Tid);
1894 0 : throw(SQL, "sql.grow", GDK_EXCEPTION);
1895 : }
1896 : }
1897 341 : BBPunfix(Tid);
1898 341 : return MAL_SUCCEED;
1899 : }
1900 :
1901 : /*mvc_append_wrap(int *bid, str *sname, str *tname, str *cname, ptr d) */
1902 : str
1903 708693 : mvc_append_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1904 : {
1905 708693 : int *res = getArgReference_int(stk, pci, 0);
1906 708693 : mvc *m = NULL;
1907 708693 : str msg;
1908 708693 : const char *sname = *getArgReference_str(stk, pci, 2);
1909 708693 : const char *tname = *getArgReference_str(stk, pci, 3);
1910 708693 : const char *cname = NULL;
1911 708693 : sqlid col_id = 0;
1912 708693 : BUN offset = (BUN)*getArgReference_oid(stk, pci, 5);
1913 708693 : bat Pos = *getArgReference_bat(stk, pci, 6);
1914 708693 : ptr ins = getArgReference(stk, pci, 7);
1915 712666 : int tpe = getArgType(mb, pci, 7), log_res = LOG_OK;
1916 712666 : bool isbat = false;
1917 712666 : sql_schema *s;
1918 712666 : sql_table *t;
1919 712666 : sql_column *c;
1920 712666 : sql_idx *i;
1921 712666 : BAT *b = NULL, *pos = NULL;
1922 712666 : BUN cnt = 1;
1923 :
1924 712666 : if (getArgType(mb, pci, 4) == TYPE_int)
1925 185 : col_id = *getArgReference_int(stk, pci, 4);
1926 : else
1927 712481 : cname = *getArgReference_str(stk, pci, 4);
1928 :
1929 712666 : *res = 0;
1930 712666 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1931 : return msg;
1932 707087 : if ((msg = checkSQLContext(cntxt)) != NULL)
1933 : return msg;
1934 707965 : if (isaBatType(tpe)) {
1935 150694 : isbat = true;
1936 150694 : tpe = getBatType(tpe);
1937 : }
1938 707965 : if (Pos != bat_nil && (pos = BATdescriptor(Pos)) == NULL)
1939 0 : throw(SQL, "sql.append", SQLSTATE(HY005) "Cannot access append positions descriptor");
1940 707965 : if (isbat && (ins = BATdescriptor(*(bat *) ins)) == NULL) {
1941 0 : bat_destroy(pos);
1942 0 : throw(SQL, "sql.append", SQLSTATE(HY005) "Cannot access append values descriptor");
1943 : }
1944 708602 : if (!isbat && ATOMextern(tpe) && !ATOMvarsized(tpe))
1945 11 : ins = *(ptr *) ins;
1946 151451 : if (isbat) {
1947 151451 : b = (BAT*) ins;
1948 151451 : if (VIEWtparent(b) || VIEWvtparent(b)) {
1949 : /* note, b == (BAT*)ins */
1950 726 : b = COLcopy(b, b->ttype, true, TRANSIENT);
1951 699 : BBPreclaim(ins);
1952 723 : ins = b;
1953 723 : if (b == NULL)
1954 0 : throw(SQL, "sql.append", GDK_EXCEPTION);
1955 : }
1956 : }
1957 708599 : s = mvc_bind_schema(m, sname);
1958 709778 : if (s == NULL) {
1959 0 : bat_destroy(pos);
1960 0 : bat_destroy(b);
1961 0 : throw(SQL, "sql.append", SQLSTATE(3F000) "Schema missing %s",sname);
1962 : }
1963 709778 : t = mvc_bind_table(m, s, tname);
1964 707685 : if (t == NULL) {
1965 0 : bat_destroy(pos);
1966 0 : bat_destroy(b);
1967 0 : throw(SQL, "sql.append", SQLSTATE(42S02) "Table missing %s",tname);
1968 : }
1969 707685 : if (!isTable(t)) {
1970 0 : bat_destroy(pos);
1971 0 : bat_destroy(b);
1972 0 : throw(SQL, "sql.append", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
1973 : }
1974 707685 : if (b)
1975 165964 : cnt = BATcount(b);
1976 707685 : sqlstore *store = m->session->tr->store;
1977 707685 : if (col_id && (c = find_sql_column_id(t, col_id)) != NULL) {
1978 185 : log_res = store->storage_api.append_col(m->session->tr, c, offset, pos, ins, cnt, isbat, tpe);
1979 707500 : } else if (!col_id && cname[0] != '%' && (c = mvc_bind_column(m, t, cname)) != NULL) {
1980 713097 : log_res = store->storage_api.append_col(m->session->tr, c, offset, pos, ins, cnt, isbat, tpe);
1981 2189 : } else if (!col_id && cname[0] == '%' && (i = mvc_bind_idx(m, s, cname + 1)) != NULL) {
1982 2189 : log_res = store->storage_api.append_idx(m->session->tr, i, offset, pos, ins, cnt, isbat, tpe);
1983 : } else {
1984 0 : bat_destroy(pos);
1985 0 : bat_destroy(b);
1986 0 : throw(SQL, "sql.append", SQLSTATE(38000) "Unable to find column or index %s.%s.%s",sname,tname,cname);
1987 : }
1988 712203 : bat_destroy(pos);
1989 708517 : bat_destroy(b);
1990 709136 : if (log_res != LOG_OK) /* the conflict case should never happen, but leave it here */
1991 0 : throw(SQL, "sql.append", SQLSTATE(42000) "Append failed %s", log_res == LOG_CONFLICT ? "due to conflict with another transaction" : GDKerrbuf);
1992 : return MAL_SUCCEED;
1993 : }
1994 :
1995 : /*mvc_update_wrap(int *bid, str *sname, str *tname, str *cname, ptr d) */
1996 : str
1997 3976 : mvc_update_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1998 : {
1999 3976 : int *res = getArgReference_int(stk, pci, 0);
2000 3976 : mvc *m = NULL;
2001 3976 : str msg;
2002 3976 : const char *sname = *getArgReference_str(stk, pci, 2);
2003 3976 : const char *tname = *getArgReference_str(stk, pci, 3);
2004 3976 : const char *cname = *getArgReference_str(stk, pci, 4);
2005 3976 : bat Tids = *getArgReference_bat(stk, pci, 5);
2006 3976 : bat Upd = *getArgReference_bat(stk, pci, 6);
2007 3976 : BAT *tids, *upd;
2008 3976 : int tpe = getArgType(mb, pci, 6), log_res = LOG_OK;
2009 3976 : bool isbat = false;
2010 3976 : sql_schema *s;
2011 3976 : sql_table *t;
2012 3976 : sql_column *c;
2013 3976 : sql_idx *i;
2014 :
2015 3976 : *res = 0;
2016 3976 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
2017 : return msg;
2018 3976 : if ((msg = checkSQLContext(cntxt)) != NULL)
2019 : return msg;
2020 3976 : if (isaBatType(tpe))
2021 3976 : isbat = true;
2022 : else
2023 0 : assert(0);
2024 3976 : if (!isbat)
2025 : throw(SQL, "sql.update", SQLSTATE(HY005) "Update values is not a BAT input");
2026 3976 : if ((tids = BATdescriptor(Tids)) == NULL)
2027 0 : throw(SQL, "sql.update", SQLSTATE(HY005) "Cannot access update positions descriptor");
2028 3976 : if ((upd = BATdescriptor(Upd)) == NULL) {
2029 0 : BBPunfix(tids->batCacheid);
2030 0 : throw(SQL, "sql.update", SQLSTATE(HY005) "Cannot access update values descriptor");
2031 : }
2032 3976 : s = mvc_bind_schema(m, sname);
2033 3976 : if (s == NULL) {
2034 0 : BBPunfix(tids->batCacheid);
2035 0 : BBPunfix(upd->batCacheid);
2036 0 : throw(SQL, "sql.update", SQLSTATE(3F000) "Schema missing %s",sname);
2037 : }
2038 3976 : t = mvc_bind_table(m, s, tname);
2039 3976 : if (t == NULL) {
2040 0 : BBPunfix(tids->batCacheid);
2041 0 : BBPunfix(upd->batCacheid);
2042 0 : throw(SQL, "sql.update", SQLSTATE(42S02) "Table missing %s.%s",sname,tname);
2043 : }
2044 3976 : if (!isTable(t)) {
2045 0 : BBPunfix(tids->batCacheid);
2046 0 : BBPunfix(upd->batCacheid);
2047 0 : throw(SQL, "sql.update", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
2048 : }
2049 3976 : sqlstore *store = m->session->tr->store;
2050 3976 : if (cname[0] != '%' && (c = mvc_bind_column(m, t, cname)) != NULL) {
2051 3194 : log_res = store->storage_api.update_col(m->session->tr, c, tids, upd, isbat);
2052 782 : } else if (cname[0] == '%' && (i = mvc_bind_idx(m, s, cname + 1)) != NULL) {
2053 782 : log_res = store->storage_api.update_idx(m->session->tr, i, tids, upd, isbat);
2054 : } else {
2055 0 : BBPunfix(tids->batCacheid);
2056 0 : BBPunfix(upd->batCacheid);
2057 0 : throw(SQL, "sql.update", SQLSTATE(38000) "Unable to find column or index %s.%s.%s",sname,tname,cname);
2058 : }
2059 3976 : BBPunfix(tids->batCacheid);
2060 3976 : BBPunfix(upd->batCacheid);
2061 3976 : if (log_res != LOG_OK)
2062 1 : throw(SQL, "sql.update", SQLSTATE(42000) "Update failed%s", log_res == LOG_CONFLICT ? " due to conflict with another transaction" : "");
2063 : return MAL_SUCCEED;
2064 : }
2065 :
2066 : /* str mvc_clear_table_wrap(lng *res, str *sname, str *tname); */
2067 : str
2068 41824 : mvc_clear_table_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2069 : {
2070 41824 : sql_schema *s;
2071 41824 : sql_table *t;
2072 41824 : mvc *m = NULL;
2073 41824 : str msg;
2074 41824 : BUN clear_res;
2075 41824 : lng *res = getArgReference_lng(stk, pci, 0);
2076 41824 : const char *sname = *getArgReference_str(stk, pci, 1);
2077 41824 : const char *tname = *getArgReference_str(stk, pci, 2);
2078 41824 : int restart_sequences = *getArgReference_int(stk, pci, 3);
2079 :
2080 41824 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
2081 : return msg;
2082 41827 : if ((msg = checkSQLContext(cntxt)) != NULL)
2083 : return msg;
2084 41828 : s = mvc_bind_schema(m, sname);
2085 41823 : if (s == NULL)
2086 0 : throw(SQL, "sql.clear_table", SQLSTATE(3F000) "Schema missing %s", sname);
2087 41823 : t = mvc_bind_table(m, s, tname);
2088 41825 : if (t == NULL)
2089 0 : throw(SQL, "sql.clear_table", SQLSTATE(42S02) "Table missing %s.%s", sname,tname);
2090 41825 : if (!isTable(t))
2091 0 : throw(SQL, "sql.clear_table", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
2092 41825 : clear_res = mvc_clear_table(m, t);
2093 41829 : if (clear_res >= BUN_NONE - 1)
2094 15820 : throw(SQL, "sql.clear_table", SQLSTATE(42000) "Table clear failed%s", clear_res == (BUN_NONE - 1) ? " due to conflict with another transaction" : "");
2095 26009 : if (restart_sequences) { /* restart the sequences if it's the case */
2096 2 : sql_trans *tr = m->session->tr;
2097 2 : const char next_value_for[] = "next value for ";
2098 :
2099 5 : for (node *n = ol_first_node(t->columns); n; n = n->next) {
2100 3 : sql_column *col = n->data;
2101 :
2102 3 : if (col->def && !strncmp(col->def, next_value_for, strlen(next_value_for))) {
2103 2 : sql_schema *seqs = NULL;
2104 2 : sql_sequence *seq = NULL;
2105 2 : char *schema = NULL, *seq_name = NULL;
2106 :
2107 2 : extract_schema_and_sequence_name(m->ta, col->def + strlen(next_value_for), &schema, &seq_name);
2108 2 : if (!schema || !seq_name || !(seqs = find_sql_schema(tr, schema)))
2109 0 : continue;
2110 :
2111 : /* TODO - At the moment the sequence may not be stored in the same schema as the table itself */
2112 2 : if ((seq = find_sql_sequence(tr, seqs, seq_name))) {
2113 2 : switch (sql_trans_sequence_restart(tr, seq, seq->start)) {
2114 0 : case -1:
2115 0 : throw(SQL, "sql.clear_table", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2116 0 : case -2:
2117 : case -3:
2118 0 : throw(SQL, "sql.clear_table", SQLSTATE(HY005) "RESTART SEQUENCE: transaction conflict detected");
2119 0 : case -4:
2120 0 : throw(SQL, "sql.clear_table", SQLSTATE(HY005) "Could not restart sequence %s.%s", seqs->base.name, seq_name);
2121 : default:
2122 : break;
2123 : }
2124 : }
2125 : }
2126 : }
2127 : }
2128 26009 : *res = (lng) clear_res;
2129 26009 : return MAL_SUCCEED;
2130 : }
2131 :
2132 : /*mvc_delete_wrap(int *d, str *sname, str *tname, ptr d) */
2133 : str
2134 367 : mvc_delete_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2135 : {
2136 367 : int *res = getArgReference_int(stk, pci, 0);
2137 367 : mvc *m = NULL;
2138 367 : str msg;
2139 367 : const char *sname = *getArgReference_str(stk, pci, 2);
2140 367 : const char *tname = *getArgReference_str(stk, pci, 3);
2141 367 : ptr ins = getArgReference(stk, pci, 4);
2142 367 : int tpe = getArgType(mb, pci, 4), log_res;
2143 367 : bool isbat = false;
2144 367 : BAT *b = NULL;
2145 367 : sql_schema *s;
2146 367 : sql_table *t;
2147 :
2148 367 : *res = 0;
2149 367 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
2150 : return msg;
2151 367 : if ((msg = checkSQLContext(cntxt)) != NULL)
2152 : return msg;
2153 367 : if (isaBatType(tpe))
2154 367 : isbat = true;
2155 367 : if (isbat && (b = BATdescriptor(*(bat *) ins)) == NULL)
2156 0 : throw(SQL, "sql.delete", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2157 367 : if (!isbat || (b->ttype != TYPE_oid && b->ttype != TYPE_void && b->ttype != TYPE_msk)) {
2158 0 : BBPreclaim(b);
2159 0 : throw(SQL, "sql.delete", SQLSTATE(HY005) "Cannot access column descriptor");
2160 : }
2161 367 : s = mvc_bind_schema(m, sname);
2162 367 : if (s == NULL) {
2163 0 : BBPreclaim(b);
2164 0 : throw(SQL, "sql.delete", SQLSTATE(3F000) "Schema missing %s",sname);
2165 : }
2166 367 : t = mvc_bind_table(m, s, tname);
2167 367 : if (t == NULL) {
2168 0 : BBPreclaim(b);
2169 0 : throw(SQL, "sql.delete", SQLSTATE(42S02) "Table missing %s.%s",sname,tname);
2170 : }
2171 367 : if (!isTable(t)) {
2172 0 : BBPreclaim(b);
2173 0 : throw(SQL, "sql.delete", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
2174 : }
2175 367 : sqlstore *store = m->session->tr->store;
2176 367 : log_res = store->storage_api.delete_tab(m->session->tr, t, b, isbat);
2177 367 : BBPreclaim(b);
2178 367 : if (log_res != LOG_OK)
2179 1 : throw(SQL, "sql.delete", SQLSTATE(42000) "Delete failed%s", log_res == LOG_CONFLICT ? " due to conflict with another transaction" : "");
2180 : return MAL_SUCCEED;
2181 : }
2182 :
2183 : static inline BAT *
2184 47 : setwritable(BAT *b)
2185 : {
2186 47 : if (isVIEW(b)) {
2187 46 : BAT *bn = COLcopy(b, b->ttype, true, TRANSIENT);
2188 46 : BBPunfix(b->batCacheid);
2189 46 : b = bn;
2190 : }
2191 47 : return b;
2192 : }
2193 :
2194 : str
2195 278575 : DELTAbat(bat *result, const bat *col, const bat *uid, const bat *uval)
2196 : {
2197 278575 : BAT *c, *u_id, *u_val, *res;
2198 :
2199 278575 : if ((u_id = BBPquickdesc(*uid)) == NULL)
2200 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2201 :
2202 : /* no updates */
2203 280062 : if (BATcount(u_id) == 0) {
2204 279348 : BBPretain(*result = *col);
2205 279348 : return MAL_SUCCEED;
2206 : }
2207 :
2208 714 : c = BATdescriptor(*col);
2209 714 : if (c == NULL)
2210 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2211 714 : if ((res = COLcopy(c, c->ttype, true, TRANSIENT)) == NULL) {
2212 0 : BBPunfix(c->batCacheid);
2213 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2214 : }
2215 714 : BBPunfix(c->batCacheid);
2216 :
2217 714 : if ((u_val = BATdescriptor(*uval)) == NULL) {
2218 0 : BBPunfix(res->batCacheid);
2219 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2220 : }
2221 714 : if ((u_id = BATdescriptor(*uid)) == NULL) {
2222 0 : BBPunfix(u_val->batCacheid);
2223 0 : BBPunfix(res->batCacheid);
2224 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2225 : }
2226 714 : assert(BATcount(u_id) == BATcount(u_val));
2227 1428 : if (BATcount(u_id) &&
2228 714 : BATreplace(res, u_id, u_val, true) != GDK_SUCCEED) {
2229 0 : BBPunfix(u_id->batCacheid);
2230 0 : BBPunfix(u_val->batCacheid);
2231 0 : BBPunfix(res->batCacheid);
2232 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2233 : }
2234 714 : BBPunfix(u_id->batCacheid);
2235 713 : BBPunfix(u_val->batCacheid);
2236 :
2237 714 : *result = res->batCacheid;
2238 714 : BBPkeepref(res);
2239 714 : return MAL_SUCCEED;
2240 : }
2241 :
2242 : str
2243 91617 : DELTAsub(bat *result, const bat *col, const bat *cid, const bat *uid, const bat *uval)
2244 : {
2245 91617 : BAT *c, *cminu = NULL, *u_id, *u_val, *u, *res;
2246 91617 : gdk_return ret;
2247 :
2248 91617 : if ((u_id = BBPquickdesc(*uid)) == NULL)
2249 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2250 :
2251 : /* no updates */
2252 91788 : if (BATcount(u_id) == 0) {
2253 91712 : BBPretain(*result = *col);
2254 91712 : return MAL_SUCCEED;
2255 : }
2256 :
2257 76 : c = BATdescriptor(*col);
2258 76 : if (c == NULL)
2259 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2260 76 : res = c;
2261 76 : if (BATcount(u_id)) {
2262 76 : u_id = BATdescriptor(*uid);
2263 76 : if (!u_id) {
2264 0 : BBPunfix(c->batCacheid);
2265 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2266 : }
2267 76 : cminu = BATdiff(c, u_id, NULL, NULL, false, false, BUN_NONE);
2268 76 : if (!cminu) {
2269 0 : BBPunfix(c->batCacheid);
2270 0 : BBPunfix(u_id->batCacheid);
2271 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2272 : }
2273 76 : res = BATproject(cminu, c);
2274 76 : BBPunfix(c->batCacheid);
2275 76 : BBPunfix(cminu->batCacheid);
2276 76 : cminu = NULL;
2277 76 : if (!res) {
2278 0 : BBPunfix(u_id->batCacheid);
2279 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2280 : }
2281 76 : c = res;
2282 :
2283 76 : if ((u_val = BATdescriptor(*uval)) == NULL) {
2284 0 : BBPunfix(c->batCacheid);
2285 0 : BBPunfix(u_id->batCacheid);
2286 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2287 : }
2288 76 : if (BATcount(u_val)) {
2289 68 : u = BATproject(u_val, u_id);
2290 68 : BBPunfix(u_val->batCacheid);
2291 68 : BBPunfix(u_id->batCacheid);
2292 68 : if (!u) {
2293 0 : BBPunfix(c->batCacheid);
2294 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2295 : }
2296 :
2297 : /* check selected updated values against candidates */
2298 68 : BAT *c_ids = BATdescriptor(*cid);
2299 :
2300 68 : if (!c_ids) {
2301 0 : BBPunfix(c->batCacheid);
2302 0 : BBPunfix(u->batCacheid);
2303 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2304 : }
2305 68 : cminu = BATintersect(u, c_ids, NULL, NULL, false, false, BUN_NONE);
2306 68 : BBPunfix(c_ids->batCacheid);
2307 68 : if (cminu == NULL) {
2308 0 : BBPunfix(c->batCacheid);
2309 0 : BBPunfix(u->batCacheid);
2310 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2311 : }
2312 68 : BAT *nres;
2313 68 : if ((nres = COLcopy(res, res->ttype, true, TRANSIENT)) == NULL) {
2314 0 : BBPunfix(res->batCacheid);
2315 0 : BBPunfix(u->batCacheid);
2316 0 : BBPunfix(cminu->batCacheid);
2317 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2318 : }
2319 68 : BBPunfix(res->batCacheid);
2320 68 : res = nres;
2321 68 : ret = BATappend(res, u, cminu, true);
2322 :
2323 68 : BBPunfix(u->batCacheid);
2324 68 : BBPunfix(cminu->batCacheid);
2325 68 : cminu = NULL;
2326 68 : if (ret != GDK_SUCCEED) {
2327 0 : BBPunfix(res->batCacheid);
2328 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2329 : }
2330 :
2331 68 : ret = BATsort(&u, NULL, NULL, res, NULL, NULL, false, false, false);
2332 68 : BBPunfix(res->batCacheid);
2333 68 : if (ret != GDK_SUCCEED) {
2334 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2335 : }
2336 68 : res = u;
2337 : } else {
2338 8 : BBPunfix(u_val->batCacheid);
2339 8 : BBPunfix(u_id->batCacheid);
2340 : }
2341 : }
2342 :
2343 76 : BATkey(res, true);
2344 76 : *result = res->batCacheid;
2345 76 : BBPkeepref(res);
2346 76 : return MAL_SUCCEED;
2347 : }
2348 :
2349 : str
2350 260964 : DELTAproject(bat *result, const bat *sub, const bat *col, const bat *uid, const bat *uval)
2351 : {
2352 260964 : BAT *s, *c, *u_id, *u_val, *res, *tres;
2353 :
2354 260964 : if ((s = BATdescriptor(*sub)) == NULL)
2355 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2356 :
2357 263243 : if ((c = BATdescriptor(*col)) == NULL) {
2358 0 : BBPunfix(s->batCacheid);
2359 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2360 : }
2361 :
2362 : /* projection(sub,col) */
2363 263228 : res = c;
2364 263228 : tres = BATproject(s, res);
2365 261416 : BBPunfix(res->batCacheid);
2366 :
2367 262732 : if (tres == NULL) {
2368 0 : BBPunfix(s->batCacheid);
2369 0 : throw(MAL, "sql.projectdelta", GDK_EXCEPTION);
2370 : }
2371 262732 : res = tres;
2372 :
2373 262732 : if ((u_id = BATdescriptor(*uid)) == NULL) {
2374 0 : BBPunfix(res->batCacheid);
2375 0 : BBPunfix(s->batCacheid);
2376 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2377 : }
2378 263229 : if (!BATcount(u_id)) {
2379 263160 : BBPunfix(u_id->batCacheid);
2380 263165 : BBPunfix(s->batCacheid);
2381 263186 : *result = res->batCacheid;
2382 263186 : BBPkeepref(res);
2383 263186 : return MAL_SUCCEED;
2384 : }
2385 69 : if ((u_val = BATdescriptor(*uval)) == NULL) {
2386 0 : BBPunfix(u_id->batCacheid);
2387 0 : BBPunfix(res->batCacheid);
2388 0 : BBPunfix(s->batCacheid);
2389 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2390 : }
2391 :
2392 69 : if (BATcount(u_val)) {
2393 69 : BAT *os, *ou;
2394 : /* figure out the positions in res that we have to
2395 : * replace with values from u_val */
2396 69 : if (BATsemijoin(&ou, &os, u_id, s, NULL, NULL, false, false, BUN_NONE) != GDK_SUCCEED) {
2397 0 : BBPunfix(s->batCacheid);
2398 0 : BBPunfix(res->batCacheid);
2399 0 : BBPunfix(u_id->batCacheid);
2400 0 : BBPunfix(u_val->batCacheid);
2401 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2402 : }
2403 : /* BATcount(ou) == BATcount(os) */
2404 69 : if (BATcount(ou) != 0) {
2405 : /* ou contains the position in u_id/u_val that
2406 : * contain the new values */
2407 47 : BAT *nu_val = BATproject(ou, u_val);
2408 47 : BBPunfix(ou->batCacheid);
2409 : /* os contains the corresponding positions in
2410 : * res that need to be replaced with those new
2411 : * values */
2412 94 : if (!nu_val || (res = setwritable(res)) == NULL ||
2413 47 : BATreplace(res, os, nu_val, false) != GDK_SUCCEED) {
2414 0 : BBPreclaim(res);
2415 0 : BBPunfix(os->batCacheid);
2416 0 : BBPunfix(s->batCacheid);
2417 0 : BBPunfix(u_id->batCacheid);
2418 0 : BBPunfix(u_val->batCacheid);
2419 0 : BBPreclaim(nu_val);
2420 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2421 : }
2422 47 : BBPunfix(nu_val->batCacheid);
2423 : } else {
2424 : /* nothing to replace */
2425 22 : BBPunfix(ou->batCacheid);
2426 : }
2427 69 : BBPunfix(os->batCacheid);
2428 : }
2429 69 : BBPunfix(s->batCacheid);
2430 69 : BBPunfix(u_id->batCacheid);
2431 69 : BBPunfix(u_val->batCacheid);
2432 :
2433 69 : *result = res->batCacheid;
2434 69 : BBPkeepref(res);
2435 69 : return MAL_SUCCEED;
2436 : }
2437 :
2438 : str
2439 26 : BATleftproject(bat *Res, const bat *Col, const bat *L, const bat *R)
2440 : {
2441 26 : BAT *c, *l, *r, *res;
2442 26 : oid *p, *lp, *rp;
2443 26 : BUN cnt = 0, i;
2444 26 : BATiter li, ri;
2445 :
2446 26 : c = BATdescriptor(*Col);
2447 26 : if (c)
2448 26 : cnt = BATcount(c);
2449 26 : l = BATdescriptor(*L);
2450 26 : r = BATdescriptor(*R);
2451 26 : res = COLnew(0, TYPE_oid, cnt, TRANSIENT);
2452 26 : if (!c || !l || !r || !res) {
2453 0 : BBPreclaim(c);
2454 0 : BBPreclaim(l);
2455 0 : BBPreclaim(r);
2456 0 : BBPreclaim(res);
2457 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2458 : }
2459 26 : p = (oid*)Tloc(res,0);
2460 51 : for(i=0;i<cnt; i++)
2461 25 : *p++ = oid_nil;
2462 26 : BATsetcount(res, cnt);
2463 :
2464 26 : cnt = BATcount(l);
2465 26 : p = (oid*)Tloc(res, 0);
2466 26 : li = bat_iterator(l);
2467 26 : ri = bat_iterator(r);
2468 26 : lp = (oid*)li.base;
2469 26 : rp = (oid*)ri.base;
2470 26 : if (l->ttype == TYPE_void) {
2471 11 : oid lp = l->tseqbase;
2472 11 : if (r->ttype == TYPE_void) {
2473 11 : oid rp = r->tseqbase;
2474 11 : for(i=0;i<cnt; i++, lp++, rp++)
2475 0 : p[lp] = rp;
2476 : } else {
2477 0 : for(i=0;i<cnt; i++, lp++)
2478 0 : p[lp] = rp[i];
2479 : }
2480 : }
2481 26 : if (r->ttype == TYPE_void) {
2482 23 : oid rp = r->tseqbase;
2483 35 : for(i=0;i<cnt; i++, rp++)
2484 12 : p[lp[i]] = rp;
2485 : } else {
2486 9 : for(i=0;i<cnt; i++)
2487 6 : p[lp[i]] = rp[i];
2488 : }
2489 26 : bat_iterator_end(&li);
2490 26 : bat_iterator_end(&ri);
2491 26 : res->tsorted = false;
2492 26 : res->trevsorted = false;
2493 26 : res->tnil = false;
2494 26 : res->tnonil = false;
2495 26 : res->tkey = false;
2496 26 : BBPunfix(c->batCacheid);
2497 26 : BBPunfix(l->batCacheid);
2498 26 : BBPunfix(r->batCacheid);
2499 26 : *Res = res->batCacheid;
2500 26 : BBPkeepref(res);
2501 26 : return MAL_SUCCEED;
2502 : }
2503 :
2504 : /* str SQLtid(bat *result, mvc *m, str *sname, str *tname) */
2505 : str
2506 438672 : SQLtid(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2507 : {
2508 438672 : bat *res = getArgReference_bat(stk, pci, 0);
2509 438672 : mvc *m = NULL;
2510 438672 : str msg = MAL_SUCCEED;
2511 438672 : sql_trans *tr;
2512 438672 : const char *sname = *getArgReference_str(stk, pci, 2);
2513 438672 : const char *tname = *getArgReference_str(stk, pci, 3);
2514 438672 : sql_schema *s;
2515 438672 : sql_table *t;
2516 :
2517 438672 : *res = bat_nil;
2518 438672 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
2519 : return msg;
2520 438691 : tr = m->session->tr;
2521 438691 : if ((msg = checkSQLContext(cntxt)) != NULL)
2522 : return msg;
2523 438865 : s = mvc_bind_schema(m, sname);
2524 438736 : if (s == NULL)
2525 0 : throw(SQL, "sql.tid", SQLSTATE(3F000) "Schema missing %s",sname);
2526 438736 : t = mvc_bind_table(m, s, tname);
2527 438593 : if (t == NULL)
2528 0 : throw(SQL, "sql.tid", SQLSTATE(42S02) "Table missing %s.%s",sname,tname);
2529 438593 : if (!isTable(t))
2530 0 : throw(SQL, "sql.tid", SQLSTATE(42000) "%s '%s' is not persistent",
2531 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
2532 :
2533 438593 : sqlstore *store = m->store;
2534 : /* we have full table count, nr of deleted (unused rows) */
2535 438593 : int part_nr = 0;
2536 438593 : int nr_parts = 1;
2537 438593 : if (pci->argc == 6) { /* partitioned version */
2538 339374 : part_nr = *getArgReference_int(stk, pci, 4);
2539 339374 : nr_parts = *getArgReference_int(stk, pci, 5);
2540 : }
2541 438593 : BAT *b = store->storage_api.bind_cands(tr, t, nr_parts, part_nr);
2542 438563 : b->tunique_est = (double)BATcount(b);
2543 438563 : if (b) {
2544 438563 : *res = b->batCacheid;
2545 438563 : BBPkeepref(b);
2546 : } else {
2547 : msg = createException(SQL, "sql.tid", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2548 : }
2549 438563 : return msg;
2550 : }
2551 :
2552 : /* unsafe pattern resultSet(tbl:bat[:str], attr:bat[:str], tpe:bat[:str], len:bat[:int],scale:bat[:int],multiset:bat[:int], cols:bat[:any]...) :int */
2553 : /* New result set rendering infrastructure */
2554 :
2555 : static str
2556 67610 : mvc_result_set_wrap( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2557 : {
2558 67610 : int *res_id =getArgReference_int(stk,pci,0);
2559 67610 : bat tblId= *getArgReference_bat(stk, pci,1);
2560 67610 : bat atrId= *getArgReference_bat(stk, pci,2);
2561 67610 : bat tpeId= *getArgReference_bat(stk, pci,3);
2562 67610 : bat lenId= *getArgReference_bat(stk, pci,4);
2563 67610 : bat scaleId= *getArgReference_bat(stk, pci,5);
2564 67610 : bat multisetId= *getArgReference_bat(stk, pci,6);
2565 67610 : bat bid;
2566 67610 : int i, res, ok;
2567 67610 : const char *tblname, *colname, *tpename;
2568 67610 : str msg= MAL_SUCCEED;
2569 67610 : int *digits, *scaledigits, *ms;
2570 67610 : oid o = 0;
2571 67610 : BATiter itertbl,iteratr,itertpe,iterdig,iterscl,iterms;
2572 67610 : backend *be = NULL;
2573 67610 : BAT *b = NULL, *tbl = NULL, *atr = NULL, *tpe = NULL,*len = NULL,*scale = NULL, *multiset = NULL;
2574 :
2575 67610 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
2576 : return msg;
2577 67612 : bid = *getArgReference_bat(stk,pci,6);
2578 67612 : b = BATdescriptor(bid);
2579 67613 : if ( b == NULL) {
2580 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2581 0 : goto wrapup_result_set;
2582 : }
2583 67613 : res = *res_id = mvc_result_table(be, mb->tag, pci->argc - (pci->retc + 6), Q_TABLE);
2584 67612 : BBPunfix(b->batCacheid);
2585 67612 : if (res < 0) {
2586 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2587 0 : goto wrapup_result_set;
2588 : }
2589 :
2590 67612 : tbl = BATdescriptor(tblId);
2591 67613 : atr = BATdescriptor(atrId);
2592 67613 : tpe = BATdescriptor(tpeId);
2593 67612 : len = BATdescriptor(lenId);
2594 67613 : scale = BATdescriptor(scaleId);
2595 67613 : multiset = BATdescriptor(multisetId);
2596 67613 : if (tbl == NULL || atr == NULL || tpe == NULL || len == NULL || scale == NULL || multiset == NULL)
2597 0 : goto wrapup_result_set;
2598 : /* mimic the old rsColumn approach; */
2599 67613 : itertbl = bat_iterator(tbl);
2600 67613 : iteratr = bat_iterator(atr);
2601 67613 : itertpe = bat_iterator(tpe);
2602 67613 : iterdig = bat_iterator(len);
2603 67613 : iterscl = bat_iterator(scale);
2604 67613 : iterms = bat_iterator(multiset);
2605 67613 : digits = (int*) iterdig.base;
2606 67613 : scaledigits = (int*) iterscl.base;
2607 67613 : ms = (int*) iterms.base;
2608 :
2609 350789 : for( i = 7; msg == MAL_SUCCEED && i< pci->argc; i++, o++){
2610 283176 : bid = *getArgReference_bat(stk,pci,i);
2611 283176 : tblname = BUNtvar(itertbl,o);
2612 283176 : colname = BUNtvar(iteratr,o);
2613 283176 : tpename = BUNtvar(itertpe,o);
2614 283176 : b = BATdescriptor(bid);
2615 283185 : if ( b == NULL)
2616 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2617 283185 : else if (mvc_result_column(be, tblname, colname, tpename, *digits++, *scaledigits++, *ms++, b))
2618 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(42000) "Cannot access column descriptor %s.%s",tblname,colname);
2619 283175 : if( b)
2620 283176 : BBPunfix(bid);
2621 : }
2622 67613 : bat_iterator_end(&itertbl);
2623 67613 : bat_iterator_end(&iteratr);
2624 67612 : bat_iterator_end(&itertpe);
2625 67611 : bat_iterator_end(&iterdig);
2626 67611 : bat_iterator_end(&iterscl);
2627 67613 : bat_iterator_end(&iterms);
2628 : /* now send it to the channel cntxt->fdout */
2629 67611 : if (bstream_getoob(cntxt->fdin))
2630 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY000) "Query aboted");
2631 67609 : else if (!msg && (ok = mvc_export_result(be, cntxt->fdout, res, true, cntxt->qryctx.starttime, mb->optimize)) < 0)
2632 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(be, cntxt->fdout, ok));
2633 67607 : wrapup_result_set:
2634 67607 : cntxt->qryctx.starttime = 0;
2635 67607 : cntxt->qryctx.endtime = 0;
2636 67607 : mb->optimize = 0;
2637 67607 : if( tbl) BBPunfix(tblId);
2638 67610 : if( atr) BBPunfix(atrId);
2639 67612 : if( tpe) BBPunfix(tpeId);
2640 67613 : if( len) BBPunfix(lenId);
2641 67613 : if( scale) BBPunfix(scaleId);
2642 67612 : if( multiset) BBPunfix(multisetId);
2643 : return msg;
2644 : }
2645 :
2646 : /* Copy the result set into a CSV file */
2647 : str
2648 31 : mvc_export_table_wrap( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2649 : {
2650 31 : int *res_id =getArgReference_int(stk,pci,0);
2651 31 : const char *filename = *getArgReference_str(stk,pci,1);
2652 31 : const char *format = *getArgReference_str(stk,pci,2);
2653 31 : const char *tsep = *getArgReference_str(stk, pci, 3);
2654 31 : const char *rsep = *getArgReference_str(stk, pci, 4);
2655 31 : const char *ssep = *getArgReference_str(stk, pci, 5);
2656 31 : const char *ns = *getArgReference_str(stk, pci, 6);
2657 31 : int onclient = *getArgReference_int(stk, pci, 7);
2658 :
2659 31 : bat tblId= *getArgReference_bat(stk, pci,8);
2660 31 : bat atrId= *getArgReference_bat(stk, pci,9);
2661 31 : bat tpeId= *getArgReference_bat(stk, pci,10);
2662 31 : bat lenId= *getArgReference_bat(stk, pci,11);
2663 31 : bat scaleId= *getArgReference_bat(stk, pci,12);
2664 31 : stream *s = NULL;
2665 31 : bat bid;
2666 31 : int i, res, ok;
2667 31 : const char *tblname, *colname, *tpename;
2668 31 : str msg= MAL_SUCCEED;
2669 31 : int *digits, *scaledigits;
2670 31 : oid o = 0;
2671 31 : BATiter itertbl,iteratr,itertpe,iterdig,iterscl;
2672 31 : backend *be;
2673 31 : mvc *m = NULL;
2674 31 : BAT *b = NULL, *tbl = NULL, *atr = NULL, *tpe = NULL,*len = NULL,*scale = NULL;
2675 31 : res_table *t = NULL;
2676 31 : bool tostdout;
2677 31 : char buf[80];
2678 31 : ssize_t sz;
2679 :
2680 31 : (void) format;
2681 :
2682 31 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
2683 : return msg;
2684 31 : m = be->mvc;
2685 :
2686 31 : if (onclient && !cntxt->filetrans) {
2687 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(42000) "Cannot transfer files to client");
2688 0 : goto wrapup_result_set1;
2689 : }
2690 :
2691 31 : bid = *getArgReference_bat(stk,pci,13);
2692 31 : res = *res_id = mvc_result_table(be, mb->tag, pci->argc - (pci->retc + 12), Q_TABLE);
2693 31 : t = be->results;
2694 31 : if (res < 0) {
2695 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2696 0 : goto wrapup_result_set1;
2697 : }
2698 :
2699 31 : t->tsep = tsep;
2700 31 : t->rsep = rsep;
2701 31 : t->ssep = ssep;
2702 31 : t->ns = ns;
2703 :
2704 31 : tbl = BATdescriptor(tblId);
2705 31 : atr = BATdescriptor(atrId);
2706 31 : tpe = BATdescriptor(tpeId);
2707 31 : len = BATdescriptor(lenId);
2708 31 : scale = BATdescriptor(scaleId);
2709 31 : if( tbl == NULL || atr == NULL || tpe == NULL || len == NULL || scale == NULL)
2710 0 : goto wrapup_result_set1;
2711 : /* mimic the old rsColumn approach; */
2712 31 : itertbl = bat_iterator(tbl);
2713 31 : iteratr = bat_iterator(atr);
2714 31 : itertpe = bat_iterator(tpe);
2715 31 : iterdig = bat_iterator(len);
2716 31 : iterscl = bat_iterator(scale);
2717 31 : digits = (int*) iterdig.base;
2718 31 : scaledigits = (int*) iterscl.base;
2719 :
2720 170 : for( i = 13; msg == MAL_SUCCEED && i< pci->argc; i++, o++){
2721 139 : bid = *getArgReference_bat(stk,pci,i);
2722 139 : tblname = BUNtvar(itertbl,o);
2723 139 : colname = BUNtvar(iteratr,o);
2724 139 : tpename = BUNtvar(itertpe,o);
2725 139 : b = BATdescriptor(bid);
2726 139 : if ( b == NULL)
2727 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2728 139 : else if (mvc_result_column(be, tblname, colname, tpename, *digits++, *scaledigits++, MS_VALUE, b))
2729 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(42000) "Cannot access column descriptor %s.%s",tblname,colname);
2730 139 : if( b)
2731 139 : BBPunfix(bid);
2732 : }
2733 31 : bat_iterator_end(&itertbl);
2734 31 : bat_iterator_end(&iteratr);
2735 31 : bat_iterator_end(&itertpe);
2736 31 : bat_iterator_end(&iterdig);
2737 31 : bat_iterator_end(&iterscl);
2738 31 : if ( msg )
2739 0 : goto wrapup_result_set1;
2740 :
2741 : /* now select the file channel */
2742 31 : if ((tostdout = strcmp(filename,"stdout") == 0)) {
2743 8 : s = cntxt->fdout;
2744 23 : } else if (!onclient) {
2745 4 : if ((s = open_wastream(filename)) == NULL || mnstr_errnr(s) != MNSTR_NO__ERROR) {
2746 0 : msg= createException(IO, "streams.open", SQLSTATE(42000) "%s", mnstr_peek_error(NULL));
2747 0 : close_stream(s);
2748 0 : goto wrapup_result_set1;
2749 : }
2750 4 : be->output_format = OFMT_CSV;
2751 : } else {
2752 19 : while (!m->scanner.rs->eof) {
2753 0 : if (bstream_next(m->scanner.rs) < 0) {
2754 0 : msg = createException(IO, "streams.open", "interrupted");
2755 0 : goto wrapup_result_set1;
2756 : }
2757 : }
2758 19 : s = m->scanner.ws;
2759 19 : mnstr_write(s, PROMPT3, sizeof(PROMPT3) - 1, 1);
2760 19 : mnstr_printf(s, "w %s\n", filename);
2761 19 : mnstr_flush(s, MNSTR_FLUSH_DATA);
2762 19 : if ((sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf))) > 1) {
2763 : /* non-empty line indicates failure on client */
2764 7 : msg = createException(IO, "streams.open", "%s", buf);
2765 : /* discard until client flushes */
2766 15 : while (mnstr_read(m->scanner.rs->s, buf, 1, sizeof(buf)) > 0) {
2767 : /* ignore remainder of error message */
2768 8 : }
2769 7 : goto wrapup_result_set1;
2770 : }
2771 : }
2772 24 : if ((ok = mvc_export_result(cntxt->sqlcontext, s, res, tostdout, cntxt->qryctx.starttime, mb->optimize)) < 0) {
2773 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(cntxt->sqlcontext, s, ok));
2774 0 : if (!onclient && !tostdout)
2775 0 : close_stream(s);
2776 0 : if (ok != -5)
2777 0 : goto wrapup_result_set1;
2778 : }
2779 24 : if (onclient) {
2780 12 : mnstr_flush(s, MNSTR_FLUSH_DATA);
2781 12 : if ((sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf))) > 1) {
2782 0 : msg = createException(IO, "streams.open", "%s", buf);
2783 : }
2784 24 : while (sz > 0)
2785 12 : sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf));
2786 12 : } else if (!tostdout) {
2787 4 : close_stream(s);
2788 : }
2789 8 : wrapup_result_set1:
2790 31 : cntxt->qryctx.starttime = 0;
2791 31 : cntxt->qryctx.endtime = 0;
2792 31 : mb->optimize = 0;
2793 31 : if( tbl) BBPunfix(tblId);
2794 31 : if( atr) BBPunfix(atrId);
2795 31 : if( tpe) BBPunfix(tpeId);
2796 31 : if( len) BBPunfix(lenId);
2797 31 : if( scale) BBPunfix(scaleId);
2798 : return msg;
2799 : }
2800 :
2801 : /* unsafe pattern resultSet(tbl:bat[:str], attr:bat[:str], tpe:bat[:str], len:bat[:int],scale:bat[:int],multiset:bat[:int],cols:any...) :int */
2802 : str
2803 566 : mvc_row_result_wrap( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2804 : {
2805 566 : int *res_id= getArgReference_int(stk, pci,0);
2806 566 : bat tblId= *getArgReference_bat(stk, pci,1);
2807 566 : bat atrId= *getArgReference_bat(stk, pci,2);
2808 566 : bat tpeId= *getArgReference_bat(stk, pci,3);
2809 566 : bat lenId= *getArgReference_bat(stk, pci,4);
2810 566 : bat scaleId= *getArgReference_bat(stk, pci,5);
2811 566 : bat multisetId= *getArgReference_bat(stk, pci,6);
2812 566 : int i, res, ok;
2813 566 : const char *tblname, *colname, *tpename;
2814 566 : str msg= MAL_SUCCEED;
2815 566 : int *digits, *scaledigits, *ms;
2816 566 : oid o = 0;
2817 566 : BATiter itertbl,iteratr,itertpe,iterdig,iterscl,iterms;
2818 566 : backend *be = NULL;
2819 566 : ptr v;
2820 566 : int mtype;
2821 566 : BAT *tbl = NULL, *atr = NULL, *tpe = NULL, *len = NULL, *scale = NULL, *multiset = NULL;
2822 :
2823 566 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
2824 : return msg;
2825 566 : res = *res_id = mvc_result_table(be, mb->tag, pci->argc - (pci->retc + 6), Q_TABLE);
2826 566 : if (res < 0) {
2827 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2828 0 : goto wrapup_result_set;
2829 : }
2830 :
2831 566 : tbl = BATdescriptor(tblId);
2832 566 : atr = BATdescriptor(atrId);
2833 566 : tpe = BATdescriptor(tpeId);
2834 566 : len = BATdescriptor(lenId);
2835 566 : scale = BATdescriptor(scaleId);
2836 566 : multiset = BATdescriptor(multisetId);
2837 566 : if( tbl == NULL || atr == NULL || tpe == NULL || len == NULL || scale == NULL)
2838 0 : goto wrapup_result_set;
2839 : /* mimic the old rsColumn approach; */
2840 566 : itertbl = bat_iterator(tbl);
2841 566 : iteratr = bat_iterator(atr);
2842 566 : itertpe = bat_iterator(tpe);
2843 566 : iterdig = bat_iterator(len);
2844 566 : iterscl = bat_iterator(scale);
2845 566 : iterms = bat_iterator(multiset);
2846 566 : digits = (int*) iterdig.base;
2847 566 : scaledigits = (int*) iterscl.base;
2848 566 : ms = (int*) iterms.base;
2849 :
2850 3309 : for( i = 7; msg == MAL_SUCCEED && i< pci->argc; i++, o++){
2851 2743 : tblname = BUNtvar(itertbl,o);
2852 2743 : colname = BUNtvar(iteratr,o);
2853 2743 : tpename = BUNtvar(itertpe,o);
2854 :
2855 2743 : v = getArgReference(stk, pci, i);
2856 2743 : mtype = getArgType(mb, pci, i);
2857 2743 : if (ATOMextern(mtype))
2858 538 : v = *(ptr *) v;
2859 2743 : if ((ok = mvc_result_value(be, tblname, colname, tpename, *digits++, *scaledigits++, *ms++, v, mtype) < 0)) {
2860 0 : msg = createException(SQL, "sql.rsColumn", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(be, be->out, ok));
2861 0 : bat_iterator_end(&itertbl);
2862 0 : bat_iterator_end(&iteratr);
2863 0 : bat_iterator_end(&itertpe);
2864 0 : bat_iterator_end(&iterdig);
2865 0 : bat_iterator_end(&iterscl);
2866 0 : bat_iterator_end(&iterms);
2867 0 : goto wrapup_result_set;
2868 : }
2869 : }
2870 566 : bat_iterator_end(&itertbl);
2871 566 : bat_iterator_end(&iteratr);
2872 566 : bat_iterator_end(&itertpe);
2873 566 : bat_iterator_end(&iterdig);
2874 566 : bat_iterator_end(&iterscl);
2875 566 : bat_iterator_end(&iterms);
2876 566 : if (!msg && (ok = mvc_export_result(cntxt->sqlcontext, cntxt->fdout, res, true, cntxt->qryctx.starttime, mb->optimize)) < 0)
2877 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(cntxt->sqlcontext, cntxt->fdout, ok));
2878 566 : wrapup_result_set:
2879 566 : cntxt->qryctx.starttime = 0;
2880 566 : cntxt->qryctx.endtime = 0;
2881 566 : mb->optimize = 0;
2882 566 : if( tbl) BBPunfix(tblId);
2883 566 : if( atr) BBPunfix(atrId);
2884 566 : if( tpe) BBPunfix(tpeId);
2885 566 : if( len) BBPunfix(lenId);
2886 566 : if( scale) BBPunfix(scaleId);
2887 566 : if( multiset) BBPunfix(multisetId);
2888 : return msg;
2889 : }
2890 :
2891 : str
2892 1 : mvc_export_row_wrap( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2893 : {
2894 1 : int *res_id= getArgReference_int(stk, pci,0);
2895 1 : str filename = * getArgReference_str(stk,pci,1);
2896 1 : const char *format = *getArgReference_str(stk,pci,2);
2897 1 : const char *tsep = *getArgReference_str(stk, pci, 3);
2898 1 : const char *rsep = *getArgReference_str(stk, pci, 4);
2899 1 : const char *ssep = *getArgReference_str(stk, pci, 5);
2900 1 : const char *ns = *getArgReference_str(stk, pci, 6);
2901 1 : int onclient = *getArgReference_int(stk, pci, 7);
2902 :
2903 1 : bat tblId= *getArgReference_bat(stk, pci,8);
2904 1 : bat atrId= *getArgReference_bat(stk, pci,9);
2905 1 : bat tpeId= *getArgReference_bat(stk, pci,10);
2906 1 : bat lenId= *getArgReference_bat(stk, pci,11);
2907 1 : bat scaleId= *getArgReference_bat(stk, pci,12);
2908 :
2909 1 : int i, res, ok;
2910 1 : stream *s = NULL;
2911 1 : const char *tblname, *colname, *tpename;
2912 1 : str msg = MAL_SUCCEED;
2913 1 : int *digits, *scaledigits;
2914 1 : oid o = 0;
2915 1 : BATiter itertbl,iteratr,itertpe,iterdig,iterscl;
2916 1 : backend *be;
2917 1 : mvc *m = NULL;
2918 1 : res_table *t = NULL;
2919 1 : ptr v;
2920 1 : int mtype;
2921 1 : BAT *tbl = NULL, *atr = NULL, *tpe = NULL,*len = NULL,*scale = NULL;
2922 1 : bool tostdout;
2923 1 : char buf[80];
2924 1 : ssize_t sz;
2925 :
2926 1 : (void) format;
2927 1 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
2928 : return msg;
2929 1 : m = be->mvc;
2930 1 : if (onclient && !cntxt->filetrans) {
2931 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(42000) "Cannot transfer files to client");
2932 0 : goto wrapup_result_set;
2933 : }
2934 :
2935 1 : res = *res_id = mvc_result_table(be, mb->tag, pci->argc - (pci->retc + 12), Q_TABLE);
2936 :
2937 1 : t = be->results;
2938 1 : if (res < 0){
2939 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2940 0 : goto wrapup_result_set;
2941 : }
2942 :
2943 1 : t->tsep = tsep;
2944 1 : t->rsep = rsep;
2945 1 : t->ssep = ssep;
2946 1 : t->ns = ns;
2947 :
2948 1 : tbl = BATdescriptor(tblId);
2949 1 : atr = BATdescriptor(atrId);
2950 1 : tpe = BATdescriptor(tpeId);
2951 1 : len = BATdescriptor(lenId);
2952 1 : scale = BATdescriptor(scaleId);
2953 1 : if (tbl == NULL || atr == NULL || tpe == NULL || len == NULL || scale == NULL)
2954 0 : goto wrapup_result_set;
2955 : /* mimic the old rsColumn approach; */
2956 1 : itertbl = bat_iterator(tbl);
2957 1 : iteratr = bat_iterator(atr);
2958 1 : itertpe = bat_iterator(tpe);
2959 1 : iterdig = bat_iterator(len);
2960 1 : iterscl = bat_iterator(scale);
2961 1 : digits = (int*) iterdig.base;
2962 1 : scaledigits = (int*) iterscl.base;
2963 :
2964 2 : for( i = 13; msg == MAL_SUCCEED && i< pci->argc; i++, o++){
2965 1 : tblname = BUNtvar(itertbl,o);
2966 1 : colname = BUNtvar(iteratr,o);
2967 1 : tpename = BUNtvar(itertpe,o);
2968 :
2969 1 : v = getArgReference(stk, pci, i);
2970 1 : mtype = getArgType(mb, pci, i);
2971 1 : if (ATOMextern(mtype))
2972 0 : v = *(ptr *) v;
2973 1 : if ((ok = mvc_result_value(be, tblname, colname, tpename, *digits++, *scaledigits++, MS_VALUE, v, mtype)) < 0) {
2974 0 : msg = createException(SQL, "sql.rsColumn", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(be, s, ok));
2975 0 : bat_iterator_end(&itertbl);
2976 0 : bat_iterator_end(&iteratr);
2977 0 : bat_iterator_end(&itertpe);
2978 0 : bat_iterator_end(&iterdig);
2979 0 : bat_iterator_end(&iterscl);
2980 0 : goto wrapup_result_set;
2981 : }
2982 : }
2983 1 : bat_iterator_end(&itertbl);
2984 1 : bat_iterator_end(&iteratr);
2985 1 : bat_iterator_end(&itertpe);
2986 1 : bat_iterator_end(&iterdig);
2987 1 : bat_iterator_end(&iterscl);
2988 : /* now select the file channel */
2989 1 : if ((tostdout = strcmp(filename,"stdout") == 0)) {
2990 1 : s = cntxt->fdout;
2991 0 : } else if (!onclient) {
2992 0 : if ((s = open_wastream(filename)) == NULL || mnstr_errnr(s) != MNSTR_NO__ERROR) {
2993 0 : msg= createException(IO, "streams.open", SQLSTATE(42000) "%s", mnstr_peek_error(NULL));
2994 0 : close_stream(s);
2995 0 : goto wrapup_result_set;
2996 : }
2997 : } else {
2998 0 : while (!m->scanner.rs->eof) {
2999 0 : if (bstream_next(m->scanner.rs) < 0) {
3000 0 : msg = createException(IO, "streams.open", "interrupted");
3001 0 : goto wrapup_result_set;
3002 : }
3003 : }
3004 0 : s = m->scanner.ws;
3005 0 : mnstr_write(s, PROMPT3, sizeof(PROMPT3) - 1, 1);
3006 0 : mnstr_printf(s, "w %s\n", filename);
3007 0 : mnstr_flush(s, MNSTR_FLUSH_DATA);
3008 0 : if ((sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf))) > 1) {
3009 : /* non-empty line indicates failure on client */
3010 0 : msg = createException(IO, "streams.open", "%s", buf);
3011 : /* discard until client flushes */
3012 0 : while (mnstr_read(m->scanner.rs->s, buf, 1, sizeof(buf)) > 0) {
3013 : /* ignore remainder of error message */
3014 0 : }
3015 0 : goto wrapup_result_set;
3016 : }
3017 : }
3018 1 : if ((ok = mvc_export_result(cntxt->sqlcontext, s, res, strcmp(filename, "stdout") == 0, cntxt->qryctx.starttime, mb->optimize)) < 0) {
3019 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(cntxt->sqlcontext, s, ok));
3020 0 : if (!onclient && !tostdout)
3021 0 : close_stream(s);
3022 0 : goto wrapup_result_set;
3023 : }
3024 1 : if (onclient) {
3025 0 : mnstr_flush(s, MNSTR_FLUSH_DATA);
3026 0 : if ((sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf))) > 1) {
3027 0 : msg = createException(IO, "streams.open", "%s", buf);
3028 : }
3029 0 : while (sz > 0)
3030 0 : sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf));
3031 1 : } else if (!tostdout) {
3032 0 : close_stream(s);
3033 : }
3034 1 : wrapup_result_set:
3035 1 : cntxt->qryctx.starttime = 0;
3036 1 : cntxt->qryctx.endtime = 0;
3037 1 : mb->optimize = 0;
3038 1 : if( tbl) BBPunfix(tblId);
3039 1 : if( atr) BBPunfix(atrId);
3040 1 : if( tpe) BBPunfix(tpeId);
3041 1 : if( len) BBPunfix(lenId);
3042 1 : if( scale) BBPunfix(scaleId);
3043 : return msg;
3044 : }
3045 :
3046 : /* str mvc_affected_rows_wrap(int *m, int m, lng *nr, str *w); */
3047 : str
3048 137966 : mvc_affected_rows_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3049 : {
3050 137966 : backend *b = NULL;
3051 137966 : int *res = getArgReference_int(stk, pci, 0), ok;
3052 : #ifndef NDEBUG
3053 137966 : int mtype = getArgType(mb, pci, 2);
3054 : #endif
3055 137966 : lng nr;
3056 137966 : str msg;
3057 :
3058 137966 : (void) mb; /* NOT USED */
3059 137966 : if ((msg = checkSQLContext(cntxt)) != NULL)
3060 : return msg;
3061 138258 : *res = 0;
3062 138258 : assert(mtype == TYPE_lng);
3063 138258 : nr = *getArgReference_lng(stk, pci, 2);
3064 138258 : b = cntxt->sqlcontext;
3065 138258 : ok = mvc_export_affrows(b, b->out, nr, "", mb->tag, cntxt->qryctx.starttime, mb->optimize);
3066 138185 : cntxt->qryctx.starttime = 0;
3067 138185 : cntxt->qryctx.endtime = 0;
3068 138185 : mb->optimize = 0;
3069 138185 : if (ok < 0)
3070 0 : throw(SQL, "sql.affectedRows", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(b, b->out, ok));
3071 : return MAL_SUCCEED;
3072 : }
3073 :
3074 : /* str mvc_export_head_wrap(int *ret, stream **s, int *res_id); */
3075 : str
3076 0 : mvc_export_head_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3077 : {
3078 0 : backend *b = NULL;
3079 0 : stream **s = (stream **) getArgReference(stk, pci, 1);
3080 0 : int res_id = *getArgReference_int(stk, pci, 2), ok;
3081 0 : str msg;
3082 :
3083 0 : (void) mb; /* NOT USED */
3084 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
3085 : return msg;
3086 0 : b = cntxt->sqlcontext;
3087 0 : ok = mvc_export_head(b, *s, res_id, FALSE, TRUE, cntxt->qryctx.starttime, mb->optimize);
3088 0 : cntxt->qryctx.starttime = 0;
3089 0 : cntxt->qryctx.endtime = 0;
3090 0 : mb->optimize = 0;
3091 0 : if (ok < 0)
3092 0 : throw(SQL, "sql.exportHead", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(b, *s, ok));
3093 : return MAL_SUCCEED;
3094 : }
3095 :
3096 : /* str mvc_export_result_wrap(int *ret, stream **s, int *res_id); */
3097 : str
3098 0 : mvc_export_result_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3099 : {
3100 0 : backend *b = NULL;
3101 0 : stream **s = (stream **) getArgReference(stk, pci, 1), *sout;
3102 0 : int res_id = *getArgReference_int(stk, pci, 2), ok;
3103 0 : str msg;
3104 :
3105 0 : (void) mb; /* NOT USED */
3106 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
3107 : return msg;
3108 0 : b = cntxt->sqlcontext;
3109 0 : sout = pci->argc > 5 ? cntxt->fdout : *s;
3110 0 : ok = mvc_export_result(b, sout, res_id, false, cntxt->qryctx.starttime, mb->optimize);
3111 0 : cntxt->qryctx.starttime = 0;
3112 0 : cntxt->qryctx.endtime = 0;
3113 0 : mb->optimize = 0;
3114 0 : if (ok < 0)
3115 0 : throw(SQL, "sql.exportResult", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(b, sout, ok));
3116 : return MAL_SUCCEED;
3117 : }
3118 :
3119 : /* str mvc_export_chunk_wrap(int *ret, stream **s, int *res_id, str *w); */
3120 : str
3121 0 : mvc_export_chunk_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3122 : {
3123 0 : backend *b = NULL;
3124 0 : stream **s = (stream **) getArgReference(stk, pci, 1);
3125 0 : int res_id = *getArgReference_int(stk, pci, 2), ok;
3126 0 : BUN offset = 0;
3127 0 : BUN nr = 0;
3128 0 : str msg;
3129 :
3130 0 : (void) mb; /* NOT USED */
3131 0 : if (pci->argc == 5) {
3132 0 : offset = (BUN) *getArgReference_int(stk, pci, 3);
3133 0 : int cnt = *getArgReference_int(stk, pci, 4);
3134 0 : nr = cnt < 0 ? BUN_NONE : (BUN) cnt;
3135 : }
3136 :
3137 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
3138 : return msg;
3139 0 : b = cntxt->sqlcontext;
3140 0 : if ((ok = mvc_export_chunk(b, *s, res_id, offset, nr)) < 0)
3141 0 : throw(SQL, "sql.exportChunk", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(b, *s, ok));
3142 : return NULL;
3143 : }
3144 :
3145 : /* str mvc_export_operation_wrap(int *ret, str *w); */
3146 : str
3147 19534 : mvc_export_operation_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3148 : {
3149 19534 : backend *b = NULL;
3150 19534 : str msg;
3151 19534 : int ok = 0;
3152 :
3153 19534 : (void) stk; /* NOT USED */
3154 19534 : (void) pci; /* NOT USED */
3155 19534 : if ((msg = checkSQLContext(cntxt)) != NULL)
3156 : return msg;
3157 19534 : b = cntxt->sqlcontext;
3158 19534 : if (b->out)
3159 19533 : ok = mvc_export_operation(b, b->out, "", cntxt->qryctx.starttime, mb->optimize);
3160 19534 : cntxt->qryctx.starttime = 0;
3161 19534 : cntxt->qryctx.endtime = 0;
3162 19534 : mb->optimize = 0;
3163 19534 : if (ok < 0)
3164 0 : throw(SQL, "sql.exportOperation", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(b, b->out, ok));
3165 : return MAL_SUCCEED;
3166 : }
3167 :
3168 : str
3169 : /*mvc_scalar_value_wrap(int *ret, int *qtype, str tn, str name, str type, int *digits, int *scale, int *eclass, int *multiset, ptr p, int mtype)*/
3170 60350 : mvc_scalar_value_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3171 : {
3172 60350 : const char *tn = *getArgReference_str(stk, pci, 1);
3173 60350 : const char *cn = *getArgReference_str(stk, pci, 2);
3174 60350 : const char *type = *getArgReference_str(stk, pci, 3);
3175 60350 : int digits = *getArgReference_int(stk, pci, 4);
3176 60350 : int scale = *getArgReference_int(stk, pci, 5);
3177 60350 : int multiset = *getArgReference_int(stk, pci, 7);
3178 60350 : ptr p = getArgReference(stk, pci, 8);
3179 60350 : int mtype = getArgType(mb, pci, 8);
3180 60350 : str msg;
3181 60350 : backend *be = NULL;
3182 60350 : int res_id, ok;
3183 60350 : (void) mb; /* NOT USED */
3184 60350 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
3185 : return msg;
3186 60350 : if (ATOMextern(mtype))
3187 621 : p = *(ptr *) p;
3188 :
3189 : // scalar values are single-column result sets
3190 60350 : if ((res_id = mvc_result_table(be, mb->tag, 1, Q_TABLE)) < 0) {
3191 0 : cntxt->qryctx.starttime = 0;
3192 0 : cntxt->qryctx.endtime = 0;
3193 0 : mb->optimize = 0;
3194 0 : throw(SQL, "sql.exportValue", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3195 : }
3196 60350 : if ((ok = mvc_result_value(be, tn, cn, type, digits, scale, multiset, p, mtype)) < 0) {
3197 0 : cntxt->qryctx.starttime = 0;
3198 0 : cntxt->qryctx.endtime = 0;
3199 0 : mb->optimize = 0;
3200 0 : throw(SQL, "sql.exportValue", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(be, be->out, ok));
3201 : }
3202 60344 : if (be->output_format == OFMT_NONE) {
3203 2 : cntxt->qryctx.starttime = 0;
3204 2 : cntxt->qryctx.endtime = 0;
3205 2 : mb->optimize = 0;
3206 2 : return MAL_SUCCEED;
3207 : }
3208 60342 : ok = mvc_export_result(be, be->out, res_id, true, cntxt->qryctx.starttime, mb->optimize);
3209 60295 : cntxt->qryctx.starttime = 0;
3210 60295 : cntxt->qryctx.endtime = 0;
3211 60295 : mb->optimize = 0;
3212 60295 : if (ok < 0)
3213 0 : throw(SQL, "sql.exportValue", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(be, be->out, ok));
3214 : return MAL_SUCCEED;
3215 : }
3216 :
3217 : static void
3218 1099 : bat2return(MalStkPtr stk, InstrPtr pci, BAT **b)
3219 : {
3220 1099 : int i;
3221 :
3222 11362 : for (i = 0; i < pci->retc; i++) {
3223 10263 : *getArgReference_bat(stk, pci, i) = b[i]->batCacheid;
3224 10263 : BBPkeepref(b[i]);
3225 : }
3226 1099 : }
3227 :
3228 : static const char fwftsep[2] = {STREAM_FWF_FIELD_SEP, '\0'};
3229 : static const char fwfrsep[2] = {STREAM_FWF_RECORD_SEP, '\0'};
3230 :
3231 : /* str mvc_import_table_wrap(int *res, sql_table **t, unsigned char* *T, unsigned char* *R, unsigned char* *S, unsigned char* *N, str *fname, lng *sz, lng *offset, int *besteffort, str *fixed_width, int *onclient, int *escape); */
3232 : str
3233 1130 : mvc_import_table_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3234 : {
3235 1130 : backend *be;
3236 1130 : BAT **b = NULL;
3237 1130 : sql_table *t = *(sql_table **) getArgReference(stk, pci, pci->retc + 0);
3238 1130 : const char *tsep = *getArgReference_str(stk, pci, pci->retc + 1);
3239 1130 : const char *rsep = *getArgReference_str(stk, pci, pci->retc + 2);
3240 1130 : const char *ssep = *getArgReference_str(stk, pci, pci->retc + 3);
3241 1130 : const char *ns = *getArgReference_str(stk, pci, pci->retc + 4);
3242 1130 : const char *fname = *getArgReference_str(stk, pci, pci->retc + 5);
3243 1130 : lng sz = *getArgReference_lng(stk, pci, pci->retc + 6);
3244 1130 : lng offset = *getArgReference_lng(stk, pci, pci->retc + 7);
3245 1130 : int besteffort = *getArgReference_int(stk, pci, pci->retc + 8);
3246 1130 : const char *fixed_widths = *getArgReference_str(stk, pci, pci->retc + 9);
3247 1130 : int onclient = *getArgReference_int(stk, pci, pci->retc + 10);
3248 1130 : bool escape = *getArgReference_int(stk, pci, pci->retc + 11);
3249 1130 : const char *decsep = *getArgReference_str(stk, pci, pci->retc + 12);
3250 1130 : const char *decskip = *getArgReference_str(stk, pci, pci->retc + 13);
3251 1130 : str msg = MAL_SUCCEED;
3252 1130 : bstream *s = NULL;
3253 1130 : stream *ss;
3254 :
3255 1130 : (void) mb; /* NOT USED */
3256 1130 : if ((msg = checkSQLContext(cntxt)) != NULL)
3257 : return msg;
3258 1130 : if (onclient && !cntxt->filetrans)
3259 0 : throw(MAL, "sql.copy_from", SQLSTATE(42000) "Cannot transfer files from client");
3260 1130 : if (strNil(decsep))
3261 0 : throw(MAL, "sql.copy_from", SQLSTATE(42000) "decimal separator cannot be nil");
3262 1136 : if (strNil(decskip))
3263 : decskip = NULL;
3264 :
3265 1130 : be = cntxt->sqlcontext;
3266 : /* The CSV parser expects ssep to have the value 0 if the user does not
3267 : * specify a quotation character
3268 : */
3269 1742 : if (*ssep == 0 || strNil(ssep))
3270 : ssep = NULL;
3271 :
3272 1130 : if (strNil(fname))
3273 786 : fname = NULL;
3274 1130 : if (fname == NULL) {
3275 786 : msg = mvc_import_table(cntxt, &b, be->mvc, be->mvc->scanner.rs, t, tsep, rsep, ssep, ns, sz, offset, besteffort, true, escape, decsep, decskip);
3276 : } else {
3277 344 : if (onclient) {
3278 248 : ss = mapi_request_upload(fname, false, be->mvc->scanner.rs, be->mvc->scanner.ws);
3279 : } else {
3280 96 : ss = open_rastream(fname);
3281 : }
3282 344 : if (ss == NULL || mnstr_errnr(ss) != MNSTR_NO__ERROR) {
3283 3 : msg = createException(IO, "sql.copy_from", SQLSTATE(42000) "%s", mnstr_peek_error(NULL));
3284 3 : close_stream(ss);
3285 3 : return msg;
3286 : }
3287 :
3288 682 : if (!strNil(fixed_widths)) {
3289 2 : size_t ncol = 0, current_width_entry = 0, i;
3290 2 : size_t *widths;
3291 2 : const char* val_start = fixed_widths;
3292 2 : size_t width_len = strlen(fixed_widths);
3293 2 : stream *ns;
3294 :
3295 71 : for (i = 0; i < width_len; i++) {
3296 69 : if (fixed_widths[i] == STREAM_FWF_FIELD_SEP) {
3297 34 : ncol++;
3298 : }
3299 : }
3300 2 : widths = malloc(sizeof(size_t) * ncol);
3301 2 : if (!widths) {
3302 0 : close_stream(ss);
3303 0 : throw(MAL, "sql.copy_from", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3304 : }
3305 71 : for (i = 0; i < width_len; i++) {
3306 69 : if (fixed_widths[i] == STREAM_FWF_FIELD_SEP) {
3307 34 : widths[current_width_entry++] = (size_t) strtoll(val_start, NULL, 10);
3308 34 : val_start = fixed_widths + i + 1;
3309 : }
3310 : }
3311 : /* overwrite other delimiters to the ones the FWF stream uses */
3312 2 : tsep = fwftsep;
3313 2 : rsep = fwfrsep;
3314 :
3315 2 : ns = stream_fwf_create(ss, ncol, widths, STREAM_FWF_FILLER);
3316 2 : if (ns == NULL || mnstr_errnr(ns) != MNSTR_NO__ERROR) {
3317 0 : msg = createException(IO, "sql.copy_from", SQLSTATE(42000) "%s", mnstr_peek_error(NULL));
3318 0 : close_stream(ss);
3319 0 : free(widths);
3320 0 : return msg;
3321 : }
3322 : ss = ns;
3323 : }
3324 : #if SIZEOF_VOID_P == 4
3325 : s = bstream_create(ss, 0x20000);
3326 : #else
3327 341 : s = bstream_create(ss, 0x200000);
3328 : #endif
3329 341 : if (s == NULL) {
3330 0 : close_stream(ss);
3331 0 : throw(MAL, "sql.copy_from", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3332 : }
3333 341 : msg = mvc_import_table(cntxt, &b, be->mvc, s, t, tsep, rsep, ssep, ns, sz, offset, besteffort, false, escape, decsep, decskip);
3334 : // This also closes ss:
3335 341 : bstream_destroy(s);
3336 : }
3337 1127 : if (b && !msg)
3338 1099 : bat2return(stk, pci, b);
3339 1127 : GDKfree(b);
3340 1127 : return msg;
3341 : }
3342 :
3343 : str
3344 250 : not_unique(bit *ret, const bat *bid)
3345 : {
3346 250 : BAT *b;
3347 :
3348 250 : if ((b = BATdescriptor(*bid)) == NULL) {
3349 0 : throw(SQL, "not_unique", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
3350 : }
3351 :
3352 250 : *ret = FALSE;
3353 250 : BATiter bi = bat_iterator(b);
3354 250 : if (bi.key || BATtdensebi(&bi) || bi.count <= 1) {
3355 245 : bat_iterator_end(&bi);
3356 245 : BBPunfix(b->batCacheid);
3357 245 : return MAL_SUCCEED;
3358 5 : } else if (bi.sorted) {
3359 5 : BUN p;
3360 5 : oid c = ((oid *) bi.base)[0];
3361 :
3362 6 : for (p = 1; p < bi.count; p++) {
3363 6 : oid v = ((oid *) bi.base)[p];
3364 6 : if (v <= c) {
3365 5 : *ret = TRUE;
3366 5 : break;
3367 : }
3368 1 : c = v;
3369 : }
3370 : } else {
3371 0 : bat_iterator_end(&bi);
3372 0 : BBPunfix(b->batCacheid);
3373 0 : throw(SQL, "not_unique", SQLSTATE(42000) "Input column should be sorted");
3374 : }
3375 5 : bat_iterator_end(&bi);
3376 5 : BBPunfix(b->batCacheid);
3377 5 : return MAL_SUCCEED;
3378 : }
3379 :
3380 : /* row case */
3381 : str
3382 75 : SQLidentity(oid *ret, const void *i)
3383 : {
3384 75 : (void)i;
3385 75 : *ret = 0;
3386 75 : return MAL_SUCCEED;
3387 : }
3388 :
3389 : str
3390 35 : BATSQLidentity(bat *ret, const bat *bid)
3391 : {
3392 35 : return BKCmirror(ret, bid);
3393 : }
3394 :
3395 : str
3396 8 : PBATSQLidentity(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3397 : {
3398 8 : bat *res = getArgReference_bat(stk, pci, 0);
3399 8 : oid *ns = getArgReference_oid(stk, pci, 1);
3400 8 : bat bid = *getArgReference_bat(stk, pci, 2);
3401 8 : oid s = *getArgReference_oid(stk, pci, 3);
3402 8 : BAT *b, *bn = NULL;
3403 :
3404 8 : (void) cntxt;
3405 8 : (void) mb;
3406 8 : if (!(b = BBPquickdesc(bid)))
3407 0 : throw(MAL, "batcalc.identity", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
3408 8 : if (!(bn = BATdense(b->hseqbase, s, BATcount(b))))
3409 0 : throw(MAL, "batcalc.identity", GDK_EXCEPTION);
3410 8 : *ns = s + BATcount(b);
3411 8 : *res = bn->batCacheid;
3412 8 : BBPkeepref(bn);
3413 8 : return MAL_SUCCEED;
3414 : }
3415 :
3416 : /*
3417 : * The core modules of Monet provide just a limited set of
3418 : * mathematical operators. The extensions required to support
3419 : * SQL-99 are shown below. At some point they also should be
3420 : * moved to module code base.
3421 : */
3422 :
3423 : str
3424 10 : SQLcst_alpha_cst(dbl *res, const dbl *decl, const dbl *theta)
3425 : {
3426 10 : dbl s, c1, c2;
3427 10 : char *msg = MAL_SUCCEED;
3428 10 : if (is_dbl_nil(*decl) || is_dbl_nil(*theta)) {
3429 0 : *res = dbl_nil;
3430 10 : } else if (fabs(*decl) + *theta > 89.9) {
3431 0 : *res = 180.0;
3432 : } else {
3433 10 : s = sin(radians(*theta));
3434 10 : c1 = cos(radians(*decl - *theta));
3435 10 : c2 = cos(radians(*decl + *theta));
3436 10 : *res = degrees(fabs(atan(s / sqrt(fabs(c1 * c2)))));
3437 : }
3438 10 : return msg;
3439 : }
3440 :
3441 : /*
3442 : sql5_export str SQLcst_alpha_cst(dbl *res, dbl *decl, dbl *theta);
3443 : sql5_export str SQLbat_alpha_cst(bat *res, bat *decl, dbl *theta);
3444 : sql5_export str SQLcst_alpha_bat(bat *res, dbl *decl, bat *theta);
3445 : */
3446 : str
3447 0 : SQLbat_alpha_cst(bat *res, const bat *decl, const dbl *theta)
3448 : {
3449 0 : BAT *b, *bn;
3450 0 : BUN p, q;
3451 0 : dbl s, c1, c2, r;
3452 0 : char *msg = NULL;
3453 :
3454 0 : if (is_dbl_nil(*theta)) {
3455 0 : throw(SQL, "SQLbat_alpha", SQLSTATE(42000) "Parameter theta should not be nil");
3456 : }
3457 0 : if ((b = BATdescriptor(*decl)) == NULL) {
3458 0 : throw(SQL, "alpha", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
3459 : }
3460 0 : bn = COLnew(b->hseqbase, TYPE_dbl, BATcount(b), TRANSIENT);
3461 0 : if (bn == NULL) {
3462 0 : BBPunfix(b->batCacheid);
3463 0 : throw(SQL, "sql.alpha", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3464 : }
3465 0 : s = sin(radians(*theta));
3466 0 : BATiter bi = bat_iterator(b);
3467 0 : const dbl *vals = (const dbl *) bi.base;
3468 0 : BATloop(b, p, q) {
3469 0 : dbl d = vals[p];
3470 0 : if (is_dbl_nil(d))
3471 0 : r = dbl_nil;
3472 0 : else if (fabs(d) + *theta > 89.9)
3473 0 : r = 180.0;
3474 : else {
3475 0 : c1 = cos(radians(d - *theta));
3476 0 : c2 = cos(radians(d + *theta));
3477 0 : r = degrees(fabs(atan(s / sqrt(fabs(c1 * c2)))));
3478 : }
3479 0 : if (BUNappend(bn, &r, false) != GDK_SUCCEED) {
3480 0 : BBPreclaim(bn);
3481 0 : bat_iterator_end(&bi);
3482 0 : BBPunfix(b->batCacheid);
3483 0 : throw(SQL, "sql.alpha", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3484 : }
3485 : }
3486 0 : bat_iterator_end(&bi);
3487 0 : *res = bn->batCacheid;
3488 0 : BBPkeepref(bn);
3489 0 : BBPunfix(b->batCacheid);
3490 0 : return msg;
3491 : }
3492 :
3493 : str
3494 0 : SQLcst_alpha_bat(bat *res, const dbl *decl, const bat *thetabid)
3495 : {
3496 0 : BAT *b, *bn;
3497 0 : BUN p, q;
3498 0 : dbl s, c1, c2, r;
3499 0 : char *msg = NULL;
3500 0 : dbl *thetas;
3501 :
3502 0 : if ((b = BATdescriptor(*thetabid)) == NULL) {
3503 0 : throw(SQL, "alpha", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
3504 : }
3505 0 : bn = COLnew(b->hseqbase, TYPE_dbl, BATcount(b), TRANSIENT);
3506 0 : if (bn == NULL) {
3507 0 : BBPunfix(b->batCacheid);
3508 0 : throw(SQL, "sql.alpha", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3509 : }
3510 0 : BATiter bi = bat_iterator(b);
3511 0 : thetas = (dbl *) bi.base;
3512 0 : BATloop(b, p, q) {
3513 0 : dbl d = *decl;
3514 0 : dbl theta = thetas[p];
3515 :
3516 0 : if (is_dbl_nil(d))
3517 0 : r = dbl_nil;
3518 0 : else if (fabs(d) + theta > 89.9)
3519 0 : r = (dbl) 180.0;
3520 : else {
3521 0 : s = sin(radians(theta));
3522 0 : c1 = cos(radians(d - theta));
3523 0 : c2 = cos(radians(d + theta));
3524 0 : r = degrees(fabs(atan(s / sqrt(fabs(c1 * c2)))));
3525 : }
3526 0 : if (BUNappend(bn, &r, false) != GDK_SUCCEED) {
3527 0 : BBPreclaim(bn);
3528 0 : bat_iterator_end(&bi);
3529 0 : BBPunfix(b->batCacheid);
3530 0 : throw(SQL, "sql.alpha", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3531 : }
3532 : }
3533 0 : bat_iterator_end(&bi);
3534 0 : *res = bn->batCacheid;
3535 0 : BBPkeepref(bn);
3536 0 : BBPunfix(b->batCacheid);
3537 0 : return msg;
3538 : }
3539 :
3540 : /* str dump_cache(int *r); */
3541 : str
3542 0 : dump_cache(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3543 : {
3544 0 : mvc *m = NULL;
3545 0 : str msg;
3546 0 : int cnt;
3547 0 : cq *q = NULL;
3548 0 : BAT *query, *count;
3549 0 : bat *rquery = getArgReference_bat(stk, pci, 0);
3550 0 : bat *rcount = getArgReference_bat(stk, pci, 1);
3551 :
3552 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
3553 : return msg;
3554 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
3555 : return msg;
3556 0 : cnt = m->qc->id;
3557 0 : query = COLnew(0, TYPE_str, cnt, TRANSIENT);
3558 0 : if (query == NULL)
3559 0 : throw(SQL, "sql.dumpcache", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3560 0 : count = COLnew(0, TYPE_int, cnt, TRANSIENT);
3561 0 : if (count == NULL) {
3562 0 : BBPunfix(query->batCacheid);
3563 0 : throw(SQL, "sql.dumpcache", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3564 : }
3565 :
3566 0 : for (q = m->qc->q; q; q = q->next) {
3567 0 : if (BUNappend(query, q->f->query, false) != GDK_SUCCEED ||
3568 0 : BUNappend(count, &q->count, false) != GDK_SUCCEED) {
3569 0 : BBPunfix(query->batCacheid);
3570 0 : BBPunfix(count->batCacheid);
3571 0 : throw(SQL, "sql.dumpcache", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3572 : }
3573 : }
3574 0 : *rquery = query->batCacheid;
3575 0 : *rcount = count->batCacheid;
3576 0 : BBPkeepref(query);
3577 0 : BBPkeepref(count);
3578 0 : return MAL_SUCCEED;
3579 : }
3580 :
3581 : /* str dump_opt_stats(int *r); */
3582 : str
3583 0 : dump_opt_stats(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3584 : {
3585 0 : backend *be;
3586 0 : str msg;
3587 0 : int cnt;
3588 0 : BAT *rewrite, *count;
3589 0 : bat *rrewrite = getArgReference_bat(stk, pci, 0);
3590 0 : bat *rcount = getArgReference_bat(stk, pci, 1);
3591 :
3592 0 : (void)mb;
3593 0 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
3594 : return msg;
3595 0 : cnt = be->mvc->qc->id;
3596 0 : rewrite = COLnew(0, TYPE_str, cnt, TRANSIENT);
3597 0 : count = COLnew(0, TYPE_int, cnt, TRANSIENT);
3598 0 : if (rewrite == NULL || count == NULL) {
3599 0 : BBPreclaim(rewrite);
3600 0 : BBPreclaim(count);
3601 0 : throw(SQL, "sql.optstats", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3602 : }
3603 :
3604 0 : if (BUNappend(rewrite, "joinidx", false) != GDK_SUCCEED ||
3605 0 : BUNappend(count, &be->join_idx, false) != GDK_SUCCEED) {
3606 0 : BBPreclaim(rewrite);
3607 0 : BBPreclaim(count);
3608 0 : throw(SQL, "sql.optstats", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3609 : }
3610 : /* TODO add other rewrites */
3611 :
3612 0 : *rrewrite = rewrite->batCacheid;
3613 0 : *rcount = count->batCacheid;
3614 0 : BBPkeepref(rewrite);
3615 0 : BBPkeepref(count);
3616 0 : return MAL_SUCCEED;
3617 : }
3618 :
3619 : /* str dump_opt_stats(int *r); */
3620 : str
3621 61 : dump_trace(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3622 : {
3623 61 : int i;
3624 61 : BAT *t[3];
3625 :
3626 61 : (void) cntxt;
3627 61 : (void) mb;
3628 61 : if (TRACEtable(cntxt, t) != 3)
3629 0 : throw(SQL, "sql.dump_trace", SQLSTATE(3F000) "Profiler not started");
3630 244 : for (i = 0; i < 3; i++) {
3631 183 : *getArgReference_bat(stk, pci, i) = t[i]->batCacheid;
3632 183 : BBPkeepref(t[i]);
3633 : }
3634 : return MAL_SUCCEED;
3635 : }
3636 :
3637 : static str
3638 0 : sql_unclosed_result_sets(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3639 : {
3640 0 : (void)mb;
3641 0 : bat *ret_query_id = getArgReference_bat(stk, pci, 0);
3642 0 : bat *ret_res_id = getArgReference_bat(stk, pci, 1);
3643 0 : backend *be = cntxt->sqlcontext;
3644 :
3645 0 : BUN count = 0;
3646 0 : for (res_table *p = be->results; p != NULL; p = p->next)
3647 0 : count++;
3648 :
3649 0 : BAT *query_ids = COLnew(0, TYPE_oid, count, TRANSIENT);
3650 0 : BAT *res_ids = COLnew(0, TYPE_int, count, TRANSIENT);
3651 :
3652 0 : if (query_ids == NULL || res_ids == NULL) {
3653 0 : BBPreclaim(query_ids);
3654 0 : BBPreclaim(res_ids);
3655 0 : throw(SQL, "sql.sql_unclosed_result_sets", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3656 : }
3657 :
3658 0 : for (res_table *p = be->results; p != NULL; p = p->next) {
3659 0 : if (BUNappend(query_ids, &p->query_id, false) != GDK_SUCCEED)
3660 0 : goto bailout;
3661 0 : if (BUNappend(res_ids, &p->id, false) != GDK_SUCCEED)
3662 0 : goto bailout;
3663 : }
3664 :
3665 0 : *ret_query_id = query_ids->batCacheid;
3666 0 : BBPkeepref(query_ids);
3667 0 : *ret_res_id = res_ids->batCacheid;
3668 0 : BBPkeepref(res_ids);
3669 :
3670 0 : return MAL_SUCCEED;
3671 :
3672 0 : bailout:
3673 0 : BBPunfix(query_ids->batCacheid);
3674 0 : BBPunfix(res_ids->batCacheid);
3675 0 : throw(SQL, "sql.sql_unclosed_result_sets", SQLSTATE(42000)"failed to retrieve result tables");
3676 : }
3677 :
3678 : static str
3679 57 : sql_sessions_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3680 : {
3681 57 : BAT *id = NULL, *user = NULL, *login = NULL, *sessiontimeout = NULL,
3682 57 : *querytimeout = NULL, *idle = NULL;
3683 57 : BAT *opt = NULL, *wlimit = NULL, *mlimit = NULL;
3684 57 : BAT *language = NULL, *peer = NULL, *hostname = NULL, *application = NULL, *client = NULL, *clientpid = NULL, *remark = NULL;
3685 57 : bat *idId = getArgReference_bat(stk, pci, 0);
3686 57 : bat *userId = getArgReference_bat(stk, pci, 1);
3687 57 : bat *loginId = getArgReference_bat(stk, pci, 2);
3688 57 : bat *idleId = getArgReference_bat(stk, pci, 3);
3689 57 : bat *optId = getArgReference_bat(stk, pci, 4);
3690 57 : bat *sessiontimeoutId = getArgReference_bat(stk, pci, 5);
3691 57 : bat *querytimeoutId = getArgReference_bat(stk, pci, 6);
3692 57 : bat *wlimitId = getArgReference_bat(stk, pci, 7);
3693 57 : bat *mlimitId = getArgReference_bat(stk, pci, 8);
3694 57 : bat *languageId = getArgReference_bat(stk, pci, 9);
3695 57 : bat *peerId = getArgReference_bat(stk, pci, 10);
3696 57 : bat *hostnameId = getArgReference_bat(stk, pci, 11);
3697 57 : bat *applicationId = getArgReference_bat(stk, pci, 12);
3698 57 : bat *clientId = getArgReference_bat(stk, pci, 13);
3699 57 : bat *clientpidId = getArgReference_bat(stk, pci, 14);
3700 57 : bat *remarkId = getArgReference_bat(stk, pci, 15);
3701 57 : Client c;
3702 57 : backend *be;
3703 57 : sqlid user_id;
3704 57 : sqlid role_id;
3705 57 : bool admin;
3706 57 : timestamp ts;
3707 57 : lng pid;
3708 57 : const char *s;
3709 57 : int timeout;
3710 57 : str msg = NULL;
3711 :
3712 57 : (void) cntxt;
3713 57 : (void) mb;
3714 :
3715 57 : id = COLnew(0, TYPE_int, 0, TRANSIENT);
3716 57 : user = COLnew(0, TYPE_str, 0, TRANSIENT);
3717 57 : login = COLnew(0, TYPE_timestamp, 0, TRANSIENT);
3718 57 : opt = COLnew(0, TYPE_str, 0, TRANSIENT);
3719 57 : sessiontimeout = COLnew(0, TYPE_int, 0, TRANSIENT);
3720 57 : querytimeout = COLnew(0, TYPE_int, 0, TRANSIENT);
3721 57 : wlimit = COLnew(0, TYPE_int, 0, TRANSIENT);
3722 57 : mlimit = COLnew(0, TYPE_int, 0, TRANSIENT);
3723 57 : idle = COLnew(0, TYPE_timestamp, 0, TRANSIENT);
3724 57 : language = COLnew(0, TYPE_str, 0, TRANSIENT);
3725 57 : peer = COLnew(0, TYPE_str, 0, TRANSIENT);
3726 57 : hostname = COLnew(0, TYPE_str, 0, TRANSIENT);
3727 57 : application = COLnew(0, TYPE_str, 0, TRANSIENT);
3728 57 : client = COLnew(0, TYPE_str, 0, TRANSIENT);
3729 57 : clientpid = COLnew(0, TYPE_lng, 0, TRANSIENT);
3730 57 : remark = COLnew(0, TYPE_str, 0, TRANSIENT);
3731 :
3732 57 : if (id == NULL || user == NULL || login == NULL || sessiontimeout == NULL
3733 57 : || idle == NULL || querytimeout == NULL || opt == NULL || wlimit == NULL
3734 57 : || mlimit == NULL || language == NULL || peer == NULL || hostname == NULL
3735 57 : || application == NULL || client == NULL || clientpid == NULL
3736 57 : || remark == NULL) {
3737 0 : BBPreclaim(id);
3738 0 : BBPreclaim(user);
3739 0 : BBPreclaim(login);
3740 0 : BBPreclaim(sessiontimeout);
3741 0 : BBPreclaim(querytimeout);
3742 0 : BBPreclaim(idle);
3743 0 : BBPreclaim(opt);
3744 0 : BBPreclaim(wlimit);
3745 0 : BBPreclaim(mlimit);
3746 0 : BBPreclaim(language);
3747 0 : BBPreclaim(peer);
3748 0 : BBPreclaim(hostname);
3749 0 : BBPreclaim(application);
3750 0 : BBPreclaim(client);
3751 0 : BBPreclaim(clientpid);
3752 0 : BBPreclaim(remark);
3753 :
3754 0 : throw(SQL, "sql.sessions", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3755 : }
3756 :
3757 57 : be = cntxt->sqlcontext;
3758 57 : user_id = be->mvc->user_id;
3759 57 : role_id = be->mvc->role_id;
3760 57 : admin = user_id == USER_MONETDB || role_id == ROLE_SYSADMIN;
3761 :
3762 57 : MT_lock_set(&mal_contextLock);
3763 3705 : for (c = mal_clients; c < mal_clients + MAL_MAXCLIENTS; c++) {
3764 3648 : if (c->mode != RUNCLIENT)
3765 3571 : continue;
3766 :
3767 77 : backend *their_be = c->sqlcontext;
3768 77 : bool allowed_to_see = admin || c == cntxt || their_be->mvc->user_id == user_id;
3769 : // Note that their role_id is not checked. Just because we have
3770 : // both been granted a ROLE does not mean you are allowed to see
3771 : // my private details.
3772 77 : if (!allowed_to_see)
3773 8 : continue;
3774 :
3775 69 : const char *username = c->username;
3776 69 : if (!username)
3777 0 : username = str_nil;
3778 69 : if (BUNappend(user, username, false) != GDK_SUCCEED)
3779 0 : goto bailout;
3780 69 : ts = timestamp_fromtime(c->login);
3781 69 : if (is_timestamp_nil(ts)) {
3782 0 : msg = createException(SQL, "sql.sessions",
3783 : SQLSTATE(22003)
3784 : "Failed to convert user logged time");
3785 0 : goto bailout;
3786 : }
3787 69 : if (BUNappend(id, &c->idx, false) != GDK_SUCCEED)
3788 0 : goto bailout;
3789 69 : if (BUNappend(login, &ts, false) != GDK_SUCCEED)
3790 0 : goto bailout;
3791 69 : timeout = (int) (c->logical_sessiontimeout);
3792 69 : if (BUNappend(sessiontimeout, &timeout, false) != GDK_SUCCEED)
3793 0 : goto bailout;
3794 69 : timeout = (int) (c->querytimeout / 1000000);
3795 69 : if (BUNappend(querytimeout, &timeout, false) != GDK_SUCCEED)
3796 0 : goto bailout;
3797 69 : if (c->idle) {
3798 12 : ts = timestamp_fromtime(c->idle);
3799 12 : if (is_timestamp_nil(ts)) {
3800 0 : msg = createException(SQL, "sql.sessions",
3801 : SQLSTATE(22003)
3802 : "Failed to convert user logged time");
3803 0 : goto bailout;
3804 : }
3805 : } else
3806 57 : ts = timestamp_nil;
3807 69 : if (BUNappend(idle, &ts, false) != GDK_SUCCEED)
3808 0 : goto bailout;
3809 69 : if (BUNappend(opt, &c->optimizer, false) != GDK_SUCCEED)
3810 0 : goto bailout;
3811 69 : if (BUNappend(wlimit, &c->workerlimit, false) != GDK_SUCCEED)
3812 0 : goto bailout;
3813 69 : if (BUNappend(mlimit, &c->memorylimit, false) != GDK_SUCCEED)
3814 0 : goto bailout;
3815 : // If the scenario is NULL we assume we're in monetdbe/e which
3816 : // is always SQL.
3817 69 : s = c->scenario ? getScenarioLanguage(c) : "sql";
3818 69 : if (BUNappend(language, s, false) != GDK_SUCCEED)
3819 0 : goto bailout;
3820 69 : s = c->peer ? c->peer : str_nil;
3821 69 : if (BUNappend(peer, s, false) != GDK_SUCCEED)
3822 0 : goto bailout;
3823 69 : s = c->client_hostname ? c->client_hostname : str_nil;
3824 69 : if (BUNappend(hostname, s, false) != GDK_SUCCEED)
3825 0 : goto bailout;
3826 69 : s = c->client_application ? c->client_application : str_nil;
3827 69 : if (BUNappend(application, s, false) != GDK_SUCCEED)
3828 0 : goto bailout;
3829 69 : s = c->client_library ? c->client_library : str_nil;
3830 69 : if (BUNappend(client, s, false) != GDK_SUCCEED)
3831 0 : goto bailout;
3832 69 : pid = c->client_pid;
3833 71 : if (BUNappend(clientpid, pid ? &pid : &lng_nil, false) != GDK_SUCCEED)
3834 0 : goto bailout;
3835 69 : s = c->client_remark ? c->client_remark : str_nil;
3836 69 : if (BUNappend(remark, s, false) != GDK_SUCCEED)
3837 0 : goto bailout;
3838 : }
3839 57 : MT_lock_unset(&mal_contextLock);
3840 :
3841 57 : *idId = id->batCacheid;
3842 57 : BBPkeepref(id);
3843 57 : *userId = user->batCacheid;
3844 57 : BBPkeepref(user);
3845 57 : *loginId = login->batCacheid;
3846 57 : BBPkeepref(login);
3847 57 : *sessiontimeoutId = sessiontimeout->batCacheid;
3848 57 : BBPkeepref(sessiontimeout);
3849 57 : *querytimeoutId = querytimeout->batCacheid;
3850 57 : BBPkeepref(querytimeout);
3851 57 : *idleId = idle->batCacheid;
3852 57 : BBPkeepref(idle);
3853 :
3854 57 : *optId = opt->batCacheid;
3855 57 : BBPkeepref(opt);
3856 57 : *wlimitId = wlimit->batCacheid;
3857 57 : BBPkeepref(wlimit);
3858 57 : *mlimitId = mlimit->batCacheid;
3859 57 : BBPkeepref(mlimit);
3860 57 : *languageId = language->batCacheid;
3861 57 : BBPkeepref(language);
3862 57 : *peerId = peer->batCacheid;
3863 57 : BBPkeepref(peer);
3864 57 : *hostnameId = hostname->batCacheid;
3865 57 : BBPkeepref(hostname);
3866 57 : *applicationId = application->batCacheid;
3867 57 : BBPkeepref(application);
3868 57 : *clientId = client->batCacheid;
3869 57 : BBPkeepref(client);
3870 57 : *clientpidId = clientpid->batCacheid;
3871 57 : BBPkeepref(clientpid);
3872 57 : *remarkId = remark->batCacheid;
3873 57 : BBPkeepref(remark);
3874 :
3875 57 : return MAL_SUCCEED;
3876 :
3877 0 : bailout:
3878 0 : MT_lock_unset(&mal_contextLock);
3879 0 : BBPunfix(id->batCacheid);
3880 0 : BBPunfix(user->batCacheid);
3881 0 : BBPunfix(login->batCacheid);
3882 0 : BBPunfix(sessiontimeout->batCacheid);
3883 0 : BBPunfix(querytimeout->batCacheid);
3884 0 : BBPunfix(idle->batCacheid);
3885 :
3886 0 : BBPunfix(opt->batCacheid);
3887 0 : BBPunfix(wlimit->batCacheid);
3888 0 : BBPunfix(mlimit->batCacheid);
3889 0 : BBPunfix(language->batCacheid);
3890 0 : BBPunfix(peer->batCacheid);
3891 0 : BBPunfix(hostname->batCacheid);
3892 0 : BBPunfix(application->batCacheid);
3893 0 : BBPunfix(client->batCacheid);
3894 0 : BBPunfix(clientpid->batCacheid);
3895 0 : BBPunfix(remark->batCacheid);
3896 0 : return msg;
3897 : }
3898 :
3899 : str
3900 107 : sql_querylog_catalog(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3901 : {
3902 107 : int i;
3903 107 : BAT *t[8];
3904 107 : str msg;
3905 :
3906 107 : (void) cntxt;
3907 107 : (void) mb;
3908 107 : msg = QLOGcatalog(t);
3909 107 : if( msg != MAL_SUCCEED)
3910 : return msg;
3911 963 : for (i = 0; i < 8; i++)
3912 856 : if( t[i]){
3913 856 : *getArgReference_bat(stk, pci, i) = t[i]->batCacheid;
3914 856 : BBPkeepref(t[i]);
3915 : } else
3916 0 : throw(SQL,"sql.querylog", SQLSTATE(45000) "Missing query catalog BAT");
3917 : return MAL_SUCCEED;
3918 : }
3919 :
3920 : str
3921 79 : sql_querylog_calls(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3922 : {
3923 79 : int i;
3924 79 : BAT *t[10];
3925 79 : str msg;
3926 :
3927 79 : (void) cntxt;
3928 79 : (void) mb;
3929 79 : msg = QLOGcalls(t);
3930 79 : if( msg != MAL_SUCCEED)
3931 : return msg;
3932 790 : for (i = 0; i < 9; i++)
3933 711 : if( t[i]){
3934 711 : *getArgReference_bat(stk, pci, i) = t[i]->batCacheid;
3935 711 : BBPkeepref(t[i]);
3936 : } else
3937 0 : throw(SQL,"sql.querylog", SQLSTATE(45000) "Missing query call BAT");
3938 : return MAL_SUCCEED;
3939 : }
3940 :
3941 : str
3942 1 : sql_querylog_empty(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3943 : {
3944 1 : (void) cntxt;
3945 1 : (void) mb;
3946 1 : (void) stk;
3947 1 : (void) pci;
3948 1 : return QLOGempty(NULL);
3949 : }
3950 :
3951 : /* str sql_rowid(oid *rid, ptr v, str *sname, str *tname); */
3952 : str
3953 0 : sql_rowid(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3954 : {
3955 0 : BAT *b;
3956 0 : mvc *m = NULL;
3957 0 : str msg;
3958 0 : sql_schema *s = NULL;
3959 0 : sql_table *t = NULL;
3960 0 : sql_column *c = NULL;
3961 0 : oid *rid = getArgReference_oid(stk, pci, 0);
3962 0 : const char *sname = *getArgReference_str(stk, pci, 2);
3963 0 : const char *tname = *getArgReference_str(stk, pci, 3);
3964 :
3965 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
3966 : return msg;
3967 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
3968 : return msg;
3969 0 : s = mvc_bind_schema(m, sname);
3970 0 : if (s == NULL)
3971 0 : throw(SQL, "calc.rowid", SQLSTATE(3F000) "Schema missing %s", sname);
3972 0 : t = mvc_bind_table(m, s, tname);
3973 0 : if (t == NULL)
3974 0 : throw(SQL, "calc.rowid", SQLSTATE(42S02) "Table missing %s.%s",sname,tname);
3975 0 : if (!isTable(t))
3976 0 : throw(SQL, "calc.rowid", SQLSTATE(42000) "%s '%s' is not persistent",
3977 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
3978 0 : if (!ol_first_node(t->columns))
3979 0 : throw(SQL, "calc.rowid", SQLSTATE(42S22) "Column missing %s.%s",sname,tname);
3980 0 : c = ol_first_node(t->columns)->data;
3981 : /* HACK, get insert bat */
3982 0 : sqlstore *store = m->session->tr->store;
3983 0 : b = store->storage_api.bind_col(m->session->tr, c, QUICK);
3984 0 : if( b == NULL)
3985 0 : throw(SQL,"calc.rowid", SQLSTATE(HY005) "Cannot access column descriptor");
3986 : /* UGH (move into storage backends!!) */
3987 0 : *rid = BATcount(b);
3988 0 : return MAL_SUCCEED;
3989 : }
3990 :
3991 : static str
3992 0 : do_sql_rank_grp(bat *rid, const bat *bid, const bat *gid, int nrank, int dense, const char *name)
3993 : {
3994 0 : BAT *r, *b, *g;
3995 0 : BUN p, q;
3996 0 : BATiter bi, gi;
3997 0 : int (*ocmp) (const void *, const void *);
3998 0 : int (*gcmp) (const void *, const void *);
3999 0 : const void *oc, *gc, *on, *gn;
4000 0 : int rank = 1;
4001 0 : int c;
4002 :
4003 0 : if ((b = BATdescriptor(*bid)) == NULL)
4004 0 : throw(SQL, name, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
4005 0 : if ((g = BATdescriptor(*gid)) == NULL) {
4006 0 : BBPunfix(b->batCacheid);
4007 0 : throw(SQL, name, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
4008 : }
4009 0 : bi = bat_iterator(b);
4010 0 : gi = bat_iterator(g);
4011 0 : ocmp = ATOMcompare(b->ttype);
4012 0 : gcmp = ATOMcompare(g->ttype);
4013 0 : oc = BUNtail(bi, 0);
4014 0 : gc = BUNtail(gi, 0);
4015 0 : if (!ALIGNsynced(b, g)) {
4016 0 : bat_iterator_end(&bi);
4017 0 : bat_iterator_end(&gi);
4018 0 : BBPunfix(b->batCacheid);
4019 0 : BBPunfix(g->batCacheid);
4020 0 : throw(SQL, name, SQLSTATE(45000) "Internal error, columns not aligned");
4021 : }
4022 : /*
4023 : if (!b->tsorted) {
4024 : BBPunfix(b->batCacheid);
4025 : BBPunfix(g->batCacheid);
4026 : throw(SQL, name, SQLSTATE(45000) "Internal error, columns not sorted");
4027 : }
4028 : */
4029 0 : r = COLnew(b->hseqbase, TYPE_int, BATcount(b), TRANSIENT);
4030 0 : if (r == NULL) {
4031 0 : bat_iterator_end(&bi);
4032 0 : bat_iterator_end(&gi);
4033 0 : BBPunfix(b->batCacheid);
4034 0 : BBPunfix(g->batCacheid);
4035 0 : throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
4036 : }
4037 0 : BATloop(b, p, q) {
4038 0 : on = BUNtail(bi, p);
4039 0 : gn = BUNtail(gi, p);
4040 :
4041 0 : if ((c = ocmp(on, oc)) != 0)
4042 0 : rank = nrank;
4043 0 : if (gcmp(gn, gc) != 0)
4044 0 : c = rank = nrank = 1;
4045 0 : oc = on;
4046 0 : gc = gn;
4047 0 : if (BUNappend(r, &rank, false) != GDK_SUCCEED) {
4048 0 : bat_iterator_end(&bi);
4049 0 : bat_iterator_end(&gi);
4050 0 : BBPunfix(b->batCacheid);
4051 0 : BBPunfix(g->batCacheid);
4052 0 : BBPunfix(r->batCacheid);
4053 0 : throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
4054 : }
4055 0 : nrank += !dense || c;
4056 : }
4057 0 : bat_iterator_end(&bi);
4058 0 : bat_iterator_end(&gi);
4059 0 : BBPunfix(b->batCacheid);
4060 0 : BBPunfix(g->batCacheid);
4061 0 : *rid = r->batCacheid;
4062 0 : BBPkeepref(r);
4063 0 : return MAL_SUCCEED;
4064 : }
4065 :
4066 : static str
4067 0 : do_sql_rank(bat *rid, const bat *bid, int nrank, int dense, const char *name)
4068 : {
4069 0 : BAT *r, *b;
4070 0 : BATiter bi;
4071 0 : int (*cmp) (const void *, const void *);
4072 0 : const void *cur, *n;
4073 0 : BUN p, q;
4074 0 : int rank = 1;
4075 0 : int c;
4076 :
4077 0 : if ((b = BATdescriptor(*bid)) == NULL)
4078 0 : throw(SQL, name, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
4079 0 : bi = bat_iterator(b);
4080 0 : if (!bi.sorted && !bi.revsorted) {
4081 0 : bat_iterator_end(&bi);
4082 0 : BBPunfix(b->batCacheid);
4083 0 : throw(SQL, name, SQLSTATE(45000) "Internal error, columns not sorted");
4084 : }
4085 :
4086 0 : cmp = ATOMcompare(bi.type);
4087 0 : cur = BUNtail(bi, 0);
4088 0 : r = COLnew(b->hseqbase, TYPE_int, BATcount(b), TRANSIENT);
4089 0 : if (r == NULL) {
4090 0 : bat_iterator_end(&bi);
4091 0 : BBPunfix(b->batCacheid);
4092 0 : throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
4093 : }
4094 0 : if (BATtdensebi(&bi)) {
4095 0 : BATloop(b, p, q) {
4096 0 : if (BUNappend(r, &rank, false) != GDK_SUCCEED)
4097 0 : goto bailout;
4098 0 : rank++;
4099 : }
4100 : } else {
4101 0 : BATloop(b, p, q) {
4102 0 : n = BUNtail(bi, p);
4103 0 : if ((c = cmp(n, cur)) != 0)
4104 0 : rank = nrank;
4105 0 : cur = n;
4106 0 : if (BUNappend(r, &rank, false) != GDK_SUCCEED)
4107 0 : goto bailout;
4108 0 : nrank += !dense || c;
4109 : }
4110 : }
4111 0 : bat_iterator_end(&bi);
4112 0 : BBPunfix(b->batCacheid);
4113 0 : *rid = r->batCacheid;
4114 0 : BBPkeepref(r);
4115 0 : return MAL_SUCCEED;
4116 0 : bailout:
4117 0 : bat_iterator_end(&bi);
4118 0 : BBPunfix(b->batCacheid);
4119 0 : BBPunfix(r->batCacheid);
4120 0 : throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
4121 : }
4122 :
4123 : str
4124 0 : sql_rank_grp(bat *rid, const bat *bid, const bat *gid, const bat *gpe)
4125 : {
4126 0 : (void) gpe;
4127 0 : return do_sql_rank_grp(rid, bid, gid, 1, 0, "sql.rank_grp");
4128 : }
4129 :
4130 : str
4131 0 : sql_dense_rank_grp(bat *rid, const bat *bid, const bat *gid, const bat *gpe)
4132 : {
4133 0 : (void) gpe;
4134 0 : return do_sql_rank_grp(rid, bid, gid, 2, 1, "sql.dense_rank_grp");
4135 : }
4136 :
4137 : str
4138 0 : sql_rank(bat *rid, const bat *bid)
4139 : {
4140 0 : return do_sql_rank(rid, bid, 1, 0, "sql.rank");
4141 : }
4142 :
4143 : str
4144 0 : sql_dense_rank(bat *rid, const bat *bid)
4145 : {
4146 0 : return do_sql_rank(rid, bid, 2, 1, "sql.dense_rank");
4147 : }
4148 :
4149 : str
4150 5 : SQLargRecord(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4151 : {
4152 5 : str s, t, *ret;
4153 :
4154 5 : (void) cntxt;
4155 5 : ret = getArgReference_str(stk, pci, 0);
4156 5 : s = instruction2str(mb, stk, getInstrPtr(mb, 0), LIST_MAL_CALL);
4157 5 : if(s == NULL)
4158 0 : throw(SQL, "sql.argRecord", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4159 5 : t = strchr(s, ' ');
4160 5 : if( ! t)
4161 0 : t = strchr(s, '\t');
4162 5 : *ret = GDKstrdup(t ? t + 1 : s);
4163 5 : GDKfree(s);
4164 5 : if(*ret == NULL)
4165 0 : throw(SQL, "sql.argRecord", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4166 : return MAL_SUCCEED;
4167 : }
4168 :
4169 : /*
4170 : * The drop_hash operation cleans up any hash indices on any of the tables columns.
4171 : */
4172 : str
4173 0 : SQLdrop_hash(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4174 : {
4175 0 : const char *sch = *getArgReference_str(stk, pci, 1);
4176 0 : const char *tbl = *getArgReference_str(stk, pci, 2);
4177 0 : sql_schema *s;
4178 0 : sql_table *t;
4179 0 : mvc *m = NULL;
4180 0 : str msg;
4181 :
4182 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
4183 : return msg;
4184 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
4185 : return msg;
4186 0 : s = mvc_bind_schema(m, sch);
4187 0 : if (s == NULL)
4188 0 : throw(SQL, "sql.drop_hash", SQLSTATE(3F000) "Schema missing %s",sch);
4189 0 : if (!mvc_schema_privs(m, s))
4190 0 : throw(SQL, "sql.drop_hash", SQLSTATE(42000) "Access denied for %s to schema '%s'", get_string_global_var(m, "current_user"), s->base.name);
4191 0 : t = mvc_bind_table(m, s, tbl);
4192 0 : if (t == NULL)
4193 0 : throw(SQL, "sql.drop_hash", SQLSTATE(42S02) "Table missing %s.%s",sch, tbl);
4194 0 : if (!isTable(t))
4195 0 : throw(SQL, "sql.drop_hash", SQLSTATE(42000) "%s '%s' is not persistent",
4196 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
4197 :
4198 0 : sqlstore *store = m->session->tr->store;
4199 0 : for (node *n = ol_first_node(t->columns); n; n = n->next) {
4200 0 : sql_column *c = n->data;
4201 0 : BAT *b = NULL, *nb = NULL;
4202 :
4203 0 : if (!(b = store->storage_api.bind_col(m->session->tr, c, RDONLY)))
4204 0 : throw(SQL, "sql.drop_hash", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
4205 0 : if (VIEWtparent(b) && (nb = BBP_desc(VIEWtparent(b)))) {
4206 0 : BBPunfix(b->batCacheid);
4207 0 : if (!(b = BATdescriptor(nb->batCacheid)))
4208 0 : throw(SQL, "sql.drop_hash", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
4209 : }
4210 0 : HASHdestroy(b);
4211 0 : BBPunfix(b->batCacheid);
4212 : }
4213 : return MAL_SUCCEED;
4214 : }
4215 :
4216 : /* after an update on the optimizer catalog, we have to change
4217 : * the internal optimizer pipe line administration
4218 : * The minimal and default pipelines may not be changed.
4219 : */
4220 : str
4221 0 : SQLoptimizersUpdate(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4222 : {
4223 0 : mvc *m = NULL;
4224 0 : str msg;
4225 :
4226 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
4227 : return msg;
4228 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
4229 : return msg;
4230 : /* find the optimizer pipeline */
4231 0 : (void) stk;
4232 0 : (void) pci;
4233 0 : throw(SQL, "updateOptimizer", SQLSTATE(0A000) PROGRAM_NYI);
4234 : }
4235 :
4236 : static str
4237 92818 : sql_storage_appendrow(BAT *bs, const char *sname, const char *tname, const char *cname,
4238 : int access, const char *tpname,
4239 : BAT *sch, BAT *tab, BAT *col, BAT *type, BAT *loc,
4240 : BAT *cnt, BAT *atom, BAT *size, BAT *heap, BAT *indices,
4241 : BAT *phash, BAT *sort, BAT *imprints, BAT *mode,
4242 : BAT *revsort, BAT *key, BAT *oidx)
4243 : {
4244 92818 : BATiter bsi = bat_iterator(bs);
4245 92818 : lng sz;
4246 92818 : int w;
4247 92818 : bit bitval;
4248 :
4249 185636 : if (BUNappend(sch, sname, false) != GDK_SUCCEED ||
4250 185636 : BUNappend(tab, tname, false) != GDK_SUCCEED ||
4251 92818 : BUNappend(col, cname, false) != GDK_SUCCEED)
4252 0 : goto bailout1;
4253 92818 : if (access == TABLE_WRITABLE) {
4254 79457 : if (BUNappend(mode, "writable", false) != GDK_SUCCEED)
4255 0 : goto bailout1;
4256 13361 : } else if (access == TABLE_APPENDONLY) {
4257 0 : if (BUNappend(mode, "appendonly", false) != GDK_SUCCEED)
4258 0 : goto bailout1;
4259 13361 : } else if (access == TABLE_READONLY) {
4260 13361 : if (BUNappend(mode, "readonly", false) != GDK_SUCCEED)
4261 0 : goto bailout1;
4262 : } else {
4263 0 : if (BUNappend(mode, str_nil, false) != GDK_SUCCEED)
4264 0 : goto bailout1;
4265 : }
4266 92818 : if (BUNappend(type, tpname, false) != GDK_SUCCEED)
4267 0 : goto bailout1;
4268 :
4269 92818 : sz = bsi.count;
4270 92818 : if (BUNappend(cnt, &sz, false) != GDK_SUCCEED)
4271 0 : goto bailout1;
4272 :
4273 92818 : if (BUNappend(loc, BBP_physical(bs->batCacheid), false) != GDK_SUCCEED)
4274 0 : goto bailout1;
4275 92818 : w = bsi.width;
4276 92818 : if (BUNappend(atom, &w, false) != GDK_SUCCEED)
4277 0 : goto bailout1;
4278 :
4279 92818 : sz = (lng) bsi.hfree;
4280 92818 : if (BUNappend(size, &sz, false) != GDK_SUCCEED)
4281 0 : goto bailout1;
4282 :
4283 92818 : sz = bsi.vhfree;
4284 92818 : if (BUNappend(heap, &sz, false) != GDK_SUCCEED)
4285 0 : goto bailout1;
4286 :
4287 92818 : sz = (lng) HASHsize(bs);
4288 92818 : if (BUNappend(indices, &sz, false) != GDK_SUCCEED)
4289 0 : goto bailout1;
4290 :
4291 92818 : bitval = sz > 0;
4292 92818 : if (BUNappend(phash, &bitval, false) != GDK_SUCCEED)
4293 0 : goto bailout1;
4294 :
4295 92818 : sz = 0;
4296 92818 : if (BUNappend(imprints, &sz, false) != GDK_SUCCEED)
4297 0 : goto bailout1;
4298 92818 : bitval = bsi.sorted;
4299 92818 : if (!bitval && bsi.nosorted == 0)
4300 3239 : bitval = bit_nil;
4301 92818 : if (BUNappend(sort, &bitval, false) != GDK_SUCCEED)
4302 0 : goto bailout1;
4303 :
4304 92818 : bitval = bsi.revsorted;
4305 92818 : if (!bitval && bsi.norevsorted == 0)
4306 3134 : bitval = bit_nil;
4307 92818 : if (BUNappend(revsort, &bitval, false) != GDK_SUCCEED)
4308 0 : goto bailout1;
4309 :
4310 92818 : bitval = bsi.key;
4311 92818 : if (!bitval && bsi.nokey[0] == 0 && bsi.nokey[1] == 0)
4312 25289 : bitval = bit_nil;
4313 92818 : if (BUNappend(key, &bitval, false) != GDK_SUCCEED)
4314 0 : goto bailout1;
4315 :
4316 92818 : MT_lock_set(&bs->batIdxLock);
4317 92818 : sz = bs->torderidx && bs->torderidx != (Heap *) 1 ? bs->torderidx->free : 0;
4318 92818 : MT_lock_unset(&bs->batIdxLock);
4319 92818 : if (BUNappend(oidx, &sz, false) != GDK_SUCCEED)
4320 0 : goto bailout1;
4321 92818 : bat_iterator_end(&bsi);
4322 92818 : return MAL_SUCCEED;
4323 0 : bailout1:
4324 0 : bat_iterator_end(&bsi);
4325 0 : throw(SQL, "sql.storage", GDK_EXCEPTION);
4326 : }
4327 :
4328 : /*
4329 : * Inspection of the actual storage footprint is a recurring question of users.
4330 : * This is modelled as a generic SQL table producing function.
4331 : * create function storage()
4332 : * returns table ("schema" string, "table" string, "column" string, "type" string, "mode" string, location string, "count" bigint, width int, columnsize bigint, heapsize bigint indices bigint, sorted int)
4333 : * external name sql.storage;
4334 : */
4335 : str
4336 414 : sql_storage(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4337 : {
4338 414 : BAT *sch, *tab, *col, *type, *loc, *cnt, *atom, *size, *heap, *indices, *phash, *sort, *imprints, *mode, *revsort, *key, *oidx, *bs = NULL;
4339 414 : mvc *m = NULL;
4340 414 : str msg = MAL_SUCCEED;
4341 414 : sql_trans *tr;
4342 414 : node *ncol;
4343 414 : bat *rsch = getArgReference_bat(stk, pci, 0);
4344 414 : bat *rtab = getArgReference_bat(stk, pci, 1);
4345 414 : bat *rcol = getArgReference_bat(stk, pci, 2);
4346 414 : bat *rtype = getArgReference_bat(stk, pci, 3);
4347 414 : bat *rmode = getArgReference_bat(stk, pci, 4);
4348 414 : bat *rloc = getArgReference_bat(stk, pci, 5);
4349 414 : bat *rcnt = getArgReference_bat(stk, pci, 6);
4350 414 : bat *ratom = getArgReference_bat(stk, pci, 7);
4351 414 : bat *rsize = getArgReference_bat(stk, pci, 8);
4352 414 : bat *rheap = getArgReference_bat(stk, pci, 9);
4353 414 : bat *rindices = getArgReference_bat(stk, pci, 10);
4354 414 : bat *rphash = getArgReference_bat(stk, pci, 11);
4355 414 : bat *rimprints = getArgReference_bat(stk, pci, 12);
4356 414 : bat *rsort = getArgReference_bat(stk, pci, 13);
4357 414 : bat *rrevsort = getArgReference_bat(stk, pci, 14);
4358 414 : bat *rkey = getArgReference_bat(stk, pci, 15);
4359 414 : bat *roidx = getArgReference_bat(stk, pci, 16);
4360 414 : str sname = 0;
4361 414 : str tname = 0;
4362 414 : str cname = 0;
4363 414 : struct os_iter si = {0};
4364 :
4365 414 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
4366 : return msg;
4367 414 : if ((msg = checkSQLContext(cntxt)) != NULL)
4368 : return msg;
4369 :
4370 414 : if( pci->argc - pci->retc >= 1) {
4371 53 : sname = *getArgReference_str(stk, pci, pci->retc);
4372 53 : if (strNil(sname))
4373 0 : throw(SQL, "sql.storage", SQLSTATE(42000) "Schema name cannot be NULL");
4374 : }
4375 414 : if( pci->argc - pci->retc >= 2) {
4376 53 : tname = *getArgReference_str(stk, pci, pci->retc + 1);
4377 53 : if (strNil(tname))
4378 0 : throw(SQL, "sql.storage", SQLSTATE(42000) "Table name cannot be NULL");
4379 : }
4380 414 : if( pci->argc - pci->retc >= 3) {
4381 31 : cname = *getArgReference_str(stk, pci, pci->retc + 2);
4382 31 : if (strNil(cname))
4383 0 : throw(SQL, "sql.storage", SQLSTATE(42000) "Column name cannot be NULL");
4384 : }
4385 :
4386 414 : tr = m->session->tr;
4387 414 : sqlstore *store = tr->store;
4388 414 : sch = COLnew(0, TYPE_str, 0, TRANSIENT);
4389 414 : tab = COLnew(0, TYPE_str, 0, TRANSIENT);
4390 414 : col = COLnew(0, TYPE_str, 0, TRANSIENT);
4391 414 : type = COLnew(0, TYPE_str, 0, TRANSIENT);
4392 414 : mode = COLnew(0, TYPE_str, 0, TRANSIENT);
4393 414 : loc = COLnew(0, TYPE_str, 0, TRANSIENT);
4394 414 : cnt = COLnew(0, TYPE_lng, 0, TRANSIENT);
4395 414 : atom = COLnew(0, TYPE_int, 0, TRANSIENT);
4396 414 : size = COLnew(0, TYPE_lng, 0, TRANSIENT);
4397 414 : heap = COLnew(0, TYPE_lng, 0, TRANSIENT);
4398 414 : indices = COLnew(0, TYPE_lng, 0, TRANSIENT);
4399 414 : phash = COLnew(0, TYPE_bit, 0, TRANSIENT);
4400 414 : imprints = COLnew(0, TYPE_lng, 0, TRANSIENT);
4401 414 : sort = COLnew(0, TYPE_bit, 0, TRANSIENT);
4402 414 : revsort = COLnew(0, TYPE_bit, 0, TRANSIENT);
4403 414 : key = COLnew(0, TYPE_bit, 0, TRANSIENT);
4404 414 : oidx = COLnew(0, TYPE_lng, 0, TRANSIENT);
4405 :
4406 414 : if (sch == NULL || tab == NULL || col == NULL || type == NULL || mode == NULL || loc == NULL || imprints == NULL ||
4407 414 : sort == NULL || cnt == NULL || atom == NULL || size == NULL || heap == NULL || indices == NULL || phash == NULL ||
4408 414 : revsort == NULL || key == NULL || oidx == NULL) {
4409 0 : msg = createException(SQL, "sql.storage", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4410 0 : goto bailout;
4411 : }
4412 :
4413 : /* check for limited storage tables */
4414 414 : os_iterator(&si, tr->cat->schemas, tr, NULL);
4415 3384 : for (sql_base *b = oi_next(&si); b; b = oi_next(&si)) {
4416 2970 : sql_schema *s = (sql_schema *) b;
4417 2970 : if ((sname && strcmp(b->name, sname) ) || b->name[0] == '%')
4418 732 : continue;
4419 2238 : if (s->tables) {
4420 2238 : struct os_iter oi;
4421 :
4422 2238 : os_iterator(&oi, s->tables, tr, NULL);
4423 60399 : for (sql_base *bt = oi_next(&oi); bt; bt = oi_next(&oi)) {
4424 58161 : sql_table *t = (sql_table *) bt;
4425 58161 : if( tname && strcmp(bt->name, tname) )
4426 6313 : continue;
4427 51848 : if (isTable(t)) {
4428 16470 : if (ol_first_node(t->columns)) {
4429 102442 : for (ncol = ol_first_node((t)->columns); ncol; ncol = ncol->next) {
4430 85972 : sql_base *bc = ncol->data;
4431 85972 : sql_column *c = (sql_column *) ncol->data;
4432 85972 : if (!c->type.multiset && c->type.type->composite)
4433 0 : continue; // virtual column, e.g. no column info
4434 85972 : if( cname && strcmp(bc->name, cname) )
4435 48 : continue;
4436 85924 : bs = store->storage_api.bind_col(tr, c, QUICK);
4437 85924 : if (bs == NULL) {
4438 0 : msg = createException(SQL, "sql.storage", SQLSTATE(HY005) "Cannot access column descriptor");
4439 0 : goto bailout;
4440 : }
4441 :
4442 171848 : msg = sql_storage_appendrow(
4443 85924 : bs, b->name, bt->name, bc->name,
4444 85924 : c->t->access, c->type.type->base.name,
4445 : sch, tab, col, type, loc, cnt, atom, size,
4446 : heap, indices, phash, sort, imprints, mode,
4447 : revsort, key, oidx);
4448 85924 : if (msg != MAL_SUCCEED)
4449 0 : goto bailout;
4450 : }
4451 : }
4452 :
4453 16470 : if (t->idxs) {
4454 23382 : for (ncol = ol_first_node((t)->idxs); ncol; ncol = ncol->next) {
4455 6912 : sql_base *bc = ncol->data;
4456 6912 : sql_idx *c = (sql_idx *) ncol->data;
4457 6912 : if (idx_has_column(c->type)) {
4458 6906 : bs = store->storage_api.bind_idx(tr, c, QUICK);
4459 :
4460 6906 : if (bs == NULL) {
4461 0 : msg = createException(SQL, "sql.storage", SQLSTATE(HY005) "Cannot access column descriptor");
4462 0 : goto bailout;
4463 : }
4464 6906 : if( cname && strcmp(bc->name, cname) )
4465 12 : continue;
4466 13788 : msg = sql_storage_appendrow(
4467 6894 : bs, b->name, bt->name, bc->name,
4468 6894 : c->t->access, "oid",
4469 : sch, tab, col, type, loc, cnt, atom, size,
4470 : heap, indices, phash, sort, imprints, mode,
4471 : revsort, key, oidx);
4472 6894 : if (msg != MAL_SUCCEED)
4473 0 : goto bailout;
4474 : }
4475 : }
4476 : }
4477 : }
4478 : }
4479 : }
4480 : }
4481 :
4482 414 : *rsch = sch->batCacheid;
4483 414 : BBPkeepref(sch);
4484 414 : *rtab = tab->batCacheid;
4485 414 : BBPkeepref(tab);
4486 414 : *rcol = col->batCacheid;
4487 414 : BBPkeepref(col);
4488 414 : *rmode = mode->batCacheid;
4489 414 : BBPkeepref(mode);
4490 414 : *rloc = loc->batCacheid;
4491 414 : BBPkeepref(loc);
4492 414 : *rtype = type->batCacheid;
4493 414 : BBPkeepref(type);
4494 414 : *rcnt = cnt->batCacheid;
4495 414 : BBPkeepref(cnt);
4496 414 : *ratom = atom->batCacheid;
4497 414 : BBPkeepref(atom);
4498 414 : *rsize = size->batCacheid;
4499 414 : BBPkeepref(size);
4500 414 : *rheap = heap->batCacheid;
4501 414 : BBPkeepref(heap);
4502 414 : *rindices = indices->batCacheid;
4503 414 : BBPkeepref(indices);
4504 414 : *rphash = phash->batCacheid;
4505 414 : BBPkeepref(phash);
4506 414 : *rimprints = imprints->batCacheid;
4507 414 : BBPkeepref(imprints);
4508 414 : *rsort = sort->batCacheid;
4509 414 : BBPkeepref(sort);
4510 414 : *rrevsort = revsort->batCacheid;
4511 414 : BBPkeepref(revsort);
4512 414 : *rkey = key->batCacheid;
4513 414 : BBPkeepref(key);
4514 414 : *roidx = oidx->batCacheid;
4515 414 : BBPkeepref(oidx);
4516 414 : return MAL_SUCCEED;
4517 :
4518 0 : bailout:
4519 0 : BBPreclaim(sch);
4520 0 : BBPreclaim(tab);
4521 0 : BBPreclaim(col);
4522 0 : BBPreclaim(mode);
4523 0 : BBPreclaim(loc);
4524 0 : BBPreclaim(cnt);
4525 0 : BBPreclaim(type);
4526 0 : BBPreclaim(atom);
4527 0 : BBPreclaim(size);
4528 0 : BBPreclaim(heap);
4529 0 : BBPreclaim(indices);
4530 0 : BBPreclaim(phash);
4531 0 : BBPreclaim(imprints);
4532 0 : BBPreclaim(sort);
4533 0 : BBPreclaim(revsort);
4534 0 : BBPreclaim(key);
4535 0 : BBPreclaim(oidx);
4536 : if (!msg)
4537 : msg = createException(SQL, "sql.storage", GDK_EXCEPTION);
4538 : return msg;
4539 : }
4540 :
4541 : void
4542 338294 : freeVariables(Client c, MalBlkPtr mb, MalStkPtr glb, int oldvtop)
4543 : {
4544 411055 : for (int i = oldvtop; i < mb->vtop;) {
4545 72724 : if (glb) {
4546 0 : if (isVarCleanup(mb, i))
4547 0 : garbageElement(c, &glb->stk[i]);
4548 : /* clean stack entry */
4549 0 : glb->stk[i].vtype = TYPE_int;
4550 0 : glb->stk[i].val.ival = 0;
4551 0 : glb->stk[i].len = 0;
4552 : }
4553 72724 : clearVariable(mb, i);
4554 72761 : i++;
4555 : }
4556 338331 : assert(oldvtop <= mb->vsize);
4557 338331 : mb->vtop = oldvtop;
4558 338331 : }
4559 :
4560 : str
4561 0 : SQLresume_log_flushing(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4562 : {
4563 0 : mvc *mvc;
4564 :
4565 0 : (void)stk; (void)pci;
4566 0 : char *msg = getSQLContext(cntxt, mb, &mvc, NULL);
4567 0 : if (msg)
4568 : return msg;
4569 0 : store_resume_log(mvc->store);
4570 0 : return MAL_SUCCEED;
4571 : }
4572 :
4573 : str
4574 0 : SQLsuspend_log_flushing(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4575 : {
4576 0 : mvc *mvc;
4577 :
4578 0 : (void)stk; (void)pci;
4579 0 : char *msg = getSQLContext(cntxt, mb, &mvc, NULL);
4580 0 : if (msg)
4581 : return msg;
4582 0 : store_suspend_log(mvc->store);
4583 0 : return MAL_SUCCEED;
4584 : }
4585 :
4586 : str
4587 : /*SQLhot_snapshot(void *ret, const str *tarfile_arg [, bool onserver ])*/
4588 5 : SQLhot_snapshot(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4589 : {
4590 5 : char *filename;
4591 5 : bool onserver;
4592 5 : char *msg = MAL_SUCCEED;
4593 5 : char buf[80];
4594 5 : mvc *mvc;
4595 5 : ssize_t sz;
4596 5 : stream *s;
4597 5 : stream *cb = NULL;
4598 5 : lng result;
4599 :
4600 5 : filename = *getArgReference_str(stk, pci, 1);
4601 5 : onserver = pci->argc == 3 ? *getArgReference_bit(stk, pci, 2) : true;
4602 :
4603 5 : msg = getSQLContext(cntxt, mb, &mvc, NULL);
4604 5 : if (msg)
4605 : return msg;
4606 :
4607 5 : sqlstore *store = mvc->session->tr->store;
4608 5 : if (onserver) {
4609 5 : lng result = store_hot_snapshot(store, filename);
4610 5 : if (result)
4611 : return MAL_SUCCEED;
4612 : else
4613 0 : throw(SQL, "sql.hot_snapshot", GDK_EXCEPTION);
4614 : }
4615 :
4616 : // sync with client, copy pasted from mvc_export_table_wrap
4617 0 : while (!mvc->scanner.rs->eof)
4618 0 : if (bstream_next(mvc->scanner.rs) < 0)
4619 0 : throw(SQL, "sql.hot_snapshot", "interrupted");
4620 :
4621 : // The snapshot code flushes from time to time.
4622 : // Use a callback stream to suppress those.
4623 0 : s = mvc->scanner.ws;
4624 0 : cb = callback_stream(
4625 : /* private */ s,
4626 : /* read */ NULL,
4627 : /* write */ (void*)mnstr_write,
4628 : /* close */ NULL,
4629 : /* destroy */ NULL,
4630 : "snapshot-callback"
4631 : );
4632 0 : if (!cb)
4633 0 : throw(SQL, "sql.hot_snapshot", GDK_EXCEPTION);
4634 :
4635 : // tell client to open file, copy pasted from mvc_export_table_wrap
4636 0 : mnstr_write(s, PROMPT3, sizeof(PROMPT3) - 1, 1);
4637 0 : mnstr_printf(s, "wb %s\n", filename);
4638 0 : mnstr_flush(s, MNSTR_FLUSH_DATA);
4639 0 : if ((sz = mnstr_readline(mvc->scanner.rs->s, buf, sizeof(buf))) > 1) {
4640 : /* non-empty line indicates failure on client */
4641 0 : msg = createException(IO, "streams.open", "%s", buf);
4642 : /* discard until client flushes */
4643 0 : while (mnstr_read(mvc->scanner.rs->s, buf, 1, sizeof(buf)) > 0) {
4644 : /* ignore remainder of error message */
4645 0 : }
4646 0 : goto end;
4647 : }
4648 :
4649 : // client is waiting for data now, send it.
4650 0 : result = store_hot_snapshot_to_stream(store, cb);
4651 0 : if (result)
4652 : msg = MAL_SUCCEED;
4653 : else
4654 0 : msg = createException(SQL, "sql.hot_snapshot", GDK_EXCEPTION);
4655 0 : mnstr_destroy(cb);
4656 :
4657 : // tell client no more data, also copy pasted from mvc_export_table_wrap
4658 0 : mnstr_flush(s, MNSTR_FLUSH_DATA);
4659 0 : if ((sz = mnstr_readline(mvc->scanner.rs->s, buf, sizeof(buf))) > 1) {
4660 0 : msg = createException(IO, "streams.open", "%s", buf);
4661 : }
4662 0 : while (sz > 0)
4663 0 : sz = mnstr_readline(mvc->scanner.rs->s, buf, sizeof(buf));
4664 :
4665 0 : end:
4666 : return msg;
4667 : }
4668 :
4669 : MT_Lock lock_persist_unlogged = MT_LOCK_INITIALIZER(lock_persist_unlogged);
4670 :
4671 : str
4672 2 : SQLpersist_unlogged(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4673 : {
4674 2 : (void)stk;
4675 2 : (void)pci;
4676 :
4677 2 : assert(pci->argc == 5);
4678 :
4679 2 : bat *o0 = getArgReference_bat(stk, pci, 0),
4680 2 : *o1 = getArgReference_bat(stk, pci, 1),
4681 2 : *o2 = getArgReference_bat(stk, pci, 2);
4682 2 : str sname = *getArgReference_str(stk, pci, 3),
4683 2 : tname = *getArgReference_str(stk, pci, 4),
4684 2 : msg = MAL_SUCCEED;
4685 :
4686 2 : mvc *m = NULL;
4687 2 : msg = getSQLContext(cntxt, mb, &m, NULL);
4688 :
4689 2 : if (msg)
4690 : return msg;
4691 :
4692 2 : sqlstore *store = store = m->session->tr->store;
4693 :
4694 2 : sql_schema *s = mvc_bind_schema(m, sname);
4695 2 : if (s == NULL)
4696 0 : throw(SQL, "sql.persist_unlogged", SQLSTATE(3F000) "Schema missing %s.", sname);
4697 :
4698 2 : if (!mvc_schema_privs(m, s))
4699 0 : throw(SQL, "sql.persist_unlogged", SQLSTATE(42000) "Access denied for %s to schema '%s'.",
4700 : get_string_global_var(m, "current_user"), s->base.name);
4701 :
4702 2 : sql_table *t = mvc_bind_table(m, s, tname);
4703 2 : if (t == NULL)
4704 0 : throw(SQL, "sql.persist_unlogged", SQLSTATE(42S02) "Table missing %s.%s", sname, tname);
4705 :
4706 2 : if (!isUnloggedTable(t) || t->access != TABLE_APPENDONLY)
4707 0 : throw(SQL, "sql.persist_unlogged", "Unlogged and Insert Only mode combination required for table %s.%s", sname, tname);
4708 :
4709 2 : lng count = 0;
4710 :
4711 2 : sql_trans *tr = m->session->tr;
4712 2 : storage *t_del = bind_del_data(tr, t, NULL);
4713 :
4714 2 : BAT *d = NULL;
4715 :
4716 2 : if (t_del)
4717 2 : d = BATdescriptor(t_del->cs.bid);
4718 2 : if (t_del == NULL || d == NULL)
4719 0 : throw(SQL, "sql.persist_unlogged", "Cannot access %s column storage.", tname);
4720 :
4721 2 : MT_lock_set(&lock_persist_unlogged);
4722 2 : BATiter d_bi = bat_iterator(d);
4723 :
4724 2 : if (BBP_status(d->batCacheid) & BBPEXISTING) {
4725 :
4726 1 : assert(d->batInserted <= d_bi.count);
4727 :
4728 1 : if (d->batInserted < d_bi.count) {
4729 1 : int n = ol_length(t->columns);
4730 :
4731 1 : bat *commit_list = GDKzalloc(sizeof(bat) * (n + 2));
4732 1 : BUN *sizes = GDKzalloc(sizeof(BUN) * (n + 2));
4733 :
4734 1 : if (commit_list == NULL || sizes == NULL) {
4735 0 : bat_iterator_end(&d_bi);
4736 0 : MT_lock_unset(&lock_persist_unlogged);
4737 0 : GDKfree(commit_list);
4738 0 : GDKfree(sizes);
4739 0 : BBPreclaim(d);
4740 0 : throw(SQL, "sql.persist_unlogged", SQLSTATE(HY001));
4741 : }
4742 :
4743 1 : commit_list[0] = 0;
4744 1 : sizes[0] = 0;
4745 1 : int i = 1;
4746 :
4747 2 : for (node *ncol = ol_first_node(t->columns); ncol; ncol = ncol->next, i++) {
4748 :
4749 1 : sql_column *c = (sql_column *) ncol->data;
4750 1 : BAT *b = store->storage_api.bind_col(tr, c, QUICK);
4751 :
4752 1 : if (b == NULL) {
4753 0 : bat_iterator_end(&d_bi);
4754 0 : MT_lock_unset(&lock_persist_unlogged);
4755 0 : GDKfree(commit_list);
4756 0 : GDKfree(sizes);
4757 0 : BBPreclaim(d);
4758 0 : throw(SQL, "sql.persist_unlogged", "Cannot access column descriptor.");
4759 : }
4760 :
4761 1 : commit_list[i] = b->batCacheid;
4762 1 : sizes[i] = d_bi.count;
4763 : }
4764 :
4765 1 : assert(i<n+2);
4766 1 : commit_list[i] = d->batCacheid;
4767 1 : sizes[i] = d_bi.count;
4768 1 : i++;
4769 :
4770 1 : if (TMsubcommit_list(commit_list, sizes, i, -1) != GDK_SUCCEED) {
4771 0 : bat_iterator_end(&d_bi);
4772 0 : MT_lock_unset(&lock_persist_unlogged);
4773 0 : GDKfree(commit_list);
4774 0 : GDKfree(sizes);
4775 0 : BBPreclaim(d);
4776 0 : throw(SQL, "sql.persist_unlogged", "Lower level commit operation failed");
4777 : }
4778 :
4779 1 : GDKfree(commit_list);
4780 1 : GDKfree(sizes);
4781 : }
4782 1 : count = d_bi.count;
4783 : } else {
4784 : /* special case of log_tstart: third arg == NULL with second arg
4785 : * true is request to rotate log file ASAP */
4786 1 : store->logger_api.log_tstart(store, true, NULL);
4787 : /* special case for sql->debug: if 1024 bit is set,
4788 : * store_manager doesn't wait for 30 seconds of idle time before
4789 : * attempting to rotate */
4790 1 : MT_lock_set(&store->flush);
4791 1 : store->debug |= 1024;
4792 1 : MT_lock_unset(&store->flush);
4793 : }
4794 :
4795 2 : bat_iterator_end(&d_bi);
4796 2 : MT_lock_unset(&lock_persist_unlogged);
4797 2 : BBPreclaim(d);
4798 :
4799 2 : BAT *table = COLnew(0, TYPE_str, 0, TRANSIENT),
4800 2 : *tableid = COLnew(0, TYPE_int, 0, TRANSIENT),
4801 2 : *rowcount = COLnew(0, TYPE_lng, 0, TRANSIENT);
4802 :
4803 4 : if (table == NULL || tableid == NULL || rowcount == NULL ||
4804 4 : BUNappend(table, tname, false) != GDK_SUCCEED ||
4805 4 : BUNappend(tableid, &(t->base.id), false) != GDK_SUCCEED ||
4806 2 : BUNappend(rowcount, &count, false) != GDK_SUCCEED) {
4807 0 : BBPnreclaim(3, table, tableid, rowcount);
4808 0 : throw(SQL, "sql.persist_unlogged", SQLSTATE(HY001));
4809 : }
4810 2 : *o0 = table->batCacheid;
4811 2 : *o1 = tableid->batCacheid;
4812 2 : *o2 = rowcount->batCacheid;
4813 2 : BBPkeepref(table);
4814 2 : BBPkeepref(tableid);
4815 2 : BBPkeepref(rowcount);
4816 2 : return msg;
4817 : }
4818 :
4819 : str
4820 9 : SQLsession_prepared_statements(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4821 : {
4822 9 : BAT *sessionid, *user, *statementid, *statement, *created;
4823 9 : bat *sid = getArgReference_bat(stk,pci,0);
4824 9 : bat *u = getArgReference_bat(stk,pci,1);
4825 9 : bat *i = getArgReference_bat(stk,pci,2);
4826 9 : bat *s = getArgReference_bat(stk,pci,3);
4827 9 : bat *c = getArgReference_bat(stk,pci,4);
4828 9 : str msg = MAL_SUCCEED;
4829 9 : mvc *sql = NULL;
4830 9 : cq *q = NULL;
4831 :
4832 9 : (void) stk;
4833 9 : (void) pci;
4834 9 : if ((msg = getSQLContext(cntxt, mb, &sql, NULL)) != NULL)
4835 : return msg;
4836 9 : if ((msg = checkSQLContext(cntxt)) != NULL)
4837 : return msg;
4838 :
4839 9 : assert(sql->qc);
4840 :
4841 9 : sessionid = COLnew(0, TYPE_int, 256, TRANSIENT);
4842 9 : user = COLnew(0, TYPE_str, 256, TRANSIENT);
4843 9 : statementid = COLnew(0, TYPE_int, 256, TRANSIENT);
4844 9 : statement = COLnew(0, TYPE_str, 256, TRANSIENT);
4845 9 : created = COLnew(0, TYPE_timestamp, 256, TRANSIENT);
4846 9 : if (sessionid == NULL || user == NULL || statementid == NULL || statement == NULL || created == NULL) {
4847 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4848 0 : goto bailout;
4849 : }
4850 :
4851 13 : for (q = sql->qc->q; q; q = q->next) {
4852 4 : gdk_return bun_res;
4853 4 : if (BUNappend(sessionid, &(cntxt->idx), false) != GDK_SUCCEED) {
4854 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4855 0 : goto bailout;
4856 : }
4857 :
4858 4 : if (msg != MAL_SUCCEED)
4859 : goto bailout;
4860 4 : bun_res = BUNappend(user, cntxt->username, false);
4861 4 : if (bun_res != GDK_SUCCEED) {
4862 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4863 0 : goto bailout;
4864 : }
4865 :
4866 4 : if (BUNappend(statementid, &(q->id), false) != GDK_SUCCEED) {
4867 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4868 0 : goto bailout;
4869 : }
4870 4 : if (BUNappend(statement, q->f->query, false) != GDK_SUCCEED) {
4871 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4872 0 : goto bailout;
4873 : }
4874 4 : if (BUNappend(created, &(q->created), false) != GDK_SUCCEED) {
4875 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4876 0 : goto bailout;
4877 : }
4878 : }
4879 :
4880 9 : bailout:
4881 0 : if (msg) {
4882 0 : BBPreclaim(sessionid);
4883 0 : BBPreclaim(user);
4884 0 : BBPreclaim(statementid);
4885 0 : BBPreclaim(statement);
4886 0 : BBPreclaim(created);
4887 : } else {
4888 9 : *sid = sessionid->batCacheid;
4889 9 : BBPkeepref(sessionid);
4890 9 : *u = user->batCacheid;
4891 9 : BBPkeepref(user);
4892 9 : *i = statementid->batCacheid;
4893 9 : BBPkeepref(statementid);
4894 9 : *s = statement->batCacheid;
4895 9 : BBPkeepref(statement);
4896 9 : *c = created->batCacheid;
4897 9 : BBPkeepref(created);
4898 : }
4899 : return msg;
4900 : }
4901 :
4902 : str
4903 6 : SQLsession_prepared_statements_args(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4904 : {
4905 6 : BAT *statementid, *type, *digits, *isinout, *number, *scale, *schema, *table, *column;
4906 6 : bat *sid = getArgReference_bat(stk,pci,0);
4907 6 : bat *t = getArgReference_bat(stk,pci,1);
4908 6 : bat *d = getArgReference_bat(stk,pci,2);
4909 6 : bat *s = getArgReference_bat(stk,pci,3);
4910 6 : bat *io = getArgReference_bat(stk,pci,4);
4911 6 : bat *n = getArgReference_bat(stk,pci,5);
4912 6 : bat *sch = getArgReference_bat(stk,pci,6);
4913 6 : bat *tbl = getArgReference_bat(stk,pci,7);
4914 6 : bat *col = getArgReference_bat(stk,pci,8);
4915 6 : str msg = MAL_SUCCEED;
4916 6 : mvc *sql = NULL;
4917 6 : cq *q = NULL;
4918 :
4919 6 : (void) stk;
4920 6 : (void) pci;
4921 6 : if ((msg = getSQLContext(cntxt, mb, &sql, NULL)) != NULL)
4922 : return msg;
4923 6 : if ((msg = checkSQLContext(cntxt)) != NULL)
4924 : return msg;
4925 :
4926 6 : assert(sql->qc);
4927 :
4928 6 : statementid = COLnew(0, TYPE_int, 256, TRANSIENT);
4929 6 : type = COLnew(0, TYPE_str, 256, TRANSIENT);
4930 6 : digits = COLnew(0, TYPE_int, 256, TRANSIENT);
4931 6 : scale = COLnew(0, TYPE_int, 256, TRANSIENT);
4932 6 : isinout = COLnew(0, TYPE_bte, 256, TRANSIENT);
4933 6 : number = COLnew(0, TYPE_int, 256, TRANSIENT);
4934 6 : schema = COLnew(0, TYPE_str, 256, TRANSIENT);
4935 6 : table = COLnew(0, TYPE_str, 256, TRANSIENT);
4936 6 : column = COLnew(0, TYPE_str, 256, TRANSIENT);
4937 6 : if (!statementid || !type || !digits || !scale || !isinout || !number || !schema || !table || !column) {
4938 0 : msg = createException(SQL, "sql.session_prepared_statements_args", GDK_EXCEPTION);
4939 0 : goto bailout;
4940 : }
4941 :
4942 9 : for (q = sql->qc->q; q; q = q->next) {
4943 3 : sql_rel *r = q->rel;
4944 3 : int arg_number = 0;
4945 3 : bte inout = ARG_OUT;
4946 :
4947 3 : if (r && (is_topn(r->op) || is_sample(r->op)))
4948 0 : r = r->l;
4949 :
4950 3 : if (r && is_project(r->op) && r->exps) {
4951 6 : for (node *n = r->exps->h; n; n = n->next, arg_number++) {
4952 3 : sql_exp *e = n->data;
4953 3 : sql_subtype *t = exp_subtype(e);
4954 3 : const char *name = exp_name(e), *rname = NULL, *rschema = ATOMnilptr(TYPE_str);
4955 3 : sql_alias *ra = exp_relname(e);
4956 :
4957 3 : if (ra) {
4958 3 : rname = ra->name;
4959 3 : if (ra->parent)
4960 0 : rschema = ra->parent->name;
4961 : }
4962 :
4963 3 : if (!name && e->type == e_column && e->r)
4964 0 : name = e->r;
4965 0 : if (!name)
4966 0 : name = ATOMnilptr(TYPE_str);
4967 3 : if (!rname && e->type == e_column && e->l)
4968 0 : rname = e->l;
4969 0 : if (!rname)
4970 0 : rname = ATOMnilptr(TYPE_str);
4971 :
4972 6 : if (BUNappend(statementid, &(q->id), false) != GDK_SUCCEED ||
4973 6 : BUNappend(type, t->type->base.name, false) != GDK_SUCCEED ||
4974 6 : BUNappend(digits, &t->digits, false) != GDK_SUCCEED ||
4975 6 : BUNappend(scale, &t->scale, false) != GDK_SUCCEED ||
4976 6 : BUNappend(isinout, &inout, false) != GDK_SUCCEED ||
4977 6 : BUNappend(number, &arg_number, false) != GDK_SUCCEED ||
4978 6 : BUNappend(schema, rschema, false) != GDK_SUCCEED ||
4979 6 : BUNappend(table, rname, false) != GDK_SUCCEED ||
4980 3 : BUNappend(column, name, false) != GDK_SUCCEED) {
4981 0 : msg = createException(SQL, "sql.session_prepared_statements_args", GDK_EXCEPTION);
4982 0 : goto bailout;
4983 : }
4984 : }
4985 : }
4986 :
4987 3 : if (q->f->ops) {
4988 3 : inout = ARG_IN;
4989 6 : for (node *n = q->f->ops->h; n; n=n->next, arg_number++) {
4990 3 : sql_arg *a = n->data;
4991 3 : sql_subtype *t = &a->type;
4992 :
4993 6 : if (BUNappend(statementid, &(q->id), false) != GDK_SUCCEED ||
4994 6 : BUNappend(type, t->type->base.name, false) != GDK_SUCCEED ||
4995 6 : BUNappend(digits, &(t->digits), false) != GDK_SUCCEED ||
4996 6 : BUNappend(scale, &(t->scale), false) != GDK_SUCCEED ||
4997 6 : BUNappend(isinout, &inout, false) != GDK_SUCCEED ||
4998 6 : BUNappend(number, &arg_number, false) != GDK_SUCCEED ||
4999 6 : BUNappend(schema, ATOMnilptr(TYPE_str), false) != GDK_SUCCEED ||
5000 6 : BUNappend(table, ATOMnilptr(TYPE_str), false) != GDK_SUCCEED ||
5001 3 : BUNappend(column, ATOMnilptr(TYPE_str), false) != GDK_SUCCEED) {
5002 0 : msg = createException(SQL, "sql.session_prepared_statements_args", GDK_EXCEPTION);
5003 0 : goto bailout;
5004 : }
5005 : }
5006 : }
5007 : }
5008 :
5009 6 : bailout:
5010 0 : if (msg) {
5011 0 : BBPreclaim(statementid);
5012 0 : BBPreclaim(type);
5013 0 : BBPreclaim(digits);
5014 0 : BBPreclaim(scale);
5015 0 : BBPreclaim(isinout);
5016 0 : BBPreclaim(number);
5017 0 : BBPreclaim(schema);
5018 0 : BBPreclaim(table);
5019 0 : BBPreclaim(column);
5020 : } else {
5021 6 : *sid = statementid->batCacheid;
5022 6 : BBPkeepref(statementid);
5023 6 : *t = type->batCacheid;
5024 6 : BBPkeepref(type);
5025 6 : *d = digits->batCacheid;
5026 6 : BBPkeepref(digits);
5027 6 : *s = scale->batCacheid;
5028 6 : BBPkeepref(scale);
5029 6 : *io = isinout->batCacheid;
5030 6 : BBPkeepref(isinout);
5031 6 : *n = number->batCacheid;
5032 6 : BBPkeepref(number);
5033 6 : *sch = schema->batCacheid;
5034 6 : BBPkeepref(schema);
5035 6 : *tbl = table->batCacheid;
5036 6 : BBPkeepref(table);
5037 6 : *col = column->batCacheid;
5038 6 : BBPkeepref(column);
5039 : }
5040 : return msg;
5041 : }
5042 :
5043 : /* input id, row-input-values
5044 : * for each id call function(with row-input-values) return table
5045 : * return for each id the table, ie id (*length of table) and table results
5046 : */
5047 : str
5048 23 : SQLunionfunc(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5049 : {
5050 23 : int arg = pci->retc;
5051 23 : str mod, fcn, ret = MAL_SUCCEED;
5052 23 : InstrPtr npci;
5053 23 : MalBlkPtr nmb = newMalBlk(1), omb = NULL;
5054 :
5055 23 : if (!nmb)
5056 0 : return createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5057 23 : mod = *getArgReference_str(stk, pci, arg++);
5058 23 : fcn = *getArgReference_str(stk, pci, arg++);
5059 23 : npci = newStmtArgs(nmb, mod, fcn, pci->argc);
5060 23 : if (npci == NULL) {
5061 0 : freeMalBlk(nmb);
5062 0 : return createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5063 : }
5064 :
5065 46 : for (int i = 1; i < pci->retc; i++) {
5066 23 : int type = getArgType(mb, pci, i);
5067 :
5068 23 : if (i==1)
5069 23 : getArg(npci, 0) = newTmpVariable(nmb, type);
5070 : else
5071 0 : npci = pushReturn(nmb, npci, newTmpVariable(nmb, type));
5072 : }
5073 60 : for (int i = pci->retc+2+1; i < pci->argc; i++) {
5074 37 : int type = getBatType(getArgType(mb, pci, i));
5075 :
5076 37 : npci = pushNil(nmb, npci, type);
5077 : }
5078 23 : pushInstruction(nmb, npci);
5079 : /* check program to get the proper malblk */
5080 23 : if (chkInstruction(cntxt->usermodule, nmb, npci)) {
5081 0 : freeMalBlk(nmb);
5082 0 : return createException(MAL, "sql.unionfunc", SQLSTATE(42000) PROGRAM_GENERAL);
5083 : }
5084 :
5085 23 : if (npci) {
5086 23 : BAT **res = NULL, **input = NULL;
5087 23 : BATiter *bi = NULL;
5088 23 : BUN cnt = 0;
5089 23 : int nrinput = pci->argc - 2 - pci->retc;
5090 23 : MalStkPtr env = NULL;
5091 23 : InstrPtr q = NULL;
5092 :
5093 23 : if (!(input = GDKzalloc(sizeof(BAT*) * nrinput))) {
5094 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5095 0 : goto finalize;
5096 : }
5097 23 : if (!(bi = GDKmalloc(sizeof(BATiter) * nrinput))) {
5098 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5099 0 : goto finalize;
5100 : }
5101 23 : assert(pci->retc + 2 + nrinput == pci->argc);
5102 83 : for (int i = 0, j = pci->retc+2; j < pci->argc; i++, j++) {
5103 60 : bat *b = getArgReference_bat(stk, pci, j);
5104 60 : if (!(input[i] = BATdescriptor(*b))) {
5105 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY005) "Cannot access column descriptor");
5106 0 : while (i > 0) {
5107 0 : i--;
5108 0 : bat_iterator_end(&bi[i]);
5109 0 : BBPunfix(input[i]->batCacheid);
5110 : }
5111 0 : GDKfree(input);
5112 0 : input = NULL;
5113 0 : goto finalize;
5114 : }
5115 60 : bi[i] = bat_iterator(input[i]);
5116 60 : cnt = BATcount(input[i]);
5117 : }
5118 :
5119 : /* create result bats */
5120 23 : if (!(res = GDKzalloc(sizeof(BAT*) * pci->retc))) {
5121 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5122 0 : goto finalize;
5123 : }
5124 69 : for (int i = 0; i<pci->retc; i++) {
5125 46 : int type = getArgType(mb, pci, i);
5126 :
5127 46 : if (!(res[i] = COLnew(0, getBatType(type), cnt, TRANSIENT))) {
5128 0 : ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
5129 0 : goto finalize;
5130 : }
5131 : }
5132 :
5133 23 : if (npci->blk && npci->blk->stop > 1) {
5134 11 : omb = nmb;
5135 11 : if (!(nmb = copyMalBlk(npci->blk))) {
5136 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5137 0 : goto finalize;
5138 : }
5139 : }
5140 23 : if (!(env = prepareMALstack(nmb, nmb->vsize))) { /* needed for result */
5141 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5142 0 : goto finalize;
5143 : }
5144 23 : q = getInstrPtr(nmb, 0);
5145 :
5146 23 : int start = 1;
5147 23 : if (nmb->stop == 1 && (omb || !npci->fcn || npci->token != PATcall)) {
5148 0 : InstrPtr *stmt = nmb->stmt;
5149 0 : nmb->stmt = (InstrPtr*)GDKmalloc(sizeof(InstrPtr*)*3);
5150 0 : nmb->stmt[0] = NULL; /* no main() */
5151 0 : nmb->stmt[1] = NULL; /* no profiling */
5152 0 : nmb->stmt[2] = stmt[0];
5153 0 : nmb->stop = nmb->ssize = 3;
5154 0 : GDKfree(stmt);
5155 0 : start = 2;
5156 : }
5157 83 : for (BUN cur = 0; cur<cnt && !ret; cur++ ) {
5158 60 : MalStkPtr nstk = prepareMALstack(nmb, nmb->vsize);
5159 60 : int i,ii;
5160 :
5161 60 : if (!nstk) { /* needed for result */
5162 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5163 : } else {
5164 : /* copy (input) arguments onto destination stack, skipping rowid col */
5165 135 : for (i = 1, ii = q->retc; ii < q->argc && !ret; ii++, i++) {
5166 75 : ValPtr lhs = &nstk->stk[q->argv[ii]];
5167 75 : ptr rhs = (ptr)BUNtail(bi[i], cur);
5168 :
5169 75 : if (VALset(lhs, input[i]->ttype, rhs) == NULL)
5170 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5171 : }
5172 60 : if (!ret && ii == q->argc) {
5173 60 : BAT *fres = NULL;
5174 60 : if (!omb && npci->fcn && npci->token == PATcall) /* pattern */
5175 15 : ret = (*(str (*)(Client, MalBlkPtr, MalStkPtr, InstrPtr))npci->fcn)(cntxt, nmb, nstk, npci);
5176 : else
5177 45 : ret = runMALsequence(cntxt, nmb, start, nmb->stop, nstk, env /* copy result in nstk first instruction*/, q);
5178 :
5179 60 : if (!ret) {
5180 : /* insert into result */
5181 60 : if (!(fres = BBPquickdesc(omb?env->stk[q->argv[0]].val.bval:nstk->stk[q->argv[0]].val.bval))) {
5182 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY005) "Cannot access column descriptor");
5183 : } else {
5184 60 : BAT *p = BATconstant(fres->hseqbase, res[0]->ttype, (ptr)BUNtail(bi[0], cur), BATcount(fres), TRANSIENT);
5185 :
5186 60 : if (p) {
5187 60 : if (BATappend(res[0], p, NULL, FALSE) != GDK_SUCCEED)
5188 0 : ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
5189 60 : BBPunfix(p->batCacheid);
5190 : } else {
5191 0 : ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
5192 : }
5193 : }
5194 : i=1;
5195 120 : for (ii = 0; i < pci->retc && !ret; ii++, i++) {
5196 60 : BAT *b;
5197 60 : ValPtr vp = omb ? env->stk + q->argv[ii] : nstk->stk + q->argv[ii];
5198 :
5199 60 : if (!(b = BATdescriptor(vp->val.bval)))
5200 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
5201 60 : else if (BATappend(res[i], b, NULL, FALSE) != GDK_SUCCEED)
5202 0 : ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
5203 60 : if (b) {
5204 60 : BBPrelease(b->batCacheid); /* release ref from env stack */
5205 60 : BBPunfix(b->batCacheid); /* free pointer */
5206 60 : VALempty(vp);
5207 : }
5208 : }
5209 : }
5210 : }
5211 60 : freeStack(nstk);
5212 : }
5213 : }
5214 23 : finalize:
5215 23 : freeStack(env);
5216 23 : if (nmb)
5217 23 : freeMalBlk(nmb);
5218 23 : if (omb)
5219 11 : freeMalBlk(omb);
5220 23 : if (res)
5221 69 : for (int i = 0; i<pci->retc; i++) {
5222 46 : bat *b = getArgReference_bat(stk, pci, i);
5223 46 : if (res[i]) {
5224 46 : *b = res[i]->batCacheid;
5225 46 : if (ret)
5226 0 : BBPunfix(*b);
5227 : else
5228 46 : BBPkeepref(res[i]);
5229 : }
5230 : }
5231 23 : GDKfree(res);
5232 23 : if (input) {
5233 83 : for (int i = 0; i<nrinput; i++) {
5234 60 : if (input[i]) {
5235 60 : bat_iterator_end(&bi[i]);
5236 60 : BBPunfix(input[i]->batCacheid);
5237 : }
5238 : }
5239 23 : GDKfree(input);
5240 : }
5241 23 : GDKfree(bi);
5242 : }
5243 : return ret;
5244 : }
5245 :
5246 : static str
5247 9 : do_str_column_vacuum(sql_trans *tr, sql_column *c, bool force)
5248 : {
5249 9 : if (ATOMvarsized(c->type.type->localtype)) {
5250 5 : int res = 0;
5251 5 : sqlstore *store = tr->store;
5252 :
5253 5 : if ((res = (int) store->storage_api.vacuum_col(tr, c, force)) != LOG_OK) {
5254 0 : if (res == LOG_CONFLICT)
5255 0 : throw(SQL, "do_str_column_vacuum", SQLSTATE(25S01) "TRANSACTION CONFLICT in storage_api.vacuum_col %s.%s.%s", c->t->s->base.name, c->t->base.name, c->base.name);
5256 0 : if (res == LOG_ERR)
5257 0 : throw(SQL, "do_str_column_vacuum", SQLSTATE(HY000) "LOG ERROR in storage_api.vacuum_col %s.%s.%s", c->t->s->base.name, c->t->base.name, c->base.name);
5258 0 : throw(SQL, "do_str_column_vacuum", SQLSTATE(HY000) "ERROR in storage_api.vacuum_col %s.%s.%s", c->t->s->base.name, c->t->base.name, c->base.name);
5259 : }
5260 : }
5261 : return MAL_SUCCEED;
5262 : }
5263 :
5264 : static str
5265 0 : do_str_table_vacuum(sql_trans *tr, sql_table *t, bool force)
5266 : {
5267 0 : int res = 0;
5268 0 : sqlstore *store = tr->store;
5269 :
5270 0 : if ((res = (int) store->storage_api.vacuum_tab(tr, t, force)) != LOG_OK) {
5271 0 : if (res == LOG_CONFLICT)
5272 0 : throw(SQL, "do_str_table_vacuum", SQLSTATE(25S01) "TRANSACTION CONFLICT in storage_api.vacuum_col %s.%s", t->s->base.name, t->base.name);
5273 0 : if (res == LOG_ERR)
5274 0 : throw(SQL, "do_str_table_vacuum", SQLSTATE(HY000) "LOG ERROR in storage_api.vacuum_col %s.%s", t->s->base.name, t->base.name);
5275 0 : throw(SQL, "do_str_table_vacuum", SQLSTATE(HY000) "ERROR in storage_api.vacuum_col %s.%s", t->s->base.name, t->base.name);
5276 : }
5277 : return MAL_SUCCEED;
5278 : }
5279 :
5280 : static str
5281 9 : SQLstr_vacuum(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5282 : {
5283 9 : mvc *m = NULL;
5284 9 : str msg = NULL;
5285 9 : char *sname = *getArgReference_str(stk, pci, 1);
5286 9 : char *tname = *getArgReference_str(stk, pci, 2);
5287 9 : char *cname = NULL;
5288 9 : if (pci->argc == 4)
5289 9 : cname = *getArgReference_str(stk, pci, 3);
5290 :
5291 9 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5292 : return msg;
5293 9 : if ((msg = checkSQLContext(cntxt)) != NULL)
5294 : return msg;
5295 :
5296 9 : sql_trans *tr = m->session->tr;
5297 9 : sql_schema *s = NULL;
5298 9 : sql_table *t = NULL;
5299 9 : sql_column *c = NULL;
5300 :
5301 9 : if (strNil(sname))
5302 0 : throw(SQL, "sql.str_vacuum", SQLSTATE(42000) "Schema name cannot be NULL");
5303 9 : if (strNil(tname))
5304 0 : throw(SQL, "sql.str_vacuum", SQLSTATE(42000) "Table name cannot be NULL");
5305 9 : if (cname && strNil(cname))
5306 0 : throw(SQL, "sql.str_vacuum", SQLSTATE(42000) "Column name cannot be NULL");
5307 9 : if ((s = mvc_bind_schema(m, sname)) == NULL)
5308 0 : throw(SQL, "sql.str_vacuum", SQLSTATE(3F000) "Invalid or missing schema %s",sname);
5309 9 : if ((t = mvc_bind_table(m, s, tname)) == NULL)
5310 0 : throw(SQL, "sql.str_vacuum", SQLSTATE(42S02) "Invalid or missing table %s.%s",sname,tname);
5311 9 : if (!isTable(t))
5312 0 : throw(SQL, "sql.str_vacuum", SQLSTATE(42000) "%s '%s' is not persistent",
5313 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
5314 9 : if (isTempTable(t))
5315 0 : throw(SQL, "sql.str_vacuum", SQLSTATE(42000) "Cannot vacuum column from temporary table");
5316 9 : if (cname) {
5317 9 : if ((c = mvc_bind_column(m, t, cname)) == NULL)
5318 0 : throw(SQL, "sql.str_vacuum", SQLSTATE(42S22) "Column not found in %s.%s.%s",sname,tname,cname);
5319 9 : if (c->storage_type)
5320 0 : throw(SQL, "sql.str_vacuum", SQLSTATE(42000) "Cannot vacuum compressed column");
5321 : }
5322 :
5323 9 : if (c)
5324 9 : return do_str_column_vacuum(tr, c, true);
5325 : else
5326 0 : return do_str_table_vacuum(tr, t, true);
5327 : }
5328 :
5329 :
5330 : static gdk_return
5331 0 : str_vacuum_callback(int argc, void *argv[])
5332 : {
5333 0 : sqlstore *store = (sqlstore *) argv[0];
5334 0 : char *sname = (char *) argv[1];
5335 0 : char *tname = (char *) argv[2];
5336 0 : char *cname = (char *) argv[3];
5337 0 : allocator *sa = NULL;
5338 0 : sql_session *session = NULL;
5339 0 : sql_schema *s = NULL;
5340 0 : sql_table *t = NULL;
5341 0 : sql_column *c = NULL;
5342 0 : char *msg;
5343 0 : gdk_return res = GDK_SUCCEED;
5344 :
5345 0 : (void) argc;
5346 :
5347 0 : if ((sa = sa_create(NULL)) == NULL) {
5348 0 : TRC_ERROR(SQL_EXECUTION, "[str_vacuum_callback] -- Failed to create allocator!");
5349 0 : return GDK_FAIL;
5350 : }
5351 :
5352 0 : if ((session = sql_session_create(store, sa, 0)) == NULL) {
5353 0 : TRC_ERROR(SQL_EXECUTION, "[str_vacuum_callback] -- Failed to create session!");
5354 0 : sa_destroy(sa);
5355 0 : return GDK_FAIL;
5356 : }
5357 :
5358 0 : if (sql_trans_begin(session) < 0) {
5359 0 : TRC_ERROR(SQL_EXECUTION, "[str_vacuum_callback] -- Failed to begin transaction!");
5360 0 : sql_session_destroy(session);
5361 0 : sa_destroy(sa);
5362 0 : return GDK_FAIL;
5363 : }
5364 :
5365 0 : do {
5366 0 : if((s = find_sql_schema(session->tr, sname)) == NULL) {
5367 0 : TRC_ERROR(SQL_EXECUTION, "[str_vacuum_callback] -- Invalid or missing schema %s!",sname);
5368 0 : res = GDK_FAIL;
5369 0 : break;
5370 : }
5371 :
5372 0 : if((t = find_sql_table(session->tr, s, tname)) == NULL) {
5373 0 : TRC_ERROR(SQL_EXECUTION, "[str_vacuum_callback] -- Invalid or missing table %s!", tname);
5374 0 : res = GDK_FAIL;
5375 0 : break;
5376 : }
5377 0 : if (cname) {
5378 0 : if ((c = find_sql_column(t, cname)) == NULL) {
5379 0 : TRC_ERROR(SQL_EXECUTION, "[str_vacuum_callback] -- Invalid or missing column %s!", cname);
5380 0 : res = GDK_FAIL;
5381 0 : break;
5382 : }
5383 :
5384 0 : if((msg=do_str_column_vacuum(session->tr, c, false)) != MAL_SUCCEED) {
5385 0 : TRC_ERROR(SQL_EXECUTION, "[str_vacuum_callback] -- %s", msg);
5386 0 : res = GDK_FAIL;
5387 : }
5388 : } else {
5389 0 : if((msg=do_str_table_vacuum(session->tr, t, false)) != MAL_SUCCEED) {
5390 0 : TRC_ERROR(SQL_EXECUTION, "[str_vacuum_callback] -- %s", msg);
5391 0 : res = GDK_FAIL;
5392 : }
5393 : }
5394 :
5395 : } while(0);
5396 :
5397 0 : if (res == GDK_SUCCEED) { /* everything is ok, do the commit route */
5398 0 : switch (sql_trans_end(session, SQL_OK)) {
5399 0 : case SQL_ERR:
5400 0 : TRC_ERROR(SQL_EXECUTION, "[str_column_vacuum_callback] -- transaction commit failed (kernel error: %s)", GDKerrbuf);
5401 0 : res = GDK_FAIL;
5402 0 : break;
5403 0 : case SQL_CONFLICT:
5404 0 : TRC_ERROR(SQL_EXECUTION, "[str_column_vacuum_callback] -- transaction is aborted because of concurrency conflicts, will ROLLBACK instead");
5405 0 : res = GDK_FAIL;
5406 0 : break;
5407 : default:
5408 : break;
5409 : }
5410 : } else { /* an error triggered, rollback and ignore further errors */
5411 0 : (void)sql_trans_end(session, SQL_ERR);
5412 : }
5413 :
5414 0 : sql_session_destroy(session);
5415 0 : sa_destroy(sa);
5416 0 : return res;
5417 : }
5418 :
5419 : static gdk_return
5420 0 : str_vacuum_callback_args_free(int argc, void *argv[])
5421 : {
5422 0 : (void) argc;
5423 : // free up sname, tname, cname. First pointer points to sqlstore so leave it.
5424 0 : GDKfree(argv[1]); // sname
5425 0 : GDKfree(argv[2]); // tname
5426 0 : if (argv[3])
5427 0 : GDKfree(argv[3]); // cname
5428 0 : return GDK_SUCCEED;
5429 : }
5430 :
5431 : static str
5432 0 : SQLstr_auto_vacuum(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5433 : {
5434 0 : mvc *m = NULL;
5435 0 : str msg = NULL;
5436 0 : char *sname = *getArgReference_str(stk, pci, 1);
5437 0 : char *tname = *getArgReference_str(stk, pci, 2);
5438 0 : char *cname = NULL;
5439 0 : int iarg = 3;
5440 0 : if (pci->argc == 5) {
5441 0 : cname = *getArgReference_str(stk, pci, 3);
5442 0 : iarg++;
5443 : }
5444 0 : int interval = *getArgReference_int(stk, pci, iarg); // in sec
5445 0 : char *sname_copy = NULL, *tname_copy = NULL, *cname_copy = NULL;
5446 :
5447 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5448 : return msg;
5449 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
5450 : return msg;
5451 :
5452 0 : sql_schema *s = NULL;
5453 0 : sql_table *t = NULL;
5454 0 : sql_column *c = NULL;
5455 :
5456 0 : if (strNil(sname))
5457 0 : throw(SQL, "sql.str_auto_vacuum", SQLSTATE(42000) "Schema name cannot be NULL");
5458 0 : if (strNil(tname))
5459 0 : throw(SQL, "sql.str_auto_vacuum", SQLSTATE(42000) "Table name cannot be NULL");
5460 0 : if (strNil(cname))
5461 0 : throw(SQL, "sql.str_auto_vacuum", SQLSTATE(42000) "Column name cannot be NULL");
5462 0 : if ((s = mvc_bind_schema(m, sname)) == NULL)
5463 0 : throw(SQL, "sql.str_auto_vacuum", SQLSTATE(3F000) "Invalid or missing schema %s",sname);
5464 0 : if ((t = mvc_bind_table(m, s, tname)) == NULL)
5465 0 : throw(SQL, "sql.str_auto_vacuum", SQLSTATE(42S02) "Invalid or missing table %s.%s",sname,tname);
5466 0 : if (!isTable(t))
5467 0 : throw(SQL, "sql.str_auto_vacuum", SQLSTATE(42000) "%s '%s' is not persistent",
5468 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
5469 0 : if (isTempTable(t))
5470 0 : throw(SQL, "sql.str_auto_vacuum", SQLSTATE(42000) "Cannot vacuum column from temporary table");
5471 0 : if (cname && (c = mvc_bind_column(m, t, cname)) == NULL)
5472 0 : throw(SQL, "sql.str_auto_vacuum", SQLSTATE(42S22) "Column not found in %s.%s.%s",sname,tname,cname);
5473 0 : if (c && c->storage_type)
5474 0 : throw(SQL, "sql.str_auto_vacuum", SQLSTATE(42000) "Cannot vacuum compressed column");
5475 :
5476 0 : if (!(sname_copy = GDKstrdup(sname)) || !(tname_copy = GDKstrdup(tname)) || (cname && !(cname_copy = GDKstrdup(cname)))) {
5477 0 : GDKfree(sname_copy);
5478 0 : GDKfree(tname_copy);
5479 0 : GDKfree(cname_copy);
5480 0 : throw(SQL, "sql.str_auto_vacuum", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5481 : }
5482 0 : void *argv[4] = {m->store, sname_copy, tname_copy, cname_copy};
5483 :
5484 0 : if (gdk_add_callback("str_vacuum", str_vacuum_callback, 4, argv, interval) != GDK_SUCCEED) {
5485 0 : str_vacuum_callback_args_free(4, argv);
5486 0 : throw(SQL, "sql.str_auto_vacuum", "adding vacuum callback failed!");
5487 : }
5488 :
5489 : return MAL_SUCCEED;
5490 : }
5491 :
5492 : static str
5493 0 : SQLstr_stop_vacuum(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5494 : {
5495 0 : mvc *m = NULL;
5496 0 : str msg = NULL;
5497 0 : char *sname = *getArgReference_str(stk, pci, 1);
5498 0 : char *tname = *getArgReference_str(stk, pci, 2);
5499 0 : char *cname = NULL;
5500 0 : if (pci->argc == 4)
5501 0 : cname = *getArgReference_str(stk, pci, 3);
5502 :
5503 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5504 : return msg;
5505 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
5506 : return msg;
5507 :
5508 0 : sql_schema *s = NULL;
5509 0 : sql_table *t = NULL;
5510 0 : sql_column *c = NULL;
5511 :
5512 0 : if (strNil(sname))
5513 0 : throw(SQL, "sql.str_stop_vacuum", SQLSTATE(42000) "Schema name cannot be NULL");
5514 0 : if (strNil(tname))
5515 0 : throw(SQL, "sql.str_stop_vacuum", SQLSTATE(42000) "Table name cannot be NULL");
5516 0 : if (cname && strNil(cname))
5517 0 : throw(SQL, "sql.str_stop_vacuum", SQLSTATE(42000) "Column name cannot be NULL");
5518 0 : if ((s = mvc_bind_schema(m, sname)) == NULL)
5519 0 : throw(SQL, "sql.str_stop_vacuum", SQLSTATE(3F000) "Invalid or missing schema %s",sname);
5520 0 : if ((t = mvc_bind_table(m, s, tname)) == NULL)
5521 0 : throw(SQL, "sql.str_stop_vacuum", SQLSTATE(42S02) "Invalid or missing table %s.%s",sname,tname);
5522 0 : if (!isTable(t))
5523 0 : throw(SQL, "sql.str_stop_vacuum", SQLSTATE(42000) "%s '%s' is not persistent",
5524 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
5525 0 : if (isTempTable(t))
5526 0 : throw(SQL, "sql.str_stop_vacuum", SQLSTATE(42000) "Cannot vacuum column from temporary table");
5527 0 : if (cname && (c = mvc_bind_column(m, t, cname)) == NULL)
5528 0 : throw(SQL, "sql.str_stop_vacuum", SQLSTATE(42S22) "Column not found in %s.%s.%s",sname,tname,cname);
5529 :
5530 0 : if(gdk_remove_callback("str_vacuum", str_vacuum_callback_args_free) != GDK_SUCCEED)
5531 0 : throw(SQL, "sql.str_stop_vacuum", "removing vacuum callback failed!");
5532 :
5533 : return MAL_SUCCEED;
5534 : }
5535 :
5536 :
5537 : #include "sql_cat.h"
5538 : #include "sql_rank.h"
5539 : #include "sql_user.h"
5540 : #include "sql_assert.h"
5541 : #include "sql_execute.h"
5542 : #include "sql_orderidx.h"
5543 : #include "sql_strimps.h"
5544 : #include "sql_subquery.h"
5545 : #include "sql_statistics.h"
5546 : #include "sql_transaction.h"
5547 : #include "for.h"
5548 : #include "dict.h"
5549 : #include "mel.h"
5550 :
5551 :
5552 : static str
5553 51 : SQLuser_password(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5554 : {
5555 51 : mvc *m = NULL;
5556 51 : str msg = NULL;
5557 51 : str *password = getArgReference_str(stk, pci, 0);
5558 51 : const char *username = *getArgReference_str(stk, pci, 1);
5559 :
5560 51 : (void) password;
5561 :
5562 51 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5563 : return msg;
5564 51 : if ((msg = checkSQLContext(cntxt)) != NULL)
5565 : return msg;
5566 51 : if (cntxt->username != username) {
5567 : // only MAL_ADMIN and user himself can access password
5568 51 : if ((msg = AUTHrequireAdmin(cntxt)) != MAL_SUCCEED)
5569 : return msg;
5570 : }
5571 51 : *password = monet5_password_hash(m, username);
5572 51 : if (!(*password))
5573 1 : throw(SQL, "mvc", SQLSTATE(42000) "SELECT: Failed to retrieve password hash");
5574 : return MAL_SUCCEED;
5575 : }
5576 :
5577 : static str
5578 10 : SQLdecypher(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5579 : {
5580 10 : mvc *m = NULL;
5581 10 : str msg = NULL;
5582 10 : str *pwhash = getArgReference_str(stk, pci, 0);
5583 10 : const char *cypher = *getArgReference_str(stk, pci, 1);
5584 :
5585 10 : (void) pwhash;
5586 :
5587 10 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5588 : return msg;
5589 10 : if ((msg = checkSQLContext(cntxt)) != NULL)
5590 : return msg;
5591 10 : return AUTHdecypherValue(pwhash, cypher);
5592 : }
5593 :
5594 : static str
5595 50 : SQLcheck(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5596 : {
5597 50 : mvc *m = NULL;
5598 50 : str msg = NULL;
5599 50 : str *r = getArgReference_str(stk, pci, 0);
5600 50 : const char *sname = *getArgReference_str(stk, pci, 1);
5601 50 : const char *kname = *getArgReference_str(stk, pci, 2);
5602 :
5603 50 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5604 : return msg;
5605 50 : if ((msg = checkSQLContext(cntxt)) != NULL)
5606 : return msg;
5607 50 : (void)sname;
5608 50 : sql_schema *s = mvc_bind_schema(m, sname);
5609 50 : if (s) {
5610 50 : sql_key *k = mvc_bind_key(m, s, kname);
5611 50 : if (k && k->check) {
5612 7 : int pos = 0;
5613 7 : sql_rel *rel = rel_basetable(m, k->t, a_create(m->sa, k->t->base.name));
5614 7 : sql_exp *exp = exp_read(m, rel, NULL, NULL, sa_strdup(m->sa, k->check), &pos, 0);
5615 7 : if (exp->comment)
5616 7 : *r = GDKstrdup(exp->comment);
5617 : else
5618 0 : *r = GDKstrdup(exp2sql(m, exp));
5619 7 : if (*r == NULL)
5620 0 : throw(SQL, "SQLcheck", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5621 : return MAL_SUCCEED;
5622 : }
5623 : }
5624 43 : if (!(*r = GDKstrdup(str_nil)))
5625 0 : throw(SQL, "SQLcheck", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5626 : return MAL_SUCCEED;
5627 : }
5628 :
5629 : static str
5630 6 : SQLread_dump_rel(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5631 : {
5632 6 : mvc *m = NULL;
5633 6 : str msg = NULL;
5634 6 : buffer *b = NULL;
5635 6 : stream *s = NULL;
5636 6 : char *res = NULL;
5637 6 : str *r = getArgReference_str(stk, pci, 0);
5638 6 : char *input = *getArgReference_str(stk, pci, 1);
5639 :
5640 6 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5641 : return msg;
5642 6 : if ((msg = checkSQLContext(cntxt)) != NULL)
5643 : return msg;
5644 :
5645 6 : list *refs = sa_list(m->sa);
5646 6 : if (refs == NULL)
5647 0 : goto bailout;
5648 :
5649 6 : int pos = 0;
5650 6 : sql_rel* rel = rel_read(m, input, &pos, refs);
5651 6 : if (!rel)
5652 0 : throw(SQL, "SQLread_dump_rel", SQLSTATE(42000) "failed to read relational plan");
5653 :
5654 6 : b = buffer_create(1024);
5655 6 : if(b == NULL)
5656 0 : goto bailout;
5657 6 : s = buffer_wastream(b, "exp_dump");
5658 6 : if(s == NULL)
5659 0 : goto bailout;
5660 :
5661 6 : refs = sa_list(m->sa);
5662 6 : if (refs == NULL)
5663 0 : goto bailout;
5664 :
5665 6 : rel_print_refs(m, s, rel, 0, refs, 0);
5666 6 : rel_print_(m, s, rel, 0, refs, 0);
5667 6 : res = buffer_get_buf(b);
5668 :
5669 6 : if (res == NULL)
5670 0 : goto bailout;
5671 6 : if (!(*r = GDKstrdup(res)))
5672 0 : goto bailout;
5673 :
5674 6 : free(res);
5675 6 : close_stream(s);
5676 6 : buffer_destroy(b);
5677 6 : return MAL_SUCCEED;
5678 :
5679 0 : bailout:
5680 0 : if (res)
5681 0 : free(res);
5682 0 : if (s)
5683 0 : mnstr_destroy(s);
5684 0 : if (b)
5685 0 : buffer_destroy(b);
5686 0 : throw(SQL, "SQLread_dump_rel", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5687 : }
5688 :
5689 : static str
5690 4 : SQLnormalize_monetdb_url(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5691 : {
5692 4 : (void)mb;
5693 4 : str *ret = getArgReference_str(stk, pci, 0);
5694 4 : str url = *getArgReference_str(stk, pci, 1);
5695 4 : allocator *sa;
5696 4 : backend *be = NULL;
5697 4 : str msg;
5698 4 : msettings_error err;
5699 4 : str normalized;
5700 :
5701 4 : if (strNil(url))
5702 0 : throw(MAL, "SQLnormalize_monetdb_url", SQLSTATE(42000) "url cannot be nil");
5703 :
5704 4 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
5705 : return msg;
5706 4 : sa = be->mvc->sa;
5707 :
5708 4 : msettings *mp = sa_msettings_create(sa);
5709 4 : if (mp == NULL)
5710 0 : throw(SQL, "SQLnormalize_monetdb_url", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5711 :
5712 4 : err = msettings_parse_url(mp, url);
5713 4 : if (err != NULL)
5714 0 : throw(SQL, "SQLnormalize_monetdb_url", SQLSTATE(42000) "Invalid URL: %s", err);
5715 :
5716 4 : normalized = sa_msettings_to_string(mp, sa, strlen(url));
5717 4 : if (normalized == NULL)
5718 0 : throw(SQL, "SQLnormalize_monetdb_url", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5719 :
5720 4 : *ret = _STRDUP(normalized);
5721 :
5722 4 : return MAL_SUCCEED;
5723 : }
5724 :
5725 : static str
5726 0 : SQLto_json(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5727 : {
5728 0 : (void)cntxt;
5729 0 : (void)mb;
5730 0 : str *res = (str*)getArgReference(stk, pci, 0);
5731 0 : sql_subtype *ft = *(sql_subtype**)getArgReference(stk, pci, pci->retc);
5732 :
5733 0 : if (!ft->type->composite && !ft->multiset) {
5734 0 : throw(SQL, "SQLto_json", SQLSTATE(42000) "Invalid sql type: %s", ft->type->base.name);
5735 : }
5736 0 : *res = GDKstrdup("");
5737 0 : return MAL_SUCCEED;
5738 : }
5739 :
5740 : static int insert_json_object(char **msg, JSON *js, BAT **bats, int *BO, int nr, int elm, sql_subtype *t);
5741 : static int insert_json_array(char **msg, JSON *js, BAT **bats, int *BO, int nr, int elm, sql_subtype *t);
5742 :
5743 : static ValPtr
5744 138 : jsonv2local(const ValPtr t, char *v)
5745 : {
5746 : // TODO add remaining types
5747 138 : switch (t->vtype) {
5748 : case TYPE_int: /* todo handle extra double quotes */
5749 24 : t->val.ival = atoi(v);
5750 24 : break;
5751 10 : case TYPE_lng:
5752 10 : t->val.lval = (lng) strtol(v, NULL, 10);
5753 10 : break;
5754 0 : case TYPE_flt:
5755 0 : t->val.fval = (flt) strtod(v, NULL);
5756 0 : break;
5757 0 : case TYPE_dbl:
5758 0 : t->val.dval = strtod(v, NULL);
5759 0 : break;
5760 104 : case TYPE_str:
5761 104 : t->val.sval = _STRDUP(v);
5762 104 : break;
5763 0 : case TYPE_timestamp:
5764 0 : sql_timestamp_fromstr(v, &t->val.lval, 0, 0);
5765 0 : break;
5766 : default:
5767 : return NULL;
5768 : }
5769 : return t;
5770 : }
5771 :
5772 : static str
5773 138 : insert_json_value(JSONterm *jt, sql_subtype *t, BAT *b)
5774 : {
5775 138 : char *msg = MAL_SUCCEED;
5776 138 : size_t vsize = jt->valuelen;
5777 138 : char *val = (char *)jt->value;
5778 :
5779 138 : ValPtr v = NULL;
5780 138 : ValRecord vr = (ValRecord) {.bat=false, .vtype=t->type->localtype};
5781 138 : if (t->type->localtype == ATOMindex("json"))
5782 10 : vr.vtype = TYPE_str;
5783 138 : char eos = val[vsize];
5784 138 : val[vsize] = '\0';
5785 138 : v = jsonv2local(&vr, val);
5786 138 : val[vsize] = eos;
5787 138 : if (v) {
5788 138 : if (BUNappend(b, VALget(v), false) != GDK_SUCCEED)
5789 0 : msg = createException(SQL, "sql.insert_json_value", "BUNappend failed");
5790 : } else {
5791 0 : msg = createException(SQL, "sql.insert_json_value", "jsonv2local failed");
5792 : }
5793 138 : return msg;
5794 : }
5795 :
5796 : static sql_subtype*
5797 176 : find_subtype_field(sql_subtype *t, const char *kname, size_t klen)
5798 : {
5799 176 : sql_subtype *nt = NULL;
5800 426 : for(node *n = t->type->d.fields->h; n; n = n->next) {
5801 426 : sql_arg *a = n->data;
5802 426 : size_t alen = strlen(a->name);
5803 426 : if (klen == alen && strncmp(kname, a->name, klen) == 0) {
5804 176 : nt = &a->type;
5805 176 : break;
5806 : }
5807 : }
5808 176 : return nt;
5809 : }
5810 :
5811 : static int
5812 64 : insert_json_object(char **msg, JSON *js, BAT **bats, int *BO, int nr, int elm, sql_subtype *t)
5813 : {
5814 64 : int bat_offset = *BO;
5815 64 : JSONterm *ja = js->elm+elm;
5816 64 : if (ja->kind != JSON_OBJECT || !t->type->composite) {
5817 0 : *msg = "missing object start";
5818 0 : return -1;
5819 : }
5820 64 : const char *name = NULL;
5821 64 : int nlen = 0;
5822 : /* TODO check if full object is there */
5823 416 : for (elm++; elm > 0 && elm <= ja->tail+1; elm++) {
5824 352 : JSONterm *jt = js->elm+elm;
5825 :
5826 352 : if (bat_offset > nr)
5827 : return -10;
5828 352 : switch (jt->kind) {
5829 40 : case JSON_OBJECT:
5830 40 : if (name && nlen) {
5831 40 : sql_subtype *nt = find_subtype_field(t, name, nlen);
5832 40 : if (nt && nt->type->composite)
5833 30 : elm = insert_json_object(msg, js, bats, &bat_offset, nr, elm, nt);
5834 10 : else if (nt && nt->type->localtype == ATOMindex("json")){
5835 : // json string value
5836 10 : if ((*msg = insert_json_value(jt, nt, bats[bat_offset])) != MAL_SUCCEED)
5837 : return -1;
5838 : // set term offset
5839 10 : elm = ((jt - 1)->next) - 1; // ? is this right
5840 10 : bat_offset ++;
5841 : } else {
5842 0 : assert(0);
5843 : }
5844 : } else {
5845 0 : assert(0);
5846 : }
5847 : break;
5848 8 : case JSON_ARRAY:
5849 : /* TODO get id for nested array from the a global struct */
5850 8 : if (name && nlen) {
5851 : // find subtype matching field
5852 8 : sql_subtype *nt = find_subtype_field(t, name, nlen);
5853 8 : if(nt && nt->multiset)
5854 8 : elm = insert_json_array(msg, js, bats, &bat_offset, nr, elm, nt);
5855 0 : else if (nt && nt->type->localtype == ATOMindex("json")) {
5856 : // json string value
5857 0 : if ((*msg = insert_json_value(jt, nt, bats[bat_offset])) != MAL_SUCCEED)
5858 : return -1;
5859 : // set term offset
5860 0 : elm = ((jt - 1)->next) - 1; // ? is this right
5861 0 : bat_offset ++;
5862 : } else {
5863 0 : assert(0);
5864 : }
5865 : } else {
5866 0 : assert(0);
5867 : }
5868 : break;
5869 176 : case JSON_ELEMENT: // field
5870 176 : name = jt->value;
5871 176 : nlen = (int)jt->valuelen;
5872 176 : break;
5873 : case JSON_VALUE:
5874 : break;
5875 94 : case JSON_STRING:
5876 94 : jt->value ++;
5877 94 : jt->valuelen --;
5878 94 : jt->valuelen --;
5879 : /* fall through */
5880 128 : case JSON_NUMBER:
5881 : case JSON_BOOL:
5882 : case JSON_NULL:
5883 128 : if (name && nlen) {
5884 128 : sql_subtype *nt = find_subtype_field(t, name, nlen);
5885 128 : if (nt) {
5886 128 : if ((*msg = insert_json_value(jt, nt, bats[bat_offset])) != MAL_SUCCEED)
5887 : return -1;
5888 128 : bat_offset ++;
5889 : } else {
5890 0 : *msg = "field name missing";
5891 0 : return -1;
5892 : }
5893 : }
5894 : }
5895 : }
5896 64 : if (bat_offset > nr)
5897 : return -10;
5898 64 : *BO = bat_offset;
5899 64 : return elm;
5900 : }
5901 :
5902 : static int
5903 8 : insert_json_array(char **msg, JSON *js, BAT **bats, int *BO, int nr, int elm, sql_subtype *t)
5904 : {
5905 8 : int old_bat_offset = *BO, bat_offset = *BO;
5906 8 : JSONterm *ja = js->elm+elm;
5907 8 : int tail = ja->tail;
5908 8 : if (ja->kind != JSON_ARRAY) {
5909 0 : *msg = "missing array start";
5910 0 : return -1;
5911 : }
5912 8 : int id = 0, anr = 1;
5913 24 : for (; elm < tail; elm=ja->next) { /* array begin, comma, end */
5914 16 : ja = js->elm+elm;
5915 16 : if (bat_offset > nr)
5916 : return -10;
5917 32 : for (elm++; elm >0 && elm < ja->next; ) {
5918 16 : JSONterm *jt = js->elm+elm;
5919 16 : switch (jt->kind) {
5920 16 : case JSON_OBJECT:
5921 16 : bat_offset = old_bat_offset;
5922 16 : sql_subtype *nt = t;
5923 16 : elm = insert_json_object(msg, js, bats, &bat_offset, nr, elm, nt);
5924 16 : if (nt->multiset) {
5925 16 : id = (int)BATcount(bats[bat_offset + (nt->multiset == MS_ARRAY?2:1)]);
5926 16 : if (elm > 0 && BUNappend(bats[bat_offset++], &id, false) != GDK_SUCCEED)
5927 : elm = -3;
5928 16 : if (elm > 0 && nt->multiset == MS_ARRAY && BUNappend(bats[bat_offset++], &anr, false) != GDK_SUCCEED)
5929 0 : elm = -3;
5930 16 : anr++;
5931 : }
5932 : break;
5933 0 : default:
5934 0 : printf("todo\n");
5935 : }
5936 : }
5937 16 : if (elm < 0)
5938 : break;
5939 : }
5940 8 : if (bat_offset > nr)
5941 : return -10;
5942 8 : if (elm > 0 && anr > 1 && BUNappend(bats[bat_offset++], &id, false) != GDK_SUCCEED)
5943 8 : elm = -2;
5944 8 : *BO = bat_offset;
5945 8 : return elm-1;//+1;
5946 : }
5947 :
5948 : static str
5949 18 : insert_json_str(const char *jstr, BAT **bats, int cnt, sql_subtype *t)
5950 : {
5951 18 : char *res = MAL_SUCCEED;
5952 18 : JSON *js = JSONparse(jstr);
5953 18 : if (!js)
5954 0 : throw(SQL, "insert_json_str", "JSONparse error");
5955 18 : int bat_offset = 0;
5956 18 : if (t->multiset)
5957 0 : (void)insert_json_array(&res, js, bats, &bat_offset, cnt, 0, t);
5958 : else
5959 18 : (void)insert_json_object(&res, js, bats, &bat_offset, cnt, 0, t);
5960 18 : JSONfree(js);
5961 18 : return res;
5962 : }
5963 :
5964 : static str
5965 7 : SQLfrom_json(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5966 : {
5967 7 : str msg = NULL;
5968 7 : mvc *m = NULL;
5969 7 : char *sqlstate = NULL;
5970 :
5971 7 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5972 : return msg;
5973 7 : if ((msg = checkSQLContext(cntxt)) != NULL)
5974 : return msg;
5975 7 : int mtype = getArgType(mb, pci, pci->retc);
5976 7 : sql_subtype *t = *(sql_subtype**)getArgReference(stk, pci, pci->retc+1);
5977 :
5978 7 : BAT **bats = (BAT**)GDKzalloc(sizeof(BAT*) * pci->retc);
5979 7 : if (!bats)
5980 0 : throw(SQL, "SQLfrom_json", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5981 58 : for(int i = 0; i < pci->retc; i++) {
5982 51 : bats[i] = COLnew(0, getBatType(getArgType(mb, pci, i)), 10, TRANSIENT);
5983 51 : if (!bats[i])
5984 0 : goto bailout;
5985 : }
5986 :
5987 7 : (void)m;
5988 :
5989 7 : if (isaBatType(mtype)) {
5990 3 : if(strcmp(BATatoms[getBatType(mtype)].name, "json") != 0 ) {
5991 0 : msg ="Incorrect bat argument type";
5992 0 : sqlstate = SQLSTATE(HY013);
5993 0 : goto bailout;
5994 : }
5995 3 : bat bid = *getArgReference_bat(stk, pci, pci->retc);
5996 3 : BAT *b = BATdescriptor(bid);
5997 3 : BATiter bi = bat_iterator(b);
5998 3 : BUN p, q;
5999 17 : BATloop(b, p, q) {
6000 14 : const char *json = (const char *) BUNtail(bi, p);
6001 14 : if ((msg = insert_json_str(json, bats, pci->retc, t)) != MAL_SUCCEED) {
6002 0 : bat_iterator_end(&bi);
6003 0 : BBPreclaim(b);
6004 0 : goto bailout;
6005 : }
6006 : }
6007 3 : bat_iterator_end(&bi);
6008 3 : BBPreclaim(b);
6009 : } else {
6010 4 : if (strcmp(BATatoms[mtype].name, "json") != 0) {
6011 0 : msg = "Incorrect argument type";
6012 0 : sqlstate = SQLSTATE(HY013);
6013 0 : goto bailout;
6014 : }
6015 4 : str json = *(str*)getArgReference(stk, pci, pci->retc);
6016 4 : if ((msg = insert_json_str(json, bats, pci->retc, t)) != MAL_SUCCEED)
6017 0 : goto bailout;
6018 : }
6019 :
6020 58 : for(int i = 0; i < pci->retc && bats[i]; i++) {
6021 51 : *getArgReference_bat(stk, pci, i) = bats[i]->batCacheid;
6022 51 : BBPkeepref(bats[i]);
6023 : }
6024 7 : GDKfree(bats);
6025 7 : return MAL_SUCCEED;
6026 0 : bailout:
6027 0 : for(int i = 0; i < pci->retc; i++)
6028 0 : if (bats[i])
6029 0 : BBPreclaim(bats[i]);
6030 0 : GDKfree(bats);
6031 0 : if (msg) {
6032 0 : if (sqlstate)
6033 0 : throw(SQL, "SQLfrom_json", SQLSTATE(HY013) "%s", msg);
6034 0 : throw(SQL, "SQLfrom_json", SQLSTATE(42000) "%s", msg);
6035 : }
6036 0 : throw(SQL, "SQLfrom_json", SQLSTATE(HY013) MAL_MALLOC_FAIL);
6037 : }
6038 :
6039 : static str
6040 20 : SQLfrom_varchar(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
6041 : {
6042 20 : str msg = NULL;
6043 20 : mvc *m = NULL;
6044 :
6045 20 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
6046 : return msg;
6047 20 : if ((msg = checkSQLContext(cntxt)) != NULL)
6048 : return msg;
6049 :
6050 20 : int mtype = getArgType(mb, pci, pci->retc);
6051 20 : if (mtype != TYPE_str)
6052 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(HY013) "Incorrect argument type");
6053 20 : str s = *(str*)getArgReference(stk, pci, pci->retc);
6054 20 : sql_subtype *t = *(sql_subtype**)getArgReference(stk, pci, pci->retc+1);
6055 :
6056 20 : BAT **bats = (BAT**)GDKzalloc(sizeof(BAT*) * pci->retc);
6057 20 : if (!bats)
6058 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(HY013) MAL_MALLOC_FAIL);
6059 118 : for(int i = 0; i < pci->retc; i++) {
6060 98 : bats[i] = COLnew(0, getBatType(getArgType(mb, pci, i)), 10, TRANSIENT);
6061 98 : if (!bats[i])
6062 0 : goto bailout;
6063 : }
6064 20 : msg = mvc_from_string(m, bats, pci->retc, s, t);
6065 20 : if (msg)
6066 0 : goto bailout;
6067 118 : for(int i = 0; i < pci->retc && bats[i]; i++) {
6068 98 : *getArgReference_bat(stk, pci, i) = bats[i]->batCacheid;
6069 98 : BBPkeepref(bats[i]);
6070 : }
6071 20 : GDKfree(bats);
6072 20 : return MAL_SUCCEED;
6073 0 : bailout:
6074 0 : for(int i = 0; i < pci->retc && bats[i]; i++)
6075 0 : BBPreclaim(bats[i]);
6076 0 : GDKfree(bats);
6077 0 : if (msg)
6078 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(42000) "%s", msg);
6079 0 : throw(SQL, "SQLfrom_varchar", SQLSTATE(HY013) MAL_MALLOC_FAIL);
6080 : }
6081 :
6082 : static mel_func sql_init_funcs[] = {
6083 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,3, arg("",str),arg("delay",bte),arg("force",bit))),
6084 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,3, arg("",str),arg("delay",sht),arg("force",bit))),
6085 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,3, arg("",str),arg("delay",int),arg("force",bit))),
6086 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,2, arg("",str),arg("delay",bte))),
6087 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,2, arg("",str),arg("delay",sht))),
6088 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,2, arg("",str),arg("delay",int))),
6089 : pattern("sql", "set_protocol", SQLset_protocol, true, "Configures the result set protocol", args(1,2, arg("",int), arg("protocol",int))),
6090 : pattern("sql", "mvc", SQLmvc, false, "Get the multiversion catalog context. \nNeeded for correct statement dependencies\n(ie sql.update, should be after sql.bind in concurrent execution)", args(1,1, arg("",int))),
6091 : pattern("sql", "eval", SQLstatement, true, "Compile and execute a single sql statement", args(1,2, arg("",void),arg("cmd",str))),
6092 : pattern("sql", "eval", SQLstatement, true, "Compile and execute a single sql statement (and optionally set the output to columnar format)", args(1,3, arg("",void),arg("cmd",str),arg("columnar",bit))),
6093 : pattern("sql", "include", SQLinclude, true, "Compile and execute a sql statements on the file", args(1,2, arg("",void),arg("fname",str))),
6094 : pattern("sql", "evalAlgebra", RAstatement, true, "Compile and execute a single 'relational algebra' statement", args(1,3, arg("",void),arg("cmd",str),arg("optimize",bit))),
6095 : pattern("sql", "register", RAstatement2, true, "", args(1,5, arg("",int),arg("mod",str),arg("fname",str),arg("rel_stmt",str),arg("sig",str))),
6096 : pattern("sql", "register", RAstatement2, true, "Compile the relational statement (rel_smt) and register it as mal function, mod.fname(signature)", args(1,6, arg("",int),arg("mod",str),arg("fname",str),arg("rel_stmt",str),arg("sig",str),arg("typ",str))),
6097 : pattern("sql", "deregister", RAstatementEnd, true, "Finish running transaction", args(1,1, arg("",int))),
6098 : pattern("sql", "hot_snapshot", SQLhot_snapshot, true, "Write db snapshot to the given tar(.gz) file", args(1,2, arg("",void),arg("tarfile",str))),
6099 : pattern("sql", "resume_log_flushing", SQLresume_log_flushing, true, "Resume WAL log flushing", args(1,1, arg("",void))),
6100 : pattern("sql", "suspend_log_flushing", SQLsuspend_log_flushing, true, "Suspend WAL log flushing", args(1,1, arg("",void))),
6101 : pattern("sql", "hot_snapshot", SQLhot_snapshot, true, "Write db snapshot to the given tar(.gz/.lz4/.bz/.xz) file on either server or client", args(1,3, arg("",void),arg("tarfile", str),arg("onserver",bit))),
6102 : pattern("sql", "persist_unlogged", SQLpersist_unlogged, true, "Persist deltas on append only table in schema s table t", args(3, 5, batarg("table", str), batarg("table_id", int), batarg("rowcount", lng), arg("s", str), arg("t", str))),
6103 : pattern("sql", "assert", SQLassert, false, "Generate an exception when b==true", args(1,3, arg("",void),arg("b",bit),arg("msg",str))),
6104 : pattern("sql", "assert", SQLassertInt, false, "Generate an exception when b!=0", args(1,3, arg("",void),arg("b",int),arg("msg",str))),
6105 : pattern("sql", "assert", SQLassertLng, false, "Generate an exception when b!=0", args(1,3, arg("",void),arg("b",lng),arg("msg",str))),
6106 : pattern("sql", "setVariable", setVariable, true, "Set the value of a session variable", args(1,5, arg("",int),arg("mvc",int),arg("sname",str),arg("varname",str),argany("value",1))),
6107 : pattern("sql", "getVariable", getVariable, false, "Get the value of a session variable", args(1,4, argany("",1),arg("mvc",int),arg("sname",str),arg("varname",str))),
6108 : pattern("sql", "logfile", mvc_logfile, true, "Enable/disable saving the sql statement traces", args(1,2, arg("",void),arg("filename",str))),
6109 : //pattern("batsql", "renumber", mvc_renumber_bulk, false, "return the input b renumbered using values from base", args(1,6, batarg("res",int),batarg("input",int),batarg("mapping_oid",int),batarg("mapping_nid",int),batarg("s1",oid),batarg("s2",oid),batarg("s3",oid))),
6110 : pattern("batsql", "renumber", mvc_renumber_bulk, false, "return the input b renumbered using values from base", args(1,4, batarg("res",int),batarg("input",int),batarg("mapping_oid",int),batarg("mapping_nid",int))),
6111 : pattern("sql", "renumber", mvc_renumber, false, "return the input b renumbered using values from base", args(1,4, arg("res",int),arg("input",int),arg("mapping_oid",int),arg("mapping_nid",int))),
6112 : pattern("sql", "next_value", mvc_next_value, true, "return the next value of the sequence", args(1,3, arg("",lng),arg("sname",str),arg("sequence",str))),
6113 : pattern("sql", "next_value_ms", mvc_next_value, false, "return the next value of the sequence", args(1,4, arg("",lng),argany("card",1), arg("sname",str),arg("sequence",str))),
6114 : pattern("batsql", "next_value", mvc_next_value_bulk, true, "return the next value of the sequence", args(1,4, batarg("",lng),arg("card",lng), arg("sname",str),arg("sequence",str))),
6115 : pattern("batsql", "next_value_ms", mvc_next_value_bulk, false, "return the next value of the sequence", args(1,4, batarg("",lng),batargany("card",1), arg("sname",str),arg("sequence",str))),
6116 : //pattern("batsql", "next_value_ms", mvc_next_value_bulk, false, "return the next value of the sequence", args(1,5, batarg("",lng),batargany("card",1), arg("sname",str),arg("sequence",str), batarg("cand",oid))),
6117 : pattern("sql", "get_value", mvc_get_value, false, "return the current value of the sequence (ie the next to be used value)", args(1,3, arg("",lng),arg("sname",str),arg("sequence",str))),
6118 : pattern("batsql", "get_value", mvc_get_value_bulk, false, "return the current value of the sequence (ie the next to be used value)", args(1,3, batarg("",lng),batarg("sname",str),batarg("sequence",str))),
6119 : pattern("batsql", "get_value", mvc_get_value_bulk, false, "return the current value of the sequence (ie the next to be used value)", args(1,5, batarg("",lng),batarg("sname",str),batarg("sequence",str),batarg("s1",oid),batarg("s2",oid))),
6120 : pattern("sql", "restart", mvc_restart_seq, true, "restart the sequence with value start", args(1,4, arg("",lng),arg("sname",str),arg("sequence",str),arg("start",lng))),
6121 : pattern("sql", "deltas", mvc_delta_values, false, "Return the delta values sizes of all columns of the schema's tables, plus the current transaction level", args(7,8, batarg("ids",int),batarg("segments",lng),batarg("all",lng),batarg("inserted",lng),batarg("updated",lng),batarg("deleted",lng),batarg("tr_level",int),arg("schema",str))),
6122 : pattern("sql", "deltas", mvc_delta_values, false, "Return the delta values sizes from the table's columns, plus the current transaction level", args(7,9, batarg("ids",int),batarg("segments",lng),batarg("all",lng),batarg("inserted",lng),batarg("updated",lng),batarg("deleted",lng),batarg("tr_level",int),arg("schema",str),arg("table",str))),
6123 : pattern("sql", "deltas", mvc_delta_values, false, "Return the delta values sizes of a column, plus the current transaction level", args(7,10, batarg("ids",int),batarg("segments",lng),batarg("all",lng),batarg("inserted",lng),batarg("updated",lng),batarg("deleted",lng),batarg("tr_level",int),arg("schema",str),arg("table",str),arg("column",str))),
6124 : pattern("sql", "emptybindidx", mvc_bind_idxbat_wrap, false, "", args(1,6, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("index",str),arg("access",int))),
6125 : pattern("sql", "bind_idxbat", mvc_bind_idxbat_wrap, false, "Bind the 'schema.table.index' BAT with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(1,6, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("index",str),arg("access",int))),
6126 : pattern("sql", "emptybindidx", mvc_bind_idxbat_wrap, false, "", args(2,7, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("index",str),arg("access",int))),
6127 : pattern("sql", "bind_idxbat", mvc_bind_idxbat_wrap, false, "Bind the 'schema.table.index' BAT with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(2,7, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("index",str),arg("access",int))),
6128 : pattern("sql", "emptybindidx", mvc_bind_idxbat_wrap, false, "", args(1,8, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("index",str),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6129 : pattern("sql", "bind_idxbat", mvc_bind_idxbat_wrap, false, "Bind the 'schema.table.index' BAT with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(1,8, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("index",str),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6130 : pattern("sql", "emptybindidx", mvc_bind_idxbat_wrap, false, "", args(2,9, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("index",str),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6131 : pattern("sql", "bind_idxbat", mvc_bind_idxbat_wrap, false, "Bind the 'schema.table.index' BAT with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(2,9, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("index",str),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6132 :
6133 : pattern("sql", "emptybind", mvc_bind_wrap, false, "", args(1,6, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",str),arg("access",int))),
6134 : pattern("sql", "bind", mvc_bind_wrap, false, "Bind the 'schema.table.column' BAT with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(1,6, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",str),arg("access",int))),
6135 : pattern("sql", "emptybind", mvc_bind_wrap, false, "", args(2,7, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",str),arg("access",int))),
6136 : pattern("sql", "bind", mvc_bind_wrap, false, "Bind the 'schema.table.column' BAT with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(2,7, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",str),arg("access",int))),
6137 : pattern("sql", "emptybind", mvc_bind_wrap, false, "", args(1,8, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",str),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6138 : pattern("sql", "bind", mvc_bind_wrap, false, "Bind the 'schema.table.column' BAT partition with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(1,8, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",str),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6139 : pattern("sql", "emptybind", mvc_bind_wrap, false, "", args(2,9, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",str),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6140 : pattern("sql", "bind", mvc_bind_wrap, false, "Bind the 'schema.table.column' BAT with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(2,9, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",str),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6141 :
6142 : pattern("sql", "emptybind", mvc_bind_wrap, false, "", args(1,6, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",int),arg("access",int))),
6143 : pattern("sql", "bind", mvc_bind_wrap, false, "Bind the 'schema.table.column' BAT with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(1,6, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",int),arg("access",int))),
6144 : pattern("sql", "emptybind", mvc_bind_wrap, false, "", args(2,7, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",int),arg("access",int))),
6145 : pattern("sql", "bind", mvc_bind_wrap, false, "Bind the 'schema.table.column' BAT with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(2,7, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",int),arg("access",int))),
6146 : pattern("sql", "emptybind", mvc_bind_wrap, false, "", args(1,8, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",int),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6147 : pattern("sql", "bind", mvc_bind_wrap, false, "Bind the 'schema.table.column' BAT partition with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(1,8, batargany("",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",int),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6148 : pattern("sql", "emptybind", mvc_bind_wrap, false, "", args(2,9, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",int),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6149 : pattern("sql", "bind", mvc_bind_wrap, false, "Bind the 'schema.table.column' BAT with access kind:\n0 - base table\n1 - inserts\n2 - updates", args(2,9, batarg("uid",oid),batargany("uval",1),arg("mvc",int),arg("schema",str),arg("table",str),arg("column",int),arg("access",int),arg("part_nr",int),arg("nr_parts",int))),
6150 :
6151 : command("sql", "delta", DELTAbat, false, "Return column bat with delta's applied.", args(1,4, batargany("",1),batargany("col",1),batarg("uid",oid),batargany("uval",1))),
6152 : command("sql", "projectdelta", DELTAproject, false, "Return column bat with delta's applied.", args(1,5, batargany("",1),batarg("select",oid),batargany("col",1),batarg("uid",oid),batargany("uval",1))),
6153 : command("sql", "subdelta", DELTAsub, false, "Return a single bat of selected delta.", args(1,5, batarg("",oid),batarg("col",oid),batarg("cand",oid),batarg("uid",oid),batarg("uval",oid))),
6154 : command("sql", "project", BATleftproject, false, "Last step of a left outer join, ie project the inner join (l,r) over the left input side (col)", args(1,4, batarg("",oid),batarg("col",oid),batarg("l",oid),batarg("r",oid))),
6155 : command("sql", "getVersion", mvc_getVersion, false, "Return the database version identifier for a client.", args(1,2, arg("",lng),arg("clientid",int))),
6156 : pattern("sql", "grow", mvc_grow_wrap, false, "Resize the tid column of a declared table.", args(1,3, arg("",int),batarg("tid",oid),argany("",1))),
6157 : pattern("sql", "claim", mvc_claim_wrap, true, "Claims slots for appending rows.", args(2,6, arg("",oid),batarg("",oid),arg("mvc",int),arg("sname",str),arg("tname",str),arg("cnt",lng))),
6158 : pattern("sql", "depend", mvc_add_dependency_change, true, "Set dml dependency on current transaction for a table.", args(0,3, arg("sname",str),arg("tname",str),arg("cnt",lng))),
6159 : pattern("sql", "predicate", mvc_add_column_predicate, true, "Add predicate on current transaction for a table column.", args(0,3, arg("sname",str),arg("tname",str),arg("cname",str))),
6160 : pattern("sql", "append", mvc_append_wrap, false, "Append to the column tname.cname (possibly optimized to replace the insert bat of tname.cname. Returns sequence number for order dependence.", args(1,8, arg("",int), arg("mvc",int),arg("sname",str),arg("tname",str),arg("cname",str),arg("offset",oid),batarg("pos",oid),argany("ins",0))),
6161 : pattern("sql", "append", mvc_append_wrap, false, "Append to the column tname.col_id (possibly optimized to replace the insert bat of tname.col_id. Returns sequence number for order dependence.", args(1,8, arg("",int), arg("mvc",int),arg("sname",str),arg("tname",str),arg("col_id",int),arg("offset",oid),batarg("pos",oid),argany("ins",0))),
6162 : pattern("sql", "update", mvc_update_wrap, false, "Update the values of the column tname.cname. Returns sequence number for order dependence)", args(1,7, arg("",int), arg("mvc",int),arg("sname",str),arg("tname",str),arg("cname",str),argany("rids",0),argany("upd",0))),
6163 : pattern("sql", "clear_table", mvc_clear_table_wrap, true, "Clear the table sname.tname.", args(1,4, arg("",lng),arg("sname",str),arg("tname",str),arg("restart_sequences",int))),
6164 : pattern("sql", "tid", SQLtid, false, "Return a column with the valid tuple identifiers associated with the table sname.tname.", args(1,4, batarg("",oid),arg("mvc",int),arg("sname",str),arg("tname",str))),
6165 : pattern("sql", "tid", SQLtid, false, "Return the tables tid column.", args(1,6, batarg("",oid),arg("mvc",int),arg("sname",str),arg("tname",str),arg("part_nr",int),arg("nr_parts",int))),
6166 : pattern("sql", "delete", mvc_delete_wrap, true, "Delete a row from a table. Returns sequence number for order dependence.", args(1,5, arg("",int),arg("mvc",int),arg("sname",str),arg("tname",str),argany("b",0))),
6167 : pattern("sql", "resultSet", mvc_scalar_value_wrap, true, "Prepare a table result set for the client front-end.", args(1,9, arg("",int),arg("tbl",str),arg("attr",str),arg("tpe",str),arg("len",int),arg("scale",int),arg("eclass",int),arg("multiset",int),argany("val",0))),
6168 : pattern("sql", "resultSet", mvc_row_result_wrap, true, "Prepare a table result set for the client front-end", args(1,8, arg("",int),batarg("tbl",str),batarg("attr",str),batarg("tpe",str),batarg("len",int),batarg("scale",int),batarg("multiset",int),varargany("cols",0))),
6169 : pattern("sql", "resultSet", mvc_result_set_wrap, true, "Prepare a table result set for the client in default CSV format", args(1,8, arg("",int),batarg("tbl",str),batarg("attr",str),batarg("tpe",str),batarg("len",int),batarg("scale",int),batarg("multiset",int),batvarargany("cols",0))),
6170 : pattern("sql", "export_table", mvc_export_row_wrap, true, "Prepare a table result set for the COPY INTO stream", args(1,14, arg("",int),arg("fname",str),arg("fmt",str),arg("colsep",str),arg("recsep",str),arg("qout",str),arg("nullrep",str),arg("onclient",int),batarg("tbl",str),batarg("attr",str),batarg("tpe",str),batarg("len",int),batarg("scale",int),varargany("cols",0))),
6171 : pattern("sql", "export_table", mvc_export_table_wrap, true, "Prepare a table result set for the COPY INTO stream", args(1,14, arg("",int),arg("fname",str),arg("fmt",str),arg("colsep",str),arg("recsep",str),arg("qout",str),arg("nullrep",str),arg("onclient",int),batarg("tbl",str),batarg("attr",str),batarg("tpe",str),batarg("len",int),batarg("scale",int),batvarargany("cols",0))),
6172 : pattern("sql", "exportHead", mvc_export_head_wrap, true, "Export a result (in order) to stream s", args(1,3, arg("",void),arg("s",streams),arg("res_id",int))),
6173 : pattern("sql", "exportResult", mvc_export_result_wrap, true, "Export a result (in order) to stream s", args(1,3, arg("",void),arg("s",streams),arg("res_id",int))),
6174 : pattern("sql", "exportChunk", mvc_export_chunk_wrap, true, "Export a chunk of the result set (in order) to stream s", args(1,3, arg("",void),arg("s",streams),arg("res_id",int))),
6175 : pattern("sql", "exportChunk", mvc_export_chunk_wrap, true, "Export a chunk of the result set (in order) to stream s", args(1,5, arg("",void),arg("s",streams),arg("res_id",int),arg("offset",int),arg("nr",int))),
6176 : pattern("sql", "exportOperation", mvc_export_operation_wrap, true, "Export result of schema/transaction queries", args(1,1, arg("",void))),
6177 : pattern("sql", "export_bin_column", mvc_bin_export_column_wrap, true, "export column as binary", args(1, 5, arg("", lng), batargany("col", 1), arg("byteswap", bit), arg("filename", str), arg("onclient", int))),
6178 : pattern("sql", "export_bin_column", mvc_bin_export_column_wrap, true, "export column as binary", args(1, 5, arg("", lng), argany("val", 1), arg("byteswap", bit), arg("filename", str), arg("onclient", int))),
6179 : pattern("sql", "affectedRows", mvc_affected_rows_wrap, true, "export the number of affected rows by the current query", args(1,3, arg("",int),arg("mvc",int),arg("nr",lng))),
6180 : pattern("sql", "copy_from", mvc_import_table_wrap, true, "Import a table from bstream s with the \ngiven tuple and separators (sep/rsep)", args(1,15, batvarargany("",0),arg("t",ptr),arg("sep",str),arg("rsep",str),arg("ssep",str),arg("ns",str),arg("fname",str),arg("nr",lng),arg("offset",lng),arg("best",int),arg("fwf",str),arg("onclient",int),arg("escape",int),arg("decsep",str),arg("decskip",str))),
6181 : //we use bat.single now
6182 : //pattern("sql", "single", CMDBATsingle, false, "", args(1,2, batargany("",2),argany("x",2))),
6183 : pattern("sql", "importColumn", mvc_bin_import_column_wrap, false, "Import a column from the given file", args(2, 8, batargany("", 0),arg("", oid), arg("method",str),arg("width",int),arg("bswap",bit),arg("path",str),arg("onclient",int),arg("nrows",oid))),
6184 : command("aggr", "not_unique", not_unique, false, "check if the tail sorted bat b doesn't have unique tail values", args(1,2, arg("",bit),batarg("b",oid))),
6185 : command("sql", "optimizers", getPipeCatalog, false, "", args(3,3, batarg("",str),batarg("",str),batarg("",str))),
6186 : pattern("sql", "optimizer_updates", SQLoptimizersUpdate, false, "", noargs),
6187 : pattern("sql", "argRecord", SQLargRecord, false, "Glue together the calling sequence", args(1,1, arg("",str))),
6188 : pattern("sql", "argRecord", SQLargRecord, false, "Glue together the calling sequence", args(1,2, arg("",str),varargany("a",0))),
6189 : pattern("sql", "sql_variables", sql_variables, false, "return the table with session variables", args(4,4, batarg("sname",str),batarg("name",str),batarg("type",str),batarg("value",str))),
6190 : pattern("sql", "sessions", sql_sessions_wrap, false, "SQL export table of active sessions, their timeouts and idle status",args(16,16,batarg("id",int),batarg("user",str),batarg("start",timestamp),batarg("idle",timestamp),batarg("optimizer",str),batarg("stimeout",int),batarg("qtimeout",int),batarg("wlimit",int),batarg("mlimit",int),batarg("language", str),batarg("peer", str),batarg("hostname", str),batarg("application", str),batarg("client", str),batarg("clientpid", lng),batarg("remark", str),)),
6191 : pattern("sql", "unclosed_result_sets", sql_unclosed_result_sets, false, "return query_id/res_id of unclosed result sets", args(2,2, batarg("query_id",oid),batarg("res_id", int))),
6192 : pattern("sql", "password", SQLuser_password, false, "Return password hash of user", args(1,2, arg("",str),arg("user",str))),
6193 : pattern("sql", "decypher", SQLdecypher, false, "Return decyphered password", args(1,2, arg("",str),arg("hash",str))),
6194 : pattern("sql", "dump_cache", dump_cache, false, "dump the content of the query cache", args(2,2, batarg("query",str),batarg("count",int))),
6195 : pattern("sql", "dump_opt_stats", dump_opt_stats, false, "dump the optimizer rewrite statistics", args(2,2, batarg("rewrite",str),batarg("count",int))),
6196 : pattern("sql", "dump_trace", dump_trace, false, "dump the trace statistics", args(3,3, batarg("ticks",lng),batarg("stmt",str),batarg("stmt",str))),
6197 : pattern("sql", "analyze", sql_analyze, true, "Update statistics for every column in the database", args(1,1, arg("",void))),
6198 : pattern("sql", "analyze", sql_analyze, true, "Update statistics for schema", args(1,2, arg("",void),arg("sch",str))),
6199 : pattern("sql", "analyze", sql_analyze, true, "Update statistics for table", args(1,3, arg("",void),arg("sch",str),arg("tbl",str))),
6200 : pattern("sql", "analyze", sql_analyze, true, "Update statistics for column", args(1,4, arg("",void),arg("sch",str),arg("tbl",str),arg("col",str))),
6201 : pattern("sql", "set_count_distinct", sql_set_count_distinct, true, "Set count distinct for column", args(1,5, arg("",void),arg("sch",str),arg("tbl",str),arg("col",str),arg("val",lng))),
6202 : pattern("sql", "set_min", sql_set_min, true, "Set min for column", args(1,5, arg("",void),arg("sch",str),arg("tbl",str),arg("col",str),argany("val",1))),
6203 : pattern("sql", "set_max", sql_set_max, true, "Set max for column", args(1,5, arg("",void),arg("sch",str),arg("tbl",str),arg("col",str),argany("val",1))),
6204 : pattern("sql", "statistics", sql_statistics, false, "return a table with statistics information", args(13,13, batarg("columnid",int),batarg("schema",str),batarg("table",str),batarg("column",str),batarg("type",str),batarg("with",int),batarg("count",lng),batarg("unique",bit),batarg("nils",bit),batarg("minval",str),batarg("maxval",str),batarg("sorted",bit),batarg("revsorted",bit))),
6205 : pattern("sql", "statistics", sql_statistics, false, "return a table with statistics information for a particular schema", args(13,14, batarg("columnid",int),batarg("schema",str),batarg("table",str),batarg("column",str),batarg("type",str),batarg("with",int),batarg("count",lng),batarg("unique",bit),batarg("nils",bit),batarg("minval",str),batarg("maxval",str),batarg("sorted",bit),batarg("revsorted",bit),arg("sname",str))),
6206 : pattern("sql", "statistics", sql_statistics, false, "return a table with statistics information for a particular table", args(13,15, batarg("columnid",int),batarg("schema",str),batarg("table",str),batarg("column",str),batarg("type",str),batarg("with",int),batarg("count",lng),batarg("unique",bit),batarg("nils",bit),batarg("minval",str),batarg("maxval",str),batarg("sorted",bit),batarg("revsorted",bit),arg("sname",str),arg("tname",str))),
6207 : pattern("sql", "statistics", sql_statistics, false, "return a table with statistics information for a particular column", args(13,16, batarg("columnid",int),batarg("schema",str),batarg("table",str),batarg("column",str),batarg("type",str),batarg("with",int),batarg("count",lng),batarg("unique",bit),batarg("nils",bit),batarg("minval",str),batarg("maxval",str),batarg("sorted",bit),batarg("revsorted",bit),arg("sname",str),arg("tname",str),arg("cname",str))),
6208 : pattern("sql", "storage", sql_storage, false, "return a table with storage information ", args(17,17, batarg("schema",str),batarg("table",str),batarg("column",str),batarg("type",str),batarg("mode",str),batarg("location",str),batarg("count",lng),batarg("atomwidth",int),batarg("columnsize",lng),batarg("heap",lng),batarg("hashes",lng),batarg("phash",bit),batarg("imprints",lng),batarg("sorted",bit),batarg("revsorted",bit),batarg("key",bit),batarg("orderidx",lng))),
6209 : pattern("sql", "storage", sql_storage, false, "return a table with storage information for a particular schema ", args(17,18, batarg("schema",str),batarg("table",str),batarg("column",str),batarg("type",str),batarg("mode",str),batarg("location",str),batarg("count",lng),batarg("atomwidth",int),batarg("columnsize",lng),batarg("heap",lng),batarg("hashes",lng),batarg("phash",bit),batarg("imprints",lng),batarg("sorted",bit),batarg("revsorted",bit),batarg("key",bit),batarg("orderidx",lng),arg("sname",str))),
6210 : pattern("sql", "storage", sql_storage, false, "return a table with storage information for a particular table", args(17,19, batarg("schema",str),batarg("table",str),batarg("column",str),batarg("type",str),batarg("mode",str),batarg("location",str),batarg("count",lng),batarg("atomwidth",int),batarg("columnsize",lng),batarg("heap",lng),batarg("hashes",lng),batarg("phash",bit),batarg("imprints",lng),batarg("sorted",bit),batarg("revsorted",bit),batarg("key",bit),batarg("orderidx",lng),arg("sname",str),arg("tname",str))),
6211 : pattern("sql", "storage", sql_storage, false, "return a table with storage information for a particular column", args(17,20, batarg("schema",str),batarg("table",str),batarg("column",str),batarg("type",str),batarg("mode",str),batarg("location",str),batarg("count",lng),batarg("atomwidth",int),batarg("columnsize",lng),batarg("heap",lng),batarg("hashes",lng),batarg("phash",bit),batarg("imprints",lng),batarg("sorted",bit),batarg("revsorted",bit),batarg("key",bit),batarg("orderidx",lng),arg("sname",str),arg("tname",str),arg("cname",str))),
6212 : pattern("sql", "createorderindex", sql_createorderindex, true, "Instantiate the order index on a column", args(0,3, arg("sch",str),arg("tbl",str),arg("col",str))),
6213 : pattern("sql", "droporderindex", sql_droporderindex, true, "Drop the order index on a column", args(0,3, arg("sch",str),arg("tbl",str),arg("col",str))),
6214 : pattern("sql", "createstrimps", sql_createstrimps, true, "Instantiate the strimps index on a column", args(0,3, arg("sch",str),arg("tbl",str),arg("col",str))),
6215 : command("calc", "identity", SQLidentity, false, "Returns a unique row identitfier.", args(1,2, arg("",oid),argany("",0))),
6216 : command("batcalc", "identity", BATSQLidentity, false, "Returns the unique row identitfiers.", args(1,2, batarg("",oid),batargany("b",0))),
6217 : pattern("batcalc", "identity", PBATSQLidentity, false, "Returns the unique row identitfiers.", args(2,4, batarg("resb",oid),arg("ns",oid),batargany("b",0),arg("s",oid))),
6218 : pattern("sql", "querylog_catalog", sql_querylog_catalog, false, "Obtain the query log catalog", args(8,8, batarg("id",oid),batarg("user",str),batarg("defined",timestamp),batarg("query",str),batarg("pipe",str),batarg("plan",str),batarg("mal",int),batarg("optimize",lng))),
6219 : pattern("sql", "querylog_calls", sql_querylog_calls, false, "Obtain the query log calls", args(9,9, batarg("id",oid),batarg("start",timestamp),batarg("stop",timestamp),batarg("arguments",str),batarg("tuples",lng),batarg("exec",lng),batarg("result",lng),batarg("cpuload",int),batarg("iowait",int))),
6220 : pattern("sql", "querylog_empty", sql_querylog_empty, true, "", noargs),
6221 : command("sql", "querylog_enable", QLOGenable, true, "", noargs),
6222 : command("sql", "querylog_enable", QLOGenableThreshold, true, "", args(0,1, arg("thres",int))),
6223 : command("sql", "querylog_disable", QLOGdisable, true, "", noargs),
6224 : pattern("sql", "prepared_statements", SQLsession_prepared_statements, false, "Available prepared statements in the current session", args(5,5, batarg("sessionid",int),batarg("user",str),batarg("statementid",int),batarg("statement",str),batarg("created",timestamp))),
6225 : pattern("sql", "prepared_statements_args", SQLsession_prepared_statements_args, false, "Available prepared statements' arguments in the current session", args(9,9, batarg("statementid",int),batarg("type",str),batarg("digits",int),batarg("scale",int),batarg("inout",bte),batarg("number",int),batarg("schema",str),batarg("table",str),batarg("column",str))),
6226 : pattern("sql", "copy_rejects", COPYrejects, false, "", args(4,4, batarg("rowid",lng),batarg("fldid",int),batarg("msg",str),batarg("inp",str))),
6227 : pattern("sql", "copy_rejects_clear", COPYrejects_clear, true, "", noargs),
6228 : pattern("for", "compress", FORcompress_col, false, "compress a sql column", args(0, 3, arg("schema", str), arg("table", str), arg("column", str))),
6229 : pattern("for", "decompress", FORdecompress, false, "decompress a for compressed (sub)column", args(1, 3, batargany("", 1), batargany("o", 0), argany("minval", 1))),
6230 : pattern("dict", "compress", DICTcompress, false, "dict compress a bat", args(2, 3, batargany("o", 0), batargany("v", 1), batargany("b", 1))),
6231 : pattern("dict", "compress", DICTcompress_col, false, "compress a sql column", args(0, 3, arg("schema", str), arg("table", str), arg("column", str))),
6232 : pattern("dict", "compress", DICTcompress_col, false, "compress a sql column", args(0, 4, arg("schema", str), arg("table", str), arg("column", str), arg("ordered", bit))),
6233 : pattern("dict", "decompress", DICTdecompress, false, "decompress a dictionary compressed (sub)column", args(1, 3, batargany("", 1), batargany("o", 0), batargany("u", 1))),
6234 : pattern("dict", "convert", DICTconvert, false, "convert candidate list into compressed offsets", args(1, 2, batargany("", 1), batargany("o", 0))),
6235 : pattern("dict", "join", DICTjoin, false, "join 2 dictionaries", args(2, 10, batarg("r0", oid), batarg("r1", oid), batargany("lo", 0), batargany("lv", 1), batargany("ro", 0), batargany("rv", 1), batarg("lc", oid), batarg("rc", oid), arg("nil_matches",bit), arg("estimate",lng))),
6236 : pattern("dict", "thetaselect", DICTthetaselect, false, "thetaselect on a dictionary", args(1, 6, batarg("r0", oid), batargany("lo", 0), batarg("lc", oid), batargany("lv", 1), argany("val",1), arg("op", str))),
6237 : pattern("dict", "renumber", DICTrenumber, false, "renumber offsets", args(1, 3, batargany("n", 1), batargany("o", 1), batargany("r", 1))),
6238 : pattern("dict", "select", DICTselect, false, "value - range select on a dictionary", args(1, 10, batarg("r0", oid), batargany("lo", 0), batarg("lc", oid), batargany("lv", 1), argany("l", 1), argany("h", 1), arg("li", bit), arg("hi", bit), arg("anti", bit), arg("unknown", bit))),
6239 : command("calc", "dec_round", bte_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, arg("",bte),arg("v",bte),arg("r",bte))),
6240 : pattern("batcalc", "dec_round", bte_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",bte),batarg("v",bte),arg("r",bte))),
6241 : pattern("batcalc", "dec_round", bte_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",bte),batarg("v",bte),arg("r",bte),batarg("s",oid))),
6242 : pattern("batcalc", "dec_round", bte_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",bte),arg("v",bte),batarg("r",bte))),
6243 : pattern("batcalc", "dec_round", bte_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",bte),arg("v",bte),batarg("r",bte),batarg("s",oid))),
6244 : pattern("batcalc", "dec_round", bte_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",bte),batarg("v",bte),batarg("r",bte))),
6245 : pattern("batcalc", "dec_round", bte_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,5, batarg("",bte),batarg("v",bte),batarg("r",bte),batarg("s1",oid),batarg("s2",oid))),
6246 : command("calc", "round", bte_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, arg("",bte),arg("v",bte),arg("r",bte),arg("d",int),arg("s",int))),
6247 : pattern("batcalc", "round", bte_bat_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",bte),batarg("v",bte),arg("r",bte),arg("d",int),arg("s",int))),
6248 : pattern("batcalc", "round", bte_bat_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,6, batarg("",bte),batarg("v",bte),arg("r",bte),batarg("s",oid),arg("d",int),arg("s",int))),
6249 : pattern("batcalc", "round", bte_bat_round_wrap_cst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",bte),arg("v",bte),batarg("r",bte),arg("d",int),arg("s",int))),
6250 : pattern("batcalc", "round", bte_bat_round_wrap_cst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,6, batarg("",bte),arg("v",bte),batarg("r",bte),batarg("s",oid),arg("d",int),arg("s",int))),
6251 : pattern("batcalc", "round", bte_bat_round_wrap_nocst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",bte),batarg("v",bte),batarg("r",bte),arg("d",int),arg("s",int))),
6252 : pattern("batcalc", "round", bte_bat_round_wrap_nocst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,7, batarg("",bte),batarg("v",bte),batarg("r",bte),batarg("s1",oid),batarg("s2",oid),arg("d",int),arg("s",int))),
6253 : command("calc", "second_interval", bte_dec2second_interval, false, "cast bte decimal to a second_interval", args(1,5, arg("",lng),arg("sc",int),arg("v",bte),arg("ek",int),arg("sk",int))),
6254 : pattern("batcalc", "second_interval", bte_batdec2second_interval, false, "cast bte decimal to a second_interval", args(1,6, batarg("",lng),arg("sc",int),batarg("v",bte),batarg("s",oid),arg("ek",int),arg("sk",int))),
6255 : command("calc", "dec_round", sht_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, arg("",sht),arg("v",sht),arg("r",sht))),
6256 : pattern("batcalc", "dec_round", sht_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",sht),batarg("v",sht),arg("r",sht))),
6257 : pattern("batcalc", "dec_round", sht_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",sht),batarg("v",sht),arg("r",sht),batarg("s",oid))),
6258 : pattern("batcalc", "dec_round", sht_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",sht),arg("v",sht),batarg("r",sht))),
6259 : pattern("batcalc", "dec_round", sht_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",sht),arg("v",sht),batarg("r",sht),batarg("s",oid))),
6260 : pattern("batcalc", "dec_round", sht_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",sht),batarg("v",sht),batarg("r",sht))),
6261 : pattern("batcalc", "dec_round", sht_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,5, batarg("",sht),batarg("v",sht),batarg("r",sht),batarg("s1",oid),batarg("s2",oid))),
6262 : command("calc", "round", sht_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, arg("",sht),arg("v",sht),arg("r",bte),arg("d",int),arg("s",int))),
6263 : pattern("batcalc", "round", sht_bat_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",sht),batarg("v",sht),arg("r",bte),arg("d",int),arg("s",int))),
6264 : pattern("batcalc", "round", sht_bat_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,6, batarg("",sht),batarg("v",sht),arg("r",bte),batarg("s",oid),arg("d",int),arg("s",int))),
6265 : pattern("batcalc", "round", sht_bat_round_wrap_cst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",sht),arg("v",sht),batarg("r",bte),arg("d",int),arg("s",int))),
6266 : pattern("batcalc", "round", sht_bat_round_wrap_cst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,6, batarg("",sht),arg("v",sht),batarg("r",bte),batarg("s",oid),arg("d",int),arg("s",int))),
6267 : pattern("batcalc", "round", sht_bat_round_wrap_nocst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",sht),batarg("v",sht),batarg("r",bte),arg("d",int),arg("s",int))),
6268 : pattern("batcalc", "round", sht_bat_round_wrap_nocst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,7, batarg("",sht),batarg("v",sht),batarg("r",bte),batarg("s1",oid),batarg("s2",oid),arg("d",int),arg("s",int))),
6269 : command("calc", "second_interval", sht_dec2second_interval, false, "cast sht decimal to a second_interval", args(1,5, arg("",lng),arg("sc",int),arg("v",sht),arg("ek",int),arg("sk",int))),
6270 : pattern("batcalc", "second_interval", sht_batdec2second_interval, false, "cast sht decimal to a second_interval", args(1,6, batarg("",lng),arg("sc",int),batarg("v",sht),batarg("s",oid),arg("ek",int),arg("sk",int))),
6271 : command("calc", "dec_round", int_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, arg("",int),arg("v",int),arg("r",int))),
6272 : pattern("batcalc", "dec_round", int_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",int),batarg("v",int),arg("r",int))),
6273 : pattern("batcalc", "dec_round", int_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",int),batarg("v",int),arg("r",int),batarg("s",oid))),
6274 : pattern("batcalc", "dec_round", int_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",int),arg("v",int),batarg("r",int))),
6275 : pattern("batcalc", "dec_round", int_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",int),arg("v",int),batarg("r",int),batarg("s",oid))),
6276 : pattern("batcalc", "dec_round", int_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",int),batarg("v",int),batarg("r",int))),
6277 : pattern("batcalc", "dec_round", int_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,5, batarg("",int),batarg("v",int),batarg("r",int),batarg("s1",oid),batarg("s2",oid))),
6278 : command("calc", "round", int_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, arg("",int),arg("v",int),arg("r",bte),arg("d",int),arg("s",int))),
6279 : pattern("batcalc", "round", int_bat_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",int),batarg("v",int),arg("r",bte),arg("d",int),arg("s",int))),
6280 : pattern("batcalc", "round", int_bat_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,6, batarg("",int),batarg("v",int),arg("r",bte),batarg("s",oid),arg("d",int),arg("s",int))),
6281 : pattern("batcalc", "round", int_bat_round_wrap_cst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",int),arg("v",int),batarg("r",bte),arg("d",int),arg("s",int))),
6282 : pattern("batcalc", "round", int_bat_round_wrap_cst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,6, batarg("",int),arg("v",int),batarg("r",bte),batarg("s",oid),arg("d",int),arg("s",int))),
6283 : pattern("batcalc", "round", int_bat_round_wrap_nocst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",int),batarg("v",int),batarg("r",bte),arg("d",int),arg("s",int))),
6284 : pattern("batcalc", "round", int_bat_round_wrap_nocst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,7, batarg("",int),batarg("v",int),batarg("r",bte),batarg("s1",oid),batarg("s2",oid),arg("d",int),arg("s",int))),
6285 : command("calc", "second_interval", int_dec2second_interval, false, "cast int decimal to a second_interval", args(1,5, arg("",lng),arg("sc",int),arg("v",int),arg("ek",int),arg("sk",int))),
6286 : pattern("batcalc", "second_interval", int_batdec2second_interval, false, "cast int decimal to a second_interval", args(1,6, batarg("",lng),arg("sc",int),batarg("v",int),batarg("s",oid),arg("ek",int),arg("sk",int))),
6287 : command("calc", "dec_round", lng_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, arg("",lng),arg("v",lng),arg("r",lng))),
6288 : pattern("batcalc", "dec_round", lng_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",lng),batarg("v",lng),arg("r",lng))),
6289 : pattern("batcalc", "dec_round", lng_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",lng),batarg("v",lng),arg("r",lng),batarg("s",oid))),
6290 : pattern("batcalc", "dec_round", lng_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",lng),arg("v",lng),batarg("r",lng))),
6291 : pattern("batcalc", "dec_round", lng_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",lng),arg("v",lng),batarg("r",lng),batarg("s",oid))),
6292 : pattern("batcalc", "dec_round", lng_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",lng),batarg("v",lng),batarg("r",lng))),
6293 : pattern("batcalc", "dec_round", lng_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,5, batarg("",lng),batarg("v",lng),batarg("r",lng),batarg("s1",oid),batarg("s2",oid))),
6294 : command("calc", "round", lng_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, arg("",lng),arg("v",lng),arg("r",bte),arg("d",int),arg("s",int))),
6295 : pattern("batcalc", "round", lng_bat_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",lng),batarg("v",lng),arg("r",bte),arg("d",int),arg("s",int))),
6296 : pattern("batcalc", "round", lng_bat_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,6, batarg("",lng),batarg("v",lng),arg("r",bte),batarg("s",oid),arg("d",int),arg("s",int))),
6297 : pattern("batcalc", "round", lng_bat_round_wrap_cst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",lng),arg("v",lng),batarg("r",bte),arg("d",int),arg("s",int))),
6298 : pattern("batcalc", "round", lng_bat_round_wrap_cst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,6, batarg("",lng),arg("v",lng),batarg("r",bte),batarg("s",oid),arg("d",int),arg("s",int))),
6299 : pattern("batcalc", "round", lng_bat_round_wrap_nocst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",lng),batarg("v",lng),batarg("r",bte),arg("d",int),arg("s",int))),
6300 : pattern("batcalc", "round", lng_bat_round_wrap_nocst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,7, batarg("",lng),batarg("v",lng),batarg("r",bte),batarg("s1",oid),batarg("s2",oid),arg("d",int),arg("s",int))),
6301 : command("calc", "second_interval", lng_dec2second_interval, false, "cast lng decimal to a second_interval", args(1,5, arg("",lng),arg("sc",int),arg("v",lng),arg("ek",int),arg("sk",int))),
6302 : pattern("batcalc", "second_interval", lng_batdec2second_interval, false, "cast lng decimal to a second_interval", args(1,6, batarg("",lng),arg("sc",int),batarg("v",lng),batarg("s",oid),arg("ek",int),arg("sk",int))),
6303 : command("calc", "dec_round", flt_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, arg("",flt),arg("v",flt),arg("r",flt))),
6304 : pattern("batcalc", "dec_round", flt_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",flt),batarg("v",flt),arg("r",flt))),
6305 : pattern("batcalc", "dec_round", flt_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",flt),batarg("v",flt),arg("r",flt),batarg("s",oid))),
6306 : pattern("batcalc", "dec_round", flt_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",flt),arg("v",flt),batarg("r",flt))),
6307 : pattern("batcalc", "dec_round", flt_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",flt),arg("v",flt),batarg("r",flt),batarg("s",oid))),
6308 : pattern("batcalc", "dec_round", flt_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",flt),batarg("v",flt),batarg("r",flt))),
6309 : pattern("batcalc", "dec_round", flt_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,5, batarg("",flt),batarg("v",flt),batarg("r",flt),batarg("s1",oid),batarg("s2",oid))),
6310 : command("calc", "round", flt_round_wrap, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,3, arg("",flt),arg("v",flt),arg("r",bte))),
6311 : pattern("batcalc", "round", flt_bat_round_wrap, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,3, batarg("",flt),batarg("v",flt),arg("r",bte))),
6312 : pattern("batcalc", "round", flt_bat_round_wrap, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,4, batarg("",flt),batarg("v",flt),arg("r",bte),batarg("s",oid))),
6313 : pattern("batcalc", "round", flt_bat_round_wrap_cst, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,3, batarg("",flt),arg("v",flt),batarg("r",bte))),
6314 : pattern("batcalc", "round", flt_bat_round_wrap_cst, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,4, batarg("",flt),arg("v",flt),batarg("r",bte),batarg("s",oid))),
6315 : pattern("batcalc", "round", flt_bat_round_wrap_nocst, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,3, batarg("",flt),batarg("v",flt),batarg("r",bte))),
6316 : pattern("batcalc", "round", flt_bat_round_wrap_nocst, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",flt),batarg("v",flt),batarg("r",bte),batarg("s1",oid),batarg("s2",oid))),
6317 : command("sql", "ms_trunc", flt_trunc_wrap, false, "truncate the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,3, arg("",flt),arg("v",flt),arg("r",int))),
6318 : command("calc", "dec_round", dbl_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, arg("",dbl),arg("v",dbl),arg("r",dbl))),
6319 : pattern("batcalc", "dec_round", dbl_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",dbl),batarg("v",dbl),arg("r",dbl))),
6320 : pattern("batcalc", "dec_round", dbl_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",dbl),batarg("v",dbl),arg("r",dbl),batarg("s",oid))),
6321 : pattern("batcalc", "dec_round", dbl_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",dbl),arg("v",dbl),batarg("r",dbl))),
6322 : pattern("batcalc", "dec_round", dbl_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",dbl),arg("v",dbl),batarg("r",dbl),batarg("s",oid))),
6323 : pattern("batcalc", "dec_round", dbl_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",dbl),batarg("v",dbl),batarg("r",dbl))),
6324 : pattern("batcalc", "dec_round", dbl_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,5, batarg("",dbl),batarg("v",dbl),batarg("r",dbl),batarg("s1",oid),batarg("s2",oid))),
6325 : command("calc", "round", dbl_round_wrap, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,3, arg("",dbl),arg("v",dbl),arg("r",bte))),
6326 : pattern("batcalc", "round", dbl_bat_round_wrap, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,3, batarg("",dbl),batarg("v",dbl),arg("r",bte))),
6327 : pattern("batcalc", "round", dbl_bat_round_wrap, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,4, batarg("",dbl),batarg("v",dbl),arg("r",bte),batarg("s",oid))),
6328 : pattern("batcalc", "round", dbl_bat_round_wrap_cst, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,3, batarg("",dbl),arg("v",dbl),batarg("r",bte))),
6329 : pattern("batcalc", "round", dbl_bat_round_wrap_cst, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,4, batarg("",dbl),arg("v",dbl),batarg("r",bte),batarg("s",oid))),
6330 : pattern("batcalc", "round", dbl_bat_round_wrap_nocst, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,3, batarg("",dbl),batarg("v",dbl),batarg("r",bte))),
6331 : pattern("batcalc", "round", dbl_bat_round_wrap_nocst, false, "round off the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",dbl),batarg("v",dbl),batarg("r",bte),batarg("s1",oid),batarg("s2",oid))),
6332 : command("sql", "ms_trunc", dbl_trunc_wrap, false, "truncate the floating point v to r digits behind the dot (if r < 0, before the dot)", args(1,3, arg("",dbl),arg("v",dbl),arg("r",int))),
6333 : command("sql", "alpha", SQLcst_alpha_cst, false, "Implementation of astronomy alpha function: expands the radius theta depending on the declination", args(1,3, arg("",dbl),arg("dec",dbl),arg("theta",dbl))),
6334 : command("batsql", "alpha", SQLbat_alpha_cst, false, "BAT implementation of astronomy alpha function", args(1,3, batarg("",dbl),batarg("dec",dbl),arg("theta",dbl))),
6335 : command("batsql", "alpha", SQLcst_alpha_bat, false, "BAT implementation of astronomy alpha function", args(1,3, batarg("",dbl),arg("dec",dbl),batarg("theta",dbl))),
6336 : command("calc", "bte", nil_2dec_bte, false, "cast to dec(bte) and check for overflow", args(1,4, arg("",bte),arg("v",void),arg("digits",int),arg("scale",int))),
6337 : command("batcalc", "bte", batnil_2dec_bte, false, "cast to dec(bte) and check for overflow", args(1,4, batarg("",bte),batarg("v",oid),arg("digits",int),arg("scale",int))),
6338 : command("calc", "bte", str_2dec_bte, false, "cast to dec(bte) and check for overflow", args(1,4, arg("",bte),arg("v",str),arg("digits",int),arg("scale",int))),
6339 : pattern("batcalc", "bte", batstr_2dec_bte, false, "cast to dec(bte) and check for overflow", args(1,5, batarg("",bte),batarg("v",str),batarg("s",oid),arg("digits",int),arg("scale",int))),
6340 : command("calc", "sht", nil_2dec_sht, false, "cast to dec(sht) and check for overflow", args(1,4, arg("",sht),arg("v",void),arg("digits",int),arg("scale",int))),
6341 : command("batcalc", "sht", batnil_2dec_sht, false, "cast to dec(sht) and check for overflow", args(1,4, batarg("",sht),batarg("v",oid),arg("digits",int),arg("scale",int))),
6342 : command("calc", "sht", str_2dec_sht, false, "cast to dec(sht) and check for overflow", args(1,4, arg("",sht),arg("v",str),arg("digits",int),arg("scale",int))),
6343 : pattern("batcalc", "sht", batstr_2dec_sht, false, "cast to dec(sht) and check for overflow", args(1,5, batarg("",sht),batarg("v",str),batarg("s",oid),arg("digits",int),arg("scale",int))),
6344 : command("calc", "int", nil_2dec_int, false, "cast to dec(int) and check for overflow", args(1,4, arg("",int),arg("v",void),arg("digits",int),arg("scale",int))),
6345 : command("batcalc", "int", batnil_2dec_int, false, "cast to dec(int) and check for overflow", args(1,4, batarg("",int),batarg("v",oid),arg("digits",int),arg("scale",int))),
6346 : command("calc", "int", str_2dec_int, false, "cast to dec(int) and check for overflow", args(1,4, arg("",int),arg("v",str),arg("digits",int),arg("scale",int))),
6347 : pattern("batcalc", "int", batstr_2dec_int, false, "cast to dec(int) and check for overflow", args(1,5, batarg("",int),batarg("v",str),batarg("s",oid),arg("digits",int),arg("scale",int))),
6348 : command("calc", "lng", nil_2dec_lng, false, "cast to dec(lng) and check for overflow", args(1,4, arg("",lng),arg("v",void),arg("digits",int),arg("scale",int))),
6349 : command("batcalc", "lng", batnil_2dec_lng, false, "cast to dec(lng) and check for overflow", args(1,4, batarg("",lng),batarg("v",oid),arg("digits",int),arg("scale",int))),
6350 : command("calc", "lng", str_2dec_lng, false, "cast to dec(lng) and check for overflow", args(1,4, arg("",lng),arg("v",str),arg("digits",int),arg("scale",int))),
6351 : pattern("batcalc", "lng", batstr_2dec_lng, false, "cast to dec(lng) and check for overflow", args(1,5, batarg("",lng),batarg("v",str),batarg("s",oid),arg("digits",int),arg("scale",int))),
6352 : pattern("calc", "timestamp", nil_2time_timestamp, false, "cast to timestamp and check for overflow", args(1,3, arg("",timestamp),arg("v",void),arg("digits",int))),
6353 : pattern("batcalc", "timestamp", nil_2time_timestamp, false, "cast to timestamp and check for overflow", args(1,3, batarg("",timestamp),batarg("v",oid),arg("digits",int))),
6354 : pattern("calc", "timestamp", str_2time_timestamp, false, "cast to timestamp and check for overflow", args(1,3, arg("",timestamp),arg("v",str),arg("digits",int))),
6355 : pattern("calc", "timestamptz", str_2time_timestamptz, false, "cast to timestamp and check for overflow", args(1,4, arg("",timestamp),arg("v",str),arg("digits",int),arg("tz_msec",lng))),
6356 : pattern("calc", "timestamp", timestamp_2time_timestamp, false, "cast timestamp to timestamp and check for overflow", args(1,3, arg("",timestamp),arg("v",timestamp),arg("digits",int))),
6357 : command("batcalc", "timestamp", batstr_2time_timestamp, false, "cast to timestamp and check for overflow", args(1,4, batarg("",timestamp),batarg("v",str),batarg("s",oid),arg("digits",int))),
6358 : command("batcalc", "timestamptz", batstr_2time_timestamptz, false, "cast to timestamp and check for overflow", args(1,5, batarg("",timestamp),batarg("v",str),batarg("s",oid),arg("digits",int),arg("tz_msec",lng))),
6359 : pattern("batcalc", "timestamp", timestamp_2time_timestamp, false, "cast timestamp to timestamp and check for overflow", args(1,4, batarg("",timestamp),batarg("v",timestamp),batarg("s",oid),arg("digits",int))),
6360 : pattern("batcalc", "daytime", nil_2time_daytime, false, "cast to daytime and check for overflow", args(1,3, batarg("",daytime),batarg("v",oid),arg("digits",int))),
6361 : pattern("calc", "daytime", str_2time_daytime, false, "cast to daytime and check for overflow", args(1,3, arg("",daytime),arg("v",str),arg("digits",int))),
6362 : pattern("calc", "daytimetz", str_2time_daytimetz, false, "cast to daytime and check for overflow", args(1,4, arg("",daytime),arg("v",str),arg("digits",int),arg("tz_msec",lng))),
6363 : pattern("calc", "daytime", daytime_2time_daytime, false, "cast daytime to daytime and check for overflow", args(1,3, arg("",daytime),arg("v",daytime),arg("digits",int))),
6364 : command("batcalc", "daytime", batstr_2time_daytime, false, "cast to daytime and check for overflow", args(1,4, batarg("",daytime),batarg("v",str),batarg("s",oid),arg("digits",int))),
6365 : pattern("batcalc", "daytimetz", str_2time_daytimetz, false, "cast daytime to daytime and check for overflow", args(1,5, batarg("",daytime),batarg("v",str),batarg("s",oid),arg("digits",int),arg("tz_msec",lng))),
6366 : pattern("batcalc", "daytime", daytime_2time_daytime, false, "cast daytime to daytime and check for overflow", args(1,4, batarg("",daytime),batarg("v",daytime),batarg("s",oid),arg("digits",int))),
6367 : command("sql", "date_trunc", bat_date_trunc, false, "Truncate a timestamp to (millennium, century,decade,year,quarter,month,week,day,hour,minute,second, milliseconds,microseconds)", args(1,3, batarg("",timestamp),arg("scale",str),batarg("v",timestamp))),
6368 : command("sql", "date_trunc", date_trunc, false, "Truncate a timestamp to (millennium, century,decade,year,quarter,month,week,day,hour,minute,second, milliseconds,microseconds)", args(1,3, arg("",timestamp),arg("scale",str),arg("v",timestamp))),
6369 : pattern("sql", "current_time", SQLcurrent_daytime, false, "Get the clients current daytime", args(1,1, arg("",daytime))),
6370 : pattern("sql", "current_timestamp", SQLcurrent_timestamp, false, "Get the clients current timestamp", args(1,1, arg("",timestamp))),
6371 : pattern("calc", "date", nil_2_date, false, "cast to date", args(1,2, arg("",date),arg("v",void))),
6372 : pattern("batcalc", "date", nil_2_date, false, "cast to date", args(1,2, batarg("",date),batarg("v",oid))),
6373 : pattern("calc", "str", SQLstr_cast, false, "cast to string and check for overflow", args(1,7, arg("",str),arg("eclass",int),arg("d1",int),arg("s1",int),arg("has_tz",int),argany("v",1),arg("digits",int))),
6374 : pattern("batcalc", "str", SQLbatstr_cast, false, "cast to string and check for overflow, no candidate list", args(1,7, batarg("",str),arg("eclass",int),arg("d1",int),arg("s1",int),arg("has_tz",int),batargany("v",1),arg("digits",int))),
6375 : pattern("batcalc", "str", SQLbatstr_cast, false, "cast to string and check for overflow", args(1,8, batarg("",str),arg("eclass",int),arg("d1",int),arg("s1",int),arg("has_tz",int),batargany("v",1),batarg("s",oid),arg("digits",int))),
6376 : pattern("calc", "month_interval", month_interval_str, false, "cast str to a month_interval and check for overflow", args(1,4, arg("",int),arg("v",str),arg("ek",int),arg("sk",int))),
6377 : pattern("batcalc", "month_interval", month_interval_str, false, "cast str to a month_interval and check for overflow", args(1,5, batarg("",int),batarg("v",str),batarg("s",oid),arg("ek",int),arg("sk",int))),
6378 : pattern("calc", "second_interval", second_interval_str, false, "cast str to a second_interval and check for overflow", args(1,4, arg("",lng),arg("v",str),arg("ek",int),arg("sk",int))),
6379 : pattern("batcalc", "second_interval", second_interval_str, false, "cast str to a second_interval and check for overflow", args(1,5, batarg("",lng),batarg("v",str),batarg("s",oid),arg("ek",int),arg("sk",int))),
6380 : pattern("calc", "month_interval", month_interval, false, "cast bte to a month_interval and check for overflow", args(1,4, arg("",int),arg("v",bte),arg("ek",int),arg("sk",int))),
6381 : pattern("batcalc", "month_interval", month_interval, false, "cast bte to a month_interval and check for overflow", args(1,5, batarg("",int),batarg("v",bte),batarg("s",oid),arg("ek",int),arg("sk",int))),
6382 : pattern("calc", "second_interval", second_interval, false, "cast bte to a second_interval and check for overflow", args(1,4, arg("",lng),arg("v",bte),arg("ek",int),arg("sk",int))),
6383 : pattern("batcalc", "second_interval", second_interval, false, "cast bte to a second_interval and check for overflow", args(1,5, batarg("",lng),batarg("v",bte),batarg("s",oid),arg("ek",int),arg("sk",int))),
6384 : pattern("calc", "month_interval", month_interval, false, "cast sht to a month_interval and check for overflow", args(1,4, arg("",int),arg("v",sht),arg("ek",int),arg("sk",int))),
6385 : pattern("batcalc", "month_interval", month_interval, false, "cast sht to a month_interval and check for overflow", args(1,5, batarg("",int),batarg("v",sht),batarg("s",oid),arg("ek",int),arg("sk",int))),
6386 : pattern("calc", "second_interval", second_interval, false, "cast sht to a second_interval and check for overflow", args(1,4, arg("",lng),arg("v",sht),arg("ek",int),arg("sk",int))),
6387 : pattern("batcalc", "second_interval", second_interval, false, "cast sht to a second_interval and check for overflow", args(1,5, batarg("",lng),batarg("v",sht),batarg("s",oid),arg("ek",int),arg("sk",int))),
6388 : pattern("calc", "month_interval", month_interval, false, "cast int to a month_interval and check for overflow", args(1,4, arg("",int),arg("v",int),arg("ek",int),arg("sk",int))),
6389 : pattern("batcalc", "month_interval", month_interval, false, "cast int to a month_interval and check for overflow", args(1,5, batarg("",int),batarg("v",int),batarg("s",oid),arg("ek",int),arg("sk",int))),
6390 : pattern("calc", "second_interval", second_interval, false, "cast int to a second_interval and check for overflow", args(1,4, arg("",lng),arg("v",int),arg("ek",int),arg("sk",int))),
6391 : pattern("batcalc", "second_interval", second_interval, false, "cast int to a second_interval and check for overflow", args(1,5, batarg("",lng),batarg("v",int),batarg("s",oid),arg("ek",int),arg("sk",int))),
6392 : pattern("calc", "month_interval", month_interval, false, "cast lng to a month_interval and check for overflow", args(1,4, arg("",int),arg("v",lng),arg("ek",int),arg("sk",int))),
6393 : pattern("batcalc", "month_interval", month_interval, false, "cast lng to a month_interval and check for overflow", args(1,5, batarg("",int),batarg("v",lng),batarg("s",oid),arg("ek",int),arg("sk",int))),
6394 : pattern("calc", "second_interval", second_interval, false, "cast lng to a second_interval and check for overflow", args(1,4, arg("",lng),arg("v",lng),arg("ek",int),arg("sk",int))),
6395 : pattern("batcalc", "second_interval", second_interval, false, "cast lng to a second_interval and check for overflow", args(1,5, batarg("",lng),batarg("v",lng),batarg("s",oid),arg("ek",int),arg("sk",int))),
6396 : pattern("calc", "rowid", sql_rowid, false, "return the next rowid", args(1,4, arg("",oid),argany("v",1),arg("schema",str),arg("table",str))),
6397 : pattern("sql", "drop_hash", SQLdrop_hash, true, "Drop hash indices for the given table", args(0,2, arg("sch",str),arg("tbl",str))),
6398 : pattern("sql", "prelude", SQLprelude, false, "", noargs),
6399 : command("sql", "epilogue", SQLepilogue, false, "", noargs),
6400 : pattern("calc", "second_interval", second_interval_daytime, false, "cast daytime to a second_interval and check for overflow", args(1,4, arg("",lng),arg("v",daytime),arg("ek",int),arg("sk",int))),
6401 : pattern("batcalc", "second_interval", second_interval_daytime, false, "cast daytime to a second_interval and check for overflow", args(1,5, batarg("",lng),batarg("v",daytime),batarg("s",oid),arg("ek",int),arg("sk",int))),
6402 : pattern("calc", "daytime", second_interval_2_daytime, false, "cast second_interval to a daytime and check for overflow", args(1,3, arg("",daytime),arg("v",lng),arg("d",int))),
6403 : pattern("batcalc", "daytime", second_interval_2_daytime, false, "cast second_interval to a daytime and check for overflow", args(1,4, batarg("",daytime),batarg("v",lng),batarg("s",oid),arg("d",int))),
6404 : pattern("calc", "daytime", timestamp_2_daytime, false, "cast timestamp to a daytime and check for overflow", args(1,3, arg("",daytime),arg("v",timestamp),arg("d",int))),
6405 : pattern("batcalc", "daytime", timestamp_2_daytime, false, "cast timestamp to a daytime and check for overflow", args(1,4, batarg("",daytime),batarg("v",timestamp),batarg("s",oid),arg("d",int))),
6406 : pattern("calc", "timestamp", date_2_timestamp, false, "cast date to a timestamp and check for overflow", args(1,3, arg("",timestamp),arg("v",date),arg("d",int))),
6407 : pattern("batcalc", "timestamp", date_2_timestamp, false, "cast date to a timestamp and check for overflow", args(1,4, batarg("",timestamp),batarg("v",date),batarg("s",oid),arg("d",int))),
6408 : pattern("sql", "update_tables", SYSupdate_tables, true, "Procedure triggered on update of the sys._tables table", args(1,1, arg("",void))),
6409 : pattern("sql", "update_schemas", SYSupdate_schemas, true, "Procedure triggered on update of the sys.schemas table", args(1,1, arg("",void))),
6410 : pattern("sql", "unionfunc", SQLunionfunc, false, "", args(1,4, varargany("",0),arg("mod",str),arg("fcn",str),varargany("",0))),
6411 : /* decimals */
6412 : command("calc", "bte", flt_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,4, arg("",bte),arg("v",flt),arg("digits",int),arg("scale",int))),
6413 : command("batcalc", "bte", batflt_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,5, batarg("",bte),batarg("v",flt),batarg("s",oid),arg("digits",int),arg("scale",int))),
6414 : command("calc", "bte", dbl_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,4, arg("",bte),arg("v",dbl),arg("digits",int),arg("scale",int))),
6415 : command("batcalc", "bte", batdbl_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,5, batarg("",bte),batarg("v",dbl),batarg("s",oid),arg("digits",int),arg("scale",int))),
6416 : command("calc", "sht", flt_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,4, arg("",sht),arg("v",flt),arg("digits",int),arg("scale",int))),
6417 : command("batcalc", "sht", batflt_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,5, batarg("",sht),batarg("v",flt),batarg("s",oid),arg("digits",int),arg("scale",int))),
6418 : command("calc", "sht", dbl_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,4, arg("",sht),arg("v",dbl),arg("digits",int),arg("scale",int))),
6419 : command("batcalc", "sht", batdbl_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,5, batarg("",sht),batarg("v",dbl),batarg("s",oid),arg("digits",int),arg("scale",int))),
6420 : command("calc", "int", flt_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,4, arg("",int),arg("v",flt),arg("digits",int),arg("scale",int))),
6421 : command("batcalc", "int", batflt_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,5, batarg("",int),batarg("v",flt),batarg("s",oid),arg("digits",int),arg("scale",int))),
6422 : command("calc", "int", dbl_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,4, arg("",int),arg("v",dbl),arg("digits",int),arg("scale",int))),
6423 : command("batcalc", "int", batdbl_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,5, batarg("",int),batarg("v",dbl),batarg("s",oid),arg("digits",int),arg("scale",int))),
6424 : command("calc", "lng", flt_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,4, arg("",lng),arg("v",flt),arg("digits",int),arg("scale",int))),
6425 : command("batcalc", "lng", batflt_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,5, batarg("",lng),batarg("v",flt),batarg("s",oid),arg("digits",int),arg("scale",int))),
6426 : command("calc", "lng", dbl_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,4, arg("",lng),arg("v",dbl),arg("digits",int),arg("scale",int))),
6427 : command("batcalc", "lng", batdbl_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,5, batarg("",lng),batarg("v",dbl),batarg("s",oid),arg("digits",int),arg("scale",int))),
6428 : command("calc", "bte", bte_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,4, arg("",bte),arg("v",bte),arg("digits",int),arg("scale",int))),
6429 : command("batcalc", "bte", batbte_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,5, batarg("",bte),batarg("v",bte),batarg("s",oid),arg("digits",int),arg("scale",int))),
6430 : command("calc", "bte", bte_dec2_bte, false, "cast decimal(bte) to bte and check for overflow", args(1,3, arg("",bte),arg("s1",int),arg("v",bte))),
6431 : command("calc", "bte", bte_dec2dec_bte, false, "cast decimal(bte) to decimal(bte) and check for overflow", args(1,5, arg("",bte),arg("s1",int),arg("v",bte),arg("d2",int),arg("s2",int))),
6432 : command("batcalc", "bte", batbte_dec2_bte, false, "cast decimal(bte) to bte and check for overflow", args(1,4, batarg("",bte),arg("s1",int),batarg("v",bte),batarg("s",oid))),
6433 : command("batcalc", "bte", batbte_dec2dec_bte, false, "cast decimal(bte) to decimal(bte) and check for overflow", args(1,6, batarg("",bte),arg("s1",int),batarg("v",bte),batarg("s",oid),arg("d2",int),arg("s2",int))),
6434 : command("calc", "bte", sht_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,4, arg("",bte),arg("v",sht),arg("digits",int),arg("scale",int))),
6435 : command("batcalc", "bte", batsht_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,5, batarg("",bte),batarg("v",sht),batarg("s",oid),arg("digits",int),arg("scale",int))),
6436 : command("calc", "bte", sht_dec2_bte, false, "cast decimal(sht) to bte and check for overflow", args(1,3, arg("",bte),arg("s1",int),arg("v",sht))),
6437 : command("calc", "bte", sht_dec2dec_bte, false, "cast decimal(sht) to decimal(bte) and check for overflow", args(1,5, arg("",bte),arg("s1",int),arg("v",sht),arg("d2",int),arg("s2",int))),
6438 : command("batcalc", "bte", batsht_dec2_bte, false, "cast decimal(sht) to bte and check for overflow", args(1,4, batarg("",bte),arg("s1",int),batarg("v",sht),batarg("s",oid))),
6439 : command("batcalc", "bte", batsht_dec2dec_bte, false, "cast decimal(sht) to decimal(bte) and check for overflow", args(1,6, batarg("",bte),arg("s1",int),batarg("v",sht),batarg("s",oid),arg("d2",int),arg("s2",int))),
6440 : command("calc", "bte", int_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,4, arg("",bte),arg("v",int),arg("digits",int),arg("scale",int))),
6441 : command("batcalc", "bte", batint_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,5, batarg("",bte),batarg("v",int),batarg("s",oid),arg("digits",int),arg("scale",int))),
6442 : command("calc", "bte", int_dec2_bte, false, "cast decimal(int) to bte and check for overflow", args(1,3, arg("",bte),arg("s1",int),arg("v",int))),
6443 : command("calc", "bte", int_dec2dec_bte, false, "cast decimal(int) to decimal(bte) and check for overflow", args(1,5, arg("",bte),arg("s1",int),arg("v",int),arg("d2",int),arg("s2",int))),
6444 : command("batcalc", "bte", batint_dec2_bte, false, "cast decimal(int) to bte and check for overflow", args(1,4, batarg("",bte),arg("s1",int),batarg("v",int),batarg("s",oid))),
6445 : command("batcalc", "bte", batint_dec2dec_bte, false, "cast decimal(int) to decimal(bte) and check for overflow", args(1,6, batarg("",bte),arg("s1",int),batarg("v",int),batarg("s",oid),arg("d2",int),arg("s2",int))),
6446 : command("calc", "bte", lng_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,4, arg("",bte),arg("v",lng),arg("digits",int),arg("scale",int))),
6447 : command("batcalc", "bte", batlng_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,5, batarg("",bte),batarg("v",lng),batarg("s",oid),arg("digits",int),arg("scale",int))),
6448 : command("calc", "bte", lng_dec2_bte, false, "cast decimal(lng) to bte and check for overflow", args(1,3, arg("",bte),arg("s1",int),arg("v",lng))),
6449 : command("calc", "bte", lng_dec2dec_bte, false, "cast decimal(lng) to decimal(bte) and check for overflow", args(1,5, arg("",bte),arg("s1",int),arg("v",lng),arg("d2",int),arg("s2",int))),
6450 : command("batcalc", "bte", batlng_dec2_bte, false, "cast decimal(lng) to bte and check for overflow", args(1,4, batarg("",bte),arg("s1",int),batarg("v",lng),batarg("s",oid))),
6451 : command("batcalc", "bte", batlng_dec2dec_bte, false, "cast decimal(lng) to decimal(bte) and check for overflow", args(1,6, batarg("",bte),arg("s1",int),batarg("v",lng),batarg("s",oid),arg("d2",int),arg("s2",int))),
6452 : command("calc", "sht", bte_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,4, arg("",sht),arg("v",bte),arg("digits",int),arg("scale",int))),
6453 : command("batcalc", "sht", batbte_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,5, batarg("",sht),batarg("v",bte),batarg("s",oid),arg("digits",int),arg("scale",int))),
6454 : command("calc", "sht", bte_dec2_sht, false, "cast decimal(bte) to sht and check for overflow", args(1,3, arg("",sht),arg("s1",int),arg("v",bte))),
6455 : command("calc", "sht", bte_dec2dec_sht, false, "cast decimal(bte) to decimal(sht) and check for overflow", args(1,5, arg("",sht),arg("s1",int),arg("v",bte),arg("d2",int),arg("s2",int))),
6456 : command("batcalc", "sht", batbte_dec2_sht, false, "cast decimal(bte) to sht and check for overflow", args(1,4, batarg("",sht),arg("s1",int),batarg("v",bte),batarg("s",oid))),
6457 : command("batcalc", "sht", batbte_dec2dec_sht, false, "cast decimal(bte) to decimal(sht) and check for overflow", args(1,6, batarg("",sht),arg("s1",int),batarg("v",bte),batarg("s",oid),arg("d2",int),arg("s2",int))),
6458 : command("calc", "sht", sht_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,4, arg("",sht),arg("v",sht),arg("digits",int),arg("scale",int))),
6459 : command("batcalc", "sht", batsht_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,5, batarg("",sht),batarg("v",sht),batarg("s",oid),arg("digits",int),arg("scale",int))),
6460 : command("calc", "sht", sht_dec2_sht, false, "cast decimal(sht) to sht and check for overflow", args(1,3, arg("",sht),arg("s1",int),arg("v",sht))),
6461 : command("calc", "sht", sht_dec2dec_sht, false, "cast decimal(sht) to decimal(sht) and check for overflow", args(1,5, arg("",sht),arg("s1",int),arg("v",sht),arg("d2",int),arg("s2",int))),
6462 : command("batcalc", "sht", batsht_dec2_sht, false, "cast decimal(sht) to sht and check for overflow", args(1,4, batarg("",sht),arg("s1",int),batarg("v",sht),batarg("s",oid))),
6463 : command("batcalc", "sht", batsht_dec2dec_sht, false, "cast decimal(sht) to decimal(sht) and check for overflow", args(1,6, batarg("",sht),arg("s1",int),batarg("v",sht),batarg("s",oid),arg("d2",int),arg("s2",int))),
6464 : command("calc", "sht", int_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,4, arg("",sht),arg("v",int),arg("digits",int),arg("scale",int))),
6465 : command("batcalc", "sht", batint_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,5, batarg("",sht),batarg("v",int),batarg("s",oid),arg("digits",int),arg("scale",int))),
6466 : command("calc", "sht", int_dec2_sht, false, "cast decimal(int) to sht and check for overflow", args(1,3, arg("",sht),arg("s1",int),arg("v",int))),
6467 : command("calc", "sht", int_dec2dec_sht, false, "cast decimal(int) to decimal(sht) and check for overflow", args(1,5, arg("",sht),arg("s1",int),arg("v",int),arg("d2",int),arg("s2",int))),
6468 : command("batcalc", "sht", batint_dec2_sht, false, "cast decimal(int) to sht and check for overflow", args(1,4, batarg("",sht),arg("s1",int),batarg("v",int),batarg("s",oid))),
6469 : command("batcalc", "sht", batint_dec2dec_sht, false, "cast decimal(int) to decimal(sht) and check for overflow", args(1,6, batarg("",sht),arg("s1",int),batarg("v",int),batarg("s",oid),arg("d2",int),arg("s2",int))),
6470 : command("calc", "sht", lng_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,4, arg("",sht),arg("v",lng),arg("digits",int),arg("scale",int))),
6471 : command("batcalc", "sht", batlng_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,5, batarg("",sht),batarg("v",lng),batarg("s",oid),arg("digits",int),arg("scale",int))),
6472 : command("calc", "sht", lng_dec2_sht, false, "cast decimal(lng) to sht and check for overflow", args(1,3, arg("",sht),arg("s1",int),arg("v",lng))),
6473 : command("calc", "sht", lng_dec2dec_sht, false, "cast decimal(lng) to decimal(sht) and check for overflow", args(1,5, arg("",sht),arg("s1",int),arg("v",lng),arg("d2",int),arg("s2",int))),
6474 : command("batcalc", "sht", batlng_dec2_sht, false, "cast decimal(lng) to sht and check for overflow", args(1,4, batarg("",sht),arg("s1",int),batarg("v",lng),batarg("s",oid))),
6475 : command("batcalc", "sht", batlng_dec2dec_sht, false, "cast decimal(lng) to decimal(sht) and check for overflow", args(1,6, batarg("",sht),arg("s1",int),batarg("v",lng),batarg("s",oid),arg("d2",int),arg("s2",int))),
6476 : command("calc", "int", bte_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,4, arg("",int),arg("v",bte),arg("digits",int),arg("scale",int))),
6477 : command("batcalc", "int", batbte_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,5, batarg("",int),batarg("v",bte),batarg("s",oid),arg("digits",int),arg("scale",int))),
6478 : command("calc", "int", bte_dec2_int, false, "cast decimal(bte) to int and check for overflow", args(1,3, arg("",int),arg("s1",int),arg("v",bte))),
6479 : command("calc", "int", bte_dec2dec_int, false, "cast decimal(bte) to decimal(int) and check for overflow", args(1,5, arg("",int),arg("s1",int),arg("v",bte),arg("d2",int),arg("s2",int))),
6480 : command("batcalc", "int", batbte_dec2_int, false, "cast decimal(bte) to int and check for overflow", args(1,4, batarg("",int),arg("s1",int),batarg("v",bte),batarg("s",oid))),
6481 : command("batcalc", "int", batbte_dec2dec_int, false, "cast decimal(bte) to decimal(int) and check for overflow", args(1,6, batarg("",int),arg("s1",int),batarg("v",bte),batarg("s",oid),arg("d2",int),arg("s2",int))),
6482 : command("calc", "int", sht_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,4, arg("",int),arg("v",sht),arg("digits",int),arg("scale",int))),
6483 : command("batcalc", "int", batsht_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,5, batarg("",int),batarg("v",sht),batarg("s",oid),arg("digits",int),arg("scale",int))),
6484 : command("calc", "int", sht_dec2_int, false, "cast decimal(sht) to int and check for overflow", args(1,3, arg("",int),arg("s1",int),arg("v",sht))),
6485 : command("calc", "int", sht_dec2dec_int, false, "cast decimal(sht) to decimal(int) and check for overflow", args(1,5, arg("",int),arg("s1",int),arg("v",sht),arg("d2",int),arg("s2",int))),
6486 : command("batcalc", "int", batsht_dec2_int, false, "cast decimal(sht) to int and check for overflow", args(1,4, batarg("",int),arg("s1",int),batarg("v",sht),batarg("s",oid))),
6487 : command("batcalc", "int", batsht_dec2dec_int, false, "cast decimal(sht) to decimal(int) and check for overflow", args(1,6, batarg("",int),arg("s1",int),batarg("v",sht),batarg("s",oid),arg("d2",int),arg("s2",int))),
6488 : command("calc", "int", int_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,4, arg("",int),arg("v",int),arg("digits",int),arg("scale",int))),
6489 : command("batcalc", "int", batint_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,5, batarg("",int),batarg("v",int),batarg("s",oid),arg("digits",int),arg("scale",int))),
6490 : command("calc", "int", int_dec2_int, false, "cast decimal(int) to int and check for overflow", args(1,3, arg("",int),arg("s1",int),arg("v",int))),
6491 : command("calc", "int", int_dec2dec_int, false, "cast decimal(int) to decimal(int) and check for overflow", args(1,5, arg("",int),arg("s1",int),arg("v",int),arg("d2",int),arg("s2",int))),
6492 : command("batcalc", "int", batint_dec2_int, false, "cast decimal(int) to int and check for overflow", args(1,4, batarg("",int),arg("s1",int),batarg("v",int),batarg("s",oid))),
6493 : command("batcalc", "int", batint_dec2dec_int, false, "cast decimal(int) to decimal(int) and check for overflow", args(1,6, batarg("",int),arg("s1",int),batarg("v",int),batarg("s",oid),arg("d2",int),arg("s2",int))),
6494 : command("calc", "int", lng_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,4, arg("",int),arg("v",lng),arg("digits",int),arg("scale",int))),
6495 : command("batcalc", "int", batlng_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,5, batarg("",int),batarg("v",lng),batarg("s",oid),arg("digits",int),arg("scale",int))),
6496 : command("calc", "int", lng_dec2_int, false, "cast decimal(lng) to int and check for overflow", args(1,3, arg("",int),arg("s1",int),arg("v",lng))),
6497 : command("calc", "int", lng_dec2dec_int, false, "cast decimal(lng) to decimal(int) and check for overflow", args(1,5, arg("",int),arg("s1",int),arg("v",lng),arg("d2",int),arg("s2",int))),
6498 : command("batcalc", "int", batlng_dec2_int, false, "cast decimal(lng) to int and check for overflow", args(1,4, batarg("",int),arg("s1",int),batarg("v",lng),batarg("s",oid))),
6499 : command("batcalc", "int", batlng_dec2dec_int, false, "cast decimal(lng) to decimal(int) and check for overflow", args(1,6, batarg("",int),arg("s1",int),batarg("v",lng),batarg("s",oid),arg("d2",int),arg("s2",int))),
6500 : command("calc", "lng", bte_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,4, arg("",lng),arg("v",bte),arg("digits",int),arg("scale",int))),
6501 : command("batcalc", "lng", batbte_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,5, batarg("",lng),batarg("v",bte),batarg("s",oid),arg("digits",int),arg("scale",int))),
6502 : command("calc", "lng", bte_dec2_lng, false, "cast decimal(bte) to lng and check for overflow", args(1,3, arg("",lng),arg("s1",int),arg("v",bte))),
6503 : command("calc", "lng", bte_dec2dec_lng, false, "cast decimal(bte) to decimal(lng) and check for overflow", args(1,5, arg("",lng),arg("s1",int),arg("v",bte),arg("d2",int),arg("s2",int))),
6504 : command("batcalc", "lng", batbte_dec2_lng, false, "cast decimal(bte) to lng and check for overflow", args(1,4, batarg("",lng),arg("s1",int),batarg("v",bte),batarg("s",oid))),
6505 : command("batcalc", "lng", batbte_dec2dec_lng, false, "cast decimal(bte) to decimal(lng) and check for overflow", args(1,6, batarg("",lng),arg("s1",int),batarg("v",bte),batarg("s",oid),arg("d2",int),arg("s2",int))),
6506 : command("calc", "lng", sht_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,4, arg("",lng),arg("v",sht),arg("digits",int),arg("scale",int))),
6507 : command("batcalc", "lng", batsht_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,5, batarg("",lng),batarg("v",sht),batarg("s",oid),arg("digits",int),arg("scale",int))),
6508 : command("calc", "lng", sht_dec2_lng, false, "cast decimal(sht) to lng and check for overflow", args(1,3, arg("",lng),arg("s1",int),arg("v",sht))),
6509 : command("calc", "lng", sht_dec2dec_lng, false, "cast decimal(sht) to decimal(lng) and check for overflow", args(1,5, arg("",lng),arg("s1",int),arg("v",sht),arg("d2",int),arg("s2",int))),
6510 : command("batcalc", "lng", batsht_dec2_lng, false, "cast decimal(sht) to lng and check for overflow", args(1,4, batarg("",lng),arg("s1",int),batarg("v",sht),batarg("s",oid))),
6511 : command("batcalc", "lng", batsht_dec2dec_lng, false, "cast decimal(sht) to decimal(lng) and check for overflow", args(1,6, batarg("",lng),arg("s1",int),batarg("v",sht),batarg("s",oid),arg("d2",int),arg("s2",int))),
6512 : command("calc", "lng", int_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,4, arg("",lng),arg("v",int),arg("digits",int),arg("scale",int))),
6513 : command("batcalc", "lng", batint_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,5, batarg("",lng),batarg("v",int),batarg("s",oid),arg("digits",int),arg("scale",int))),
6514 : command("calc", "lng", int_dec2_lng, false, "cast decimal(int) to lng and check for overflow", args(1,3, arg("",lng),arg("s1",int),arg("v",int))),
6515 : command("calc", "lng", int_dec2dec_lng, false, "cast decimal(int) to decimal(lng) and check for overflow", args(1,5, arg("",lng),arg("s1",int),arg("v",int),arg("d2",int),arg("s2",int))),
6516 : command("batcalc", "lng", batint_dec2_lng, false, "cast decimal(int) to lng and check for overflow", args(1,4, batarg("",lng),arg("s1",int),batarg("v",int),batarg("s",oid))),
6517 : command("batcalc", "lng", batint_dec2dec_lng, false, "cast decimal(int) to decimal(lng) and check for overflow", args(1,6, batarg("",lng),arg("s1",int),batarg("v",int),batarg("s",oid),arg("d2",int),arg("s2",int))),
6518 : command("calc", "lng", lng_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,4, arg("",lng),arg("v",lng),arg("digits",int),arg("scale",int))),
6519 : command("batcalc", "lng", batlng_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,5, batarg("",lng),batarg("v",lng),batarg("s",oid),arg("digits",int),arg("scale",int))),
6520 : command("calc", "lng", lng_dec2_lng, false, "cast decimal(lng) to lng and check for overflow", args(1,3, arg("",lng),arg("s1",int),arg("v",lng))),
6521 : command("calc", "lng", lng_dec2dec_lng, false, "cast decimal(lng) to decimal(lng) and check for overflow", args(1,5, arg("",lng),arg("s1",int),arg("v",lng),arg("d2",int),arg("s2",int))),
6522 : command("batcalc", "lng", batlng_dec2_lng, false, "cast decimal(lng) to lng and check for overflow", args(1,4, batarg("",lng),arg("s1",int),batarg("v",lng),batarg("s",oid))),
6523 : command("batcalc", "lng", batlng_dec2dec_lng, false, "cast decimal(lng) to decimal(lng) and check for overflow", args(1,6, batarg("",lng),arg("s1",int),batarg("v",lng),batarg("s",oid),arg("d2",int),arg("s2",int))),
6524 : command("calc", "flt", bte_num2dec_flt, false, "cast number to decimal(flt) and check for overflow", args(1,4, arg("",flt),arg("v",bte),arg("digits",int),arg("scale",int))),
6525 : command("batcalc", "flt", batbte_num2dec_flt, false, "cast number to decimal(flt) and check for overflow", args(1,5, batarg("",flt),batarg("v",bte),batarg("s",oid),arg("digits",int),arg("scale",int))),
6526 : command("calc", "flt", bte_dec2_flt, false, "cast decimal(bte) to flt and check for overflow", args(1,3, arg("",flt),arg("s1",int),arg("v",bte))),
6527 : command("calc", "flt", bte_dec2dec_flt, false, "cast decimal(bte) to decimal(flt) and check for overflow", args(1,5, arg("",flt),arg("s1",int),arg("v",bte),arg("d2",int),arg("s2",int))),
6528 : command("batcalc", "flt", batbte_dec2_flt, false, "cast decimal(bte) to flt and check for overflow", args(1,4, batarg("",flt),arg("s1",int),batarg("v",bte),batarg("s",oid))),
6529 : command("batcalc", "flt", batbte_dec2dec_flt, false, "cast decimal(bte) to decimal(flt) and check for overflow", args(1,6, batarg("",flt),arg("s1",int),batarg("v",bte),batarg("s",oid),arg("d2",int),arg("s2",int))),
6530 : command("calc", "flt", sht_num2dec_flt, false, "cast number to decimal(flt) and check for overflow", args(1,4, arg("",flt),arg("v",sht),arg("digits",int),arg("scale",int))),
6531 : command("batcalc", "flt", batsht_num2dec_flt, false, "cast number to decimal(flt) and check for overflow", args(1,5, batarg("",flt),batarg("v",sht),batarg("s",oid),arg("digits",int),arg("scale",int))),
6532 : command("calc", "flt", sht_dec2_flt, false, "cast decimal(sht) to flt and check for overflow", args(1,3, arg("",flt),arg("s1",int),arg("v",sht))),
6533 : command("calc", "flt", sht_dec2dec_flt, false, "cast decimal(sht) to decimal(flt) and check for overflow", args(1,5, arg("",flt),arg("s1",int),arg("v",sht),arg("d2",int),arg("s2",int))),
6534 : command("batcalc", "flt", batsht_dec2_flt, false, "cast decimal(sht) to flt and check for overflow", args(1,4, batarg("",flt),arg("s1",int),batarg("v",sht),batarg("s",oid))),
6535 : command("batcalc", "flt", batsht_dec2dec_flt, false, "cast decimal(sht) to decimal(flt) and check for overflow", args(1,6, batarg("",flt),arg("s1",int),batarg("v",sht),batarg("s",oid),arg("d2",int),arg("s2",int))),
6536 : command("calc", "flt", int_num2dec_flt, false, "cast number to decimal(flt) and check for overflow", args(1,4, arg("",flt),arg("v",int),arg("digits",int),arg("scale",int))),
6537 : command("batcalc", "flt", batint_num2dec_flt, false, "cast number to decimal(flt) and check for overflow", args(1,5, batarg("",flt),batarg("v",int),batarg("s",oid),arg("digits",int),arg("scale",int))),
6538 : command("calc", "flt", int_dec2_flt, false, "cast decimal(int) to flt and check for overflow", args(1,3, arg("",flt),arg("s1",int),arg("v",int))),
6539 : command("calc", "flt", int_dec2dec_flt, false, "cast decimal(int) to decimal(flt) and check for overflow", args(1,5, arg("",flt),arg("s1",int),arg("v",int),arg("d2",int),arg("s2",int))),
6540 : command("batcalc", "flt", batint_dec2_flt, false, "cast decimal(int) to flt and check for overflow", args(1,4, batarg("",flt),arg("s1",int),batarg("v",int),batarg("s",oid))),
6541 : command("batcalc", "flt", batint_dec2dec_flt, false, "cast decimal(int) to decimal(flt) and check for overflow", args(1,6, batarg("",flt),arg("s1",int),batarg("v",int),batarg("s",oid),arg("d2",int),arg("s2",int))),
6542 : command("calc", "flt", lng_num2dec_flt, false, "cast number to decimal(flt) and check for overflow", args(1,4, arg("",flt),arg("v",lng),arg("digits",int),arg("scale",int))),
6543 : command("batcalc", "flt", batlng_num2dec_flt, false, "cast number to decimal(flt) and check for overflow", args(1,5, batarg("",flt),batarg("v",lng),batarg("s",oid),arg("digits",int),arg("scale",int))),
6544 : command("calc", "flt", lng_dec2_flt, false, "cast decimal(lng) to flt and check for overflow", args(1,3, arg("",flt),arg("s1",int),arg("v",lng))),
6545 : command("calc", "flt", lng_dec2dec_flt, false, "cast decimal(lng) to decimal(flt) and check for overflow", args(1,5, arg("",flt),arg("s1",int),arg("v",lng),arg("d2",int),arg("s2",int))),
6546 : command("batcalc", "flt", batlng_dec2_flt, false, "cast decimal(lng) to flt and check for overflow", args(1,4, batarg("",flt),arg("s1",int),batarg("v",lng),batarg("s",oid))),
6547 : command("batcalc", "flt", batlng_dec2dec_flt, false, "cast decimal(lng) to decimal(flt) and check for overflow", args(1,6, batarg("",flt),arg("s1",int),batarg("v",lng),batarg("s",oid),arg("d2",int),arg("s2",int))),
6548 : command("calc", "dbl", bte_num2dec_dbl, false, "cast number to decimal(dbl) and check for overflow", args(1,4, arg("",dbl),arg("v",bte),arg("digits",int),arg("scale",int))),
6549 : command("batcalc", "dbl", batbte_num2dec_dbl, false, "cast number to decimal(dbl) and check for overflow", args(1,5, batarg("",dbl),batarg("v",bte),batarg("s",oid),arg("digits",int),arg("scale",int))),
6550 : command("calc", "dbl", bte_dec2_dbl, false, "cast decimal(bte) to dbl and check for overflow", args(1,3, arg("",dbl),arg("s1",int),arg("v",bte))),
6551 : command("calc", "dbl", bte_dec2dec_dbl, false, "cast decimal(bte) to decimal(dbl) and check for overflow", args(1,5, arg("",dbl),arg("s1",int),arg("v",bte),arg("d2",int),arg("s2",int))),
6552 : command("batcalc", "dbl", batbte_dec2_dbl, false, "cast decimal(bte) to dbl and check for overflow", args(1,4, batarg("",dbl),arg("s1",int),batarg("v",bte),batarg("s",oid))),
6553 : command("batcalc", "dbl", batbte_dec2dec_dbl, false, "cast decimal(bte) to decimal(dbl) and check for overflow", args(1,6, batarg("",dbl),arg("s1",int),batarg("v",bte),batarg("s",oid),arg("d2",int),arg("s2",int))),
6554 : command("calc", "dbl", sht_num2dec_dbl, false, "cast number to decimal(dbl) and check for overflow", args(1,4, arg("",dbl),arg("v",sht),arg("digits",int),arg("scale",int))),
6555 : command("batcalc", "dbl", batsht_num2dec_dbl, false, "cast number to decimal(dbl) and check for overflow", args(1,5, batarg("",dbl),batarg("v",sht),batarg("s",oid),arg("digits",int),arg("scale",int))),
6556 : command("calc", "dbl", sht_dec2_dbl, false, "cast decimal(sht) to dbl and check for overflow", args(1,3, arg("",dbl),arg("s1",int),arg("v",sht))),
6557 : command("calc", "dbl", sht_dec2dec_dbl, false, "cast decimal(sht) to decimal(dbl) and check for overflow", args(1,5, arg("",dbl),arg("s1",int),arg("v",sht),arg("d2",int),arg("s2",int))),
6558 : command("batcalc", "dbl", batsht_dec2_dbl, false, "cast decimal(sht) to dbl and check for overflow", args(1,4, batarg("",dbl),arg("s1",int),batarg("v",sht),batarg("s",oid))),
6559 : command("batcalc", "dbl", batsht_dec2dec_dbl, false, "cast decimal(sht) to decimal(dbl) and check for overflow", args(1,6, batarg("",dbl),arg("s1",int),batarg("v",sht),batarg("s",oid),arg("d2",int),arg("s2",int))),
6560 : command("calc", "dbl", int_num2dec_dbl, false, "cast number to decimal(dbl) and check for overflow", args(1,4, arg("",dbl),arg("v",int),arg("digits",int),arg("scale",int))),
6561 : command("batcalc", "dbl", batint_num2dec_dbl, false, "cast number to decimal(dbl) and check for overflow", args(1,5, batarg("",dbl),batarg("v",int),batarg("s",oid),arg("digits",int),arg("scale",int))),
6562 : command("calc", "dbl", int_dec2_dbl, false, "cast decimal(int) to dbl and check for overflow", args(1,3, arg("",dbl),arg("s1",int),arg("v",int))),
6563 : command("calc", "dbl", int_dec2dec_dbl, false, "cast decimal(int) to decimal(dbl) and check for overflow", args(1,5, arg("",dbl),arg("s1",int),arg("v",int),arg("d2",int),arg("s2",int))),
6564 : command("batcalc", "dbl", batint_dec2_dbl, false, "cast decimal(int) to dbl and check for overflow", args(1,4, batarg("",dbl),arg("s1",int),batarg("v",int),batarg("s",oid))),
6565 : command("batcalc", "dbl", batint_dec2dec_dbl, false, "cast decimal(int) to decimal(dbl) and check for overflow", args(1,6, batarg("",dbl),arg("s1",int),batarg("v",int),batarg("s",oid),arg("d2",int),arg("s2",int))),
6566 : command("calc", "dbl", lng_num2dec_dbl, false, "cast number to decimal(dbl) and check for overflow", args(1,4, arg("",dbl),arg("v",lng),arg("digits",int),arg("scale",int))),
6567 : command("batcalc", "dbl", batlng_num2dec_dbl, false, "cast number to decimal(dbl) and check for overflow", args(1,5, batarg("",dbl),batarg("v",lng),batarg("s",oid),arg("digits",int),arg("scale",int))),
6568 : command("calc", "dbl", lng_dec2_dbl, false, "cast decimal(lng) to dbl and check for overflow", args(1,3, arg("",dbl),arg("s1",int),arg("v",lng))),
6569 : command("calc", "dbl", lng_dec2dec_dbl, false, "cast decimal(lng) to decimal(dbl) and check for overflow", args(1,5, arg("",dbl),arg("s1",int),arg("v",lng),arg("d2",int),arg("s2",int))),
6570 : command("batcalc", "dbl", batlng_dec2_dbl, false, "cast decimal(lng) to dbl and check for overflow", args(1,4, batarg("",dbl),arg("s1",int),batarg("v",lng),batarg("s",oid))),
6571 : command("batcalc", "dbl", batlng_dec2dec_dbl, false, "cast decimal(lng) to decimal(dbl) and check for overflow", args(1,6, batarg("",dbl),arg("s1",int),batarg("v",lng),batarg("s",oid),arg("d2",int),arg("s2",int))),
6572 : /* sql_rank */
6573 : pattern("sql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,2, arg("",bit),argany("b",1))),
6574 : pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,2, batarg("",bit),batargany("b",1))),
6575 : pattern("sql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, arg("",bit),arg("p",bit),argany("b",1))),
6576 : pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, batarg("",bit),arg("p",bit),batargany("b",1))),
6577 : pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, batarg("",bit),batarg("p",bit),argany("b",1))),
6578 : pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, batarg("",bit),batarg("p",bit),batargany("b",1))),
6579 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, arg("",oid),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",bte))),
6580 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, batarg("",oid),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",bte))),
6581 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, arg("",oid),arg("p",bit),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",bte))),
6582 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, batarg("",oid),batarg("p",bit),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",bte))),
6583 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, arg("",oid),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",sht))),
6584 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, batarg("",oid),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",sht))),
6585 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, arg("",oid),arg("p",bit),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",sht))),
6586 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, batarg("",oid),batarg("p",bit),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",sht))),
6587 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, arg("",oid),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",int))),
6588 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, batarg("",oid),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",int))),
6589 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, arg("",oid),arg("p",bit),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",int))),
6590 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, batarg("",oid),batarg("p",bit),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",int))),
6591 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, arg("",oid),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",lng))),
6592 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, batarg("",oid),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",lng))),
6593 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, arg("",oid),arg("p",bit),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",lng))),
6594 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, batarg("",oid),batarg("p",bit),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",lng))),
6595 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, arg("",oid),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",flt))),
6596 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, batarg("",oid),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",flt))),
6597 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, arg("",oid),arg("p",bit),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",flt))),
6598 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, batarg("",oid),batarg("p",bit),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",flt))),
6599 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, arg("",oid),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",dbl))),
6600 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, batarg("",oid),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",dbl))),
6601 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, arg("",oid),arg("p",bit),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",dbl))),
6602 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, batarg("",oid),batarg("p",bit),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",dbl))),
6603 : pattern("sql", "row_number", SQLrow_number, false, "return the row_numer-ed groups", args(1,4, arg("",int),argany("b",1),arg("p",bit),arg("o",bit))),
6604 : pattern("batsql", "row_number", SQLrow_number, false, "return the row_numer-ed groups", args(1,4, batarg("",int),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit))),
6605 : pattern("sql", "rank", SQLrank, false, "return the ranked groups", args(1,4, arg("",int),argany("b",1),arg("p",bit),arg("o",bit))),
6606 : pattern("batsql", "rank", SQLrank, false, "return the ranked groups", args(1,4, batarg("",int),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit))),
6607 : pattern("sql", "dense_rank", SQLdense_rank, false, "return the densely ranked groups", args(1,4, arg("",int),argany("b",1),arg("p",bit),arg("o",bit))),
6608 : pattern("batsql", "dense_rank", SQLdense_rank, false, "return the densely ranked groups", args(1,4, batarg("",int),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit))),
6609 : pattern("sql", "percent_rank", SQLpercent_rank, false, "return the percentage into the total number of groups for each row", args(1,4, arg("",dbl),argany("b",1),arg("p",bit),arg("o",bit))),
6610 : pattern("batsql", "percent_rank", SQLpercent_rank, false, "return the percentage into the total number of groups for each row", args(1,4, batarg("",dbl),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit))),
6611 : pattern("sql", "cume_dist", SQLcume_dist, false, "return the accumulated distribution of the number of rows per group to the total number of partition rows", args(1,4, arg("",dbl),argany("b",1),arg("p",bit),arg("o",bit))),
6612 : pattern("batsql", "cume_dist", SQLcume_dist, false, "return the accumulated distribution of the number of rows per group to the total number of partition rows", args(1,4, batarg("",dbl),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit))),
6613 : pattern("sql", "lag", SQLlag, false, "return the value in the previous row in the partition or NULL if non existent", args(1,4, argany("",1),argany("b",1),arg("p",bit),arg("o",bit))),
6614 : pattern("batsql", "lag", SQLlag, false, "return the value in the previous row in the partition or NULL if non existent", args(1,4, batargany("",1),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit))),
6615 : pattern("sql", "lag", SQLlag, false, "return the value in the previous 'l' row in the partition or NULL if non existent", args(1,5, argany("",1),argany("b",1),argany("l",0),arg("p",bit),arg("o",bit))),
6616 : pattern("batsql", "lag", SQLlag, false, "return the value in the previous 'l' row in the partition or NULL if non existent", args(1,5, batargany("",1),optbatargany("b",1),optbatargany("l",0),optbatarg("p",bit),optbatarg("o",bit))),
6617 : pattern("sql", "lag", SQLlag, false, "return the value in the previous 'l' row in the partition or 'd' if non existent", args(1,6, argany("",1),argany("b",1),argany("l",0),argany("d",1),arg("p",bit),arg("o",bit))),
6618 : pattern("batsql", "lag", SQLlag, false, "return the value in the previous 'l' row in the partition or 'd' if non existent", args(1,6, batargany("",1),optbatargany("b",1),optbatargany("l",0),optbatargany("d",1),optbatarg("p",bit),optbatarg("o",bit))),
6619 : pattern("sql", "lead", SQLlead, false, "return the value in the next row in the partition or NULL if non existent", args(1,4, argany("",1),argany("b",1),arg("p",bit),arg("o",bit))),
6620 : pattern("batsql", "lead", SQLlead, false, "return the value in the next row in the partition or NULL if non existent", args(1,4, batargany("",1),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit))),
6621 : pattern("sql", "lead", SQLlead, false, "return the value in the next 'l' row in the partition or NULL if non existent", args(1,5, argany("",1),argany("b",1),argany("l",0),arg("p",bit),arg("o",bit))),
6622 : pattern("batsql", "lead", SQLlead, false, "return the value in the next 'l' row in the partition or NULL if non existent", args(1,5, batargany("",1),optbatargany("b",1),optbatargany("l",0),optbatarg("p",bit),optbatarg("o",bit))),
6623 : pattern("sql", "lead", SQLlead, false, "return the value in the next 'l' row in the partition or 'd' if non existent", args(1,6, argany("",1),argany("b",1),argany("l",0),argany("d",1),arg("p",bit),arg("o",bit))),
6624 : pattern("batsql", "lead", SQLlead, false, "return the value in the next 'l' row in the partition or 'd' if non existent", args(1,6, batargany("",1),optbatargany("b",1),optbatargany("l",0),optbatargany("d",1),optbatarg("p",bit),optbatarg("o",bit))),
6625 : pattern("sql", "ntile", SQLntile, false, "return the groups divided as equally as possible", args(1,5, argany("",1),argany("b",0),argany("n",1),arg("p",bit),arg("o",bit))),
6626 : pattern("batsql", "ntile", SQLntile, false, "return the groups divided as equally as possible", args(1,5, batargany("",1),optbatargany("b",0),optbatargany("n",1),optbatarg("p",bit),optbatarg("o",bit))),
6627 : /* these window functions support frames */
6628 : pattern("sql", "first_value", SQLfirst_value, false, "return the first value of groups", args(1,7, argany("",1),argany("b",1),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6629 : pattern("batsql", "first_value", SQLfirst_value, false, "return the first value of groups", args(1,7, batargany("",1),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6630 : pattern("sql", "last_value", SQLlast_value, false, "return the last value of groups", args(1,7, argany("",1),argany("b",1),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6631 : pattern("batsql", "last_value", SQLlast_value, false, "return the last value of groups", args(1,7, batargany("",1),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6632 : pattern("sql", "nth_value", SQLnth_value, false, "return the nth value of each group", args(1,8, argany("",1),argany("b",1),arg("n",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6633 : pattern("batsql", "nth_value", SQLnth_value, false, "return the nth value of each group", args(1,8, batargany("",1),optbatargany("b",1),optbatarg("n",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6634 : pattern("sql", "min", SQLmin, false, "return the minimum of groups", args(1,7, argany("",1),argany("b",1),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6635 : pattern("batsql", "min", SQLmin, false, "return the minimum of groups", args(1,7, batargany("",1),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6636 : pattern("sql", "max", SQLmax, false, "return the maximum of groups", args(1,7, argany("",1),argany("b",1),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6637 : pattern("batsql", "max", SQLmax, false, "return the maximum of groups",args(1,7, batargany("",1),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6638 : pattern("sql", "count", SQLbasecount, false, "return count of basetable", args(1,3, arg("",lng),arg("sname",str),arg("tname",str))),
6639 : pattern("sql", "count", SQLcount, false, "return count of groups", args(1,8, arg("",lng),argany("b",1),arg("ignils",bit),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6640 : pattern("batsql", "count", SQLcount, false,"return count of groups",args(1,8, batarg("",lng),batargany("b",1),arg("ignils",bit),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6641 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",lng),arg("b",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6642 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",lng),batarg("b",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6643 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",lng),arg("b",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6644 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",lng),batarg("b",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6645 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",lng),arg("b",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6646 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",lng),batarg("b",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6647 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",lng),arg("b",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6648 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",lng),batarg("b",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6649 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",flt),arg("b",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6650 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",flt),batarg("b",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6651 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",dbl),arg("b",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6652 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",dbl),batarg("b",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6653 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",dbl),arg("b",dbl),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6654 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",dbl),batarg("b",dbl),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6655 : /* sql.sum for month intervals */
6656 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",int),arg("b",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6657 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",int),batarg("b",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6658 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",lng),arg("b",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6659 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",lng),batarg("b",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6660 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",lng),arg("b",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6661 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",lng),batarg("b",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6662 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",lng),arg("b",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6663 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",lng),batarg("b",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6664 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",lng),arg("b",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6665 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",lng),batarg("b",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6666 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",flt),arg("b",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6667 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",flt),batarg("b",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6668 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",dbl),arg("b",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6669 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",dbl),batarg("b",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6670 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",dbl),arg("b",dbl),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6671 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",dbl),batarg("b",dbl),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6672 : pattern("sql", "avg", SQLavg, false, "return the average of groups", args(1,7, arg("",dbl),arg("b",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6673 : pattern("batsql", "avg", SQLavg, false, "return the average of groups", args(1,7, batarg("",dbl),batarg("b",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6674 : pattern("sql", "avg", SQLavg, false, "return the average of groups", args(1,7, arg("",dbl),arg("b",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6675 : pattern("batsql", "avg", SQLavg, false, "return the average of groups", args(1,7, batarg("",dbl),batarg("b",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6676 : pattern("sql", "avg", SQLavg, false, "return the average of groups", args(1,7, arg("",dbl),arg("b",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6677 : pattern("batsql", "avg", SQLavg, false, "return the average of groups", args(1,7, batarg("",dbl),batarg("b",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6678 : pattern("sql", "avg", SQLavg, false, "return the average of groups", args(1,7, arg("",dbl),arg("b",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6679 : pattern("batsql", "avg", SQLavg, false, "return the average of groups", args(1,7, batarg("",dbl),batarg("b",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6680 : pattern("sql", "avg", SQLavg, false, "return the average of groups", args(1,7, arg("",dbl),arg("b",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6681 : pattern("batsql", "avg", SQLavg, false, "return the average of groups", args(1,7, batarg("",dbl),batarg("b",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6682 : pattern("sql", "avg", SQLavg, false, "return the average of groups", args(1,7, arg("",dbl),arg("b",dbl),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6683 : pattern("batsql", "avg", SQLavg, false, "return the average of groups", args(1,7, batarg("",dbl),batarg("b",dbl),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6684 : pattern("sql", "avg", SQLavginteger, false, "return the average of groups", args(1,7, arg("",bte),arg("b",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6685 : pattern("batsql", "avg", SQLavginteger, false, "return the average of groups", args(1,7, batarg("",bte),batarg("b",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6686 : pattern("sql", "avg", SQLavginteger, false, "return the average of groups", args(1,7, arg("",sht),arg("b",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6687 : pattern("batsql", "avg", SQLavginteger, false, "return the average of groups", args(1,7, batarg("",sht),batarg("b",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6688 : pattern("sql", "avg", SQLavginteger, false, "return the average of groups", args(1,7, arg("",int),arg("b",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6689 : pattern("batsql", "avg", SQLavginteger, false, "return the average of groups", args(1,7, batarg("",int),batarg("b",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6690 : pattern("sql", "avg", SQLavginteger, false, "return the average of groups", args(1,7, arg("",lng),arg("b",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6691 : pattern("batsql", "avg", SQLavginteger, false, "return the average of groups", args(1,7, batarg("",lng),batarg("b",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6692 : pattern("sql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, arg("",dbl),arg("b",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6693 : pattern("batsql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, batarg("",dbl),batarg("b",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6694 : pattern("sql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, arg("",dbl),arg("b",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6695 : pattern("batsql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, batarg("",dbl),batarg("b",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6696 : pattern("sql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, arg("",dbl),arg("b",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6697 : pattern("batsql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, batarg("",dbl),batarg("b",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6698 : pattern("sql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, arg("",dbl),arg("b",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6699 : pattern("batsql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, batarg("",dbl),batarg("b",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6700 : pattern("sql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, arg("",dbl),arg("b",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6701 : pattern("batsql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, batarg("",dbl),batarg("b",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6702 : pattern("sql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, arg("",dbl),arg("b",dbl),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6703 : pattern("batsql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, batarg("",dbl),batarg("b",dbl),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6704 : pattern("sql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, arg("",dbl),arg("b",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6705 : pattern("batsql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, batarg("",dbl),batarg("b",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6706 : pattern("sql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, arg("",dbl),arg("b",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6707 : pattern("batsql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, batarg("",dbl),batarg("b",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6708 : pattern("sql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, arg("",dbl),arg("b",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6709 : pattern("batsql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, batarg("",dbl),batarg("b",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6710 : pattern("sql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, arg("",dbl),arg("b",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6711 : pattern("batsql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, batarg("",dbl),batarg("b",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6712 : pattern("sql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, arg("",dbl),arg("b",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6713 : pattern("batsql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, batarg("",dbl),batarg("b",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6714 : pattern("sql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, arg("",dbl),arg("b",dbl),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6715 : pattern("batsql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, batarg("",dbl),batarg("b",dbl),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6716 : pattern("sql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, arg("",dbl),arg("b",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6717 : pattern("batsql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, batarg("",dbl),batarg("b",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6718 : pattern("sql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, arg("",dbl),arg("b",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6719 : pattern("batsql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, batarg("",dbl),batarg("b",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6720 : pattern("sql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, arg("",dbl),arg("b",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6721 : pattern("batsql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, batarg("",dbl),batarg("b",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6722 : pattern("sql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, arg("",dbl),arg("b",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6723 : pattern("batsql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, batarg("",dbl),batarg("b",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6724 : pattern("sql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, arg("",dbl),arg("b",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6725 : pattern("batsql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, batarg("",dbl),batarg("b",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6726 : pattern("sql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, arg("",dbl),arg("b",dbl),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6727 : pattern("batsql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, batarg("",dbl),batarg("b",dbl),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6728 : pattern("sql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, arg("",dbl),arg("b",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6729 : pattern("batsql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, batarg("",dbl),batarg("b",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6730 : pattern("sql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, arg("",dbl),arg("b",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6731 : pattern("batsql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, batarg("",dbl),batarg("b",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6732 : pattern("sql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, arg("",dbl),arg("b",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6733 : pattern("batsql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, batarg("",dbl),batarg("b",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6734 : pattern("sql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, arg("",dbl),arg("b",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6735 : pattern("batsql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, batarg("",dbl),batarg("b",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6736 : pattern("sql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, arg("",dbl),arg("b",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6737 : pattern("batsql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, batarg("",dbl),batarg("b",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6738 : pattern("sql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, arg("",dbl),arg("b",dbl),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6739 : pattern("batsql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, batarg("",dbl),batarg("b",dbl),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6740 : pattern("sql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, arg("",dbl),arg("b",bte),arg("c",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6741 : pattern("batsql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, batarg("",dbl),optbatarg("b",bte),optbatarg("c",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6742 : pattern("sql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, arg("",dbl),arg("b",sht),arg("c",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6743 : pattern("batsql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, batarg("",dbl),optbatarg("b",sht),optbatarg("c",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6744 : pattern("sql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, arg("",dbl),arg("b",int),arg("c",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6745 : pattern("batsql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, batarg("",dbl),optbatarg("b",int),optbatarg("c",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6746 : pattern("sql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, arg("",dbl),arg("b",lng),arg("c",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6747 : pattern("batsql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, batarg("",dbl),optbatarg("b",lng),optbatarg("c",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6748 : pattern("sql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, arg("",dbl),arg("b",flt),arg("c",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6749 : pattern("batsql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, batarg("",dbl),optbatarg("b",flt),optbatarg("c",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6750 : pattern("sql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, arg("",dbl),arg("b",dbl),arg("c",dbl),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6751 : pattern("batsql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, batarg("",dbl),optbatarg("b",dbl),optbatarg("c",dbl),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6752 : pattern("sql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, arg("",dbl),arg("b",bte),arg("c",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6753 : pattern("batsql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, batarg("",dbl),optbatarg("b",bte),optbatarg("c",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6754 : pattern("sql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, arg("",dbl),arg("b",sht),arg("c",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6755 : pattern("batsql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, batarg("",dbl),optbatarg("b",sht),optbatarg("c",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6756 : pattern("sql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, arg("",dbl),arg("b",int),arg("c",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6757 : pattern("batsql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, batarg("",dbl),optbatarg("b",int),optbatarg("c",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6758 : pattern("sql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, arg("",dbl),arg("b",lng),arg("c",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6759 : pattern("batsql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, batarg("",dbl),optbatarg("b",lng),optbatarg("c",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6760 : pattern("sql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, arg("",dbl),arg("b",flt),arg("c",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6761 : pattern("batsql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, batarg("",dbl),optbatarg("b",flt),optbatarg("c",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6762 : pattern("sql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, arg("",dbl),arg("b",dbl),arg("c",dbl),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6763 : pattern("batsql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, batarg("",dbl),optbatarg("b",dbl),optbatarg("c",dbl),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6764 : pattern("sql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, arg("",dbl),arg("b",bte),arg("c",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6765 : pattern("batsql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, batarg("",dbl),optbatarg("b",bte),optbatarg("c",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6766 : pattern("sql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, arg("",dbl),arg("b",sht),arg("c",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6767 : pattern("batsql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, batarg("",dbl),optbatarg("b",sht),optbatarg("c",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6768 : pattern("sql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, arg("",dbl),arg("b",int),arg("c",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6769 : pattern("batsql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, batarg("",dbl),optbatarg("b",int),optbatarg("c",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6770 : pattern("sql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, arg("",dbl),arg("b",lng),arg("c",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6771 : pattern("batsql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, batarg("",dbl),optbatarg("b",lng),optbatarg("c",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6772 : pattern("sql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, arg("",dbl),arg("b",flt),arg("c",flt),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6773 : pattern("batsql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, batarg("",dbl),optbatarg("b",flt),optbatarg("c",flt),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6774 : pattern("sql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, arg("",dbl),arg("b",dbl),arg("c",dbl),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6775 : pattern("batsql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, batarg("",dbl),optbatarg("b",dbl),optbatarg("c",dbl),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6776 : pattern("sql", "str_group_concat", SQLstrgroup_concat, false, "return the string concatenation of groups", args(1,7, arg("",str),arg("b",str),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6777 : pattern("batsql", "str_group_concat", SQLstrgroup_concat, false, "return the string concatenation of groups", args(1,7, batarg("",str),batarg("b",str),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6778 : pattern("sql", "str_group_concat", SQLstrgroup_concat, false, "return the string concatenation of groups with a custom separator", args(1,8, arg("",str),arg("b",str),arg("sep",str),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6779 : pattern("batsql", "str_group_concat", SQLstrgroup_concat, false, "return the string concatenation of groups with a custom separator", args(1,8, batarg("",str),optbatarg("b",str),optbatarg("sep",str),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6780 : /* sql_subquery */
6781 : command("aggr", "zero_or_one", zero_or_one, false, "if col contains exactly one value return this. In case of more raise an exception else return nil", args(1,2, argany("",1),batargany("col",1))),
6782 : command("aggr", "zero_or_one", zero_or_one_error, false, "if col contains exactly one value return this. In case of more raise an exception if err is true else return nil", args(1,3, argany("",1),batargany("col",1),arg("err",bit))),
6783 : command("aggr", "zero_or_one", zero_or_one_error_bat, false, "if col contains exactly one value return this. In case of more raise an exception if err is true else return nil", args(1,3, argany("",1),batargany("col",1),batarg("err",bit))),
6784 : command("aggr", "subzero_or_one", SQLsubzero_or_one, false, "", args(1,5, batargany("",1),batargany("b",1),batarg("g",oid),batarg("e",oid),arg("no_nil",bit))),
6785 : command("aggr", "all", SQLall, false, "if all values in b are equal return this, else nil", args(1,2, argany("",1),batargany("b",1))),
6786 : pattern("aggr", "suball", SQLall_grp, false, "if all values in l are equal (per group) return the value, else nil", args(1,5, batargany("",1),batargany("l",1),batarg("g",oid),batarg("e",oid),arg("no_nil",bit))),
6787 : pattern("aggr", "suball", SQLall_grp, false, "if all values in l are equal (per group) return the value, else nil", args(1,6, batargany("",1),batargany("l",1),batarg("g",oid),batarg("e",oid),batarg("s",oid),arg("no_nil",bit))),
6788 : command("aggr", "null", SQLnil, false, "if b has a nil return true, else false", args(1,2, arg("",bit),batargany("b",1))),
6789 : pattern("aggr", "subnull", SQLnil_grp, false, "if any value in l is nil with in a group return true for that group, else false", args(1,5, batarg("",bit),batargany("l",1),batarg("g",oid),batarg("e",oid),arg("no_nil",bit))),
6790 : pattern("aggr", "subnull", SQLnil_grp, false, "if any value in l is nil with in a group return true for that group, else false; with candidate list", args(1,6, batarg("",bit),batargany("l",1),batarg("g",oid),batarg("e",oid),batarg("s",oid),arg("no_nil",bit))),
6791 : pattern("sql", "any", SQLany_cmp, false, "if cmp then true, (nl or nr) nil then nil, else false", args(1,4, arg("",bit),arg("cmp",bit),arg("nl",bit),arg("nr",bit))),
6792 : pattern("batsql", "any", SQLany_cmp, false, "if cmp then true, (nl or nr) nil then nil, else false", args(1,4, batarg("",bit),batarg("cmp",bit),arg("nl",bit),arg("nr",bit))),
6793 : pattern("batsql", "any", SQLany_cmp, false, "if cmp then true, (nl or nr) nil then nil, else false", args(1,4, batarg("",bit),arg("cmp",bit),batarg("nl",bit),arg("nr",bit))),
6794 : pattern("batsql", "any", SQLany_cmp, false, "if cmp then true, (nl or nr) nil then nil, else false", args(1,4, batarg("",bit),arg("cmp",bit),arg("nl",bit),batarg("nr",bit))),
6795 : pattern("batsql", "any", SQLany_cmp, false, "if cmp then true, (nl or nr) nil then nil, else false", args(1,4, batarg("",bit),arg("cmp",bit),batarg("nl",bit),batarg("nr",bit))),
6796 : pattern("batsql", "any", SQLany_cmp, false, "if cmp then true, (nl or nr) nil then nil, else false", args(1,4, batarg("",bit),batarg("cmp",bit),arg("nl",bit),batarg("nr",bit))),
6797 : pattern("batsql", "any", SQLany_cmp, false, "if cmp then true, (nl or nr) nil then nil, else false", args(1,4, batarg("",bit),batarg("cmp",bit),batarg("nl",bit),arg("nr",bit))),
6798 : pattern("batsql", "any", SQLany_cmp, false, "if cmp then true, (nl or nr) nil then nil, else false", args(1,4, batarg("",bit),batarg("cmp",bit),batarg("nl",bit),batarg("nr",bit))),
6799 : pattern("sql", "all", SQLall_cmp, false, "if !cmp then false, (nl or nr) then nil, else true", args(1,4, arg("",bit),arg("cmp",bit),arg("nl",bit),arg("nr",bit))),
6800 : pattern("batsql", "all", SQLall_cmp, false, "if !cmp then false, (nl or nr) then nil, else true", args(1,4, batarg("",bit),batarg("cmp",bit),arg("nl",bit),arg("nr",bit))),
6801 : pattern("batsql", "all", SQLall_cmp, false, "if !cmp then false, (nl or nr) then nil, else true", args(1,4, batarg("",bit),arg("cmp",bit),batarg("nl",bit),arg("nr",bit))),
6802 : pattern("batsql", "all", SQLall_cmp, false, "if !cmp then false, (nl or nr) then nil, else true", args(1,4, batarg("",bit),arg("cmp",bit),arg("nl",bit),batarg("nr",bit))),
6803 : pattern("batsql", "all", SQLall_cmp, false, "if !cmp then false, (nl or nr) then nil, else true", args(1,4, batarg("",bit),arg("cmp",bit),batarg("nl",bit),batarg("nr",bit))),
6804 : pattern("batsql", "all", SQLall_cmp, false, "if !cmp then false, (nl or nr) then nil, else true", args(1,4, batarg("",bit),batarg("cmp",bit),arg("nl",bit),batarg("nr",bit))),
6805 : pattern("batsql", "all", SQLall_cmp, false, "if !cmp then false, (nl or nr) then nil, else true", args(1,4, batarg("",bit),batarg("cmp",bit),batarg("nl",bit),arg("nr",bit))),
6806 : pattern("batsql", "all", SQLall_cmp, false, "if !cmp then false, (nl or nr) then nil, else true", args(1,4, batarg("",bit),batarg("cmp",bit),batarg("nl",bit),batarg("nr",bit))),
6807 : pattern("aggr", "anyequal", SQLanyequal, false, "if any value in r is equal to l, return true, else if r has nil, return nil, else return false", args(1,3, arg("",bit),batargany("l",1),batargany("r",1))),
6808 : pattern("bataggr", "anyequal", SQLanyequal, false, "if any value in r is equal to l, return true, else if r has nil, return nil, else return false", args(1,3, batarg("",bit),batargany("l",1),batargany("r",1))),
6809 : pattern("aggr", "allnotequal", SQLallnotequal, false, "if all values in r are not equal to l, return true, else if r has nil, return nil, else return false", args(1,3, arg("",bit),batargany("l",1),batargany("r",1))),
6810 : pattern("bataggr", "allnotequal", SQLallnotequal, false, "if all values in r are not equal to l, return true, else if r has nil, return nil, else return false", args(1,3, arg("",bit),batargany("l",1),batargany("r",1))),
6811 : pattern("aggr", "subanyequal", SQLanyequal_grp, false, "if any value in r is equal to l, return true, else if r has nil, return nil, else return false", args(1,6, batarg("",bit),batargany("l",1),batargany("r",1),batarg("g",oid),batarg("e",oid),arg("no_nil",bit))),
6812 : // pattern("aggr", "subanyequal", SQLanyequal_grp, false, "if any value in r is equal to l, return true, else if r has nil, return nil, else return false; with candidate list", args(1,7, batarg("",bit),batargany("l",1),batargany("r",1),batarg("g",oid),batarg("e",oid),batarg("s",oid),arg("no_nil",bit))),
6813 : pattern("aggr", "subanyequal", SQLanyequal_grp2, false, "if any value in r is equal to l, return true, else if r has nil, return nil, else return false, except if rid is nil (ie empty) then return false", args(1,7, batarg("",bit),batargany("l",1),batargany("r",1),batarg("rid",oid),batarg("g",oid),batarg("e",oid),arg("no_nil",bit))),
6814 : pattern("aggr", "subanyequal", SQLanyequal_grp2, false, "if any value in r is equal to l, return true, else if r has nil, return nil, else return false, except if rid is nil (ie empty) then return false; with candidate list", args(1,8, batarg("",bit),batargany("l",1),batargany("r",1),batarg("rid",oid),batarg("g",oid),batarg("e",oid),batarg("s",oid),arg("no_nil",bit))),
6815 : pattern("aggr", "suballnotequal", SQLallnotequal_grp, false, "if all values in r are not equal to l, return true, else if r has nil, return nil else return false", args(1,6, batarg("",bit),batargany("l",1),batargany("r",1),batarg("g",oid),batarg("e",oid),arg("no_nil",bit))),
6816 : // pattern("aggr", "suballnotequal", SQLallnotequal_grp, false, "if all values in r are not equal to l, return true, else if r has nil, return nil else return false; with candidate list", args(1,7, batarg("",bit),batargany("l",1),batargany("r",1),batarg("g",oid),batarg("e",oid),batarg("s",oid),arg("no_nil",bit))),
6817 : pattern("aggr", "suballnotequal", SQLallnotequal_grp2, false, "if all values in r are not equal to l, return true, else if r has nil return nil, else return false, except if rid is nil (ie empty) then return true", args(1,7, batarg("",bit),batargany("l",1),batargany("r",1),batarg("rid",oid),batarg("g",oid),batarg("e",oid),arg("no_nil",bit))),
6818 : pattern("aggr", "suballnotequal", SQLallnotequal_grp2, false, "if all values in r are not equal to l, return true, else if r has nil return nil, else return false, except if rid is nil (ie empty) then return true; with candidate list", args(1,8, batarg("",bit),batargany("l",1),batargany("r",1),batarg("rid",oid),batarg("g",oid),batarg("e",oid),batarg("s",oid),arg("no_nil",bit))),
6819 : pattern("aggr", "exist", SQLexist, false, "", args(1,2, arg("",bit), argany("b",1))),
6820 : pattern("bataggr", "exist", SQLexist, false, "", args(1,2, batarg("",bit), argany("b",1))),
6821 : pattern("bataggr", "exist", SQLexist, false, "", args(1,2, arg("",bit), batargany("b",1))),
6822 : pattern("bataggr", "exist", SQLexist, false, "", args(1,2, batarg("",bit), batargany("b",1))),
6823 : pattern("aggr", "subexist", SQLsubexist, false, "", args(1,5, batarg("",bit),batargany("b",0),batarg("g",oid),batarg("e",oid),arg("no_nil",bit))),
6824 : pattern("aggr", "subexist", SQLsubexist, false, "", args(1,6, batarg("",bit),batargany("b",0),batarg("g",oid),batarg("e",oid),batarg("s",oid),arg("no_nil",bit))),
6825 : pattern("aggr", "not_exist", SQLnot_exist, false, "", args(1,2, arg("",bit), argany("b",1))),
6826 : pattern("bataggr", "not_exist", SQLnot_exist, false, "", args(1,2, batarg("",bit), argany("b",1))),
6827 : pattern("bataggr", "not_exist", SQLnot_exist, false, "", args(1,2, arg("",bit), batargany("b",1))),
6828 : pattern("bataggr", "not_exist", SQLnot_exist, false, "", args(1,2, batarg("",bit), batargany("b",1))),
6829 : pattern("aggr", "subnot_exist", SQLsubnot_exist, false, "", args(1,5, batarg("",bit),batargany("b",0),batarg("g",oid),batarg("e",oid),arg("no_nil",bit))),
6830 : pattern("aggr", "subnot_exist", SQLsubnot_exist, false, "", args(1,6, batarg("",bit),batargany("b",0),batarg("g",oid),batarg("e",oid),batarg("s",oid),arg("no_nil",bit))),
6831 : /* sqlcatalog */
6832 : pattern("sqlcatalog", "create_seq", SQLcreate_seq, false, "Catalog operation create_seq", args(0,4, arg("sname",str),arg("seqname",str),arg("seq",ptr),arg("action",int))),
6833 : pattern("sqlcatalog", "alter_seq", SQLalter_seq, false, "Catalog operation alter_seq", args(0,4, arg("sname",str),arg("seqname",str),arg("seq",ptr),arg("val",lng))),
6834 : pattern("sqlcatalog", "alter_seq", SQLalter_seq, false, "Catalog operation alter_seq", args(0,4, arg("sname",str),arg("seqname",str),arg("seq",ptr),batarg("val",lng))),
6835 : pattern("sqlcatalog", "drop_seq", SQLdrop_seq, false, "Catalog operation drop_seq", args(0,3, arg("sname",str),arg("nme",str),arg("action",int))),
6836 : pattern("sqlcatalog", "create_schema", SQLcreate_schema, false, "Catalog operation create_schema", args(0,3, arg("sname",str),arg("auth",str),arg("action",int))),
6837 : pattern("sqlcatalog", "drop_schema", SQLdrop_schema, false, "Catalog operation drop_schema", args(0,3, arg("sname",str),arg("ifexists",int),arg("action",int))),
6838 : pattern("sqlcatalog", "create_table", SQLcreate_table, false, "Catalog operation create_table", args(0,4, arg("sname",str),arg("tname",str),arg("tbl",ptr),arg("temp",int))),
6839 : pattern("sqlcatalog", "create_table", SQLcreate_table, false, "Catalog operation create_table", args(0,6, arg("sname",str),arg("tname",str),arg("tbl",ptr),arg("pw_encrypted",int),arg("username",str),arg("passwd",str))),
6840 : pattern("sqlcatalog", "create_view", SQLcreate_view, false, "Catalog operation create_view", args(0,5, arg("sname",str),arg("vname",str),arg("tbl",ptr),arg("temp",int),arg("replace",int))),
6841 : pattern("sqlcatalog", "drop_table", SQLdrop_table, false, "Catalog operation drop_table", args(0,4, arg("sname",str),arg("name",str),arg("action",int),arg("ifexists",int))),
6842 : pattern("sqlcatalog", "drop_view", SQLdrop_view, false, "Catalog operation drop_view", args(0,4, arg("sname",str),arg("name",str),arg("action",int),arg("ifexists",int))),
6843 : pattern("sqlcatalog", "drop_constraint", SQLdrop_constraint, false, "Catalog operation drop_constraint", args(0,5, arg("sname",str),arg("tname",str),arg("name",str),arg("action",int),arg("ifexists",int))),
6844 : pattern("sqlcatalog", "alter_table", SQLalter_table, false, "Catalog operation alter_table", args(0,4, arg("sname",str),arg("tname",str),arg("tbl",ptr),arg("action",int))),
6845 : pattern("sqlcatalog", "create_type", SQLcreate_type, false, "Catalog operation create_type", args(0,3, arg("sname",str),arg("nme",str),arg("impl",str))),
6846 : pattern("sqlcatalog", "create_type", SQLcreate_type, false, "Catalog operation create_type", args(0,3, arg("sname",str),arg("nme",str),arg("fields",ptr))),
6847 : pattern("sqlcatalog", "drop_type", SQLdrop_type, false, "Catalog operation drop_type", args(0,3, arg("sname",str),arg("nme",str),arg("action",int))),
6848 : pattern("sqlcatalog", "grant_roles", SQLgrant_roles, false, "Catalog operation grant_roles", args(0,4, arg("sname",str),arg("auth",str),arg("grantor",int),arg("admin",int))),
6849 : pattern("sqlcatalog", "revoke_roles", SQLrevoke_roles, false, "Catalog operation revoke_roles", args(0,4, arg("sname",str),arg("auth",str),arg("grantor",int),arg("admin",int))),
6850 : pattern("sqlcatalog", "grant", SQLgrant, false, "Catalog operation grant", args(0,7, arg("sname",str),arg("tbl",str),arg("grantee",str),arg("privs",int),arg("cname",str),arg("gr",int),arg("grantor",int))),
6851 : pattern("sqlcatalog", "revoke", SQLrevoke, false, "Catalog operation revoke", args(0,7, arg("sname",str),arg("tbl",str),arg("grantee",str),arg("privs",int),arg("cname",str),arg("grant",int),arg("grantor",int))),
6852 : pattern("sqlcatalog", "grant_function", SQLgrant_function, false, "Catalog operation grant_function", args(0,6, arg("sname",str),arg("fcnid",int),arg("grantee",str),arg("privs",int),arg("grant",int),arg("grantor",int))),
6853 : pattern("sqlcatalog", "revoke_function", SQLrevoke_function, false, "Catalog operation revoke_function", args(0,6, arg("sname",str),arg("fcnid",int),arg("grantee",str),arg("privs",int),arg("grant",int),arg("grantor",int))),
6854 : pattern("sqlcatalog", "create_user", SQLcreate_user, false, "Catalog operation create_user", args(0,10, arg("sname",str),arg("passwrd",str),arg("enc",int),arg("schema",str),arg("schemapath",str),arg("fullname",str), arg("max_memory", lng), arg("max_workers", int), arg("optimizer", str), arg("default_role", str))),
6855 : pattern("sqlcatalog", "drop_user", SQLdrop_user, false, "Catalog operation drop_user", args(0,2, arg("sname",str),arg("action",int))),
6856 : pattern("sqlcatalog", "drop_user", SQLdrop_user, false, "Catalog operation drop_user", args(0,3, arg("sname",str),arg("auth",str),arg("action",int))),
6857 : pattern("sqlcatalog", "alter_user", SQLalter_user, false, "Catalog operation alter_user", args(0,9, arg("sname",str),arg("passwrd",str),arg("enc",int),arg("schema",str),arg("schemapath",str),arg("oldpasswrd",str),arg("role",str),arg("max_memory",lng),arg("max_workers",int))),
6858 : pattern("sqlcatalog", "rename_user", SQLrename_user, false, "Catalog operation rename_user", args(0,3, arg("sname",str),arg("newnme",str),arg("action",int))),
6859 : pattern("sqlcatalog", "create_role", SQLcreate_role, false, "Catalog operation create_role", args(0,3, arg("sname",str),arg("role",str),arg("grator",int))),
6860 : pattern("sqlcatalog", "drop_role", SQLdrop_role, false, "Catalog operation drop_role", args(0,3, arg("auth",str),arg("role",str),arg("action",int))),
6861 : pattern("sqlcatalog", "drop_role", SQLdrop_role, false, "Catalog operation drop_role", args(0,2, arg("role",str),arg("action",int))),
6862 : pattern("sqlcatalog", "drop_index", SQLdrop_index, false, "Catalog operation drop_index", args(0,3, arg("sname",str),arg("iname",str),arg("action",int))),
6863 : pattern("sqlcatalog", "drop_function", SQLdrop_function, false, "Catalog operation drop_function", args(0,5, arg("sname",str),arg("fname",str),arg("fid",int),arg("type",int),arg("action",int))),
6864 : pattern("sqlcatalog", "create_function", SQLcreate_function, false, "Catalog operation create_function", args(0,4, arg("sname",str),arg("fname",str),arg("fcn",ptr),arg("replace",int))),
6865 : pattern("sqlcatalog", "create_trigger", SQLcreate_trigger, false, "Catalog operation create_trigger", args(0,11, arg("sname",str),arg("tname",str),arg("triggername",str),arg("time",int),arg("orientation",int),arg("event",int),arg("old",str),arg("new",str),arg("cond",str),arg("qry",str),arg("replace",int))),
6866 : pattern("sqlcatalog", "drop_trigger", SQLdrop_trigger, false, "Catalog operation drop_trigger", args(0,3, arg("sname",str),arg("nme",str),arg("ifexists",int))),
6867 : pattern("sqlcatalog", "alter_add_table", SQLalter_add_table, false, "Catalog operation alter_add_table", args(0,5, arg("sname",str),arg("mtnme",str),arg("psnme",str),arg("ptnme",str),arg("action",int))),
6868 : pattern("sqlcatalog", "alter_del_table", SQLalter_del_table, false, "Catalog operation alter_del_table", args(0,5, arg("sname",str),arg("mtnme",str),arg("psnme",str),arg("ptnme",str),arg("action",int))),
6869 : pattern("sqlcatalog", "alter_set_table", SQLalter_set_table, false, "Catalog operation alter_set_table", args(0,3, arg("sname",str),arg("tnme",str),arg("access",int))),
6870 : pattern("sqlcatalog", "alter_add_range_partition", SQLalter_add_range_partition, false, "Catalog operation alter_add_range_partition", args(0,9, arg("sname",str),arg("mtnme",str),arg("psnme",str),arg("ptnme",str),argany("min",1),argany("max",1),arg("nills",bit),arg("update",int),arg("assert",lng))),
6871 : pattern("sqlcatalog", "alter_add_range_partition", SQLalter_add_range_partition, false, "Catalog operation alter_add_range_partition", args(0,9, arg("sname",str),arg("mtnme",str),arg("psnme",str),arg("ptnme",str),argany("min",1),argany("max",1),arg("nills",bit),arg("update",int),batarg("assert",lng))),
6872 : pattern("sqlcatalog", "alter_add_value_partition", SQLalter_add_value_partition, false, "Catalog operation alter_add_value_partition", args(0,7, arg("sname",str),arg("mtnme",str),arg("psnme",str),arg("ptnme",str),arg("nills",bit),arg("update",int),arg("assert",lng))),
6873 : pattern("sqlcatalog", "alter_add_value_partition", SQLalter_add_value_partition, false, "Catalog operation alter_add_value_partition", args(0,8, arg("sname",str),arg("mtnme",str),arg("psnme",str),arg("ptnme",str),arg("nills",bit),arg("update",int),arg("assert",lng), varargany("arg",0))),
6874 : pattern("sqlcatalog", "alter_add_value_partition", SQLalter_add_value_partition, false, "Catalog operation alter_add_value_partition", args(0,7, arg("sname",str),arg("mtnme",str),arg("psnme",str),arg("ptnme",str),arg("nills",bit),arg("update",int),batarg("assert",lng))),
6875 : pattern("sqlcatalog", "alter_add_value_partition", SQLalter_add_value_partition, false, "Catalog operation alter_add_value_partition", args(0,8, arg("sname",str),arg("mtnme",str),arg("psnme",str),arg("ptnme",str),arg("nills",bit),arg("update",int),batarg("assert",lng), varargany("arg",0))),
6876 : pattern("sqlcatalog", "comment_on", SQLcomment_on, false, "Catalog operation comment_on", args(0,2, arg("objid",int),arg("remark",str))),
6877 : pattern("sqlcatalog", "rename_schema", SQLrename_schema, false, "Catalog operation rename_schema", args(0,2, arg("sname",str),arg("newnme",str))),
6878 : pattern("sqlcatalog", "rename_table", SQLrename_table, false, "Catalog operation rename_table", args(0,4, arg("osname",str),arg("nsname",str),arg("otname",str),arg("ntname",str))),
6879 : pattern("sqlcatalog", "rename_column", SQLrename_column, false, "Catalog operation rename_column", args(0,4, arg("sname",str),arg("tname",str),arg("cname",str),arg("newnme",str))),
6880 : /* sql_transaction */
6881 : pattern("sql", "transaction_release", SQLtransaction_release, true, "A transaction statement (type can be commit,release,rollback or start)", args(1,3, arg("",void),arg("chain",int),arg("name",str))),
6882 : pattern("sql", "transaction_commit", SQLtransaction_commit, true, "A transaction statement (type can be commit,release,rollback or start)", args(1,3, arg("",void),arg("chain",int),arg("name",str))),
6883 : pattern("sql", "transaction_rollback", SQLtransaction_rollback, true, "A transaction statement (type can be commit,release,rollback or start)", args(1,3, arg("",void),arg("chain",int),arg("name",str))),
6884 : pattern("sql", "transaction_begin", SQLtransaction_begin, true, "A transaction statement (type can be commit,release,rollback or start)", args(1,3, arg("",void),arg("chain",int),arg("name",str))),
6885 : #ifdef HAVE_HGE
6886 : /* sql_hge */
6887 : command("calc", "dec_round", hge_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, arg("",hge),arg("v",hge),arg("r",hge))),
6888 : pattern("batcalc", "dec_round", hge_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",hge),batarg("v",hge),arg("r",hge))),
6889 : pattern("batcalc", "dec_round", hge_bat_dec_round_wrap, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",hge),batarg("v",hge),arg("r",hge),batarg("s",oid))),
6890 : pattern("batcalc", "dec_round", hge_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",hge),arg("v",hge),batarg("r",hge))),
6891 : pattern("batcalc", "dec_round", hge_bat_dec_round_wrap_cst, false, "round off the value v to nearests multiple of r", args(1,4, batarg("",hge),arg("v",hge),batarg("r",hge),batarg("s",oid))),
6892 : pattern("batcalc", "dec_round", hge_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,3, batarg("",hge),batarg("v",hge),batarg("r",hge))),
6893 : pattern("batcalc", "dec_round", hge_bat_dec_round_wrap_nocst, false, "round off the value v to nearests multiple of r", args(1,5, batarg("",hge),batarg("v",hge),batarg("r",hge),batarg("s1",oid),batarg("s2",oid))),
6894 : command("calc", "round", hge_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, arg("",hge),arg("v",hge),arg("r",bte),arg("d",int),arg("s",int))),
6895 : pattern("batcalc", "round", hge_bat_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",hge),batarg("v",hge),arg("r",bte),arg("d",int),arg("s",int))),
6896 : pattern("batcalc", "round", hge_bat_round_wrap, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,6, batarg("",hge),batarg("v",hge),arg("r",bte),batarg("s",oid),arg("d",int),arg("s",int))),
6897 : pattern("batcalc", "round", hge_bat_round_wrap_cst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",hge),arg("v",hge),batarg("r",bte),arg("d",int),arg("s",int))),
6898 : pattern("batcalc", "round", hge_bat_round_wrap_cst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,6, batarg("",hge),arg("v",hge),batarg("r",bte),batarg("s",oid),arg("d",int),arg("s",int))),
6899 : pattern("batcalc", "round", hge_bat_round_wrap_nocst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,5, batarg("",hge),batarg("v",hge),batarg("r",bte),arg("d",int),arg("s",int))),
6900 : pattern("batcalc", "round", hge_bat_round_wrap_nocst, false, "round off the decimal v(d,s) to r digits behind the dot (if r < 0, before the dot)", args(1,7, batarg("",hge),batarg("v",hge),batarg("r",bte),batarg("s1",oid),batarg("s2",oid),arg("d",int),arg("s",int))),
6901 : command("calc", "second_interval", hge_dec2second_interval, false, "cast hge decimal to a second_interval", args(1,5, arg("",lng),arg("sc",int),arg("v",hge),arg("ek",int),arg("sk",int))),
6902 : pattern("batcalc", "second_interval", hge_batdec2second_interval, false, "cast hge decimal to a second_interval", args(1,6, batarg("",lng),arg("sc",int),batarg("v",hge),batarg("s",oid),arg("ek",int),arg("sk",int))),
6903 : command("calc", "hge", nil_2dec_hge, false, "cast to dec(hge) and check for overflow", args(1,4, arg("",hge),arg("v",void),arg("digits",int),arg("scale",int))),
6904 : command("batcalc", "hge", batnil_2dec_hge, false, "cast to dec(hge) and check for overflow", args(1,4, batarg("",hge),batarg("v",void),arg("digits",int),arg("scale",int))),
6905 : command("calc", "hge", str_2dec_hge, false, "cast to dec(hge) and check for overflow", args(1,4, arg("",hge),arg("v",str),arg("digits",int),arg("scale",int))),
6906 : pattern("batcalc", "hge", batstr_2dec_hge, false, "cast to dec(hge) and check for overflow", args(1,5, batarg("",hge),batarg("v",str),batarg("s",oid),arg("digits",int),arg("scale",int))),
6907 : pattern("calc", "month_interval", month_interval, false, "cast hge to a month_interval and check for overflow", args(1,4, arg("",int),arg("v",hge),arg("ek",int),arg("sk",int))),
6908 : pattern("batcalc", "month_interval", month_interval, false, "cast hge to a month_interval and check for overflow", args(1,5, batarg("",int),batarg("v",hge),batarg("s",oid),arg("ek",int),arg("sk",int))),
6909 : pattern("calc", "second_interval", second_interval, false, "cast hge to a second_interval and check for overflow", args(1,4, arg("",lng),arg("v",hge),arg("ek",int),arg("sk",int))),
6910 : pattern("batcalc", "second_interval", second_interval, false, "cast hge to a second_interval and check for overflow", args(1,5, batarg("",lng),batarg("v",hge),batarg("s",oid),arg("ek",int),arg("sk",int))),
6911 : /* sql_decimal_hge */
6912 : command("calc", "hge", flt_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,4, arg("",hge),arg("v",flt),arg("digits",int),arg("scale",int))),
6913 : command("batcalc", "hge", batflt_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,5, batarg("",hge),batarg("v",flt),batarg("s",oid),arg("digits",int),arg("scale",int))),
6914 : command("calc", "hge", dbl_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,4, arg("",hge),arg("v",dbl),arg("digits",int),arg("scale",int))),
6915 : command("batcalc", "hge", batdbl_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,5, batarg("",hge),batarg("v",dbl),batarg("s",oid),arg("digits",int),arg("scale",int))),
6916 : command("calc", "hge", bte_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,4, arg("",hge),arg("v",bte),arg("digits",int),arg("scale",int))),
6917 : command("batcalc", "hge", batbte_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,5, batarg("",hge),batarg("v",bte),batarg("s",oid),arg("digits",int),arg("scale",int))),
6918 : command("calc", "hge", bte_dec2_hge, false, "cast decimal(bte) to hge and check for overflow", args(1,3, arg("",hge),arg("s1",int),arg("v",bte))),
6919 : command("calc", "hge", bte_dec2dec_hge, false, "cast decimal(bte) to decimal(hge) and check for overflow", args(1,5, arg("",hge),arg("s1",int),arg("v",bte),arg("d2",int),arg("s2",int))),
6920 : command("batcalc", "hge", batbte_dec2_hge, false, "cast decimal(bte) to hge and check for overflow", args(1,4, batarg("",hge),arg("s1",int),batarg("v",bte),batarg("s",oid))),
6921 : command("batcalc", "hge", batbte_dec2dec_hge, false, "cast decimal(bte) to decimal(hge) and check for overflow", args(1,6, batarg("",hge),arg("s1",int),batarg("v",bte),batarg("s",oid),arg("d2",int),arg("s2",int))),
6922 : command("calc", "hge", sht_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,4, arg("",hge),arg("v",sht),arg("digits",int),arg("scale",int))),
6923 : command("batcalc", "hge", batsht_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,5, batarg("",hge),batarg("v",sht),batarg("s",oid),arg("digits",int),arg("scale",int))),
6924 : command("calc", "hge", sht_dec2_hge, false, "cast decimal(sht) to hge and check for overflow", args(1,3, arg("",hge),arg("s1",int),arg("v",sht))),
6925 : command("calc", "hge", sht_dec2dec_hge, false, "cast decimal(sht) to decimal(hge) and check for overflow", args(1,5, arg("",hge),arg("s1",int),arg("v",sht),arg("d2",int),arg("s2",int))),
6926 : command("batcalc", "hge", batsht_dec2_hge, false, "cast decimal(sht) to hge and check for overflow", args(1,4, batarg("",hge),arg("s1",int),batarg("v",sht),batarg("s",oid))),
6927 : command("batcalc", "hge", batsht_dec2dec_hge, false, "cast decimal(sht) to decimal(hge) and check for overflow", args(1,6, batarg("",hge),arg("s1",int),batarg("v",sht),batarg("s",oid),arg("d2",int),arg("s2",int))),
6928 : command("calc", "hge", int_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,4, arg("",hge),arg("v",int),arg("digits",int),arg("scale",int))),
6929 : command("batcalc", "hge", batint_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,5, batarg("",hge),batarg("v",int),batarg("s",oid),arg("digits",int),arg("scale",int))),
6930 : command("calc", "hge", int_dec2_hge, false, "cast decimal(int) to hge and check for overflow", args(1,3, arg("",hge),arg("s1",int),arg("v",int))),
6931 : command("calc", "hge", int_dec2dec_hge, false, "cast decimal(int) to decimal(hge) and check for overflow", args(1,5, arg("",hge),arg("s1",int),arg("v",int),arg("d2",int),arg("s2",int))),
6932 : command("batcalc", "hge", batint_dec2_hge, false, "cast decimal(int) to hge and check for overflow", args(1,4, batarg("",hge),arg("s1",int),batarg("v",int),batarg("s",oid))),
6933 : command("batcalc", "hge", batint_dec2dec_hge, false, "cast decimal(int) to decimal(hge) and check for overflow", args(1,6, batarg("",hge),arg("s1",int),batarg("v",int),batarg("s",oid),arg("d2",int),arg("s2",int))),
6934 : command("calc", "hge", lng_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,4, arg("",hge),arg("v",lng),arg("digits",int),arg("scale",int))),
6935 : command("batcalc", "hge", batlng_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,5, batarg("",hge),batarg("v",lng),batarg("s",oid),arg("digits",int),arg("scale",int))),
6936 : command("calc", "hge", lng_dec2_hge, false, "cast decimal(lng) to hge and check for overflow", args(1,3, arg("",hge),arg("s1",int),arg("v",lng))),
6937 : command("calc", "hge", lng_dec2dec_hge, false, "cast decimal(lng) to decimal(hge) and check for overflow", args(1,5, arg("",hge),arg("s1",int),arg("v",lng),arg("d2",int),arg("s2",int))),
6938 : command("batcalc", "hge", batlng_dec2_hge, false, "cast decimal(lng) to hge and check for overflow", args(1,4, batarg("",hge),arg("s1",int),batarg("v",lng),batarg("s",oid))),
6939 : command("batcalc", "hge", batlng_dec2dec_hge, false, "cast decimal(lng) to decimal(hge) and check for overflow", args(1,6, batarg("",hge),arg("s1",int),batarg("v",lng),batarg("s",oid),arg("d2",int),arg("s2",int))),
6940 : command("calc", "hge", hge_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,4, arg("",hge),arg("v",hge),arg("digits",int),arg("scale",int))),
6941 : command("batcalc", "hge", bathge_num2dec_hge, false, "cast number to decimal(hge) and check for overflow", args(1,5, batarg("",hge),batarg("v",hge),batarg("s",oid),arg("digits",int),arg("scale",int))),
6942 : command("calc", "hge", hge_dec2_hge, false, "cast decimal(hge) to hge and check for overflow", args(1,3, arg("",hge),arg("s1",int),arg("v",hge))),
6943 : command("calc", "hge", hge_dec2dec_hge, false, "cast decimal(hge) to decimal(hge) and check for overflow", args(1,5, arg("",hge),arg("s1",int),arg("v",hge),arg("d2",int),arg("s2",int))),
6944 : command("batcalc", "hge", bathge_dec2_hge, false, "cast decimal(hge) to hge and check for overflow", args(1,4, batarg("",hge),arg("s1",int),batarg("v",hge),batarg("s",oid))),
6945 : command("batcalc", "hge", bathge_dec2dec_hge, false, "cast decimal(hge) to decimal(hge) and check for overflow", args(1,6, batarg("",hge),arg("s1",int),batarg("v",hge),batarg("s",oid),arg("d2",int),arg("s2",int))),
6946 : command("calc", "bte", hge_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,4, arg("",bte),arg("v",hge),arg("digits",int),arg("scale",int))),
6947 : command("batcalc", "bte", bathge_num2dec_bte, false, "cast number to decimal(bte) and check for overflow", args(1,5, batarg("",bte),batarg("v",hge),batarg("s",oid),arg("digits",int),arg("scale",int))),
6948 : command("calc", "bte", hge_dec2_bte, false, "cast decimal(hge) to bte and check for overflow", args(1,3, arg("",bte),arg("s1",int),arg("v",hge))),
6949 : command("calc", "bte", hge_dec2dec_bte, false, "cast decimal(hge) to decimal(bte) and check for overflow", args(1,5, arg("",bte),arg("s1",int),arg("v",hge),arg("d2",int),arg("s2",int))),
6950 : command("batcalc", "bte", bathge_dec2_bte, false, "cast decimal(hge) to bte and check for overflow", args(1,4, batarg("",bte),arg("s1",int),batarg("v",hge),batarg("s",oid))),
6951 : command("batcalc", "bte", bathge_dec2dec_bte, false, "cast decimal(hge) to decimal(bte) and check for overflow", args(1,6, batarg("",bte),arg("s1",int),batarg("v",hge),batarg("s",oid),arg("d2",int),arg("s2",int))),
6952 : command("calc", "sht", hge_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,4, arg("",sht),arg("v",hge),arg("digits",int),arg("scale",int))),
6953 : command("batcalc", "sht", bathge_num2dec_sht, false, "cast number to decimal(sht) and check for overflow", args(1,5, batarg("",sht),batarg("v",hge),batarg("s",oid),arg("digits",int),arg("scale",int))),
6954 : command("calc", "sht", hge_dec2_sht, false, "cast decimal(hge) to sht and check for overflow", args(1,3, arg("",sht),arg("s1",int),arg("v",hge))),
6955 : command("calc", "sht", hge_dec2dec_sht, false, "cast decimal(hge) to decimal(sht) and check for overflow", args(1,5, arg("",sht),arg("s1",int),arg("v",hge),arg("d2",int),arg("s2",int))),
6956 : command("batcalc", "sht", bathge_dec2_sht, false, "cast decimal(hge) to sht and check for overflow", args(1,4, batarg("",sht),arg("s1",int),batarg("v",hge),batarg("s",oid))),
6957 : command("batcalc", "sht", bathge_dec2dec_sht, false, "cast decimal(hge) to decimal(sht) and check for overflow", args(1,6, batarg("",sht),arg("s1",int),batarg("v",hge),batarg("s",oid),arg("d2",int),arg("s2",int))),
6958 : command("calc", "int", hge_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,4, arg("",int),arg("v",hge),arg("digits",int),arg("scale",int))),
6959 : command("batcalc", "int", bathge_num2dec_int, false, "cast number to decimal(int) and check for overflow", args(1,5, batarg("",int),batarg("v",hge),batarg("s",oid),arg("digits",int),arg("scale",int))),
6960 : command("calc", "int", hge_dec2_int, false, "cast decimal(hge) to int and check for overflow", args(1,3, arg("",int),arg("s1",int),arg("v",hge))),
6961 : command("calc", "int", hge_dec2dec_int, false, "cast decimal(hge) to decimal(int) and check for overflow", args(1,5, arg("",int),arg("s1",int),arg("v",hge),arg("d2",int),arg("s2",int))),
6962 : command("batcalc", "int", bathge_dec2_int, false, "cast decimal(hge) to int and check for overflow", args(1,4, batarg("",int),arg("s1",int),batarg("v",hge),batarg("s",oid))),
6963 : command("batcalc", "int", bathge_dec2dec_int, false, "cast decimal(hge) to decimal(int) and check for overflow", args(1,6, batarg("",int),arg("s1",int),batarg("v",hge),batarg("s",oid),arg("d2",int),arg("s2",int))),
6964 : command("calc", "lng", hge_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,4, arg("",lng),arg("v",hge),arg("digits",int),arg("scale",int))),
6965 : command("batcalc", "lng", bathge_num2dec_lng, false, "cast number to decimal(lng) and check for overflow", args(1,5, batarg("",lng),batarg("v",hge),batarg("s",oid),arg("digits",int),arg("scale",int))),
6966 : command("calc", "lng", hge_dec2_lng, false, "cast decimal(hge) to lng and check for overflow", args(1,3, arg("",lng),arg("s1",int),arg("v",hge))),
6967 : command("calc", "lng", hge_dec2dec_lng, false, "cast decimal(hge) to decimal(lng) and check for overflow", args(1,5, arg("",lng),arg("s1",int),arg("v",hge),arg("d2",int),arg("s2",int))),
6968 : command("batcalc", "lng", bathge_dec2_lng, false, "cast decimal(hge) to lng and check for overflow", args(1,4, batarg("",lng),arg("s1",int),batarg("v",hge),batarg("s",oid))),
6969 : command("batcalc", "lng", bathge_dec2dec_lng, false, "cast decimal(hge) to decimal(lng) and check for overflow", args(1,6, batarg("",lng),arg("s1",int),batarg("v",hge),batarg("s",oid),arg("d2",int),arg("s2",int))),
6970 : command("calc", "flt", hge_num2dec_flt, false, "cast number to decimal(flt) and check for overflow", args(1,4, arg("",flt),arg("v",hge),arg("digits",int),arg("scale",int))),
6971 : command("batcalc", "flt", bathge_num2dec_flt, false, "cast number to decimal(flt) and check for overflow", args(1,5, batarg("",flt),batarg("v",hge),batarg("s",oid),arg("digits",int),arg("scale",int))),
6972 : command("calc", "flt", hge_dec2_flt, false, "cast decimal(hge) to flt and check for overflow", args(1,3, arg("",flt),arg("s1",int),arg("v",hge))),
6973 : command("calc", "flt", hge_dec2dec_flt, false, "cast decimal(hge) to decimal(flt) and check for overflow", args(1,5, arg("",flt),arg("s1",int),arg("v",hge),arg("d2",int),arg("s2",int))),
6974 : command("batcalc", "flt", bathge_dec2_flt, false, "cast decimal(hge) to flt and check for overflow", args(1,4, batarg("",flt),arg("s1",int),batarg("v",hge),batarg("s",oid))),
6975 : command("batcalc", "flt", bathge_dec2dec_flt, false, "cast decimal(hge) to decimal(flt) and check for overflow", args(1,6, batarg("",flt),arg("s1",int),batarg("v",hge),batarg("s",oid),arg("d2",int),arg("s2",int))),
6976 : command("calc", "dbl", hge_num2dec_dbl, false, "cast number to decimal(dbl) and check for overflow", args(1,4, arg("",dbl),arg("v",hge),arg("digits",int),arg("scale",int))),
6977 : command("batcalc", "dbl", bathge_num2dec_dbl, false, "cast number to decimal(dbl) and check for overflow", args(1,5, batarg("",dbl),batarg("v",hge),batarg("s",oid),arg("digits",int),arg("scale",int))),
6978 : command("calc", "dbl", hge_dec2_dbl, false, "cast decimal(hge) to dbl and check for overflow", args(1,3, arg("",dbl),arg("s1",int),arg("v",hge))),
6979 : command("calc", "dbl", hge_dec2dec_dbl, false, "cast decimal(hge) to decimal(dbl) and check for overflow", args(1,5, arg("",dbl),arg("s1",int),arg("v",hge),arg("d2",int),arg("s2",int))),
6980 : command("batcalc", "dbl", bathge_dec2_dbl, false, "cast decimal(hge) to dbl and check for overflow", args(1,4, batarg("",dbl),arg("s1",int),batarg("v",hge),batarg("s",oid))),
6981 : command("batcalc", "dbl", bathge_dec2dec_dbl, false, "cast decimal(hge) to decimal(dbl) and check for overflow", args(1,6, batarg("",dbl),arg("s1",int),batarg("v",hge),batarg("s",oid),arg("d2",int),arg("s2",int))),
6982 : /* sql_rank_hge */
6983 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, arg("",oid),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",hge))),
6984 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,6, batarg("",oid),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",hge))),
6985 : pattern("sql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, arg("",oid),arg("p",bit),argany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),arg("limit",hge))),
6986 : pattern("batsql", "window_bound", SQLwindow_bound, false, "computes window ranges for each row", args(1,7, batarg("",oid),batarg("p",bit),batargany("b",1),arg("unit",int),arg("bound",int),arg("excl",int),optbatarg("limit",hge))),
6987 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",hge),arg("b",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6988 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",hge),batarg("b",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6989 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",hge),arg("b",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6990 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",hge),batarg("b",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6991 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",hge),arg("b",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6992 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",hge),batarg("b",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6993 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",hge),arg("b",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6994 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",hge),batarg("b",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6995 : pattern("sql", "sum", SQLsum, false, "return the sum of groups", args(1,7, arg("",hge),arg("b",hge),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6996 : pattern("batsql", "sum", SQLsum, false, "return the sum of groups", args(1,7, batarg("",hge),batarg("b",hge),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6997 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",hge),arg("b",bte),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
6998 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",hge),batarg("b",bte),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
6999 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",hge),arg("b",sht),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7000 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",hge),batarg("b",sht),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7001 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",hge),arg("b",int),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7002 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",hge),batarg("b",int),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7003 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",hge),arg("b",lng),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7004 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",hge),batarg("b",lng),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7005 : pattern("sql", "prod", SQLprod, false, "return the product of groups", args(1,7, arg("",hge),arg("b",hge),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7006 : pattern("batsql", "prod", SQLprod, false, "return the product of groups", args(1,7, batarg("",hge),batarg("b",hge),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7007 : pattern("sql", "avg", SQLavg, false, "return the average of groups", args(1,7, arg("",dbl),arg("b",hge),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7008 : pattern("batsql", "avg", SQLavg, false, "return the average of groups", args(1,7, batarg("",dbl),batarg("b",hge),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7009 : pattern("sql", "avg", SQLavginteger, false, "return the average of groups", args(1,7, arg("",hge),arg("b",hge),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7010 : pattern("batsql", "avg", SQLavginteger, false, "return the average of groups", args(1,7, batarg("",hge),batarg("b",hge),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7011 : pattern("sql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, arg("",dbl),arg("b",hge),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7012 : pattern("batsql", "stdev", SQLstddev_samp, false, "return the standard deviation sample of groups", args(1,7, batarg("",dbl),batarg("b",hge),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7013 : pattern("sql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, arg("",dbl),arg("b",hge),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7014 : pattern("batsql", "stdevp", SQLstddev_pop, false, "return the standard deviation population of groups", args(1,7, batarg("",dbl),batarg("b",hge),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7015 : pattern("sql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, arg("",dbl),arg("b",hge),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7016 : pattern("batsql", "variance", SQLvar_samp, false, "return the variance sample of groups", args(1,7, batarg("",dbl),batarg("b",hge),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7017 : pattern("sql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, arg("",dbl),arg("b",hge),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7018 : pattern("batsql", "variancep", SQLvar_pop, false, "return the variance population of groups", args(1,7, batarg("",dbl),batarg("b",hge),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7019 : pattern("sql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, arg("",dbl),arg("b",hge),arg("c",hge),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7020 : pattern("batsql", "covariance", SQLcovar_samp, false, "return the covariance sample value of groups", args(1,8, batarg("",dbl),optbatarg("b",hge),optbatarg("c",hge),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7021 : pattern("sql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, arg("",dbl),arg("b",hge),arg("c",hge),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7022 : pattern("batsql", "covariancep", SQLcovar_pop, false, "return the covariance population value of groups", args(1,8, batarg("",dbl),optbatarg("b",hge),optbatarg("c",hge),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7023 : pattern("sql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, arg("",dbl),arg("b",hge),arg("c",hge),arg("p",bit),arg("o",bit),arg("t",int),arg("s",oid),arg("e",oid))),
7024 : pattern("batsql", "corr", SQLcorr, false, "return the correlation value of groups", args(1,8, batarg("",dbl),optbatarg("b",hge),optbatarg("c",hge),optbatarg("p",bit),optbatarg("o",bit),arg("t",int),optbatarg("s",oid),optbatarg("e",oid))),
7025 : #endif
7026 : pattern("sql", "vacuum", SQLstr_vacuum, true, "vacuum a string column", args(0,3, arg("sname",str),arg("tname",str),arg("cname",str))),
7027 : pattern("sql", "vacuum", SQLstr_auto_vacuum, true, "auto vacuum string column with interval(sec)", args(0,4, arg("sname",str),arg("tname",str),arg("cname",str),arg("interval", int))),
7028 : pattern("sql", "stop_vacuum", SQLstr_stop_vacuum, true, "stop auto vacuum", args(0,3, arg("sname",str),arg("tname",str),arg("cname",str))),
7029 : pattern("sql", "vacuum", SQLstr_vacuum, true, "vacuum a string column", args(0,2, arg("sname",str),arg("tname",str))),
7030 : pattern("sql", "vacuum", SQLstr_auto_vacuum, true, "auto vacuum string column of given table with interval(sec)", args(0,3, arg("sname",str),arg("tname",str),arg("interval", int))),
7031 : pattern("sql", "stop_vacuum", SQLstr_stop_vacuum, true, "stop auto vacuum", args(0,2, arg("sname",str),arg("tname",str))),
7032 : pattern("sql", "check", SQLcheck, false, "Return sql string of check constraint.", args(1,3, arg("sql",str), arg("sname", str), arg("name", str))),
7033 : pattern("sql", "read_dump_rel", SQLread_dump_rel, false, "Reads sql_rel string into sql_rel object and then writes it to the return value", args(1,2, arg("sql",str), arg("sql_rel", str))),
7034 : pattern("sql", "normalize_monetdb_url", SQLnormalize_monetdb_url, false, "Normalize mapi:monetdb://, monetdb:// or monetdbs:// URL", args(1,2, arg("",str),arg("u",str))),
7035 : pattern("sql", "from_json", SQLfrom_json, false, "Converts json string into table of nested/multiset structures", args(1,3, batvarargany("t",0), optbatarg("input", json), arg("type", ptr))),
7036 : pattern("sql", "to_json", SQLto_json, false, "Convert complex type into json", args(1,3, arg("res", json), arg("type", ptr), batvarargany("t",0))),
7037 : pattern("sql", "from_varchar", SQLfrom_varchar, false, "Converts string into table of nested/multiset structures", args(1,3, batvarargany("t",0), optbatarg("input", str), arg("type", ptr))),
7038 : { .imp=NULL }
7039 : };
7040 : #include "mal_import.h"
7041 : #ifdef _MSC_VER
7042 : #undef read
7043 : #pragma section(".CRT$XCU",read)
7044 : #endif
7045 348 : LIB_STARTUP_FUNC(init_sql_mal)
7046 348 : { mal_module("sql", NULL, sql_init_funcs); }
|
