Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : /*
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 "mal.h"
35 : #include "mal_client.h"
36 : #include "mal_interpreter.h"
37 : #include "mal_resolve.h"
38 : #include "mal_client.h"
39 : #include "mal_interpreter.h"
40 : #include "mal_scenario.h"
41 : #include "mal_profiler.h"
42 : #include "bat5.h"
43 : #include "opt_pipes.h"
44 : #include "clients.h"
45 : #include "mal_instruction.h"
46 : #include "mal_resource.h"
47 : #include "mal_authorize.h"
48 : #include "gdk_cand.h"
49 :
50 : static inline void
51 0 : BBPnreclaim(int nargs, ...)
52 : {
53 0 : va_list valist;
54 0 : va_start(valist, nargs);
55 0 : for (int i = 0; i < nargs; i++) {
56 0 : BAT *b = va_arg(valist, BAT *);
57 0 : BBPreclaim(b);
58 : }
59 0 : va_end(valist);
60 0 : }
61 :
62 : static int
63 19451 : rel_is_table(sql_rel *rel)
64 : {
65 19451 : if (!rel || is_base(rel->op))
66 14141 : return 1;
67 : return 0;
68 : }
69 :
70 : static int
71 14141 : exp_is_point_select(sql_exp *e)
72 : {
73 14141 : if (!e)
74 : return 1;
75 14141 : if (e->type == e_cmp && !e->f && e->flag == (int) cmp_equal) {
76 6957 : sql_exp *r = e->r;
77 6957 : sql_exp *l = e->l;
78 :
79 6957 : if (!is_func(l->type) && r->card <= CARD_AGGR)
80 6838 : return 1;
81 : }
82 : return 0;
83 : }
84 :
85 : static int
86 559863 : rel_no_mitosis(mvc *sql, sql_rel *rel)
87 : {
88 1304570 : if (mvc_highwater(sql))
89 : return 0;
90 966392 : if (!rel || is_basetable(rel->op))
91 : return 1;
92 : /* use mitosis on order topn */
93 793336 : if (is_topn(rel->op)) {
94 16469 : sql_rel *l = rel->l;
95 16469 : if (l && is_simple_project(l->op) && l->r)
96 : return 0;
97 : }
98 793047 : if (is_topn(rel->op) || is_sample(rel->op) || is_simple_project(rel->op))
99 314387 : return rel_no_mitosis(sql, rel->l);
100 478660 : if (is_ddl(rel->op) && rel->flag == ddl_output) {
101 : // COPY SELECT ... INTO
102 74 : return rel_no_mitosis(sql, rel->l);
103 : }
104 478586 : if ((is_delete(rel->op) || is_truncate(rel->op)) && rel->card <= CARD_AGGR)
105 : return 1;
106 436786 : if ((is_insert(rel->op) || is_update(rel->op)) && rel->card <= CARD_AGGR)
107 92065 : return rel_no_mitosis(sql, rel->r);
108 358862 : if (is_select(rel->op) && rel_is_table(rel->l) && !list_empty(rel->exps)) {
109 : /* just one point expression makes this a point query */
110 14141 : if (exp_is_point_select(rel->exps->h->data))
111 : return 1;
112 : }
113 : return 0;
114 : }
115 :
116 : static int
117 338172 : rel_need_distinct_query(sql_rel *rel)
118 : {
119 338172 : int need_distinct = 0;
120 :
121 381593 : while (rel && is_simple_project(rel->op))
122 43421 : rel = rel->l;
123 338172 : if (rel && is_groupby(rel->op) && !list_empty(rel->exps) && list_empty(rel->r)) {
124 2051 : for (node *n = rel->exps->h; n && !need_distinct; n = n->next) {
125 1104 : sql_exp *e = n->data;
126 :
127 1104 : if (e->type == e_aggr && need_distinct(e))
128 1104 : need_distinct = 1;
129 : }
130 : }
131 338172 : return need_distinct;
132 : }
133 :
134 : sql_rel *
135 562152 : sql_symbol2relation(backend *be, symbol *sym)
136 : {
137 562152 : sql_rel *rel;
138 562152 : sql_query *query = query_create(be->mvc);
139 562153 : lng Tbegin, Tend;
140 562153 : int value_based_opt = be->mvc->emode != m_prepare, storage_based_opt;
141 562153 : int profile = be->mvc->emode == m_plan;
142 562153 : Client c = be->client;
143 :
144 562153 : Tbegin = GDKusec();
145 562153 : rel = rel_semantic(query, sym);
146 562145 : Tend = GDKusec();
147 562146 : if(profilerStatus > 0 )
148 0 : profilerEvent(NULL,
149 : &(struct NonMalEvent)
150 0 : {SQL_TO_REL, c, Tend, NULL, NULL, rel?0:1, Tend-Tbegin});
151 :
152 562146 : storage_based_opt = value_based_opt && rel && !is_ddl(rel->op);
153 294866 : Tbegin = Tend;
154 2608 : if (rel)
155 559887 : rel = sql_processrelation(be->mvc, rel, profile, 1, value_based_opt, storage_based_opt);
156 559873 : if (rel)
157 559852 : rel = rel_partition(be->mvc, rel);
158 559865 : if (rel && (rel_no_mitosis(be->mvc, rel) || rel_need_distinct_query(rel)))
159 221747 : be->no_mitosis = 1;
160 559866 : if (rel /*&& (be->mvc->emode != m_plan || (ATOMIC_GET(&GDKdebug) & FORCEMITOMASK) == 0)*/)
161 559866 : rel = rel_physical(be->mvc, rel);
162 562134 : Tend = GDKusec();
163 562137 : be->reloptimizer = Tend - Tbegin;
164 :
165 562137 : if(profilerStatus > 0)
166 0 : profilerEvent(NULL,
167 : &(struct NonMalEvent)
168 0 : {REL_OPT, c, Tend, NULL, NULL, rel?0:1, be->reloptimizer});
169 562137 : return rel;
170 : }
171 :
172 : /*
173 : * After the SQL statement has been executed, its data structures
174 : * should be garbage collected. For successful actions we have to finish
175 : * the transaction as well, e.g. commit or rollback.
176 : */
177 : int
178 732386 : sqlcleanup(backend *be, int err)
179 : {
180 732386 : sql_destroy_params(be->mvc);
181 :
182 : /* some statements dynamically disable caching */
183 732369 : be->mvc->sym = NULL;
184 732369 : be->mvc->runs = NULL;
185 732369 : if (be->mvc->ta)
186 732374 : be->mvc->ta = sa_reset(be->mvc->ta);
187 732377 : if (be->mvc->sa)
188 732040 : be->mvc->sa = sa_reset(be->mvc->sa);
189 732362 : if (err >0)
190 373 : be->mvc->session->status = -err;
191 732362 : if (err <0)
192 34832 : be->mvc->session->status = err;
193 732362 : be->mvc->label = 0;
194 732362 : be->mvc->nid = 1;
195 732362 : be->no_mitosis = 0;
196 732362 : scanner_query_processed(&(be->mvc->scanner));
197 732376 : return err;
198 : }
199 :
200 : /*
201 : * The internal administration of the MAL compiler and execution state
202 : * is administered by a state descriptor accessible in each phase.
203 : * Failure to find the state descriptor aborts the session.
204 : */
205 :
206 : str
207 6366731 : checkSQLContext(Client cntxt)
208 : {
209 6366731 : backend *be;
210 :
211 6366731 : if (cntxt == NULL)
212 0 : throw(SQL, "mvc", SQLSTATE(42005) "No client record");
213 6366731 : if (cntxt->sqlcontext == NULL)
214 0 : throw(SQL, "mvc", SQLSTATE(42006) "SQL module not initialized");
215 6366731 : be = (backend *) cntxt->sqlcontext;
216 6366731 : if (be->mvc == NULL)
217 0 : throw(SQL, "mvc", SQLSTATE(42006) "SQL module not initialized, mvc struct missing");
218 : return MAL_SUCCEED;
219 : }
220 :
221 : str
222 125529 : getBackendContext(Client cntxt, backend **be)
223 : {
224 125529 : str msg;
225 :
226 125529 : if ((msg = checkSQLContext(cntxt)) != MAL_SUCCEED)
227 : return msg;
228 125529 : *be = (backend *) cntxt->sqlcontext;
229 125529 : return MAL_SUCCEED;
230 : }
231 :
232 : str
233 3047543 : getSQLContext(Client cntxt, MalBlkPtr mb, mvc **c, backend **b)
234 : {
235 3047543 : backend *be;
236 3047543 : (void) mb;
237 3047543 : str msg;
238 :
239 3047543 : if ((msg = checkSQLContext(cntxt)) != MAL_SUCCEED)
240 : return msg;
241 3047173 : be = (backend *) cntxt->sqlcontext;
242 3047173 : if (c)
243 3047173 : *c = be->mvc;
244 3047173 : if (b)
245 461 : *b = be;
246 : return MAL_SUCCEED;
247 : }
248 :
249 : str
250 280687 : SQLmvc(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
251 : {
252 280687 : mvc *sql = NULL;
253 280687 : str msg;
254 280687 : int *res = getArgReference_int(stk, pci, 0);
255 :
256 280687 : if ((msg = getSQLContext(cntxt, mb, &sql, NULL)) != NULL)
257 : return msg;
258 280684 : if ((msg = checkSQLContext(cntxt)) != NULL)
259 : return msg;
260 280684 : *res = 0;
261 280684 : return MAL_SUCCEED;
262 : }
263 :
264 : static str
265 2 : SQLshutdown_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
266 : {
267 2 : str msg;
268 :
269 2 : if ((msg = CLTshutdown(cntxt, mb, stk, pci)) == MAL_SUCCEED) {
270 : /* administer the shutdown in the system log */
271 2 : TRC_INFO(SQL_TRANS, "Shutdown: %s\n", *getArgReference_str(stk, pci, 0));
272 : }
273 2 : return msg;
274 : }
275 :
276 : static str
277 1 : SQLset_protocol(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
278 : {
279 1 : const int protocol = *getArgReference_int(stk, pci, 1);
280 :
281 1 : (void) mb;
282 1 : (void) stk;
283 :
284 1 : if (!(
285 1 : protocol == PROTOCOL_AUTO ||
286 : protocol == PROTOCOL_9 ||
287 1 : protocol == PROTOCOL_COLUMNAR))
288 : {
289 0 : return createException(SQL, "sql.set_protocol", "unknown protocol: %d", protocol);
290 : }
291 :
292 1 : *getArgReference_int(stk, pci, 0) = (cntxt->protocol = (protocol_version) protocol);
293 :
294 1 : return MAL_SUCCEED;
295 : }
296 :
297 : str
298 32460 : create_table_or_view(mvc *sql, char *sname, char *tname, sql_table *t, int temp, int replace)
299 : {
300 32460 : allocator *osa;
301 32460 : sql_schema *s = mvc_bind_schema(sql, sname);
302 32460 : sql_table *nt = NULL, *ot;
303 32460 : node *n;
304 32460 : int check = 0;
305 32460 : const char *action = (temp == SQL_DECLARED_TABLE) ? "DECLARE" : (replace ? "CREATE OR REPLACE" : "CREATE");
306 32460 : const char *obj = t->query ? "VIEW" : "TABLE";
307 32460 : str msg = MAL_SUCCEED;
308 :
309 32460 : if (store_readonly(sql->session->tr->store))
310 0 : throw(SQL, "sql.catalog", SQLSTATE(25006) "schema statements cannot be executed on a readonly database.");
311 :
312 32460 : if (!s)
313 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "%s %s: schema '%s' doesn't exist", action, obj, sname);
314 32460 : if (temp != SQL_DECLARED_TABLE && (!mvc_schema_privs(sql, s) && !(isTempSchema(s) && temp == SQL_LOCAL_TEMP)))
315 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: insufficient privileges for user '%s' in schema '%s'",
316 : action, obj, get_string_global_var(sql, "current_user"), s->base.name);
317 32460 : if ((ot = mvc_bind_table(sql, s, t->base.name))) {
318 19 : if (replace) {
319 19 : if (ot->type != t->type)
320 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: unable to drop %s '%s': is a %s",
321 0 : action, obj, obj, t->base.name, TABLE_TYPE_DESCRIPTION(ot->type, ot->properties));
322 19 : if (ot->system)
323 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: cannot replace system %s '%s'", action, obj, obj, t->base.name);
324 19 : if (mvc_check_dependency(sql, ot->base.id, isView(ot) ? VIEW_DEPENDENCY : TABLE_DEPENDENCY, NULL))
325 2 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: cannot replace %s '%s', there are database objects which depend on it",
326 : action, obj, obj, t->base.name);
327 17 : if ((msg = mvc_drop_table(sql, s, ot, 0)) != MAL_SUCCEED)
328 : return msg;
329 : } else {
330 0 : throw(SQL, "sql.catalog", SQLSTATE(42S01) "%s %s: name '%s' already in use", action, obj, t->base.name);
331 : }
332 : }
333 32458 : if (temp == SQL_DECLARED_TABLE && ol_length(t->keys))
334 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: '%s' cannot have constraints", action, obj, t->base.name);
335 :
336 32458 : 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)) {
337 0 : case -1:
338 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
339 4 : case -2:
340 : case -3:
341 4 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s %s: '%s' name conflicts", action, obj, t->base.name);
342 : default:
343 32454 : break;
344 : }
345 32454 : osa = sql->sa;
346 32454 : allocator *nsa = sql->sa = sa_create(NULL);
347 : /* first check default values */
348 288595 : for (n = ol_first_node(t->columns); n; n = n->next) {
349 256142 : sql_column *c = n->data;
350 :
351 256142 : if (c->def) {
352 : /* TODO please don't place an auto incremented sequence in the default value */
353 1384 : const char next_value_for[] = "next value for \"sys\".\"seq_";
354 1384 : sql_rel *r = NULL;
355 :
356 1384 : sa_reset(nsa);
357 1384 : sql->sa = nsa;
358 1384 : r = rel_parse(sql, s, sa_message(sql->ta, "select %s;", c->def), m_deps);
359 2768 : if (!r || !is_project(r->op) || !r->exps || list_length(r->exps) != 1 ||
360 1384 : exp_check_type(sql, &c->type, r, r->exps->h->data, type_equal) == NULL) {
361 1 : if (r)
362 1 : rel_destroy(r);
363 1 : sa_destroy(nsa);
364 1 : sql->sa = osa;
365 1 : if (strlen(sql->errstr) > 6 && sql->errstr[5] == '!')
366 1 : throw(SQL, "sql.catalog", "%s", sql->errstr);
367 : else
368 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s", sql->errstr);
369 : }
370 : /* For a self incremented column, it's sequence will get a BEDROPPED_DEPENDENCY,
371 : so no additional dependencies are needed */
372 1383 : if (strncmp(c->def, next_value_for, strlen(next_value_for)) != 0) {
373 1182 : list *blist = rel_dependencies(sql, r);
374 1182 : if (mvc_create_dependencies(sql, blist, nt->base.id, FUNC_DEPENDENCY)) {
375 0 : sa_destroy(nsa);
376 0 : sql->sa = osa;
377 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
378 : }
379 : }
380 1383 : sa_reset(sql->sa);
381 : }
382 : }
383 :
384 288594 : for (n = ol_first_node(t->columns); n; n = n->next) {
385 256141 : sql_column *c = n->data, *copied = NULL;
386 :
387 256141 : switch (mvc_copy_column(sql, nt, c, &copied)) {
388 0 : case -1:
389 0 : sa_destroy(nsa);
390 0 : sql->sa = osa;
391 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
392 0 : case -2:
393 : case -3:
394 0 : sa_destroy(nsa);
395 0 : sql->sa = osa;
396 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s_%s conflicts", s->base.name, t->base.name, c->base.name);
397 : default:
398 256141 : break;
399 : }
400 256141 : if (isPartitionedByColumnTable(t) && c->base.id == t->part.pcol->base.id)
401 80 : nt->part.pcol = copied;
402 : }
403 32453 : if (isPartitionedByExpressionTable(t)) {
404 27 : char *err = NULL;
405 :
406 27 : _DELETE(nt->part.pexp->exp);
407 27 : nt->part.pexp->exp = _STRDUP(t->part.pexp->exp);
408 27 : err = bootstrap_partition_expression(sql, nt, 1);
409 27 : if (err) {
410 3 : sa_destroy(nsa);
411 3 : sql->sa = osa;
412 3 : return err;
413 : }
414 24 : sa_reset(nsa);
415 : }
416 32450 : check = sql_trans_set_partition_table(sql->session->tr, nt);
417 32450 : if (check == -4) {
418 0 : sa_destroy(nsa);
419 0 : sql->sa = osa;
420 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s: the partition's expression is too long", s->base.name, t->base.name);
421 32450 : } else if (check) {
422 0 : sa_destroy(nsa);
423 0 : sql->sa = osa;
424 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s: an internal error occurred", s->base.name, t->base.name);
425 : }
426 :
427 32450 : if (t->idxs) {
428 38521 : for (n = ol_first_node(t->idxs); n; n = n->next) {
429 6071 : sql_idx *i = n->data;
430 :
431 6071 : switch (mvc_copy_idx(sql, nt, i, NULL)) {
432 0 : case -1:
433 0 : sa_destroy(nsa);
434 0 : sql->sa = osa;
435 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
436 0 : case -2:
437 : case -3:
438 0 : sa_destroy(nsa);
439 0 : sql->sa = osa;
440 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s_%s index conflicts", s->base.name, t->base.name, i->base.name);
441 : default:
442 6071 : break;
443 : }
444 : }
445 : }
446 32450 : if (t->keys) {
447 38532 : for (n = ol_first_node(t->keys); n; n = n->next) {
448 6089 : sql_key *k = n->data;
449 6089 : char *err = NULL;
450 :
451 6089 : err = sql_partition_validate_key(sql, nt, k, "CREATE");
452 6089 : if (err) {
453 6 : sa_destroy(nsa);
454 6 : sql->sa = osa;
455 6 : return err;
456 : }
457 6083 : sa_reset(sql->sa);
458 6083 : switch (mvc_copy_key(sql, nt, k, NULL)) {
459 1 : case -1:
460 1 : sa_destroy(nsa);
461 1 : sql->sa = osa;
462 1 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
463 0 : case -2:
464 : case -3:
465 0 : sa_destroy(nsa);
466 0 : sql->sa = osa;
467 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s_%s constraint conflicts", s->base.name, t->base.name, k->base.name);
468 : default:
469 6082 : break;
470 : }
471 6082 : sa_reset(sql->sa);
472 : }
473 : }
474 32443 : if (t->triggers) {
475 32443 : for (n = ol_first_node(t->triggers); n; n = n->next) {
476 0 : sql_trigger *tr = n->data;
477 :
478 0 : switch (mvc_copy_trigger(sql, nt, tr, NULL)) {
479 0 : case -1:
480 0 : sa_destroy(nsa);
481 0 : sql->sa = osa;
482 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
483 0 : case -2:
484 : case -3:
485 0 : sa_destroy(nsa);
486 0 : sql->sa = osa;
487 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: %s_%s_%s trigger conflicts", s->base.name, t->base.name, nt->base.name);
488 : default:
489 0 : break;
490 : }
491 : }
492 : }
493 : /* also create dependencies when not renaming */
494 32443 : if (nt->query && isView(nt)) {
495 22355 : sql_rel *r = NULL;
496 :
497 22355 : sa_reset(nsa);
498 22355 : r = rel_parse(sql, s, nt->query, m_deps);
499 22355 : if (r)
500 22355 : r = sql_processrelation(sql, r, 0, 0, 0, 0);
501 22355 : if (r) {
502 22355 : list *blist = rel_dependencies(sql, r);
503 22355 : if (mvc_create_dependencies(sql, blist, nt->base.id, VIEW_DEPENDENCY)) {
504 0 : sa_destroy(nsa);
505 0 : sql->sa = osa;
506 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
507 : }
508 : }
509 22355 : sql->sa = osa;
510 22355 : if (!r) {
511 0 : sa_destroy(nsa);
512 0 : if (strlen(sql->errstr) > 6 && sql->errstr[5] == '!')
513 0 : throw(SQL, "sql.catalog", "%s", sql->errstr);
514 : else
515 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "%s", sql->errstr);
516 : }
517 : }
518 32443 : sa_destroy(nsa);
519 32443 : sql->sa = osa;
520 32443 : return MAL_SUCCEED;
521 : }
522 :
523 : static int
524 99008 : mvc_claim_slots(sql_trans *tr, sql_table *t, size_t cnt, BUN *offset, BAT **pos)
525 : {
526 99008 : sqlstore *store = tr->store;
527 99008 : return store->storage_api.claim_tab(tr, t, cnt, offset, pos);
528 : }
529 :
530 : str
531 98995 : mvc_claim_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
532 : {
533 98995 : BUN *offset = (BUN*)getArgReference_oid(stk, pci, 0);
534 98995 : bat *res = getArgReference_bat(stk, pci, 1);
535 98995 : mvc *m = NULL;
536 98995 : str msg;
537 98995 : const char *sname = *getArgReference_str(stk, pci, 3);
538 98995 : const char *tname = *getArgReference_str(stk, pci, 4);
539 98995 : lng cnt = *getArgReference_lng(stk, pci, 5);
540 98995 : BAT *pos = NULL;
541 98995 : sql_schema *s;
542 98995 : sql_table *t;
543 :
544 98995 : *res = 0;
545 98995 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
546 : return msg;
547 98995 : if ((msg = checkSQLContext(cntxt)) != NULL)
548 : return msg;
549 :
550 98995 : s = mvc_bind_schema(m, sname);
551 98995 : if (s == NULL)
552 0 : throw(SQL, "sql.claim", SQLSTATE(3F000) "Schema missing %s", sname);
553 98995 : t = mvc_bind_table(m, s, tname);
554 98995 : if (t == NULL)
555 0 : throw(SQL, "sql.claim", SQLSTATE(42S02) "Table missing %s.%s", sname, tname);
556 98995 : if (!isTable(t))
557 0 : throw(SQL, "sql.claim", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
558 98995 : if (mvc_claim_slots(m->session->tr, t, (size_t)cnt, offset, &pos) == LOG_OK) {
559 98995 : *res = bat_nil;
560 98995 : if (pos) {
561 7 : *res = pos->batCacheid;
562 7 : BBPkeepref(pos);
563 : }
564 98995 : return MAL_SUCCEED;
565 : }
566 0 : throw(SQL, "sql.claim", SQLSTATE(3F000) "Could not claim slots");
567 : }
568 :
569 : str
570 127890 : mvc_add_dependency_change(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
571 : {
572 127890 : str msg;
573 127890 : mvc *m = NULL;
574 127890 : const char *sname = *getArgReference_str(stk, pci, 1);
575 127890 : const char *tname = *getArgReference_str(stk, pci, 2);
576 127890 : lng cnt = *getArgReference_lng(stk, pci, 3);
577 127890 : sql_schema *s;
578 127890 : sql_table *t;
579 :
580 127890 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
581 : return msg;
582 127888 : if ((msg = checkSQLContext(cntxt)) != NULL)
583 : return msg;
584 :
585 127888 : if ((s = mvc_bind_schema(m, sname)) == NULL)
586 0 : throw(SQL, "sql.dependency_change", SQLSTATE(3F000) "Schema missing %s", sname);
587 127889 : if ((t = mvc_bind_table(m, s, tname)) == NULL)
588 0 : throw(SQL, "sql.dependency_change", SQLSTATE(42S02) "Table missing %s.%s", sname, tname);
589 127890 : if (!isTable(t))
590 0 : throw(SQL, "sql.dependency_change", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
591 127890 : if (cnt > 0 && !isNew(t) && isGlobal(t) && !isGlobalTemp(t) && sql_trans_add_dependency_change(m->session->tr, t->base.id, dml) != LOG_OK)
592 0 : throw(SQL, "sql.dependency_change", SQLSTATE(HY013) MAL_MALLOC_FAIL);
593 : return MAL_SUCCEED;
594 : }
595 :
596 : str
597 13316 : mvc_add_column_predicate(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
598 : {
599 13316 : str msg;
600 13316 : mvc *m = NULL;
601 13316 : const char *sname = *getArgReference_str(stk, pci, 1);
602 13316 : const char *tname = *getArgReference_str(stk, pci, 2);
603 13316 : const char *cname = *getArgReference_str(stk, pci, 3);
604 13316 : sql_schema *s;
605 13316 : sql_table *t;
606 13316 : sql_column *c;
607 :
608 13316 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
609 : return msg;
610 13316 : if ((msg = checkSQLContext(cntxt)) != NULL)
611 : return msg;
612 :
613 13316 : if ((s = mvc_bind_schema(m, sname)) == NULL)
614 0 : throw(SQL, "sql.column_predicate", SQLSTATE(3F000) "Schema missing %s", sname);
615 13316 : if ((t = mvc_bind_table(m, s, tname)) == NULL)
616 0 : throw(SQL, "sql.column_predicate", SQLSTATE(42S02) "Table missing %s.%s", sname, tname);
617 13316 : if ((c = mvc_bind_column(m, t, cname)) == NULL)
618 0 : throw(SQL, "sql.column_predicate", SQLSTATE(42S22) "Column not found in %s.%s.%s",sname,tname,cname);
619 :
620 13316 : if ((m->session->level & tr_snapshot) == tr_snapshot || isNew(c) || !isGlobal(c->t) || isGlobalTemp(c->t))
621 : return MAL_SUCCEED;
622 6295 : if (sql_trans_add_predicate(m->session->tr, c, 0, NULL, NULL, false, false) != LOG_OK)
623 0 : throw(SQL, "sql.column_predicate", SQLSTATE(HY013) MAL_MALLOC_FAIL);
624 : return MAL_SUCCEED;
625 : }
626 :
627 : str
628 1 : create_table_from_emit(Client cntxt, char *sname, char *tname, sql_emit_col *columns, size_t ncols)
629 : {
630 1 : size_t i;
631 1 : sql_table *t = NULL;
632 1 : sql_schema *s = NULL;
633 1 : mvc *sql = NULL;
634 1 : str msg = MAL_SUCCEED;
635 :
636 1 : if ((msg = getSQLContext(cntxt, NULL, &sql, NULL)) != NULL)
637 : return msg;
638 1 : if ((msg = checkSQLContext(cntxt)) != NULL)
639 : return msg;
640 :
641 1 : if (!sname)
642 0 : sname = "sys";
643 1 : if (!(s = mvc_bind_schema(sql, sname)))
644 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "CREATE TABLE: no such schema '%s'", sname);
645 1 : if (!mvc_schema_privs(sql, s))
646 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);
647 1 : switch (mvc_create_table(&t, sql, s, tname, tt_table, 0, SQL_DECLARED_TABLE, CA_COMMIT, -1, 0)) {
648 0 : case -1:
649 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
650 0 : case -2:
651 : case -3:
652 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: transaction conflict detected");
653 : default:
654 : break;
655 : }
656 :
657 3 : for (i = 0; i < ncols; i++) {
658 2 : BAT *b = columns[i].b;
659 2 : const char *atomname = ATOMname(b->ttype);
660 2 : sql_subtype tpe;
661 2 : sql_column *col = NULL;
662 :
663 2 : if (!strcmp(atomname, "str"))
664 2 : sql_find_subtype(&tpe, "varchar", 0, 0);
665 : else {
666 0 : sql_subtype *t = sql_bind_localtype(atomname);
667 0 : if (!t)
668 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "CREATE TABLE: could not find type for column");
669 0 : tpe = *t;
670 : }
671 :
672 2 : if (columns[i].name && columns[i].name[0] == '%')
673 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: generated labels not allowed in column names, use an alias instead");
674 2 : if (tpe.type->eclass == EC_ANY)
675 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: any type (plain null value) not allowed as a column type, use an explicit cast");
676 2 : switch (mvc_create_column(&col, sql, t, columns[i].name, &tpe)) {
677 0 : case -1:
678 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
679 0 : case -2:
680 : case -3:
681 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "CREATE TABLE: transaction conflict detected");
682 : default:
683 2 : break;
684 : }
685 : }
686 1 : if ((msg = create_table_or_view(sql, sname, t->base.name, t, 0, 0)) != MAL_SUCCEED)
687 : return msg;
688 1 : if (!(t = mvc_bind_table(sql, s, tname)))
689 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "CREATE TABLE: could not bind table %s", tname);
690 1 : BUN offset;
691 1 : BAT *pos = NULL;
692 1 : if (mvc_claim_slots(sql->session->tr, t, BATcount(columns[0].b), &offset, &pos) != LOG_OK)
693 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "CREATE TABLE: Could not insert data");
694 3 : for (i = 0; i < ncols; i++) {
695 2 : BAT *b = columns[i].b;
696 2 : sql_column *col = NULL;
697 :
698 2 : if (!(col = mvc_bind_column(sql, t, columns[i].name))) {
699 0 : bat_destroy(pos);
700 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "CREATE TABLE: could not bind column %s", columns[i].name);
701 : }
702 2 : if ((msg = mvc_append_column(sql->session->tr, col, offset, pos, b)) != MAL_SUCCEED) {
703 0 : bat_destroy(pos);
704 0 : return msg;
705 : }
706 : }
707 1 : bat_destroy(pos);
708 1 : return msg;
709 : }
710 :
711 : str
712 12 : append_to_table_from_emit(Client cntxt, char *sname, char *tname, sql_emit_col *columns, size_t ncols)
713 : {
714 12 : size_t i;
715 12 : sql_table *t;
716 12 : sql_schema *s;
717 12 : mvc *sql = NULL;
718 12 : str msg = MAL_SUCCEED;
719 :
720 12 : if ((msg = getSQLContext(cntxt, NULL, &sql, NULL)) != NULL)
721 : return msg;
722 12 : if ((msg = checkSQLContext(cntxt)) != NULL)
723 : return msg;
724 :
725 12 : if (!sname)
726 0 : sname = "sys";
727 12 : if (!(s = mvc_bind_schema(sql, sname)))
728 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "APPEND TABLE: no such schema '%s'", sname);
729 12 : if (!(t = mvc_bind_table(sql, s, tname)))
730 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "APPEND TABLE: could not bind table %s", tname);
731 12 : if (!isTable(t))
732 0 : throw(SQL, "sql.catalog", SQLSTATE(42000) "APPEND TABLE: %s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
733 12 : BUN offset;
734 12 : BAT *pos = NULL;
735 12 : if (mvc_claim_slots(sql->session->tr, t, BATcount(columns[0].b), &offset, &pos) != LOG_OK)
736 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "APPEND TABLE: Could not append data");
737 62 : for (i = 0; i < ncols; i++) {
738 50 : BAT *b = columns[i].b;
739 50 : sql_column *col = NULL;
740 :
741 50 : if (!(col = mvc_bind_column(sql, t, columns[i].name))) {
742 0 : bat_destroy(pos);
743 0 : throw(SQL, "sql.catalog", SQLSTATE(3F000) "APPEND TABLE: could not bind column %s", columns[i].name);
744 : }
745 50 : if ((msg = mvc_append_column(sql->session->tr, col, offset, pos, b)) != MAL_SUCCEED) {
746 0 : bat_destroy(pos);
747 0 : return msg;
748 : }
749 : }
750 12 : bat_destroy(pos);
751 16 : if (BATcount(columns[0].b) > 0 && !isNew(t) && isGlobal(t) && !isGlobalTemp(t) &&
752 4 : sql_trans_add_dependency_change(sql->session->tr, t->base.id, dml) != LOG_OK)
753 0 : throw(SQL, "sql.catalog", SQLSTATE(HY013) MAL_MALLOC_FAIL);
754 : return msg;
755 : }
756 :
757 : BAT *
758 257 : mvc_bind(mvc *m, const char *sname, const char *tname, const char *cname, int access)
759 : {
760 257 : sql_trans *tr = m->session->tr;
761 257 : BAT *b = NULL;
762 257 : sql_schema *s = NULL;
763 257 : sql_table *t = NULL;
764 257 : sql_column *c = NULL;
765 :
766 257 : s = mvc_bind_schema(m, sname);
767 257 : if (s == NULL)
768 : return NULL;
769 257 : t = mvc_bind_table(m, s, tname);
770 257 : if (t == NULL || !isTable(t))
771 : return NULL;
772 257 : c = mvc_bind_column(m, t, cname);
773 257 : if (c == NULL)
774 : return NULL;
775 :
776 257 : sqlstore *store = tr->store;
777 257 : b = store->storage_api.bind_col(tr, c, access);
778 257 : return b;
779 : }
780 :
781 : /* setVariable(int *ret, str *sname, str *name, any value) */
782 : str
783 379 : setVariable(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
784 : {
785 379 : int *res = getArgReference_int(stk, pci, 0);
786 379 : mvc *m = NULL;
787 379 : str msg;
788 379 : const char *sname = *getArgReference_str(stk, pci, 2);
789 379 : const char *varname = *getArgReference_str(stk, pci, 3);
790 379 : int mtype = getArgType(mb, pci, 4);
791 379 : sql_schema *s;
792 379 : sql_var *var;
793 :
794 379 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
795 : return msg;
796 379 : if ((msg = checkSQLContext(cntxt)) != NULL)
797 : return msg;
798 :
799 379 : if (!(s = mvc_bind_schema(m, sname)))
800 0 : throw(SQL, "sql.setVariable", SQLSTATE(3F000) "Cannot find the schema '%s'", sname);
801 :
802 379 : *res = 0;
803 379 : if (mtype < 0 || mtype >= 255)
804 0 : throw(SQL, "sql.setVariable", SQLSTATE(42100) "Variable type error");
805 :
806 379 : if ((var = find_global_var(m, s, varname))) {
807 519 : if (!strcmp("sys", s->base.name) && !strcmp("optimizer", varname)) {
808 167 : const char *newopt = *getArgReference_str(stk, pci, 4);
809 167 : char buf[18];
810 :
811 167 : if (strNil(newopt))
812 27 : throw(SQL, "sql.setVariable", SQLSTATE(42000) "Variable '%s.%s' cannot be NULL", sname, varname);
813 167 : if (!isOptimizerPipe(newopt) && strchr(newopt, (int) ';') == 0)
814 5 : throw(SQL, "sql.setVariable", SQLSTATE(42100) "optimizer '%s' unknown", newopt);
815 162 : (void) snprintf(buf, sizeof(buf), "user_%d", cntxt->idx); /* should always suffice */
816 162 : if (!isOptimizerPipe(newopt) || strcmp(buf, newopt) == 0) {
817 23 : if ((msg = addPipeDefinition(cntxt, buf, newopt)))
818 : return msg;
819 1 : if (!sqlvar_set_string(find_global_var(m, s, varname), buf))
820 0 : throw(SQL, "sql.setVariable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
821 139 : } else if (!sqlvar_set_string(find_global_var(m, s, varname), newopt))
822 0 : throw(SQL, "sql.setVariable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
823 : } else {
824 212 : ValPtr ptr = &stk->stk[getArg(pci, 4)];
825 :
826 212 : if ((msg = sql_update_var(m, s, varname, ptr)))
827 : return msg;
828 197 : if (!sqlvar_set(var, ptr))
829 0 : throw(SQL, "sql.setVariable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
830 : }
831 337 : return MAL_SUCCEED;
832 : }
833 0 : throw(SQL, "sql.setVariable", SQLSTATE(42100) "Variable '%s.%s' unknown", sname, varname);
834 : }
835 :
836 : /* getVariable(int *ret, str *name) */
837 : str
838 437 : getVariable(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
839 : {
840 437 : int mtype = getArgType(mb, pci, 0);
841 437 : mvc *m = NULL;
842 437 : str msg;
843 437 : const char *sname = *getArgReference_str(stk, pci, 2);
844 437 : const char *varname = *getArgReference_str(stk, pci, 3);
845 437 : ValRecord *dst, *src;
846 437 : sql_schema *s;
847 437 : sql_var *var;
848 :
849 437 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
850 : return msg;
851 437 : if ((msg = checkSQLContext(cntxt)) != NULL)
852 : return msg;
853 :
854 437 : if (!(s = mvc_bind_schema(m, sname)))
855 0 : throw(SQL, "sql.getVariable", SQLSTATE(3F000) "Cannot find the schema '%s'", sname);
856 437 : if (mtype < 0 || mtype >= 255)
857 0 : throw(SQL, "sql.getVariable", SQLSTATE(42100) "Variable type error");
858 437 : if (!(var = find_global_var(m, s, varname)))
859 0 : throw(SQL, "sql.getVariable", SQLSTATE(42100) "Variable '%s.%s' unknown", sname, varname);
860 437 : src = &(var->var.data);
861 437 : dst = &stk->stk[getArg(pci, 0)];
862 437 : if (VALcopy(dst, src) == NULL)
863 0 : throw(MAL, "sql.getVariable", SQLSTATE(HY013) MAL_MALLOC_FAIL);
864 : return MAL_SUCCEED;
865 : }
866 :
867 : str
868 1 : sql_variables(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
869 : {
870 1 : mvc *m = NULL;
871 1 : BAT *schemas, *names, *types, *values;
872 1 : str msg = MAL_SUCCEED;
873 1 : bat *s = getArgReference_bat(stk,pci,0);
874 1 : bat *n = getArgReference_bat(stk,pci,1);
875 1 : bat *t = getArgReference_bat(stk,pci,2);
876 1 : bat *v = getArgReference_bat(stk,pci,3);
877 1 : int nvars;
878 :
879 1 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
880 : return msg;
881 1 : if ((msg = checkSQLContext(cntxt)) != NULL)
882 : return msg;
883 :
884 1 : nvars = list_length(m->global_vars);
885 1 : schemas = COLnew(0, TYPE_str, nvars, TRANSIENT);
886 1 : names = COLnew(0, TYPE_str, nvars, TRANSIENT);
887 1 : types = COLnew(0, TYPE_str, nvars, TRANSIENT);
888 1 : values = COLnew(0, TYPE_str, nvars, TRANSIENT);
889 1 : if (!schemas || !names || !types || !values) {
890 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) MAL_MALLOC_FAIL);
891 0 : goto bailout;
892 : }
893 :
894 1 : if (m->global_vars) {
895 10 : for (node *n = m->global_vars->h; n ; n = n->next) {
896 9 : sql_var *var = (sql_var*) n->data;
897 9 : atom value = var->var;
898 9 : ValPtr myptr = &(value.data);
899 9 : ValRecord val = (ValRecord) {.vtype = TYPE_void,};
900 9 : gdk_return res;
901 :
902 9 : if (value.tpe.type->localtype != TYPE_str) {
903 5 : ptr ok = VALcopy(&val, myptr);
904 5 : if (ok)
905 5 : ok = VALconvert(TYPE_str, &val);
906 5 : if (!ok) {
907 0 : VALclear(&val);
908 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) "Failed to convert variable '%s.%s' into a string", var->sname, var->name);
909 0 : goto bailout;
910 : }
911 : myptr = &val;
912 : }
913 9 : res = BUNappend(values, VALget(myptr), false);
914 9 : VALclear(&val);
915 9 : if (res != GDK_SUCCEED) {
916 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) MAL_MALLOC_FAIL);
917 0 : goto bailout;
918 : }
919 9 : if (BUNappend(schemas, var->sname, false) != GDK_SUCCEED) {
920 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) MAL_MALLOC_FAIL);
921 0 : goto bailout;
922 : }
923 9 : if (BUNappend(names, var->name, false) != GDK_SUCCEED) {
924 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) MAL_MALLOC_FAIL);
925 0 : goto bailout;
926 : }
927 9 : if (BUNappend(types, value.tpe.type->base.name, false) != GDK_SUCCEED) {
928 0 : msg = createException(SQL, "sql.variables", SQLSTATE(HY013) MAL_MALLOC_FAIL);
929 0 : goto bailout;
930 : }
931 : }
932 : }
933 :
934 1 : bailout:
935 0 : if (msg) {
936 0 : BBPreclaim(schemas);
937 0 : BBPreclaim(names);
938 0 : BBPreclaim(types);
939 0 : BBPreclaim(values);
940 : } else {
941 1 : *s = schemas->batCacheid;
942 1 : BBPkeepref(schemas);
943 1 : *n = names->batCacheid;
944 1 : BBPkeepref(names);
945 1 : *t = types->batCacheid;
946 1 : BBPkeepref(types);
947 1 : *v = values->batCacheid;
948 1 : BBPkeepref(values);
949 : }
950 : return msg;
951 : }
952 :
953 : /* str mvc_logfile(int *d, str *filename); */
954 : str
955 0 : mvc_logfile(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
956 : {
957 0 : mvc *m = NULL;
958 0 : str msg;
959 0 : const char *filename = *getArgReference_str(stk, pci, 1);
960 :
961 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
962 : return msg;
963 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
964 : return msg;
965 0 : if (m->scanner.log) {
966 0 : close_stream(m->scanner.log);
967 0 : m->scanner.log = NULL;
968 : }
969 :
970 0 : if (!strNil(filename)) {
971 0 : if((m->scanner.log = open_wastream(filename)) == NULL)
972 0 : throw(SQL, "sql.logfile", SQLSTATE(HY013) "%s", mnstr_peek_error(NULL));
973 : }
974 : return MAL_SUCCEED;
975 : }
976 :
977 : /* str mvc_next_value(lng *res, str *sname, str *seqname); */
978 : str
979 974 : mvc_next_value(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
980 : {
981 974 : backend *be = NULL;
982 974 : str msg;
983 974 : sql_schema *s;
984 974 : sql_sequence *seq;
985 974 : lng *res = getArgReference_lng(stk, pci, 0);
986 974 : const char *sname = *getArgReference_str(stk, pci, 1);
987 974 : const char *seqname = *getArgReference_str(stk, pci, 2);
988 :
989 974 : (void)mb;
990 974 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
991 : return msg;
992 974 : if (!(s = mvc_bind_schema(be->mvc, sname)))
993 0 : throw(SQL, "sql.next_value", SQLSTATE(3F000) "Cannot find the schema %s", sname);
994 974 : if (!mvc_schema_privs(be->mvc, s))
995 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);
996 974 : if (!(seq = find_sql_sequence(be->mvc->session->tr, s, seqname)))
997 0 : throw(SQL, "sql.next_value", SQLSTATE(HY050) "Cannot find the sequence %s.%s", sname, seqname);
998 :
999 974 : if (seq_next_value(be->mvc->session->tr->store, seq, res)) {
1000 973 : be->last_id = *res;
1001 973 : sqlvar_set_number(find_global_var(be->mvc, mvc_bind_schema(be->mvc, "sys"), "last_id"), be->last_id);
1002 973 : return MAL_SUCCEED;
1003 : }
1004 1 : throw(SQL, "sql.next_value", SQLSTATE(HY050) "Cannot generate next sequence value %s.%s", sname, seqname);
1005 : }
1006 :
1007 : str
1008 88 : mvc_next_value_bulk(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1009 : {
1010 88 : backend *be = NULL;
1011 88 : str msg;
1012 88 : sql_schema *s;
1013 88 : sql_sequence *seq;
1014 88 : bat *res = getArgReference_bat(stk, pci, 0);
1015 88 : BUN card = (BUN)*getArgReference_lng(stk, pci, 1);
1016 88 : const char *sname = *getArgReference_str(stk, pci, 2);
1017 88 : const char *seqname = *getArgReference_str(stk, pci, 3);
1018 88 : BAT *r = NULL;
1019 :
1020 88 : (void)mb;
1021 88 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
1022 : return msg;
1023 88 : if (!(s = mvc_bind_schema(be->mvc, sname)))
1024 0 : throw(SQL, "sql.next_value", SQLSTATE(3F000) "Cannot find the schema %s", sname);
1025 88 : if (!mvc_schema_privs(be->mvc, s))
1026 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);
1027 88 : if (!(seq = find_sql_sequence(be->mvc->session->tr, s, seqname)))
1028 0 : throw(SQL, "sql.next_value", SQLSTATE(HY050) "Cannot find the sequence %s.%s", sname, seqname);
1029 88 : if (!(r = COLnew(0, TYPE_lng, card, TRANSIENT)))
1030 0 : throw(SQL, "sql.next_value", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1031 :
1032 88 : lng *restrict rb = Tloc(r, 0);
1033 :
1034 88 : if (seqbulk_next_value(be->mvc->session->tr->store, seq, card, rb)) {
1035 88 : be->last_id = rb[card-1];
1036 88 : sqlvar_set_number(find_global_var(be->mvc, mvc_bind_schema(be->mvc, "sys"), "last_id"), be->last_id);
1037 88 : BATsetcount(r, card);
1038 88 : r->tnonil = true;
1039 88 : r->tnil = false;
1040 : /* TODO set the min/max, tsorted/trevsorted and tkey properties based on the sequence values */
1041 88 : r->tsorted = r->trevsorted = r->tkey = BATcount(r) <= 1;
1042 88 : *res = r->batCacheid;
1043 88 : BBPkeepref(r);
1044 88 : return MAL_SUCCEED;
1045 : }
1046 0 : BBPreclaim(r);
1047 0 : throw(SQL, "sql.next_value", SQLSTATE(HY050) "Cannot generate next sequence value %s.%s", sname, seqname);
1048 : }
1049 :
1050 : /* str mvc_get_value(lng *res, str *sname, str *seqname); */
1051 : str
1052 26 : mvc_get_value(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1053 : {
1054 26 : mvc *m = NULL;
1055 26 : str msg;
1056 26 : sql_schema *s;
1057 26 : sql_sequence *seq;
1058 26 : lng *res = getArgReference_lng(stk, pci, 0);
1059 26 : const char *sname = *getArgReference_str(stk, pci, 1);
1060 26 : const char *seqname = *getArgReference_str(stk, pci, 2);
1061 :
1062 26 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1063 : return msg;
1064 26 : if ((msg = checkSQLContext(cntxt)) != NULL)
1065 : return msg;
1066 26 : if (!(s = mvc_bind_schema(m, sname)))
1067 0 : throw(SQL, "sql.get_value", SQLSTATE(3F000) "Cannot find the schema %s", sname);
1068 26 : if (!(seq = find_sql_sequence(m->session->tr, s, seqname)))
1069 0 : throw(SQL, "sql.get_value", SQLSTATE(HY050) "Cannot find the sequence %s.%s", sname, seqname);
1070 :
1071 26 : if (seq_get_value(m->session->tr->store, seq, res))
1072 : return MAL_SUCCEED;
1073 :
1074 0 : throw(SQL, "sql.get_value", SQLSTATE(HY050) "Cannot get sequence value %s.%s", sname, seqname);
1075 : }
1076 :
1077 : /* needed for msqldump and describe_sequences view */
1078 : static str
1079 131 : mvc_get_value_bulk(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1080 : {
1081 131 : mvc *m = NULL;
1082 131 : sql_schema *s;
1083 131 : sql_sequence *seq;
1084 131 : BATiter schi, seqi;
1085 131 : BAT *bn = NULL, *scheb = NULL, *sches = NULL, *seqb = NULL, *seqs = NULL;
1086 131 : lng *restrict vals;
1087 131 : str msg = MAL_SUCCEED;
1088 131 : bool nils = false;
1089 131 : struct canditer ci1 = {0}, ci2 = {0};
1090 131 : oid off1, off2;
1091 131 : bat *res = getArgReference_bat(stk, pci, 0), *l = getArgReference_bat(stk, pci, 1), *r = getArgReference_bat(stk, pci, 2),
1092 131 : *sid1 = pci->argc == 5 ? getArgReference_bat(stk, pci, 3) : NULL, *sid2 = pci->argc == 5 ? getArgReference_bat(stk, pci, 4) : NULL;
1093 :
1094 131 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1095 : return msg;
1096 131 : if ((msg = checkSQLContext(cntxt)) != NULL)
1097 : return msg;
1098 131 : if (!(scheb = BATdescriptor(*l)) || !(seqb = BATdescriptor(*r))) {
1099 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1100 0 : goto bailout;
1101 : }
1102 131 : if ((sid1 && !is_bat_nil(*sid1) && !(sches = BATdescriptor(*sid1))) || (sid2 && !is_bat_nil(*sid2) && !(seqs = BATdescriptor(*sid2)))) {
1103 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1104 0 : goto bailout;
1105 : }
1106 131 : canditer_init(&ci1, scheb, sches);
1107 131 : canditer_init(&ci2, seqb, seqs);
1108 131 : if (ci2.ncand != ci1.ncand || ci1.hseq != ci2.hseq) {
1109 0 : msg = createException(SQL, "sql.get_value", ILLEGAL_ARGUMENT " Requires bats of identical size");
1110 0 : goto bailout;
1111 : }
1112 131 : if (!(bn = COLnew(ci1.hseq, TYPE_lng, ci1.ncand, TRANSIENT))) {
1113 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1114 0 : goto bailout;
1115 : }
1116 :
1117 131 : off1 = scheb->hseqbase;
1118 131 : off2 = seqb->hseqbase;
1119 131 : schi = bat_iterator(scheb);
1120 131 : seqi = bat_iterator(seqb);
1121 131 : vals = Tloc(bn, 0);
1122 171 : for (BUN i = 0; i < ci1.ncand; i++) {
1123 40 : oid p1 = canditer_next(&ci1) - off1, p2 = canditer_next(&ci2) - off2;
1124 40 : const char *sname = BUNtvar(schi, p1);
1125 40 : const char *seqname = BUNtvar(seqi, p2);
1126 :
1127 80 : if (strNil(sname) || strNil(seqname)) {
1128 0 : vals[i] = lng_nil;
1129 0 : nils = true;
1130 : } else {
1131 40 : if (!(s = mvc_bind_schema(m, sname))) {
1132 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(3F000) "Cannot find the schema %s", sname);
1133 0 : goto bailout1;
1134 : }
1135 40 : if (!(seq = find_sql_sequence(m->session->tr, s, seqname))) {
1136 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(HY050) "Cannot find the sequence %s.%s", sname, seqname);
1137 0 : goto bailout1;
1138 : }
1139 40 : if (!seq_get_value(m->session->tr->store, seq, &(vals[i]))) {
1140 0 : msg = createException(SQL, "sql.get_value", SQLSTATE(HY050) "Cannot get the next sequence value %s.%s", sname, seqname);
1141 0 : goto bailout1;
1142 : }
1143 : }
1144 : }
1145 :
1146 131 : bailout1:
1147 131 : bat_iterator_end(&schi);
1148 131 : bat_iterator_end(&seqi);
1149 131 : bailout:
1150 131 : BBPreclaim(scheb);
1151 131 : BBPreclaim(sches);
1152 131 : BBPreclaim(seqb);
1153 131 : BBPreclaim(seqs);
1154 131 : if (bn && !msg) {
1155 131 : BATsetcount(bn, ci1.ncand);
1156 131 : bn->tnil = nils;
1157 131 : bn->tnonil = !nils;
1158 131 : bn->tkey = BATcount(bn) <= 1;
1159 131 : bn->tsorted = BATcount(bn) <= 1;
1160 131 : bn->trevsorted = BATcount(bn) <= 1;
1161 131 : *res = bn->batCacheid;
1162 131 : BBPkeepref(bn);
1163 0 : } else if (bn)
1164 0 : BBPreclaim(bn);
1165 : return msg;
1166 : }
1167 :
1168 : str
1169 0 : mvc_getVersion(lng *version, const int *clientid)
1170 : {
1171 0 : mvc *m = NULL;
1172 0 : Client cntxt = MCgetClient(*clientid);
1173 0 : str msg;
1174 :
1175 0 : if ((msg = getSQLContext(cntxt, NULL, &m, NULL)) != NULL)
1176 : return msg;
1177 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
1178 : return msg;
1179 0 : *version = -1;
1180 0 : if (m->session->tr)
1181 0 : *version = (lng)m->session->tr->ts;
1182 : return MAL_SUCCEED;
1183 : }
1184 :
1185 : /* str mvc_restart_seq(lng *res, str *sname, str *seqname, lng *start); */
1186 : str
1187 2 : mvc_restart_seq(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1188 : {
1189 2 : mvc *m = NULL;
1190 2 : str msg;
1191 2 : sql_schema *s;
1192 2 : sql_sequence *seq;
1193 2 : lng *res = getArgReference_lng(stk, pci, 0);
1194 2 : const char *sname = *getArgReference_str(stk, pci, 1);
1195 2 : const char *seqname = *getArgReference_str(stk, pci, 2);
1196 2 : lng start = *getArgReference_lng(stk, pci, 3);
1197 :
1198 2 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1199 : return msg;
1200 2 : if ((msg = checkSQLContext(cntxt)) != NULL)
1201 : return msg;
1202 2 : if (!(s = mvc_bind_schema(m, sname)))
1203 0 : throw(SQL, "sql.restart", SQLSTATE(3F000) "Cannot find the schema %s", sname);
1204 2 : if (!mvc_schema_privs(m, s))
1205 0 : throw(SQL, "sql.restart", SQLSTATE(42000) "Access denied for %s to schema '%s'", get_string_global_var(m, "current_user"), s->base.name);
1206 2 : if (!(seq = find_sql_sequence(m->session->tr, s, seqname)))
1207 0 : throw(SQL, "sql.restart", SQLSTATE(HY050) "Failed to fetch sequence %s.%s", sname, seqname);
1208 2 : if (is_lng_nil(start))
1209 0 : throw(SQL, "sql.restart", SQLSTATE(HY050) "Cannot (re)start sequence %s.%s with NULL", sname, seqname);
1210 2 : if (start < seq->minvalue)
1211 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);
1212 2 : if (start > seq->maxvalue)
1213 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);
1214 2 : switch (sql_trans_sequence_restart(m->session->tr, seq, start)) {
1215 0 : case -1:
1216 0 : throw(SQL,"sql.restart",SQLSTATE(HY013) MAL_MALLOC_FAIL);
1217 0 : case -2:
1218 : case -3:
1219 0 : throw(SQL,"sql.restart",SQLSTATE(42000) "RESTART SEQUENCE: transaction conflict detected");
1220 0 : case -4:
1221 0 : throw(SQL,"sql.restart",SQLSTATE(HY050) "Cannot (re)start sequence %s.%s", sname, seqname);
1222 2 : default:
1223 2 : *res = start;
1224 : }
1225 2 : return MAL_SUCCEED;
1226 : }
1227 :
1228 : BAT *
1229 0 : mvc_bind_idxbat(mvc *m, const char *sname, const char *tname, const char *iname, int access)
1230 : {
1231 0 : sql_trans *tr = m->session->tr;
1232 0 : BAT *b = NULL;
1233 0 : sql_schema *s = NULL;
1234 0 : sql_idx *i = NULL;
1235 :
1236 0 : s = mvc_bind_schema(m, sname);
1237 0 : if (s == NULL)
1238 : return NULL;
1239 0 : i = mvc_bind_idx(m, s, iname);
1240 0 : if (i == NULL || !isTable(i->t))
1241 : return NULL;
1242 :
1243 0 : (void) tname;
1244 0 : sqlstore *store = tr->store;
1245 0 : b = store->storage_api.bind_idx(tr, i, access);
1246 0 : return b;
1247 : }
1248 :
1249 : /* str mvc_bind_wrap(int *bid, str *sname, str *tname, str *cname, int *access); */
1250 : str
1251 1300382 : mvc_bind_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1252 : {
1253 1300382 : int upd = (pci->argc == 7 || pci->argc == 9);
1254 1300382 : BAT *b = NULL;
1255 1300382 : bat *bid = getArgReference_bat(stk, pci, 0);
1256 1300382 : mvc *m = NULL;
1257 1300382 : str msg;
1258 1300382 : const char *sname = *getArgReference_str(stk, pci, 2 + upd);
1259 1300382 : const char *tname = *getArgReference_str(stk, pci, 3 + upd);
1260 1300382 : const char *cname = *getArgReference_str(stk, pci, 4 + upd);
1261 1300382 : const int access = *getArgReference_int(stk, pci, 5 + upd);
1262 :
1263 1300382 : const bool partitioned_access = pci->argc == (8 + upd) && getArgType(mb, pci, 6 + upd) == TYPE_int;
1264 :
1265 : /* This doesn't work with quick access for now... */
1266 1300382 : assert(access != QUICK);
1267 1300382 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1268 : return msg;
1269 1300052 : if ((msg = checkSQLContext(cntxt)) != NULL)
1270 : return msg;
1271 1299983 : sqlstore *store = m->store;
1272 1299983 : sql_schema *s = mvc_bind_schema(m, sname);
1273 1300072 : sql_table *t = mvc_bind_table(m, s, tname);
1274 1300091 : if (t && !isTable(t))
1275 0 : throw(SQL, "sql.bind", SQLSTATE(42000) "%s '%s' is not persistent",
1276 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
1277 1300091 : sql_column *c = mvc_bind_column(m, t, cname);
1278 :
1279 1300024 : if (partitioned_access) {
1280 : /* partitioned access */
1281 931669 : int part_nr = *getArgReference_int(stk, pci, 6 + upd);
1282 931669 : int nr_parts = *getArgReference_int(stk, pci, 7 + upd);
1283 931669 : BUN cnt = store->storage_api.count_col(m->session->tr, c, 0), psz;
1284 931989 : oid l, h;
1285 931989 : psz = cnt ? (cnt / nr_parts) : 0;
1286 931989 : l = part_nr * psz;
1287 931989 : if (l > cnt)
1288 0 : l = cnt;
1289 931989 : h = (part_nr + 1 == nr_parts) ? cnt : ((part_nr + 1) * psz);
1290 931989 : if (h > cnt)
1291 0 : h = cnt;
1292 :
1293 931989 : if (upd) {
1294 237570 : BAT *ui = NULL, *uv = NULL;
1295 237570 : if (store->storage_api.bind_updates(m->session->tr, c, &ui, &uv) == LOG_ERR)
1296 0 : throw(SQL,"sql.bind",SQLSTATE(HY005) "Cannot access the update columns");
1297 :
1298 237557 : h--;
1299 237557 : BAT* bn = BATselect(ui, NULL, &l, &h, true, true, false);
1300 237486 : if(bn == NULL) {
1301 0 : BBPunfix(ui->batCacheid);
1302 0 : BBPunfix(uv->batCacheid);
1303 0 : throw(SQL, "sql.bind", GDK_EXCEPTION);
1304 : }
1305 :
1306 237486 : bat *uvl = getArgReference_bat(stk, pci, 1);
1307 :
1308 237486 : if (BATcount(bn)) {
1309 3 : BAT *id;
1310 3 : BAT *vl;
1311 3 : if (ui == NULL || uv == NULL) {
1312 0 : bat_destroy(uv);
1313 0 : bat_destroy(ui);
1314 0 : BBPunfix(bn->batCacheid);
1315 0 : throw(SQL,"sql.bind",SQLSTATE(HY005) "Cannot access the insert column %s.%s.%s",
1316 : sname, tname, cname);
1317 : }
1318 3 : assert(uv->batCount == ui->batCount);
1319 3 : id = BATproject(bn, ui);
1320 3 : vl = BATproject(bn, uv);
1321 3 : bat_destroy(ui);
1322 3 : bat_destroy(uv);
1323 3 : if (id == NULL || vl == NULL) {
1324 0 : BBPunfix(bn->batCacheid);
1325 0 : bat_destroy(id);
1326 0 : bat_destroy(vl);
1327 0 : throw(SQL, "sql.bind", GDK_EXCEPTION);
1328 : }
1329 3 : if ( BATcount(id) != BATcount(vl)){
1330 0 : BBPunfix(bn->batCacheid);
1331 0 : bat_destroy(id);
1332 0 : bat_destroy(vl);
1333 0 : throw(SQL, "sql.bind", SQLSTATE(0000) "Inconsistent BAT count");
1334 : }
1335 3 : BBPkeepref(id);
1336 3 : BBPkeepref(vl);
1337 3 : *bid = id->batCacheid;
1338 3 : *uvl = vl->batCacheid;
1339 : } else {
1340 237483 : *bid = e_bat(TYPE_oid);
1341 237523 : *uvl = e_bat(c->type.type->localtype);
1342 237566 : if (*bid == BID_NIL || *uvl == BID_NIL) {
1343 0 : if (*bid)
1344 0 : BBPunfix(*bid);
1345 0 : if (*uvl)
1346 0 : BBPunfix(*uvl);
1347 0 : BBPunfix(b->batCacheid);
1348 0 : throw(SQL, "sql.bind", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1349 : }
1350 : }
1351 : } else {
1352 694419 : int coltype = getBatType(getArgType(mb, pci, 0));
1353 694419 : b = store->storage_api.bind_col(m->session->tr, c, access);
1354 694348 : if (b == NULL)
1355 0 : throw(SQL, "sql.bind", SQLSTATE(42000) "Cannot bind column %s.%s.%s", sname, tname, cname);
1356 :
1357 694348 : if (b->ttype && b->ttype != coltype) {
1358 0 : BBPunfix(b->batCacheid);
1359 0 : throw(SQL,"sql.bind",SQLSTATE(42000) "Column type mismatch %s.%s.%s",sname,tname,cname);
1360 : }
1361 :
1362 694348 : BAT* bn = BATslice(b, l, h);
1363 694321 : if(bn == NULL) {
1364 0 : BBPunfix(b->batCacheid);
1365 0 : throw(SQL, "sql.bind", GDK_EXCEPTION);
1366 : }
1367 694321 : BAThseqbase(bn, l);
1368 694355 : BBPunfix(b->batCacheid);
1369 694159 : BBPkeepref(bn);
1370 694148 : *bid = bn->batCacheid;
1371 : }
1372 : }
1373 368355 : else if (upd) { /*unpartitioned access to update bats*/
1374 112875 : BAT *ui = NULL, *uv = NULL;
1375 112875 : if (store->storage_api.bind_updates(m->session->tr, c, &ui, &uv) == LOG_ERR)
1376 0 : throw(SQL,"sql.bind",SQLSTATE(HY005) "Cannot access the update columns");
1377 :
1378 112879 : bat *uvl = getArgReference_bat(stk, pci, 1);
1379 112879 : BBPkeepref(ui);
1380 112879 : BBPkeepref(uv);
1381 112876 : *bid = ui->batCacheid;
1382 112876 : *uvl = uv->batCacheid;
1383 : }
1384 : else { /*unpartitioned access to base column*/
1385 255480 : int coltype = getBatType(getArgType(mb, pci, 0));
1386 255480 : b = store->storage_api.bind_col(m->session->tr, c, access);
1387 255484 : if (b == NULL)
1388 0 : throw(SQL, "sql.bin", "Couldn't bind column");
1389 :
1390 255484 : if (b->ttype && b->ttype != coltype) {
1391 0 : BBPunfix(b->batCacheid);
1392 0 : throw(SQL,"sql.bind",SQLSTATE(42000) "Column type mismatch %s.%s.%s",sname,tname,cname);
1393 : }
1394 255484 : BBPkeepref(b);
1395 255432 : *bid = b->batCacheid;
1396 : }
1397 : return MAL_SUCCEED;
1398 : }
1399 :
1400 : /* The output of this function are 7 columns:
1401 : * - The sqlid of the column
1402 : * - Number of values of the column.
1403 : * - Number of segments, indication of the fragmentation
1404 : * - Number of inserted rows during the current transaction.
1405 : * - Number of updated rows during the current transaction.
1406 : * - Number of deletes of the column's table.
1407 : * - the number in the transaction chain (.i.e for each savepoint a new transaction is added in the chain)
1408 : */
1409 :
1410 : static str
1411 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)
1412 : {
1413 17 : int level = 0;
1414 17 : sqlstore *store = m->session->tr->store;
1415 :
1416 17 : lng inserted = (lng) store->storage_api.count_col(m->session->tr, c, 1);
1417 17 : lng all = (lng) store->storage_api.count_col(m->session->tr, c, 0);
1418 17 : lng updates = (lng) store->storage_api.count_col(m->session->tr, c, 2);
1419 :
1420 17 : if (BUNappend(col1, &c->base.id, false) != GDK_SUCCEED) {
1421 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1422 : }
1423 17 : if (BUNappend(col2, &segments, false) != GDK_SUCCEED) {
1424 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1425 : }
1426 17 : if (BUNappend(col3, &all, false) != GDK_SUCCEED) {
1427 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1428 : }
1429 17 : if (BUNappend(col4, &inserted, false) != GDK_SUCCEED) {
1430 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1431 : }
1432 17 : if (BUNappend(col5, &updates, false) != GDK_SUCCEED) {
1433 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1434 : }
1435 17 : if (BUNappend(col6, &deletes, false) != GDK_SUCCEED) {
1436 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1437 : }
1438 : /* compute level using global transaction */
1439 17 : if (c) {
1440 34 : for(sql_delta *d = ATOMIC_PTR_GET(&c->data); d; d = d->next)
1441 17 : level++;
1442 : }
1443 17 : if (BUNappend(col7, &level, false) != GDK_SUCCEED) {
1444 0 : return createException(SQL,"sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1445 : }
1446 : return MAL_SUCCEED;
1447 : }
1448 :
1449 : str
1450 17 : mvc_delta_values(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1451 : {
1452 17 : const char *sname = *getArgReference_str(stk, pci, 7),
1453 17 : *tname = (pci->argc > 8) ? *getArgReference_str(stk, pci, 8) : NULL,
1454 17 : *cname = (pci->argc > 9) ? *getArgReference_str(stk, pci, 9) : NULL;
1455 17 : mvc *m;
1456 17 : str msg = MAL_SUCCEED;
1457 17 : BAT *col1 = NULL, *col2 = NULL, *col3 = NULL, *col4 = NULL, *col5 = NULL, *col6 = NULL, *col7 = NULL;
1458 17 : bat *b1 = getArgReference_bat(stk, pci, 0),
1459 17 : *b2 = getArgReference_bat(stk, pci, 1),
1460 17 : *b3 = getArgReference_bat(stk, pci, 2),
1461 17 : *b4 = getArgReference_bat(stk, pci, 3),
1462 17 : *b5 = getArgReference_bat(stk, pci, 4),
1463 17 : *b6 = getArgReference_bat(stk, pci, 5),
1464 17 : *b7 = getArgReference_bat(stk, pci, 6);
1465 17 : sql_schema *s = NULL;
1466 17 : sql_table *t = NULL;
1467 17 : sql_column *c = NULL;
1468 17 : node *n;
1469 17 : BUN nrows = 0;
1470 17 : lng deletes, segments;
1471 :
1472 17 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1473 : return msg;
1474 :
1475 17 : sqlstore *store = m->store;
1476 17 : sql_trans *tr = m->session->tr;
1477 17 : if ((msg = checkSQLContext(cntxt)) != NULL)
1478 0 : goto cleanup;
1479 :
1480 17 : if (!(s = mvc_bind_schema(m, sname)))
1481 0 : throw(SQL, "sql.delta", SQLSTATE(3F000) "No such schema '%s'", sname);
1482 :
1483 17 : if (tname) {
1484 17 : if (!(t = mvc_bind_table(m, s, tname)))
1485 0 : throw(SQL, "sql.delta", SQLSTATE(3F000) "No such table '%s' in schema '%s'", tname, s->base.name);
1486 17 : if (!isTable(t))
1487 0 : throw(SQL, "sql.delta", SQLSTATE(42000) "%s doesn't have delta values", TABLE_TYPE_DESCRIPTION(t->type, t->properties));
1488 17 : if (cname) {
1489 0 : if (!(c = mvc_bind_column(m, t, cname)))
1490 0 : throw(SQL, "sql.delta", SQLSTATE(3F000) "No such column '%s' in table '%s'", cname, t->base.name);
1491 : nrows = 1;
1492 : } else {
1493 17 : nrows = (BUN) ol_length(t->columns);
1494 : }
1495 0 : } else if (s->tables) {
1496 0 : struct os_iter oi;
1497 0 : os_iterator(&oi, s->tables, tr, NULL);
1498 0 : for (sql_base *b = oi_next(&oi); b; b = oi_next(&oi)) {
1499 0 : t = (sql_table *)b;
1500 0 : if (isTable(t))
1501 0 : nrows += (BUN) ol_length(t->columns);
1502 : }
1503 : }
1504 :
1505 17 : if ((col1 = COLnew(0, TYPE_int, nrows, TRANSIENT)) == NULL) {
1506 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1507 0 : goto cleanup;
1508 : }
1509 17 : if ((col2 = COLnew(0, TYPE_lng, nrows, TRANSIENT)) == NULL) {
1510 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1511 0 : goto cleanup;
1512 : }
1513 17 : if ((col3 = COLnew(0, TYPE_lng, nrows, TRANSIENT)) == NULL) {
1514 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1515 0 : goto cleanup;
1516 : }
1517 17 : if ((col4 = COLnew(0, TYPE_lng, nrows, TRANSIENT)) == NULL) {
1518 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1519 0 : goto cleanup;
1520 : }
1521 17 : if ((col5 = COLnew(0, TYPE_lng, nrows, TRANSIENT)) == NULL) {
1522 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1523 0 : goto cleanup;
1524 : }
1525 17 : if ((col6 = COLnew(0, TYPE_lng, nrows, TRANSIENT)) == NULL) {
1526 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1527 0 : goto cleanup;
1528 : }
1529 17 : if ((col7 = COLnew(0, TYPE_int, nrows, TRANSIENT)) == NULL) {
1530 0 : msg = createException(SQL, "sql.delta", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1531 0 : goto cleanup;
1532 : }
1533 :
1534 17 : if (nrows) {
1535 17 : if (tname) {
1536 17 : deletes = (lng) store->storage_api.count_del(m->session->tr, t, 0);
1537 17 : segments = (lng) store->storage_api.count_del(m->session->tr, t, 10);
1538 17 : if (cname) {
1539 0 : if ((msg=mvc_insert_delta_values(m, col1, col2, col3, col4, col5, col6, col7, c, segments, deletes)) != NULL)
1540 0 : goto cleanup;
1541 : } else {
1542 34 : for (n = ol_first_node(t->columns); n ; n = n->next) {
1543 17 : c = (sql_column*) n->data;
1544 17 : if ((msg=mvc_insert_delta_values(m, col1, col2, col3, col4, col5, col6, col7, c, segments, deletes)) != NULL)
1545 0 : goto cleanup;
1546 : }
1547 : }
1548 0 : } else if (s->tables) {
1549 0 : struct os_iter oi;
1550 0 : os_iterator(&oi, s->tables, tr, NULL);
1551 0 : for (sql_base *b = oi_next(&oi); b; b = oi_next(&oi)) {
1552 0 : t = (sql_table *)b;
1553 0 : if (isTable(t)) {
1554 0 : deletes = (lng) store->storage_api.count_del(m->session->tr, t, 0);
1555 0 : segments = (lng) store->storage_api.count_del(m->session->tr, t, 10);
1556 :
1557 0 : for (node *nn = ol_first_node(t->columns); nn ; nn = nn->next) {
1558 0 : c = (sql_column*) nn->data;
1559 :
1560 0 : if ((msg=mvc_insert_delta_values(m, col1, col2, col3, col4, col5, col6, col7, c, segments, deletes)) != NULL)
1561 0 : goto cleanup;
1562 : }
1563 : }
1564 : }
1565 : }
1566 : }
1567 :
1568 0 : cleanup:
1569 17 : if (msg) {
1570 0 : if (col1)
1571 0 : BBPreclaim(col1);
1572 0 : if (col2)
1573 0 : BBPreclaim(col2);
1574 0 : if (col3)
1575 0 : BBPreclaim(col3);
1576 0 : if (col4)
1577 0 : BBPreclaim(col4);
1578 0 : if (col5)
1579 0 : BBPreclaim(col5);
1580 0 : if (col6)
1581 0 : BBPreclaim(col6);
1582 0 : if (col7)
1583 0 : BBPreclaim(col7);
1584 : } else {
1585 17 : *b1 = col1->batCacheid;
1586 17 : BBPkeepref(col1);
1587 17 : *b2 = col2->batCacheid;
1588 17 : BBPkeepref(col2);
1589 17 : *b3 = col3->batCacheid;
1590 17 : BBPkeepref(col3);
1591 17 : *b4 = col4->batCacheid;
1592 17 : BBPkeepref(col4);
1593 17 : *b5 = col5->batCacheid;
1594 17 : BBPkeepref(col5);
1595 17 : *b6 = col6->batCacheid;
1596 17 : BBPkeepref(col6);
1597 17 : *b7 = col7->batCacheid;
1598 17 : BBPkeepref(col7);
1599 : }
1600 : return msg;
1601 : }
1602 :
1603 : /* str mvc_bind_idxbat_wrap(int *bid, str *sname, str *tname, str *iname, int *access); */
1604 : str
1605 2526 : mvc_bind_idxbat_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1606 : {
1607 2526 : int upd = (pci->argc == 7 || pci->argc == 9);
1608 2526 : BAT *b = NULL;
1609 2526 : bat *bid = getArgReference_bat(stk, pci, 0);
1610 2526 : mvc *m = NULL;
1611 2526 : str msg;
1612 2526 : const char *sname = *getArgReference_str(stk, pci, 2 + upd);
1613 2526 : const char *tname = *getArgReference_str(stk, pci, 3 + upd);
1614 2526 : const char *iname = *getArgReference_str(stk, pci, 4 + upd);
1615 2526 : const int access = *getArgReference_int(stk, pci, 5 + upd);
1616 :
1617 2526 : const bool partitioned_access = pci->argc == (8 + upd) && getArgType(mb, pci, 6 + upd) == TYPE_int;
1618 :
1619 : /* This doesn't work with quick access for now... */
1620 2526 : assert(access != QUICK);
1621 2526 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1622 : return msg;
1623 2526 : if ((msg = checkSQLContext(cntxt)) != NULL)
1624 : return msg;
1625 2526 : sqlstore *store = m->store;
1626 2526 : sql_schema *s = mvc_bind_schema(m, sname);
1627 2524 : sql_table *t = mvc_bind_table(m, s, tname);
1628 2524 : if (t && !isTable(t))
1629 0 : throw(SQL, "sql.bindidx", SQLSTATE(42000) "%s '%s' is not persistent",
1630 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
1631 2524 : sql_idx *i = mvc_bind_idx(m, s, iname);
1632 :
1633 2526 : if (partitioned_access) {
1634 : /* partitioned access */
1635 1453 : int part_nr = *getArgReference_int(stk, pci, 6 + upd);
1636 1453 : int nr_parts = *getArgReference_int(stk, pci, 7 + upd);
1637 1453 : BUN cnt = store->storage_api.count_idx(m->session->tr, i, 0), psz;
1638 1453 : oid l, h;
1639 1453 : psz = cnt ? (cnt / nr_parts) : 0;
1640 1453 : l = part_nr * psz;
1641 1453 : if (l > cnt)
1642 0 : l = cnt;
1643 1453 : h = (part_nr + 1 == nr_parts) ? cnt : ((part_nr + 1) * psz);
1644 1453 : if (h > cnt)
1645 0 : h = cnt;
1646 :
1647 1453 : if (upd) {
1648 0 : BAT *ui = NULL, *uv = NULL;
1649 0 : if (store->storage_api.bind_updates_idx(m->session->tr, i, &ui, &uv) == LOG_ERR)
1650 0 : throw(SQL,"sql.bindidx",SQLSTATE(HY005) "Cannot access the update columns");
1651 :
1652 0 : h--;
1653 0 : BAT* bn = BATselect(ui, NULL, &l, &h, true, true, false);
1654 0 : if(bn == NULL) {
1655 0 : BBPunfix(ui->batCacheid);
1656 0 : BBPunfix(uv->batCacheid);
1657 0 : throw(SQL, "sql.bindidx", GDK_EXCEPTION);
1658 : }
1659 :
1660 0 : bat *uvl = getArgReference_bat(stk, pci, 1);
1661 :
1662 0 : if (BATcount(bn)) {
1663 0 : BAT *id;
1664 0 : BAT *vl;
1665 0 : if (ui == NULL || uv == NULL) {
1666 0 : bat_destroy(uv);
1667 0 : bat_destroy(ui);
1668 0 : BBPunfix(bn->batCacheid);
1669 0 : throw(SQL,"sql.bindidx",SQLSTATE(42000) "Cannot access index column %s.%s.%s",sname,tname,iname);
1670 : }
1671 0 : assert(uv->batCount == ui->batCount);
1672 0 : id = BATproject(bn, ui);
1673 0 : vl = BATproject(bn, uv);
1674 0 : bat_destroy(ui);
1675 0 : bat_destroy(uv);
1676 0 : if (id == NULL || vl == NULL) {
1677 0 : BBPunfix(bn->batCacheid);
1678 0 : bat_destroy(id);
1679 0 : bat_destroy(vl);
1680 0 : throw(SQL, "sql.bindidx", GDK_EXCEPTION);
1681 : }
1682 0 : if ( BATcount(id) != BATcount(vl)){
1683 0 : BBPunfix(bn->batCacheid);
1684 0 : bat_destroy(id);
1685 0 : bat_destroy(vl);
1686 0 : throw(SQL, "sql.bindidx", SQLSTATE(0000) "Inconsistent BAT count");
1687 : }
1688 0 : BBPkeepref(id);
1689 0 : BBPkeepref(vl);
1690 0 : *bid = id->batCacheid;
1691 0 : *uvl = vl->batCacheid;
1692 : } else {
1693 0 : *bid = e_bat(TYPE_oid);
1694 0 : *uvl = e_bat((i->type==join_idx)?TYPE_oid:TYPE_lng);
1695 0 : if (*bid == BID_NIL || *uvl == BID_NIL) {
1696 0 : if (*bid)
1697 0 : BBPunfix(*bid);
1698 0 : if (*uvl)
1699 0 : BBPunfix(*uvl);
1700 0 : BBPunfix(b->batCacheid);
1701 0 : throw(SQL, "sql.bindidx", SQLSTATE(HY013) MAL_MALLOC_FAIL);
1702 : }
1703 : }
1704 : } else {
1705 1453 : int idxtype = getBatType(getArgType(mb, pci, 0));
1706 1453 : b = store->storage_api.bind_idx(m->session->tr, i, access);
1707 :
1708 1453 : if (b && b->ttype && b->ttype != idxtype) {
1709 0 : BBPunfix(b->batCacheid);
1710 0 : throw(SQL,"sql.bindidx",SQLSTATE(42000) "Index type mismatch %s.%s.%s",sname,tname,iname);
1711 : }
1712 :
1713 1453 : BAT* bn = BATslice(b, l, h);
1714 1453 : if(bn == NULL) {
1715 0 : BBPunfix(b->batCacheid);
1716 0 : throw(SQL, "sql.bindidx", GDK_EXCEPTION);
1717 : }
1718 1453 : BAThseqbase(bn, l);
1719 1453 : BBPunfix(b->batCacheid);
1720 1453 : BBPkeepref(bn);
1721 1452 : *bid = bn->batCacheid;
1722 : }
1723 : }
1724 1073 : else if (upd) { /*unpartitioned access to update bats*/
1725 23 : BAT *ui = NULL, *uv = NULL;
1726 23 : if (store->storage_api.bind_updates_idx(m->session->tr, i, &ui, &uv) == LOG_ERR)
1727 0 : throw(SQL,"sql.bindidx",SQLSTATE(HY005) "Cannot access the update columns");
1728 :
1729 23 : bat *uvl = getArgReference_bat(stk, pci, 1);
1730 23 : BBPkeepref(ui);
1731 23 : BBPkeepref(uv);
1732 23 : *bid = ui->batCacheid;
1733 23 : *uvl = uv->batCacheid;
1734 : }
1735 : else { /*unpartitioned access to base index*/
1736 1050 : int idxtype = getBatType(getArgType(mb, pci, 0));
1737 1050 : b = store->storage_api.bind_idx(m->session->tr, i, access);
1738 1050 : if (b == NULL)
1739 0 : throw(SQL,"sql.bindidx", "Couldn't bind index");
1740 :
1741 1050 : if (b->ttype && b->ttype != idxtype) {
1742 0 : BBPunfix(b->batCacheid);
1743 0 : throw(SQL,"sql.bindidx",SQLSTATE(42000) "Index type mismatch %s.%s.%s",sname,tname,iname);
1744 : }
1745 1050 : BBPkeepref(b);
1746 1050 : *bid = b->batCacheid;
1747 : }
1748 : return MAL_SUCCEED;
1749 : }
1750 :
1751 : str
1752 52 : mvc_append_column(sql_trans *t, sql_column *c, BUN offset, BAT *pos, BAT *ins)
1753 : {
1754 52 : sqlstore *store = t->store;
1755 52 : int res = store->storage_api.append_col(t, c, offset, pos, ins, BATcount(ins), true, ins->ttype);
1756 52 : if (res != LOG_OK) /* the conflict case should never happen, but leave it here */
1757 0 : throw(SQL, "sql.append", SQLSTATE(42000) "Append failed %s", res == LOG_CONFLICT ? "due to conflict with another transaction" : GDKerrbuf);
1758 : return MAL_SUCCEED;
1759 : }
1760 :
1761 : /*mvc_grow_wrap(int *bid, str *sname, str *tname, str *cname, ptr d) */
1762 : str
1763 341 : mvc_grow_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1764 : {
1765 341 : int *res = getArgReference_int(stk, pci, 0);
1766 341 : bat Tid = *getArgReference_bat(stk, pci, 1);
1767 341 : ptr Ins = getArgReference(stk, pci, 2);
1768 341 : int tpe = getArgType(mb, pci, 2);
1769 341 : bool isbat = false;
1770 341 : BAT *tid = 0, *ins = 0;
1771 341 : size_t cnt = 1;
1772 341 : oid v = 0;
1773 :
1774 341 : (void)cntxt;
1775 341 : *res = 0;
1776 341 : if ((tid = BATdescriptor(Tid)) == NULL)
1777 0 : throw(SQL, "sql.grow", SQLSTATE(HY005) "Cannot access descriptor");
1778 341 : if (isaBatType(tpe))
1779 8 : isbat = true;
1780 8 : if (isbat && (ins = BATdescriptor(*(bat *) Ins)) == NULL) {
1781 0 : BBPunfix(Tid);
1782 0 : throw(SQL, "sql.grow", SQLSTATE(HY005) "Cannot access descriptor");
1783 : }
1784 8 : if (ins) {
1785 8 : cnt = BATcount(ins);
1786 8 : BBPunfix(ins->batCacheid);
1787 : }
1788 341 : if (BATcount(tid)) {
1789 311 : (void)BATmax(tid, &v);
1790 311 : v++;
1791 : }
1792 691 : for(;cnt>0; cnt--, v++) {
1793 350 : if (BUNappend(tid, &v, false) != GDK_SUCCEED) {
1794 0 : BBPunfix(Tid);
1795 0 : throw(SQL, "sql.grow", GDK_EXCEPTION);
1796 : }
1797 : }
1798 341 : BBPunfix(Tid);
1799 341 : return MAL_SUCCEED;
1800 : }
1801 :
1802 : /*mvc_append_wrap(int *bid, str *sname, str *tname, str *cname, ptr d) */
1803 : str
1804 580742 : mvc_append_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1805 : {
1806 580742 : int *res = getArgReference_int(stk, pci, 0);
1807 580742 : mvc *m = NULL;
1808 580742 : str msg;
1809 580742 : const char *sname = *getArgReference_str(stk, pci, 2);
1810 580742 : const char *tname = *getArgReference_str(stk, pci, 3);
1811 580742 : const char *cname = *getArgReference_str(stk, pci, 4);
1812 580742 : BUN offset = (BUN)*getArgReference_oid(stk, pci, 5);
1813 580742 : bat Pos = *getArgReference_bat(stk, pci, 6);
1814 580742 : ptr ins = getArgReference(stk, pci, 7);
1815 580658 : int tpe = getArgType(mb, pci, 7), log_res = LOG_OK;
1816 580658 : bool isbat = false;
1817 580658 : sql_schema *s;
1818 580658 : sql_table *t;
1819 580658 : sql_column *c;
1820 580658 : sql_idx *i;
1821 580658 : BAT *b = NULL, *pos = NULL;
1822 580658 : BUN cnt = 1;
1823 :
1824 580658 : *res = 0;
1825 580658 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1826 : return msg;
1827 580505 : if ((msg = checkSQLContext(cntxt)) != NULL)
1828 : return msg;
1829 580461 : if (isaBatType(tpe)) {
1830 151037 : isbat = true;
1831 151037 : tpe = getBatType(tpe);
1832 : }
1833 580461 : if (Pos != bat_nil && (pos = BATdescriptor(Pos)) == NULL)
1834 0 : throw(SQL, "sql.append", SQLSTATE(HY005) "Cannot access append positions descriptor");
1835 580461 : if (isbat && (ins = BATdescriptor(*(bat *) ins)) == NULL) {
1836 0 : bat_destroy(pos);
1837 0 : throw(SQL, "sql.append", SQLSTATE(HY005) "Cannot access append values descriptor");
1838 : }
1839 580483 : if (!isbat && ATOMextern(tpe) && !ATOMvarsized(tpe))
1840 11 : ins = *(ptr *) ins;
1841 151069 : if (isbat) {
1842 151069 : b = (BAT*) ins;
1843 151069 : if (VIEWtparent(b) || VIEWvtparent(b)) {
1844 : /* note, b == (BAT*)ins */
1845 723 : b = COLcopy(b, b->ttype, true, TRANSIENT);
1846 723 : BBPreclaim(ins);
1847 723 : ins = b;
1848 723 : if (b == NULL)
1849 0 : throw(SQL, "sql.append", GDK_EXCEPTION);
1850 : }
1851 : }
1852 580483 : s = mvc_bind_schema(m, sname);
1853 580505 : if (s == NULL) {
1854 0 : bat_destroy(pos);
1855 0 : bat_destroy(b);
1856 0 : throw(SQL, "sql.append", SQLSTATE(3F000) "Schema missing %s",sname);
1857 : }
1858 580505 : t = mvc_bind_table(m, s, tname);
1859 580822 : if (t == NULL) {
1860 0 : bat_destroy(pos);
1861 0 : bat_destroy(b);
1862 0 : throw(SQL, "sql.append", SQLSTATE(42S02) "Table missing %s",tname);
1863 : }
1864 580822 : if (!isTable(t)) {
1865 0 : bat_destroy(pos);
1866 0 : bat_destroy(b);
1867 0 : throw(SQL, "sql.append", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
1868 : }
1869 580822 : if (b)
1870 151077 : cnt = BATcount(b);
1871 580822 : sqlstore *store = m->session->tr->store;
1872 580822 : if (cname[0] != '%' && (c = mvc_bind_column(m, t, cname)) != NULL) {
1873 578390 : log_res = store->storage_api.append_col(m->session->tr, c, offset, pos, ins, cnt, isbat, tpe);
1874 2184 : } else if (cname[0] == '%' && (i = mvc_bind_idx(m, s, cname + 1)) != NULL) {
1875 2184 : log_res = store->storage_api.append_idx(m->session->tr, i, offset, pos, ins, cnt, isbat, tpe);
1876 : } else {
1877 0 : bat_destroy(pos);
1878 0 : bat_destroy(b);
1879 0 : throw(SQL, "sql.append", SQLSTATE(38000) "Unable to find column or index %s.%s.%s",sname,tname,cname);
1880 : }
1881 580642 : bat_destroy(pos);
1882 580578 : bat_destroy(b);
1883 580371 : if (log_res != LOG_OK) /* the conflict case should never happen, but leave it here */
1884 0 : throw(SQL, "sql.append", SQLSTATE(42000) "Append failed %s", log_res == LOG_CONFLICT ? "due to conflict with another transaction" : GDKerrbuf);
1885 : return MAL_SUCCEED;
1886 : }
1887 :
1888 : /*mvc_update_wrap(int *bid, str *sname, str *tname, str *cname, ptr d) */
1889 : str
1890 3714 : mvc_update_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1891 : {
1892 3714 : int *res = getArgReference_int(stk, pci, 0);
1893 3714 : mvc *m = NULL;
1894 3714 : str msg;
1895 3714 : const char *sname = *getArgReference_str(stk, pci, 2);
1896 3714 : const char *tname = *getArgReference_str(stk, pci, 3);
1897 3714 : const char *cname = *getArgReference_str(stk, pci, 4);
1898 3714 : bat Tids = *getArgReference_bat(stk, pci, 5);
1899 3714 : bat Upd = *getArgReference_bat(stk, pci, 6);
1900 3714 : BAT *tids, *upd;
1901 3714 : int tpe = getArgType(mb, pci, 6), log_res = LOG_OK;
1902 3714 : bool isbat = false;
1903 3714 : sql_schema *s;
1904 3714 : sql_table *t;
1905 3714 : sql_column *c;
1906 3714 : sql_idx *i;
1907 :
1908 3714 : *res = 0;
1909 3714 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1910 : return msg;
1911 3714 : if ((msg = checkSQLContext(cntxt)) != NULL)
1912 : return msg;
1913 3714 : if (isaBatType(tpe))
1914 3714 : isbat = true;
1915 : else
1916 0 : assert(0);
1917 3714 : if (!isbat)
1918 : throw(SQL, "sql.update", SQLSTATE(HY005) "Update values is not a BAT input");
1919 3714 : if ((tids = BATdescriptor(Tids)) == NULL)
1920 0 : throw(SQL, "sql.update", SQLSTATE(HY005) "Cannot access update positions descriptor");
1921 3714 : if ((upd = BATdescriptor(Upd)) == NULL) {
1922 0 : BBPunfix(tids->batCacheid);
1923 0 : throw(SQL, "sql.update", SQLSTATE(HY005) "Cannot access update values descriptor");
1924 : }
1925 3714 : s = mvc_bind_schema(m, sname);
1926 3714 : if (s == NULL) {
1927 0 : BBPunfix(tids->batCacheid);
1928 0 : BBPunfix(upd->batCacheid);
1929 0 : throw(SQL, "sql.update", SQLSTATE(3F000) "Schema missing %s",sname);
1930 : }
1931 3714 : t = mvc_bind_table(m, s, tname);
1932 3714 : if (t == NULL) {
1933 0 : BBPunfix(tids->batCacheid);
1934 0 : BBPunfix(upd->batCacheid);
1935 0 : throw(SQL, "sql.update", SQLSTATE(42S02) "Table missing %s.%s",sname,tname);
1936 : }
1937 3714 : if (!isTable(t)) {
1938 0 : BBPunfix(tids->batCacheid);
1939 0 : BBPunfix(upd->batCacheid);
1940 0 : throw(SQL, "sql.update", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
1941 : }
1942 3714 : sqlstore *store = m->session->tr->store;
1943 3714 : if (cname[0] != '%' && (c = mvc_bind_column(m, t, cname)) != NULL) {
1944 2932 : log_res = store->storage_api.update_col(m->session->tr, c, tids, upd, isbat);
1945 782 : } else if (cname[0] == '%' && (i = mvc_bind_idx(m, s, cname + 1)) != NULL) {
1946 782 : log_res = store->storage_api.update_idx(m->session->tr, i, tids, upd, isbat);
1947 : } else {
1948 0 : BBPunfix(tids->batCacheid);
1949 0 : BBPunfix(upd->batCacheid);
1950 0 : throw(SQL, "sql.update", SQLSTATE(38000) "Unable to find column or index %s.%s.%s",sname,tname,cname);
1951 : }
1952 3714 : BBPunfix(tids->batCacheid);
1953 3714 : BBPunfix(upd->batCacheid);
1954 3714 : if (log_res != LOG_OK)
1955 1 : throw(SQL, "sql.update", SQLSTATE(42000) "Update failed%s", log_res == LOG_CONFLICT ? " due to conflict with another transaction" : "");
1956 : return MAL_SUCCEED;
1957 : }
1958 :
1959 : /* str mvc_clear_table_wrap(lng *res, str *sname, str *tname); */
1960 : str
1961 41826 : mvc_clear_table_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1962 : {
1963 41826 : sql_schema *s;
1964 41826 : sql_table *t;
1965 41826 : mvc *m = NULL;
1966 41826 : str msg;
1967 41826 : BUN clear_res;
1968 41826 : lng *res = getArgReference_lng(stk, pci, 0);
1969 41826 : const char *sname = *getArgReference_str(stk, pci, 1);
1970 41826 : const char *tname = *getArgReference_str(stk, pci, 2);
1971 41826 : int restart_sequences = *getArgReference_int(stk, pci, 3);
1972 :
1973 41826 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
1974 : return msg;
1975 41826 : if ((msg = checkSQLContext(cntxt)) != NULL)
1976 : return msg;
1977 41826 : s = mvc_bind_schema(m, sname);
1978 41826 : if (s == NULL)
1979 0 : throw(SQL, "sql.clear_table", SQLSTATE(3F000) "Schema missing %s", sname);
1980 41826 : t = mvc_bind_table(m, s, tname);
1981 41826 : if (t == NULL)
1982 0 : throw(SQL, "sql.clear_table", SQLSTATE(42S02) "Table missing %s.%s", sname,tname);
1983 41826 : if (!isTable(t))
1984 0 : throw(SQL, "sql.clear_table", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
1985 41826 : clear_res = mvc_clear_table(m, t);
1986 41826 : if (clear_res >= BUN_NONE - 1)
1987 15870 : throw(SQL, "sql.clear_table", SQLSTATE(42000) "Table clear failed%s", clear_res == (BUN_NONE - 1) ? " due to conflict with another transaction" : "");
1988 25956 : if (restart_sequences) { /* restart the sequences if it's the case */
1989 2 : sql_trans *tr = m->session->tr;
1990 2 : const char next_value_for[] = "next value for ";
1991 :
1992 5 : for (node *n = ol_first_node(t->columns); n; n = n->next) {
1993 3 : sql_column *col = n->data;
1994 :
1995 3 : if (col->def && !strncmp(col->def, next_value_for, strlen(next_value_for))) {
1996 2 : sql_schema *seqs = NULL;
1997 2 : sql_sequence *seq = NULL;
1998 2 : char *schema = NULL, *seq_name = NULL;
1999 :
2000 2 : extract_schema_and_sequence_name(m->ta, col->def + strlen(next_value_for), &schema, &seq_name);
2001 2 : if (!schema || !seq_name || !(seqs = find_sql_schema(tr, schema)))
2002 0 : continue;
2003 :
2004 : /* TODO - At the moment the sequence may not be stored in the same schema as the table itself */
2005 2 : if ((seq = find_sql_sequence(tr, seqs, seq_name))) {
2006 2 : switch (sql_trans_sequence_restart(tr, seq, seq->start)) {
2007 0 : case -1:
2008 0 : throw(SQL, "sql.clear_table", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2009 0 : case -2:
2010 : case -3:
2011 0 : throw(SQL, "sql.clear_table", SQLSTATE(HY005) "RESTART SEQUENCE: transaction conflict detected");
2012 0 : case -4:
2013 0 : throw(SQL, "sql.clear_table", SQLSTATE(HY005) "Could not restart sequence %s.%s", seqs->base.name, seq_name);
2014 : default:
2015 : break;
2016 : }
2017 : }
2018 : }
2019 : }
2020 : }
2021 25956 : *res = (lng) clear_res;
2022 25956 : return MAL_SUCCEED;
2023 : }
2024 :
2025 : /*mvc_delete_wrap(int *d, str *sname, str *tname, ptr d) */
2026 : str
2027 333 : mvc_delete_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2028 : {
2029 333 : int *res = getArgReference_int(stk, pci, 0);
2030 333 : mvc *m = NULL;
2031 333 : str msg;
2032 333 : const char *sname = *getArgReference_str(stk, pci, 2);
2033 333 : const char *tname = *getArgReference_str(stk, pci, 3);
2034 333 : ptr ins = getArgReference(stk, pci, 4);
2035 333 : int tpe = getArgType(mb, pci, 4), log_res;
2036 333 : bool isbat = false;
2037 333 : BAT *b = NULL;
2038 333 : sql_schema *s;
2039 333 : sql_table *t;
2040 :
2041 333 : *res = 0;
2042 333 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
2043 : return msg;
2044 333 : if ((msg = checkSQLContext(cntxt)) != NULL)
2045 : return msg;
2046 333 : if (isaBatType(tpe))
2047 333 : isbat = true;
2048 333 : if (isbat && (b = BATdescriptor(*(bat *) ins)) == NULL)
2049 0 : throw(SQL, "sql.delete", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2050 333 : if (!isbat || (b->ttype != TYPE_oid && b->ttype != TYPE_void && b->ttype != TYPE_msk)) {
2051 0 : BBPreclaim(b);
2052 0 : throw(SQL, "sql.delete", SQLSTATE(HY005) "Cannot access column descriptor");
2053 : }
2054 333 : s = mvc_bind_schema(m, sname);
2055 333 : if (s == NULL) {
2056 0 : BBPreclaim(b);
2057 0 : throw(SQL, "sql.delete", SQLSTATE(3F000) "Schema missing %s",sname);
2058 : }
2059 333 : t = mvc_bind_table(m, s, tname);
2060 333 : if (t == NULL) {
2061 0 : BBPreclaim(b);
2062 0 : throw(SQL, "sql.delete", SQLSTATE(42S02) "Table missing %s.%s",sname,tname);
2063 : }
2064 333 : if (!isTable(t)) {
2065 0 : BBPreclaim(b);
2066 0 : throw(SQL, "sql.delete", SQLSTATE(42000) "%s '%s' is not persistent", TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
2067 : }
2068 333 : sqlstore *store = m->session->tr->store;
2069 333 : log_res = store->storage_api.delete_tab(m->session->tr, t, b, isbat);
2070 333 : BBPreclaim(b);
2071 333 : if (log_res != LOG_OK)
2072 1 : throw(SQL, "sql.delete", SQLSTATE(42000) "Delete failed%s", log_res == LOG_CONFLICT ? " due to conflict with another transaction" : "");
2073 : return MAL_SUCCEED;
2074 : }
2075 :
2076 : static inline BAT *
2077 13 : setwritable(BAT *b)
2078 : {
2079 13 : if (isVIEW(b)) {
2080 12 : BAT *bn = COLcopy(b, b->ttype, true, TRANSIENT);
2081 12 : BBPunfix(b->batCacheid);
2082 12 : b = bn;
2083 : }
2084 13 : return b;
2085 : }
2086 :
2087 : str
2088 164076 : DELTAbat(bat *result, const bat *col, const bat *uid, const bat *uval)
2089 : {
2090 164076 : BAT *c, *u_id, *u_val, *res;
2091 :
2092 164076 : if ((u_id = BBPquickdesc(*uid)) == NULL)
2093 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2094 :
2095 : /* no updates */
2096 163975 : if (BATcount(u_id) == 0) {
2097 163273 : BBPretain(*result = *col);
2098 163273 : return MAL_SUCCEED;
2099 : }
2100 :
2101 702 : c = BATdescriptor(*col);
2102 702 : if (c == NULL)
2103 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2104 702 : if ((res = COLcopy(c, c->ttype, true, TRANSIENT)) == NULL) {
2105 0 : BBPunfix(c->batCacheid);
2106 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2107 : }
2108 702 : BBPunfix(c->batCacheid);
2109 :
2110 702 : if ((u_val = BATdescriptor(*uval)) == NULL) {
2111 0 : BBPunfix(res->batCacheid);
2112 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2113 : }
2114 702 : if ((u_id = BATdescriptor(*uid)) == NULL) {
2115 0 : BBPunfix(u_val->batCacheid);
2116 0 : BBPunfix(res->batCacheid);
2117 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2118 : }
2119 702 : assert(BATcount(u_id) == BATcount(u_val));
2120 1404 : if (BATcount(u_id) &&
2121 702 : BATreplace(res, u_id, u_val, true) != GDK_SUCCEED) {
2122 0 : BBPunfix(u_id->batCacheid);
2123 0 : BBPunfix(u_val->batCacheid);
2124 0 : BBPunfix(res->batCacheid);
2125 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2126 : }
2127 702 : BBPunfix(u_id->batCacheid);
2128 702 : BBPunfix(u_val->batCacheid);
2129 :
2130 702 : *result = res->batCacheid;
2131 702 : BBPkeepref(res);
2132 702 : return MAL_SUCCEED;
2133 : }
2134 :
2135 : str
2136 58414 : DELTAsub(bat *result, const bat *col, const bat *cid, const bat *uid, const bat *uval)
2137 : {
2138 58414 : BAT *c, *cminu = NULL, *u_id, *u_val, *u, *res;
2139 58414 : gdk_return ret;
2140 :
2141 58414 : if ((u_id = BBPquickdesc(*uid)) == NULL)
2142 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2143 :
2144 : /* no updates */
2145 58407 : if (BATcount(u_id) == 0) {
2146 58335 : BBPretain(*result = *col);
2147 58335 : return MAL_SUCCEED;
2148 : }
2149 :
2150 72 : c = BATdescriptor(*col);
2151 72 : if (c == NULL)
2152 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2153 72 : res = c;
2154 72 : if (BATcount(u_id)) {
2155 72 : u_id = BATdescriptor(*uid);
2156 72 : if (!u_id) {
2157 0 : BBPunfix(c->batCacheid);
2158 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2159 : }
2160 72 : cminu = BATdiff(c, u_id, NULL, NULL, false, false, BUN_NONE);
2161 72 : if (!cminu) {
2162 0 : BBPunfix(c->batCacheid);
2163 0 : BBPunfix(u_id->batCacheid);
2164 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2165 : }
2166 72 : res = BATproject(cminu, c);
2167 72 : BBPunfix(c->batCacheid);
2168 72 : BBPunfix(cminu->batCacheid);
2169 72 : cminu = NULL;
2170 72 : if (!res) {
2171 0 : BBPunfix(u_id->batCacheid);
2172 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2173 : }
2174 72 : c = res;
2175 :
2176 72 : if ((u_val = BATdescriptor(*uval)) == NULL) {
2177 0 : BBPunfix(c->batCacheid);
2178 0 : BBPunfix(u_id->batCacheid);
2179 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2180 : }
2181 72 : if (BATcount(u_val)) {
2182 68 : u = BATproject(u_val, u_id);
2183 68 : BBPunfix(u_val->batCacheid);
2184 68 : BBPunfix(u_id->batCacheid);
2185 68 : if (!u) {
2186 0 : BBPunfix(c->batCacheid);
2187 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2188 : }
2189 :
2190 : /* check selected updated values against candidates */
2191 68 : BAT *c_ids = BATdescriptor(*cid);
2192 :
2193 68 : if (!c_ids) {
2194 0 : BBPunfix(c->batCacheid);
2195 0 : BBPunfix(u->batCacheid);
2196 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2197 : }
2198 68 : cminu = BATintersect(u, c_ids, NULL, NULL, false, false, BUN_NONE);
2199 68 : BBPunfix(c_ids->batCacheid);
2200 68 : if (cminu == NULL) {
2201 0 : BBPunfix(c->batCacheid);
2202 0 : BBPunfix(u->batCacheid);
2203 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2204 : }
2205 68 : BAT *nres;
2206 68 : if ((nres = COLcopy(res, res->ttype, true, TRANSIENT)) == NULL) {
2207 0 : BBPunfix(res->batCacheid);
2208 0 : BBPunfix(u->batCacheid);
2209 0 : BBPunfix(cminu->batCacheid);
2210 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2211 : }
2212 68 : BBPunfix(res->batCacheid);
2213 68 : res = nres;
2214 68 : ret = BATappend(res, u, cminu, true);
2215 68 : BBPunfix(u->batCacheid);
2216 68 : BBPunfix(cminu->batCacheid);
2217 68 : cminu = NULL;
2218 68 : if (ret != GDK_SUCCEED) {
2219 0 : BBPunfix(res->batCacheid);
2220 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2221 : }
2222 :
2223 68 : ret = BATsort(&u, NULL, NULL, res, NULL, NULL, false, false, false);
2224 68 : BBPunfix(res->batCacheid);
2225 68 : if (ret != GDK_SUCCEED) {
2226 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2227 : }
2228 68 : res = u;
2229 : } else {
2230 4 : BBPunfix(u_val->batCacheid);
2231 4 : BBPunfix(u_id->batCacheid);
2232 : }
2233 : }
2234 :
2235 72 : BATkey(res, true);
2236 72 : *result = res->batCacheid;
2237 72 : BBPkeepref(res);
2238 72 : return MAL_SUCCEED;
2239 : }
2240 :
2241 : str
2242 162506 : DELTAproject(bat *result, const bat *sub, const bat *col, const bat *uid, const bat *uval)
2243 : {
2244 162506 : BAT *s, *c, *u_id, *u_val, *res, *tres;
2245 :
2246 162506 : if ((s = BATdescriptor(*sub)) == NULL)
2247 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2248 :
2249 162510 : if ((c = BATdescriptor(*col)) == NULL) {
2250 0 : BBPunfix(s->batCacheid);
2251 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2252 : }
2253 :
2254 : /* projection(sub,col) */
2255 162490 : res = c;
2256 162490 : tres = BATproject(s, res);
2257 162447 : BBPunfix(res->batCacheid);
2258 :
2259 162447 : if (tres == NULL) {
2260 0 : BBPunfix(s->batCacheid);
2261 0 : throw(MAL, "sql.projectdelta", GDK_EXCEPTION);
2262 : }
2263 162447 : res = tres;
2264 :
2265 162447 : if ((u_id = BATdescriptor(*uid)) == NULL) {
2266 0 : BBPunfix(res->batCacheid);
2267 0 : BBPunfix(s->batCacheid);
2268 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2269 : }
2270 162510 : if (!BATcount(u_id)) {
2271 162495 : BBPunfix(u_id->batCacheid);
2272 162486 : BBPunfix(s->batCacheid);
2273 162493 : *result = res->batCacheid;
2274 162493 : BBPkeepref(res);
2275 162493 : return MAL_SUCCEED;
2276 : }
2277 15 : if ((u_val = BATdescriptor(*uval)) == NULL) {
2278 0 : BBPunfix(u_id->batCacheid);
2279 0 : BBPunfix(res->batCacheid);
2280 0 : BBPunfix(s->batCacheid);
2281 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2282 : }
2283 :
2284 15 : if (BATcount(u_val)) {
2285 15 : BAT *os, *ou;
2286 : /* figure out the positions in res that we have to
2287 : * replace with values from u_val */
2288 15 : if (BATsemijoin(&ou, &os, u_id, s, NULL, NULL, false, false, BUN_NONE) != GDK_SUCCEED) {
2289 0 : BBPunfix(s->batCacheid);
2290 0 : BBPunfix(res->batCacheid);
2291 0 : BBPunfix(u_id->batCacheid);
2292 0 : BBPunfix(u_val->batCacheid);
2293 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2294 : }
2295 : /* BATcount(ou) == BATcount(os) */
2296 15 : if (BATcount(ou) != 0) {
2297 : /* ou contains the position in u_id/u_val that
2298 : * contain the new values */
2299 13 : BAT *nu_val = BATproject(ou, u_val);
2300 13 : BBPunfix(ou->batCacheid);
2301 : /* os contains the corresponding positions in
2302 : * res that need to be replaced with those new
2303 : * values */
2304 26 : if (!nu_val || (res = setwritable(res)) == NULL ||
2305 13 : BATreplace(res, os, nu_val, false) != GDK_SUCCEED) {
2306 0 : BBPreclaim(res);
2307 0 : BBPunfix(os->batCacheid);
2308 0 : BBPunfix(s->batCacheid);
2309 0 : BBPunfix(u_id->batCacheid);
2310 0 : BBPunfix(u_val->batCacheid);
2311 0 : BBPreclaim(nu_val);
2312 0 : throw(MAL, "sql.delta", GDK_EXCEPTION);
2313 : }
2314 13 : BBPunfix(nu_val->batCacheid);
2315 : } else {
2316 : /* nothing to replace */
2317 2 : BBPunfix(ou->batCacheid);
2318 : }
2319 15 : BBPunfix(os->batCacheid);
2320 : }
2321 15 : BBPunfix(s->batCacheid);
2322 15 : BBPunfix(u_id->batCacheid);
2323 15 : BBPunfix(u_val->batCacheid);
2324 :
2325 15 : *result = res->batCacheid;
2326 15 : BBPkeepref(res);
2327 15 : return MAL_SUCCEED;
2328 : }
2329 :
2330 : str
2331 26 : BATleftproject(bat *Res, const bat *Col, const bat *L, const bat *R)
2332 : {
2333 26 : BAT *c, *l, *r, *res;
2334 26 : oid *p, *lp, *rp;
2335 26 : BUN cnt = 0, i;
2336 26 : BATiter li, ri;
2337 :
2338 26 : c = BATdescriptor(*Col);
2339 26 : if (c)
2340 26 : cnt = BATcount(c);
2341 26 : l = BATdescriptor(*L);
2342 26 : r = BATdescriptor(*R);
2343 26 : res = COLnew(0, TYPE_oid, cnt, TRANSIENT);
2344 26 : if (!c || !l || !r || !res) {
2345 0 : BBPreclaim(c);
2346 0 : BBPreclaim(l);
2347 0 : BBPreclaim(r);
2348 0 : BBPreclaim(res);
2349 0 : throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2350 : }
2351 26 : p = (oid*)Tloc(res,0);
2352 51 : for(i=0;i<cnt; i++)
2353 25 : *p++ = oid_nil;
2354 26 : BATsetcount(res, cnt);
2355 :
2356 26 : cnt = BATcount(l);
2357 26 : p = (oid*)Tloc(res, 0);
2358 26 : li = bat_iterator(l);
2359 26 : ri = bat_iterator(r);
2360 26 : lp = (oid*)li.base;
2361 26 : rp = (oid*)ri.base;
2362 26 : if (l->ttype == TYPE_void) {
2363 11 : oid lp = l->tseqbase;
2364 11 : if (r->ttype == TYPE_void) {
2365 11 : oid rp = r->tseqbase;
2366 11 : for(i=0;i<cnt; i++, lp++, rp++)
2367 0 : p[lp] = rp;
2368 : } else {
2369 0 : for(i=0;i<cnt; i++, lp++)
2370 0 : p[lp] = rp[i];
2371 : }
2372 : }
2373 26 : if (r->ttype == TYPE_void) {
2374 23 : oid rp = r->tseqbase;
2375 35 : for(i=0;i<cnt; i++, rp++)
2376 12 : p[lp[i]] = rp;
2377 : } else {
2378 9 : for(i=0;i<cnt; i++)
2379 6 : p[lp[i]] = rp[i];
2380 : }
2381 26 : bat_iterator_end(&li);
2382 26 : bat_iterator_end(&ri);
2383 26 : res->tsorted = false;
2384 26 : res->trevsorted = false;
2385 26 : res->tnil = false;
2386 26 : res->tnonil = false;
2387 26 : res->tkey = false;
2388 26 : BBPunfix(c->batCacheid);
2389 26 : BBPunfix(l->batCacheid);
2390 26 : BBPunfix(r->batCacheid);
2391 26 : *Res = res->batCacheid;
2392 26 : BBPkeepref(res);
2393 26 : return MAL_SUCCEED;
2394 : }
2395 :
2396 : /* str SQLtid(bat *result, mvc *m, str *sname, str *tname) */
2397 : str
2398 276748 : SQLtid(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2399 : {
2400 276748 : bat *res = getArgReference_bat(stk, pci, 0);
2401 276748 : mvc *m = NULL;
2402 276748 : str msg = MAL_SUCCEED;
2403 276748 : sql_trans *tr;
2404 276748 : const char *sname = *getArgReference_str(stk, pci, 2);
2405 276748 : const char *tname = *getArgReference_str(stk, pci, 3);
2406 276748 : sql_schema *s;
2407 276748 : sql_table *t;
2408 :
2409 276748 : *res = bat_nil;
2410 276748 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
2411 : return msg;
2412 276744 : tr = m->session->tr;
2413 276744 : if ((msg = checkSQLContext(cntxt)) != NULL)
2414 : return msg;
2415 276744 : s = mvc_bind_schema(m, sname);
2416 276748 : if (s == NULL)
2417 0 : throw(SQL, "sql.tid", SQLSTATE(3F000) "Schema missing %s",sname);
2418 276748 : t = mvc_bind_table(m, s, tname);
2419 276746 : if (t == NULL)
2420 0 : throw(SQL, "sql.tid", SQLSTATE(42S02) "Table missing %s.%s",sname,tname);
2421 276746 : if (!isTable(t))
2422 0 : throw(SQL, "sql.tid", SQLSTATE(42000) "%s '%s' is not persistent",
2423 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
2424 :
2425 276746 : sqlstore *store = m->store;
2426 : /* we have full table count, nr of deleted (unused rows) */
2427 276746 : int part_nr = 0;
2428 276746 : int nr_parts = 1;
2429 276746 : if (pci->argc == 6) { /* partitioned version */
2430 179647 : part_nr = *getArgReference_int(stk, pci, 4);
2431 179647 : nr_parts = *getArgReference_int(stk, pci, 5);
2432 : }
2433 276746 : BAT *b = store->storage_api.bind_cands(tr, t, nr_parts, part_nr);
2434 276749 : if (b) {
2435 276749 : *res = b->batCacheid;
2436 276749 : BBPkeepref(b);
2437 : } else {
2438 0 : msg = createException(SQL, "sql.tid", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2439 : }
2440 : return msg;
2441 : }
2442 :
2443 : /* unsafe pattern resultSet(tbl:bat[:str], attr:bat[:str], tpe:bat[:str], len:bat[:int],scale:bat[:int], cols:bat[:any]...) :int */
2444 : /* New result set rendering infrastructure */
2445 :
2446 : static str
2447 63648 : mvc_result_set_wrap( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2448 : {
2449 63648 : int *res_id =getArgReference_int(stk,pci,0);
2450 63648 : bat tblId= *getArgReference_bat(stk, pci,1);
2451 63648 : bat atrId= *getArgReference_bat(stk, pci,2);
2452 63648 : bat tpeId= *getArgReference_bat(stk, pci,3);
2453 63648 : bat lenId= *getArgReference_bat(stk, pci,4);
2454 63648 : bat scaleId= *getArgReference_bat(stk, pci,5);
2455 63648 : bat bid;
2456 63648 : int i, res, ok;
2457 63648 : const char *tblname, *colname, *tpename;
2458 63648 : str msg= MAL_SUCCEED;
2459 63648 : int *digits, *scaledigits;
2460 63648 : oid o = 0;
2461 63648 : BATiter itertbl,iteratr,itertpe,iterdig,iterscl;
2462 63648 : backend *be = NULL;
2463 63648 : BAT *b = NULL, *tbl = NULL, *atr = NULL, *tpe = NULL,*len = NULL,*scale = NULL;
2464 :
2465 63648 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
2466 : return msg;
2467 63648 : bid = *getArgReference_bat(stk,pci,6);
2468 63648 : b = BATdescriptor(bid);
2469 63648 : if ( b == NULL) {
2470 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2471 0 : goto wrapup_result_set;
2472 : }
2473 63648 : res = *res_id = mvc_result_table(be, mb->tag, pci->argc - (pci->retc + 5), Q_TABLE);
2474 63647 : BBPunfix(b->batCacheid);
2475 63648 : if (res < 0) {
2476 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2477 0 : goto wrapup_result_set;
2478 : }
2479 :
2480 63648 : tbl = BATdescriptor(tblId);
2481 63648 : atr = BATdescriptor(atrId);
2482 63648 : tpe = BATdescriptor(tpeId);
2483 63648 : len = BATdescriptor(lenId);
2484 63648 : scale = BATdescriptor(scaleId);
2485 63648 : if (tbl == NULL || atr == NULL || tpe == NULL || len == NULL || scale == NULL)
2486 0 : goto wrapup_result_set;
2487 : /* mimic the old rsColumn approach; */
2488 63648 : itertbl = bat_iterator(tbl);
2489 63648 : iteratr = bat_iterator(atr);
2490 63648 : itertpe = bat_iterator(tpe);
2491 63648 : iterdig = bat_iterator(len);
2492 63648 : iterscl = bat_iterator(scale);
2493 63648 : digits = (int*) iterdig.base;
2494 63648 : scaledigits = (int*) iterscl.base;
2495 :
2496 337821 : for( i = 6; msg == MAL_SUCCEED && i< pci->argc; i++, o++){
2497 274173 : bid = *getArgReference_bat(stk,pci,i);
2498 274173 : tblname = BUNtvar(itertbl,o);
2499 274171 : colname = BUNtvar(iteratr,o);
2500 274161 : tpename = BUNtvar(itertpe,o);
2501 274162 : b = BATdescriptor(bid);
2502 274161 : if ( b == NULL)
2503 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2504 274161 : else if (mvc_result_column(be, tblname, colname, tpename, *digits++, *scaledigits++, b))
2505 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(42000) "Cannot access column descriptor %s.%s",tblname,colname);
2506 274170 : if( b)
2507 274170 : BBPunfix(bid);
2508 : }
2509 63648 : bat_iterator_end(&itertbl);
2510 63648 : bat_iterator_end(&iteratr);
2511 63648 : bat_iterator_end(&itertpe);
2512 63648 : bat_iterator_end(&iterdig);
2513 63648 : bat_iterator_end(&iterscl);
2514 : /* now send it to the channel cntxt->fdout */
2515 63648 : if (bstream_getoob(cntxt->fdin))
2516 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY000) "Query aboted");
2517 63648 : else if (!msg && (ok = mvc_export_result(be, cntxt->fdout, res, true, cntxt->qryctx.starttime, mb->optimize)) < 0)
2518 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(be, cntxt->fdout, ok));
2519 63648 : wrapup_result_set:
2520 63648 : cntxt->qryctx.starttime = 0;
2521 63648 : cntxt->qryctx.endtime = 0;
2522 63648 : mb->optimize = 0;
2523 63648 : if( tbl) BBPunfix(tblId);
2524 63647 : if( atr) BBPunfix(atrId);
2525 63648 : if( tpe) BBPunfix(tpeId);
2526 63648 : if( len) BBPunfix(lenId);
2527 63648 : if( scale) BBPunfix(scaleId);
2528 : return msg;
2529 : }
2530 :
2531 : /* Copy the result set into a CSV file */
2532 : str
2533 31 : mvc_export_table_wrap( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2534 : {
2535 31 : int *res_id =getArgReference_int(stk,pci,0);
2536 31 : const char *filename = *getArgReference_str(stk,pci,1);
2537 31 : const char *format = *getArgReference_str(stk,pci,2);
2538 31 : const char *tsep = *getArgReference_str(stk, pci, 3);
2539 31 : const char *rsep = *getArgReference_str(stk, pci, 4);
2540 31 : const char *ssep = *getArgReference_str(stk, pci, 5);
2541 31 : const char *ns = *getArgReference_str(stk, pci, 6);
2542 31 : int onclient = *getArgReference_int(stk, pci, 7);
2543 :
2544 31 : bat tblId= *getArgReference_bat(stk, pci,8);
2545 31 : bat atrId= *getArgReference_bat(stk, pci,9);
2546 31 : bat tpeId= *getArgReference_bat(stk, pci,10);
2547 31 : bat lenId= *getArgReference_bat(stk, pci,11);
2548 31 : bat scaleId= *getArgReference_bat(stk, pci,12);
2549 31 : stream *s = NULL;
2550 31 : bat bid;
2551 31 : int i, res, ok;
2552 31 : const char *tblname, *colname, *tpename;
2553 31 : str msg= MAL_SUCCEED;
2554 31 : int *digits, *scaledigits;
2555 31 : oid o = 0;
2556 31 : BATiter itertbl,iteratr,itertpe,iterdig,iterscl;
2557 31 : backend *be;
2558 31 : mvc *m = NULL;
2559 31 : BAT *b = NULL, *tbl = NULL, *atr = NULL, *tpe = NULL,*len = NULL,*scale = NULL;
2560 31 : res_table *t = NULL;
2561 31 : bool tostdout;
2562 31 : char buf[80];
2563 31 : ssize_t sz;
2564 :
2565 31 : (void) format;
2566 :
2567 31 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
2568 : return msg;
2569 31 : m = be->mvc;
2570 :
2571 31 : if (onclient && !cntxt->filetrans) {
2572 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(42000) "Cannot transfer files to client");
2573 0 : goto wrapup_result_set1;
2574 : }
2575 :
2576 31 : bid = *getArgReference_bat(stk,pci,13);
2577 31 : res = *res_id = mvc_result_table(be, mb->tag, pci->argc - (pci->retc + 12), Q_TABLE);
2578 31 : t = be->results;
2579 31 : if (res < 0) {
2580 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2581 0 : goto wrapup_result_set1;
2582 : }
2583 :
2584 31 : t->tsep = tsep;
2585 31 : t->rsep = rsep;
2586 31 : t->ssep = ssep;
2587 31 : t->ns = ns;
2588 :
2589 31 : tbl = BATdescriptor(tblId);
2590 31 : atr = BATdescriptor(atrId);
2591 31 : tpe = BATdescriptor(tpeId);
2592 31 : len = BATdescriptor(lenId);
2593 31 : scale = BATdescriptor(scaleId);
2594 31 : if( tbl == NULL || atr == NULL || tpe == NULL || len == NULL || scale == NULL)
2595 0 : goto wrapup_result_set1;
2596 : /* mimic the old rsColumn approach; */
2597 31 : itertbl = bat_iterator(tbl);
2598 31 : iteratr = bat_iterator(atr);
2599 31 : itertpe = bat_iterator(tpe);
2600 31 : iterdig = bat_iterator(len);
2601 31 : iterscl = bat_iterator(scale);
2602 31 : digits = (int*) iterdig.base;
2603 31 : scaledigits = (int*) iterscl.base;
2604 :
2605 170 : for( i = 13; msg == MAL_SUCCEED && i< pci->argc; i++, o++){
2606 139 : bid = *getArgReference_bat(stk,pci,i);
2607 139 : tblname = BUNtvar(itertbl,o);
2608 139 : colname = BUNtvar(iteratr,o);
2609 139 : tpename = BUNtvar(itertpe,o);
2610 139 : b = BATdescriptor(bid);
2611 139 : if ( b == NULL)
2612 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
2613 139 : else if (mvc_result_column(be, tblname, colname, tpename, *digits++, *scaledigits++, b))
2614 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(42000) "Cannot access column descriptor %s.%s",tblname,colname);
2615 139 : if( b)
2616 139 : BBPunfix(bid);
2617 : }
2618 31 : bat_iterator_end(&itertbl);
2619 31 : bat_iterator_end(&iteratr);
2620 31 : bat_iterator_end(&itertpe);
2621 31 : bat_iterator_end(&iterdig);
2622 31 : bat_iterator_end(&iterscl);
2623 31 : if ( msg )
2624 0 : goto wrapup_result_set1;
2625 :
2626 : /* now select the file channel */
2627 31 : if ((tostdout = strcmp(filename,"stdout") == 0)) {
2628 8 : s = cntxt->fdout;
2629 23 : } else if (!onclient) {
2630 4 : if ((s = open_wastream(filename)) == NULL || mnstr_errnr(s) != MNSTR_NO__ERROR) {
2631 0 : msg= createException(IO, "streams.open", SQLSTATE(42000) "%s", mnstr_peek_error(NULL));
2632 0 : close_stream(s);
2633 0 : goto wrapup_result_set1;
2634 : }
2635 4 : be->output_format = OFMT_CSV;
2636 : } else {
2637 19 : while (!m->scanner.rs->eof) {
2638 0 : if (bstream_next(m->scanner.rs) < 0) {
2639 0 : msg = createException(IO, "streams.open", "interrupted");
2640 0 : goto wrapup_result_set1;
2641 : }
2642 : }
2643 19 : s = m->scanner.ws;
2644 19 : mnstr_write(s, PROMPT3, sizeof(PROMPT3) - 1, 1);
2645 19 : mnstr_printf(s, "w %s\n", filename);
2646 19 : mnstr_flush(s, MNSTR_FLUSH_DATA);
2647 19 : if ((sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf))) > 1) {
2648 : /* non-empty line indicates failure on client */
2649 7 : msg = createException(IO, "streams.open", "%s", buf);
2650 : /* discard until client flushes */
2651 15 : while (mnstr_read(m->scanner.rs->s, buf, 1, sizeof(buf)) > 0) {
2652 : /* ignore remainder of error message */
2653 8 : }
2654 7 : goto wrapup_result_set1;
2655 : }
2656 : }
2657 24 : if ((ok = mvc_export_result(cntxt->sqlcontext, s, res, tostdout, cntxt->qryctx.starttime, mb->optimize)) < 0) {
2658 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(cntxt->sqlcontext, s, ok));
2659 0 : if (!onclient && !tostdout)
2660 0 : close_stream(s);
2661 0 : if (ok != -5)
2662 0 : goto wrapup_result_set1;
2663 : }
2664 24 : if (onclient) {
2665 12 : mnstr_flush(s, MNSTR_FLUSH_DATA);
2666 12 : if ((sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf))) > 1) {
2667 0 : msg = createException(IO, "streams.open", "%s", buf);
2668 : }
2669 24 : while (sz > 0)
2670 12 : sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf));
2671 12 : } else if (!tostdout) {
2672 4 : close_stream(s);
2673 : }
2674 8 : wrapup_result_set1:
2675 31 : cntxt->qryctx.starttime = 0;
2676 31 : cntxt->qryctx.endtime = 0;
2677 31 : mb->optimize = 0;
2678 31 : if( tbl) BBPunfix(tblId);
2679 31 : if( atr) BBPunfix(atrId);
2680 31 : if( tpe) BBPunfix(tpeId);
2681 31 : if( len) BBPunfix(lenId);
2682 31 : if( scale) BBPunfix(scaleId);
2683 : return msg;
2684 : }
2685 :
2686 : /* unsafe pattern resultSet(tbl:bat[:str], attr:bat[:str], tpe:bat[:str], len:bat[:int],scale:bat[:int], cols:any...) :int */
2687 : str
2688 412 : mvc_row_result_wrap( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2689 : {
2690 412 : int *res_id= getArgReference_int(stk, pci,0);
2691 412 : bat tblId= *getArgReference_bat(stk, pci,1);
2692 412 : bat atrId= *getArgReference_bat(stk, pci,2);
2693 412 : bat tpeId= *getArgReference_bat(stk, pci,3);
2694 412 : bat lenId= *getArgReference_bat(stk, pci,4);
2695 412 : bat scaleId= *getArgReference_bat(stk, pci,5);
2696 412 : int i, res, ok;
2697 412 : const char *tblname, *colname, *tpename;
2698 412 : str msg= MAL_SUCCEED;
2699 412 : int *digits, *scaledigits;
2700 412 : oid o = 0;
2701 412 : BATiter itertbl,iteratr,itertpe,iterdig,iterscl;
2702 412 : backend *be = NULL;
2703 412 : ptr v;
2704 412 : int mtype;
2705 412 : BAT *tbl = NULL, *atr = NULL, *tpe = NULL, *len = NULL, *scale = NULL;
2706 :
2707 412 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
2708 : return msg;
2709 412 : res = *res_id = mvc_result_table(be, mb->tag, pci->argc - (pci->retc + 5), Q_TABLE);
2710 412 : if (res < 0) {
2711 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2712 0 : goto wrapup_result_set;
2713 : }
2714 :
2715 412 : tbl = BATdescriptor(tblId);
2716 412 : atr = BATdescriptor(atrId);
2717 412 : tpe = BATdescriptor(tpeId);
2718 412 : len = BATdescriptor(lenId);
2719 412 : scale = BATdescriptor(scaleId);
2720 412 : if( tbl == NULL || atr == NULL || tpe == NULL || len == NULL || scale == NULL)
2721 0 : goto wrapup_result_set;
2722 : /* mimic the old rsColumn approach; */
2723 412 : itertbl = bat_iterator(tbl);
2724 412 : iteratr = bat_iterator(atr);
2725 412 : itertpe = bat_iterator(tpe);
2726 412 : iterdig = bat_iterator(len);
2727 412 : iterscl = bat_iterator(scale);
2728 412 : digits = (int*) iterdig.base;
2729 412 : scaledigits = (int*) iterscl.base;
2730 :
2731 1514 : for( i = 6; msg == MAL_SUCCEED && i< pci->argc; i++, o++){
2732 1102 : tblname = BUNtvar(itertbl,o);
2733 1102 : colname = BUNtvar(iteratr,o);
2734 1102 : tpename = BUNtvar(itertpe,o);
2735 :
2736 1102 : v = getArgReference(stk, pci, i);
2737 1102 : mtype = getArgType(mb, pci, i);
2738 1102 : if (ATOMextern(mtype))
2739 181 : v = *(ptr *) v;
2740 1102 : if ((ok = mvc_result_value(be, tblname, colname, tpename, *digits++, *scaledigits++, v, mtype) < 0)) {
2741 0 : msg = createException(SQL, "sql.rsColumn", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(be, be->out, ok));
2742 0 : bat_iterator_end(&itertbl);
2743 0 : bat_iterator_end(&iteratr);
2744 0 : bat_iterator_end(&itertpe);
2745 0 : bat_iterator_end(&iterdig);
2746 0 : bat_iterator_end(&iterscl);
2747 0 : goto wrapup_result_set;
2748 : }
2749 : }
2750 412 : bat_iterator_end(&itertbl);
2751 412 : bat_iterator_end(&iteratr);
2752 412 : bat_iterator_end(&itertpe);
2753 412 : bat_iterator_end(&iterdig);
2754 412 : bat_iterator_end(&iterscl);
2755 412 : if (!msg && (ok = mvc_export_result(cntxt->sqlcontext, cntxt->fdout, res, true, cntxt->qryctx.starttime, mb->optimize)) < 0)
2756 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(cntxt->sqlcontext, cntxt->fdout, ok));
2757 412 : wrapup_result_set:
2758 412 : cntxt->qryctx.starttime = 0;
2759 412 : cntxt->qryctx.endtime = 0;
2760 412 : mb->optimize = 0;
2761 412 : if( tbl) BBPunfix(tblId);
2762 412 : if( atr) BBPunfix(atrId);
2763 412 : if( tpe) BBPunfix(tpeId);
2764 412 : if( len) BBPunfix(lenId);
2765 412 : if( scale) BBPunfix(scaleId);
2766 : return msg;
2767 : }
2768 :
2769 : str
2770 1 : mvc_export_row_wrap( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2771 : {
2772 1 : int *res_id= getArgReference_int(stk, pci,0);
2773 1 : str filename = * getArgReference_str(stk,pci,1);
2774 1 : const char *format = *getArgReference_str(stk,pci,2);
2775 1 : const char *tsep = *getArgReference_str(stk, pci, 3);
2776 1 : const char *rsep = *getArgReference_str(stk, pci, 4);
2777 1 : const char *ssep = *getArgReference_str(stk, pci, 5);
2778 1 : const char *ns = *getArgReference_str(stk, pci, 6);
2779 1 : int onclient = *getArgReference_int(stk, pci, 7);
2780 :
2781 1 : bat tblId= *getArgReference_bat(stk, pci,8);
2782 1 : bat atrId= *getArgReference_bat(stk, pci,9);
2783 1 : bat tpeId= *getArgReference_bat(stk, pci,10);
2784 1 : bat lenId= *getArgReference_bat(stk, pci,11);
2785 1 : bat scaleId= *getArgReference_bat(stk, pci,12);
2786 :
2787 1 : int i, res, ok;
2788 1 : stream *s = NULL;
2789 1 : const char *tblname, *colname, *tpename;
2790 1 : str msg = MAL_SUCCEED;
2791 1 : int *digits, *scaledigits;
2792 1 : oid o = 0;
2793 1 : BATiter itertbl,iteratr,itertpe,iterdig,iterscl;
2794 1 : backend *be;
2795 1 : mvc *m = NULL;
2796 1 : res_table *t = NULL;
2797 1 : ptr v;
2798 1 : int mtype;
2799 1 : BAT *tbl = NULL, *atr = NULL, *tpe = NULL,*len = NULL,*scale = NULL;
2800 1 : bool tostdout;
2801 1 : char buf[80];
2802 1 : ssize_t sz;
2803 :
2804 1 : (void) format;
2805 1 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
2806 : return msg;
2807 1 : m = be->mvc;
2808 1 : if (onclient && !cntxt->filetrans) {
2809 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(42000) "Cannot transfer files to client");
2810 0 : goto wrapup_result_set;
2811 : }
2812 :
2813 1 : res = *res_id = mvc_result_table(be, mb->tag, pci->argc - (pci->retc + 12), Q_TABLE);
2814 :
2815 1 : t = be->results;
2816 1 : if (res < 0){
2817 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2818 0 : goto wrapup_result_set;
2819 : }
2820 :
2821 1 : t->tsep = tsep;
2822 1 : t->rsep = rsep;
2823 1 : t->ssep = ssep;
2824 1 : t->ns = ns;
2825 :
2826 1 : tbl = BATdescriptor(tblId);
2827 1 : atr = BATdescriptor(atrId);
2828 1 : tpe = BATdescriptor(tpeId);
2829 1 : len = BATdescriptor(lenId);
2830 1 : scale = BATdescriptor(scaleId);
2831 1 : if (tbl == NULL || atr == NULL || tpe == NULL || len == NULL || scale == NULL)
2832 0 : goto wrapup_result_set;
2833 : /* mimic the old rsColumn approach; */
2834 1 : itertbl = bat_iterator(tbl);
2835 1 : iteratr = bat_iterator(atr);
2836 1 : itertpe = bat_iterator(tpe);
2837 1 : iterdig = bat_iterator(len);
2838 1 : iterscl = bat_iterator(scale);
2839 1 : digits = (int*) iterdig.base;
2840 1 : scaledigits = (int*) iterscl.base;
2841 :
2842 2 : for( i = 13; msg == MAL_SUCCEED && i< pci->argc; i++, o++){
2843 1 : tblname = BUNtvar(itertbl,o);
2844 1 : colname = BUNtvar(iteratr,o);
2845 1 : tpename = BUNtvar(itertpe,o);
2846 :
2847 1 : v = getArgReference(stk, pci, i);
2848 1 : mtype = getArgType(mb, pci, i);
2849 1 : if (ATOMextern(mtype))
2850 0 : v = *(ptr *) v;
2851 1 : if ((ok = mvc_result_value(be, tblname, colname, tpename, *digits++, *scaledigits++, v, mtype)) < 0) {
2852 0 : msg = createException(SQL, "sql.rsColumn", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(be, s, ok));
2853 0 : bat_iterator_end(&itertbl);
2854 0 : bat_iterator_end(&iteratr);
2855 0 : bat_iterator_end(&itertpe);
2856 0 : bat_iterator_end(&iterdig);
2857 0 : bat_iterator_end(&iterscl);
2858 0 : goto wrapup_result_set;
2859 : }
2860 : }
2861 1 : bat_iterator_end(&itertbl);
2862 1 : bat_iterator_end(&iteratr);
2863 1 : bat_iterator_end(&itertpe);
2864 1 : bat_iterator_end(&iterdig);
2865 1 : bat_iterator_end(&iterscl);
2866 : /* now select the file channel */
2867 1 : if ((tostdout = strcmp(filename,"stdout") == 0)) {
2868 1 : s = cntxt->fdout;
2869 0 : } else if (!onclient) {
2870 0 : if ((s = open_wastream(filename)) == NULL || mnstr_errnr(s) != MNSTR_NO__ERROR) {
2871 0 : msg= createException(IO, "streams.open", SQLSTATE(42000) "%s", mnstr_peek_error(NULL));
2872 0 : close_stream(s);
2873 0 : goto wrapup_result_set;
2874 : }
2875 : } else {
2876 0 : while (!m->scanner.rs->eof) {
2877 0 : if (bstream_next(m->scanner.rs) < 0) {
2878 0 : msg = createException(IO, "streams.open", "interrupted");
2879 0 : goto wrapup_result_set;
2880 : }
2881 : }
2882 0 : s = m->scanner.ws;
2883 0 : mnstr_write(s, PROMPT3, sizeof(PROMPT3) - 1, 1);
2884 0 : mnstr_printf(s, "w %s\n", filename);
2885 0 : mnstr_flush(s, MNSTR_FLUSH_DATA);
2886 0 : if ((sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf))) > 1) {
2887 : /* non-empty line indicates failure on client */
2888 0 : msg = createException(IO, "streams.open", "%s", buf);
2889 : /* discard until client flushes */
2890 0 : while (mnstr_read(m->scanner.rs->s, buf, 1, sizeof(buf)) > 0) {
2891 : /* ignore remainder of error message */
2892 0 : }
2893 0 : goto wrapup_result_set;
2894 : }
2895 : }
2896 1 : if ((ok = mvc_export_result(cntxt->sqlcontext, s, res, strcmp(filename, "stdout") == 0, cntxt->qryctx.starttime, mb->optimize)) < 0) {
2897 0 : msg = createException(SQL, "sql.resultSet", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(cntxt->sqlcontext, s, ok));
2898 0 : if (!onclient && !tostdout)
2899 0 : close_stream(s);
2900 0 : goto wrapup_result_set;
2901 : }
2902 1 : if (onclient) {
2903 0 : mnstr_flush(s, MNSTR_FLUSH_DATA);
2904 0 : if ((sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf))) > 1) {
2905 0 : msg = createException(IO, "streams.open", "%s", buf);
2906 : }
2907 0 : while (sz > 0)
2908 0 : sz = mnstr_readline(m->scanner.rs->s, buf, sizeof(buf));
2909 1 : } else if (!tostdout) {
2910 0 : close_stream(s);
2911 : }
2912 1 : wrapup_result_set:
2913 1 : cntxt->qryctx.starttime = 0;
2914 1 : cntxt->qryctx.endtime = 0;
2915 1 : mb->optimize = 0;
2916 1 : if( tbl) BBPunfix(tblId);
2917 1 : if( atr) BBPunfix(atrId);
2918 1 : if( tpe) BBPunfix(tpeId);
2919 1 : if( len) BBPunfix(lenId);
2920 1 : if( scale) BBPunfix(scaleId);
2921 : return msg;
2922 : }
2923 :
2924 : str
2925 63648 : mvc_table_result_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2926 : {
2927 63648 : str res = MAL_SUCCEED;
2928 63648 : backend *be = NULL;
2929 63648 : str msg;
2930 63648 : int *res_id;
2931 63648 : int nr_cols;
2932 63648 : mapi_query_t qtype;
2933 :
2934 63648 : if ( pci->argc > 6)
2935 63648 : return mvc_result_set_wrap(cntxt,mb,stk,pci);
2936 :
2937 0 : assert(0);
2938 : res_id = getArgReference_int(stk, pci, 0);
2939 : nr_cols = *getArgReference_int(stk, pci, 1);
2940 : qtype = (mapi_query_t) *getArgReference_int(stk, pci, 2);
2941 : bat order_bid = *getArgReference_bat(stk, pci, 3);
2942 : (void)order_bid;
2943 : /* TODO remove use */
2944 :
2945 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
2946 : return msg;
2947 : *res_id = mvc_result_table(be, mb->tag, nr_cols, qtype);
2948 : if (*res_id < 0)
2949 : res = createException(SQL, "sql.resultSet", SQLSTATE(HY013) MAL_MALLOC_FAIL);
2950 : return res;
2951 : }
2952 :
2953 : /* str mvc_affected_rows_wrap(int *m, int m, lng *nr, str *w); */
2954 : str
2955 127630 : mvc_affected_rows_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2956 : {
2957 127630 : backend *b = NULL;
2958 127630 : int *res = getArgReference_int(stk, pci, 0), ok;
2959 : #ifndef NDEBUG
2960 127630 : int mtype = getArgType(mb, pci, 2);
2961 : #endif
2962 127630 : lng nr;
2963 127630 : str msg;
2964 :
2965 127630 : (void) mb; /* NOT USED */
2966 127630 : if ((msg = checkSQLContext(cntxt)) != NULL)
2967 : return msg;
2968 127629 : *res = 0;
2969 127629 : assert(mtype == TYPE_lng);
2970 127629 : nr = *getArgReference_lng(stk, pci, 2);
2971 127629 : b = cntxt->sqlcontext;
2972 127629 : ok = mvc_export_affrows(b, b->out, nr, "", mb->tag, cntxt->qryctx.starttime, mb->optimize);
2973 127627 : cntxt->qryctx.starttime = 0;
2974 127627 : cntxt->qryctx.endtime = 0;
2975 127627 : mb->optimize = 0;
2976 127627 : if (ok < 0)
2977 0 : throw(SQL, "sql.affectedRows", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(b, b->out, ok));
2978 : return MAL_SUCCEED;
2979 : }
2980 :
2981 : /* str mvc_export_head_wrap(int *ret, stream **s, int *res_id); */
2982 : str
2983 0 : mvc_export_head_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
2984 : {
2985 0 : backend *b = NULL;
2986 0 : stream **s = (stream **) getArgReference(stk, pci, 1);
2987 0 : int res_id = *getArgReference_int(stk, pci, 2), ok;
2988 0 : str msg;
2989 :
2990 0 : (void) mb; /* NOT USED */
2991 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
2992 : return msg;
2993 0 : b = cntxt->sqlcontext;
2994 0 : ok = mvc_export_head(b, *s, res_id, FALSE, TRUE, cntxt->qryctx.starttime, mb->optimize);
2995 0 : cntxt->qryctx.starttime = 0;
2996 0 : cntxt->qryctx.endtime = 0;
2997 0 : mb->optimize = 0;
2998 0 : if (ok < 0)
2999 0 : throw(SQL, "sql.exportHead", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(b, *s, ok));
3000 : return MAL_SUCCEED;
3001 : }
3002 :
3003 : /* str mvc_export_result_wrap(int *ret, stream **s, int *res_id); */
3004 : str
3005 0 : mvc_export_result_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3006 : {
3007 0 : backend *b = NULL;
3008 0 : stream **s = (stream **) getArgReference(stk, pci, 1), *sout;
3009 0 : int res_id = *getArgReference_int(stk, pci, 2), ok;
3010 0 : str msg;
3011 :
3012 0 : (void) mb; /* NOT USED */
3013 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
3014 : return msg;
3015 0 : b = cntxt->sqlcontext;
3016 0 : sout = pci->argc > 5 ? cntxt->fdout : *s;
3017 0 : ok = mvc_export_result(b, sout, res_id, false, cntxt->qryctx.starttime, mb->optimize);
3018 0 : cntxt->qryctx.starttime = 0;
3019 0 : cntxt->qryctx.endtime = 0;
3020 0 : mb->optimize = 0;
3021 0 : if (ok < 0)
3022 0 : throw(SQL, "sql.exportResult", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(b, sout, ok));
3023 : return MAL_SUCCEED;
3024 : }
3025 :
3026 : /* str mvc_export_chunk_wrap(int *ret, stream **s, int *res_id, str *w); */
3027 : str
3028 0 : mvc_export_chunk_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3029 : {
3030 0 : backend *b = NULL;
3031 0 : stream **s = (stream **) getArgReference(stk, pci, 1);
3032 0 : int res_id = *getArgReference_int(stk, pci, 2), ok;
3033 0 : BUN offset = 0;
3034 0 : BUN nr = 0;
3035 0 : str msg;
3036 :
3037 0 : (void) mb; /* NOT USED */
3038 0 : if (pci->argc == 5) {
3039 0 : offset = (BUN) *getArgReference_int(stk, pci, 3);
3040 0 : int cnt = *getArgReference_int(stk, pci, 4);
3041 0 : nr = cnt < 0 ? BUN_NONE : (BUN) cnt;
3042 : }
3043 :
3044 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
3045 : return msg;
3046 0 : b = cntxt->sqlcontext;
3047 0 : if ((ok = mvc_export_chunk(b, *s, res_id, offset, nr)) < 0)
3048 0 : throw(SQL, "sql.exportChunk", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(b, *s, ok));
3049 : return NULL;
3050 : }
3051 :
3052 : /* str mvc_export_operation_wrap(int *ret, str *w); */
3053 : str
3054 19296 : mvc_export_operation_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3055 : {
3056 19296 : backend *b = NULL;
3057 19296 : str msg;
3058 19296 : int ok = 0;
3059 :
3060 19296 : (void) stk; /* NOT USED */
3061 19296 : (void) pci; /* NOT USED */
3062 19296 : if ((msg = checkSQLContext(cntxt)) != NULL)
3063 : return msg;
3064 19296 : b = cntxt->sqlcontext;
3065 19296 : if (b->out)
3066 19295 : ok = mvc_export_operation(b, b->out, "", cntxt->qryctx.starttime, mb->optimize);
3067 19296 : cntxt->qryctx.starttime = 0;
3068 19296 : cntxt->qryctx.endtime = 0;
3069 19296 : mb->optimize = 0;
3070 19296 : if (ok < 0)
3071 0 : throw(SQL, "sql.exportOperation", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(b, b->out, ok));
3072 : return MAL_SUCCEED;
3073 : }
3074 :
3075 : str
3076 : /*mvc_scalar_value_wrap(int *ret, int *qtype, str tn, str name, str type, int *digits, int *scale, int *eclass, ptr p, int mtype)*/
3077 60314 : mvc_scalar_value_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3078 : {
3079 60314 : const char *tn = *getArgReference_str(stk, pci, 1);
3080 60314 : const char *cn = *getArgReference_str(stk, pci, 2);
3081 60314 : const char *type = *getArgReference_str(stk, pci, 3);
3082 60314 : int digits = *getArgReference_int(stk, pci, 4);
3083 60314 : int scale = *getArgReference_int(stk, pci, 5);
3084 60314 : ptr p = getArgReference(stk, pci, 7);
3085 60314 : int mtype = getArgType(mb, pci, 7);
3086 60314 : str msg;
3087 60314 : backend *be = NULL;
3088 60314 : int res_id, ok;
3089 60314 : (void) mb; /* NOT USED */
3090 60314 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
3091 : return msg;
3092 60314 : if (ATOMextern(mtype))
3093 617 : p = *(ptr *) p;
3094 :
3095 : // scalar values are single-column result sets
3096 60314 : if ((res_id = mvc_result_table(be, mb->tag, 1, Q_TABLE)) < 0) {
3097 0 : cntxt->qryctx.starttime = 0;
3098 0 : cntxt->qryctx.endtime = 0;
3099 0 : mb->optimize = 0;
3100 0 : throw(SQL, "sql.exportValue", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3101 : }
3102 60314 : if ((ok = mvc_result_value(be, tn, cn, type, digits, scale, p, mtype)) < 0) {
3103 0 : cntxt->qryctx.starttime = 0;
3104 0 : cntxt->qryctx.endtime = 0;
3105 0 : mb->optimize = 0;
3106 0 : throw(SQL, "sql.exportValue", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(be, be->out, ok));
3107 : }
3108 60314 : if (be->output_format == OFMT_NONE) {
3109 2 : cntxt->qryctx.starttime = 0;
3110 2 : cntxt->qryctx.endtime = 0;
3111 2 : mb->optimize = 0;
3112 2 : return MAL_SUCCEED;
3113 : }
3114 60312 : ok = mvc_export_result(be, be->out, res_id, true, cntxt->qryctx.starttime, mb->optimize);
3115 60312 : cntxt->qryctx.starttime = 0;
3116 60312 : cntxt->qryctx.endtime = 0;
3117 60312 : mb->optimize = 0;
3118 60312 : if (ok < 0)
3119 0 : throw(SQL, "sql.exportValue", SQLSTATE(45000) "Result set construction failed: %s", mvc_export_error(be, be->out, ok));
3120 : return MAL_SUCCEED;
3121 : }
3122 :
3123 : static void
3124 1095 : bat2return(MalStkPtr stk, InstrPtr pci, BAT **b)
3125 : {
3126 1095 : int i;
3127 :
3128 11338 : for (i = 0; i < pci->retc; i++) {
3129 10243 : *getArgReference_bat(stk, pci, i) = b[i]->batCacheid;
3130 10243 : BBPkeepref(b[i]);
3131 : }
3132 1095 : }
3133 :
3134 : static const char fwftsep[2] = {STREAM_FWF_FIELD_SEP, '\0'};
3135 : static const char fwfrsep[2] = {STREAM_FWF_RECORD_SEP, '\0'};
3136 :
3137 : /* 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); */
3138 : str
3139 1122 : mvc_import_table_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3140 : {
3141 1122 : backend *be;
3142 1122 : BAT **b = NULL;
3143 1122 : sql_table *t = *(sql_table **) getArgReference(stk, pci, pci->retc + 0);
3144 1122 : const char *tsep = *getArgReference_str(stk, pci, pci->retc + 1);
3145 1122 : const char *rsep = *getArgReference_str(stk, pci, pci->retc + 2);
3146 1122 : const char *ssep = *getArgReference_str(stk, pci, pci->retc + 3);
3147 1122 : const char *ns = *getArgReference_str(stk, pci, pci->retc + 4);
3148 1122 : const char *fname = *getArgReference_str(stk, pci, pci->retc + 5);
3149 1122 : lng sz = *getArgReference_lng(stk, pci, pci->retc + 6);
3150 1122 : lng offset = *getArgReference_lng(stk, pci, pci->retc + 7);
3151 1122 : int besteffort = *getArgReference_int(stk, pci, pci->retc + 8);
3152 1122 : const char *fixed_widths = *getArgReference_str(stk, pci, pci->retc + 9);
3153 1122 : int onclient = *getArgReference_int(stk, pci, pci->retc + 10);
3154 1122 : bool escape = *getArgReference_int(stk, pci, pci->retc + 11);
3155 1122 : const char *decsep = *getArgReference_str(stk, pci, pci->retc + 12);
3156 1122 : const char *decskip = *getArgReference_str(stk, pci, pci->retc + 13);
3157 1122 : str msg = MAL_SUCCEED;
3158 1122 : bstream *s = NULL;
3159 1122 : stream *ss;
3160 :
3161 1122 : (void) mb; /* NOT USED */
3162 1122 : if ((msg = checkSQLContext(cntxt)) != NULL)
3163 : return msg;
3164 1122 : if (onclient && !cntxt->filetrans)
3165 0 : throw(MAL, "sql.copy_from", SQLSTATE(42000) "Cannot transfer files from client");
3166 1122 : if (strNil(decsep))
3167 0 : throw(MAL, "sql.copy_from", SQLSTATE(42000) "decimal separator cannot be nil");
3168 1128 : if (strNil(decskip))
3169 : decskip = NULL;
3170 :
3171 1122 : be = cntxt->sqlcontext;
3172 : /* The CSV parser expects ssep to have the value 0 if the user does not
3173 : * specify a quotation character
3174 : */
3175 1733 : if (*ssep == 0 || strNil(ssep))
3176 : ssep = NULL;
3177 :
3178 1122 : if (strNil(fname))
3179 782 : fname = NULL;
3180 1122 : if (fname == NULL) {
3181 782 : msg = mvc_import_table(cntxt, &b, be->mvc, be->mvc->scanner.rs, t, tsep, rsep, ssep, ns, sz, offset, besteffort, true, escape, decsep, decskip);
3182 : } else {
3183 340 : if (onclient) {
3184 246 : ss = mapi_request_upload(fname, false, be->mvc->scanner.rs, be->mvc->scanner.ws);
3185 : } else {
3186 94 : ss = open_rastream(fname);
3187 : }
3188 340 : if (ss == NULL || mnstr_errnr(ss) != MNSTR_NO__ERROR) {
3189 2 : msg = createException(IO, "sql.copy_from", SQLSTATE(42000) "%s", mnstr_peek_error(NULL));
3190 2 : close_stream(ss);
3191 2 : return msg;
3192 : }
3193 :
3194 676 : if (!strNil(fixed_widths)) {
3195 2 : size_t ncol = 0, current_width_entry = 0, i;
3196 2 : size_t *widths;
3197 2 : const char* val_start = fixed_widths;
3198 2 : size_t width_len = strlen(fixed_widths);
3199 2 : stream *ns;
3200 :
3201 71 : for (i = 0; i < width_len; i++) {
3202 69 : if (fixed_widths[i] == STREAM_FWF_FIELD_SEP) {
3203 34 : ncol++;
3204 : }
3205 : }
3206 2 : widths = malloc(sizeof(size_t) * ncol);
3207 2 : if (!widths) {
3208 0 : close_stream(ss);
3209 0 : throw(MAL, "sql.copy_from", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3210 : }
3211 71 : for (i = 0; i < width_len; i++) {
3212 69 : if (fixed_widths[i] == STREAM_FWF_FIELD_SEP) {
3213 34 : widths[current_width_entry++] = (size_t) strtoll(val_start, NULL, 10);
3214 34 : val_start = fixed_widths + i + 1;
3215 : }
3216 : }
3217 : /* overwrite other delimiters to the ones the FWF stream uses */
3218 2 : tsep = fwftsep;
3219 2 : rsep = fwfrsep;
3220 :
3221 2 : ns = stream_fwf_create(ss, ncol, widths, STREAM_FWF_FILLER);
3222 2 : if (ns == NULL || mnstr_errnr(ns) != MNSTR_NO__ERROR) {
3223 0 : msg = createException(IO, "sql.copy_from", SQLSTATE(42000) "%s", mnstr_peek_error(NULL));
3224 0 : close_stream(ss);
3225 0 : free(widths);
3226 0 : return msg;
3227 : }
3228 : ss = ns;
3229 : }
3230 : #if SIZEOF_VOID_P == 4
3231 : s = bstream_create(ss, 0x20000);
3232 : #else
3233 338 : s = bstream_create(ss, 0x200000);
3234 : #endif
3235 338 : if (s == NULL) {
3236 0 : close_stream(ss);
3237 0 : throw(MAL, "sql.copy_from", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3238 : }
3239 338 : msg = mvc_import_table(cntxt, &b, be->mvc, s, t, tsep, rsep, ssep, ns, sz, offset, besteffort, false, escape, decsep, decskip);
3240 : // This also closes ss:
3241 338 : bstream_destroy(s);
3242 : }
3243 1120 : if (b && !msg)
3244 1095 : bat2return(stk, pci, b);
3245 1120 : GDKfree(b);
3246 1120 : return msg;
3247 : }
3248 :
3249 : str
3250 245 : not_unique(bit *ret, const bat *bid)
3251 : {
3252 245 : BAT *b;
3253 :
3254 245 : if ((b = BATdescriptor(*bid)) == NULL) {
3255 0 : throw(SQL, "not_unique", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
3256 : }
3257 :
3258 245 : *ret = FALSE;
3259 245 : BATiter bi = bat_iterator(b);
3260 245 : if (bi.key || BATtdensebi(&bi) || bi.count <= 1) {
3261 240 : bat_iterator_end(&bi);
3262 240 : BBPunfix(b->batCacheid);
3263 240 : return MAL_SUCCEED;
3264 5 : } else if (bi.sorted) {
3265 5 : BUN p;
3266 5 : oid c = ((oid *) bi.base)[0];
3267 :
3268 6 : for (p = 1; p < bi.count; p++) {
3269 6 : oid v = ((oid *) bi.base)[p];
3270 6 : if (v <= c) {
3271 5 : *ret = TRUE;
3272 5 : break;
3273 : }
3274 1 : c = v;
3275 : }
3276 : } else {
3277 0 : bat_iterator_end(&bi);
3278 0 : BBPunfix(b->batCacheid);
3279 0 : throw(SQL, "not_unique", SQLSTATE(42000) "Input column should be sorted");
3280 : }
3281 5 : bat_iterator_end(&bi);
3282 5 : BBPunfix(b->batCacheid);
3283 5 : return MAL_SUCCEED;
3284 : }
3285 :
3286 : /* row case */
3287 : str
3288 72 : SQLidentity(oid *ret, const void *i)
3289 : {
3290 72 : (void)i;
3291 72 : *ret = 0;
3292 72 : return MAL_SUCCEED;
3293 : }
3294 :
3295 : str
3296 25 : BATSQLidentity(bat *ret, const bat *bid)
3297 : {
3298 25 : return BKCmirror(ret, bid);
3299 : }
3300 :
3301 : str
3302 4 : PBATSQLidentity(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3303 : {
3304 4 : bat *res = getArgReference_bat(stk, pci, 0);
3305 4 : oid *ns = getArgReference_oid(stk, pci, 1);
3306 4 : bat bid = *getArgReference_bat(stk, pci, 2);
3307 4 : oid s = *getArgReference_oid(stk, pci, 3);
3308 4 : BAT *b, *bn = NULL;
3309 :
3310 4 : (void) cntxt;
3311 4 : (void) mb;
3312 4 : if (!(b = BBPquickdesc(bid)))
3313 0 : throw(MAL, "batcalc.identity", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
3314 4 : if (!(bn = BATdense(b->hseqbase, s, BATcount(b))))
3315 0 : throw(MAL, "batcalc.identity", GDK_EXCEPTION);
3316 4 : *ns = s + BATcount(b);
3317 4 : *res = bn->batCacheid;
3318 4 : BBPkeepref(bn);
3319 4 : return MAL_SUCCEED;
3320 : }
3321 :
3322 : /*
3323 : * The core modules of Monet provide just a limited set of
3324 : * mathematical operators. The extensions required to support
3325 : * SQL-99 are shown below. At some point they also should be
3326 : * moved to module code base.
3327 : */
3328 :
3329 : str
3330 10 : SQLcst_alpha_cst(dbl *res, const dbl *decl, const dbl *theta)
3331 : {
3332 10 : dbl s, c1, c2;
3333 10 : char *msg = MAL_SUCCEED;
3334 10 : if (is_dbl_nil(*decl) || is_dbl_nil(*theta)) {
3335 0 : *res = dbl_nil;
3336 10 : } else if (fabs(*decl) + *theta > 89.9) {
3337 0 : *res = 180.0;
3338 : } else {
3339 10 : s = sin(radians(*theta));
3340 10 : c1 = cos(radians(*decl - *theta));
3341 10 : c2 = cos(radians(*decl + *theta));
3342 10 : *res = degrees(fabs(atan(s / sqrt(fabs(c1 * c2)))));
3343 : }
3344 10 : return msg;
3345 : }
3346 :
3347 : /*
3348 : sql5_export str SQLcst_alpha_cst(dbl *res, dbl *decl, dbl *theta);
3349 : sql5_export str SQLbat_alpha_cst(bat *res, bat *decl, dbl *theta);
3350 : sql5_export str SQLcst_alpha_bat(bat *res, dbl *decl, bat *theta);
3351 : */
3352 : str
3353 0 : SQLbat_alpha_cst(bat *res, const bat *decl, const dbl *theta)
3354 : {
3355 0 : BAT *b, *bn;
3356 0 : BUN p, q;
3357 0 : dbl s, c1, c2, r;
3358 0 : char *msg = NULL;
3359 :
3360 0 : if (is_dbl_nil(*theta)) {
3361 0 : throw(SQL, "SQLbat_alpha", SQLSTATE(42000) "Parameter theta should not be nil");
3362 : }
3363 0 : if ((b = BATdescriptor(*decl)) == NULL) {
3364 0 : throw(SQL, "alpha", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
3365 : }
3366 0 : bn = COLnew(b->hseqbase, TYPE_dbl, BATcount(b), TRANSIENT);
3367 0 : if (bn == NULL) {
3368 0 : BBPunfix(b->batCacheid);
3369 0 : throw(SQL, "sql.alpha", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3370 : }
3371 0 : s = sin(radians(*theta));
3372 0 : BATiter bi = bat_iterator(b);
3373 0 : const dbl *vals = (const dbl *) bi.base;
3374 0 : BATloop(b, p, q) {
3375 0 : dbl d = vals[p];
3376 0 : if (is_dbl_nil(d))
3377 0 : r = dbl_nil;
3378 0 : else if (fabs(d) + *theta > 89.9)
3379 0 : r = 180.0;
3380 : else {
3381 0 : c1 = cos(radians(d - *theta));
3382 0 : c2 = cos(radians(d + *theta));
3383 0 : r = degrees(fabs(atan(s / sqrt(fabs(c1 * c2)))));
3384 : }
3385 0 : if (BUNappend(bn, &r, false) != GDK_SUCCEED) {
3386 0 : BBPreclaim(bn);
3387 0 : bat_iterator_end(&bi);
3388 0 : BBPunfix(b->batCacheid);
3389 0 : throw(SQL, "sql.alpha", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3390 : }
3391 : }
3392 0 : bat_iterator_end(&bi);
3393 0 : *res = bn->batCacheid;
3394 0 : BBPkeepref(bn);
3395 0 : BBPunfix(b->batCacheid);
3396 0 : return msg;
3397 : }
3398 :
3399 : str
3400 0 : SQLcst_alpha_bat(bat *res, const dbl *decl, const bat *thetabid)
3401 : {
3402 0 : BAT *b, *bn;
3403 0 : BUN p, q;
3404 0 : dbl s, c1, c2, r;
3405 0 : char *msg = NULL;
3406 0 : dbl *thetas;
3407 :
3408 0 : if ((b = BATdescriptor(*thetabid)) == NULL) {
3409 0 : throw(SQL, "alpha", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
3410 : }
3411 0 : bn = COLnew(b->hseqbase, TYPE_dbl, BATcount(b), TRANSIENT);
3412 0 : if (bn == NULL) {
3413 0 : BBPunfix(b->batCacheid);
3414 0 : throw(SQL, "sql.alpha", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3415 : }
3416 0 : BATiter bi = bat_iterator(b);
3417 0 : thetas = (dbl *) bi.base;
3418 0 : BATloop(b, p, q) {
3419 0 : dbl d = *decl;
3420 0 : dbl theta = thetas[p];
3421 :
3422 0 : if (is_dbl_nil(d))
3423 0 : r = dbl_nil;
3424 0 : else if (fabs(d) + theta > 89.9)
3425 0 : r = (dbl) 180.0;
3426 : else {
3427 0 : s = sin(radians(theta));
3428 0 : c1 = cos(radians(d - theta));
3429 0 : c2 = cos(radians(d + theta));
3430 0 : r = degrees(fabs(atan(s / sqrt(fabs(c1 * c2)))));
3431 : }
3432 0 : if (BUNappend(bn, &r, false) != GDK_SUCCEED) {
3433 0 : BBPreclaim(bn);
3434 0 : bat_iterator_end(&bi);
3435 0 : BBPunfix(b->batCacheid);
3436 0 : throw(SQL, "sql.alpha", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3437 : }
3438 : }
3439 0 : bat_iterator_end(&bi);
3440 0 : *res = bn->batCacheid;
3441 0 : BBPkeepref(bn);
3442 0 : BBPunfix(b->batCacheid);
3443 0 : return msg;
3444 : }
3445 :
3446 : /* str dump_cache(int *r); */
3447 : str
3448 0 : dump_cache(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3449 : {
3450 0 : mvc *m = NULL;
3451 0 : str msg;
3452 0 : int cnt;
3453 0 : cq *q = NULL;
3454 0 : BAT *query, *count;
3455 0 : bat *rquery = getArgReference_bat(stk, pci, 0);
3456 0 : bat *rcount = getArgReference_bat(stk, pci, 1);
3457 :
3458 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
3459 : return msg;
3460 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
3461 : return msg;
3462 0 : cnt = m->qc->id;
3463 0 : query = COLnew(0, TYPE_str, cnt, TRANSIENT);
3464 0 : if (query == NULL)
3465 0 : throw(SQL, "sql.dumpcache", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3466 0 : count = COLnew(0, TYPE_int, cnt, TRANSIENT);
3467 0 : if (count == NULL) {
3468 0 : BBPunfix(query->batCacheid);
3469 0 : throw(SQL, "sql.dumpcache", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3470 : }
3471 :
3472 0 : for (q = m->qc->q; q; q = q->next) {
3473 0 : if (BUNappend(query, q->f->query, false) != GDK_SUCCEED ||
3474 0 : BUNappend(count, &q->count, false) != GDK_SUCCEED) {
3475 0 : BBPunfix(query->batCacheid);
3476 0 : BBPunfix(count->batCacheid);
3477 0 : throw(SQL, "sql.dumpcache", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3478 : }
3479 : }
3480 0 : *rquery = query->batCacheid;
3481 0 : *rcount = count->batCacheid;
3482 0 : BBPkeepref(query);
3483 0 : BBPkeepref(count);
3484 0 : return MAL_SUCCEED;
3485 : }
3486 :
3487 : /* str dump_opt_stats(int *r); */
3488 : str
3489 0 : dump_opt_stats(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3490 : {
3491 0 : backend *be;
3492 0 : str msg;
3493 0 : int cnt;
3494 0 : BAT *rewrite, *count;
3495 0 : bat *rrewrite = getArgReference_bat(stk, pci, 0);
3496 0 : bat *rcount = getArgReference_bat(stk, pci, 1);
3497 :
3498 0 : (void)mb;
3499 0 : if ((msg = getBackendContext(cntxt, &be)) != NULL)
3500 : return msg;
3501 0 : cnt = be->mvc->qc->id;
3502 0 : rewrite = COLnew(0, TYPE_str, cnt, TRANSIENT);
3503 0 : count = COLnew(0, TYPE_int, cnt, TRANSIENT);
3504 0 : if (rewrite == NULL || count == NULL) {
3505 0 : BBPreclaim(rewrite);
3506 0 : BBPreclaim(count);
3507 0 : throw(SQL, "sql.optstats", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3508 : }
3509 :
3510 0 : if (BUNappend(rewrite, "joinidx", false) != GDK_SUCCEED ||
3511 0 : BUNappend(count, &be->join_idx, false) != GDK_SUCCEED) {
3512 0 : BBPreclaim(rewrite);
3513 0 : BBPreclaim(count);
3514 0 : throw(SQL, "sql.optstats", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3515 : }
3516 : /* TODO add other rewrites */
3517 :
3518 0 : *rrewrite = rewrite->batCacheid;
3519 0 : *rcount = count->batCacheid;
3520 0 : BBPkeepref(rewrite);
3521 0 : BBPkeepref(count);
3522 0 : return MAL_SUCCEED;
3523 : }
3524 :
3525 : /* str dump_opt_stats(int *r); */
3526 : str
3527 61 : dump_trace(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3528 : {
3529 61 : int i;
3530 61 : BAT *t[3];
3531 :
3532 61 : (void) cntxt;
3533 61 : (void) mb;
3534 61 : if (TRACEtable(cntxt, t) != 3)
3535 0 : throw(SQL, "sql.dump_trace", SQLSTATE(3F000) "Profiler not started");
3536 244 : for (i = 0; i < 3; i++) {
3537 183 : *getArgReference_bat(stk, pci, i) = t[i]->batCacheid;
3538 183 : BBPkeepref(t[i]);
3539 : }
3540 : return MAL_SUCCEED;
3541 : }
3542 :
3543 : static str
3544 57 : sql_sessions_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3545 : {
3546 57 : BAT *id = NULL, *user = NULL, *login = NULL, *sessiontimeout = NULL,
3547 57 : *querytimeout = NULL, *idle = NULL;
3548 57 : BAT *opt = NULL, *wlimit = NULL, *mlimit = NULL;
3549 57 : BAT *language = NULL, *peer = NULL, *hostname = NULL, *application = NULL, *client = NULL, *clientpid = NULL, *remark = NULL;
3550 57 : bat *idId = getArgReference_bat(stk, pci, 0);
3551 57 : bat *userId = getArgReference_bat(stk, pci, 1);
3552 57 : bat *loginId = getArgReference_bat(stk, pci, 2);
3553 57 : bat *idleId = getArgReference_bat(stk, pci, 3);
3554 57 : bat *optId = getArgReference_bat(stk, pci, 4);
3555 57 : bat *sessiontimeoutId = getArgReference_bat(stk, pci, 5);
3556 57 : bat *querytimeoutId = getArgReference_bat(stk, pci, 6);
3557 57 : bat *wlimitId = getArgReference_bat(stk, pci, 7);
3558 57 : bat *mlimitId = getArgReference_bat(stk, pci, 8);
3559 57 : bat *languageId = getArgReference_bat(stk, pci, 9);
3560 57 : bat *peerId = getArgReference_bat(stk, pci, 10);
3561 57 : bat *hostnameId = getArgReference_bat(stk, pci, 11);
3562 57 : bat *applicationId = getArgReference_bat(stk, pci, 12);
3563 57 : bat *clientId = getArgReference_bat(stk, pci, 13);
3564 57 : bat *clientpidId = getArgReference_bat(stk, pci, 14);
3565 57 : bat *remarkId = getArgReference_bat(stk, pci, 15);
3566 57 : Client c;
3567 57 : backend *be;
3568 57 : sqlid user_id;
3569 57 : sqlid role_id;
3570 57 : bool admin;
3571 57 : timestamp ts;
3572 57 : lng pid;
3573 57 : const char *s;
3574 57 : int timeout;
3575 57 : str msg = NULL;
3576 :
3577 57 : (void) cntxt;
3578 57 : (void) mb;
3579 :
3580 57 : id = COLnew(0, TYPE_int, 0, TRANSIENT);
3581 57 : user = COLnew(0, TYPE_str, 0, TRANSIENT);
3582 57 : login = COLnew(0, TYPE_timestamp, 0, TRANSIENT);
3583 57 : opt = COLnew(0, TYPE_str, 0, TRANSIENT);
3584 57 : sessiontimeout = COLnew(0, TYPE_int, 0, TRANSIENT);
3585 57 : querytimeout = COLnew(0, TYPE_int, 0, TRANSIENT);
3586 57 : wlimit = COLnew(0, TYPE_int, 0, TRANSIENT);
3587 57 : mlimit = COLnew(0, TYPE_int, 0, TRANSIENT);
3588 57 : idle = COLnew(0, TYPE_timestamp, 0, TRANSIENT);
3589 57 : language = COLnew(0, TYPE_str, 0, TRANSIENT);
3590 57 : peer = COLnew(0, TYPE_str, 0, TRANSIENT);
3591 57 : hostname = COLnew(0, TYPE_str, 0, TRANSIENT);
3592 57 : application = COLnew(0, TYPE_str, 0, TRANSIENT);
3593 57 : client = COLnew(0, TYPE_str, 0, TRANSIENT);
3594 57 : clientpid = COLnew(0, TYPE_lng, 0, TRANSIENT);
3595 57 : remark = COLnew(0, TYPE_str, 0, TRANSIENT);
3596 :
3597 57 : if (id == NULL || user == NULL || login == NULL || sessiontimeout == NULL
3598 57 : || idle == NULL || querytimeout == NULL || opt == NULL || wlimit == NULL
3599 57 : || mlimit == NULL || language == NULL || peer == NULL || hostname == NULL
3600 57 : || application == NULL || client == NULL || clientpid == NULL
3601 57 : || remark == NULL) {
3602 0 : BBPreclaim(id);
3603 0 : BBPreclaim(user);
3604 0 : BBPreclaim(login);
3605 0 : BBPreclaim(sessiontimeout);
3606 0 : BBPreclaim(querytimeout);
3607 0 : BBPreclaim(idle);
3608 0 : BBPreclaim(opt);
3609 0 : BBPreclaim(wlimit);
3610 0 : BBPreclaim(mlimit);
3611 0 : BBPreclaim(language);
3612 0 : BBPreclaim(peer);
3613 0 : BBPreclaim(hostname);
3614 0 : BBPreclaim(application);
3615 0 : BBPreclaim(client);
3616 0 : BBPreclaim(clientpid);
3617 0 : BBPreclaim(remark);
3618 :
3619 0 : throw(SQL, "sql.sessions", SQLSTATE(HY013) MAL_MALLOC_FAIL);
3620 : }
3621 :
3622 57 : be = cntxt->sqlcontext;
3623 57 : user_id = be->mvc->user_id;
3624 57 : role_id = be->mvc->role_id;
3625 57 : admin = user_id == USER_MONETDB || role_id == ROLE_SYSADMIN;
3626 :
3627 57 : MT_lock_set(&mal_contextLock);
3628 3705 : for (c = mal_clients; c < mal_clients + MAL_MAXCLIENTS; c++) {
3629 3648 : if (c->mode != RUNCLIENT)
3630 3571 : continue;
3631 :
3632 77 : backend *their_be = c->sqlcontext;
3633 77 : bool allowed_to_see = admin || c == cntxt || their_be->mvc->user_id == user_id;
3634 : // Note that their role_id is not checked. Just because we have
3635 : // both been granted a ROLE does not mean you are allowed to see
3636 : // my private details.
3637 77 : if (!allowed_to_see)
3638 8 : continue;
3639 :
3640 69 : const char *username = c->username;
3641 69 : if (!username)
3642 0 : username = str_nil;
3643 69 : if (BUNappend(user, username, false) != GDK_SUCCEED)
3644 0 : goto bailout;
3645 69 : ts = timestamp_fromtime(c->login);
3646 69 : if (is_timestamp_nil(ts)) {
3647 0 : msg = createException(SQL, "sql.sessions",
3648 : SQLSTATE(22003)
3649 : "Failed to convert user logged time");
3650 0 : goto bailout;
3651 : }
3652 69 : if (BUNappend(id, &c->idx, false) != GDK_SUCCEED)
3653 0 : goto bailout;
3654 69 : if (BUNappend(login, &ts, false) != GDK_SUCCEED)
3655 0 : goto bailout;
3656 69 : timeout = (int) (c->logical_sessiontimeout);
3657 69 : if (BUNappend(sessiontimeout, &timeout, false) != GDK_SUCCEED)
3658 0 : goto bailout;
3659 69 : timeout = (int) (c->querytimeout / 1000000);
3660 69 : if (BUNappend(querytimeout, &timeout, false) != GDK_SUCCEED)
3661 0 : goto bailout;
3662 69 : if (c->idle) {
3663 12 : ts = timestamp_fromtime(c->idle);
3664 12 : if (is_timestamp_nil(ts)) {
3665 0 : msg = createException(SQL, "sql.sessions",
3666 : SQLSTATE(22003)
3667 : "Failed to convert user logged time");
3668 0 : goto bailout;
3669 : }
3670 : } else
3671 57 : ts = timestamp_nil;
3672 69 : if (BUNappend(idle, &ts, false) != GDK_SUCCEED)
3673 0 : goto bailout;
3674 69 : if (BUNappend(opt, &c->optimizer, false) != GDK_SUCCEED)
3675 0 : goto bailout;
3676 69 : if (BUNappend(wlimit, &c->workerlimit, false) != GDK_SUCCEED)
3677 0 : goto bailout;
3678 69 : if (BUNappend(mlimit, &c->memorylimit, false) != GDK_SUCCEED)
3679 0 : goto bailout;
3680 : // If the scenario is NULL we assume we're in monetdbe/e which
3681 : // is always SQL.
3682 69 : s = c->scenario ? getScenarioLanguage(c) : "sql";
3683 69 : if (BUNappend(language, s, false) != GDK_SUCCEED)
3684 0 : goto bailout;
3685 69 : s = c->peer ? c->peer : str_nil;
3686 69 : if (BUNappend(peer, s, false) != GDK_SUCCEED)
3687 0 : goto bailout;
3688 69 : s = c->client_hostname ? c->client_hostname : str_nil;
3689 69 : if (BUNappend(hostname, s, false) != GDK_SUCCEED)
3690 0 : goto bailout;
3691 69 : s = c->client_application ? c->client_application : str_nil;
3692 69 : if (BUNappend(application, s, false) != GDK_SUCCEED)
3693 0 : goto bailout;
3694 69 : s = c->client_library ? c->client_library : str_nil;
3695 69 : if (BUNappend(client, s, false) != GDK_SUCCEED)
3696 0 : goto bailout;
3697 69 : pid = c->client_pid;
3698 71 : if (BUNappend(clientpid, pid ? &pid : &lng_nil, false) != GDK_SUCCEED)
3699 0 : goto bailout;
3700 69 : s = c->client_remark ? c->client_remark : str_nil;
3701 69 : if (BUNappend(remark, s, false) != GDK_SUCCEED)
3702 0 : goto bailout;
3703 : }
3704 57 : MT_lock_unset(&mal_contextLock);
3705 :
3706 57 : *idId = id->batCacheid;
3707 57 : BBPkeepref(id);
3708 57 : *userId = user->batCacheid;
3709 57 : BBPkeepref(user);
3710 57 : *loginId = login->batCacheid;
3711 57 : BBPkeepref(login);
3712 57 : *sessiontimeoutId = sessiontimeout->batCacheid;
3713 57 : BBPkeepref(sessiontimeout);
3714 57 : *querytimeoutId = querytimeout->batCacheid;
3715 57 : BBPkeepref(querytimeout);
3716 57 : *idleId = idle->batCacheid;
3717 57 : BBPkeepref(idle);
3718 :
3719 57 : *optId = opt->batCacheid;
3720 57 : BBPkeepref(opt);
3721 57 : *wlimitId = wlimit->batCacheid;
3722 57 : BBPkeepref(wlimit);
3723 57 : *mlimitId = mlimit->batCacheid;
3724 57 : BBPkeepref(mlimit);
3725 57 : *languageId = language->batCacheid;
3726 57 : BBPkeepref(language);
3727 57 : *peerId = peer->batCacheid;
3728 57 : BBPkeepref(peer);
3729 57 : *hostnameId = hostname->batCacheid;
3730 57 : BBPkeepref(hostname);
3731 57 : *applicationId = application->batCacheid;
3732 57 : BBPkeepref(application);
3733 57 : *clientId = client->batCacheid;
3734 57 : BBPkeepref(client);
3735 57 : *clientpidId = clientpid->batCacheid;
3736 57 : BBPkeepref(clientpid);
3737 57 : *remarkId = remark->batCacheid;
3738 57 : BBPkeepref(remark);
3739 :
3740 57 : return MAL_SUCCEED;
3741 :
3742 0 : bailout:
3743 0 : MT_lock_unset(&mal_contextLock);
3744 0 : BBPunfix(id->batCacheid);
3745 0 : BBPunfix(user->batCacheid);
3746 0 : BBPunfix(login->batCacheid);
3747 0 : BBPunfix(sessiontimeout->batCacheid);
3748 0 : BBPunfix(querytimeout->batCacheid);
3749 0 : BBPunfix(idle->batCacheid);
3750 :
3751 0 : BBPunfix(opt->batCacheid);
3752 0 : BBPunfix(wlimit->batCacheid);
3753 0 : BBPunfix(mlimit->batCacheid);
3754 0 : BBPunfix(language->batCacheid);
3755 0 : BBPunfix(peer->batCacheid);
3756 0 : BBPunfix(hostname->batCacheid);
3757 0 : BBPunfix(application->batCacheid);
3758 0 : BBPunfix(client->batCacheid);
3759 0 : BBPunfix(clientpid->batCacheid);
3760 0 : BBPunfix(remark->batCacheid);
3761 0 : return msg;
3762 : }
3763 :
3764 : str
3765 107 : sql_querylog_catalog(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3766 : {
3767 107 : int i;
3768 107 : BAT *t[8];
3769 107 : str msg;
3770 :
3771 107 : (void) cntxt;
3772 107 : (void) mb;
3773 107 : msg = QLOGcatalog(t);
3774 107 : if( msg != MAL_SUCCEED)
3775 : return msg;
3776 963 : for (i = 0; i < 8; i++)
3777 856 : if( t[i]){
3778 856 : *getArgReference_bat(stk, pci, i) = t[i]->batCacheid;
3779 856 : BBPkeepref(t[i]);
3780 : } else
3781 0 : throw(SQL,"sql.querylog", SQLSTATE(45000) "Missing query catalog BAT");
3782 : return MAL_SUCCEED;
3783 : }
3784 :
3785 : str
3786 79 : sql_querylog_calls(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3787 : {
3788 79 : int i;
3789 79 : BAT *t[10];
3790 79 : str msg;
3791 :
3792 79 : (void) cntxt;
3793 79 : (void) mb;
3794 79 : msg = QLOGcalls(t);
3795 79 : if( msg != MAL_SUCCEED)
3796 : return msg;
3797 790 : for (i = 0; i < 9; i++)
3798 711 : if( t[i]){
3799 711 : *getArgReference_bat(stk, pci, i) = t[i]->batCacheid;
3800 711 : BBPkeepref(t[i]);
3801 : } else
3802 0 : throw(SQL,"sql.querylog", SQLSTATE(45000) "Missing query call BAT");
3803 : return MAL_SUCCEED;
3804 : }
3805 :
3806 : str
3807 1 : sql_querylog_empty(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3808 : {
3809 1 : (void) cntxt;
3810 1 : (void) mb;
3811 1 : (void) stk;
3812 1 : (void) pci;
3813 1 : return QLOGempty(NULL);
3814 : }
3815 :
3816 : /* str sql_rowid(oid *rid, ptr v, str *sname, str *tname); */
3817 : str
3818 0 : sql_rowid(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
3819 : {
3820 0 : BAT *b;
3821 0 : mvc *m = NULL;
3822 0 : str msg;
3823 0 : sql_schema *s = NULL;
3824 0 : sql_table *t = NULL;
3825 0 : sql_column *c = NULL;
3826 0 : oid *rid = getArgReference_oid(stk, pci, 0);
3827 0 : const char *sname = *getArgReference_str(stk, pci, 2);
3828 0 : const char *tname = *getArgReference_str(stk, pci, 3);
3829 :
3830 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
3831 : return msg;
3832 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
3833 : return msg;
3834 0 : s = mvc_bind_schema(m, sname);
3835 0 : if (s == NULL)
3836 0 : throw(SQL, "calc.rowid", SQLSTATE(3F000) "Schema missing %s", sname);
3837 0 : t = mvc_bind_table(m, s, tname);
3838 0 : if (t == NULL)
3839 0 : throw(SQL, "calc.rowid", SQLSTATE(42S02) "Table missing %s.%s",sname,tname);
3840 0 : if (!isTable(t))
3841 0 : throw(SQL, "calc.rowid", SQLSTATE(42000) "%s '%s' is not persistent",
3842 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
3843 0 : if (!ol_first_node(t->columns))
3844 0 : throw(SQL, "calc.rowid", SQLSTATE(42S22) "Column missing %s.%s",sname,tname);
3845 0 : c = ol_first_node(t->columns)->data;
3846 : /* HACK, get insert bat */
3847 0 : sqlstore *store = m->session->tr->store;
3848 0 : b = store->storage_api.bind_col(m->session->tr, c, QUICK);
3849 0 : if( b == NULL)
3850 0 : throw(SQL,"calc.rowid", SQLSTATE(HY005) "Cannot access column descriptor");
3851 : /* UGH (move into storage backends!!) */
3852 0 : *rid = BATcount(b);
3853 0 : return MAL_SUCCEED;
3854 : }
3855 :
3856 : static str
3857 0 : do_sql_rank_grp(bat *rid, const bat *bid, const bat *gid, int nrank, int dense, const char *name)
3858 : {
3859 0 : BAT *r, *b, *g;
3860 0 : BUN p, q;
3861 0 : BATiter bi, gi;
3862 0 : int (*ocmp) (const void *, const void *);
3863 0 : int (*gcmp) (const void *, const void *);
3864 0 : const void *oc, *gc, *on, *gn;
3865 0 : int rank = 1;
3866 0 : int c;
3867 :
3868 0 : if ((b = BATdescriptor(*bid)) == NULL)
3869 0 : throw(SQL, name, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
3870 0 : if ((g = BATdescriptor(*gid)) == NULL) {
3871 0 : BBPunfix(b->batCacheid);
3872 0 : throw(SQL, name, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
3873 : }
3874 0 : bi = bat_iterator(b);
3875 0 : gi = bat_iterator(g);
3876 0 : ocmp = ATOMcompare(b->ttype);
3877 0 : gcmp = ATOMcompare(g->ttype);
3878 0 : oc = BUNtail(bi, 0);
3879 0 : gc = BUNtail(gi, 0);
3880 0 : if (!ALIGNsynced(b, g)) {
3881 0 : bat_iterator_end(&bi);
3882 0 : bat_iterator_end(&gi);
3883 0 : BBPunfix(b->batCacheid);
3884 0 : BBPunfix(g->batCacheid);
3885 0 : throw(SQL, name, SQLSTATE(45000) "Internal error, columns not aligned");
3886 : }
3887 : /*
3888 : if (!b->tsorted) {
3889 : BBPunfix(b->batCacheid);
3890 : BBPunfix(g->batCacheid);
3891 : throw(SQL, name, SQLSTATE(45000) "Internal error, columns not sorted");
3892 : }
3893 : */
3894 0 : r = COLnew(b->hseqbase, TYPE_int, BATcount(b), TRANSIENT);
3895 0 : if (r == NULL) {
3896 0 : bat_iterator_end(&bi);
3897 0 : bat_iterator_end(&gi);
3898 0 : BBPunfix(b->batCacheid);
3899 0 : BBPunfix(g->batCacheid);
3900 0 : throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
3901 : }
3902 0 : BATloop(b, p, q) {
3903 0 : on = BUNtail(bi, p);
3904 0 : gn = BUNtail(gi, p);
3905 :
3906 0 : if ((c = ocmp(on, oc)) != 0)
3907 0 : rank = nrank;
3908 0 : if (gcmp(gn, gc) != 0)
3909 0 : c = rank = nrank = 1;
3910 0 : oc = on;
3911 0 : gc = gn;
3912 0 : if (BUNappend(r, &rank, false) != GDK_SUCCEED) {
3913 0 : bat_iterator_end(&bi);
3914 0 : bat_iterator_end(&gi);
3915 0 : BBPunfix(b->batCacheid);
3916 0 : BBPunfix(g->batCacheid);
3917 0 : BBPunfix(r->batCacheid);
3918 0 : throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
3919 : }
3920 0 : nrank += !dense || c;
3921 : }
3922 0 : bat_iterator_end(&bi);
3923 0 : bat_iterator_end(&gi);
3924 0 : BBPunfix(b->batCacheid);
3925 0 : BBPunfix(g->batCacheid);
3926 0 : *rid = r->batCacheid;
3927 0 : BBPkeepref(r);
3928 0 : return MAL_SUCCEED;
3929 : }
3930 :
3931 : static str
3932 0 : do_sql_rank(bat *rid, const bat *bid, int nrank, int dense, const char *name)
3933 : {
3934 0 : BAT *r, *b;
3935 0 : BATiter bi;
3936 0 : int (*cmp) (const void *, const void *);
3937 0 : const void *cur, *n;
3938 0 : BUN p, q;
3939 0 : int rank = 1;
3940 0 : int c;
3941 :
3942 0 : if ((b = BATdescriptor(*bid)) == NULL)
3943 0 : throw(SQL, name, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
3944 0 : bi = bat_iterator(b);
3945 0 : if (!bi.sorted && !bi.revsorted) {
3946 0 : bat_iterator_end(&bi);
3947 0 : BBPunfix(b->batCacheid);
3948 0 : throw(SQL, name, SQLSTATE(45000) "Internal error, columns not sorted");
3949 : }
3950 :
3951 0 : cmp = ATOMcompare(bi.type);
3952 0 : cur = BUNtail(bi, 0);
3953 0 : r = COLnew(b->hseqbase, TYPE_int, BATcount(b), TRANSIENT);
3954 0 : if (r == NULL) {
3955 0 : bat_iterator_end(&bi);
3956 0 : BBPunfix(b->batCacheid);
3957 0 : throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
3958 : }
3959 0 : if (BATtdensebi(&bi)) {
3960 0 : BATloop(b, p, q) {
3961 0 : if (BUNappend(r, &rank, false) != GDK_SUCCEED)
3962 0 : goto bailout;
3963 0 : rank++;
3964 : }
3965 : } else {
3966 0 : BATloop(b, p, q) {
3967 0 : n = BUNtail(bi, p);
3968 0 : if ((c = cmp(n, cur)) != 0)
3969 0 : rank = nrank;
3970 0 : cur = n;
3971 0 : if (BUNappend(r, &rank, false) != GDK_SUCCEED)
3972 0 : goto bailout;
3973 0 : nrank += !dense || c;
3974 : }
3975 : }
3976 0 : bat_iterator_end(&bi);
3977 0 : BBPunfix(b->batCacheid);
3978 0 : *rid = r->batCacheid;
3979 0 : BBPkeepref(r);
3980 0 : return MAL_SUCCEED;
3981 0 : bailout:
3982 0 : bat_iterator_end(&bi);
3983 0 : BBPunfix(b->batCacheid);
3984 0 : BBPunfix(r->batCacheid);
3985 0 : throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
3986 : }
3987 :
3988 : str
3989 0 : sql_rank_grp(bat *rid, const bat *bid, const bat *gid, const bat *gpe)
3990 : {
3991 0 : (void) gpe;
3992 0 : return do_sql_rank_grp(rid, bid, gid, 1, 0, "sql.rank_grp");
3993 : }
3994 :
3995 : str
3996 0 : sql_dense_rank_grp(bat *rid, const bat *bid, const bat *gid, const bat *gpe)
3997 : {
3998 0 : (void) gpe;
3999 0 : return do_sql_rank_grp(rid, bid, gid, 2, 1, "sql.dense_rank_grp");
4000 : }
4001 :
4002 : str
4003 0 : sql_rank(bat *rid, const bat *bid)
4004 : {
4005 0 : return do_sql_rank(rid, bid, 1, 0, "sql.rank");
4006 : }
4007 :
4008 : str
4009 0 : sql_dense_rank(bat *rid, const bat *bid)
4010 : {
4011 0 : return do_sql_rank(rid, bid, 2, 1, "sql.dense_rank");
4012 : }
4013 :
4014 : str
4015 5 : SQLargRecord(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4016 : {
4017 5 : str s, t, *ret;
4018 :
4019 5 : (void) cntxt;
4020 5 : ret = getArgReference_str(stk, pci, 0);
4021 5 : s = instruction2str(mb, stk, getInstrPtr(mb, 0), LIST_MAL_CALL);
4022 5 : if(s == NULL)
4023 0 : throw(SQL, "sql.argRecord", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4024 5 : t = strchr(s, ' ');
4025 5 : if( ! t)
4026 0 : t = strchr(s, '\t');
4027 5 : *ret = GDKstrdup(t ? t + 1 : s);
4028 5 : GDKfree(s);
4029 5 : if(*ret == NULL)
4030 0 : throw(SQL, "sql.argRecord", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4031 : return MAL_SUCCEED;
4032 : }
4033 :
4034 : /*
4035 : * The drop_hash operation cleans up any hash indices on any of the tables columns.
4036 : */
4037 : str
4038 0 : SQLdrop_hash(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4039 : {
4040 0 : const char *sch = *getArgReference_str(stk, pci, 1);
4041 0 : const char *tbl = *getArgReference_str(stk, pci, 2);
4042 0 : sql_schema *s;
4043 0 : sql_table *t;
4044 0 : mvc *m = NULL;
4045 0 : str msg;
4046 :
4047 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
4048 : return msg;
4049 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
4050 : return msg;
4051 0 : s = mvc_bind_schema(m, sch);
4052 0 : if (s == NULL)
4053 0 : throw(SQL, "sql.drop_hash", SQLSTATE(3F000) "Schema missing %s",sch);
4054 0 : if (!mvc_schema_privs(m, s))
4055 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);
4056 0 : t = mvc_bind_table(m, s, tbl);
4057 0 : if (t == NULL)
4058 0 : throw(SQL, "sql.drop_hash", SQLSTATE(42S02) "Table missing %s.%s",sch, tbl);
4059 0 : if (!isTable(t))
4060 0 : throw(SQL, "sql.drop_hash", SQLSTATE(42000) "%s '%s' is not persistent",
4061 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
4062 :
4063 0 : sqlstore *store = m->session->tr->store;
4064 0 : for (node *n = ol_first_node(t->columns); n; n = n->next) {
4065 0 : sql_column *c = n->data;
4066 0 : BAT *b = NULL, *nb = NULL;
4067 :
4068 0 : if (!(b = store->storage_api.bind_col(m->session->tr, c, RDONLY)))
4069 0 : throw(SQL, "sql.drop_hash", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
4070 0 : if (VIEWtparent(b) && (nb = BBP_desc(VIEWtparent(b)))) {
4071 0 : BBPunfix(b->batCacheid);
4072 0 : if (!(b = BATdescriptor(nb->batCacheid)))
4073 0 : throw(SQL, "sql.drop_hash", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
4074 : }
4075 0 : HASHdestroy(b);
4076 0 : BBPunfix(b->batCacheid);
4077 : }
4078 : return MAL_SUCCEED;
4079 : }
4080 :
4081 : /* after an update on the optimizer catalog, we have to change
4082 : * the internal optimizer pipe line administration
4083 : * The minimal and default pipelines may not be changed.
4084 : */
4085 : str
4086 0 : SQLoptimizersUpdate(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4087 : {
4088 0 : mvc *m = NULL;
4089 0 : str msg;
4090 :
4091 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
4092 : return msg;
4093 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
4094 : return msg;
4095 : /* find the optimizer pipeline */
4096 0 : (void) stk;
4097 0 : (void) pci;
4098 0 : throw(SQL, "updateOptimizer", SQLSTATE(0A000) PROGRAM_NYI);
4099 : }
4100 :
4101 : static str
4102 90652 : sql_storage_appendrow(BAT *bs, const char *sname, const char *tname, const char *cname,
4103 : int access, const char *tpname,
4104 : BAT *sch, BAT *tab, BAT *col, BAT *type, BAT *loc,
4105 : BAT *cnt, BAT *atom, BAT *size, BAT *heap, BAT *indices,
4106 : BAT *phash, BAT *sort, BAT *imprints, BAT *mode,
4107 : BAT *revsort, BAT *key, BAT *oidx)
4108 : {
4109 90652 : BATiter bsi = bat_iterator(bs);
4110 90652 : lng sz;
4111 90652 : int w;
4112 90652 : bit bitval;
4113 :
4114 181304 : if (BUNappend(sch, sname, false) != GDK_SUCCEED ||
4115 181304 : BUNappend(tab, tname, false) != GDK_SUCCEED ||
4116 90652 : BUNappend(col, cname, false) != GDK_SUCCEED)
4117 0 : goto bailout1;
4118 90652 : if (access == TABLE_WRITABLE) {
4119 77291 : if (BUNappend(mode, "writable", false) != GDK_SUCCEED)
4120 0 : goto bailout1;
4121 13361 : } else if (access == TABLE_APPENDONLY) {
4122 0 : if (BUNappend(mode, "appendonly", false) != GDK_SUCCEED)
4123 0 : goto bailout1;
4124 13361 : } else if (access == TABLE_READONLY) {
4125 13361 : if (BUNappend(mode, "readonly", false) != GDK_SUCCEED)
4126 0 : goto bailout1;
4127 : } else {
4128 0 : if (BUNappend(mode, str_nil, false) != GDK_SUCCEED)
4129 0 : goto bailout1;
4130 : }
4131 90652 : if (BUNappend(type, tpname, false) != GDK_SUCCEED)
4132 0 : goto bailout1;
4133 :
4134 90652 : sz = bsi.count;
4135 90652 : if (BUNappend(cnt, &sz, false) != GDK_SUCCEED)
4136 0 : goto bailout1;
4137 :
4138 90652 : if (BUNappend(loc, BBP_physical(bs->batCacheid), false) != GDK_SUCCEED)
4139 0 : goto bailout1;
4140 90652 : w = bsi.width;
4141 90652 : if (BUNappend(atom, &w, false) != GDK_SUCCEED)
4142 0 : goto bailout1;
4143 :
4144 90652 : sz = (lng) bsi.hfree;
4145 90652 : if (BUNappend(size, &sz, false) != GDK_SUCCEED)
4146 0 : goto bailout1;
4147 :
4148 90652 : sz = bsi.vhfree;
4149 90652 : if (BUNappend(heap, &sz, false) != GDK_SUCCEED)
4150 0 : goto bailout1;
4151 :
4152 90652 : MT_rwlock_rdlock(&bs->thashlock);
4153 : /* one lock, two values: hash size, and
4154 : * whether we (may) have a hash */
4155 90652 : sz = hashinfo(bs->thash, bs->batCacheid);
4156 90652 : bitval = bs->thash != NULL;
4157 90652 : MT_rwlock_rdunlock(&bs->thashlock);
4158 90652 : if (BUNappend(indices, &sz, false) != GDK_SUCCEED)
4159 0 : goto bailout1;
4160 :
4161 90652 : if (BUNappend(phash, &bitval, false) != GDK_SUCCEED)
4162 0 : goto bailout1;
4163 :
4164 90652 : sz = IMPSimprintsize(bs);
4165 90652 : if (BUNappend(imprints, &sz, false) != GDK_SUCCEED)
4166 0 : goto bailout1;
4167 90652 : bitval = bsi.sorted;
4168 90652 : if (!bitval && bsi.nosorted == 0)
4169 2988 : bitval = bit_nil;
4170 90652 : if (BUNappend(sort, &bitval, false) != GDK_SUCCEED)
4171 0 : goto bailout1;
4172 :
4173 90652 : bitval = bsi.revsorted;
4174 90652 : if (!bitval && bsi.norevsorted == 0)
4175 2823 : bitval = bit_nil;
4176 90652 : if (BUNappend(revsort, &bitval, false) != GDK_SUCCEED)
4177 0 : goto bailout1;
4178 :
4179 90652 : bitval = bsi.key;
4180 90652 : if (!bitval && bsi.nokey[0] == 0 && bsi.nokey[1] == 0)
4181 24850 : bitval = bit_nil;
4182 90652 : if (BUNappend(key, &bitval, false) != GDK_SUCCEED)
4183 0 : goto bailout1;
4184 :
4185 90652 : MT_lock_set(&bs->batIdxLock);
4186 90652 : sz = bs->torderidx && bs->torderidx != (Heap *) 1 ? bs->torderidx->free : 0;
4187 90652 : MT_lock_unset(&bs->batIdxLock);
4188 90652 : if (BUNappend(oidx, &sz, false) != GDK_SUCCEED)
4189 0 : goto bailout1;
4190 90652 : bat_iterator_end(&bsi);
4191 90652 : return MAL_SUCCEED;
4192 0 : bailout1:
4193 0 : bat_iterator_end(&bsi);
4194 0 : throw(SQL, "sql.storage", GDK_EXCEPTION);
4195 : }
4196 :
4197 : /*
4198 : * Inspection of the actual storage footprint is a recurring question of users.
4199 : * This is modelled as a generic SQL table producing function.
4200 : * create function storage()
4201 : * 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)
4202 : * external name sql.storage;
4203 : */
4204 : str
4205 414 : sql_storage(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4206 : {
4207 414 : BAT *sch, *tab, *col, *type, *loc, *cnt, *atom, *size, *heap, *indices, *phash, *sort, *imprints, *mode, *revsort, *key, *oidx, *bs = NULL;
4208 414 : mvc *m = NULL;
4209 414 : str msg = MAL_SUCCEED;
4210 414 : sql_trans *tr;
4211 414 : node *ncol;
4212 414 : bat *rsch = getArgReference_bat(stk, pci, 0);
4213 414 : bat *rtab = getArgReference_bat(stk, pci, 1);
4214 414 : bat *rcol = getArgReference_bat(stk, pci, 2);
4215 414 : bat *rtype = getArgReference_bat(stk, pci, 3);
4216 414 : bat *rmode = getArgReference_bat(stk, pci, 4);
4217 414 : bat *rloc = getArgReference_bat(stk, pci, 5);
4218 414 : bat *rcnt = getArgReference_bat(stk, pci, 6);
4219 414 : bat *ratom = getArgReference_bat(stk, pci, 7);
4220 414 : bat *rsize = getArgReference_bat(stk, pci, 8);
4221 414 : bat *rheap = getArgReference_bat(stk, pci, 9);
4222 414 : bat *rindices = getArgReference_bat(stk, pci, 10);
4223 414 : bat *rphash = getArgReference_bat(stk, pci, 11);
4224 414 : bat *rimprints = getArgReference_bat(stk, pci, 12);
4225 414 : bat *rsort = getArgReference_bat(stk, pci, 13);
4226 414 : bat *rrevsort = getArgReference_bat(stk, pci, 14);
4227 414 : bat *rkey = getArgReference_bat(stk, pci, 15);
4228 414 : bat *roidx = getArgReference_bat(stk, pci, 16);
4229 414 : str sname = 0;
4230 414 : str tname = 0;
4231 414 : str cname = 0;
4232 414 : struct os_iter si = {0};
4233 :
4234 414 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
4235 : return msg;
4236 414 : if ((msg = checkSQLContext(cntxt)) != NULL)
4237 : return msg;
4238 :
4239 414 : if( pci->argc - pci->retc >= 1) {
4240 53 : sname = *getArgReference_str(stk, pci, pci->retc);
4241 53 : if (strNil(sname))
4242 0 : throw(SQL, "sql.storage", SQLSTATE(42000) "Schema name cannot be NULL");
4243 : }
4244 414 : if( pci->argc - pci->retc >= 2) {
4245 53 : tname = *getArgReference_str(stk, pci, pci->retc + 1);
4246 53 : if (strNil(tname))
4247 0 : throw(SQL, "sql.storage", SQLSTATE(42000) "Table name cannot be NULL");
4248 : }
4249 414 : if( pci->argc - pci->retc >= 3) {
4250 31 : cname = *getArgReference_str(stk, pci, pci->retc + 2);
4251 31 : if (strNil(cname))
4252 0 : throw(SQL, "sql.storage", SQLSTATE(42000) "Column name cannot be NULL");
4253 : }
4254 :
4255 414 : tr = m->session->tr;
4256 414 : sqlstore *store = tr->store;
4257 414 : sch = COLnew(0, TYPE_str, 0, TRANSIENT);
4258 414 : tab = COLnew(0, TYPE_str, 0, TRANSIENT);
4259 414 : col = COLnew(0, TYPE_str, 0, TRANSIENT);
4260 414 : type = COLnew(0, TYPE_str, 0, TRANSIENT);
4261 414 : mode = COLnew(0, TYPE_str, 0, TRANSIENT);
4262 414 : loc = COLnew(0, TYPE_str, 0, TRANSIENT);
4263 414 : cnt = COLnew(0, TYPE_lng, 0, TRANSIENT);
4264 414 : atom = COLnew(0, TYPE_int, 0, TRANSIENT);
4265 414 : size = COLnew(0, TYPE_lng, 0, TRANSIENT);
4266 414 : heap = COLnew(0, TYPE_lng, 0, TRANSIENT);
4267 414 : indices = COLnew(0, TYPE_lng, 0, TRANSIENT);
4268 414 : phash = COLnew(0, TYPE_bit, 0, TRANSIENT);
4269 414 : imprints = COLnew(0, TYPE_lng, 0, TRANSIENT);
4270 414 : sort = COLnew(0, TYPE_bit, 0, TRANSIENT);
4271 414 : revsort = COLnew(0, TYPE_bit, 0, TRANSIENT);
4272 414 : key = COLnew(0, TYPE_bit, 0, TRANSIENT);
4273 414 : oidx = COLnew(0, TYPE_lng, 0, TRANSIENT);
4274 :
4275 414 : if (sch == NULL || tab == NULL || col == NULL || type == NULL || mode == NULL || loc == NULL || imprints == NULL ||
4276 414 : sort == NULL || cnt == NULL || atom == NULL || size == NULL || heap == NULL || indices == NULL || phash == NULL ||
4277 414 : revsort == NULL || key == NULL || oidx == NULL) {
4278 0 : msg = createException(SQL, "sql.storage", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4279 0 : goto bailout;
4280 : }
4281 :
4282 : /* check for limited storage tables */
4283 414 : os_iterator(&si, tr->cat->schemas, tr, NULL);
4284 3384 : for (sql_base *b = oi_next(&si); b; b = oi_next(&si)) {
4285 2970 : sql_schema *s = (sql_schema *) b;
4286 2970 : if ((sname && strcmp(b->name, sname) ) || b->name[0] == '%')
4287 732 : continue;
4288 2238 : if (s->tables) {
4289 2238 : struct os_iter oi;
4290 :
4291 2238 : os_iterator(&oi, s->tables, tr, NULL);
4292 60399 : for (sql_base *bt = oi_next(&oi); bt; bt = oi_next(&oi)) {
4293 58161 : sql_table *t = (sql_table *) bt;
4294 58161 : if( tname && strcmp(bt->name, tname) )
4295 6313 : continue;
4296 51848 : if (isTable(t)) {
4297 16470 : if (ol_first_node(t->columns)) {
4298 100276 : for (ncol = ol_first_node((t)->columns); ncol; ncol = ncol->next) {
4299 83806 : sql_base *bc = ncol->data;
4300 83806 : sql_column *c = (sql_column *) ncol->data;
4301 :
4302 83806 : if( cname && strcmp(bc->name, cname) )
4303 48 : continue;
4304 83758 : bs = store->storage_api.bind_col(tr, c, QUICK);
4305 83758 : if (bs == NULL) {
4306 0 : msg = createException(SQL, "sql.storage", SQLSTATE(HY005) "Cannot access column descriptor");
4307 0 : goto bailout;
4308 : }
4309 :
4310 167516 : msg = sql_storage_appendrow(
4311 83758 : bs, b->name, bt->name, bc->name,
4312 83758 : c->t->access, c->type.type->base.name,
4313 : sch, tab, col, type, loc, cnt, atom, size,
4314 : heap, indices, phash, sort, imprints, mode,
4315 : revsort, key, oidx);
4316 83758 : if (msg != MAL_SUCCEED)
4317 0 : goto bailout;
4318 : }
4319 : }
4320 :
4321 16470 : if (t->idxs) {
4322 23382 : for (ncol = ol_first_node((t)->idxs); ncol; ncol = ncol->next) {
4323 6912 : sql_base *bc = ncol->data;
4324 6912 : sql_idx *c = (sql_idx *) ncol->data;
4325 6912 : if (idx_has_column(c->type)) {
4326 6906 : bs = store->storage_api.bind_idx(tr, c, QUICK);
4327 :
4328 6906 : if (bs == NULL) {
4329 0 : msg = createException(SQL, "sql.storage", SQLSTATE(HY005) "Cannot access column descriptor");
4330 0 : goto bailout;
4331 : }
4332 6906 : if( cname && strcmp(bc->name, cname) )
4333 12 : continue;
4334 13788 : msg = sql_storage_appendrow(
4335 6894 : bs, b->name, bt->name, bc->name,
4336 6894 : c->t->access, "oid",
4337 : sch, tab, col, type, loc, cnt, atom, size,
4338 : heap, indices, phash, sort, imprints, mode,
4339 : revsort, key, oidx);
4340 6894 : if (msg != MAL_SUCCEED)
4341 0 : goto bailout;
4342 : }
4343 : }
4344 : }
4345 : }
4346 : }
4347 : }
4348 : }
4349 :
4350 414 : *rsch = sch->batCacheid;
4351 414 : BBPkeepref(sch);
4352 414 : *rtab = tab->batCacheid;
4353 414 : BBPkeepref(tab);
4354 414 : *rcol = col->batCacheid;
4355 414 : BBPkeepref(col);
4356 414 : *rmode = mode->batCacheid;
4357 414 : BBPkeepref(mode);
4358 414 : *rloc = loc->batCacheid;
4359 414 : BBPkeepref(loc);
4360 414 : *rtype = type->batCacheid;
4361 414 : BBPkeepref(type);
4362 414 : *rcnt = cnt->batCacheid;
4363 414 : BBPkeepref(cnt);
4364 414 : *ratom = atom->batCacheid;
4365 414 : BBPkeepref(atom);
4366 414 : *rsize = size->batCacheid;
4367 414 : BBPkeepref(size);
4368 414 : *rheap = heap->batCacheid;
4369 414 : BBPkeepref(heap);
4370 414 : *rindices = indices->batCacheid;
4371 414 : BBPkeepref(indices);
4372 414 : *rphash = phash->batCacheid;
4373 414 : BBPkeepref(phash);
4374 414 : *rimprints = imprints->batCacheid;
4375 414 : BBPkeepref(imprints);
4376 414 : *rsort = sort->batCacheid;
4377 414 : BBPkeepref(sort);
4378 414 : *rrevsort = revsort->batCacheid;
4379 414 : BBPkeepref(revsort);
4380 414 : *rkey = key->batCacheid;
4381 414 : BBPkeepref(key);
4382 414 : *roidx = oidx->batCacheid;
4383 414 : BBPkeepref(oidx);
4384 414 : return MAL_SUCCEED;
4385 :
4386 0 : bailout:
4387 0 : BBPreclaim(sch);
4388 0 : BBPreclaim(tab);
4389 0 : BBPreclaim(col);
4390 0 : BBPreclaim(mode);
4391 0 : BBPreclaim(loc);
4392 0 : BBPreclaim(cnt);
4393 0 : BBPreclaim(type);
4394 0 : BBPreclaim(atom);
4395 0 : BBPreclaim(size);
4396 0 : BBPreclaim(heap);
4397 0 : BBPreclaim(indices);
4398 0 : BBPreclaim(phash);
4399 0 : BBPreclaim(imprints);
4400 0 : BBPreclaim(sort);
4401 0 : BBPreclaim(revsort);
4402 0 : BBPreclaim(key);
4403 0 : BBPreclaim(oidx);
4404 : if (!msg)
4405 : msg = createException(SQL, "sql.storage", GDK_EXCEPTION);
4406 : return msg;
4407 : }
4408 :
4409 : void
4410 301931 : freeVariables(Client c, MalBlkPtr mb, MalStkPtr glb, int oldvtop)
4411 : {
4412 374399 : for (int i = oldvtop; i < mb->vtop;) {
4413 72468 : if (glb) {
4414 0 : if (isVarCleanup(mb, i))
4415 0 : garbageElement(c, &glb->stk[i]);
4416 : /* clean stack entry */
4417 0 : glb->stk[i].vtype = TYPE_int;
4418 0 : glb->stk[i].val.ival = 0;
4419 0 : glb->stk[i].len = 0;
4420 : }
4421 72468 : clearVariable(mb, i);
4422 72468 : i++;
4423 : }
4424 301931 : assert(oldvtop <= mb->vsize);
4425 301931 : mb->vtop = oldvtop;
4426 301931 : }
4427 :
4428 : str
4429 0 : SQLresume_log_flushing(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4430 : {
4431 0 : mvc *mvc;
4432 :
4433 0 : (void)stk; (void)pci;
4434 0 : char *msg = getSQLContext(cntxt, mb, &mvc, NULL);
4435 0 : if (msg)
4436 : return msg;
4437 0 : store_resume_log(mvc->store);
4438 0 : return MAL_SUCCEED;
4439 : }
4440 :
4441 : str
4442 0 : SQLsuspend_log_flushing(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4443 : {
4444 0 : mvc *mvc;
4445 :
4446 0 : (void)stk; (void)pci;
4447 0 : char *msg = getSQLContext(cntxt, mb, &mvc, NULL);
4448 0 : if (msg)
4449 : return msg;
4450 0 : store_suspend_log(mvc->store);
4451 0 : return MAL_SUCCEED;
4452 : }
4453 :
4454 : str
4455 : /*SQLhot_snapshot(void *ret, const str *tarfile_arg [, bool onserver ])*/
4456 5 : SQLhot_snapshot(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4457 : {
4458 5 : char *filename;
4459 5 : bool onserver;
4460 5 : char *msg = MAL_SUCCEED;
4461 5 : char buf[80];
4462 5 : mvc *mvc;
4463 5 : ssize_t sz;
4464 5 : stream *s;
4465 5 : stream *cb = NULL;
4466 5 : lng result;
4467 :
4468 5 : filename = *getArgReference_str(stk, pci, 1);
4469 5 : onserver = pci->argc == 3 ? *getArgReference_bit(stk, pci, 2) : true;
4470 :
4471 5 : msg = getSQLContext(cntxt, mb, &mvc, NULL);
4472 5 : if (msg)
4473 : return msg;
4474 :
4475 5 : sqlstore *store = mvc->session->tr->store;
4476 5 : if (onserver) {
4477 5 : lng result = store_hot_snapshot(store, filename);
4478 5 : if (result)
4479 : return MAL_SUCCEED;
4480 : else
4481 0 : throw(SQL, "sql.hot_snapshot", GDK_EXCEPTION);
4482 : }
4483 :
4484 : // sync with client, copy pasted from mvc_export_table_wrap
4485 0 : while (!mvc->scanner.rs->eof)
4486 0 : if (bstream_next(mvc->scanner.rs) < 0)
4487 0 : throw(SQL, "sql.hot_snapshot", "interrupted");
4488 :
4489 : // The snapshot code flushes from time to time.
4490 : // Use a callback stream to suppress those.
4491 0 : s = mvc->scanner.ws;
4492 0 : cb = callback_stream(
4493 : /* private */ s,
4494 : /* read */ NULL,
4495 : /* write */ (void*)mnstr_write,
4496 : /* close */ NULL,
4497 : /* destroy */ NULL,
4498 : "snapshot-callback"
4499 : );
4500 0 : if (!cb)
4501 0 : throw(SQL, "sql.hot_snapshot", GDK_EXCEPTION);
4502 :
4503 : // tell client to open file, copy pasted from mvc_export_table_wrap
4504 0 : mnstr_write(s, PROMPT3, sizeof(PROMPT3) - 1, 1);
4505 0 : mnstr_printf(s, "wb %s\n", filename);
4506 0 : mnstr_flush(s, MNSTR_FLUSH_DATA);
4507 0 : if ((sz = mnstr_readline(mvc->scanner.rs->s, buf, sizeof(buf))) > 1) {
4508 : /* non-empty line indicates failure on client */
4509 0 : msg = createException(IO, "streams.open", "%s", buf);
4510 : /* discard until client flushes */
4511 0 : while (mnstr_read(mvc->scanner.rs->s, buf, 1, sizeof(buf)) > 0) {
4512 : /* ignore remainder of error message */
4513 0 : }
4514 0 : goto end;
4515 : }
4516 :
4517 : // client is waiting for data now, send it.
4518 0 : result = store_hot_snapshot_to_stream(store, cb);
4519 0 : if (result)
4520 : msg = MAL_SUCCEED;
4521 : else
4522 0 : msg = createException(SQL, "sql.hot_snapshot", GDK_EXCEPTION);
4523 0 : mnstr_destroy(cb);
4524 :
4525 : // tell client no more data, also copy pasted from mvc_export_table_wrap
4526 0 : mnstr_flush(s, MNSTR_FLUSH_DATA);
4527 0 : if ((sz = mnstr_readline(mvc->scanner.rs->s, buf, sizeof(buf))) > 1) {
4528 0 : msg = createException(IO, "streams.open", "%s", buf);
4529 : }
4530 0 : while (sz > 0)
4531 0 : sz = mnstr_readline(mvc->scanner.rs->s, buf, sizeof(buf));
4532 :
4533 0 : end:
4534 : return msg;
4535 : }
4536 :
4537 : MT_Lock lock_persist_unlogged = MT_LOCK_INITIALIZER(lock_persist_unlogged);
4538 :
4539 : str
4540 2 : SQLpersist_unlogged(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4541 : {
4542 2 : (void)stk;
4543 2 : (void)pci;
4544 :
4545 2 : assert(pci->argc == 5);
4546 :
4547 2 : bat *o0 = getArgReference_bat(stk, pci, 0),
4548 2 : *o1 = getArgReference_bat(stk, pci, 1),
4549 2 : *o2 = getArgReference_bat(stk, pci, 2);
4550 2 : str sname = *getArgReference_str(stk, pci, 3),
4551 2 : tname = *getArgReference_str(stk, pci, 4),
4552 2 : msg = MAL_SUCCEED;
4553 :
4554 2 : mvc *m = NULL;
4555 2 : msg = getSQLContext(cntxt, mb, &m, NULL);
4556 :
4557 2 : if (msg)
4558 : return msg;
4559 :
4560 2 : sqlstore *store = store = m->session->tr->store;
4561 :
4562 2 : sql_schema *s = mvc_bind_schema(m, sname);
4563 2 : if (s == NULL)
4564 0 : throw(SQL, "sql.persist_unlogged", SQLSTATE(3F000) "Schema missing %s.", sname);
4565 :
4566 2 : if (!mvc_schema_privs(m, s))
4567 0 : throw(SQL, "sql.persist_unlogged", SQLSTATE(42000) "Access denied for %s to schema '%s'.",
4568 : get_string_global_var(m, "current_user"), s->base.name);
4569 :
4570 2 : sql_table *t = mvc_bind_table(m, s, tname);
4571 2 : if (t == NULL)
4572 0 : throw(SQL, "sql.persist_unlogged", SQLSTATE(42S02) "Table missing %s.%s", sname, tname);
4573 :
4574 2 : if (!isUnloggedTable(t) || t->access != TABLE_APPENDONLY)
4575 0 : throw(SQL, "sql.persist_unlogged", "Unlogged and Insert Only mode combination required for table %s.%s", sname, tname);
4576 :
4577 2 : lng count = 0;
4578 :
4579 2 : sql_trans *tr = m->session->tr;
4580 2 : storage *t_del = bind_del_data(tr, t, NULL);
4581 :
4582 2 : BAT *d = NULL;
4583 :
4584 2 : if (t_del)
4585 2 : d = BATdescriptor(t_del->cs.bid);
4586 2 : if (t_del == NULL || d == NULL)
4587 0 : throw(SQL, "sql.persist_unlogged", "Cannot access %s column storage.", tname);
4588 :
4589 2 : MT_lock_set(&lock_persist_unlogged);
4590 2 : BATiter d_bi = bat_iterator(d);
4591 :
4592 2 : if (BBP_status(d->batCacheid) & BBPEXISTING) {
4593 :
4594 1 : assert(d->batInserted <= d_bi.count);
4595 :
4596 1 : if (d->batInserted < d_bi.count) {
4597 1 : int n = ol_length(t->columns);
4598 :
4599 1 : bat *commit_list = GDKzalloc(sizeof(bat) * (n + 2));
4600 1 : BUN *sizes = GDKzalloc(sizeof(BUN) * (n + 2));
4601 :
4602 1 : if (commit_list == NULL || sizes == NULL) {
4603 0 : bat_iterator_end(&d_bi);
4604 0 : MT_lock_unset(&lock_persist_unlogged);
4605 0 : GDKfree(commit_list);
4606 0 : GDKfree(sizes);
4607 0 : BBPreclaim(d);
4608 0 : throw(SQL, "sql.persist_unlogged", SQLSTATE(HY001));
4609 : }
4610 :
4611 1 : commit_list[0] = 0;
4612 1 : sizes[0] = 0;
4613 1 : int i = 1;
4614 :
4615 2 : for (node *ncol = ol_first_node(t->columns); ncol; ncol = ncol->next, i++) {
4616 :
4617 1 : sql_column *c = (sql_column *) ncol->data;
4618 1 : BAT *b = store->storage_api.bind_col(tr, c, QUICK);
4619 :
4620 1 : if (b == NULL) {
4621 0 : bat_iterator_end(&d_bi);
4622 0 : MT_lock_unset(&lock_persist_unlogged);
4623 0 : GDKfree(commit_list);
4624 0 : GDKfree(sizes);
4625 0 : BBPreclaim(d);
4626 0 : throw(SQL, "sql.persist_unlogged", "Cannot access column descriptor.");
4627 : }
4628 :
4629 1 : commit_list[i] = b->batCacheid;
4630 1 : sizes[i] = d_bi.count;
4631 : }
4632 :
4633 1 : assert(i<n+2);
4634 1 : commit_list[i] = d->batCacheid;
4635 1 : sizes[i] = d_bi.count;
4636 1 : i++;
4637 :
4638 1 : if (TMsubcommit_list(commit_list, sizes, i, -1) != GDK_SUCCEED) {
4639 0 : bat_iterator_end(&d_bi);
4640 0 : MT_lock_unset(&lock_persist_unlogged);
4641 0 : GDKfree(commit_list);
4642 0 : GDKfree(sizes);
4643 0 : BBPreclaim(d);
4644 0 : throw(SQL, "sql.persist_unlogged", "Lower level commit operation failed");
4645 : }
4646 :
4647 1 : GDKfree(commit_list);
4648 1 : GDKfree(sizes);
4649 : }
4650 1 : count = d_bi.count;
4651 : } else {
4652 : /* special case of log_tstart: third arg == NULL with second arg
4653 : * true is request to rotate log file ASAP */
4654 1 : store->logger_api.log_tstart(store, true, NULL);
4655 : /* special case for sql->debug: if 1024 bit is set,
4656 : * store_manager doesn't wait for 30 seconds of idle time before
4657 : * attempting to rotate */
4658 1 : MT_lock_set(&store->flush);
4659 1 : store->debug |= 1024;
4660 1 : MT_lock_unset(&store->flush);
4661 : }
4662 :
4663 2 : bat_iterator_end(&d_bi);
4664 2 : MT_lock_unset(&lock_persist_unlogged);
4665 2 : BBPreclaim(d);
4666 :
4667 2 : BAT *table = COLnew(0, TYPE_str, 0, TRANSIENT),
4668 2 : *tableid = COLnew(0, TYPE_int, 0, TRANSIENT),
4669 2 : *rowcount = COLnew(0, TYPE_lng, 0, TRANSIENT);
4670 :
4671 4 : if (table == NULL || tableid == NULL || rowcount == NULL ||
4672 4 : BUNappend(table, tname, false) != GDK_SUCCEED ||
4673 4 : BUNappend(tableid, &(t->base.id), false) != GDK_SUCCEED ||
4674 2 : BUNappend(rowcount, &count, false) != GDK_SUCCEED) {
4675 0 : BBPnreclaim(3, table, tableid, rowcount);
4676 0 : throw(SQL, "sql.persist_unlogged", SQLSTATE(HY001));
4677 : }
4678 2 : *o0 = table->batCacheid;
4679 2 : *o1 = tableid->batCacheid;
4680 2 : *o2 = rowcount->batCacheid;
4681 2 : BBPkeepref(table);
4682 2 : BBPkeepref(tableid);
4683 2 : BBPkeepref(rowcount);
4684 2 : return msg;
4685 : }
4686 :
4687 : str
4688 9 : SQLsession_prepared_statements(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4689 : {
4690 9 : BAT *sessionid, *user, *statementid, *statement, *created;
4691 9 : bat *sid = getArgReference_bat(stk,pci,0);
4692 9 : bat *u = getArgReference_bat(stk,pci,1);
4693 9 : bat *i = getArgReference_bat(stk,pci,2);
4694 9 : bat *s = getArgReference_bat(stk,pci,3);
4695 9 : bat *c = getArgReference_bat(stk,pci,4);
4696 9 : str msg = MAL_SUCCEED;
4697 9 : mvc *sql = NULL;
4698 9 : cq *q = NULL;
4699 :
4700 9 : (void) stk;
4701 9 : (void) pci;
4702 9 : if ((msg = getSQLContext(cntxt, mb, &sql, NULL)) != NULL)
4703 : return msg;
4704 9 : if ((msg = checkSQLContext(cntxt)) != NULL)
4705 : return msg;
4706 :
4707 9 : assert(sql->qc);
4708 :
4709 9 : sessionid = COLnew(0, TYPE_int, 256, TRANSIENT);
4710 9 : user = COLnew(0, TYPE_str, 256, TRANSIENT);
4711 9 : statementid = COLnew(0, TYPE_int, 256, TRANSIENT);
4712 9 : statement = COLnew(0, TYPE_str, 256, TRANSIENT);
4713 9 : created = COLnew(0, TYPE_timestamp, 256, TRANSIENT);
4714 9 : if (sessionid == NULL || user == NULL || statementid == NULL || statement == NULL || created == NULL) {
4715 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4716 0 : goto bailout;
4717 : }
4718 :
4719 13 : for (q = sql->qc->q; q; q = q->next) {
4720 4 : gdk_return bun_res;
4721 4 : if (BUNappend(sessionid, &(cntxt->idx), false) != GDK_SUCCEED) {
4722 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4723 0 : goto bailout;
4724 : }
4725 :
4726 4 : if (msg != MAL_SUCCEED)
4727 : goto bailout;
4728 4 : bun_res = BUNappend(user, cntxt->username, false);
4729 4 : if (bun_res != GDK_SUCCEED) {
4730 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4731 0 : goto bailout;
4732 : }
4733 :
4734 4 : if (BUNappend(statementid, &(q->id), false) != GDK_SUCCEED) {
4735 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4736 0 : goto bailout;
4737 : }
4738 4 : if (BUNappend(statement, q->f->query, false) != GDK_SUCCEED) {
4739 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4740 0 : goto bailout;
4741 : }
4742 4 : if (BUNappend(created, &(q->created), false) != GDK_SUCCEED) {
4743 0 : msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
4744 0 : goto bailout;
4745 : }
4746 : }
4747 :
4748 9 : bailout:
4749 0 : if (msg) {
4750 0 : BBPreclaim(sessionid);
4751 0 : BBPreclaim(user);
4752 0 : BBPreclaim(statementid);
4753 0 : BBPreclaim(statement);
4754 0 : BBPreclaim(created);
4755 : } else {
4756 9 : *sid = sessionid->batCacheid;
4757 9 : BBPkeepref(sessionid);
4758 9 : *u = user->batCacheid;
4759 9 : BBPkeepref(user);
4760 9 : *i = statementid->batCacheid;
4761 9 : BBPkeepref(statementid);
4762 9 : *s = statement->batCacheid;
4763 9 : BBPkeepref(statement);
4764 9 : *c = created->batCacheid;
4765 9 : BBPkeepref(created);
4766 : }
4767 : return msg;
4768 : }
4769 :
4770 : str
4771 6 : SQLsession_prepared_statements_args(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4772 : {
4773 6 : BAT *statementid, *type, *digits, *isinout, *number, *scale, *schema, *table, *column;
4774 6 : bat *sid = getArgReference_bat(stk,pci,0);
4775 6 : bat *t = getArgReference_bat(stk,pci,1);
4776 6 : bat *d = getArgReference_bat(stk,pci,2);
4777 6 : bat *s = getArgReference_bat(stk,pci,3);
4778 6 : bat *io = getArgReference_bat(stk,pci,4);
4779 6 : bat *n = getArgReference_bat(stk,pci,5);
4780 6 : bat *sch = getArgReference_bat(stk,pci,6);
4781 6 : bat *tbl = getArgReference_bat(stk,pci,7);
4782 6 : bat *col = getArgReference_bat(stk,pci,8);
4783 6 : str msg = MAL_SUCCEED;
4784 6 : mvc *sql = NULL;
4785 6 : cq *q = NULL;
4786 :
4787 6 : (void) stk;
4788 6 : (void) pci;
4789 6 : if ((msg = getSQLContext(cntxt, mb, &sql, NULL)) != NULL)
4790 : return msg;
4791 6 : if ((msg = checkSQLContext(cntxt)) != NULL)
4792 : return msg;
4793 :
4794 6 : assert(sql->qc);
4795 :
4796 6 : statementid = COLnew(0, TYPE_int, 256, TRANSIENT);
4797 6 : type = COLnew(0, TYPE_str, 256, TRANSIENT);
4798 6 : digits = COLnew(0, TYPE_int, 256, TRANSIENT);
4799 6 : scale = COLnew(0, TYPE_int, 256, TRANSIENT);
4800 6 : isinout = COLnew(0, TYPE_bte, 256, TRANSIENT);
4801 6 : number = COLnew(0, TYPE_int, 256, TRANSIENT);
4802 6 : schema = COLnew(0, TYPE_str, 256, TRANSIENT);
4803 6 : table = COLnew(0, TYPE_str, 256, TRANSIENT);
4804 6 : column = COLnew(0, TYPE_str, 256, TRANSIENT);
4805 6 : if (!statementid || !type || !digits || !scale || !isinout || !number || !schema || !table || !column) {
4806 0 : msg = createException(SQL, "sql.session_prepared_statements_args", GDK_EXCEPTION);
4807 0 : goto bailout;
4808 : }
4809 :
4810 9 : for (q = sql->qc->q; q; q = q->next) {
4811 3 : sql_rel *r = q->rel;
4812 3 : int arg_number = 0;
4813 3 : bte inout = ARG_OUT;
4814 :
4815 3 : if (r && (is_topn(r->op) || is_sample(r->op)))
4816 0 : r = r->l;
4817 :
4818 3 : if (r && is_project(r->op) && r->exps) {
4819 6 : for (node *n = r->exps->h; n; n = n->next, arg_number++) {
4820 3 : sql_exp *e = n->data;
4821 3 : sql_subtype *t = exp_subtype(e);
4822 3 : const char *name = exp_name(e), *rname = exp_relname(e), *rschema = ATOMnilptr(TYPE_str);
4823 :
4824 3 : if (!name && e->type == e_column && e->r)
4825 0 : name = e->r;
4826 0 : if (!name)
4827 0 : name = ATOMnilptr(TYPE_str);
4828 3 : if (!rname && e->type == e_column && e->l)
4829 0 : rname = e->l;
4830 0 : if (!rname)
4831 0 : rname = ATOMnilptr(TYPE_str);
4832 :
4833 6 : if (BUNappend(statementid, &(q->id), false) != GDK_SUCCEED ||
4834 6 : BUNappend(type, t->type->base.name, false) != GDK_SUCCEED ||
4835 6 : BUNappend(digits, &t->digits, false) != GDK_SUCCEED ||
4836 6 : BUNappend(scale, &t->scale, false) != GDK_SUCCEED ||
4837 6 : BUNappend(isinout, &inout, false) != GDK_SUCCEED ||
4838 6 : BUNappend(number, &arg_number, false) != GDK_SUCCEED ||
4839 6 : BUNappend(schema, rschema, false) != GDK_SUCCEED ||
4840 6 : BUNappend(table, rname, false) != GDK_SUCCEED ||
4841 3 : BUNappend(column, name, false) != GDK_SUCCEED) {
4842 0 : msg = createException(SQL, "sql.session_prepared_statements_args", GDK_EXCEPTION);
4843 0 : goto bailout;
4844 : }
4845 : }
4846 : }
4847 :
4848 3 : if (q->f->ops) {
4849 3 : inout = ARG_IN;
4850 6 : for (node *n = q->f->ops->h; n; n=n->next, arg_number++) {
4851 3 : sql_arg *a = n->data;
4852 3 : sql_subtype *t = &a->type;
4853 :
4854 6 : if (BUNappend(statementid, &(q->id), false) != GDK_SUCCEED ||
4855 6 : BUNappend(type, t->type->base.name, false) != GDK_SUCCEED ||
4856 6 : BUNappend(digits, &(t->digits), false) != GDK_SUCCEED ||
4857 6 : BUNappend(scale, &(t->scale), false) != GDK_SUCCEED ||
4858 6 : BUNappend(isinout, &inout, false) != GDK_SUCCEED ||
4859 6 : BUNappend(number, &arg_number, false) != GDK_SUCCEED ||
4860 6 : BUNappend(schema, ATOMnilptr(TYPE_str), false) != GDK_SUCCEED ||
4861 6 : BUNappend(table, ATOMnilptr(TYPE_str), false) != GDK_SUCCEED ||
4862 3 : BUNappend(column, ATOMnilptr(TYPE_str), false) != GDK_SUCCEED) {
4863 0 : msg = createException(SQL, "sql.session_prepared_statements_args", GDK_EXCEPTION);
4864 0 : goto bailout;
4865 : }
4866 : }
4867 : }
4868 : }
4869 :
4870 6 : bailout:
4871 0 : if (msg) {
4872 0 : BBPreclaim(statementid);
4873 0 : BBPreclaim(type);
4874 0 : BBPreclaim(digits);
4875 0 : BBPreclaim(scale);
4876 0 : BBPreclaim(isinout);
4877 0 : BBPreclaim(number);
4878 0 : BBPreclaim(schema);
4879 0 : BBPreclaim(table);
4880 0 : BBPreclaim(column);
4881 : } else {
4882 6 : *sid = statementid->batCacheid;
4883 6 : BBPkeepref(statementid);
4884 6 : *t = type->batCacheid;
4885 6 : BBPkeepref(type);
4886 6 : *d = digits->batCacheid;
4887 6 : BBPkeepref(digits);
4888 6 : *s = scale->batCacheid;
4889 6 : BBPkeepref(scale);
4890 6 : *io = isinout->batCacheid;
4891 6 : BBPkeepref(isinout);
4892 6 : *n = number->batCacheid;
4893 6 : BBPkeepref(number);
4894 6 : *sch = schema->batCacheid;
4895 6 : BBPkeepref(schema);
4896 6 : *tbl = table->batCacheid;
4897 6 : BBPkeepref(table);
4898 6 : *col = column->batCacheid;
4899 6 : BBPkeepref(column);
4900 : }
4901 : return msg;
4902 : }
4903 :
4904 : /* input id, row-input-values
4905 : * for each id call function(with row-input-values) return table
4906 : * return for each id the table, ie id (*length of table) and table results
4907 : */
4908 : str
4909 23 : SQLunionfunc(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
4910 : {
4911 23 : int arg = pci->retc;
4912 23 : str mod, fcn, ret = MAL_SUCCEED;
4913 23 : InstrPtr npci;
4914 23 : MalBlkPtr nmb = newMalBlk(1), omb = NULL;
4915 :
4916 23 : if (!nmb)
4917 0 : return createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4918 23 : mod = *getArgReference_str(stk, pci, arg++);
4919 23 : fcn = *getArgReference_str(stk, pci, arg++);
4920 23 : npci = newStmtArgs(nmb, mod, fcn, pci->argc);
4921 23 : if (npci == NULL) {
4922 0 : freeMalBlk(nmb);
4923 0 : return createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4924 : }
4925 :
4926 46 : for (int i = 1; i < pci->retc; i++) {
4927 23 : int type = getArgType(mb, pci, i);
4928 :
4929 23 : if (i==1)
4930 23 : getArg(npci, 0) = newTmpVariable(nmb, type);
4931 : else
4932 0 : npci = pushReturn(nmb, npci, newTmpVariable(nmb, type));
4933 : }
4934 60 : for (int i = pci->retc+2+1; i < pci->argc; i++) {
4935 37 : int type = getBatType(getArgType(mb, pci, i));
4936 :
4937 37 : npci = pushNil(nmb, npci, type);
4938 : }
4939 23 : pushInstruction(nmb, npci);
4940 : /* check program to get the proper malblk */
4941 23 : if (chkInstruction(cntxt->usermodule, nmb, npci)) {
4942 0 : freeMalBlk(nmb);
4943 0 : return createException(MAL, "sql.unionfunc", SQLSTATE(42000) PROGRAM_GENERAL);
4944 : }
4945 :
4946 23 : if (npci) {
4947 23 : BAT **res = NULL, **input = NULL;
4948 23 : BATiter *bi = NULL;
4949 23 : BUN cnt = 0;
4950 23 : int nrinput = pci->argc - 2 - pci->retc;
4951 23 : MalStkPtr env = NULL;
4952 23 : InstrPtr q = NULL;
4953 :
4954 23 : if (!(input = GDKzalloc(sizeof(BAT*) * nrinput))) {
4955 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4956 0 : goto finalize;
4957 : }
4958 23 : if (!(bi = GDKmalloc(sizeof(BATiter) * nrinput))) {
4959 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4960 0 : goto finalize;
4961 : }
4962 23 : assert(pci->retc + 2 + nrinput == pci->argc);
4963 83 : for (int i = 0, j = pci->retc+2; j < pci->argc; i++, j++) {
4964 60 : bat *b = getArgReference_bat(stk, pci, j);
4965 60 : if (!(input[i] = BATdescriptor(*b))) {
4966 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY005) "Cannot access column descriptor");
4967 0 : while (i > 0) {
4968 0 : i--;
4969 0 : bat_iterator_end(&bi[i]);
4970 0 : BBPunfix(input[i]->batCacheid);
4971 : }
4972 0 : GDKfree(input);
4973 0 : input = NULL;
4974 0 : goto finalize;
4975 : }
4976 60 : bi[i] = bat_iterator(input[i]);
4977 60 : cnt = BATcount(input[i]);
4978 : }
4979 :
4980 : /* create result bats */
4981 23 : if (!(res = GDKzalloc(sizeof(BAT*) * pci->retc))) {
4982 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4983 0 : goto finalize;
4984 : }
4985 69 : for (int i = 0; i<pci->retc; i++) {
4986 46 : int type = getArgType(mb, pci, i);
4987 :
4988 46 : if (!(res[i] = COLnew(0, getBatType(type), cnt, TRANSIENT))) {
4989 0 : ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
4990 0 : goto finalize;
4991 : }
4992 : }
4993 :
4994 23 : if (npci->blk && npci->blk->stop > 1) {
4995 11 : omb = nmb;
4996 11 : if (!(nmb = copyMalBlk(npci->blk))) {
4997 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
4998 0 : goto finalize;
4999 : }
5000 : }
5001 23 : if (!(env = prepareMALstack(nmb, nmb->vsize))) { /* needed for result */
5002 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5003 0 : goto finalize;
5004 : }
5005 23 : q = getInstrPtr(nmb, 0);
5006 :
5007 23 : int start = 1;
5008 23 : if (nmb->stop == 1 && (omb || !npci->fcn || npci->token != PATcall)) {
5009 0 : InstrPtr *stmt = nmb->stmt;
5010 0 : nmb->stmt = (InstrPtr*)GDKmalloc(sizeof(InstrPtr*)*3);
5011 0 : nmb->stmt[0] = NULL; /* no main() */
5012 0 : nmb->stmt[1] = NULL; /* no profiling */
5013 0 : nmb->stmt[2] = stmt[0];
5014 0 : nmb->stop = nmb->ssize = 3;
5015 0 : GDKfree(stmt);
5016 0 : start = 2;
5017 : }
5018 83 : for (BUN cur = 0; cur<cnt && !ret; cur++ ) {
5019 60 : MalStkPtr nstk = prepareMALstack(nmb, nmb->vsize);
5020 60 : int i,ii;
5021 :
5022 60 : if (!nstk) { /* needed for result */
5023 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5024 : } else {
5025 : /* copy (input) arguments onto destination stack, skipping rowid col */
5026 135 : for (i = 1, ii = q->retc; ii < q->argc && !ret; ii++, i++) {
5027 75 : ValPtr lhs = &nstk->stk[q->argv[ii]];
5028 75 : ptr rhs = (ptr)BUNtail(bi[i], cur);
5029 :
5030 75 : if (VALset(lhs, input[i]->ttype, rhs) == NULL)
5031 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5032 : }
5033 60 : if (!ret && ii == q->argc) {
5034 60 : BAT *fres = NULL;
5035 60 : if (!omb && npci->fcn && npci->token == PATcall) /* pattern */
5036 15 : ret = (*(str (*)(Client, MalBlkPtr, MalStkPtr, InstrPtr))npci->fcn)(cntxt, nmb, nstk, npci);
5037 : else
5038 45 : ret = runMALsequence(cntxt, nmb, start, nmb->stop, nstk, env /* copy result in nstk first instruction*/, q);
5039 :
5040 60 : if (!ret) {
5041 : /* insert into result */
5042 60 : if (!(fres = BBPquickdesc(omb?env->stk[q->argv[0]].val.bval:nstk->stk[q->argv[0]].val.bval))) {
5043 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY005) "Cannot access column descriptor");
5044 : } else {
5045 60 : BAT *p = BATconstant(fres->hseqbase, res[0]->ttype, (ptr)BUNtail(bi[0], cur), BATcount(fres), TRANSIENT);
5046 :
5047 60 : if (p) {
5048 60 : if (BATappend(res[0], p, NULL, FALSE) != GDK_SUCCEED)
5049 0 : ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
5050 60 : BBPunfix(p->batCacheid);
5051 : } else {
5052 0 : ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
5053 : }
5054 : }
5055 : i=1;
5056 120 : for (ii = 0; i < pci->retc && !ret; ii++, i++) {
5057 60 : BAT *b;
5058 60 : ValPtr vp = omb ? env->stk + q->argv[ii] : nstk->stk + q->argv[ii];
5059 :
5060 60 : if (!(b = BATdescriptor(vp->val.bval)))
5061 0 : ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
5062 60 : else if (BATappend(res[i], b, NULL, FALSE) != GDK_SUCCEED)
5063 0 : ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
5064 60 : if (b) {
5065 60 : BBPrelease(b->batCacheid); /* release ref from env stack */
5066 60 : BBPunfix(b->batCacheid); /* free pointer */
5067 60 : VALempty(vp);
5068 : }
5069 : }
5070 : }
5071 : }
5072 60 : freeStack(nstk);
5073 : }
5074 : }
5075 23 : finalize:
5076 23 : freeStack(env);
5077 23 : if (nmb)
5078 23 : freeMalBlk(nmb);
5079 23 : if (omb)
5080 11 : freeMalBlk(omb);
5081 23 : if (res)
5082 69 : for (int i = 0; i<pci->retc; i++) {
5083 46 : bat *b = getArgReference_bat(stk, pci, i);
5084 46 : if (res[i]) {
5085 46 : *b = res[i]->batCacheid;
5086 46 : if (ret)
5087 0 : BBPunfix(*b);
5088 : else
5089 46 : BBPkeepref(res[i]);
5090 : }
5091 : }
5092 23 : GDKfree(res);
5093 23 : if (input) {
5094 83 : for (int i = 0; i<nrinput; i++) {
5095 60 : if (input[i]) {
5096 60 : bat_iterator_end(&bi[i]);
5097 60 : BBPunfix(input[i]->batCacheid);
5098 : }
5099 : }
5100 23 : GDKfree(input);
5101 : }
5102 23 : GDKfree(bi);
5103 : }
5104 : return ret;
5105 : }
5106 :
5107 : static str
5108 9 : do_str_column_vacuum(sql_trans *tr, sql_column *c, char *sname, char *tname, char *cname)
5109 : {
5110 9 : int res;
5111 9 : int access = 0;
5112 9 : BAT* b = NULL;
5113 9 : BAT* bn = NULL;
5114 9 : sqlstore *store = tr->store;
5115 :
5116 9 : if ((b = store->storage_api.bind_col(tr, c, access)) == NULL)
5117 0 : throw(SQL, "do_str_column_vacuum", SQLSTATE(42S22) "storage_api.bind_col failed for %s.%s.%s", sname, tname, cname);
5118 : // vacuum varsized bats
5119 9 : if (ATOMvarsized(c->type.type->localtype)) {
5120 : // TODO check for num of updates on the BAT against some threshold
5121 : // and decide whether to proceed
5122 5 : if ((bn = COLcopy(b, b->ttype, true, PERSISTENT)) == NULL) {
5123 0 : BBPunfix(b->batCacheid);
5124 0 : throw(SQL, "do_str_column_vacuum", SQLSTATE(42S22) "COLcopy failed for %s.%s.%s", sname, tname, cname);
5125 : }
5126 5 : if ((res = (int) store->storage_api.swap_bats(tr, c, bn)) != LOG_OK) {
5127 0 : BBPreclaim(bn);
5128 0 : BBPunfix(b->batCacheid);
5129 0 : if (res == LOG_CONFLICT)
5130 0 : throw(SQL, "do_str_column_vacuum", SQLSTATE(25S01) "TRANSACTION CONFLICT in storage_api.swap_bats %s.%s.%s", sname, tname, cname);
5131 0 : if (res == LOG_ERR)
5132 0 : throw(SQL, "do_str_column_vacuum", SQLSTATE(HY000) "LOG ERROR in storage_api.swap_bats %s.%s.%s", sname, tname, cname);
5133 0 : throw(SQL, "do_str_column_vacuum", SQLSTATE(HY000) "ERROR in storage_api.swap_bats %s.%s.%s", sname, tname, cname);
5134 : }
5135 : }
5136 9 : BBPunfix(b->batCacheid);
5137 9 : BBPreclaim(bn);
5138 : return MAL_SUCCEED;
5139 : }
5140 :
5141 : str
5142 9 : SQLstr_column_vacuum(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5143 : {
5144 9 : mvc *m = NULL;
5145 9 : str msg = NULL;
5146 9 : char *sname = *getArgReference_str(stk, pci, 1);
5147 9 : char *tname = *getArgReference_str(stk, pci, 2);
5148 9 : char *cname = *getArgReference_str(stk, pci, 3);
5149 :
5150 9 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5151 : return msg;
5152 9 : if ((msg = checkSQLContext(cntxt)) != NULL)
5153 : return msg;
5154 :
5155 9 : sql_trans *tr = m->session->tr;
5156 9 : sql_schema *s = NULL;
5157 9 : sql_table *t = NULL;
5158 9 : sql_column *c = NULL;
5159 :
5160 9 : if (strNil(sname))
5161 0 : throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "Schema name cannot be NULL");
5162 9 : if (strNil(tname))
5163 0 : throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "Table name cannot be NULL");
5164 9 : if (strNil(cname))
5165 0 : throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "Column name cannot be NULL");
5166 9 : if ((s = mvc_bind_schema(m, sname)) == NULL)
5167 0 : throw(SQL, "sql.str_column_vacuum", SQLSTATE(3F000) "Invalid or missing schema %s",sname);
5168 9 : if ((t = mvc_bind_table(m, s, tname)) == NULL)
5169 0 : throw(SQL, "sql.str_column_vacuum", SQLSTATE(42S02) "Invalid or missing table %s.%s",sname,tname);
5170 9 : if (!isTable(t))
5171 0 : throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "%s '%s' is not persistent",
5172 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
5173 9 : if (isTempTable(t))
5174 0 : throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "Cannot vacuum column from temporary table");
5175 9 : if ((c = mvc_bind_column(m, t, cname)) == NULL)
5176 0 : throw(SQL, "sql.str_column_vacuum", SQLSTATE(42S22) "Column not found in %s.%s.%s",sname,tname,cname);
5177 9 : if (c->storage_type)
5178 0 : throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "Cannot vacuum compressed column");
5179 :
5180 9 : return do_str_column_vacuum(tr, c, sname, tname, cname);
5181 : }
5182 :
5183 :
5184 : static gdk_return
5185 0 : str_column_vacuum_callback(int argc, void *argv[]) {
5186 0 : sqlstore *store = (sqlstore *) argv[0];
5187 0 : char *sname = (char *) argv[1];
5188 0 : char *tname = (char *) argv[2];
5189 0 : char *cname = (char *) argv[3];
5190 0 : allocator *sa = NULL;
5191 0 : sql_session *session = NULL;
5192 0 : sql_schema *s = NULL;
5193 0 : sql_table *t = NULL;
5194 0 : sql_column *c = NULL;
5195 0 : char *msg;
5196 0 : gdk_return res = GDK_SUCCEED;
5197 :
5198 0 : (void) argc;
5199 :
5200 0 : if ((sa = sa_create(NULL)) == NULL) {
5201 0 : TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Failed to create allocator!");
5202 0 : return GDK_FAIL;
5203 : }
5204 :
5205 0 : if ((session = sql_session_create(store, sa, 0)) == NULL) {
5206 0 : TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Failed to create session!");
5207 0 : sa_destroy(sa);
5208 0 : return GDK_FAIL;
5209 : }
5210 :
5211 0 : if (sql_trans_begin(session) < 0) {
5212 0 : TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Failed to begin transaction!");
5213 0 : sql_session_destroy(session);
5214 0 : sa_destroy(sa);
5215 0 : return GDK_FAIL;
5216 : }
5217 :
5218 0 : do {
5219 0 : if((s = find_sql_schema(session->tr, sname)) == NULL) {
5220 0 : TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Invalid or missing schema %s!",sname);
5221 0 : res = GDK_FAIL;
5222 0 : break;
5223 : }
5224 :
5225 0 : if((t = find_sql_table(session->tr, s, tname)) == NULL) {
5226 0 : TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Invalid or missing table %s!", tname);
5227 0 : res = GDK_FAIL;
5228 0 : break;
5229 : }
5230 :
5231 0 : if ((c = find_sql_column(t, cname)) == NULL) {
5232 0 : TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Invalid or missing column %s!", cname);
5233 0 : res = GDK_FAIL;
5234 0 : break;
5235 : }
5236 :
5237 0 : if((msg=do_str_column_vacuum(session->tr, c, sname, tname, cname)) != MAL_SUCCEED) {
5238 0 : TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- %s", msg);
5239 0 : res = GDK_FAIL;
5240 : }
5241 :
5242 : } while(0);
5243 :
5244 0 : if (res == GDK_SUCCEED) { /* everything is ok, do the commit route */
5245 0 : switch (sql_trans_end(session, SQL_OK)) {
5246 0 : case SQL_ERR:
5247 0 : TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- transaction commit failed (kernel error: %s)", GDKerrbuf);
5248 0 : res = GDK_FAIL;
5249 0 : break;
5250 0 : case SQL_CONFLICT:
5251 0 : TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- transaction is aborted because of concurrency conflicts, will ROLLBACK instead");
5252 0 : res = GDK_FAIL;
5253 0 : break;
5254 : default:
5255 : break;
5256 : }
5257 : } else { /* an error triggered, rollback and ignore further errors */
5258 0 : (void)sql_trans_end(session, SQL_ERR);
5259 : }
5260 :
5261 0 : sql_session_destroy(session);
5262 0 : sa_destroy(sa);
5263 0 : return res;
5264 : }
5265 :
5266 : static gdk_return
5267 0 : str_column_vacuum_callback_args_free(int argc, void *argv[])
5268 : {
5269 0 : (void) argc;
5270 : // free up sname, tname, cname. First pointer points to sqlstore so leave it.
5271 0 : GDKfree(argv[1]); // sname
5272 0 : GDKfree(argv[2]); // tname
5273 0 : GDKfree(argv[3]); // cname
5274 0 : return GDK_SUCCEED;
5275 : }
5276 :
5277 : str
5278 0 : SQLstr_column_auto_vacuum(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5279 : {
5280 0 : mvc *m = NULL;
5281 0 : str msg = NULL;
5282 0 : char *sname = *getArgReference_str(stk, pci, 1);
5283 0 : char *tname = *getArgReference_str(stk, pci, 2);
5284 0 : char *cname = *getArgReference_str(stk, pci, 3);
5285 0 : int interval = *getArgReference_int(stk, pci, 4); // in sec
5286 0 : char *sname_copy = NULL, *tname_copy = NULL, *cname_copy = NULL;
5287 :
5288 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5289 : return msg;
5290 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
5291 : return msg;
5292 :
5293 0 : sql_schema *s = NULL;
5294 0 : sql_table *t = NULL;
5295 0 : sql_column *c = NULL;
5296 :
5297 0 : if (strNil(sname))
5298 0 : throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "Schema name cannot be NULL");
5299 0 : if (strNil(tname))
5300 0 : throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "Table name cannot be NULL");
5301 0 : if (strNil(cname))
5302 0 : throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "Column name cannot be NULL");
5303 0 : if ((s = mvc_bind_schema(m, sname)) == NULL)
5304 0 : throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(3F000) "Invalid or missing schema %s",sname);
5305 0 : if ((t = mvc_bind_table(m, s, tname)) == NULL)
5306 0 : throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42S02) "Invalid or missing table %s.%s",sname,tname);
5307 0 : if (!isTable(t))
5308 0 : throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "%s '%s' is not persistent",
5309 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
5310 0 : if (isTempTable(t))
5311 0 : throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "Cannot vacuum column from temporary table");
5312 0 : if ((c = mvc_bind_column(m, t, cname)) == NULL)
5313 0 : throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42S22) "Column not found in %s.%s.%s",sname,tname,cname);
5314 0 : if (c->storage_type)
5315 0 : throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "Cannot vacuum compressed column");
5316 :
5317 0 : if (!(sname_copy = GDKstrdup(sname)) || !(tname_copy = GDKstrdup(tname)) || !(cname_copy = GDKstrdup(cname))) {
5318 0 : GDKfree(sname_copy);
5319 0 : GDKfree(tname_copy);
5320 0 : GDKfree(cname_copy);
5321 0 : throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5322 : }
5323 0 : void *argv[4] = {m->store, sname_copy, tname_copy, cname_copy};
5324 :
5325 0 : if (gdk_add_callback("str_column_vacuum", str_column_vacuum_callback, 4, argv, interval) != GDK_SUCCEED) {
5326 0 : str_column_vacuum_callback_args_free(4, argv);
5327 0 : throw(SQL, "sql.str_column_auto_vacuum", "adding vacuum callback failed!");
5328 : }
5329 :
5330 : return MAL_SUCCEED;
5331 : }
5332 :
5333 : str
5334 0 : SQLstr_column_stop_vacuum(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5335 : {
5336 0 : mvc *m = NULL;
5337 0 : str msg = NULL;
5338 0 : char *sname = *getArgReference_str(stk, pci, 1);
5339 0 : char *tname = *getArgReference_str(stk, pci, 2);
5340 0 : char *cname = *getArgReference_str(stk, pci, 3);
5341 :
5342 0 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5343 : return msg;
5344 0 : if ((msg = checkSQLContext(cntxt)) != NULL)
5345 : return msg;
5346 :
5347 0 : sql_schema *s = NULL;
5348 0 : sql_table *t = NULL;
5349 0 : sql_column *c = NULL;
5350 :
5351 0 : if (strNil(sname))
5352 0 : throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42000) "Schema name cannot be NULL");
5353 0 : if (strNil(tname))
5354 0 : throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42000) "Table name cannot be NULL");
5355 0 : if (strNil(cname))
5356 0 : throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42000) "Column name cannot be NULL");
5357 0 : if ((s = mvc_bind_schema(m, sname)) == NULL)
5358 0 : throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(3F000) "Invalid or missing schema %s",sname);
5359 0 : if ((t = mvc_bind_table(m, s, tname)) == NULL)
5360 0 : throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42S02) "Invalid or missing table %s.%s",sname,tname);
5361 0 : if (!isTable(t))
5362 0 : throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42000) "%s '%s' is not persistent",
5363 0 : TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
5364 0 : if (isTempTable(t))
5365 0 : throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42000) "Cannot vacuum column from temporary table");
5366 0 : if ((c = mvc_bind_column(m, t, cname)) == NULL)
5367 0 : throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42S22) "Column not found in %s.%s.%s",sname,tname,cname);
5368 :
5369 0 : if(gdk_remove_callback("str_column_vacuum", str_column_vacuum_callback_args_free) != GDK_SUCCEED)
5370 0 : throw(SQL, "sql.str_column_stop_vacuum", "removing vacuum callback failed!");
5371 :
5372 : return MAL_SUCCEED;
5373 : }
5374 :
5375 :
5376 : #include "sql_cat.h"
5377 : #include "sql_rank.h"
5378 : #include "sql_user.h"
5379 : #include "sql_assert.h"
5380 : #include "sql_execute.h"
5381 : #include "sql_orderidx.h"
5382 : #include "sql_strimps.h"
5383 : #include "sql_subquery.h"
5384 : #include "sql_statistics.h"
5385 : #include "sql_transaction.h"
5386 : #include "for.h"
5387 : #include "dict.h"
5388 : #include "mel.h"
5389 :
5390 :
5391 : static str
5392 51 : SQLuser_password(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5393 : {
5394 51 : mvc *m = NULL;
5395 51 : str msg = NULL;
5396 51 : str *password = getArgReference_str(stk, pci, 0);
5397 51 : const char *username = *getArgReference_str(stk, pci, 1);
5398 :
5399 51 : (void) password;
5400 :
5401 51 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5402 : return msg;
5403 51 : if ((msg = checkSQLContext(cntxt)) != NULL)
5404 : return msg;
5405 51 : if (cntxt->username != username) {
5406 : // only MAL_ADMIN and user himself can access password
5407 51 : if ((msg = AUTHrequireAdmin(cntxt)) != MAL_SUCCEED)
5408 : return msg;
5409 : }
5410 51 : *password = monet5_password_hash(m, username);
5411 51 : if (!(*password))
5412 1 : throw(SQL, "mvc", SQLSTATE(42000) "SELECT: Failed to retrieve password hash");
5413 : return MAL_SUCCEED;
5414 : }
5415 :
5416 : static str
5417 10 : SQLdecypher(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5418 : {
5419 10 : mvc *m = NULL;
5420 10 : str msg = NULL;
5421 10 : str *pwhash = getArgReference_str(stk, pci, 0);
5422 10 : const char *cypher = *getArgReference_str(stk, pci, 1);
5423 :
5424 10 : (void) pwhash;
5425 :
5426 10 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5427 : return msg;
5428 10 : if ((msg = checkSQLContext(cntxt)) != NULL)
5429 : return msg;
5430 10 : return AUTHdecypherValue(pwhash, cypher);
5431 : }
5432 :
5433 : static str
5434 40 : SQLcheck(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
5435 : {
5436 40 : mvc *m = NULL;
5437 40 : str msg = NULL;
5438 40 : str *r = getArgReference_str(stk, pci, 0);
5439 40 : const char *sname = *getArgReference_str(stk, pci, 1);
5440 40 : const char *kname = *getArgReference_str(stk, pci, 2);
5441 :
5442 40 : if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
5443 : return msg;
5444 40 : if ((msg = checkSQLContext(cntxt)) != NULL)
5445 : return msg;
5446 40 : (void)sname;
5447 40 : sql_schema *s = mvc_bind_schema(m, sname);
5448 40 : if (s) {
5449 40 : sql_key *k = mvc_bind_key(m, s, kname);
5450 40 : if (k && k->check) {
5451 7 : int pos = 0;
5452 7 : sql_rel *rel = rel_basetable(m, k->t, k->t->base.name);
5453 7 : sql_exp *exp = exp_read(m, rel, NULL, NULL, sa_strdup(m->sa, k->check), &pos, 0);
5454 7 : if (exp->comment)
5455 7 : *r = GDKstrdup(exp->comment);
5456 : else
5457 0 : *r = GDKstrdup(exp2sql(m, exp));
5458 7 : if (*r == NULL)
5459 0 : throw(SQL, "SQLcheck", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5460 : return MAL_SUCCEED;
5461 : }
5462 : }
5463 33 : if (!(*r = GDKstrdup(str_nil)))
5464 0 : throw(SQL, "SQLcheck", SQLSTATE(HY013) MAL_MALLOC_FAIL);
5465 : return MAL_SUCCEED;
5466 : }
5467 :
5468 : static mel_func sql_init_funcs[] = {
5469 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,3, arg("",str),arg("delay",bte),arg("force",bit))),
5470 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,3, arg("",str),arg("delay",sht),arg("force",bit))),
5471 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,3, arg("",str),arg("delay",int),arg("force",bit))),
5472 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,2, arg("",str),arg("delay",bte))),
5473 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,2, arg("",str),arg("delay",sht))),
5474 : pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,2, arg("",str),arg("delay",int))),
5475 : pattern("sql", "set_protocol", SQLset_protocol, true, "Configures the result set protocol", args(1,2, arg("",int), arg("protocol",int))),
5476 : 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))),
5477 : pattern("sql", "eval", SQLstatement, true, "Compile and execute a single sql statement", args(1,2, arg("",void),arg("cmd",str))),
5478 : 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))),
5479 : pattern("sql", "include", SQLinclude, true, "Compile and execute a sql statements on the file", args(1,2, arg("",void),arg("fname",str))),
5480 : pattern("sql", "evalAlgebra", RAstatement, true, "Compile and execute a single 'relational algebra' statement", args(1,3, arg("",void),arg("cmd",str),arg("optimize",bit))),
5481 : pattern("sql", "register", RAstatement2, true, "", args(1,5, arg("",int),arg("mod",str),arg("fname",str),arg("rel_stmt",str),arg("sig",str))),
5482 : 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))),
5483 : pattern("sql", "deregister", RAstatementEnd, true, "Finish running transaction", args(1,1, arg("",int))),
5484 : pattern("sql", "hot_snapshot", SQLhot_snapshot, true, "Write db snapshot to the given tar(.gz) file", args(1,2, arg("",void),arg("tarfile",str))),
5485 : pattern("sql", "resume_log_flushing", SQLresume_log_flushing, true, "Resume WAL log flushing", args(1,1, arg("",void))),
5486 : pattern("sql", "suspend_log_flushing", SQLsuspend_log_flushing, true, "Suspend WAL log flushing", args(1,1, arg("",void))),
5487 : 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))),
5488 : 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))),
5489 : pattern("sql", "assert", SQLassert, false, "Generate an exception when b==true", args(1,3, arg("",void),arg("b",bit),arg("msg",str))),
5490 : pattern("sql", "assert", SQLassertInt, false, "Generate an exception when b!=0", args(1,3, arg("",void),arg("b",int),arg("msg",str))),
5491 : pattern("sql", "assert", SQLassertLng, false, "Generate an exception when b!=0", args(1,3, arg("",void),arg("b",lng),arg("msg",str))),
5492 : 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))),
5493 : 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))),
5494 : pattern("sql", "logfile", mvc_logfile, true, "Enable/disable saving the sql statement traces", args(1,2, arg("",void),arg("filename",str))),
5495 : 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))),
5496 : 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))),
5497 : 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))),
5498 : 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))),
5499 : 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))),
5500 : 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))),
5501 : 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))),
5502 : 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))),
5503 : 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))),
5504 : 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))),
5505 : 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))),
5506 : 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))),
5507 : 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))),
5508 : 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))),
5509 : 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))),
5510 : 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))),
5511 : 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))),
5512 : 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))),
5513 : 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))),
5514 : 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))),
5515 : 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))),
5516 : 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))),
5517 : 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))),
5518 : 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))),
5519 : 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))),
5520 : 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))),
5521 : 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))),
5522 : 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))),
5523 : 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))),
5524 : command("sql", "getVersion", mvc_getVersion, false, "Return the database version identifier for a client.", args(1,2, arg("",lng),arg("clientid",int))),
5525 : 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))),
5526 : 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))),
5527 : 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))),
5528 : 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))),
5529 : 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))),
5530 : 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))),
5531 : 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))),
5532 : 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))),
5533 : 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))),
5534 : 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))),
5535 : pattern("sql", "resultSet", mvc_scalar_value_wrap, true, "Prepare a table result set for the client front-end.", args(1,8, arg("",int),arg("tbl",str),arg("attr",str),arg("tpe",str),arg("len",int),arg("scale",int),arg("eclass",int),argany("val",0))),
5536 : pattern("sql", "resultSet", mvc_row_result_wrap, true, "Prepare a table result set for the client front-end", args(1,7, arg("",int),batarg("tbl",str),batarg("attr",str),batarg("tpe",str),batarg("len",int),batarg("scale",int),varargany("cols",0))),
5537 : pattern("sql", "resultSet", mvc_table_result_wrap, true, "Prepare a table result set for the client in default CSV format", args(1,7, arg("",int),batarg("tbl",str),batarg("attr",str),batarg("tpe",str),batarg("len",int),batarg("scale",int),batvarargany("cols",0))),
5538 : 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))),
5539 : 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))),
5540 : 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))),
5541 : 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))),
5542 : 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))),
5543 : 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))),
5544 : pattern("sql", "exportOperation", mvc_export_operation_wrap, true, "Export result of schema/transaction queries", args(1,1, arg("",void))),
5545 : 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))),
5546 : 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))),
5547 : 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))),
5548 : 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))),
5549 : //we use bat.single now
5550 : //pattern("sql", "single", CMDBATsingle, false, "", args(1,2, batargany("",2),argany("x",2))),
5551 : 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))),
5552 : 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))),
5553 : command("sql", "optimizers", getPipeCatalog, false, "", args(3,3, batarg("",str),batarg("",str),batarg("",str))),
5554 : pattern("sql", "optimizer_updates", SQLoptimizersUpdate, false, "", noargs),
5555 : pattern("sql", "argRecord", SQLargRecord, false, "Glue together the calling sequence", args(1,1, arg("",str))),
5556 : pattern("sql", "argRecord", SQLargRecord, false, "Glue together the calling sequence", args(1,2, arg("",str),varargany("a",0))),
5557 : 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))),
5558 : 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),)),
5559 : pattern("sql", "password", SQLuser_password, false, "Return password hash of user", args(1,2, arg("",str),arg("user",str))),
5560 : pattern("sql", "decypher", SQLdecypher, false, "Return decyphered password", args(1,2, arg("",str),arg("hash",str))),
5561 : pattern("sql", "dump_cache", dump_cache, false, "dump the content of the query cache", args(2,2, batarg("query",str),batarg("count",int))),
5562 : pattern("sql", "dump_opt_stats", dump_opt_stats, false, "dump the optimizer rewrite statistics", args(2,2, batarg("rewrite",str),batarg("count",int))),
5563 : pattern("sql", "dump_trace", dump_trace, false, "dump the trace statistics", args(3,3, batarg("ticks",lng),batarg("stmt",str),batarg("stmt",str))),
5564 : pattern("sql", "analyze", sql_analyze, true, "Update statistics for every column in the database", args(1,1, arg("",void))),
5565 : pattern("sql", "analyze", sql_analyze, true, "Update statistics for schema", args(1,2, arg("",void),arg("sch",str))),
5566 : pattern("sql", "analyze", sql_analyze, true, "Update statistics for table", args(1,3, arg("",void),arg("sch",str),arg("tbl",str))),
5567 : pattern("sql", "analyze", sql_analyze, true, "Update statistics for column", args(1,4, arg("",void),arg("sch",str),arg("tbl",str),arg("col",str))),
5568 : 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))),
5569 : 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))),
5570 : 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))),
5571 : 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))),
5572 : 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))),
5573 : 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))),
5574 : 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))),
5575 : 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))),
5576 : 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))),
5577 : 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))),
5578 : 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))),
5579 : 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))),
5580 : 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))),
5581 : 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))),
5582 : command("calc", "identity", SQLidentity, false, "Returns a unique row identitfier.", args(1,2, arg("",oid),argany("",0))),
5583 : command("batcalc", "identity", BATSQLidentity, false, "Returns the unique row identitfiers.", args(1,2, batarg("",oid),batargany("b",0))),
5584 : 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))),
5585 : 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))),
5586 : 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))),
5587 : pattern("sql", "querylog_empty", sql_querylog_empty, true, "", noargs),
5588 : command("sql", "querylog_enable", QLOGenable, true, "", noargs),
5589 : command("sql", "querylog_enable", QLOGenableThreshold, true, "", args(0,1, arg("thres",int))),
5590 : command("sql", "querylog_disable", QLOGdisable, true, "", noargs),
5591 : 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))),
5592 : 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))),
5593 : pattern("sql", "copy_rejects", COPYrejects, false, "", args(4,4, batarg("rowid",lng),batarg("fldid",int),batarg("msg",str),batarg("inp",str))),
5594 : pattern("sql", "copy_rejects_clear", COPYrejects_clear, true, "", noargs),
5595 : pattern("for", "compress", FORcompress_col, false, "compress a sql column", args(0, 3, arg("schema", str), arg("table", str), arg("column", str))),
5596 : pattern("for", "decompress", FORdecompress, false, "decompress a for compressed (sub)column", args(1, 3, batargany("", 1), batargany("o", 0), argany("minval", 1))),
5597 : pattern("dict", "compress", DICTcompress, false, "dict compress a bat", args(2, 3, batargany("o", 0), batargany("v", 1), batargany("b", 1))),
5598 : pattern("dict", "compress", DICTcompress_col, false, "compress a sql column", args(0, 3, arg("schema", str), arg("table", str), arg("column", str))),
5599 : 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))),
5600 : pattern("dict", "decompress", DICTdecompress, false, "decompress a dictionary compressed (sub)column", args(1, 3, batargany("", 1), batargany("o", 0), batargany("u", 1))),
5601 : pattern("dict", "convert", DICTconvert, false, "convert candidate list into compressed offsets", args(1, 2, batargany("", 1), batargany("o", 0))),
5602 : 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))),
5603 : 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))),
5604 : pattern("dict", "renumber", DICTrenumber, false, "renumber offsets", args(1, 3, batargany("n", 1), batargany("o", 1), batargany("r", 1))),
5605 : 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))),
5606 : 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))),
5607 : 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))),
5608 : 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))),
5609 : 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))),
5610 : 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))),
5611 : 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))),
5612 : 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))),
5613 : 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))),
5614 : 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))),
5615 : 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))),
5616 : 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))),
5617 : 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))),
5618 : 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))),
5619 : 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))),
5620 : 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))),
5621 : 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))),
5622 : 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))),
5623 : 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))),
5624 : 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))),
5625 : 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))),
5626 : 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))),
5627 : 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))),
5628 : 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))),
5629 : 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))),
5630 : 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))),
5631 : 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))),
5632 : 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))),
5633 : 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))),
5634 : 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))),
5635 : 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))),
5636 : 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))),
5637 : 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))),
5638 : 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))),
5639 : 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))),
5640 : 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))),
5641 : 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))),
5642 : 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))),
5643 : 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))),
5644 : 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))),
5645 : 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))),
5646 : 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))),
5647 : 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))),
5648 : 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))),
5649 : 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))),
5650 : 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))),
5651 : 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))),
5652 : 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))),
5653 : 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))),
5654 : 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))),
5655 : 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))),
5656 : 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))),
5657 : 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))),
5658 : 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))),
5659 : 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))),
5660 : 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))),
5661 : 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))),
5662 : 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))),
5663 : 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))),
5664 : 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))),
5665 : 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))),
5666 : 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))),
5667 : 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))),
5668 : 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))),
5669 : 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))),
5670 : 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))),
5671 : 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))),
5672 : 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))),
5673 : 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))),
5674 : 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))),
5675 : 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))),
5676 : 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))),
5677 : 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))),
5678 : 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))),
5679 : 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))),
5680 : 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))),
5681 : 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))),
5682 : 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))),
5683 : 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))),
5684 : 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))),
5685 : 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))),
5686 : 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))),
5687 : 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))),
5688 : 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))),
5689 : 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))),
5690 : 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))),
5691 : 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))),
5692 : 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))),
5693 : 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))),
5694 : 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))),
5695 : 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))),
5696 : 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))),
5697 : 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))),
5698 : 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))),
5699 : 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))),
5700 : 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))),
5701 : command("batsql", "alpha", SQLbat_alpha_cst, false, "BAT implementation of astronomy alpha function", args(1,3, batarg("",dbl),batarg("dec",dbl),arg("theta",dbl))),
5702 : command("batsql", "alpha", SQLcst_alpha_bat, false, "BAT implementation of astronomy alpha function", args(1,3, batarg("",dbl),arg("dec",dbl),batarg("theta",dbl))),
5703 : 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))),
5704 : 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))),
5705 : 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))),
5706 : 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))),
5707 : 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))),
5708 : 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))),
5709 : 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))),
5710 : 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))),
5711 : 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))),
5712 : 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))),
5713 : 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))),
5714 : 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))),
5715 : 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))),
5716 : 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))),
5717 : 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))),
5718 : 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))),
5719 : 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))),
5720 : 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))),
5721 : 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))),
5722 : 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))),
5723 : 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))),
5724 : 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))),
5725 : 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))),
5726 : 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))),
5727 : 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))),
5728 : 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))),
5729 : 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))),
5730 : 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))),
5731 : 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))),
5732 : 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))),
5733 : 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))),
5734 : 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))),
5735 : 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))),
5736 : pattern("sql", "current_time", SQLcurrent_daytime, false, "Get the clients current daytime", args(1,1, arg("",daytime))),
5737 : pattern("sql", "current_timestamp", SQLcurrent_timestamp, false, "Get the clients current timestamp", args(1,1, arg("",timestamp))),
5738 : pattern("calc", "date", nil_2_date, false, "cast to date", args(1,2, arg("",date),arg("v",void))),
5739 : pattern("batcalc", "date", nil_2_date, false, "cast to date", args(1,2, batarg("",date),batarg("v",oid))),
5740 : 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))),
5741 : 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))),
5742 : 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))),
5743 : 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))),
5744 : 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))),
5745 : 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))),
5746 : 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))),
5747 : 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))),
5748 : 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))),
5749 : 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))),
5750 : 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))),
5751 : 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))),
5752 : 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))),
5753 : 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))),
5754 : 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))),
5755 : 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))),
5756 : 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))),
5757 : 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))),
5758 : 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))),
5759 : 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))),
5760 : 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))),
5761 : 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))),
5762 : 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))),
5763 : pattern("calc", "rowid", sql_rowid, false, "return the next rowid", args(1,4, arg("",oid),argany("v",1),arg("schema",str),arg("table",str))),
5764 : pattern("sql", "drop_hash", SQLdrop_hash, true, "Drop hash indices for the given table", args(0,2, arg("sch",str),arg("tbl",str))),
5765 : pattern("sql", "prelude", SQLprelude, false, "", noargs),
5766 : command("sql", "epilogue", SQLepilogue, false, "", noargs),
5767 : 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))),
5768 : 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))),
5769 : 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))),
5770 : 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))),
5771 : 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))),
5772 : 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))),
5773 : 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))),
5774 : 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))),
5775 : pattern("sql", "update_tables", SYSupdate_tables, true, "Procedure triggered on update of the sys._tables table", args(1,1, arg("",void))),
5776 : pattern("sql", "update_schemas", SYSupdate_schemas, true, "Procedure triggered on update of the sys.schemas table", args(1,1, arg("",void))),
5777 : pattern("sql", "unionfunc", SQLunionfunc, false, "", args(1,4, varargany("",0),arg("mod",str),arg("fcn",str),varargany("",0))),
5778 : /* decimals */
5779 : 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))),
5780 : 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))),
5781 : 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))),
5782 : 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))),
5783 : 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))),
5784 : 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))),
5785 : 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))),
5786 : 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))),
5787 : 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))),
5788 : 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))),
5789 : 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))),
5790 : 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))),
5791 : 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))),
5792 : 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))),
5793 : 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))),
5794 : 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))),
5795 : 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))),
5796 : 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))),
5797 : 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))),
5798 : 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))),
5799 : 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))),
5800 : 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))),
5801 : 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))),
5802 : 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))),
5803 : 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))),
5804 : 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))),
5805 : 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))),
5806 : 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))),
5807 : 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))),
5808 : 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))),
5809 : 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))),
5810 : 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))),
5811 : 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))),
5812 : 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))),
5813 : 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))),
5814 : 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))),
5815 : 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))),
5816 : 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))),
5817 : 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))),
5818 : 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))),
5819 : 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))),
5820 : 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))),
5821 : 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))),
5822 : 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))),
5823 : 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))),
5824 : 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))),
5825 : 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))),
5826 : 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))),
5827 : 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))),
5828 : 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))),
5829 : 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))),
5830 : 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))),
5831 : 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))),
5832 : 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))),
5833 : 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))),
5834 : 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))),
5835 : 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))),
5836 : 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))),
5837 : 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))),
5838 : 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))),
5839 : 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))),
5840 : 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))),
5841 : 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))),
5842 : 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))),
5843 : 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))),
5844 : 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))),
5845 : 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))),
5846 : 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))),
5847 : 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))),
5848 : 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))),
5849 : 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))),
5850 : 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))),
5851 : 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))),
5852 : 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))),
5853 : 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))),
5854 : 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))),
5855 : 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))),
5856 : 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))),
5857 : 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))),
5858 : 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))),
5859 : 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))),
5860 : 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))),
5861 : 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))),
5862 : 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))),
5863 : 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))),
5864 : 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))),
5865 : 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))),
5866 : 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))),
5867 : 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))),
5868 : 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))),
5869 : 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))),
5870 : 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))),
5871 : 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))),
5872 : 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))),
5873 : 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))),
5874 : 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))),
5875 : 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))),
5876 : 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))),
5877 : 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))),
5878 : 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))),
5879 : 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))),
5880 : 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))),
5881 : 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))),
5882 : 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))),
5883 : 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))),
5884 : 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))),
5885 : 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))),
5886 : 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))),
5887 : 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))),
5888 : 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))),
5889 : 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))),
5890 : 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))),
5891 : 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))),
5892 : 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))),
5893 : 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))),
5894 : 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))),
5895 : 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))),
5896 : 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))),
5897 : 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))),
5898 : 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))),
5899 : 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))),
5900 : 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))),
5901 : 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))),
5902 : 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))),
5903 : 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))),
5904 : 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))),
5905 : 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))),
5906 : 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))),
5907 : 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))),
5908 : 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))),
5909 : 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))),
5910 : 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))),
5911 : 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))),
5912 : 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))),
5913 : 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))),
5914 : 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))),
5915 : 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))),
5916 : 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))),
5917 : 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))),
5918 : 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))),
5919 : 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))),
5920 : 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))),
5921 : 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))),
5922 : 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))),
5923 : 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))),
5924 : 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))),
5925 : 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))),
5926 : 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))),
5927 : 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))),
5928 : 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))),
5929 : 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))),
5930 : 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))),
5931 : 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))),
5932 : 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))),
5933 : 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))),
5934 : 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))),
5935 : 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))),
5936 : 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))),
5937 : 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))),
5938 : 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))),
5939 : /* sql_rank */
5940 : pattern("sql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,2, arg("",bit),argany("b",1))),
5941 : pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,2, batarg("",bit),batargany("b",1))),
5942 : pattern("sql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, arg("",bit),arg("p",bit),argany("b",1))),
5943 : pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, batarg("",bit),arg("p",bit),batargany("b",1))),
5944 : pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, batarg("",bit),batarg("p",bit),argany("b",1))),
5945 : pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, batarg("",bit),batarg("p",bit),batargany("b",1))),
5946 : 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))),
5947 : 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))),
5948 : 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))),
5949 : 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))),
5950 : 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))),
5951 : 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))),
5952 : 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))),
5953 : 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))),
5954 : 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))),
5955 : 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))),
5956 : 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))),
5957 : 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))),
5958 : 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))),
5959 : 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))),
5960 : 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))),
5961 : 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))),
5962 : 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))),
5963 : 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))),
5964 : 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))),
5965 : 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))),
5966 : 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))),
5967 : 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))),
5968 : 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))),
5969 : 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))),
5970 : 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))),
5971 : 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))),
5972 : pattern("sql", "rank", SQLrank, false, "return the ranked groups", args(1,4, arg("",int),argany("b",1),arg("p",bit),arg("o",bit))),
5973 : pattern("batsql", "rank", SQLrank, false, "return the ranked groups", args(1,4, batarg("",int),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit))),
5974 : 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))),
5975 : 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))),
5976 : 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))),
5977 : 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))),
5978 : 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))),
5979 : 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))),
5980 : 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))),
5981 : 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))),
5982 : 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))),
5983 : 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))),
5984 : 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))),
5985 : 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))),
5986 : 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))),
5987 : 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))),
5988 : 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))),
5989 : 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))),
5990 : 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))),
5991 : 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))),
5992 : 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))),
5993 : 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))),
5994 : /* these window functions support frames */
5995 : 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))),
5996 : 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))),
5997 : 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))),
5998 : 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))),
5999 : 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))),
6000 : 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))),
6001 : 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))),
6002 : 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))),
6003 : 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))),
6004 : 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))),
6005 : pattern("sql", "count", SQLbasecount, false, "return count of basetable", args(1,3, arg("",lng),arg("sname",str),arg("tname",str))),
6006 : 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))),
6007 : 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))),
6008 : 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))),
6009 : 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))),
6010 : 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))),
6011 : 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))),
6012 : 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))),
6013 : 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))),
6014 : 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))),
6015 : 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))),
6016 : 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))),
6017 : 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))),
6018 : 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))),
6019 : 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))),
6020 : 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))),
6021 : 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))),
6022 : /* sql.sum for month intervals */
6023 : 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))),
6024 : 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))),
6025 : 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))),
6026 : 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))),
6027 : 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))),
6028 : 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))),
6029 : 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))),
6030 : 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))),
6031 : 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))),
6032 : 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))),
6033 : 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))),
6034 : 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))),
6035 : 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))),
6036 : 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))),
6037 : 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))),
6038 : 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))),
6039 : 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))),
6040 : 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))),
6041 : 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))),
6042 : 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))),
6043 : 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))),
6044 : 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))),
6045 : 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))),
6046 : 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))),
6047 : 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))),
6048 : 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))),
6049 : 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))),
6050 : 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))),
6051 : 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))),
6052 : 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))),
6053 : 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))),
6054 : 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))),
6055 : 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))),
6056 : 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))),
6057 : 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))),
6058 : 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))),
6059 : 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))),
6060 : 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))),
6061 : 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))),
6062 : 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))),
6063 : 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))),
6064 : 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))),
6065 : 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))),
6066 : 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))),
6067 : 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))),
6068 : 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))),
6069 : 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))),
6070 : 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))),
6071 : 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))),
6072 : 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))),
6073 : 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))),
6074 : 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))),
6075 : 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))),
6076 : 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))),
6077 : 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))),
6078 : 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))),
6079 : 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))),
6080 : 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))),
6081 : 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))),
6082 : 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))),
6083 : 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))),
6084 : 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))),
6085 : 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))),
6086 : 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))),
6087 : 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))),
6088 : 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))),
6089 : 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))),
6090 : 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))),
6091 : 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))),
6092 : 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))),
6093 : 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))),
6094 : 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))),
6095 : 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))),
6096 : 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))),
6097 : 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))),
6098 : 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))),
6099 : 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))),
6100 : 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))),
6101 : 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))),
6102 : 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))),
6103 : 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))),
6104 : 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))),
6105 : 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))),
6106 : 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))),
6107 : 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))),
6108 : 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))),
6109 : 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))),
6110 : 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))),
6111 : 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))),
6112 : 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))),
6113 : 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))),
6114 : 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))),
6115 : 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))),
6116 : 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))),
6117 : 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))),
6118 : 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))),
6119 : 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))),
6120 : 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))),
6121 : 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))),
6122 : 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))),
6123 : 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))),
6124 : 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))),
6125 : 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))),
6126 : 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))),
6127 : 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))),
6128 : 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))),
6129 : 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))),
6130 : 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))),
6131 : 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))),
6132 : 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))),
6133 : 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))),
6134 : 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))),
6135 : 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))),
6136 : 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))),
6137 : 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))),
6138 : 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))),
6139 : 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))),
6140 : 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))),
6141 : 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))),
6142 : 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))),
6143 : 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))),
6144 : 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))),
6145 : 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))),
6146 : 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))),
6147 : /* sql_subquery */
6148 : 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))),
6149 : 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))),
6150 : 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))),
6151 : 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))),
6152 : command("aggr", "all", SQLall, false, "if all values in b are equal return this, else nil", args(1,2, argany("",1),batargany("b",1))),
6153 : 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))),
6154 : 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))),
6155 : command("aggr", "null", SQLnil, false, "if b has a nil return true, else false", args(1,2, arg("",bit),batargany("b",1))),
6156 : 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))),
6157 : 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))),
6158 : 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))),
6159 : 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))),
6160 : 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))),
6161 : 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))),
6162 : 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))),
6163 : 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))),
6164 : 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))),
6165 : 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))),
6166 : 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))),
6167 : 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))),
6168 : 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))),
6169 : 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))),
6170 : 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))),
6171 : 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))),
6172 : 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))),
6173 : 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))),
6174 : 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))),
6175 : 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))),
6176 : 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))),
6177 : 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))),
6178 : 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))),
6179 : // 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))),
6180 : 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))),
6181 : 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))),
6182 : 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))),
6183 : // 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))),
6184 : 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))),
6185 : 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))),
6186 : pattern("aggr", "exist", SQLexist, false, "", args(1,2, arg("",bit), argany("b",1))),
6187 : pattern("bataggr", "exist", SQLexist, false, "", args(1,2, batarg("",bit), argany("b",1))),
6188 : pattern("bataggr", "exist", SQLexist, false, "", args(1,2, arg("",bit), batargany("b",1))),
6189 : pattern("bataggr", "exist", SQLexist, false, "", args(1,2, batarg("",bit), batargany("b",1))),
6190 : pattern("aggr", "subexist", SQLsubexist, false, "", args(1,5, batarg("",bit),batargany("b",0),batarg("g",oid),batarg("e",oid),arg("no_nil",bit))),
6191 : 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))),
6192 : pattern("aggr", "not_exist", SQLnot_exist, false, "", args(1,2, arg("",bit), argany("b",1))),
6193 : pattern("bataggr", "not_exist", SQLnot_exist, false, "", args(1,2, batarg("",bit), argany("b",1))),
6194 : pattern("bataggr", "not_exist", SQLnot_exist, false, "", args(1,2, arg("",bit), batargany("b",1))),
6195 : pattern("bataggr", "not_exist", SQLnot_exist, false, "", args(1,2, batarg("",bit), batargany("b",1))),
6196 : 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))),
6197 : 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))),
6198 : /* sqlcatalog */
6199 : 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))),
6200 : 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))),
6201 : 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))),
6202 : pattern("sqlcatalog", "drop_seq", SQLdrop_seq, false, "Catalog operation drop_seq", args(0,3, arg("sname",str),arg("nme",str),arg("action",int))),
6203 : pattern("sqlcatalog", "create_schema", SQLcreate_schema, false, "Catalog operation create_schema", args(0,3, arg("sname",str),arg("auth",str),arg("action",int))),
6204 : pattern("sqlcatalog", "drop_schema", SQLdrop_schema, false, "Catalog operation drop_schema", args(0,3, arg("sname",str),arg("ifexists",int),arg("action",int))),
6205 : 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))),
6206 : 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))),
6207 : 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))),
6208 : 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))),
6209 : 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))),
6210 : 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))),
6211 : 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))),
6212 : pattern("sqlcatalog", "create_type", SQLcreate_type, false, "Catalog operation create_type", args(0,3, arg("sname",str),arg("nme",str),arg("impl",str))),
6213 : pattern("sqlcatalog", "drop_type", SQLdrop_type, false, "Catalog operation drop_type", args(0,3, arg("sname",str),arg("nme",str),arg("action",int))),
6214 : 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))),
6215 : 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))),
6216 : 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))),
6217 : 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))),
6218 : 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))),
6219 : 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))),
6220 : 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))),
6221 : pattern("sqlcatalog", "drop_user", SQLdrop_user, false, "Catalog operation drop_user", args(0,2, arg("sname",str),arg("action",int))),
6222 : pattern("sqlcatalog", "drop_user", SQLdrop_user, false, "Catalog operation drop_user", args(0,3, arg("sname",str),arg("auth",str),arg("action",int))),
6223 : 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))),
6224 : pattern("sqlcatalog", "rename_user", SQLrename_user, false, "Catalog operation rename_user", args(0,3, arg("sname",str),arg("newnme",str),arg("action",int))),
6225 : pattern("sqlcatalog", "create_role", SQLcreate_role, false, "Catalog operation create_role", args(0,3, arg("sname",str),arg("role",str),arg("grator",int))),
6226 : pattern("sqlcatalog", "drop_role", SQLdrop_role, false, "Catalog operation drop_role", args(0,3, arg("auth",str),arg("role",str),arg("action",int))),
6227 : pattern("sqlcatalog", "drop_role", SQLdrop_role, false, "Catalog operation drop_role", args(0,2, arg("role",str),arg("action",int))),
6228 : pattern("sqlcatalog", "drop_index", SQLdrop_index, false, "Catalog operation drop_index", args(0,3, arg("sname",str),arg("iname",str),arg("action",int))),
6229 : 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))),
6230 : 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))),
6231 : 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))),
6232 : pattern("sqlcatalog", "drop_trigger", SQLdrop_trigger, false, "Catalog operation drop_trigger", args(0,3, arg("sname",str),arg("nme",str),arg("ifexists",int))),
6233 : 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))),
6234 : 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))),
6235 : 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))),
6236 : 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))),
6237 : 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))),
6238 : 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))),
6239 : 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))),
6240 : 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))),
6241 : 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))),
6242 : pattern("sqlcatalog", "comment_on", SQLcomment_on, false, "Catalog operation comment_on", args(0,2, arg("objid",int),arg("remark",str))),
6243 : pattern("sqlcatalog", "rename_schema", SQLrename_schema, false, "Catalog operation rename_schema", args(0,2, arg("sname",str),arg("newnme",str))),
6244 : 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))),
6245 : 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))),
6246 : /* sql_transaction */
6247 : 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))),
6248 : 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))),
6249 : 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))),
6250 : 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))),
6251 : #ifdef HAVE_HGE
6252 : /* sql_hge */
6253 : 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))),
6254 : 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))),
6255 : 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))),
6256 : 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))),
6257 : 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))),
6258 : 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))),
6259 : 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))),
6260 : 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))),
6261 : 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))),
6262 : 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))),
6263 : 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))),
6264 : 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))),
6265 : 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))),
6266 : 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))),
6267 : 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))),
6268 : 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))),
6269 : 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))),
6270 : 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))),
6271 : 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))),
6272 : 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))),
6273 : 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))),
6274 : 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))),
6275 : 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))),
6276 : 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))),
6277 : /* sql_decimal_hge */
6278 : 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))),
6279 : 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))),
6280 : 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))),
6281 : 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))),
6282 : 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))),
6283 : 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))),
6284 : 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))),
6285 : 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))),
6286 : 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))),
6287 : 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))),
6288 : 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))),
6289 : 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))),
6290 : 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))),
6291 : 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))),
6292 : 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))),
6293 : 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))),
6294 : 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))),
6295 : 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))),
6296 : 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))),
6297 : 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))),
6298 : 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))),
6299 : 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))),
6300 : 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))),
6301 : 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))),
6302 : 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))),
6303 : 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))),
6304 : 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))),
6305 : 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))),
6306 : 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))),
6307 : 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))),
6308 : 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))),
6309 : 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))),
6310 : 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))),
6311 : 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))),
6312 : 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))),
6313 : 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))),
6314 : 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))),
6315 : 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))),
6316 : 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))),
6317 : 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))),
6318 : 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))),
6319 : 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))),
6320 : 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))),
6321 : 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))),
6322 : 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))),
6323 : 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))),
6324 : 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))),
6325 : 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))),
6326 : 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))),
6327 : 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))),
6328 : 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))),
6329 : 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))),
6330 : 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))),
6331 : 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))),
6332 : 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))),
6333 : 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))),
6334 : 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))),
6335 : 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))),
6336 : 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))),
6337 : 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))),
6338 : 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))),
6339 : 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))),
6340 : 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))),
6341 : 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))),
6342 : 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))),
6343 : 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))),
6344 : 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))),
6345 : 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))),
6346 : 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))),
6347 : 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))),
6348 : /* sql_rank_hge */
6349 : 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))),
6350 : 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))),
6351 : 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))),
6352 : 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))),
6353 : 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))),
6354 : 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))),
6355 : 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))),
6356 : 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))),
6357 : 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))),
6358 : 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))),
6359 : 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))),
6360 : 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))),
6361 : 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))),
6362 : 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))),
6363 : 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))),
6364 : 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))),
6365 : 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))),
6366 : 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))),
6367 : 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))),
6368 : 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))),
6369 : 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))),
6370 : 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))),
6371 : 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))),
6372 : 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))),
6373 : 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))),
6374 : 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))),
6375 : 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))),
6376 : 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))),
6377 : 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))),
6378 : 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))),
6379 : 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))),
6380 : 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))),
6381 : 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))),
6382 : 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))),
6383 : 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))),
6384 : 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))),
6385 : 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))),
6386 : 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))),
6387 : 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))),
6388 : 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))),
6389 : 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))),
6390 : 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))),
6391 : #endif
6392 : pattern("sql", "vacuum", SQLstr_column_vacuum, true, "vacuum a string column", args(0,3, arg("sname",str),arg("tname",str),arg("cname",str))),
6393 : pattern("sql", "vacuum", SQLstr_column_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))),
6394 : pattern("sql", "stop_vacuum", SQLstr_column_stop_vacuum, true, "stop auto vacuum", args(0,3, arg("sname",str),arg("tname",str),arg("cname",str))),
6395 : pattern("sql", "check", SQLcheck, false, "Return sql string of check constraint.", args(1,3, arg("sql",str), arg("sname", str), arg("name", str))),
6396 : { .imp=NULL }
6397 : };
6398 : #include "mal_import.h"
6399 : #ifdef _MSC_VER
6400 : #undef read
6401 : #pragma section(".CRT$XCU",read)
6402 : #endif
6403 318 : LIB_STARTUP_FUNC(init_sql_mal)
6404 318 : { mal_module("sql", NULL, sql_init_funcs); }
|
