LCOV - code coverage report
Current view: top level - sql/backends/monet5 - sql.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2402 3802 63.2 %
Date: 2024-10-03 20:03:20 Functions: 77 103 74.8 %

          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       19319 : rel_is_table(sql_rel *rel)
      64             : {
      65       19319 :         if (!rel || is_base(rel->op))
      66       14267 :                 return 1;
      67             :         return 0;
      68             : }
      69             : 
      70             : static int
      71       14267 : exp_is_point_select(sql_exp *e)
      72             : {
      73       14267 :         if (!e)
      74             :                 return 1;
      75       14267 :         if (e->type == e_cmp && !e->f && e->flag == (int) cmp_equal) {
      76        7088 :                 sql_exp *r = e->r;
      77        7088 :                 sql_exp *l = e->l;
      78             : 
      79        7088 :                 if (!is_func(l->type) && r->card <= CARD_AGGR)
      80        6969 :                         return 1;
      81             :         }
      82             :         return 0;
      83             : }
      84             : 
      85             : static int
      86      559555 : rel_no_mitosis(mvc *sql, sql_rel *rel)
      87             : {
      88     1303599 :         if (mvc_highwater(sql))
      89             :                 return 0;
      90      965840 :         if (!rel || is_basetable(rel->op))
      91             :                 return 1;
      92             :         /* use mitosis on order topn */
      93      792829 :         if (is_topn(rel->op)) {
      94       16425 :                 sql_rel *l = rel->l;
      95       16425 :                 if (l && is_simple_project(l->op) && l->r)
      96             :                         return 0;
      97             :         }
      98      792541 :         if (is_topn(rel->op) || is_sample(rel->op) || is_simple_project(rel->op))
      99      314110 :                 return rel_no_mitosis(sql, rel->l);
     100      478431 :         if (is_ddl(rel->op) && rel->flag == ddl_output) {
     101             :                 // COPY SELECT ... INTO
     102          74 :                 return rel_no_mitosis(sql, rel->l);
     103             :         }
     104      478357 :         if ((is_delete(rel->op) || is_truncate(rel->op)) && rel->card <= CARD_AGGR)
     105             :                 return 1;
     106      436557 :         if ((is_insert(rel->op) || is_update(rel->op)) && rel->card <= CARD_AGGR)
     107       92096 :                 return rel_no_mitosis(sql, rel->r);
     108      358728 :         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       14267 :                 if (exp_is_point_select(rel->exps->h->data))
     111             :                         return 1;
     112             :         }
     113             :         return 0;
     114             : }
     115             : 
     116             : static int
     117      337780 : rel_need_distinct_query(sql_rel *rel)
     118             : {
     119      337780 :         int need_distinct = 0;
     120             : 
     121      380840 :         while (rel && is_simple_project(rel->op))
     122       43060 :                 rel = rel->l;
     123      337780 :         if (rel && is_groupby(rel->op) && !list_empty(rel->exps) && list_empty(rel->r)) {
     124        2397 :                 for (node *n = rel->exps->h; n && !need_distinct; n = n->next) {
     125        1335 :                         sql_exp *e = n->data;
     126             : 
     127        1335 :                         if (e->type == e_aggr && need_distinct(e))
     128        1335 :                                 need_distinct = 1;
     129             :                 }
     130             :         }
     131      337780 :         return need_distinct;
     132             : }
     133             : 
     134             : sql_rel *
     135      561845 : sql_symbol2relation(backend *be, symbol *sym)
     136             : {
     137      561845 :         sql_rel *rel;
     138      561845 :         sql_query *query = query_create(be->mvc);
     139      561842 :         lng Tbegin, Tend;
     140      561842 :         int value_based_opt = be->mvc->emode != m_prepare, storage_based_opt;
     141      561842 :         int profile = be->mvc->emode == m_plan;
     142      561842 :         Client c = be->client;
     143             : 
     144      561842 :         Tbegin = GDKusec();
     145      561845 :         rel = rel_semantic(query, sym);
     146      561837 :         Tend = GDKusec();
     147      561840 :         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      561840 :         storage_based_opt = value_based_opt && rel && !is_ddl(rel->op);
     153      294791 :         Tbegin = Tend;
     154        2606 :         if (rel)
     155      559583 :                 rel = sql_processrelation(be->mvc, rel, profile, 1, value_based_opt, storage_based_opt);
     156      559578 :         if (rel)
     157      559557 :                 rel = rel_partition(be->mvc, rel);
     158      559555 :         if (rel && (rel_no_mitosis(be->mvc, rel) || rel_need_distinct_query(rel)))
     159      221826 :                 be->no_mitosis = 1;
     160      559553 :         if (rel /*&& (be->mvc->emode != m_plan || (ATOMIC_GET(&GDKdebug) & FORCEMITOMASK) == 0)*/)
     161      559553 :                 rel = rel_physical(be->mvc, rel);
     162      561824 :         Tend = GDKusec();
     163      561829 :         be->reloptimizer = Tend - Tbegin;
     164             : 
     165      561829 :         if(profilerStatus > 0)
     166           0 :                 profilerEvent(NULL,
     167             :                                           &(struct NonMalEvent)
     168           0 :                                           {REL_OPT, c, Tend, NULL, NULL, rel?0:1, be->reloptimizer});
     169      561829 :         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      732067 : sqlcleanup(backend *be, int err)
     179             : {
     180      732067 :         sql_destroy_params(be->mvc);
     181             : 
     182             :         /* some statements dynamically disable caching */
     183      732065 :         be->mvc->sym = NULL;
     184      732065 :         be->mvc->runs = NULL;
     185      732065 :         if (be->mvc->ta)
     186      732068 :                 be->mvc->ta = sa_reset(be->mvc->ta);
     187      732074 :         if (be->mvc->sa)
     188      731738 :                 be->mvc->sa = sa_reset(be->mvc->sa);
     189      732066 :         if (err >0)
     190         373 :                 be->mvc->session->status = -err;
     191      732066 :         if (err <0)
     192       34971 :                 be->mvc->session->status = err;
     193      732066 :         be->mvc->label = 0;
     194      732066 :         be->mvc->nid = 1;
     195      732066 :         be->no_mitosis = 0;
     196      732066 :         scanner_query_processed(&(be->mvc->scanner));
     197      732066 :         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     6223930 : checkSQLContext(Client cntxt)
     208             : {
     209     6223930 :         backend *be;
     210             : 
     211     6223930 :         if (cntxt == NULL)
     212           0 :                 throw(SQL, "mvc", SQLSTATE(42005) "No client record");
     213     6223930 :         if (cntxt->sqlcontext == NULL)
     214           0 :                 throw(SQL, "mvc", SQLSTATE(42006) "SQL module not initialized");
     215     6223930 :         be = (backend *) cntxt->sqlcontext;
     216     6223930 :         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      125267 : getBackendContext(Client cntxt, backend **be)
     223             : {
     224      125267 :         str msg;
     225             : 
     226      125267 :         if ((msg = checkSQLContext(cntxt)) != MAL_SUCCEED)
     227             :                 return msg;
     228      125268 :         *be = (backend *) cntxt->sqlcontext;
     229      125268 :         return MAL_SUCCEED;
     230             : }
     231             : 
     232             : str
     233     2976463 : getSQLContext(Client cntxt, MalBlkPtr mb, mvc **c, backend **b)
     234             : {
     235     2976463 :         backend *be;
     236     2976463 :         (void) mb;
     237     2976463 :         str msg;
     238             : 
     239     2976463 :         if ((msg = checkSQLContext(cntxt)) != MAL_SUCCEED)
     240             :                 return msg;
     241     2975955 :         be = (backend *) cntxt->sqlcontext;
     242     2975955 :         if (c)
     243     2975955 :                 *c = be->mvc;
     244     2975955 :         if (b)
     245         448 :                 *b = be;
     246             :         return MAL_SUCCEED;
     247             : }
     248             : 
     249             : str
     250      280571 : SQLmvc(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     251             : {
     252      280571 :         mvc *sql = NULL;
     253      280571 :         str msg;
     254      280571 :         int *res = getArgReference_int(stk, pci, 0);
     255             : 
     256      280571 :         if ((msg = getSQLContext(cntxt, mb, &sql, NULL)) != NULL)
     257             :                 return msg;
     258      280570 :         if ((msg = checkSQLContext(cntxt)) != NULL)
     259             :                 return msg;
     260      280569 :         *res = 0;
     261      280569 :         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       32437 : create_table_or_view(mvc *sql, char *sname, char *tname, sql_table *t, int temp, int replace)
     299             : {
     300       32437 :         allocator *osa;
     301       32437 :         sql_schema *s = mvc_bind_schema(sql, sname);
     302       32437 :         sql_table *nt = NULL, *ot;
     303       32437 :         node *n;
     304       32437 :         int check = 0;
     305       32437 :         const char *action = (temp == SQL_DECLARED_TABLE) ? "DECLARE" : (replace ? "CREATE OR REPLACE" : "CREATE");
     306       32437 :         const char *obj = t->query ? "VIEW" : "TABLE";
     307       32437 :         str msg = MAL_SUCCEED;
     308             : 
     309       32437 :         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       32437 :         if (!s)
     313           0 :                 throw(SQL, "sql.catalog", SQLSTATE(3F000) "%s %s: schema '%s' doesn't exist", action, obj, sname);
     314       32437 :         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       32437 :         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       32435 :         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       32435 :         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       32431 :                         break;
     344             :         }
     345       32431 :         osa = sql->sa;
     346       32431 :         allocator *nsa = sql->sa = sa_create(NULL);
     347             :         /* first check default values */
     348      288532 :         for (n = ol_first_node(t->columns); n; n = n->next) {
     349      256102 :                 sql_column *c = n->data;
     350             : 
     351      256102 :                 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      288531 :         for (n = ol_first_node(t->columns); n; n = n->next) {
     385      256101 :                 sql_column *c = n->data, *copied = NULL;
     386             : 
     387      256101 :                 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      256101 :                                 break;
     399             :                 }
     400      256101 :                 if (isPartitionedByColumnTable(t) && c->base.id == t->part.pcol->base.id)
     401          80 :                         nt->part.pcol = copied;
     402             :         }
     403       32430 :         if (isPartitionedByExpressionTable(t)) {
     404          22 :                 char *err = NULL;
     405             : 
     406          22 :                 _DELETE(nt->part.pexp->exp);
     407          22 :                 nt->part.pexp->exp = _STRDUP(t->part.pexp->exp);
     408          22 :                 err = bootstrap_partition_expression(sql, nt, 1);
     409          22 :                 if (err) {
     410           3 :                         sa_destroy(nsa);
     411           3 :                         sql->sa = osa;
     412           3 :                         return err;
     413             :                 }
     414          19 :                 sa_reset(nsa);
     415             :         }
     416       32427 :         check = sql_trans_set_partition_table(sql->session->tr, nt);
     417       32427 :         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       32427 :         } 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       32427 :         if (t->idxs) {
     428       38498 :                 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       32427 :         if (t->keys) {
     447       38509 :                 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       32420 :         if (t->triggers) {
     475       32420 :                 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       32420 :         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       32420 :         sa_destroy(nsa);
     519       32420 :         sql->sa = osa;
     520       32420 :         return MAL_SUCCEED;
     521             : }
     522             : 
     523             : static int
     524       98898 : mvc_claim_slots(sql_trans *tr, sql_table *t, size_t cnt, BUN *offset, BAT **pos)
     525             : {
     526       98898 :         sqlstore *store = tr->store;
     527       98898 :         return store->storage_api.claim_tab(tr, t, cnt, offset, pos);
     528             : }
     529             : 
     530             : str
     531       98885 : mvc_claim_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     532             : {
     533       98885 :         BUN *offset = (BUN*)getArgReference_oid(stk, pci, 0);
     534       98885 :         bat *res = getArgReference_bat(stk, pci, 1);
     535       98885 :         mvc *m = NULL;
     536       98885 :         str msg;
     537       98885 :         const char *sname = *getArgReference_str(stk, pci, 3);
     538       98885 :         const char *tname = *getArgReference_str(stk, pci, 4);
     539       98885 :         lng cnt = *getArgReference_lng(stk, pci, 5);
     540       98885 :         BAT *pos = NULL;
     541       98885 :         sql_schema *s;
     542       98885 :         sql_table *t;
     543             : 
     544       98885 :         *res = 0;
     545       98885 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
     546             :                 return msg;
     547       98885 :         if ((msg = checkSQLContext(cntxt)) != NULL)
     548             :                 return msg;
     549             : 
     550       98885 :         s = mvc_bind_schema(m, sname);
     551       98885 :         if (s == NULL)
     552           0 :                 throw(SQL, "sql.claim", SQLSTATE(3F000) "Schema missing %s", sname);
     553       98885 :         t = mvc_bind_table(m, s, tname);
     554       98885 :         if (t == NULL)
     555           0 :                 throw(SQL, "sql.claim", SQLSTATE(42S02) "Table missing %s.%s", sname, tname);
     556       98885 :         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       98885 :         if (mvc_claim_slots(m->session->tr, t, (size_t)cnt, offset, &pos) == LOG_OK) {
     559       98884 :                 *res = bat_nil;
     560       98884 :                 if (pos) {
     561           7 :                         *res = pos->batCacheid;
     562           7 :                         BBPkeepref(pos);
     563             :                 }
     564       98885 :                 return MAL_SUCCEED;
     565             :         }
     566           0 :         throw(SQL, "sql.claim", SQLSTATE(3F000) "Could not claim slots");
     567             : }
     568             : 
     569             : str
     570      127780 : mvc_add_dependency_change(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     571             : {
     572      127780 :         str msg;
     573      127780 :         mvc *m = NULL;
     574      127780 :         const char *sname = *getArgReference_str(stk, pci, 1);
     575      127780 :         const char *tname = *getArgReference_str(stk, pci, 2);
     576      127780 :         lng cnt = *getArgReference_lng(stk, pci, 3);
     577      127780 :         sql_schema *s;
     578      127780 :         sql_table *t;
     579             : 
     580      127780 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
     581             :                 return msg;
     582      127780 :         if ((msg = checkSQLContext(cntxt)) != NULL)
     583             :                 return msg;
     584             : 
     585      127780 :         if ((s = mvc_bind_schema(m, sname)) == NULL)
     586           0 :                 throw(SQL, "sql.dependency_change", SQLSTATE(3F000) "Schema missing %s", sname);
     587      127779 :         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      127780 :         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      127780 :         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         381 : setVariable(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     784             : {
     785         381 :         int *res = getArgReference_int(stk, pci, 0);
     786         381 :         mvc *m = NULL;
     787         381 :         str msg;
     788         381 :         const char *sname = *getArgReference_str(stk, pci, 2);
     789         381 :         const char *varname = *getArgReference_str(stk, pci, 3);
     790         381 :         int mtype = getArgType(mb, pci, 4);
     791         381 :         sql_schema *s;
     792         381 :         sql_var *var;
     793             : 
     794         381 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
     795             :                 return msg;
     796         381 :         if ((msg = checkSQLContext(cntxt)) != NULL)
     797             :                 return msg;
     798             : 
     799         381 :         if (!(s = mvc_bind_schema(m, sname)))
     800           0 :                 throw(SQL, "sql.setVariable", SQLSTATE(3F000) "Cannot find the schema '%s'", sname);
     801             : 
     802         381 :         *res = 0;
     803         381 :         if (mtype < 0 || mtype >= 255)
     804           0 :                 throw(SQL, "sql.setVariable", SQLSTATE(42100) "Variable type error");
     805             : 
     806         381 :         if ((var = find_global_var(m, s, varname))) {
     807         523 :                 if (!strcmp("sys", s->base.name) && !strcmp("optimizer", varname)) {
     808         169 :                         const char *newopt = *getArgReference_str(stk, pci, 4);
     809         169 :                         char buf[18];
     810             : 
     811         169 :                         if (strNil(newopt))
     812          27 :                                 throw(SQL, "sql.setVariable", SQLSTATE(42000) "Variable '%s.%s' cannot be NULL", sname, varname);
     813         169 :                         if (!isOptimizerPipe(newopt) && strchr(newopt, (int) ';') == 0)
     814           5 :                                 throw(SQL, "sql.setVariable", SQLSTATE(42100) "optimizer '%s' unknown", newopt);
     815         164 :                         (void) snprintf(buf, sizeof(buf), "user_%d", cntxt->idx); /* should always suffice */
     816         164 :                         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         141 :                         } 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         339 :                 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         122 : mvc_get_value_bulk(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    1080             : {
    1081         122 :         mvc *m = NULL;
    1082         122 :         sql_schema *s;
    1083         122 :         sql_sequence *seq;
    1084         122 :         BATiter schi, seqi;
    1085         122 :         BAT *bn = NULL, *scheb = NULL, *sches = NULL, *seqb = NULL, *seqs = NULL;
    1086         122 :         lng *restrict vals;
    1087         122 :         str msg = MAL_SUCCEED;
    1088         122 :         bool nils = false;
    1089         122 :         struct canditer ci1 = {0}, ci2 = {0};
    1090         122 :         oid off1, off2;
    1091         122 :         bat *res = getArgReference_bat(stk, pci, 0), *l = getArgReference_bat(stk, pci, 1), *r = getArgReference_bat(stk, pci, 2),
    1092         122 :                 *sid1 = pci->argc == 5 ? getArgReference_bat(stk, pci, 3) : NULL, *sid2 = pci->argc == 5 ? getArgReference_bat(stk, pci, 4) : NULL;
    1093             : 
    1094         122 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    1095             :                 return msg;
    1096         122 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    1097             :                 return msg;
    1098         122 :         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         122 :         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         122 :         canditer_init(&ci1, scheb, sches);
    1107         122 :         canditer_init(&ci2, seqb, seqs);
    1108         122 :         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         122 :         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         122 :         off1 = scheb->hseqbase;
    1118         122 :         off2 = seqb->hseqbase;
    1119         122 :         schi = bat_iterator(scheb);
    1120         122 :         seqi = bat_iterator(seqb);
    1121         122 :         vals = Tloc(bn, 0);
    1122         162 :         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         122 : bailout1:
    1147         122 :         bat_iterator_end(&schi);
    1148         122 :         bat_iterator_end(&seqi);
    1149         122 : bailout:
    1150         122 :         BBPreclaim(scheb);
    1151         122 :         BBPreclaim(sches);
    1152         122 :         BBPreclaim(seqb);
    1153         122 :         BBPreclaim(seqs);
    1154         122 :         if (bn && !msg) {
    1155         122 :                 BATsetcount(bn, ci1.ncand);
    1156         122 :                 bn->tnil = nils;
    1157         122 :                 bn->tnonil = !nils;
    1158         122 :                 bn->tkey = BATcount(bn) <= 1;
    1159         122 :                 bn->tsorted = BATcount(bn) <= 1;
    1160         122 :                 bn->trevsorted = BATcount(bn) <= 1;
    1161         122 :                 *res = bn->batCacheid;
    1162         122 :                 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     1291219 : mvc_bind_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    1252             : {
    1253     1291219 :         int upd = (pci->argc == 7 || pci->argc == 9);
    1254     1291219 :         BAT *b = NULL;
    1255     1291219 :         bat *bid = getArgReference_bat(stk, pci, 0);
    1256     1291219 :         mvc *m = NULL;
    1257     1291219 :         str msg;
    1258     1291219 :         const char *sname       = *getArgReference_str(stk, pci, 2 + upd);
    1259     1291219 :         const char *tname       = *getArgReference_str(stk, pci, 3 + upd);
    1260     1291219 :         const char *cname       = *getArgReference_str(stk, pci, 4 + upd);
    1261     1291219 :         const int       access  = *getArgReference_int(stk, pci, 5 + upd);
    1262             : 
    1263     1291219 :         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     1291219 :         assert(access != QUICK);
    1267     1291219 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    1268             :                 return msg;
    1269     1290896 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    1270             :                 return msg;
    1271     1290840 :         sqlstore *store = m->store;
    1272     1290840 :         sql_schema *s = mvc_bind_schema(m, sname);
    1273     1290904 :         sql_table *t = mvc_bind_table(m, s, tname);
    1274     1290973 :         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     1290973 :         sql_column *c = mvc_bind_column(m, t, cname);
    1278             : 
    1279     1290776 :         if (partitioned_access) {
    1280             :                 /* partitioned access */
    1281      921795 :                 int part_nr = *getArgReference_int(stk, pci, 6 + upd);
    1282      921795 :                 int nr_parts = *getArgReference_int(stk, pci, 7 + upd);
    1283      921795 :                 BUN cnt = store->storage_api.count_col(m->session->tr, c, 0), psz;
    1284      922202 :                 oid l, h;
    1285      922202 :                 psz = cnt ? (cnt / nr_parts) : 0;
    1286      922202 :                 l = part_nr * psz;
    1287      922202 :                 if (l > cnt)
    1288           0 :                         l = cnt;
    1289      922202 :                 h = (part_nr + 1 == nr_parts) ? cnt : ((part_nr + 1) * psz);
    1290      922202 :                 if (h > cnt)
    1291           0 :                         h = cnt;
    1292             : 
    1293      922202 :                 if (upd) {
    1294      235802 :                         BAT *ui = NULL, *uv = NULL;
    1295      235802 :                         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      235791 :                         h--;
    1299      235791 :                         BAT* bn = BATselect(ui, NULL, &l, &h, true, true, false);
    1300      235700 :                         if(bn == NULL) {
    1301           0 :                                 BBPunfix(ui->batCacheid);
    1302           0 :                                 BBPunfix(uv->batCacheid);
    1303           0 :                                 throw(SQL, "sql.bind", GDK_EXCEPTION);
    1304             :                         }
    1305             : 
    1306      235700 :                         bat *uvl = getArgReference_bat(stk, pci, 1);
    1307             : 
    1308      235700 :                         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      235697 :                                 *bid = e_bat(TYPE_oid);
    1341      235763 :                                 *uvl = e_bat(c->type.type->localtype);
    1342      235791 :                                 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      686400 :                         int coltype = getBatType(getArgType(mb, pci, 0));
    1353      686400 :                         b = store->storage_api.bind_col(m->session->tr, c, access);
    1354      686258 :                         if (b == NULL)
    1355           0 :                                 throw(SQL, "sql.bind", SQLSTATE(42000) "Cannot bind column %s.%s.%s", sname, tname, cname);
    1356             : 
    1357      686258 :                         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      686258 :                         BAT* bn = BATslice(b, l, h);
    1363      686384 :                         if(bn == NULL) {
    1364           0 :                                 BBPunfix(b->batCacheid);
    1365           0 :                                 throw(SQL, "sql.bind", GDK_EXCEPTION);
    1366             :                         }
    1367      686384 :                         BAThseqbase(bn, l);
    1368      686393 :                         BBPunfix(b->batCacheid);
    1369      686175 :                         BBPkeepref(bn);
    1370      685980 :                         *bid = bn->batCacheid;
    1371             :                 }
    1372             :         }
    1373      368981 :         else if (upd) { /*unpartitioned access to update bats*/
    1374      112501 :                 BAT *ui = NULL, *uv = NULL;
    1375      112501 :                 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      112508 :                 bat *uvl = getArgReference_bat(stk, pci, 1);
    1379      112508 :                 BBPkeepref(ui);
    1380      112509 :                 BBPkeepref(uv);
    1381      112503 :                 *bid = ui->batCacheid;
    1382      112503 :                 *uvl = uv->batCacheid;
    1383             :         }
    1384             :         else { /*unpartitioned access to base column*/
    1385      256480 :                 int coltype = getBatType(getArgType(mb, pci, 0));
    1386      256480 :                 b = store->storage_api.bind_col(m->session->tr, c, access);
    1387      256478 :                 if (b == NULL)
    1388           0 :                         throw(SQL, "sql.bin", "Couldn't bind column");
    1389             : 
    1390      256478 :                 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      256478 :                 BBPkeepref(b);
    1395      256455 :                 *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        2525 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    1624             :                 return msg;
    1625        2525 :         sqlstore *store = m->store;
    1626        2525 :         sql_schema *s = mvc_bind_schema(m, sname);
    1627        2526 :         sql_table *t = mvc_bind_table(m, s, tname);
    1628        2525 :         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        2525 :         sql_idx *i = mvc_bind_idx(m, s, iname);
    1632             : 
    1633        2523 :         if (partitioned_access) {
    1634             :                 /* partitioned access */
    1635        1450 :                 int part_nr = *getArgReference_int(stk, pci, 6 + upd);
    1636        1450 :                 int nr_parts = *getArgReference_int(stk, pci, 7 + upd);
    1637        1450 :                 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        1452 :                         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        1452 :                         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      580532 : mvc_append_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    1805             : {
    1806      580532 :         int *res = getArgReference_int(stk, pci, 0);
    1807      580532 :         mvc *m = NULL;
    1808      580532 :         str msg;
    1809      580532 :         const char *sname = *getArgReference_str(stk, pci, 2);
    1810      580532 :         const char *tname = *getArgReference_str(stk, pci, 3);
    1811      580532 :         const char *cname = *getArgReference_str(stk, pci, 4);
    1812      580532 :         BUN offset = (BUN)*getArgReference_oid(stk, pci, 5);
    1813      580532 :         bat Pos = *getArgReference_bat(stk, pci, 6);
    1814      580532 :         ptr ins = getArgReference(stk, pci, 7);
    1815      580747 :         int tpe = getArgType(mb, pci, 7), log_res = LOG_OK;
    1816      580747 :         bool isbat = false;
    1817      580747 :         sql_schema *s;
    1818      580747 :         sql_table *t;
    1819      580747 :         sql_column *c;
    1820      580747 :         sql_idx *i;
    1821      580747 :         BAT *b = NULL, *pos = NULL;
    1822      580747 :         BUN cnt = 1;
    1823             : 
    1824      580747 :         *res = 0;
    1825      580747 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    1826             :                 return msg;
    1827      580450 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    1828             :                 return msg;
    1829      580420 :         if (isaBatType(tpe)) {
    1830      151027 :                 isbat = true;
    1831      151027 :                 tpe = getBatType(tpe);
    1832             :         }
    1833      580420 :         if (Pos != bat_nil && (pos = BATdescriptor(Pos)) == NULL)
    1834           0 :                 throw(SQL, "sql.append", SQLSTATE(HY005) "Cannot access append positions descriptor");
    1835      580420 :         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      580437 :         if (!isbat && ATOMextern(tpe) && !ATOMvarsized(tpe))
    1840          11 :                 ins = *(ptr *) ins;
    1841      151061 :         if (isbat) {
    1842      151061 :                 b =  (BAT*) ins;
    1843      151061 :                 if (VIEWtparent(b) || VIEWvtparent(b)) {
    1844             :                         /* note, b == (BAT*)ins */
    1845         723 :                         b = COLcopy(b, b->ttype, true, TRANSIENT);
    1846         723 :                         BBPreclaim(ins);
    1847         722 :                         ins = b;
    1848         722 :                         if (b == NULL)
    1849           0 :                                 throw(SQL, "sql.append", GDK_EXCEPTION);
    1850             :                 }
    1851             :         }
    1852      580436 :         s = mvc_bind_schema(m, sname);
    1853      580437 :         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      580437 :         t = mvc_bind_table(m, s, tname);
    1859      580609 :         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      580609 :         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      580609 :         if (b)
    1870      151044 :                 cnt = BATcount(b);
    1871      580609 :         sqlstore *store = m->session->tr->store;
    1872      580609 :         if (cname[0] != '%' && (c = mvc_bind_column(m, t, cname)) != NULL) {
    1873      578305 :                 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      580552 :         bat_destroy(pos);
    1882      580571 :         bat_destroy(b);
    1883      580429 :         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      162806 : DELTAbat(bat *result, const bat *col, const bat *uid, const bat *uval)
    2089             : {
    2090      162806 :         BAT *c, *u_id, *u_val, *res;
    2091             : 
    2092      162806 :         if ((u_id = BBPquickdesc(*uid)) == NULL)
    2093           0 :                 throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    2094             : 
    2095             :         /* no updates */
    2096      162672 :         if (BATcount(u_id) == 0) {
    2097      161970 :                 BBPretain(*result = *col);
    2098      161970 :                 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       50529 : DELTAsub(bat *result, const bat *col, const bat *cid, const bat *uid, const bat *uval)
    2137             : {
    2138       50529 :         BAT *c, *cminu = NULL, *u_id, *u_val, *u, *res;
    2139       50529 :         gdk_return ret;
    2140             : 
    2141       50529 :         if ((u_id = BBPquickdesc(*uid)) == NULL)
    2142           0 :                 throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    2143             : 
    2144             :         /* no updates */
    2145       50516 :         if (BATcount(u_id) == 0) {
    2146       50444 :                 BBPretain(*result = *col);
    2147       50444 :                 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      137083 : DELTAproject(bat *result, const bat *sub, const bat *col, const bat *uid, const bat *uval)
    2243             : {
    2244      137083 :         BAT *s, *c, *u_id, *u_val, *res, *tres;
    2245             : 
    2246      137083 :         if ((s = BATdescriptor(*sub)) == NULL)
    2247           0 :                 throw(MAL, "sql.delta", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    2248             : 
    2249      137084 :         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      137069 :         res = c;
    2256      137069 :         tres = BATproject(s, res);
    2257      137024 :         BBPunfix(res->batCacheid);
    2258             : 
    2259      137037 :         if (tres == NULL) {
    2260           0 :                 BBPunfix(s->batCacheid);
    2261           0 :                 throw(MAL, "sql.projectdelta", GDK_EXCEPTION);
    2262             :         }
    2263      137037 :         res = tres;
    2264             : 
    2265      137037 :         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      137077 :         if (!BATcount(u_id)) {
    2271      137062 :                 BBPunfix(u_id->batCacheid);
    2272      137049 :                 BBPunfix(s->batCacheid);
    2273      137070 :                 *result = res->batCacheid;
    2274      137070 :                 BBPkeepref(res);
    2275      137070 :                 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      215162 : SQLtid(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    2399             : {
    2400      215162 :         bat *res = getArgReference_bat(stk, pci, 0);
    2401      215162 :         mvc *m = NULL;
    2402      215162 :         str msg = MAL_SUCCEED;
    2403      215162 :         sql_trans *tr;
    2404      215162 :         const char *sname = *getArgReference_str(stk, pci, 2);
    2405      215162 :         const char *tname = *getArgReference_str(stk, pci, 3);
    2406      215162 :         sql_schema *s;
    2407      215162 :         sql_table *t;
    2408             : 
    2409      215162 :         *res = bat_nil;
    2410      215162 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    2411             :                 return msg;
    2412      215160 :         tr = m->session->tr;
    2413      215160 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    2414             :                 return msg;
    2415      215159 :         s = mvc_bind_schema(m, sname);
    2416      215161 :         if (s == NULL)
    2417           0 :                 throw(SQL, "sql.tid", SQLSTATE(3F000) "Schema missing %s",sname);
    2418      215161 :         t = mvc_bind_table(m, s, tname);
    2419      215162 :         if (t == NULL)
    2420           0 :                 throw(SQL, "sql.tid", SQLSTATE(42S02) "Table missing %s.%s",sname,tname);
    2421      215162 :         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      215162 :         sqlstore *store = m->store;
    2426             :         /* we have full table count, nr of deleted (unused rows) */
    2427      215162 :         int part_nr = 0;
    2428      215162 :         int nr_parts = 1;
    2429      215162 :         if (pci->argc == 6) {        /* partitioned version */
    2430       97933 :                 part_nr = *getArgReference_int(stk, pci, 4);
    2431       97933 :                 nr_parts = *getArgReference_int(stk, pci, 5);
    2432             :         }
    2433      215162 :         BAT *b = store->storage_api.bind_cands(tr, t, nr_parts, part_nr);
    2434      215162 :         if (b) {
    2435      215162 :                 *res = b->batCacheid;
    2436      215162 :                 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       63288 : mvc_result_set_wrap( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    2448             : {
    2449       63288 :         int *res_id =getArgReference_int(stk,pci,0);
    2450       63288 :         bat tblId= *getArgReference_bat(stk, pci,1);
    2451       63288 :         bat atrId= *getArgReference_bat(stk, pci,2);
    2452       63288 :         bat tpeId= *getArgReference_bat(stk, pci,3);
    2453       63288 :         bat lenId= *getArgReference_bat(stk, pci,4);
    2454       63288 :         bat scaleId= *getArgReference_bat(stk, pci,5);
    2455       63288 :         bat bid;
    2456       63288 :         int i, res, ok;
    2457       63288 :         const char *tblname, *colname, *tpename;
    2458       63288 :         str msg= MAL_SUCCEED;
    2459       63288 :         int *digits, *scaledigits;
    2460       63288 :         oid o = 0;
    2461       63288 :         BATiter itertbl,iteratr,itertpe,iterdig,iterscl;
    2462       63288 :         backend *be = NULL;
    2463       63288 :         BAT *b = NULL, *tbl = NULL, *atr = NULL, *tpe = NULL,*len = NULL,*scale = NULL;
    2464             : 
    2465       63288 :         if ((msg = getBackendContext(cntxt, &be)) != NULL)
    2466             :                 return msg;
    2467       63289 :         bid = *getArgReference_bat(stk,pci,6);
    2468       63289 :         b = BATdescriptor(bid);
    2469       63289 :         if ( b == NULL) {
    2470           0 :                 msg = createException(SQL, "sql.resultSet", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    2471           0 :                 goto wrapup_result_set;
    2472             :         }
    2473       63289 :         res = *res_id = mvc_result_table(be, mb->tag, pci->argc - (pci->retc + 5), Q_TABLE);
    2474       63288 :         BBPunfix(b->batCacheid);
    2475       63289 :         if (res < 0) {
    2476           0 :                 msg = createException(SQL, "sql.resultSet", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    2477           0 :                 goto wrapup_result_set;
    2478             :         }
    2479             : 
    2480       63289 :         tbl = BATdescriptor(tblId);
    2481       63289 :         atr = BATdescriptor(atrId);
    2482       63289 :         tpe = BATdescriptor(tpeId);
    2483       63289 :         len = BATdescriptor(lenId);
    2484       63289 :         scale = BATdescriptor(scaleId);
    2485       63288 :         if (tbl == NULL || atr == NULL || tpe == NULL || len == NULL || scale == NULL)
    2486           0 :                 goto wrapup_result_set;
    2487             :         /* mimic the old rsColumn approach; */
    2488       63288 :         itertbl = bat_iterator(tbl);
    2489       63287 :         iteratr = bat_iterator(atr);
    2490       63288 :         itertpe = bat_iterator(tpe);
    2491       63289 :         iterdig = bat_iterator(len);
    2492       63289 :         iterscl = bat_iterator(scale);
    2493       63289 :         digits = (int*) iterdig.base;
    2494       63289 :         scaledigits = (int*) iterscl.base;
    2495             : 
    2496      336081 :         for( i = 6; msg == MAL_SUCCEED && i< pci->argc; i++, o++){
    2497      272793 :                 bid = *getArgReference_bat(stk,pci,i);
    2498      272793 :                 tblname = BUNtvar(itertbl,o);
    2499      272796 :                 colname = BUNtvar(iteratr,o);
    2500      272792 :                 tpename = BUNtvar(itertpe,o);
    2501      272789 :                 b = BATdescriptor(bid);
    2502      272795 :                 if ( b == NULL)
    2503           0 :                         msg = createException(SQL, "sql.resultSet", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    2504      272795 :                 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      272805 :                 if( b)
    2507      272805 :                         BBPunfix(bid);
    2508             :         }
    2509       63288 :         bat_iterator_end(&itertbl);
    2510       63289 :         bat_iterator_end(&iteratr);
    2511       63289 :         bat_iterator_end(&itertpe);
    2512       63289 :         bat_iterator_end(&iterdig);
    2513       63289 :         bat_iterator_end(&iterscl);
    2514             :         /* now send it to the channel cntxt->fdout */
    2515       63289 :         if (bstream_getoob(cntxt->fdin))
    2516           0 :                 msg = createException(SQL, "sql.resultSet", SQLSTATE(HY000) "Query aboted");
    2517       63288 :         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       63288 :   wrapup_result_set:
    2520       63288 :         cntxt->qryctx.starttime = 0;
    2521       63288 :         cntxt->qryctx.endtime = 0;
    2522       63288 :         mb->optimize = 0;
    2523       63288 :         if( tbl) BBPunfix(tblId);
    2524       63288 :         if( atr) BBPunfix(atrId);
    2525       63288 :         if( tpe) BBPunfix(tpeId);
    2526       63289 :         if( len) BBPunfix(lenId);
    2527       63288 :         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         528 : mvc_row_result_wrap( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    2689             : {
    2690         528 :         int *res_id= getArgReference_int(stk, pci,0);
    2691         528 :         bat tblId= *getArgReference_bat(stk, pci,1);
    2692         528 :         bat atrId= *getArgReference_bat(stk, pci,2);
    2693         528 :         bat tpeId= *getArgReference_bat(stk, pci,3);
    2694         528 :         bat lenId= *getArgReference_bat(stk, pci,4);
    2695         528 :         bat scaleId= *getArgReference_bat(stk, pci,5);
    2696         528 :         int i, res, ok;
    2697         528 :         const char *tblname, *colname, *tpename;
    2698         528 :         str msg= MAL_SUCCEED;
    2699         528 :         int *digits, *scaledigits;
    2700         528 :         oid o = 0;
    2701         528 :         BATiter itertbl,iteratr,itertpe,iterdig,iterscl;
    2702         528 :         backend *be = NULL;
    2703         528 :         ptr v;
    2704         528 :         int mtype;
    2705         528 :         BAT *tbl = NULL, *atr = NULL, *tpe = NULL, *len = NULL, *scale = NULL;
    2706             : 
    2707         528 :         if ((msg = getBackendContext(cntxt, &be)) != NULL)
    2708             :                 return msg;
    2709         528 :         res = *res_id = mvc_result_table(be, mb->tag, pci->argc - (pci->retc + 5), Q_TABLE);
    2710         528 :         if (res < 0) {
    2711           0 :                 msg = createException(SQL, "sql.resultSet", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    2712           0 :                 goto wrapup_result_set;
    2713             :         }
    2714             : 
    2715         528 :         tbl = BATdescriptor(tblId);
    2716         528 :         atr = BATdescriptor(atrId);
    2717         528 :         tpe = BATdescriptor(tpeId);
    2718         528 :         len = BATdescriptor(lenId);
    2719         528 :         scale = BATdescriptor(scaleId);
    2720         528 :         if( tbl == NULL || atr == NULL || tpe == NULL || len == NULL || scale == NULL)
    2721           0 :                 goto wrapup_result_set;
    2722             :         /* mimic the old rsColumn approach; */
    2723         528 :         itertbl = bat_iterator(tbl);
    2724         528 :         iteratr = bat_iterator(atr);
    2725         528 :         itertpe = bat_iterator(tpe);
    2726         528 :         iterdig = bat_iterator(len);
    2727         528 :         iterscl = bat_iterator(scale);
    2728         528 :         digits = (int*) iterdig.base;
    2729         528 :         scaledigits = (int*) iterscl.base;
    2730             : 
    2731        1862 :         for( i = 6; msg == MAL_SUCCEED && i< pci->argc; i++, o++){
    2732        1334 :                 tblname = BUNtvar(itertbl,o);
    2733        1334 :                 colname = BUNtvar(iteratr,o);
    2734        1334 :                 tpename = BUNtvar(itertpe,o);
    2735             : 
    2736        1334 :                 v = getArgReference(stk, pci, i);
    2737        1334 :                 mtype = getArgType(mb, pci, i);
    2738        1334 :                 if (ATOMextern(mtype))
    2739         181 :                         v = *(ptr *) v;
    2740        1334 :                 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         528 :         bat_iterator_end(&itertbl);
    2751         528 :         bat_iterator_end(&iteratr);
    2752         528 :         bat_iterator_end(&itertpe);
    2753         528 :         bat_iterator_end(&iterdig);
    2754         528 :         bat_iterator_end(&iterscl);
    2755         528 :         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         528 :   wrapup_result_set:
    2758         528 :         cntxt->qryctx.starttime = 0;
    2759         528 :         cntxt->qryctx.endtime = 0;
    2760         528 :         mb->optimize = 0;
    2761         528 :         if( tbl) BBPunfix(tblId);
    2762         528 :         if( atr) BBPunfix(atrId);
    2763         528 :         if( tpe) BBPunfix(tpeId);
    2764         528 :         if( len) BBPunfix(lenId);
    2765         528 :         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       63288 : mvc_table_result_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    2926             : {
    2927       63288 :         str res = MAL_SUCCEED;
    2928       63288 :         backend *be = NULL;
    2929       63288 :         str msg;
    2930       63288 :         int *res_id;
    2931       63288 :         int nr_cols;
    2932       63288 :         mapi_query_t qtype;
    2933             : 
    2934       63288 :         if ( pci->argc > 6)
    2935       63288 :                 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      127520 : mvc_affected_rows_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    2956             : {
    2957      127520 :         backend *b = NULL;
    2958      127520 :         int *res = getArgReference_int(stk, pci, 0), ok;
    2959             : #ifndef NDEBUG
    2960      127520 :         int mtype = getArgType(mb, pci, 2);
    2961             : #endif
    2962      127520 :         lng nr;
    2963      127520 :         str msg;
    2964             : 
    2965      127520 :         (void) mb;              /* NOT USED */
    2966      127520 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    2967             :                 return msg;
    2968      127520 :         *res = 0;
    2969      127520 :         assert(mtype == TYPE_lng);
    2970      127520 :         nr = *getArgReference_lng(stk, pci, 2);
    2971      127520 :         b = cntxt->sqlcontext;
    2972      127520 :         ok = mvc_export_affrows(b, b->out, nr, "", mb->tag, cntxt->qryctx.starttime, mb->optimize);
    2973      127519 :         cntxt->qryctx.starttime = 0;
    2974      127519 :         cntxt->qryctx.endtime = 0;
    2975      127519 :         mb->optimize = 0;
    2976      127519 :         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       19250 : mvc_export_operation_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    3055             : {
    3056       19250 :         backend *b = NULL;
    3057       19250 :         str msg;
    3058       19250 :         int ok = 0;
    3059             : 
    3060       19250 :         (void) stk;             /* NOT USED */
    3061       19250 :         (void) pci;             /* NOT USED */
    3062       19250 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    3063             :                 return msg;
    3064       19250 :         b = cntxt->sqlcontext;
    3065       19250 :         if (b->out)
    3066       19249 :                 ok = mvc_export_operation(b, b->out, "", cntxt->qryctx.starttime, mb->optimize);
    3067       19250 :         cntxt->qryctx.starttime = 0;
    3068       19250 :         cntxt->qryctx.endtime = 0;
    3069       19250 :         mb->optimize = 0;
    3070       19250 :         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       60296 : mvc_scalar_value_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    3078             : {
    3079       60296 :         const char *tn = *getArgReference_str(stk, pci, 1);
    3080       60296 :         const char *cn = *getArgReference_str(stk, pci, 2);
    3081       60296 :         const char *type = *getArgReference_str(stk, pci, 3);
    3082       60296 :         int digits = *getArgReference_int(stk, pci, 4);
    3083       60296 :         int scale = *getArgReference_int(stk, pci, 5);
    3084       60296 :         ptr p = getArgReference(stk, pci, 7);
    3085       60296 :         int mtype = getArgType(mb, pci, 7);
    3086       60296 :         str msg;
    3087       60296 :         backend *be = NULL;
    3088       60296 :         int res_id, ok;
    3089       60296 :         (void) mb;              /* NOT USED */
    3090       60296 :         if ((msg = getBackendContext(cntxt, &be)) != NULL)
    3091             :                 return msg;
    3092       60296 :         if (ATOMextern(mtype))
    3093         606 :                 p = *(ptr *) p;
    3094             : 
    3095             :         // scalar values are single-column result sets
    3096       60296 :         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       60296 :         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       60296 :         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       60294 :         ok = mvc_export_result(be, be->out, res_id, true, cntxt->qryctx.starttime, mb->optimize);
    3115       60294 :         cntxt->qryctx.starttime = 0;
    3116       60294 :         cntxt->qryctx.endtime = 0;
    3117       60294 :         mb->optimize = 0;
    3118       60294 :         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        1094 : bat2return(MalStkPtr stk, InstrPtr pci, BAT **b)
    3125             : {
    3126        1094 :         int i;
    3127             : 
    3128       11334 :         for (i = 0; i < pci->retc; i++) {
    3129       10240 :                 *getArgReference_bat(stk, pci, i) = b[i]->batCacheid;
    3130       10240 :                 BBPkeepref(b[i]);
    3131             :         }
    3132        1094 : }
    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        1121 : mvc_import_table_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    3140             : {
    3141        1121 :         backend *be;
    3142        1121 :         BAT **b = NULL;
    3143        1121 :         sql_table *t = *(sql_table **) getArgReference(stk, pci, pci->retc + 0);
    3144        1121 :         const char *tsep = *getArgReference_str(stk, pci, pci->retc + 1);
    3145        1121 :         const char *rsep = *getArgReference_str(stk, pci, pci->retc + 2);
    3146        1121 :         const char *ssep = *getArgReference_str(stk, pci, pci->retc + 3);
    3147        1121 :         const char *ns = *getArgReference_str(stk, pci, pci->retc + 4);
    3148        1121 :         const char *fname = *getArgReference_str(stk, pci, pci->retc + 5);
    3149        1121 :         lng sz = *getArgReference_lng(stk, pci, pci->retc + 6);
    3150        1121 :         lng offset = *getArgReference_lng(stk, pci, pci->retc + 7);
    3151        1121 :         int besteffort = *getArgReference_int(stk, pci, pci->retc + 8);
    3152        1121 :         const char *fixed_widths = *getArgReference_str(stk, pci, pci->retc + 9);
    3153        1121 :         int onclient = *getArgReference_int(stk, pci, pci->retc + 10);
    3154        1121 :         bool escape = *getArgReference_int(stk, pci, pci->retc + 11);
    3155        1121 :         const char *decsep = *getArgReference_str(stk, pci, pci->retc + 12);
    3156        1121 :         const char *decskip = *getArgReference_str(stk, pci, pci->retc + 13);
    3157        1121 :         str msg = MAL_SUCCEED;
    3158        1121 :         bstream *s = NULL;
    3159        1121 :         stream *ss;
    3160             : 
    3161        1121 :         (void) mb;              /* NOT USED */
    3162        1121 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    3163             :                 return msg;
    3164        1121 :         if (onclient && !cntxt->filetrans)
    3165           0 :                 throw(MAL, "sql.copy_from", SQLSTATE(42000) "Cannot transfer files from client");
    3166        1121 :         if (strNil(decsep))
    3167           0 :                 throw(MAL, "sql.copy_from", SQLSTATE(42000) "decimal separator cannot be nil");
    3168        1127 :         if (strNil(decskip))
    3169             :                 decskip = NULL;
    3170             : 
    3171        1121 :         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        1731 :         if (*ssep == 0 || strNil(ssep))
    3176             :                 ssep = NULL;
    3177             : 
    3178        1121 :         if (strNil(fname))
    3179         782 :                 fname = NULL;
    3180        1121 :         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         339 :                 if (onclient) {
    3184          48 :                         ss = mapi_request_upload(fname, false, be->mvc->scanner.rs, be->mvc->scanner.ws);
    3185             :                 } else {
    3186         291 :                         ss = open_rastream(fname);
    3187             :                 }
    3188         339 :                 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         674 :                 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         337 :                 s = bstream_create(ss, 0x200000);
    3234             : #endif
    3235         337 :                 if (s == NULL) {
    3236           0 :                         close_stream(ss);
    3237           0 :                         throw(MAL, "sql.copy_from", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    3238             :                 }
    3239         337 :                 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         337 :                 bstream_destroy(s);
    3242             :         }
    3243        1119 :         if (b && !msg)
    3244        1094 :                 bat2return(stk, pci, b);
    3245        1119 :         GDKfree(b);
    3246        1119 :         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          69 :                 if (BUNappend(language, getScenarioLanguage(c), false) != GDK_SUCCEED)
    3681           0 :                         goto bailout;
    3682          69 :                 s = c->peer ? c->peer : str_nil;
    3683          69 :                 if (BUNappend(peer, s, false) != GDK_SUCCEED)
    3684           0 :                         goto bailout;
    3685          69 :                 s = c->client_hostname ? c->client_hostname : str_nil;
    3686          69 :                 if (BUNappend(hostname, s, false) != GDK_SUCCEED)
    3687           0 :                         goto bailout;
    3688          69 :                 s = c->client_application ? c->client_application : str_nil;
    3689          69 :                 if (BUNappend(application, s, false) != GDK_SUCCEED)
    3690           0 :                         goto bailout;
    3691          69 :                 s = c->client_library ? c->client_library : str_nil;
    3692          69 :                 if (BUNappend(client, s, false) != GDK_SUCCEED)
    3693           0 :                         goto bailout;
    3694          69 :                 pid = c->client_pid;
    3695          71 :                 if (BUNappend(clientpid, pid ? &pid : &lng_nil, false) != GDK_SUCCEED)
    3696           0 :                         goto bailout;
    3697          69 :                 s = c->client_remark ? c->client_remark : str_nil;
    3698          69 :                 if (BUNappend(remark, s, false) != GDK_SUCCEED)
    3699           0 :                         goto bailout;
    3700             :         }
    3701          57 :         MT_lock_unset(&mal_contextLock);
    3702             : 
    3703          57 :         *idId = id->batCacheid;
    3704          57 :         BBPkeepref(id);
    3705          57 :         *userId = user->batCacheid;
    3706          57 :         BBPkeepref(user);
    3707          57 :         *loginId = login->batCacheid;
    3708          57 :         BBPkeepref(login);
    3709          57 :         *sessiontimeoutId = sessiontimeout->batCacheid;
    3710          57 :         BBPkeepref(sessiontimeout);
    3711          57 :         *querytimeoutId = querytimeout->batCacheid;
    3712          57 :         BBPkeepref(querytimeout);
    3713          57 :         *idleId = idle->batCacheid;
    3714          57 :         BBPkeepref(idle);
    3715             : 
    3716          57 :         *optId = opt->batCacheid;
    3717          57 :         BBPkeepref(opt);
    3718          57 :         *wlimitId = wlimit->batCacheid;
    3719          57 :         BBPkeepref(wlimit);
    3720          57 :         *mlimitId = mlimit->batCacheid;
    3721          57 :         BBPkeepref(mlimit);
    3722          57 :         *languageId = language->batCacheid;
    3723          57 :         BBPkeepref(language);
    3724          57 :         *peerId = peer->batCacheid;
    3725          57 :         BBPkeepref(peer);
    3726          57 :         *hostnameId = hostname->batCacheid;
    3727          57 :         BBPkeepref(hostname);
    3728          57 :         *applicationId = application->batCacheid;
    3729          57 :         BBPkeepref(application);
    3730          57 :         *clientId = client->batCacheid;
    3731          57 :         BBPkeepref(client);
    3732          57 :         *clientpidId = clientpid->batCacheid;
    3733          57 :         BBPkeepref(clientpid);
    3734          57 :         *remarkId = remark->batCacheid;
    3735          57 :         BBPkeepref(remark);
    3736             : 
    3737          57 :         return MAL_SUCCEED;
    3738             : 
    3739           0 :   bailout:
    3740           0 :         MT_lock_unset(&mal_contextLock);
    3741           0 :         BBPunfix(id->batCacheid);
    3742           0 :         BBPunfix(user->batCacheid);
    3743           0 :         BBPunfix(login->batCacheid);
    3744           0 :         BBPunfix(sessiontimeout->batCacheid);
    3745           0 :         BBPunfix(querytimeout->batCacheid);
    3746           0 :         BBPunfix(idle->batCacheid);
    3747             : 
    3748           0 :         BBPunfix(opt->batCacheid);
    3749           0 :         BBPunfix(wlimit->batCacheid);
    3750           0 :         BBPunfix(mlimit->batCacheid);
    3751           0 :         BBPunfix(language->batCacheid);
    3752           0 :         BBPunfix(peer->batCacheid);
    3753           0 :         BBPunfix(hostname->batCacheid);
    3754           0 :         BBPunfix(application->batCacheid);
    3755           0 :         BBPunfix(client->batCacheid);
    3756           0 :         BBPunfix(clientpid->batCacheid);
    3757           0 :         BBPunfix(remark->batCacheid);
    3758           0 :         return msg;
    3759             : }
    3760             : 
    3761             : str
    3762         107 : sql_querylog_catalog(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    3763             : {
    3764         107 :         int i;
    3765         107 :         BAT *t[8];
    3766         107 :         str msg;
    3767             : 
    3768         107 :         (void) cntxt;
    3769         107 :         (void) mb;
    3770         107 :         msg = QLOGcatalog(t);
    3771         107 :         if( msg != MAL_SUCCEED)
    3772             :                 return msg;
    3773         963 :         for (i = 0; i < 8; i++)
    3774         856 :         if( t[i]){
    3775         856 :                 *getArgReference_bat(stk, pci, i) = t[i]->batCacheid;
    3776         856 :                 BBPkeepref(t[i]);
    3777             :         } else
    3778           0 :                 throw(SQL,"sql.querylog", SQLSTATE(45000) "Missing query catalog BAT");
    3779             :         return MAL_SUCCEED;
    3780             : }
    3781             : 
    3782             : str
    3783          79 : sql_querylog_calls(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    3784             : {
    3785          79 :         int i;
    3786          79 :         BAT *t[10];
    3787          79 :         str msg;
    3788             : 
    3789          79 :         (void) cntxt;
    3790          79 :         (void) mb;
    3791          79 :         msg = QLOGcalls(t);
    3792          79 :         if( msg != MAL_SUCCEED)
    3793             :                 return msg;
    3794         790 :         for (i = 0; i < 9; i++)
    3795         711 :         if( t[i]){
    3796         711 :                 *getArgReference_bat(stk, pci, i) = t[i]->batCacheid;
    3797         711 :                 BBPkeepref(t[i]);
    3798             :         } else
    3799           0 :                 throw(SQL,"sql.querylog", SQLSTATE(45000) "Missing query call BAT");
    3800             :         return MAL_SUCCEED;
    3801             : }
    3802             : 
    3803             : str
    3804           1 : sql_querylog_empty(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    3805             : {
    3806           1 :         (void) cntxt;
    3807           1 :         (void) mb;
    3808           1 :         (void) stk;
    3809           1 :         (void) pci;
    3810           1 :         return QLOGempty(NULL);
    3811             : }
    3812             : 
    3813             : /* str sql_rowid(oid *rid, ptr v, str *sname, str *tname); */
    3814             : str
    3815           0 : sql_rowid(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    3816             : {
    3817           0 :         BAT *b;
    3818           0 :         mvc *m = NULL;
    3819           0 :         str msg;
    3820           0 :         sql_schema *s = NULL;
    3821           0 :         sql_table *t = NULL;
    3822           0 :         sql_column *c = NULL;
    3823           0 :         oid *rid = getArgReference_oid(stk, pci, 0);
    3824           0 :         const char *sname = *getArgReference_str(stk, pci, 2);
    3825           0 :         const char *tname = *getArgReference_str(stk, pci, 3);
    3826             : 
    3827           0 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    3828             :                 return msg;
    3829           0 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    3830             :                 return msg;
    3831           0 :         s = mvc_bind_schema(m, sname);
    3832           0 :         if (s == NULL)
    3833           0 :                 throw(SQL, "calc.rowid", SQLSTATE(3F000) "Schema missing %s", sname);
    3834           0 :         t = mvc_bind_table(m, s, tname);
    3835           0 :         if (t == NULL)
    3836           0 :                 throw(SQL, "calc.rowid", SQLSTATE(42S02) "Table missing %s.%s",sname,tname);
    3837           0 :         if (!isTable(t))
    3838           0 :                 throw(SQL, "calc.rowid", SQLSTATE(42000) "%s '%s' is not persistent",
    3839           0 :                           TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
    3840           0 :         if (!ol_first_node(t->columns))
    3841           0 :                 throw(SQL, "calc.rowid", SQLSTATE(42S22) "Column missing %s.%s",sname,tname);
    3842           0 :         c = ol_first_node(t->columns)->data;
    3843             :         /* HACK, get insert bat */
    3844           0 :         sqlstore *store = m->session->tr->store;
    3845           0 :         b = store->storage_api.bind_col(m->session->tr, c, QUICK);
    3846           0 :         if( b == NULL)
    3847           0 :                 throw(SQL,"calc.rowid", SQLSTATE(HY005) "Cannot access column descriptor");
    3848             :         /* UGH (move into storage backends!!) */
    3849           0 :         *rid = BATcount(b);
    3850           0 :         return MAL_SUCCEED;
    3851             : }
    3852             : 
    3853             : static str
    3854           0 : do_sql_rank_grp(bat *rid, const bat *bid, const bat *gid, int nrank, int dense, const char *name)
    3855             : {
    3856           0 :         BAT *r, *b, *g;
    3857           0 :         BUN p, q;
    3858           0 :         BATiter bi, gi;
    3859           0 :         int (*ocmp) (const void *, const void *);
    3860           0 :         int (*gcmp) (const void *, const void *);
    3861           0 :         const void *oc, *gc, *on, *gn;
    3862           0 :         int rank = 1;
    3863           0 :         int c;
    3864             : 
    3865           0 :         if ((b = BATdescriptor(*bid)) == NULL)
    3866           0 :                 throw(SQL, name, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    3867           0 :         if ((g = BATdescriptor(*gid)) == NULL) {
    3868           0 :                 BBPunfix(b->batCacheid);
    3869           0 :                 throw(SQL, name, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    3870             :         }
    3871           0 :         bi = bat_iterator(b);
    3872           0 :         gi = bat_iterator(g);
    3873           0 :         ocmp = ATOMcompare(b->ttype);
    3874           0 :         gcmp = ATOMcompare(g->ttype);
    3875           0 :         oc = BUNtail(bi, 0);
    3876           0 :         gc = BUNtail(gi, 0);
    3877           0 :         if (!ALIGNsynced(b, g)) {
    3878           0 :                 bat_iterator_end(&bi);
    3879           0 :                 bat_iterator_end(&gi);
    3880           0 :                 BBPunfix(b->batCacheid);
    3881           0 :                 BBPunfix(g->batCacheid);
    3882           0 :                 throw(SQL, name, SQLSTATE(45000) "Internal error, columns not aligned");
    3883             :         }
    3884             : /*
    3885             :   if (!b->tsorted) {
    3886             :   BBPunfix(b->batCacheid);
    3887             :   BBPunfix(g->batCacheid);
    3888             :   throw(SQL, name, SQLSTATE(45000) "Internal error, columns not sorted");
    3889             :   }
    3890             : */
    3891           0 :         r = COLnew(b->hseqbase, TYPE_int, BATcount(b), TRANSIENT);
    3892           0 :         if (r == NULL) {
    3893           0 :                 bat_iterator_end(&bi);
    3894           0 :                 bat_iterator_end(&gi);
    3895           0 :                 BBPunfix(b->batCacheid);
    3896           0 :                 BBPunfix(g->batCacheid);
    3897           0 :                 throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
    3898             :         }
    3899           0 :         BATloop(b, p, q) {
    3900           0 :                 on = BUNtail(bi, p);
    3901           0 :                 gn = BUNtail(gi, p);
    3902             : 
    3903           0 :                 if ((c = ocmp(on, oc)) != 0)
    3904           0 :                         rank = nrank;
    3905           0 :                 if (gcmp(gn, gc) != 0)
    3906           0 :                         c = rank = nrank = 1;
    3907           0 :                 oc = on;
    3908           0 :                 gc = gn;
    3909           0 :                 if (BUNappend(r, &rank, false) != GDK_SUCCEED) {
    3910           0 :                         bat_iterator_end(&bi);
    3911           0 :                         bat_iterator_end(&gi);
    3912           0 :                         BBPunfix(b->batCacheid);
    3913           0 :                         BBPunfix(g->batCacheid);
    3914           0 :                         BBPunfix(r->batCacheid);
    3915           0 :                         throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
    3916             :                 }
    3917           0 :                 nrank += !dense || c;
    3918             :         }
    3919           0 :         bat_iterator_end(&bi);
    3920           0 :         bat_iterator_end(&gi);
    3921           0 :         BBPunfix(b->batCacheid);
    3922           0 :         BBPunfix(g->batCacheid);
    3923           0 :         *rid = r->batCacheid;
    3924           0 :         BBPkeepref(r);
    3925           0 :         return MAL_SUCCEED;
    3926             : }
    3927             : 
    3928             : static str
    3929           0 : do_sql_rank(bat *rid, const bat *bid, int nrank, int dense, const char *name)
    3930             : {
    3931           0 :         BAT *r, *b;
    3932           0 :         BATiter bi;
    3933           0 :         int (*cmp) (const void *, const void *);
    3934           0 :         const void *cur, *n;
    3935           0 :         BUN p, q;
    3936           0 :         int rank = 1;
    3937           0 :         int c;
    3938             : 
    3939           0 :         if ((b = BATdescriptor(*bid)) == NULL)
    3940           0 :                 throw(SQL, name, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    3941           0 :         bi = bat_iterator(b);
    3942           0 :         if (!bi.sorted && !bi.revsorted) {
    3943           0 :                 bat_iterator_end(&bi);
    3944           0 :                 BBPunfix(b->batCacheid);
    3945           0 :                 throw(SQL, name, SQLSTATE(45000) "Internal error, columns not sorted");
    3946             :         }
    3947             : 
    3948           0 :         cmp = ATOMcompare(bi.type);
    3949           0 :         cur = BUNtail(bi, 0);
    3950           0 :         r = COLnew(b->hseqbase, TYPE_int, BATcount(b), TRANSIENT);
    3951           0 :         if (r == NULL) {
    3952           0 :                 bat_iterator_end(&bi);
    3953           0 :                 BBPunfix(b->batCacheid);
    3954           0 :                 throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
    3955             :         }
    3956           0 :         if (BATtdensebi(&bi)) {
    3957           0 :                 BATloop(b, p, q) {
    3958           0 :                         if (BUNappend(r, &rank, false) != GDK_SUCCEED)
    3959           0 :                                 goto bailout;
    3960           0 :                         rank++;
    3961             :                 }
    3962             :         } else {
    3963           0 :                 BATloop(b, p, q) {
    3964           0 :                         n = BUNtail(bi, p);
    3965           0 :                         if ((c = cmp(n, cur)) != 0)
    3966           0 :                                 rank = nrank;
    3967           0 :                         cur = n;
    3968           0 :                         if (BUNappend(r, &rank, false) != GDK_SUCCEED)
    3969           0 :                                 goto bailout;
    3970           0 :                         nrank += !dense || c;
    3971             :                 }
    3972             :         }
    3973           0 :         bat_iterator_end(&bi);
    3974           0 :         BBPunfix(b->batCacheid);
    3975           0 :         *rid = r->batCacheid;
    3976           0 :         BBPkeepref(r);
    3977           0 :         return MAL_SUCCEED;
    3978           0 :   bailout:
    3979           0 :         bat_iterator_end(&bi);
    3980           0 :         BBPunfix(b->batCacheid);
    3981           0 :         BBPunfix(r->batCacheid);
    3982           0 :         throw(SQL, name, SQLSTATE(HY013) MAL_MALLOC_FAIL);
    3983             : }
    3984             : 
    3985             : str
    3986           0 : sql_rank_grp(bat *rid, const bat *bid, const bat *gid, const bat *gpe)
    3987             : {
    3988           0 :         (void) gpe;
    3989           0 :         return do_sql_rank_grp(rid, bid, gid, 1, 0, "sql.rank_grp");
    3990             : }
    3991             : 
    3992             : str
    3993           0 : sql_dense_rank_grp(bat *rid, const bat *bid, const bat *gid, const bat *gpe)
    3994             : {
    3995           0 :         (void) gpe;
    3996           0 :         return do_sql_rank_grp(rid, bid, gid, 2, 1, "sql.dense_rank_grp");
    3997             : }
    3998             : 
    3999             : str
    4000           0 : sql_rank(bat *rid, const bat *bid)
    4001             : {
    4002           0 :         return do_sql_rank(rid, bid, 1, 0, "sql.rank");
    4003             : }
    4004             : 
    4005             : str
    4006           0 : sql_dense_rank(bat *rid, const bat *bid)
    4007             : {
    4008           0 :         return do_sql_rank(rid, bid, 2, 1, "sql.dense_rank");
    4009             : }
    4010             : 
    4011             : str
    4012           5 : SQLargRecord(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    4013             : {
    4014           5 :         str s, t, *ret;
    4015             : 
    4016           5 :         (void) cntxt;
    4017           5 :         ret = getArgReference_str(stk, pci, 0);
    4018           5 :         s = instruction2str(mb, stk, getInstrPtr(mb, 0), LIST_MAL_CALL);
    4019           5 :         if(s == NULL)
    4020           0 :                 throw(SQL, "sql.argRecord", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    4021           5 :         t = strchr(s, ' ');
    4022           5 :         if( ! t)
    4023           0 :                 t = strchr(s, '\t');
    4024           5 :         *ret = GDKstrdup(t ? t + 1 : s);
    4025           5 :         GDKfree(s);
    4026           5 :         if(*ret == NULL)
    4027           0 :                 throw(SQL, "sql.argRecord", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    4028             :         return MAL_SUCCEED;
    4029             : }
    4030             : 
    4031             : /*
    4032             :  * The drop_hash operation cleans up any hash indices on any of the tables columns.
    4033             :  */
    4034             : str
    4035           0 : SQLdrop_hash(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    4036             : {
    4037           0 :         const char *sch = *getArgReference_str(stk, pci, 1);
    4038           0 :         const char *tbl = *getArgReference_str(stk, pci, 2);
    4039           0 :         sql_schema *s;
    4040           0 :         sql_table *t;
    4041           0 :         mvc *m = NULL;
    4042           0 :         str msg;
    4043             : 
    4044           0 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    4045             :                 return msg;
    4046           0 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    4047             :                 return msg;
    4048           0 :         s = mvc_bind_schema(m, sch);
    4049           0 :         if (s == NULL)
    4050           0 :                 throw(SQL, "sql.drop_hash", SQLSTATE(3F000) "Schema missing %s",sch);
    4051           0 :         if (!mvc_schema_privs(m, s))
    4052           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);
    4053           0 :         t = mvc_bind_table(m, s, tbl);
    4054           0 :         if (t == NULL)
    4055           0 :                 throw(SQL, "sql.drop_hash", SQLSTATE(42S02) "Table missing %s.%s",sch, tbl);
    4056           0 :         if (!isTable(t))
    4057           0 :                 throw(SQL, "sql.drop_hash", SQLSTATE(42000) "%s '%s' is not persistent",
    4058           0 :                           TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
    4059             : 
    4060           0 :         sqlstore *store = m->session->tr->store;
    4061           0 :         for (node *n = ol_first_node(t->columns); n; n = n->next) {
    4062           0 :                 sql_column *c = n->data;
    4063           0 :                 BAT *b = NULL, *nb = NULL;
    4064             : 
    4065           0 :                 if (!(b = store->storage_api.bind_col(m->session->tr, c, RDONLY)))
    4066           0 :                         throw(SQL, "sql.drop_hash", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    4067           0 :                 if (VIEWtparent(b) && (nb = BBP_desc(VIEWtparent(b)))) {
    4068           0 :                         BBPunfix(b->batCacheid);
    4069           0 :                         if (!(b = BATdescriptor(nb->batCacheid)))
    4070           0 :                                 throw(SQL, "sql.drop_hash", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    4071             :                 }
    4072           0 :                 HASHdestroy(b);
    4073           0 :                 BBPunfix(b->batCacheid);
    4074             :         }
    4075             :         return MAL_SUCCEED;
    4076             : }
    4077             : 
    4078             : /* after an update on the optimizer catalog, we have to change
    4079             :  * the internal optimizer pipe line administration
    4080             :  * The minimal and default pipelines may not be changed.
    4081             :  */
    4082             : str
    4083           0 : SQLoptimizersUpdate(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    4084             : {
    4085           0 :         mvc *m = NULL;
    4086           0 :         str msg;
    4087             : 
    4088           0 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    4089             :                 return msg;
    4090           0 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    4091             :                 return msg;
    4092             :         /* find the optimizer pipeline */
    4093           0 :         (void) stk;
    4094           0 :         (void) pci;
    4095           0 :         throw(SQL, "updateOptimizer", SQLSTATE(0A000) PROGRAM_NYI);
    4096             : }
    4097             : 
    4098             : static str
    4099       90652 : sql_storage_appendrow(BAT *bs, const char *sname, const char *tname, const char *cname,
    4100             :                                           int access, const char *tpname,
    4101             :                                           BAT *sch, BAT *tab, BAT *col, BAT *type, BAT *loc,
    4102             :                                           BAT *cnt, BAT *atom, BAT *size, BAT *heap, BAT *indices,
    4103             :                                           BAT *phash, BAT *sort, BAT *imprints, BAT *mode,
    4104             :                                           BAT *revsort, BAT *key, BAT *oidx)
    4105             : {
    4106       90652 :         BATiter bsi = bat_iterator(bs);
    4107       90652 :         lng sz;
    4108       90652 :         int w;
    4109       90652 :         bit bitval;
    4110             : 
    4111      181304 :         if (BUNappend(sch, sname, false) != GDK_SUCCEED ||
    4112      181304 :                 BUNappend(tab, tname, false) != GDK_SUCCEED ||
    4113       90652 :                 BUNappend(col, cname, false) != GDK_SUCCEED)
    4114           0 :                 goto bailout1;
    4115       90652 :         if (access == TABLE_WRITABLE) {
    4116       77291 :                 if (BUNappend(mode, "writable", false) != GDK_SUCCEED)
    4117           0 :                         goto bailout1;
    4118       13361 :         } else if (access == TABLE_APPENDONLY) {
    4119           0 :                 if (BUNappend(mode, "appendonly", false) != GDK_SUCCEED)
    4120           0 :                         goto bailout1;
    4121       13361 :         } else if (access == TABLE_READONLY) {
    4122       13361 :                 if (BUNappend(mode, "readonly", false) != GDK_SUCCEED)
    4123           0 :                         goto bailout1;
    4124             :         } else {
    4125           0 :                 if (BUNappend(mode, str_nil, false) != GDK_SUCCEED)
    4126           0 :                         goto bailout1;
    4127             :         }
    4128       90652 :         if (BUNappend(type, tpname, false) != GDK_SUCCEED)
    4129           0 :                 goto bailout1;
    4130             : 
    4131       90652 :         sz = bsi.count;
    4132       90652 :         if (BUNappend(cnt, &sz, false) != GDK_SUCCEED)
    4133           0 :                 goto bailout1;
    4134             : 
    4135       90652 :         if (BUNappend(loc, BBP_physical(bs->batCacheid), false) != GDK_SUCCEED)
    4136           0 :                 goto bailout1;
    4137       90652 :         w = bsi.width;
    4138       90652 :         if (BUNappend(atom, &w, false) != GDK_SUCCEED)
    4139           0 :                 goto bailout1;
    4140             : 
    4141       90652 :         sz = (lng) bsi.hfree;
    4142       90652 :         if (BUNappend(size, &sz, false) != GDK_SUCCEED)
    4143           0 :                 goto bailout1;
    4144             : 
    4145       90652 :         sz = bsi.vhfree;
    4146       90652 :         if (BUNappend(heap, &sz, false) != GDK_SUCCEED)
    4147           0 :                 goto bailout1;
    4148             : 
    4149       90652 :         MT_rwlock_rdlock(&bs->thashlock);
    4150             :         /* one lock, two values: hash size, and
    4151             :          * whether we (may) have a hash */
    4152       90652 :         sz = hashinfo(bs->thash, bs->batCacheid);
    4153       90652 :         bitval = bs->thash != NULL;
    4154       90652 :         MT_rwlock_rdunlock(&bs->thashlock);
    4155       90652 :         if (BUNappend(indices, &sz, false) != GDK_SUCCEED)
    4156           0 :                 goto bailout1;
    4157             : 
    4158       90652 :         if (BUNappend(phash, &bitval, false) != GDK_SUCCEED)
    4159           0 :                 goto bailout1;
    4160             : 
    4161       90652 :         sz = IMPSimprintsize(bs);
    4162       90652 :         if (BUNappend(imprints, &sz, false) != GDK_SUCCEED)
    4163           0 :                 goto bailout1;
    4164       90652 :         bitval = bsi.sorted;
    4165       90652 :         if (!bitval && bsi.nosorted == 0)
    4166        2915 :                 bitval = bit_nil;
    4167       90652 :         if (BUNappend(sort, &bitval, false) != GDK_SUCCEED)
    4168           0 :                 goto bailout1;
    4169             : 
    4170       90652 :         bitval = bsi.revsorted;
    4171       90652 :         if (!bitval && bsi.norevsorted == 0)
    4172        2696 :                 bitval = bit_nil;
    4173       90652 :         if (BUNappend(revsort, &bitval, false) != GDK_SUCCEED)
    4174           0 :                 goto bailout1;
    4175             : 
    4176       90652 :         bitval = bsi.key;
    4177       90652 :         if (!bitval && bsi.nokey[0] == 0 && bsi.nokey[1] == 0)
    4178       24836 :                 bitval = bit_nil;
    4179       90652 :         if (BUNappend(key, &bitval, false) != GDK_SUCCEED)
    4180           0 :                 goto bailout1;
    4181             : 
    4182       90652 :         MT_lock_set(&bs->batIdxLock);
    4183       90652 :         sz = bs->torderidx && bs->torderidx != (Heap *) 1 ? bs->torderidx->free : 0;
    4184       90652 :         MT_lock_unset(&bs->batIdxLock);
    4185       90652 :         if (BUNappend(oidx, &sz, false) != GDK_SUCCEED)
    4186           0 :                 goto bailout1;
    4187       90652 :         bat_iterator_end(&bsi);
    4188       90652 :         return MAL_SUCCEED;
    4189           0 :   bailout1:
    4190           0 :         bat_iterator_end(&bsi);
    4191           0 :         throw(SQL, "sql.storage", GDK_EXCEPTION);
    4192             : }
    4193             : 
    4194             : /*
    4195             :  * Inspection of the actual storage footprint is a recurring question of users.
    4196             :  * This is modelled as a generic SQL table producing function.
    4197             :  * create function storage()
    4198             :  * 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)
    4199             :  * external name sql.storage;
    4200             :  */
    4201             : str
    4202         414 : sql_storage(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    4203             : {
    4204         414 :         BAT *sch, *tab, *col, *type, *loc, *cnt, *atom, *size, *heap, *indices, *phash, *sort, *imprints, *mode, *revsort, *key, *oidx, *bs = NULL;
    4205         414 :         mvc *m = NULL;
    4206         414 :         str msg = MAL_SUCCEED;
    4207         414 :         sql_trans *tr;
    4208         414 :         node *ncol;
    4209         414 :         bat *rsch = getArgReference_bat(stk, pci, 0);
    4210         414 :         bat *rtab = getArgReference_bat(stk, pci, 1);
    4211         414 :         bat *rcol = getArgReference_bat(stk, pci, 2);
    4212         414 :         bat *rtype = getArgReference_bat(stk, pci, 3);
    4213         414 :         bat *rmode = getArgReference_bat(stk, pci, 4);
    4214         414 :         bat *rloc = getArgReference_bat(stk, pci, 5);
    4215         414 :         bat *rcnt = getArgReference_bat(stk, pci, 6);
    4216         414 :         bat *ratom = getArgReference_bat(stk, pci, 7);
    4217         414 :         bat *rsize = getArgReference_bat(stk, pci, 8);
    4218         414 :         bat *rheap = getArgReference_bat(stk, pci, 9);
    4219         414 :         bat *rindices = getArgReference_bat(stk, pci, 10);
    4220         414 :         bat *rphash = getArgReference_bat(stk, pci, 11);
    4221         414 :         bat *rimprints = getArgReference_bat(stk, pci, 12);
    4222         414 :         bat *rsort = getArgReference_bat(stk, pci, 13);
    4223         414 :         bat *rrevsort = getArgReference_bat(stk, pci, 14);
    4224         414 :         bat *rkey = getArgReference_bat(stk, pci, 15);
    4225         414 :         bat *roidx = getArgReference_bat(stk, pci, 16);
    4226         414 :         str sname = 0;
    4227         414 :         str tname = 0;
    4228         414 :         str cname = 0;
    4229         414 :         struct os_iter si = {0};
    4230             : 
    4231         414 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    4232             :                 return msg;
    4233         414 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    4234             :                 return msg;
    4235             : 
    4236         414 :         if( pci->argc - pci->retc >= 1) {
    4237          53 :                 sname = *getArgReference_str(stk, pci, pci->retc);
    4238          53 :                 if (strNil(sname))
    4239           0 :                         throw(SQL, "sql.storage", SQLSTATE(42000) "Schema name cannot be NULL");
    4240             :         }
    4241         414 :         if( pci->argc - pci->retc >= 2) {
    4242          53 :                 tname = *getArgReference_str(stk, pci, pci->retc + 1);
    4243          53 :                 if (strNil(tname))
    4244           0 :                         throw(SQL, "sql.storage", SQLSTATE(42000) "Table name cannot be NULL");
    4245             :         }
    4246         414 :         if( pci->argc - pci->retc >= 3) {
    4247          31 :                 cname = *getArgReference_str(stk, pci, pci->retc + 2);
    4248          31 :                 if (strNil(cname))
    4249           0 :                         throw(SQL, "sql.storage", SQLSTATE(42000) "Column name cannot be NULL");
    4250             :         }
    4251             : 
    4252         414 :         tr = m->session->tr;
    4253         414 :         sqlstore *store = tr->store;
    4254         414 :         sch = COLnew(0, TYPE_str, 0, TRANSIENT);
    4255         414 :         tab = COLnew(0, TYPE_str, 0, TRANSIENT);
    4256         414 :         col = COLnew(0, TYPE_str, 0, TRANSIENT);
    4257         414 :         type = COLnew(0, TYPE_str, 0, TRANSIENT);
    4258         414 :         mode = COLnew(0, TYPE_str, 0, TRANSIENT);
    4259         414 :         loc = COLnew(0, TYPE_str, 0, TRANSIENT);
    4260         414 :         cnt = COLnew(0, TYPE_lng, 0, TRANSIENT);
    4261         414 :         atom = COLnew(0, TYPE_int, 0, TRANSIENT);
    4262         414 :         size = COLnew(0, TYPE_lng, 0, TRANSIENT);
    4263         414 :         heap = COLnew(0, TYPE_lng, 0, TRANSIENT);
    4264         414 :         indices = COLnew(0, TYPE_lng, 0, TRANSIENT);
    4265         414 :         phash = COLnew(0, TYPE_bit, 0, TRANSIENT);
    4266         414 :         imprints = COLnew(0, TYPE_lng, 0, TRANSIENT);
    4267         414 :         sort = COLnew(0, TYPE_bit, 0, TRANSIENT);
    4268         414 :         revsort = COLnew(0, TYPE_bit, 0, TRANSIENT);
    4269         414 :         key = COLnew(0, TYPE_bit, 0, TRANSIENT);
    4270         414 :         oidx = COLnew(0, TYPE_lng, 0, TRANSIENT);
    4271             : 
    4272         414 :         if (sch == NULL || tab == NULL || col == NULL || type == NULL || mode == NULL || loc == NULL || imprints == NULL ||
    4273         414 :             sort == NULL || cnt == NULL || atom == NULL || size == NULL || heap == NULL || indices == NULL || phash == NULL ||
    4274         414 :             revsort == NULL || key == NULL || oidx == NULL) {
    4275           0 :                 msg = createException(SQL, "sql.storage", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    4276           0 :                 goto bailout;
    4277             :         }
    4278             : 
    4279             :         /* check for limited storage tables */
    4280         414 :         os_iterator(&si, tr->cat->schemas, tr, NULL);
    4281        3384 :         for (sql_base *b = oi_next(&si); b; b = oi_next(&si)) {
    4282        2970 :                 sql_schema *s = (sql_schema *) b;
    4283        2970 :                 if ((sname && strcmp(b->name, sname) ) || b->name[0] == '%')
    4284         732 :                         continue;
    4285        2238 :                 if (s->tables) {
    4286        2238 :                         struct os_iter oi;
    4287             : 
    4288        2238 :                         os_iterator(&oi, s->tables, tr, NULL);
    4289       60399 :                         for (sql_base *bt = oi_next(&oi); bt; bt = oi_next(&oi)) {
    4290       58161 :                                 sql_table *t = (sql_table *) bt;
    4291       58161 :                                 if( tname && strcmp(bt->name, tname) )
    4292        6313 :                                         continue;
    4293       51848 :                                 if (isTable(t)) {
    4294       16470 :                                         if (ol_first_node(t->columns)) {
    4295      100276 :                                                 for (ncol = ol_first_node((t)->columns); ncol; ncol = ncol->next) {
    4296       83806 :                                                         sql_base *bc = ncol->data;
    4297       83806 :                                                         sql_column *c = (sql_column *) ncol->data;
    4298             : 
    4299       83806 :                                                         if( cname && strcmp(bc->name, cname) )
    4300          48 :                                                                 continue;
    4301       83758 :                                                         bs = store->storage_api.bind_col(tr, c, QUICK);
    4302       83758 :                                                         if (bs == NULL) {
    4303           0 :                                                                 msg = createException(SQL, "sql.storage", SQLSTATE(HY005) "Cannot access column descriptor");
    4304           0 :                                                                 goto bailout;
    4305             :                                                         }
    4306             : 
    4307      167516 :                                                         msg = sql_storage_appendrow(
    4308       83758 :                                                                 bs, b->name, bt->name, bc->name,
    4309       83758 :                                                                 c->t->access, c->type.type->base.name,
    4310             :                                                                 sch, tab, col, type, loc, cnt, atom, size,
    4311             :                                                                 heap, indices, phash, sort, imprints, mode,
    4312             :                                                                 revsort, key, oidx);
    4313       83758 :                                                         if (msg != MAL_SUCCEED)
    4314           0 :                                                                 goto bailout;
    4315             :                                                 }
    4316             :                                         }
    4317             : 
    4318       16470 :                                         if (t->idxs) {
    4319       23382 :                                                 for (ncol = ol_first_node((t)->idxs); ncol; ncol = ncol->next) {
    4320        6912 :                                                         sql_base *bc = ncol->data;
    4321        6912 :                                                         sql_idx *c = (sql_idx *) ncol->data;
    4322        6912 :                                                         if (idx_has_column(c->type)) {
    4323        6906 :                                                                 bs = store->storage_api.bind_idx(tr, c, QUICK);
    4324             : 
    4325        6906 :                                                                 if (bs == NULL) {
    4326           0 :                                                                         msg = createException(SQL, "sql.storage", SQLSTATE(HY005) "Cannot access column descriptor");
    4327           0 :                                                                         goto bailout;
    4328             :                                                                 }
    4329        6906 :                                                                 if( cname && strcmp(bc->name, cname) )
    4330          12 :                                                                         continue;
    4331       13788 :                                                                 msg = sql_storage_appendrow(
    4332        6894 :                                                                         bs, b->name, bt->name, bc->name,
    4333        6894 :                                                                         c->t->access, "oid",
    4334             :                                                                         sch, tab, col, type, loc, cnt, atom, size,
    4335             :                                                                         heap, indices, phash, sort, imprints, mode,
    4336             :                                                                         revsort, key, oidx);
    4337        6894 :                                                                 if (msg != MAL_SUCCEED)
    4338           0 :                                                                         goto bailout;
    4339             :                                                         }
    4340             :                                                 }
    4341             :                                         }
    4342             :                                 }
    4343             :                         }
    4344             :                 }
    4345             :         }
    4346             : 
    4347         414 :         *rsch = sch->batCacheid;
    4348         414 :         BBPkeepref(sch);
    4349         414 :         *rtab = tab->batCacheid;
    4350         414 :         BBPkeepref(tab);
    4351         414 :         *rcol = col->batCacheid;
    4352         414 :         BBPkeepref(col);
    4353         414 :         *rmode = mode->batCacheid;
    4354         414 :         BBPkeepref(mode);
    4355         414 :         *rloc = loc->batCacheid;
    4356         414 :         BBPkeepref(loc);
    4357         414 :         *rtype = type->batCacheid;
    4358         414 :         BBPkeepref(type);
    4359         414 :         *rcnt = cnt->batCacheid;
    4360         414 :         BBPkeepref(cnt);
    4361         414 :         *ratom = atom->batCacheid;
    4362         414 :         BBPkeepref(atom);
    4363         414 :         *rsize = size->batCacheid;
    4364         414 :         BBPkeepref(size);
    4365         414 :         *rheap = heap->batCacheid;
    4366         414 :         BBPkeepref(heap);
    4367         414 :         *rindices = indices->batCacheid;
    4368         414 :         BBPkeepref(indices);
    4369         414 :         *rphash = phash->batCacheid;
    4370         414 :         BBPkeepref(phash);
    4371         414 :         *rimprints = imprints->batCacheid;
    4372         414 :         BBPkeepref(imprints);
    4373         414 :         *rsort = sort->batCacheid;
    4374         414 :         BBPkeepref(sort);
    4375         414 :         *rrevsort = revsort->batCacheid;
    4376         414 :         BBPkeepref(revsort);
    4377         414 :         *rkey = key->batCacheid;
    4378         414 :         BBPkeepref(key);
    4379         414 :         *roidx = oidx->batCacheid;
    4380         414 :         BBPkeepref(oidx);
    4381         414 :         return MAL_SUCCEED;
    4382             : 
    4383           0 :   bailout:
    4384           0 :         BBPreclaim(sch);
    4385           0 :         BBPreclaim(tab);
    4386           0 :         BBPreclaim(col);
    4387           0 :         BBPreclaim(mode);
    4388           0 :         BBPreclaim(loc);
    4389           0 :         BBPreclaim(cnt);
    4390           0 :         BBPreclaim(type);
    4391           0 :         BBPreclaim(atom);
    4392           0 :         BBPreclaim(size);
    4393           0 :         BBPreclaim(heap);
    4394           0 :         BBPreclaim(indices);
    4395           0 :         BBPreclaim(phash);
    4396           0 :         BBPreclaim(imprints);
    4397           0 :         BBPreclaim(sort);
    4398           0 :         BBPreclaim(revsort);
    4399           0 :         BBPreclaim(key);
    4400           0 :         BBPreclaim(oidx);
    4401             :         if (!msg)
    4402             :                 msg = createException(SQL, "sql.storage", GDK_EXCEPTION);
    4403             :         return msg;
    4404             : }
    4405             : 
    4406             : void
    4407      301446 : freeVariables(Client c, MalBlkPtr mb, MalStkPtr glb, int oldvtop)
    4408             : {
    4409      374019 :         for (int i = oldvtop; i < mb->vtop;) {
    4410       72574 :                 if (glb) {
    4411           0 :                         if (isVarCleanup(mb, i))
    4412           0 :                                 garbageElement(c, &glb->stk[i]);
    4413             :                         /* clean stack entry */
    4414           0 :                         glb->stk[i].vtype = TYPE_int;
    4415           0 :                         glb->stk[i].val.ival = 0;
    4416           0 :                         glb->stk[i].len = 0;
    4417             :                 }
    4418       72574 :                 clearVariable(mb, i);
    4419       72573 :                 i++;
    4420             :         }
    4421      301445 :         assert(oldvtop <= mb->vsize);
    4422      301445 :         mb->vtop = oldvtop;
    4423      301445 : }
    4424             : 
    4425             : str
    4426           0 : SQLresume_log_flushing(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    4427             : {
    4428           0 :         mvc *mvc;
    4429             : 
    4430           0 :         (void)stk; (void)pci;
    4431           0 :         char *msg = getSQLContext(cntxt, mb, &mvc, NULL);
    4432           0 :         if (msg)
    4433             :                 return msg;
    4434           0 :         store_resume_log(mvc->store);
    4435           0 :         return MAL_SUCCEED;
    4436             : }
    4437             : 
    4438             : str
    4439           0 : SQLsuspend_log_flushing(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    4440             : {
    4441           0 :         mvc *mvc;
    4442             : 
    4443           0 :         (void)stk; (void)pci;
    4444           0 :         char *msg = getSQLContext(cntxt, mb, &mvc, NULL);
    4445           0 :         if (msg)
    4446             :                 return msg;
    4447           0 :         store_suspend_log(mvc->store);
    4448           0 :         return MAL_SUCCEED;
    4449             : }
    4450             : 
    4451             : str
    4452             : /*SQLhot_snapshot(void *ret, const str *tarfile_arg [, bool onserver ])*/
    4453           5 : SQLhot_snapshot(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    4454             : {
    4455           5 :         char *filename;
    4456           5 :         bool onserver;
    4457           5 :         char *msg = MAL_SUCCEED;
    4458           5 :         char buf[80];
    4459           5 :         mvc *mvc;
    4460           5 :         ssize_t sz;
    4461           5 :         stream *s;
    4462           5 :         stream *cb = NULL;
    4463           5 :         lng result;
    4464             : 
    4465           5 :         filename = *getArgReference_str(stk, pci, 1);
    4466           5 :         onserver = pci->argc == 3 ? *getArgReference_bit(stk, pci, 2) : true;
    4467             : 
    4468           5 :         msg = getSQLContext(cntxt, mb, &mvc, NULL);
    4469           5 :         if (msg)
    4470             :                 return msg;
    4471             : 
    4472           5 :         sqlstore *store = mvc->session->tr->store;
    4473           5 :         if (onserver) {
    4474           5 :                 lng result = store_hot_snapshot(store, filename);
    4475           5 :                 if (result)
    4476             :                         return MAL_SUCCEED;
    4477             :                 else
    4478           0 :                         throw(SQL, "sql.hot_snapshot", GDK_EXCEPTION);
    4479             :         }
    4480             : 
    4481             :         // sync with client, copy pasted from mvc_export_table_wrap
    4482           0 :         while (!mvc->scanner.rs->eof)
    4483           0 :                 if (bstream_next(mvc->scanner.rs) < 0)
    4484           0 :                         throw(SQL, "sql.hot_snapshot", "interrupted");
    4485             : 
    4486             :         // The snapshot code flushes from time to time.
    4487             :         // Use a callback stream to suppress those.
    4488           0 :         s = mvc->scanner.ws;
    4489           0 :         cb = callback_stream(
    4490             :                 /* private */ s,
    4491             :                 /* read */    NULL,
    4492             :                 /* write */   (void*)mnstr_write,
    4493             :                 /* close */   NULL,
    4494             :                 /* destroy */ NULL,
    4495             :                 "snapshot-callback"
    4496             :         );
    4497           0 :         if (!cb)
    4498           0 :                 throw(SQL, "sql.hot_snapshot", GDK_EXCEPTION);
    4499             : 
    4500             :         // tell client to open file, copy pasted from mvc_export_table_wrap
    4501           0 :         mnstr_write(s, PROMPT3, sizeof(PROMPT3) - 1, 1);
    4502           0 :         mnstr_printf(s, "wb %s\n", filename);
    4503           0 :         mnstr_flush(s, MNSTR_FLUSH_DATA);
    4504           0 :         if ((sz = mnstr_readline(mvc->scanner.rs->s, buf, sizeof(buf))) > 1) {
    4505             :                 /* non-empty line indicates failure on client */
    4506           0 :                 msg = createException(IO, "streams.open", "%s", buf);
    4507             :                         /* discard until client flushes */
    4508           0 :                         while (mnstr_read(mvc->scanner.rs->s, buf, 1, sizeof(buf)) > 0) {
    4509             :                                 /* ignore remainder of error message */
    4510           0 :                         }
    4511           0 :                 goto end;
    4512             :         }
    4513             : 
    4514             :         // client is waiting for data now, send it.
    4515           0 :         result = store_hot_snapshot_to_stream(store, cb);
    4516           0 :         if (result)
    4517             :                 msg = MAL_SUCCEED;
    4518             :         else
    4519           0 :                 msg = createException(SQL, "sql.hot_snapshot", GDK_EXCEPTION);
    4520           0 :         mnstr_destroy(cb);
    4521             : 
    4522             :         // tell client no more data, also copy pasted from mvc_export_table_wrap
    4523           0 :         mnstr_flush(s, MNSTR_FLUSH_DATA);
    4524           0 :         if ((sz = mnstr_readline(mvc->scanner.rs->s, buf, sizeof(buf))) > 1) {
    4525           0 :                 msg = createException(IO, "streams.open", "%s", buf);
    4526             :         }
    4527           0 :         while (sz > 0)
    4528           0 :                 sz = mnstr_readline(mvc->scanner.rs->s, buf, sizeof(buf));
    4529             : 
    4530           0 : end:
    4531             :         return msg;
    4532             : }
    4533             : 
    4534             : MT_Lock lock_persist_unlogged = MT_LOCK_INITIALIZER(lock_persist_unlogged);
    4535             : 
    4536             : str
    4537           2 : SQLpersist_unlogged(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    4538             : {
    4539           2 :         (void)stk;
    4540           2 :         (void)pci;
    4541             : 
    4542           2 :         assert(pci->argc == 5);
    4543             : 
    4544           2 :         bat *o0 = getArgReference_bat(stk, pci, 0),
    4545           2 :                 *o1 = getArgReference_bat(stk, pci, 1),
    4546           2 :                 *o2 = getArgReference_bat(stk, pci, 2);
    4547           2 :         str sname = *getArgReference_str(stk, pci, 3),
    4548           2 :                 tname = *getArgReference_str(stk, pci, 4),
    4549           2 :                 msg = MAL_SUCCEED;
    4550             : 
    4551           2 :         mvc *m = NULL;
    4552           2 :         msg = getSQLContext(cntxt, mb, &m, NULL);
    4553             : 
    4554           2 :         if (msg)
    4555             :                 return msg;
    4556             : 
    4557           2 :         sqlstore *store = store = m->session->tr->store;
    4558             : 
    4559           2 :         sql_schema *s = mvc_bind_schema(m, sname);
    4560           2 :         if (s == NULL)
    4561           0 :                 throw(SQL, "sql.persist_unlogged", SQLSTATE(3F000) "Schema missing %s.", sname);
    4562             : 
    4563           2 :         if (!mvc_schema_privs(m, s))
    4564           0 :                 throw(SQL, "sql.persist_unlogged", SQLSTATE(42000) "Access denied for %s to schema '%s'.",
    4565             :                           get_string_global_var(m, "current_user"), s->base.name);
    4566             : 
    4567           2 :         sql_table *t = mvc_bind_table(m, s, tname);
    4568           2 :         if (t == NULL)
    4569           0 :                 throw(SQL, "sql.persist_unlogged", SQLSTATE(42S02) "Table missing %s.%s", sname, tname);
    4570             : 
    4571           2 :         if (!isUnloggedTable(t) || t->access != TABLE_APPENDONLY)
    4572           0 :                 throw(SQL, "sql.persist_unlogged", "Unlogged and Insert Only mode combination required for table %s.%s", sname, tname);
    4573             : 
    4574           2 :         lng count = 0;
    4575             : 
    4576           2 :         sql_trans *tr = m->session->tr;
    4577           2 :         storage *t_del = bind_del_data(tr, t, NULL);
    4578             : 
    4579           2 :         BAT *d = NULL;
    4580             : 
    4581           2 :         if (t_del)
    4582           2 :                 d = BATdescriptor(t_del->cs.bid);
    4583           2 :         if (t_del == NULL || d == NULL)
    4584           0 :                 throw(SQL, "sql.persist_unlogged", "Cannot access %s column storage.", tname);
    4585             : 
    4586           2 :         MT_lock_set(&lock_persist_unlogged);
    4587           2 :         BATiter d_bi = bat_iterator(d);
    4588             : 
    4589           2 :         if (BBP_status(d->batCacheid) & BBPEXISTING) {
    4590             : 
    4591           1 :                 assert(d->batInserted <= d_bi.count);
    4592             : 
    4593           1 :                 if (d->batInserted < d_bi.count) {
    4594           1 :                         int n = ol_length(t->columns);
    4595             : 
    4596           1 :                         bat *commit_list = GDKzalloc(sizeof(bat) * (n + 2));
    4597           1 :                         BUN *sizes = GDKzalloc(sizeof(BUN) * (n + 2));
    4598             : 
    4599           1 :                         if (commit_list == NULL || sizes == NULL) {
    4600           0 :                                 bat_iterator_end(&d_bi);
    4601           0 :                                 MT_lock_unset(&lock_persist_unlogged);
    4602           0 :                                 GDKfree(commit_list);
    4603           0 :                                 GDKfree(sizes);
    4604           0 :                                 BBPreclaim(d);
    4605           0 :                                 throw(SQL, "sql.persist_unlogged", SQLSTATE(HY001));
    4606             :                         }
    4607             : 
    4608           1 :                         commit_list[0] = 0;
    4609           1 :                         sizes[0] = 0;
    4610           1 :                         int i = 1;
    4611             : 
    4612           2 :                         for (node *ncol = ol_first_node(t->columns); ncol; ncol = ncol->next, i++) {
    4613             : 
    4614           1 :                                 sql_column *c = (sql_column *) ncol->data;
    4615           1 :                                 BAT *b = store->storage_api.bind_col(tr, c, QUICK);
    4616             : 
    4617           1 :                                 if (b == NULL) {
    4618           0 :                                         bat_iterator_end(&d_bi);
    4619           0 :                                         MT_lock_unset(&lock_persist_unlogged);
    4620           0 :                                         GDKfree(commit_list);
    4621           0 :                                         GDKfree(sizes);
    4622           0 :                                         BBPreclaim(d);
    4623           0 :                                         throw(SQL, "sql.persist_unlogged", "Cannot access column descriptor.");
    4624             :                                 }
    4625             : 
    4626           1 :                                 commit_list[i] = b->batCacheid;
    4627           1 :                                 sizes[i] = d_bi.count;
    4628             :                         }
    4629             : 
    4630           1 :                         assert(i<n+2);
    4631           1 :                         commit_list[i] = d->batCacheid;
    4632           1 :                         sizes[i] = d_bi.count;
    4633           1 :                         i++;
    4634             : 
    4635           1 :                         if (TMsubcommit_list(commit_list, sizes, i, -1) != GDK_SUCCEED) {
    4636           0 :                                 bat_iterator_end(&d_bi);
    4637           0 :                                 MT_lock_unset(&lock_persist_unlogged);
    4638           0 :                                 GDKfree(commit_list);
    4639           0 :                                 GDKfree(sizes);
    4640           0 :                                 BBPreclaim(d);
    4641           0 :                                 throw(SQL, "sql.persist_unlogged", "Lower level commit operation failed");
    4642             :                         }
    4643             : 
    4644           1 :                         GDKfree(commit_list);
    4645           1 :                         GDKfree(sizes);
    4646             :                 }
    4647           1 :                 count = d_bi.count;
    4648             :         } else {
    4649             :                 /* special case of log_tstart: third arg == NULL with second arg
    4650             :                  * true is request to rotate log file ASAP */
    4651           1 :                 store->logger_api.log_tstart(store, true, NULL);
    4652             :                 /* special case for sql->debug: if 1024 bit is set,
    4653             :                  * store_manager doesn't wait for 30 seconds of idle time before
    4654             :                  * attempting to rotate */
    4655           1 :                 MT_lock_set(&store->flush);
    4656           1 :                 store->debug |= 1024;
    4657           1 :                 MT_lock_unset(&store->flush);
    4658             :         }
    4659             : 
    4660           2 :         bat_iterator_end(&d_bi);
    4661           2 :         MT_lock_unset(&lock_persist_unlogged);
    4662           2 :         BBPreclaim(d);
    4663             : 
    4664           2 :         BAT *table = COLnew(0, TYPE_str, 0, TRANSIENT),
    4665           2 :                 *tableid = COLnew(0, TYPE_int, 0, TRANSIENT),
    4666           2 :                 *rowcount = COLnew(0, TYPE_lng, 0, TRANSIENT);
    4667             : 
    4668           4 :         if (table == NULL || tableid == NULL || rowcount == NULL ||
    4669           4 :                 BUNappend(table, tname, false) != GDK_SUCCEED ||
    4670           4 :                 BUNappend(tableid, &(t->base.id), false) != GDK_SUCCEED ||
    4671           2 :                 BUNappend(rowcount, &count, false) != GDK_SUCCEED) {
    4672           0 :                 BBPnreclaim(3, table, tableid, rowcount);
    4673           0 :                 throw(SQL, "sql.persist_unlogged", SQLSTATE(HY001));
    4674             :         }
    4675           2 :         *o0 = table->batCacheid;
    4676           2 :         *o1 = tableid->batCacheid;
    4677           2 :         *o2 = rowcount->batCacheid;
    4678           2 :         BBPkeepref(table);
    4679           2 :         BBPkeepref(tableid);
    4680           2 :         BBPkeepref(rowcount);
    4681           2 :         return msg;
    4682             : }
    4683             : 
    4684             : str
    4685           9 : SQLsession_prepared_statements(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    4686             : {
    4687           9 :         BAT *sessionid, *user, *statementid, *statement, *created;
    4688           9 :         bat *sid = getArgReference_bat(stk,pci,0);
    4689           9 :         bat *u = getArgReference_bat(stk,pci,1);
    4690           9 :         bat *i = getArgReference_bat(stk,pci,2);
    4691           9 :         bat *s = getArgReference_bat(stk,pci,3);
    4692           9 :         bat *c = getArgReference_bat(stk,pci,4);
    4693           9 :         str msg = MAL_SUCCEED;
    4694           9 :         mvc *sql = NULL;
    4695           9 :         cq *q = NULL;
    4696             : 
    4697           9 :         (void) stk;
    4698           9 :         (void) pci;
    4699           9 :         if ((msg = getSQLContext(cntxt, mb, &sql, NULL)) != NULL)
    4700             :                 return msg;
    4701           9 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    4702             :                 return msg;
    4703             : 
    4704           9 :         assert(sql->qc);
    4705             : 
    4706           9 :         sessionid = COLnew(0, TYPE_int, 256, TRANSIENT);
    4707           9 :         user = COLnew(0, TYPE_str, 256, TRANSIENT);
    4708           9 :         statementid = COLnew(0, TYPE_int, 256, TRANSIENT);
    4709           9 :         statement = COLnew(0, TYPE_str, 256, TRANSIENT);
    4710           9 :         created = COLnew(0, TYPE_timestamp, 256, TRANSIENT);
    4711           9 :         if (sessionid == NULL || user == NULL || statementid == NULL || statement == NULL || created == NULL) {
    4712           0 :                 msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
    4713           0 :                 goto bailout;
    4714             :         }
    4715             : 
    4716          13 :         for (q = sql->qc->q; q; q = q->next) {
    4717           4 :                 gdk_return bun_res;
    4718           4 :                 if (BUNappend(sessionid, &(cntxt->idx), false) != GDK_SUCCEED) {
    4719           0 :                         msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
    4720           0 :                         goto bailout;
    4721             :                 }
    4722             : 
    4723           4 :                 if (msg != MAL_SUCCEED)
    4724             :                         goto bailout;
    4725           4 :                 bun_res = BUNappend(user, cntxt->username, false);
    4726           4 :                 if (bun_res != GDK_SUCCEED) {
    4727           0 :                         msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
    4728           0 :                         goto bailout;
    4729             :                 }
    4730             : 
    4731           4 :                 if (BUNappend(statementid, &(q->id), false) != GDK_SUCCEED) {
    4732           0 :                         msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
    4733           0 :                         goto bailout;
    4734             :                 }
    4735           4 :                 if (BUNappend(statement, q->f->query, false) != GDK_SUCCEED) {
    4736           0 :                         msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
    4737           0 :                         goto bailout;
    4738             :                 }
    4739           4 :                 if (BUNappend(created, &(q->created), false) != GDK_SUCCEED) {
    4740           0 :                         msg = createException(SQL, "sql.session_prepared_statements", GDK_EXCEPTION);
    4741           0 :                         goto bailout;
    4742             :                 }
    4743             :         }
    4744             : 
    4745           9 : bailout:
    4746           0 :         if (msg) {
    4747           0 :                 BBPreclaim(sessionid);
    4748           0 :                 BBPreclaim(user);
    4749           0 :                 BBPreclaim(statementid);
    4750           0 :                 BBPreclaim(statement);
    4751           0 :                 BBPreclaim(created);
    4752             :         } else {
    4753           9 :                 *sid = sessionid->batCacheid;
    4754           9 :                 BBPkeepref(sessionid);
    4755           9 :                 *u = user->batCacheid;
    4756           9 :                 BBPkeepref(user);
    4757           9 :                 *i = statementid->batCacheid;
    4758           9 :                 BBPkeepref(statementid);
    4759           9 :                 *s = statement->batCacheid;
    4760           9 :                 BBPkeepref(statement);
    4761           9 :                 *c = created->batCacheid;
    4762           9 :                 BBPkeepref(created);
    4763             :         }
    4764             :         return msg;
    4765             : }
    4766             : 
    4767             : str
    4768           6 : SQLsession_prepared_statements_args(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    4769             : {
    4770           6 :         BAT *statementid, *type, *digits, *isinout, *number, *scale, *schema, *table, *column;
    4771           6 :         bat *sid = getArgReference_bat(stk,pci,0);
    4772           6 :         bat *t = getArgReference_bat(stk,pci,1);
    4773           6 :         bat *d = getArgReference_bat(stk,pci,2);
    4774           6 :         bat *s = getArgReference_bat(stk,pci,3);
    4775           6 :         bat *io = getArgReference_bat(stk,pci,4);
    4776           6 :         bat *n = getArgReference_bat(stk,pci,5);
    4777           6 :         bat *sch = getArgReference_bat(stk,pci,6);
    4778           6 :         bat *tbl = getArgReference_bat(stk,pci,7);
    4779           6 :         bat *col = getArgReference_bat(stk,pci,8);
    4780           6 :         str msg = MAL_SUCCEED;
    4781           6 :         mvc *sql = NULL;
    4782           6 :         cq *q = NULL;
    4783             : 
    4784           6 :         (void) stk;
    4785           6 :         (void) pci;
    4786           6 :         if ((msg = getSQLContext(cntxt, mb, &sql, NULL)) != NULL)
    4787             :                 return msg;
    4788           6 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    4789             :                 return msg;
    4790             : 
    4791           6 :         assert(sql->qc);
    4792             : 
    4793           6 :         statementid = COLnew(0, TYPE_int, 256, TRANSIENT);
    4794           6 :         type = COLnew(0, TYPE_str, 256, TRANSIENT);
    4795           6 :         digits = COLnew(0, TYPE_int, 256, TRANSIENT);
    4796           6 :         scale = COLnew(0, TYPE_int, 256, TRANSIENT);
    4797           6 :         isinout = COLnew(0, TYPE_bte, 256, TRANSIENT);
    4798           6 :         number = COLnew(0, TYPE_int, 256, TRANSIENT);
    4799           6 :         schema = COLnew(0, TYPE_str, 256, TRANSIENT);
    4800           6 :         table = COLnew(0, TYPE_str, 256, TRANSIENT);
    4801           6 :         column = COLnew(0, TYPE_str, 256, TRANSIENT);
    4802           6 :         if (!statementid || !type || !digits || !scale || !isinout || !number || !schema || !table || !column) {
    4803           0 :                 msg = createException(SQL, "sql.session_prepared_statements_args", GDK_EXCEPTION);
    4804           0 :                 goto bailout;
    4805             :         }
    4806             : 
    4807           9 :         for (q = sql->qc->q; q; q = q->next) {
    4808           3 :                 sql_rel *r = q->rel;
    4809           3 :                 int arg_number = 0;
    4810           3 :                 bte inout = ARG_OUT;
    4811             : 
    4812           3 :                 if (r && (is_topn(r->op) || is_sample(r->op)))
    4813           0 :                         r = r->l;
    4814             : 
    4815           3 :                 if (r && is_project(r->op) && r->exps) {
    4816           6 :                         for (node *n = r->exps->h; n; n = n->next, arg_number++) {
    4817           3 :                                 sql_exp *e = n->data;
    4818           3 :                                 sql_subtype *t = exp_subtype(e);
    4819           3 :                                 const char *name = exp_name(e), *rname = exp_relname(e), *rschema = ATOMnilptr(TYPE_str);
    4820             : 
    4821           3 :                                 if (!name && e->type == e_column && e->r)
    4822           0 :                                         name = e->r;
    4823           0 :                                 if (!name)
    4824           0 :                                         name = ATOMnilptr(TYPE_str);
    4825           3 :                                 if (!rname && e->type == e_column && e->l)
    4826           0 :                                         rname = e->l;
    4827           0 :                                 if (!rname)
    4828           0 :                                         rname = ATOMnilptr(TYPE_str);
    4829             : 
    4830           6 :                                 if (BUNappend(statementid, &(q->id), false) != GDK_SUCCEED ||
    4831           6 :                                         BUNappend(type, t->type->base.name, false) != GDK_SUCCEED ||
    4832           6 :                                         BUNappend(digits, &t->digits, false) != GDK_SUCCEED ||
    4833           6 :                                         BUNappend(scale, &t->scale, false) != GDK_SUCCEED ||
    4834           6 :                                         BUNappend(isinout, &inout, false) != GDK_SUCCEED ||
    4835           6 :                                         BUNappend(number, &arg_number, false) != GDK_SUCCEED ||
    4836           6 :                                         BUNappend(schema, rschema, false) != GDK_SUCCEED ||
    4837           6 :                                         BUNappend(table, rname, false) != GDK_SUCCEED ||
    4838           3 :                                         BUNappend(column, name, false) != GDK_SUCCEED) {
    4839           0 :                                         msg = createException(SQL, "sql.session_prepared_statements_args", GDK_EXCEPTION);
    4840           0 :                                         goto bailout;
    4841             :                                 }
    4842             :                         }
    4843             :                 }
    4844             : 
    4845           3 :                 if (q->f->ops) {
    4846           3 :                         inout = ARG_IN;
    4847           6 :                         for (node *n = q->f->ops->h; n; n=n->next, arg_number++) {
    4848           3 :                                 sql_arg *a = n->data;
    4849           3 :                                 sql_subtype *t = &a->type;
    4850             : 
    4851           6 :                                 if (BUNappend(statementid, &(q->id), false) != GDK_SUCCEED ||
    4852           6 :                                         BUNappend(type, t->type->base.name, false) != GDK_SUCCEED ||
    4853           6 :                                         BUNappend(digits, &(t->digits), false) != GDK_SUCCEED ||
    4854           6 :                                         BUNappend(scale, &(t->scale), false) != GDK_SUCCEED ||
    4855           6 :                                         BUNappend(isinout, &inout, false) != GDK_SUCCEED ||
    4856           6 :                                         BUNappend(number, &arg_number, false) != GDK_SUCCEED ||
    4857           6 :                                         BUNappend(schema, ATOMnilptr(TYPE_str), false) != GDK_SUCCEED ||
    4858           6 :                                         BUNappend(table, ATOMnilptr(TYPE_str), false) != GDK_SUCCEED ||
    4859           3 :                                         BUNappend(column, ATOMnilptr(TYPE_str), false) != GDK_SUCCEED) {
    4860           0 :                                         msg = createException(SQL, "sql.session_prepared_statements_args", GDK_EXCEPTION);
    4861           0 :                                         goto bailout;
    4862             :                                 }
    4863             :                         }
    4864             :                 }
    4865             :         }
    4866             : 
    4867           6 : bailout:
    4868           0 :         if (msg) {
    4869           0 :                 BBPreclaim(statementid);
    4870           0 :                 BBPreclaim(type);
    4871           0 :                 BBPreclaim(digits);
    4872           0 :                 BBPreclaim(scale);
    4873           0 :                 BBPreclaim(isinout);
    4874           0 :                 BBPreclaim(number);
    4875           0 :                 BBPreclaim(schema);
    4876           0 :                 BBPreclaim(table);
    4877           0 :                 BBPreclaim(column);
    4878             :         } else {
    4879           6 :                 *sid = statementid->batCacheid;
    4880           6 :                 BBPkeepref(statementid);
    4881           6 :                 *t = type->batCacheid;
    4882           6 :                 BBPkeepref(type);
    4883           6 :                 *d = digits->batCacheid;
    4884           6 :                 BBPkeepref(digits);
    4885           6 :                 *s = scale->batCacheid;
    4886           6 :                 BBPkeepref(scale);
    4887           6 :                 *io = isinout->batCacheid;
    4888           6 :                 BBPkeepref(isinout);
    4889           6 :                 *n = number->batCacheid;
    4890           6 :                 BBPkeepref(number);
    4891           6 :                 *sch = schema->batCacheid;
    4892           6 :                 BBPkeepref(schema);
    4893           6 :                 *tbl = table->batCacheid;
    4894           6 :                 BBPkeepref(table);
    4895           6 :                 *col = column->batCacheid;
    4896           6 :                 BBPkeepref(column);
    4897             :         }
    4898             :         return msg;
    4899             : }
    4900             : 
    4901             : /* input id, row-input-values
    4902             :  * for each id call function(with row-input-values) return table
    4903             :  * return for each id the table, ie id (*length of table) and table results
    4904             :  */
    4905             : str
    4906          23 : SQLunionfunc(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    4907             : {
    4908          23 :         int arg = pci->retc;
    4909          23 :         str mod, fcn, ret = MAL_SUCCEED;
    4910          23 :         InstrPtr npci;
    4911          23 :         MalBlkPtr nmb = newMalBlk(1), omb = NULL;
    4912             : 
    4913          23 :         if (!nmb)
    4914           0 :                 return createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    4915          23 :         mod = *getArgReference_str(stk, pci, arg++);
    4916          23 :         fcn = *getArgReference_str(stk, pci, arg++);
    4917          23 :         npci = newStmtArgs(nmb, mod, fcn, pci->argc);
    4918          23 :         if (npci == NULL) {
    4919           0 :                 freeMalBlk(nmb);
    4920           0 :                 return createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    4921             :         }
    4922             : 
    4923          46 :         for (int i = 1; i < pci->retc; i++) {
    4924          23 :                 int type = getArgType(mb, pci, i);
    4925             : 
    4926          23 :                 if (i==1)
    4927          23 :                         getArg(npci, 0) = newTmpVariable(nmb, type);
    4928             :                 else
    4929           0 :                         npci = pushReturn(nmb, npci, newTmpVariable(nmb, type));
    4930             :         }
    4931          60 :         for (int i = pci->retc+2+1; i < pci->argc; i++) {
    4932          37 :                 int type = getBatType(getArgType(mb, pci, i));
    4933             : 
    4934          37 :                 npci = pushNil(nmb, npci, type);
    4935             :         }
    4936          23 :         pushInstruction(nmb, npci);
    4937             :         /* check program to get the proper malblk */
    4938          23 :         if (chkInstruction(cntxt->usermodule, nmb, npci)) {
    4939           0 :                 freeMalBlk(nmb);
    4940           0 :                 return createException(MAL, "sql.unionfunc", SQLSTATE(42000) PROGRAM_GENERAL);
    4941             :         }
    4942             : 
    4943          23 :         if (npci) {
    4944          23 :                 BAT **res = NULL, **input = NULL;
    4945          23 :                 BATiter *bi = NULL;
    4946          23 :                 BUN cnt = 0;
    4947          23 :                 int nrinput = pci->argc - 2 - pci->retc;
    4948          23 :                 MalStkPtr env = NULL;
    4949          23 :                 InstrPtr q = NULL;
    4950             : 
    4951          23 :                 if (!(input = GDKzalloc(sizeof(BAT*) * nrinput))) {
    4952           0 :                         ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    4953           0 :                         goto finalize;
    4954             :                 }
    4955          23 :                 if (!(bi = GDKmalloc(sizeof(BATiter) * nrinput))) {
    4956           0 :                         ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    4957           0 :                         goto finalize;
    4958             :                 }
    4959          23 :                 assert(pci->retc + 2 + nrinput == pci->argc);
    4960          83 :                 for (int i = 0, j = pci->retc+2; j < pci->argc; i++, j++) {
    4961          60 :                         bat *b = getArgReference_bat(stk, pci, j);
    4962          60 :                         if (!(input[i] = BATdescriptor(*b))) {
    4963           0 :                                 ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY005) "Cannot access column descriptor");
    4964           0 :                                 while (i > 0) {
    4965           0 :                                         i--;
    4966           0 :                                         bat_iterator_end(&bi[i]);
    4967           0 :                                         BBPunfix(input[i]->batCacheid);
    4968             :                                 }
    4969           0 :                                 GDKfree(input);
    4970           0 :                                 input = NULL;
    4971           0 :                                 goto finalize;
    4972             :                         }
    4973          60 :                         bi[i] = bat_iterator(input[i]);
    4974          60 :                         cnt = BATcount(input[i]);
    4975             :                 }
    4976             : 
    4977             :                 /* create result bats */
    4978          23 :                 if (!(res = GDKzalloc(sizeof(BAT*) * pci->retc))) {
    4979           0 :                         ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    4980           0 :                         goto finalize;
    4981             :                 }
    4982          69 :                 for (int i = 0; i<pci->retc; i++) {
    4983          46 :                         int type = getArgType(mb, pci, i);
    4984             : 
    4985          46 :                         if (!(res[i] = COLnew(0, getBatType(type), cnt, TRANSIENT))) {
    4986           0 :                                 ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
    4987           0 :                                 goto finalize;
    4988             :                         }
    4989             :                 }
    4990             : 
    4991          23 :                 if (npci->blk && npci->blk->stop > 1) {
    4992          11 :                         omb = nmb;
    4993          11 :                         if (!(nmb = copyMalBlk(npci->blk))) {
    4994           0 :                                 ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    4995           0 :                                 goto finalize;
    4996             :                         }
    4997             :                 }
    4998          23 :                 if (!(env = prepareMALstack(nmb, nmb->vsize))) { /* needed for result */
    4999           0 :                         ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    5000           0 :                         goto finalize;
    5001             :                 }
    5002          23 :                 q = getInstrPtr(nmb, 0);
    5003             : 
    5004          23 :                 int start = 1;
    5005          23 :                 if (nmb->stop == 1 && (omb || !npci->fcn || npci->token != PATcall)) {
    5006           0 :                         InstrPtr *stmt = nmb->stmt;
    5007           0 :                         nmb->stmt = (InstrPtr*)GDKmalloc(sizeof(InstrPtr*)*3);
    5008           0 :                         nmb->stmt[0] = NULL; /* no main() */
    5009           0 :                         nmb->stmt[1] = NULL; /* no profiling */
    5010           0 :                         nmb->stmt[2] = stmt[0];
    5011           0 :                         nmb->stop = nmb->ssize = 3;
    5012           0 :                         GDKfree(stmt);
    5013           0 :                         start = 2;
    5014             :                 }
    5015          83 :                 for (BUN cur = 0; cur<cnt && !ret; cur++ ) {
    5016          60 :                         MalStkPtr nstk = prepareMALstack(nmb, nmb->vsize);
    5017          60 :                         int i,ii;
    5018             : 
    5019          60 :                         if (!nstk) { /* needed for result */
    5020           0 :                                 ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    5021             :                         } else {
    5022             :                                 /* copy (input) arguments onto destination stack, skipping rowid col */
    5023         135 :                                 for (i = 1, ii = q->retc; ii < q->argc && !ret; ii++, i++) {
    5024          75 :                                         ValPtr lhs = &nstk->stk[q->argv[ii]];
    5025          75 :                                         ptr rhs = (ptr)BUNtail(bi[i], cur);
    5026             : 
    5027          75 :                                         if (VALset(lhs, input[i]->ttype, rhs) == NULL)
    5028           0 :                                                 ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    5029             :                                 }
    5030          60 :                                 if (!ret && ii == q->argc) {
    5031          60 :                                         BAT *fres = NULL;
    5032          60 :                                         if (!omb && npci->fcn && npci->token == PATcall) /* pattern */
    5033          15 :                                                 ret = (*(str (*)(Client, MalBlkPtr, MalStkPtr, InstrPtr))npci->fcn)(cntxt, nmb, nstk, npci);
    5034             :                                         else
    5035          45 :                                                 ret = runMALsequence(cntxt, nmb, start, nmb->stop, nstk, env /* copy result in nstk first instruction*/, q);
    5036             : 
    5037          60 :                                         if (!ret) {
    5038             :                                                 /* insert into result */
    5039          60 :                                                 if (!(fres = BBPquickdesc(omb?env->stk[q->argv[0]].val.bval:nstk->stk[q->argv[0]].val.bval))) {
    5040           0 :                                                         ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY005) "Cannot access column descriptor");
    5041             :                                                 } else {
    5042          60 :                                                         BAT *p = BATconstant(fres->hseqbase, res[0]->ttype, (ptr)BUNtail(bi[0], cur), BATcount(fres), TRANSIENT);
    5043             : 
    5044          60 :                                                         if (p) {
    5045          60 :                                                                 if (BATappend(res[0], p, NULL, FALSE) != GDK_SUCCEED)
    5046           0 :                                                                         ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
    5047          60 :                                                                 BBPunfix(p->batCacheid);
    5048             :                                                         } else {
    5049           0 :                                                                 ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
    5050             :                                                         }
    5051             :                                                 }
    5052             :                                                 i=1;
    5053         120 :                                                 for (ii = 0; i < pci->retc && !ret; ii++, i++) {
    5054          60 :                                                         BAT *b;
    5055          60 :                                                         ValPtr vp = omb ? env->stk + q->argv[ii] : nstk->stk + q->argv[ii];
    5056             : 
    5057          60 :                                                         if (!(b = BATdescriptor(vp->val.bval)))
    5058           0 :                                                                 ret = createException(MAL, "sql.unionfunc", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
    5059          60 :                                                         else if (BATappend(res[i], b, NULL, FALSE) != GDK_SUCCEED)
    5060           0 :                                                                 ret = createException(MAL, "sql.unionfunc", GDK_EXCEPTION);
    5061          60 :                                                         if (b) {
    5062          60 :                                                                 BBPrelease(b->batCacheid); /* release ref from env stack */
    5063          60 :                                                                 BBPunfix(b->batCacheid);   /* free pointer */
    5064          60 :                                                                 VALempty(vp);
    5065             :                                                         }
    5066             :                                                 }
    5067             :                                         }
    5068             :                                 }
    5069          60 :                                 freeStack(nstk);
    5070             :                         }
    5071             :                 }
    5072          23 : finalize:
    5073          23 :                 freeStack(env);
    5074          23 :                 if (nmb)
    5075          23 :                         freeMalBlk(nmb);
    5076          23 :                 if (omb)
    5077          11 :                         freeMalBlk(omb);
    5078          23 :                 if (res)
    5079          69 :                         for (int i = 0; i<pci->retc; i++) {
    5080          46 :                                 bat *b = getArgReference_bat(stk, pci, i);
    5081          46 :                                 if (res[i]) {
    5082          46 :                                         *b = res[i]->batCacheid;
    5083          46 :                                         if (ret)
    5084           0 :                                                 BBPunfix(*b);
    5085             :                                         else
    5086          46 :                                                 BBPkeepref(res[i]);
    5087             :                                 }
    5088             :                         }
    5089          23 :                 GDKfree(res);
    5090          23 :                 if (input) {
    5091          83 :                         for (int i = 0; i<nrinput; i++) {
    5092          60 :                                 if (input[i]) {
    5093          60 :                                         bat_iterator_end(&bi[i]);
    5094          60 :                                         BBPunfix(input[i]->batCacheid);
    5095             :                                 }
    5096             :                         }
    5097          23 :                         GDKfree(input);
    5098             :                 }
    5099          23 :                 GDKfree(bi);
    5100             :         }
    5101             :         return ret;
    5102             : }
    5103             : 
    5104             : static str
    5105           9 : do_str_column_vacuum(sql_trans *tr, sql_column *c, char *sname, char *tname, char *cname)
    5106             : {
    5107           9 :         int res;
    5108           9 :         int access = 0;
    5109           9 :         BAT* b = NULL;
    5110           9 :         BAT* bn = NULL;
    5111           9 :         sqlstore *store = tr->store;
    5112             : 
    5113           9 :         if ((b = store->storage_api.bind_col(tr, c, access)) == NULL)
    5114           0 :                 throw(SQL, "do_str_column_vacuum", SQLSTATE(42S22) "storage_api.bind_col failed for %s.%s.%s", sname, tname, cname);
    5115             :         // vacuum varsized bats
    5116           9 :         if (ATOMvarsized(c->type.type->localtype)) {
    5117             :                 // TODO check for num of updates on the BAT against some threshold
    5118             :                 // and decide whether to proceed
    5119           5 :                 if ((bn = COLcopy(b, b->ttype, true, PERSISTENT)) == NULL) {
    5120           0 :                         BBPunfix(b->batCacheid);
    5121           0 :                         throw(SQL, "do_str_column_vacuum", SQLSTATE(42S22) "COLcopy failed for %s.%s.%s", sname, tname, cname);
    5122             :                 }
    5123           5 :                 if ((res = (int) store->storage_api.swap_bats(tr, c, bn)) != LOG_OK) {
    5124           0 :                         BBPreclaim(bn);
    5125           0 :                         BBPunfix(b->batCacheid);
    5126           0 :                         if (res == LOG_CONFLICT)
    5127           0 :                                 throw(SQL, "do_str_column_vacuum", SQLSTATE(25S01) "TRANSACTION CONFLICT in storage_api.swap_bats %s.%s.%s", sname, tname, cname);
    5128           0 :                         if (res == LOG_ERR)
    5129           0 :                                 throw(SQL, "do_str_column_vacuum", SQLSTATE(HY000) "LOG ERROR in storage_api.swap_bats %s.%s.%s", sname, tname, cname);
    5130           0 :                         throw(SQL, "do_str_column_vacuum", SQLSTATE(HY000) "ERROR in storage_api.swap_bats %s.%s.%s", sname, tname, cname);
    5131             :                 }
    5132             :         }
    5133           9 :         BBPunfix(b->batCacheid);
    5134           9 :         BBPreclaim(bn);
    5135             :         return MAL_SUCCEED;
    5136             : }
    5137             : 
    5138             : str
    5139           9 : SQLstr_column_vacuum(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    5140             : {
    5141           9 :         mvc *m = NULL;
    5142           9 :         str msg = NULL;
    5143           9 :         char *sname = *getArgReference_str(stk, pci, 1);
    5144           9 :         char *tname = *getArgReference_str(stk, pci, 2);
    5145           9 :         char *cname = *getArgReference_str(stk, pci, 3);
    5146             : 
    5147           9 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    5148             :                 return msg;
    5149           9 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    5150             :                 return msg;
    5151             : 
    5152           9 :         sql_trans *tr = m->session->tr;
    5153           9 :         sql_schema *s = NULL;
    5154           9 :         sql_table *t = NULL;
    5155           9 :         sql_column *c = NULL;
    5156             : 
    5157           9 :         if (strNil(sname))
    5158           0 :                 throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "Schema name cannot be NULL");
    5159           9 :         if (strNil(tname))
    5160           0 :                 throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "Table name cannot be NULL");
    5161           9 :         if (strNil(cname))
    5162           0 :                 throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "Column name cannot be NULL");
    5163           9 :         if ((s = mvc_bind_schema(m, sname)) == NULL)
    5164           0 :                 throw(SQL, "sql.str_column_vacuum", SQLSTATE(3F000) "Invalid or missing schema %s",sname);
    5165           9 :         if ((t = mvc_bind_table(m, s, tname)) == NULL)
    5166           0 :                 throw(SQL, "sql.str_column_vacuum", SQLSTATE(42S02) "Invalid or missing table %s.%s",sname,tname);
    5167           9 :         if (!isTable(t))
    5168           0 :                 throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "%s '%s' is not persistent",
    5169           0 :                           TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
    5170           9 :         if (isTempTable(t))
    5171           0 :                 throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "Cannot vacuum column from temporary table");
    5172           9 :         if ((c = mvc_bind_column(m, t, cname)) == NULL)
    5173           0 :                 throw(SQL, "sql.str_column_vacuum", SQLSTATE(42S22) "Column not found in %s.%s.%s",sname,tname,cname);
    5174           9 :         if (c->storage_type)
    5175           0 :                 throw(SQL, "sql.str_column_vacuum", SQLSTATE(42000) "Cannot vacuum compressed column");
    5176             : 
    5177           9 :         return do_str_column_vacuum(tr, c, sname, tname, cname);
    5178             : }
    5179             : 
    5180             : 
    5181             : static gdk_return
    5182           0 : str_column_vacuum_callback(int argc, void *argv[]) {
    5183           0 :         sqlstore *store = (sqlstore *) argv[0];
    5184           0 :         char *sname = (char *) argv[1];
    5185           0 :         char *tname = (char *) argv[2];
    5186           0 :         char *cname = (char *) argv[3];
    5187           0 :         allocator *sa = NULL;
    5188           0 :         sql_session *session = NULL;
    5189           0 :         sql_schema *s = NULL;
    5190           0 :         sql_table *t = NULL;
    5191           0 :         sql_column *c = NULL;
    5192           0 :         char *msg;
    5193           0 :         gdk_return res = GDK_SUCCEED;
    5194             : 
    5195           0 :         (void) argc;
    5196             : 
    5197           0 :         if ((sa = sa_create(NULL)) == NULL) {
    5198           0 :                 TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Failed to create allocator!");
    5199           0 :                 return GDK_FAIL;
    5200             :         }
    5201             : 
    5202           0 :         if ((session = sql_session_create(store, sa, 0)) == NULL) {
    5203           0 :                 TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Failed to create session!");
    5204           0 :                 sa_destroy(sa);
    5205           0 :                 return GDK_FAIL;
    5206             :         }
    5207             : 
    5208           0 :         if (sql_trans_begin(session) < 0) {
    5209           0 :                 TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Failed to begin transaction!");
    5210           0 :                 sql_session_destroy(session);
    5211           0 :                 sa_destroy(sa);
    5212           0 :                 return GDK_FAIL;
    5213             :         }
    5214             : 
    5215           0 :         do {
    5216           0 :                 if((s = find_sql_schema(session->tr, sname)) == NULL) {
    5217           0 :                         TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Invalid or missing schema %s!",sname);
    5218           0 :                         res = GDK_FAIL;
    5219           0 :                         break;
    5220             :                 }
    5221             : 
    5222           0 :                 if((t = find_sql_table(session->tr, s, tname)) == NULL) {
    5223           0 :                         TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Invalid or missing table %s!", tname);
    5224           0 :                         res = GDK_FAIL;
    5225           0 :                         break;
    5226             :                 }
    5227             : 
    5228           0 :                 if ((c = find_sql_column(t, cname)) == NULL) {
    5229           0 :                         TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- Invalid or missing column %s!", cname);
    5230           0 :                         res = GDK_FAIL;
    5231           0 :                         break;
    5232             :                 }
    5233             : 
    5234           0 :                 if((msg=do_str_column_vacuum(session->tr, c, sname, tname, cname)) != MAL_SUCCEED) {
    5235           0 :                         TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- %s", msg);
    5236           0 :                         res = GDK_FAIL;
    5237             :                 }
    5238             : 
    5239             :         } while(0);
    5240             : 
    5241           0 :         if (res == GDK_SUCCEED) { /* everything is ok, do the commit route */
    5242           0 :                 switch (sql_trans_end(session, SQL_OK)) {
    5243           0 :                         case SQL_ERR:
    5244           0 :                                 TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- transaction commit failed (kernel error: %s)", GDKerrbuf);
    5245           0 :                                 res = GDK_FAIL;
    5246           0 :                                 break;
    5247           0 :                         case SQL_CONFLICT:
    5248           0 :                                 TRC_ERROR((component_t) SQL, "[str_column_vacuum_callback] -- transaction is aborted because of concurrency conflicts, will ROLLBACK instead");
    5249           0 :                                 res = GDK_FAIL;
    5250           0 :                                 break;
    5251             :                         default:
    5252             :                                 break;
    5253             :                 }
    5254             :         } else { /* an error triggered, rollback and ignore further errors */
    5255           0 :                 (void)sql_trans_end(session, SQL_ERR);
    5256             :         }
    5257             : 
    5258           0 :         sql_session_destroy(session);
    5259           0 :         sa_destroy(sa);
    5260           0 :         return res;
    5261             : }
    5262             : 
    5263             : static gdk_return
    5264           0 : str_column_vacuum_callback_args_free(int argc, void *argv[])
    5265             : {
    5266           0 :         (void) argc;
    5267             :         // free up sname, tname, cname. First pointer points to sqlstore so leave it.
    5268           0 :         GDKfree(argv[1]); // sname
    5269           0 :         GDKfree(argv[2]); // tname
    5270           0 :         GDKfree(argv[3]); // cname
    5271           0 :         return GDK_SUCCEED;
    5272             : }
    5273             : 
    5274             : str
    5275           0 : SQLstr_column_auto_vacuum(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    5276             : {
    5277           0 :         mvc *m = NULL;
    5278           0 :         str msg = NULL;
    5279           0 :         char *sname = *getArgReference_str(stk, pci, 1);
    5280           0 :         char *tname = *getArgReference_str(stk, pci, 2);
    5281           0 :         char *cname = *getArgReference_str(stk, pci, 3);
    5282           0 :         int interval = *getArgReference_int(stk, pci, 4); // in sec
    5283           0 :         char *sname_copy = NULL, *tname_copy = NULL, *cname_copy = NULL;
    5284             : 
    5285           0 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    5286             :                 return msg;
    5287           0 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    5288             :                 return msg;
    5289             : 
    5290           0 :         sql_schema *s = NULL;
    5291           0 :         sql_table *t = NULL;
    5292           0 :         sql_column *c = NULL;
    5293             : 
    5294           0 :         if (strNil(sname))
    5295           0 :                 throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "Schema name cannot be NULL");
    5296           0 :         if (strNil(tname))
    5297           0 :                 throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "Table name cannot be NULL");
    5298           0 :         if (strNil(cname))
    5299           0 :                 throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "Column name cannot be NULL");
    5300           0 :         if ((s = mvc_bind_schema(m, sname)) == NULL)
    5301           0 :                 throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(3F000) "Invalid or missing schema %s",sname);
    5302           0 :         if ((t = mvc_bind_table(m, s, tname)) == NULL)
    5303           0 :                 throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42S02) "Invalid or missing table %s.%s",sname,tname);
    5304           0 :         if (!isTable(t))
    5305           0 :                 throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "%s '%s' is not persistent",
    5306           0 :                           TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
    5307           0 :         if (isTempTable(t))
    5308           0 :                 throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "Cannot vacuum column from temporary table");
    5309           0 :         if ((c = mvc_bind_column(m, t, cname)) == NULL)
    5310           0 :                 throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42S22) "Column not found in %s.%s.%s",sname,tname,cname);
    5311           0 :         if (c->storage_type)
    5312           0 :                 throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(42000) "Cannot vacuum compressed column");
    5313             : 
    5314           0 :         if (!(sname_copy = GDKstrdup(sname)) || !(tname_copy = GDKstrdup(tname)) || !(cname_copy = GDKstrdup(cname))) {
    5315           0 :                 GDKfree(sname_copy);
    5316           0 :                 GDKfree(tname_copy);
    5317           0 :                 GDKfree(cname_copy);
    5318           0 :                 throw(SQL, "sql.str_column_auto_vacuum", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    5319             :         }
    5320           0 :         void *argv[4] = {m->store, sname_copy, tname_copy, cname_copy};
    5321             : 
    5322           0 :         if (gdk_add_callback("str_column_vacuum", str_column_vacuum_callback, 4, argv, interval) != GDK_SUCCEED) {
    5323           0 :                 str_column_vacuum_callback_args_free(4, argv);
    5324           0 :                 throw(SQL, "sql.str_column_auto_vacuum", "adding vacuum callback failed!");
    5325             :         }
    5326             : 
    5327             :         return MAL_SUCCEED;
    5328             : }
    5329             : 
    5330             : str
    5331           0 : SQLstr_column_stop_vacuum(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    5332             : {
    5333           0 :         mvc *m = NULL;
    5334           0 :         str msg = NULL;
    5335           0 :         char *sname = *getArgReference_str(stk, pci, 1);
    5336           0 :         char *tname = *getArgReference_str(stk, pci, 2);
    5337           0 :         char *cname = *getArgReference_str(stk, pci, 3);
    5338             : 
    5339           0 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    5340             :                 return msg;
    5341           0 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    5342             :                 return msg;
    5343             : 
    5344           0 :         sql_schema *s = NULL;
    5345           0 :         sql_table *t = NULL;
    5346           0 :         sql_column *c = NULL;
    5347             : 
    5348           0 :         if (strNil(sname))
    5349           0 :                 throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42000) "Schema name cannot be NULL");
    5350           0 :         if (strNil(tname))
    5351           0 :                 throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42000) "Table name cannot be NULL");
    5352           0 :         if (strNil(cname))
    5353           0 :                 throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42000) "Column name cannot be NULL");
    5354           0 :         if ((s = mvc_bind_schema(m, sname)) == NULL)
    5355           0 :                 throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(3F000) "Invalid or missing schema %s",sname);
    5356           0 :         if ((t = mvc_bind_table(m, s, tname)) == NULL)
    5357           0 :                 throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42S02) "Invalid or missing table %s.%s",sname,tname);
    5358           0 :         if (!isTable(t))
    5359           0 :                 throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42000) "%s '%s' is not persistent",
    5360           0 :                           TABLE_TYPE_DESCRIPTION(t->type, t->properties), t->base.name);
    5361           0 :         if (isTempTable(t))
    5362           0 :                 throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42000) "Cannot vacuum column from temporary table");
    5363           0 :         if ((c = mvc_bind_column(m, t, cname)) == NULL)
    5364           0 :                 throw(SQL, "sql.str_column_stop_vacuum", SQLSTATE(42S22) "Column not found in %s.%s.%s",sname,tname,cname);
    5365             : 
    5366           0 :         if(gdk_remove_callback("str_column_vacuum", str_column_vacuum_callback_args_free) != GDK_SUCCEED)
    5367           0 :                 throw(SQL, "sql.str_column_stop_vacuum", "removing vacuum callback failed!");
    5368             : 
    5369             :         return MAL_SUCCEED;
    5370             : }
    5371             : 
    5372             : 
    5373             : #include "sql_cat.h"
    5374             : #include "sql_rank.h"
    5375             : #include "sql_user.h"
    5376             : #include "sql_assert.h"
    5377             : #include "sql_execute.h"
    5378             : #include "sql_orderidx.h"
    5379             : #include "sql_strimps.h"
    5380             : #include "sql_subquery.h"
    5381             : #include "sql_statistics.h"
    5382             : #include "sql_transaction.h"
    5383             : #include "for.h"
    5384             : #include "dict.h"
    5385             : #include "mel.h"
    5386             : 
    5387             : 
    5388             : static str
    5389          51 : SQLuser_password(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    5390             : {
    5391          51 :         mvc *m = NULL;
    5392          51 :         str msg = NULL;
    5393          51 :         str *password = getArgReference_str(stk, pci, 0);
    5394          51 :         const char *username = *getArgReference_str(stk, pci, 1);
    5395             : 
    5396          51 :         (void) password;
    5397             : 
    5398          51 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    5399             :                 return msg;
    5400          51 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    5401             :                 return msg;
    5402          51 :         if (cntxt->username != username) {
    5403             :                 // only MAL_ADMIN and user himself can access password
    5404          51 :                 if ((msg = AUTHrequireAdmin(cntxt)) != MAL_SUCCEED)
    5405             :                         return msg;
    5406             :         }
    5407          51 :         *password = monet5_password_hash(m, username);
    5408          51 :         if (!(*password))
    5409           1 :                 throw(SQL, "mvc", SQLSTATE(42000) "SELECT: Failed to retrieve password hash");
    5410             :         return MAL_SUCCEED;
    5411             : }
    5412             : 
    5413             : static str
    5414          10 : SQLdecypher(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    5415             : {
    5416          10 :         mvc *m = NULL;
    5417          10 :         str msg = NULL;
    5418          10 :         str *pwhash = getArgReference_str(stk, pci, 0);
    5419          10 :         const char *cypher = *getArgReference_str(stk, pci, 1);
    5420             : 
    5421          10 :         (void) pwhash;
    5422             : 
    5423          10 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    5424             :                 return msg;
    5425          10 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    5426             :                 return msg;
    5427          10 :         return AUTHdecypherValue(pwhash, cypher);
    5428             : }
    5429             : 
    5430             : static str
    5431          40 : SQLcheck(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
    5432             : {
    5433          40 :         mvc *m = NULL;
    5434          40 :         str msg = NULL;
    5435          40 :         str *r = getArgReference_str(stk, pci, 0);
    5436          40 :         const char *sname = *getArgReference_str(stk, pci, 1);
    5437          40 :         const char *kname = *getArgReference_str(stk, pci, 2);
    5438             : 
    5439          40 :         if ((msg = getSQLContext(cntxt, mb, &m, NULL)) != NULL)
    5440             :                 return msg;
    5441          40 :         if ((msg = checkSQLContext(cntxt)) != NULL)
    5442             :                 return msg;
    5443          40 :         (void)sname;
    5444          40 :         sql_schema *s = mvc_bind_schema(m, sname);
    5445          40 :         if (s) {
    5446          40 :                 sql_key *k = mvc_bind_key(m, s, kname);
    5447          40 :                 if (k && k->check) {
    5448           7 :                         int pos = 0;
    5449           7 :                         sql_rel *rel = rel_basetable(m, k->t, k->t->base.name);
    5450           7 :                         sql_exp *exp = exp_read(m, rel, NULL, NULL, sa_strdup(m->sa, k->check), &pos, 0);
    5451           7 :                         if (exp->comment)
    5452           5 :                                 *r = GDKstrdup(exp->comment);
    5453             :                         else
    5454           2 :                                 *r = GDKstrdup(exp2sql(m, exp));
    5455           7 :                         if (*r == NULL)
    5456           0 :                                 throw(SQL, "SQLcheck", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    5457             :                         return MAL_SUCCEED;
    5458             :                 }
    5459             :         }
    5460          33 :         if (!(*r = GDKstrdup(str_nil)))
    5461           0 :                 throw(SQL, "SQLcheck", SQLSTATE(HY013) MAL_MALLOC_FAIL);
    5462             :         return MAL_SUCCEED;
    5463             : }
    5464             : 
    5465             : static mel_func sql_init_funcs[] = {
    5466             :  pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,3, arg("",str),arg("delay",bte),arg("force",bit))),
    5467             :  pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,3, arg("",str),arg("delay",sht),arg("force",bit))),
    5468             :  pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,3, arg("",str),arg("delay",int),arg("force",bit))),
    5469             :  pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,2, arg("",str),arg("delay",bte))),
    5470             :  pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,2, arg("",str),arg("delay",sht))),
    5471             :  pattern("sql", "shutdown", SQLshutdown_wrap, true, "", args(1,2, arg("",str),arg("delay",int))),
    5472             :  pattern("sql", "set_protocol", SQLset_protocol, true, "Configures the result set protocol", args(1,2, arg("",int), arg("protocol",int))),
    5473             :  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))),
    5474             :  pattern("sql", "eval", SQLstatement, true, "Compile and execute a single sql statement", args(1,2, arg("",void),arg("cmd",str))),
    5475             :  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))),
    5476             :  pattern("sql", "include", SQLinclude, true, "Compile and execute a sql statements on the file", args(1,2, arg("",void),arg("fname",str))),
    5477             :  pattern("sql", "evalAlgebra", RAstatement, true, "Compile and execute a single 'relational algebra' statement", args(1,3, arg("",void),arg("cmd",str),arg("optimize",bit))),
    5478             :  pattern("sql", "register", RAstatement2, true, "", args(1,5, arg("",int),arg("mod",str),arg("fname",str),arg("rel_stmt",str),arg("sig",str))),
    5479             :  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))),
    5480             :  pattern("sql", "deregister", RAstatementEnd, true, "Finish running transaction", args(1,1, arg("",int))),
    5481             :  pattern("sql", "hot_snapshot", SQLhot_snapshot, true, "Write db snapshot to the given tar(.gz) file", args(1,2, arg("",void),arg("tarfile",str))),
    5482             :  pattern("sql", "resume_log_flushing", SQLresume_log_flushing, true, "Resume WAL log flushing", args(1,1, arg("",void))),
    5483             :  pattern("sql", "suspend_log_flushing", SQLsuspend_log_flushing, true, "Suspend WAL log flushing", args(1,1, arg("",void))),
    5484             :  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))),
    5485             :  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))),
    5486             :  pattern("sql", "assert", SQLassert, false, "Generate an exception when b==true", args(1,3, arg("",void),arg("b",bit),arg("msg",str))),
    5487             :  pattern("sql", "assert", SQLassertInt, false, "Generate an exception when b!=0", args(1,3, arg("",void),arg("b",int),arg("msg",str))),
    5488             :  pattern("sql", "assert", SQLassertLng, false, "Generate an exception when b!=0", args(1,3, arg("",void),arg("b",lng),arg("msg",str))),
    5489             :  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))),
    5490             :  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))),
    5491             :  pattern("sql", "logfile", mvc_logfile, true, "Enable/disable saving the sql statement traces", args(1,2, arg("",void),arg("filename",str))),
    5492             :  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))),
    5493             :  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))),
    5494             :  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))),
    5495             :  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))),
    5496             :  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))),
    5497             :  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))),
    5498             :  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))),
    5499             :  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))),
    5500             :  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))),
    5501             :  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))),
    5502             :  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))),
    5503             :  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))),
    5504             :  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))),
    5505             :  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))),
    5506             :  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))),
    5507             :  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))),
    5508             :  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))),
    5509             :  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))),
    5510             :  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))),
    5511             :  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))),
    5512             :  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))),
    5513             :  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))),
    5514             :  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))),
    5515             :  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))),
    5516             :  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))),
    5517             :  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))),
    5518             :  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))),
    5519             :  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))),
    5520             :  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))),
    5521             :  command("sql", "getVersion", mvc_getVersion, false, "Return the database version identifier for a client.", args(1,2, arg("",lng),arg("clientid",int))),
    5522             :  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))),
    5523             :  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))),
    5524             :  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))),
    5525             :  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))),
    5526             :  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))),
    5527             :  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))),
    5528             :  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))),
    5529             :  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))),
    5530             :  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))),
    5531             :  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))),
    5532             :  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))),
    5533             :  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))),
    5534             :  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))),
    5535             :  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))),
    5536             :  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))),
    5537             :  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))),
    5538             :  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))),
    5539             :  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))),
    5540             :  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))),
    5541             :  pattern("sql", "exportOperation", mvc_export_operation_wrap, true, "Export result of schema/transaction queries", args(1,1, arg("",void))),
    5542             :  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))),
    5543             :  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))),
    5544             :  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))),
    5545             :  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))),
    5546             :  //we use bat.single now
    5547             :  //pattern("sql", "single", CMDBATsingle, false, "", args(1,2, batargany("",2),argany("x",2))),
    5548             :  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))),
    5549             :  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))),
    5550             :  command("sql", "optimizers", getPipeCatalog, false, "", args(3,3, batarg("",str),batarg("",str),batarg("",str))),
    5551             :  pattern("sql", "optimizer_updates", SQLoptimizersUpdate, false, "", noargs),
    5552             :  pattern("sql", "argRecord", SQLargRecord, false, "Glue together the calling sequence", args(1,1, arg("",str))),
    5553             :  pattern("sql", "argRecord", SQLargRecord, false, "Glue together the calling sequence", args(1,2, arg("",str),varargany("a",0))),
    5554             :  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))),
    5555             :  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),)),
    5556             :  pattern("sql", "password", SQLuser_password, false, "Return password hash of user", args(1,2, arg("",str),arg("user",str))),
    5557             :  pattern("sql", "decypher", SQLdecypher, false, "Return decyphered password", args(1,2, arg("",str),arg("hash",str))),
    5558             :  pattern("sql", "dump_cache", dump_cache, false, "dump the content of the query cache", args(2,2, batarg("query",str),batarg("count",int))),
    5559             :  pattern("sql", "dump_opt_stats", dump_opt_stats, false, "dump the optimizer rewrite statistics", args(2,2, batarg("rewrite",str),batarg("count",int))),
    5560             :  pattern("sql", "dump_trace", dump_trace, false, "dump the trace statistics", args(3,3, batarg("ticks",lng),batarg("stmt",str),batarg("stmt",str))),
    5561             :  pattern("sql", "analyze", sql_analyze, true, "Update statistics for every column in the database", args(1,1, arg("",void))),
    5562             :  pattern("sql", "analyze", sql_analyze, true, "Update statistics for schema", args(1,2, arg("",void),arg("sch",str))),
    5563             :  pattern("sql", "analyze", sql_analyze, true, "Update statistics for table", args(1,3, arg("",void),arg("sch",str),arg("tbl",str))),
    5564             :  pattern("sql", "analyze", sql_analyze, true, "Update statistics for column", args(1,4, arg("",void),arg("sch",str),arg("tbl",str),arg("col",str))),
    5565             :  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))),
    5566             :  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))),
    5567             :  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))),
    5568             :  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))),
    5569             :  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))),
    5570             :  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))),
    5571             :  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))),
    5572             :  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))),
    5573             :  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))),
    5574             :  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))),
    5575             :  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))),
    5576             :  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))),
    5577             :  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))),
    5578             :  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))),
    5579             :  command("calc", "identity", SQLidentity, false, "Returns a unique row identitfier.", args(1,2, arg("",oid),argany("",0))),
    5580             :  command("batcalc", "identity", BATSQLidentity, false, "Returns the unique row identitfiers.", args(1,2, batarg("",oid),batargany("b",0))),
    5581             :  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))),
    5582             :  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))),
    5583             :  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))),
    5584             :  pattern("sql", "querylog_empty", sql_querylog_empty, true, "", noargs),
    5585             :  command("sql", "querylog_enable", QLOGenable, true, "", noargs),
    5586             :  command("sql", "querylog_enable", QLOGenableThreshold, true, "", args(0,1, arg("thres",int))),
    5587             :  command("sql", "querylog_disable", QLOGdisable, true, "", noargs),
    5588             :  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))),
    5589             :  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))),
    5590             :  pattern("sql", "copy_rejects", COPYrejects, false, "", args(4,4, batarg("rowid",lng),batarg("fldid",int),batarg("msg",str),batarg("inp",str))),
    5591             :  pattern("sql", "copy_rejects_clear", COPYrejects_clear, true, "", noargs),
    5592             :  pattern("for", "compress", FORcompress_col, false, "compress a sql column", args(0, 3, arg("schema", str), arg("table", str), arg("column", str))),
    5593             :  pattern("for", "decompress", FORdecompress, false, "decompress a for compressed (sub)column", args(1, 3, batargany("", 1), batargany("o", 0), argany("minval", 1))),
    5594             :  pattern("dict", "compress", DICTcompress, false, "dict compress a bat", args(2, 3, batargany("o", 0), batargany("v", 1), batargany("b", 1))),
    5595             :  pattern("dict", "compress", DICTcompress_col, false, "compress a sql column", args(0, 3, arg("schema", str), arg("table", str), arg("column", str))),
    5596             :  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))),
    5597             :  pattern("dict", "decompress", DICTdecompress, false, "decompress a dictionary compressed (sub)column", args(1, 3, batargany("", 1), batargany("o", 0), batargany("u", 1))),
    5598             :  pattern("dict", "convert", DICTconvert, false, "convert candidate list into compressed offsets", args(1, 2, batargany("", 1), batargany("o", 0))),
    5599             :  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))),
    5600             :  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))),
    5601             :  pattern("dict", "renumber", DICTrenumber, false, "renumber offsets", args(1, 3, batargany("n", 1), batargany("o", 1), batargany("r", 1))),
    5602             :  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))),
    5603             :  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))),
    5604             :  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))),
    5605             :  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))),
    5606             :  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))),
    5607             :  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))),
    5608             :  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))),
    5609             :  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))),
    5610             :  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))),
    5611             :  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))),
    5612             :  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))),
    5613             :  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))),
    5614             :  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))),
    5615             :  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))),
    5616             :  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))),
    5617             :  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))),
    5618             :  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))),
    5619             :  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))),
    5620             :  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))),
    5621             :  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))),
    5622             :  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))),
    5623             :  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))),
    5624             :  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))),
    5625             :  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))),
    5626             :  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))),
    5627             :  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))),
    5628             :  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))),
    5629             :  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))),
    5630             :  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))),
    5631             :  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))),
    5632             :  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))),
    5633             :  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))),
    5634             :  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))),
    5635             :  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))),
    5636             :  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))),
    5637             :  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))),
    5638             :  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))),
    5639             :  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))),
    5640             :  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))),
    5641             :  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))),
    5642             :  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))),
    5643             :  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))),
    5644             :  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))),
    5645             :  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))),
    5646             :  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))),
    5647             :  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))),
    5648             :  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))),
    5649             :  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))),
    5650             :  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))),
    5651             :  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))),
    5652             :  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))),
    5653             :  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))),
    5654             :  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))),
    5655             :  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))),
    5656             :  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))),
    5657             :  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))),
    5658             :  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))),
    5659             :  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))),
    5660             :  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))),
    5661             :  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))),
    5662             :  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))),
    5663             :  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))),
    5664             :  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))),
    5665             :  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))),
    5666             :  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))),
    5667             :  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))),
    5668             :  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))),
    5669             :  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))),
    5670             :  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))),
    5671             :  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))),
    5672             :  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))),
    5673             :  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))),
    5674             :  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))),
    5675             :  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))),
    5676             :  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))),
    5677             :  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))),
    5678             :  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))),
    5679             :  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))),
    5680             :  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))),
    5681             :  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))),
    5682             :  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))),
    5683             :  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))),
    5684             :  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))),
    5685             :  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))),
    5686             :  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))),
    5687             :  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))),
    5688             :  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))),
    5689             :  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))),
    5690             :  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))),
    5691             :  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))),
    5692             :  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))),
    5693             :  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))),
    5694             :  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))),
    5695             :  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))),
    5696             :  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))),
    5697             :  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))),
    5698             :  command("batsql", "alpha", SQLbat_alpha_cst, false, "BAT implementation of astronomy alpha function", args(1,3, batarg("",dbl),batarg("dec",dbl),arg("theta",dbl))),
    5699             :  command("batsql", "alpha", SQLcst_alpha_bat, false, "BAT implementation of astronomy alpha function", args(1,3, batarg("",dbl),arg("dec",dbl),batarg("theta",dbl))),
    5700             :  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))),
    5701             :  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))),
    5702             :  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))),
    5703             :  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))),
    5704             :  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))),
    5705             :  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))),
    5706             :  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))),
    5707             :  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))),
    5708             :  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))),
    5709             :  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))),
    5710             :  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))),
    5711             :  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))),
    5712             :  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))),
    5713             :  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))),
    5714             :  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))),
    5715             :  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))),
    5716             :  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))),
    5717             :  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))),
    5718             :  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))),
    5719             :  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))),
    5720             :  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))),
    5721             :  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))),
    5722             :  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))),
    5723             :  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))),
    5724             :  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))),
    5725             :  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))),
    5726             :  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))),
    5727             :  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))),
    5728             :  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))),
    5729             :  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))),
    5730             :  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))),
    5731             :  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))),
    5732             :  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))),
    5733             :  pattern("sql", "current_time", SQLcurrent_daytime, false, "Get the clients current daytime", args(1,1, arg("",daytime))),
    5734             :  pattern("sql", "current_timestamp", SQLcurrent_timestamp, false, "Get the clients current timestamp", args(1,1, arg("",timestamp))),
    5735             :  pattern("calc", "date", nil_2_date, false, "cast to date", args(1,2, arg("",date),arg("v",void))),
    5736             :  pattern("batcalc", "date", nil_2_date, false, "cast to date", args(1,2, batarg("",date),batarg("v",oid))),
    5737             :  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))),
    5738             :  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))),
    5739             :  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))),
    5740             :  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))),
    5741             :  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))),
    5742             :  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))),
    5743             :  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))),
    5744             :  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))),
    5745             :  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))),
    5746             :  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))),
    5747             :  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))),
    5748             :  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))),
    5749             :  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))),
    5750             :  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))),
    5751             :  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))),
    5752             :  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))),
    5753             :  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))),
    5754             :  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))),
    5755             :  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))),
    5756             :  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))),
    5757             :  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))),
    5758             :  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))),
    5759             :  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))),
    5760             :  pattern("calc", "rowid", sql_rowid, false, "return the next rowid", args(1,4, arg("",oid),argany("v",1),arg("schema",str),arg("table",str))),
    5761             :  pattern("sql", "drop_hash", SQLdrop_hash, true, "Drop hash indices for the given table", args(0,2, arg("sch",str),arg("tbl",str))),
    5762             :  pattern("sql", "prelude", SQLprelude, false, "", noargs),
    5763             :  command("sql", "epilogue", SQLepilogue, false, "", noargs),
    5764             :  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))),
    5765             :  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))),
    5766             :  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))),
    5767             :  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))),
    5768             :  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))),
    5769             :  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))),
    5770             :  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))),
    5771             :  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))),
    5772             :  pattern("sql", "update_tables", SYSupdate_tables, true, "Procedure triggered on update of the sys._tables table", args(1,1, arg("",void))),
    5773             :  pattern("sql", "update_schemas", SYSupdate_schemas, true, "Procedure triggered on update of the sys.schemas table", args(1,1, arg("",void))),
    5774             :  pattern("sql", "unionfunc", SQLunionfunc, false, "", args(1,4, varargany("",0),arg("mod",str),arg("fcn",str),varargany("",0))),
    5775             :  /* decimals */
    5776             :  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))),
    5777             :  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))),
    5778             :  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))),
    5779             :  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))),
    5780             :  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))),
    5781             :  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))),
    5782             :  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))),
    5783             :  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))),
    5784             :  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))),
    5785             :  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))),
    5786             :  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))),
    5787             :  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))),
    5788             :  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))),
    5789             :  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))),
    5790             :  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))),
    5791             :  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))),
    5792             :  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))),
    5793             :  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))),
    5794             :  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))),
    5795             :  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))),
    5796             :  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))),
    5797             :  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))),
    5798             :  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))),
    5799             :  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))),
    5800             :  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))),
    5801             :  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))),
    5802             :  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))),
    5803             :  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))),
    5804             :  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))),
    5805             :  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))),
    5806             :  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))),
    5807             :  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))),
    5808             :  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))),
    5809             :  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))),
    5810             :  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))),
    5811             :  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))),
    5812             :  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))),
    5813             :  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))),
    5814             :  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))),
    5815             :  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))),
    5816             :  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))),
    5817             :  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))),
    5818             :  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))),
    5819             :  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))),
    5820             :  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))),
    5821             :  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))),
    5822             :  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))),
    5823             :  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))),
    5824             :  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))),
    5825             :  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))),
    5826             :  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))),
    5827             :  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))),
    5828             :  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))),
    5829             :  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))),
    5830             :  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))),
    5831             :  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))),
    5832             :  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))),
    5833             :  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))),
    5834             :  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))),
    5835             :  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))),
    5836             :  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))),
    5837             :  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))),
    5838             :  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))),
    5839             :  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))),
    5840             :  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))),
    5841             :  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))),
    5842             :  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))),
    5843             :  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))),
    5844             :  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))),
    5845             :  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))),
    5846             :  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))),
    5847             :  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))),
    5848             :  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))),
    5849             :  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))),
    5850             :  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))),
    5851             :  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))),
    5852             :  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))),
    5853             :  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))),
    5854             :  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))),
    5855             :  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))),
    5856             :  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))),
    5857             :  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))),
    5858             :  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))),
    5859             :  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))),
    5860             :  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))),
    5861             :  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))),
    5862             :  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))),
    5863             :  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))),
    5864             :  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))),
    5865             :  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))),
    5866             :  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))),
    5867             :  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))),
    5868             :  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))),
    5869             :  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))),
    5870             :  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))),
    5871             :  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))),
    5872             :  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))),
    5873             :  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))),
    5874             :  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))),
    5875             :  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))),
    5876             :  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))),
    5877             :  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))),
    5878             :  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))),
    5879             :  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))),
    5880             :  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))),
    5881             :  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))),
    5882             :  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))),
    5883             :  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))),
    5884             :  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))),
    5885             :  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))),
    5886             :  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))),
    5887             :  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))),
    5888             :  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))),
    5889             :  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))),
    5890             :  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))),
    5891             :  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))),
    5892             :  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))),
    5893             :  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))),
    5894             :  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))),
    5895             :  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))),
    5896             :  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))),
    5897             :  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))),
    5898             :  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))),
    5899             :  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))),
    5900             :  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))),
    5901             :  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))),
    5902             :  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))),
    5903             :  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))),
    5904             :  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))),
    5905             :  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))),
    5906             :  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))),
    5907             :  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))),
    5908             :  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))),
    5909             :  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))),
    5910             :  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))),
    5911             :  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))),
    5912             :  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))),
    5913             :  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))),
    5914             :  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))),
    5915             :  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))),
    5916             :  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))),
    5917             :  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))),
    5918             :  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))),
    5919             :  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))),
    5920             :  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))),
    5921             :  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))),
    5922             :  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))),
    5923             :  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))),
    5924             :  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))),
    5925             :  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))),
    5926             :  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))),
    5927             :  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))),
    5928             :  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))),
    5929             :  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))),
    5930             :  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))),
    5931             :  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))),
    5932             :  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))),
    5933             :  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))),
    5934             :  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))),
    5935             :  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))),
    5936             :  /* sql_rank */
    5937             :  pattern("sql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,2, arg("",bit),argany("b",1))),
    5938             :  pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,2, batarg("",bit),batargany("b",1))),
    5939             :  pattern("sql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, arg("",bit),arg("p",bit),argany("b",1))),
    5940             :  pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, batarg("",bit),arg("p",bit),batargany("b",1))),
    5941             :  pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, batarg("",bit),batarg("p",bit),argany("b",1))),
    5942             :  pattern("batsql", "diff", SQLdiff, false, "return true if cur != prev row", args(1,3, batarg("",bit),batarg("p",bit),batargany("b",1))),
    5943             :  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))),
    5944             :  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))),
    5945             :  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))),
    5946             :  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))),
    5947             :  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))),
    5948             :  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))),
    5949             :  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))),
    5950             :  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))),
    5951             :  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))),
    5952             :  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))),
    5953             :  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))),
    5954             :  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))),
    5955             :  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))),
    5956             :  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))),
    5957             :  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))),
    5958             :  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))),
    5959             :  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))),
    5960             :  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))),
    5961             :  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))),
    5962             :  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))),
    5963             :  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))),
    5964             :  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))),
    5965             :  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))),
    5966             :  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))),
    5967             :  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))),
    5968             :  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))),
    5969             :  pattern("sql", "rank", SQLrank, false, "return the ranked groups", args(1,4, arg("",int),argany("b",1),arg("p",bit),arg("o",bit))),
    5970             :  pattern("batsql", "rank", SQLrank, false, "return the ranked groups", args(1,4, batarg("",int),batargany("b",1),optbatarg("p",bit),optbatarg("o",bit))),
    5971             :  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))),
    5972             :  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))),
    5973             :  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))),
    5974             :  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))),
    5975             :  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))),
    5976             :  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))),
    5977             :  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))),
    5978             :  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))),
    5979             :  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))),
    5980             :  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))),
    5981             :  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))),
    5982             :  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))),
    5983             :  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))),
    5984             :  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))),
    5985             :  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))),
    5986             :  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))),
    5987             :  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))),
    5988             :  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))),
    5989             :  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))),
    5990             :  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))),
    5991             :  /* these window functions support frames */
    5992             :  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))),
    5993             :  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))),
    5994             :  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))),
    5995             :  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))),
    5996             :  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))),
    5997             :  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))),
    5998             :  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))),
    5999             :  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))),
    6000             :  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))),
    6001             :  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))),
    6002             :  pattern("sql", "count", SQLbasecount, false, "return count of basetable", args(1,3, arg("",lng),arg("sname",str),arg("tname",str))),
    6003             :  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))),
    6004             :  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))),
    6005             :  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))),
    6006             :  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))),
    6007             :  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))),
    6008             :  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))),
    6009             :  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))),
    6010             :  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))),
    6011             :  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))),
    6012             :  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))),
    6013             :  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))),
    6014             :  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))),
    6015             :  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))),
    6016             :  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))),
    6017             :  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))),
    6018             :  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))),
    6019             :  /* sql.sum for month intervals */
    6020             :  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))),
    6021             :  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))),
    6022             :  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))),
    6023             :  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))),
    6024             :  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))),
    6025             :  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))),
    6026             :  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))),
    6027             :  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))),
    6028             :  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))),
    6029             :  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))),
    6030             :  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))),
    6031             :  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))),
    6032             :  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))),
    6033             :  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))),
    6034             :  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))),
    6035             :  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))),
    6036             :  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))),
    6037             :  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))),
    6038             :  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))),
    6039             :  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))),
    6040             :  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))),
    6041             :  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))),
    6042             :  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))),
    6043             :  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))),
    6044             :  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))),
    6045             :  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))),
    6046             :  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))),
    6047             :  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))),
    6048             :  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))),
    6049             :  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))),
    6050             :  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))),
    6051             :  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))),
    6052             :  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))),
    6053             :  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))),
    6054             :  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))),
    6055             :  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))),
    6056             :  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))),
    6057             :  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))),
    6058             :  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))),
    6059             :  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))),
    6060             :  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))),
    6061             :  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))),
    6062             :  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))),
    6063             :  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))),
    6064             :  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))),
    6065             :  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))),
    6066             :  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))),
    6067             :  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))),
    6068             :  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))),
    6069             :  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))),
    6070             :  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))),
    6071             :  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))),
    6072             :  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))),
    6073             :  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))),
    6074             :  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))),
    6075             :  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))),
    6076             :  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))),
    6077             :  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))),
    6078             :  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))),
    6079             :  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))),
    6080             :  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))),
    6081             :  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))),
    6082             :  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))),
    6083             :  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))),
    6084             :  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))),
    6085             :  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))),
    6086             :  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))),
    6087             :  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))),
    6088             :  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))),
    6089             :  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))),
    6090             :  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))),
    6091             :  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))),
    6092             :  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))),
    6093             :  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))),
    6094             :  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))),
    6095             :  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))),
    6096             :  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))),
    6097             :  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))),
    6098             :  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))),
    6099             :  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))),
    6100             :  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))),
    6101             :  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))),
    6102             :  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))),
    6103             :  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))),
    6104             :  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))),
    6105             :  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))),
    6106             :  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))),
    6107             :  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))),
    6108             :  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))),
    6109             :  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))),
    6110             :  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))),
    6111             :  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))),
    6112             :  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))),
    6113             :  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))),
    6114             :  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))),
    6115             :  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))),
    6116             :  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))),
    6117             :  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))),
    6118             :  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))),
    6119             :  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))),
    6120             :  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))),
    6121             :  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))),
    6122             :  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))),
    6123             :  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))),
    6124             :  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))),
    6125             :  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))),
    6126             :  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))),
    6127             :  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))),
    6128             :  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))),
    6129             :  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))),
    6130             :  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))),
    6131             :  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))),
    6132             :  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))),
    6133             :  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))),
    6134             :  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))),
    6135             :  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))),
    6136             :  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))),
    6137             :  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))),
    6138             :  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))),
    6139             :  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))),
    6140             :  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))),
    6141             :  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))),
    6142             :  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))),
    6143             :  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))),
    6144             :  /* sql_subquery */
    6145             :  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))),
    6146             :  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))),
    6147             :  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))),
    6148             :  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))),
    6149             :  command("aggr", "all", SQLall, false, "if all values in b are equal return this, else nil", args(1,2, argany("",1),batargany("b",1))),
    6150             :  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))),
    6151             :  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))),
    6152             :  command("aggr", "null", SQLnil, false, "if b has a nil return true, else false", args(1,2, arg("",bit),batargany("b",1))),
    6153             :  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))),
    6154             :  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))),
    6155             :  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))),
    6156             :  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))),
    6157             :  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))),
    6158             :  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))),
    6159             :  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))),
    6160             :  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))),
    6161             :  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))),
    6162             :  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))),
    6163             :  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))),
    6164             :  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))),
    6165             :  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))),
    6166             :  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))),
    6167             :  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))),
    6168             :  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))),
    6169             :  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))),
    6170             :  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))),
    6171             :  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))),
    6172             :  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))),
    6173             :  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))),
    6174             :  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))),
    6175             :  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))),
    6176             : // 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))),
    6177             :  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))),
    6178             :  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))),
    6179             :  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))),
    6180             : // 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))),
    6181             :  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))),
    6182             :  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))),
    6183             :  pattern("aggr", "exist", SQLexist, false, "", args(1,2, arg("",bit), argany("b",1))),
    6184             :  pattern("bataggr", "exist", SQLexist, false, "", args(1,2, batarg("",bit), argany("b",1))),
    6185             :  pattern("bataggr", "exist", SQLexist, false, "", args(1,2, arg("",bit), batargany("b",1))),
    6186             :  pattern("bataggr", "exist", SQLexist, false, "", args(1,2, batarg("",bit), batargany("b",1))),
    6187             :  pattern("aggr", "subexist", SQLsubexist, false, "", args(1,5, batarg("",bit),batargany("b",0),batarg("g",oid),batarg("e",oid),arg("no_nil",bit))),
    6188             :  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))),
    6189             :  pattern("aggr", "not_exist", SQLnot_exist, false, "", args(1,2, arg("",bit), argany("b",1))),
    6190             :  pattern("bataggr", "not_exist", SQLnot_exist, false, "", args(1,2, batarg("",bit), argany("b",1))),
    6191             :  pattern("bataggr", "not_exist", SQLnot_exist, false, "", args(1,2, arg("",bit), batargany("b",1))),
    6192             :  pattern("bataggr", "not_exist", SQLnot_exist, false, "", args(1,2, batarg("",bit), batargany("b",1))),
    6193             :  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))),
    6194             :  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))),
    6195             :  /* sqlcatalog */
    6196             :  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))),
    6197             :  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))),
    6198             :  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))),
    6199             :  pattern("sqlcatalog", "drop_seq", SQLdrop_seq, false, "Catalog operation drop_seq", args(0,3, arg("sname",str),arg("nme",str),arg("action",int))),
    6200             :  pattern("sqlcatalog", "create_schema", SQLcreate_schema, false, "Catalog operation create_schema", args(0,3, arg("sname",str),arg("auth",str),arg("action",int))),
    6201             :  pattern("sqlcatalog", "drop_schema", SQLdrop_schema, false, "Catalog operation drop_schema", args(0,3, arg("sname",str),arg("ifexists",int),arg("action",int))),
    6202             :  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))),
    6203             :  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))),
    6204             :  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))),
    6205             :  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))),
    6206             :  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))),
    6207             :  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))),
    6208             :  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))),
    6209             :  pattern("sqlcatalog", "create_type", SQLcreate_type, false, "Catalog operation create_type", args(0,3, arg("sname",str),arg("nme",str),arg("impl",str))),
    6210             :  pattern("sqlcatalog", "drop_type", SQLdrop_type, false, "Catalog operation drop_type", args(0,3, arg("sname",str),arg("nme",str),arg("action",int))),
    6211             :  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))),
    6212             :  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))),
    6213             :  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))),
    6214             :  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))),
    6215             :  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))),
    6216             :  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))),
    6217             :  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))),
    6218             :  pattern("sqlcatalog", "drop_user", SQLdrop_user, false, "Catalog operation drop_user", args(0,2, arg("sname",str),arg("action",int))),
    6219             :  pattern("sqlcatalog", "drop_user", SQLdrop_user, false, "Catalog operation drop_user", args(0,3, arg("sname",str),arg("auth",str),arg("action",int))),
    6220             :  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))),
    6221             :  pattern("sqlcatalog", "rename_user", SQLrename_user, false, "Catalog operation rename_user", args(0,3, arg("sname",str),arg("newnme",str),arg("action",int))),
    6222             :  pattern("sqlcatalog", "create_role", SQLcreate_role, false, "Catalog operation create_role", args(0,3, arg("sname",str),arg("role",str),arg("grator",int))),
    6223             :  pattern("sqlcatalog", "drop_role", SQLdrop_role, false, "Catalog operation drop_role", args(0,3, arg("auth",str),arg("role",str),arg("action",int))),
    6224             :  pattern("sqlcatalog", "drop_role", SQLdrop_role, false, "Catalog operation drop_role", args(0,2, arg("role",str),arg("action",int))),
    6225             :  pattern("sqlcatalog", "drop_index", SQLdrop_index, false, "Catalog operation drop_index", args(0,3, arg("sname",str),arg("iname",str),arg("action",int))),
    6226             :  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))),
    6227             :  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))),
    6228             :  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))),
    6229             :  pattern("sqlcatalog", "drop_trigger", SQLdrop_trigger, false, "Catalog operation drop_trigger", args(0,3, arg("sname",str),arg("nme",str),arg("ifexists",int))),
    6230             :  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))),
    6231             :  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))),
    6232             :  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))),
    6233             :  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))),
    6234             :  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))),
    6235             :  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))),
    6236             :  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))),
    6237             :  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))),
    6238             :  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))),
    6239             :  pattern("sqlcatalog", "comment_on", SQLcomment_on, false, "Catalog operation comment_on", args(0,2, arg("objid",int),arg("remark",str))),
    6240             :  pattern("sqlcatalog", "rename_schema", SQLrename_schema, false, "Catalog operation rename_schema", args(0,2, arg("sname",str),arg("newnme",str))),
    6241             :  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))),
    6242             :  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))),
    6243             :  /* sql_transaction */
    6244             :  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))),
    6245             :  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))),
    6246             :  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))),
    6247             :  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))),
    6248             : #ifdef HAVE_HGE
    6249             :  /* sql_hge */
    6250             :  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))),
    6251             :  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))),
    6252             :  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))),
    6253             :  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))),
    6254             :  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))),
    6255             :  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))),
    6256             :  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))),
    6257             :  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))),
    6258             :  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))),
    6259             :  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))),
    6260             :  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))),
    6261             :  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))),
    6262             :  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))),
    6263             :  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))),
    6264             :  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))),
    6265             :  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))),
    6266             :  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))),
    6267             :  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))),
    6268             :  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))),
    6269             :  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))),
    6270             :  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))),
    6271             :  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))),
    6272             :  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))),
    6273             :  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))),
    6274             :  /* sql_decimal_hge */
    6275             :  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))),
    6276             :  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))),
    6277             :  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))),
    6278             :  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))),
    6279             :  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))),
    6280             :  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))),
    6281             :  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))),
    6282             :  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))),
    6283             :  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))),
    6284             :  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))),
    6285             :  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))),
    6286             :  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))),
    6287             :  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))),
    6288             :  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))),
    6289             :  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))),
    6290             :  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))),
    6291             :  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))),
    6292             :  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))),
    6293             :  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))),
    6294             :  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))),
    6295             :  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))),
    6296             :  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))),
    6297             :  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))),
    6298             :  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))),
    6299             :  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))),
    6300             :  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))),
    6301             :  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))),
    6302             :  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))),
    6303             :  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))),
    6304             :  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))),
    6305             :  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))),
    6306             :  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))),
    6307             :  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))),
    6308             :  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))),
    6309             :  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))),
    6310             :  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))),
    6311             :  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))),
    6312             :  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))),
    6313             :  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))),
    6314             :  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))),
    6315             :  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))),
    6316             :  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))),
    6317             :  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))),
    6318             :  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))),
    6319             :  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))),
    6320             :  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))),
    6321             :  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))),
    6322             :  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))),
    6323             :  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))),
    6324             :  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))),
    6325             :  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))),
    6326             :  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))),
    6327             :  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))),
    6328             :  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))),
    6329             :  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))),
    6330             :  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))),
    6331             :  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))),
    6332             :  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))),
    6333             :  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))),
    6334             :  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))),
    6335             :  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))),
    6336             :  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))),
    6337             :  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))),
    6338             :  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))),
    6339             :  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))),
    6340             :  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))),
    6341             :  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))),
    6342             :  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))),
    6343             :  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))),
    6344             :  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))),
    6345             :  /* sql_rank_hge */
    6346             :  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))),
    6347             :  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))),
    6348             :  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))),
    6349             :  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))),
    6350             :  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))),
    6351             :  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))),
    6352             :  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))),
    6353             :  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))),
    6354             :  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))),
    6355             :  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))),
    6356             :  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))),
    6357             :  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))),
    6358             :  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))),
    6359             :  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))),
    6360             :  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))),
    6361             :  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))),
    6362             :  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))),
    6363             :  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))),
    6364             :  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))),
    6365             :  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))),
    6366             :  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))),
    6367             :  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))),
    6368             :  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))),
    6369             :  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))),
    6370             :  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))),
    6371             :  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))),
    6372             :  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))),
    6373             :  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))),
    6374             :  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))),
    6375             :  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))),
    6376             :  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))),
    6377             :  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))),
    6378             :  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))),
    6379             :  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))),
    6380             :  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))),
    6381             :  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))),
    6382             :  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))),
    6383             :  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))),
    6384             :  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))),
    6385             :  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))),
    6386             :  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))),
    6387             :  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))),
    6388             : #endif
    6389             :  pattern("sql", "vacuum", SQLstr_column_vacuum, true, "vacuum a string column", args(0,3, arg("sname",str),arg("tname",str),arg("cname",str))),
    6390             :  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))),
    6391             :  pattern("sql", "stop_vacuum", SQLstr_column_stop_vacuum, true, "stop auto vacuum", args(0,3, arg("sname",str),arg("tname",str),arg("cname",str))),
    6392             :  pattern("sql", "check", SQLcheck, false, "Return sql string of check constraint.", args(1,3, arg("sql",str), arg("sname", str), arg("name", str))),
    6393             :  { .imp=NULL }
    6394             : };
    6395             : #include "mal_import.h"
    6396             : #ifdef _MSC_VER
    6397             : #undef read
    6398             : #pragma section(".CRT$XCU",read)
    6399             : #endif
    6400         317 : LIB_STARTUP_FUNC(init_sql_mal)
    6401         317 : { mal_module("sql", NULL, sql_init_funcs); }

Generated by: LCOV version 1.14