Changeset: 64aa8408ee4e for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=64aa8408ee4e
Added Files:
gdk/gdk_analytic.h
gdk/gdk_analytic_bounds.c
gdk/gdk_analytic_func.c
monetdb5/modules/atoms/mtime_analytic.c
sql/backends/monet5/sql_rank.mal.sh
sql/backends/monet5/sql_rank_hge.mal
sql/backends/monet5/sql_rank_hge.mal.sh
sql/test/analytics/Tests/All
sql/test/analytics/Tests/analytics00.sql
sql/test/analytics/Tests/analytics00.stable.err
sql/test/analytics/Tests/analytics00.stable.out
sql/test/analytics/Tests/analytics01.sql
sql/test/analytics/Tests/analytics01.stable.err
sql/test/analytics/Tests/analytics01.stable.out
sql/test/analytics/Tests/analytics02.sql
sql/test/analytics/Tests/analytics02.stable.err
sql/test/analytics/Tests/analytics02.stable.out
sql/test/analytics/Tests/analytics03.sql
sql/test/analytics/Tests/analytics03.stable.err
sql/test/analytics/Tests/analytics03.stable.out
sql/test/analytics/Tests/analytics04.sql
sql/test/analytics/Tests/analytics04.stable.err
sql/test/analytics/Tests/analytics04.stable.out
sql/test/analytics/Tests/analytics05.sql
sql/test/analytics/Tests/analytics05.stable.err
sql/test/analytics/Tests/analytics05.stable.out
sql/test/analytics/Tests/analytics06.sql
sql/test/analytics/Tests/analytics06.stable.err
sql/test/analytics/Tests/analytics06.stable.out
sql/test/analytics/Tests/analytics07.sql
sql/test/analytics/Tests/analytics07.stable.err
sql/test/analytics/Tests/analytics07.stable.out
sql/test/analytics/Tests/analytics08.sql
sql/test/analytics/Tests/analytics08.stable.err
sql/test/analytics/Tests/analytics08.stable.out
sql/test/analytics/Tests/analytics09.sql
sql/test/analytics/Tests/analytics09.stable.err
sql/test/analytics/Tests/analytics09.stable.out
Modified Files:
clients/Tests/MAL-signatures.stable.out
clients/Tests/MAL-signatures.stable.out.int128
clients/Tests/exports.stable.out
clients/mapiclient/mhelp.c
clients/odbc/driver/SQLGetInfo.c
gdk/Makefile.ag
gdk/gdk_aggr.c
gdk/gdk_bbp.c
gdk/gdk_calc_private.h
monetdb5/modules/atoms/Makefile.ag
monetdb5/modules/atoms/mtime.c
monetdb5/modules/atoms/mtime.h
monetdb5/optimizer/opt_prelude.c
monetdb5/optimizer/opt_prelude.h
monetdb5/optimizer/opt_support.c
sql/backends/monet5/Makefile.ag
sql/backends/monet5/rel_bin.c
sql/backends/monet5/sql_hge.mal
sql/backends/monet5/sql_rank.c
sql/backends/monet5/sql_rank.h
sql/backends/monet5/sql_rank.mal
sql/common/sql_types.c
sql/common/sql_types.h
sql/include/sql_catalog.h
sql/scripts/51_sys_schema_extension.sql
sql/server/rel_select.c
sql/server/rel_updates.c
sql/server/sql_atom.c
sql/server/sql_atom.h
sql/server/sql_mvc.c
sql/server/sql_mvc.h
sql/server/sql_parser.h
sql/server/sql_parser.y
sql/server/sql_scan.c
sql/server/sql_symbol.c
sql/server/sql_symbol.h
sql/test/BugDay_2005-10-06_2.9.3/Tests/foreign_key_in_frontend_crashes_backend.SF-935578.sql
sql/test/BugTracker-2009/Tests/orderby_with_row_number.SF-2895791.stable.out
sql/test/BugTracker-2012/Tests/row_number_does_not_work_in_complex_query.Bug-2805.stable.out
sql/test/BugTracker-2018/Tests/count_from_commented_function_signatures.Bug-6542.stable.out
sql/test/BugTracker-2018/Tests/groupby_having_orderby_count.Bug-6624.stable.out
sql/test/Tests/rank.stable.out
sql/test/Tests/systemfunctions.stable.out
sql/test/Tests/systemfunctions.stable.out.int128
sql/test/emptydb/Tests/check.stable.out
sql/test/emptydb/Tests/check.stable.out.32bit
sql/test/emptydb/Tests/check.stable.out.int128
Branch: default
Log Message:
Merged with analytics branch.
diffs (truncated from 19219 to 300 lines):
diff --git a/clients/Tests/MAL-signatures.stable.out
b/clients/Tests/MAL-signatures.stable.out
--- a/clients/Tests/MAL-signatures.stable.out
+++ b/clients/Tests/MAL-signatures.stable.out
@@ -8377,6 +8377,14 @@ Ready.
[ "batrapi", "subeval_aggr", "pattern batrapi.subeval_aggr(fptr:ptr,
expr:str, arg:any...):any... ", "RAPIevalAggr;", "grouped aggregates
through R" ]
[ "batsql", "alpha", "command batsql.alpha(dec:bat[:dbl],
theta:dbl):bat[:dbl] ", "SQLbat_alpha_cst;", "BAT implementation of
astronomy alpha function" ]
[ "batsql", "alpha", "command batsql.alpha(dec:dbl,
theta:bat[:dbl]):bat[:dbl] ", "SQLcst_alpha_bat;", "BAT implementation of
astronomy alpha function" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:bte], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:dbl], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:flt], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:int], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:lng], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:sht], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "count", "pattern batsql.count(b:bat[:any_1],
ignils:bit, s:bat[:lng], e:bat[:lng]):bat[:lng] ", "SQLcount;", "return
count of groups" ]
+[ "batsql", "cume_dist", "pattern batsql.cume_dist(b:bat[:any_1],
p:any_2, o:any_3):bat[:dbl] ", "SQLcume_dist;", "return the accumulated
distribution of the number of rows per group to the total number of partition
rows" ]
[ "batsql", "dec_round", "command batsql.dec_round(v:bat[:bte],
r:bte):bat[:bte] ", "bte_bat_dec_round_wrap;", "round off the value v
to nearests multiple of r" ]
[ "batsql", "dec_round", "command batsql.dec_round(v:bat[:dbl],
r:dbl):bat[:dbl] ", "dbl_bat_dec_round_wrap;", "round off the value v
to nearests multiple of r" ]
[ "batsql", "dec_round", "command batsql.dec_round(v:bat[:flt],
r:flt):bat[:flt] ", "flt_bat_dec_round_wrap;", "round off the value v
to nearests multiple of r" ]
@@ -8386,8 +8394,38 @@ Ready.
[ "batsql", "dense_rank", "pattern batsql.dense_rank(b:bat[:any_1],
p:any_2, o:any_3):bat[:int] ", "SQLdense_rank;", "return the
densely ranked groups" ]
[ "batsql", "diff", "pattern batsql.diff(b:bat[:any_1]):bat[:bit] ",
"SQLdiff;", "return true if cur != prev row" ]
[ "batsql", "diff", "pattern batsql.diff(p:bat[:bit],
b:bat[:any_1]):bat[:bit] ", "SQLdiff;", "return true if cur != prev row"
]
+[ "batsql", "first_value", "pattern batsql.first_value(b:bat[:any_1],
s:bat[:lng], e:bat[:lng]):bat[:any_1] ", "SQLfirst_value;", "return
the first value of groups" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:any_2, d:any_1,
p:any_3, o:any_4):bat[:any_1] ", "SQLlag;", "return the value in the
previous 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:any_2,
d:bat[:any_1], p:any_3, o:any_4):bat[:any_1] ", "SQLlag;", "return the
value in the previous 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:any_2, p:any_3,
o:any_4):bat[:any_1] ", "SQLlag;", "return the value in the previous
'l' row in the partition or NULL if non existent" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:bat[:any_2],
d:any_1, p:any_3, o:any_4):bat[:any_1] ", "SQLlag;", "return the value
in the previous 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:bat[:any_2],
d:bat[:any_1], p:any_3, o:any_4):bat[:any_1] ", "SQLlag;", "return
the value in the previous 'l' row in the partition or 'd' if non existent"
]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:bat[:any_2],
p:any_3, o:any_4):bat[:any_1] ", "SQLlag;", "return the value in the
previous 'l' row in the partition or NULL if non existent" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], p:any_3,
o:any_4):bat[:any_1] ", "SQLlag;", "return the value in the previous
row in the partition or NULL if non existent" ]
+[ "batsql", "last_value", "pattern batsql.last_value(b:bat[:any_1],
s:bat[:lng], e:bat[:lng]):bat[:any_1] ", "SQLlast_value;", "return
the last value of groups" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:any_2, d:any_1,
p:any_3, o:any_4):bat[:any_1] ", "SQLlead;", "return the value in the next
'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:any_2,
d:bat[:any_1], p:any_3, o:any_4):bat[:any_1] ", "SQLlead;", "return the
value in the next 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:any_2, p:any_3,
o:any_4):bat[:any_1] ", "SQLlead;", "return the value in the next 'l' row
in the partition or NULL if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:bat[:any_2],
d:any_1, p:any_3, o:any_4):bat[:any_1] ", "SQLlead;", "return the value
in the next 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:bat[:any_2],
d:bat[:any_1], p:any_3, o:any_4):bat[:any_1] ", "SQLlead;", "return
the value in the next 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:bat[:any_2],
p:any_3, o:any_4):bat[:any_1] ", "SQLlead;", "return the value in the
next 'l' row in the partition or NULL if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], p:any_3,
o:any_4):bat[:any_1] ", "SQLlead;", "return the value in the next row in
the partition or NULL if non existent" ]
+[ "batsql", "max", "pattern batsql.max(b:bat[:any_1], s:bat[:lng],
e:bat[:lng]):bat[:any_1] ", "SQLmax;", "return the maximum of groups"
]
+[ "batsql", "min", "pattern batsql.min(b:bat[:any_1], s:bat[:lng],
e:bat[:lng]):bat[:any_1] ", "SQLmin;", "return the minimum of groups"
]
[ "batsql", "next_value", "pattern batsql.next_value(sname:bat[:str],
sequence:str):bat[:lng] ", "mvc_bat_next_value;", "return the next value of
the sequence" ]
+[ "batsql", "nth_value", "pattern batsql.nth_value(b:bat[:any_1],
n:any_2, s:bat[:lng], e:bat[:lng]):bat[:any_1] ", "SQLnth_value;",
"return the nth value of each group" ]
+[ "batsql", "nth_value", "pattern batsql.nth_value(b:bat[:any_1],
n:bat[:any_2], s:bat[:lng], e:bat[:lng]):bat[:any_1] ", "SQLnth_value;",
"return the nth value of each group" ]
+[ "batsql", "ntile", "pattern batsql.ntile(b:bat[:any_1], n:any_2,
p:any_3, o:any_4):bat[:any_2] ", "SQLntile;", "return the groups divided as
equally as possible" ]
+[ "batsql", "ntile", "pattern batsql.ntile(b:bat[:any_1],
n:bat[:any_2], p:any_3, o:any_4):bat[:any_2] ", "SQLntile;", "return the
groups divided as equally as possible" ]
[ "batsql", "password", "pattern
batsql.password(user:bat[:str]):bat[:str] ", "db_password_wrap;", "Return
password hash of user" ]
+[ "batsql", "percent_rank", "pattern batsql.percent_rank(b:bat[:any_1],
p:any_2, o:any_3):bat[:dbl] ", "SQLpercent_rank;", "return the
percentage into the total number of groups for each row" ]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:bte], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:dbl], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:flt], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:flt], s:bat[:lng],
e:bat[:lng]):bat[:flt] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:int], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:lng], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:sht], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLprod;", "return the product of groups"
]
[ "batsql", "rank", "pattern batsql.rank(b:bat[:any_1], p:any_2,
o:any_3):bat[:int] ", "SQLrank;", "return the ranked groups" ]
[ "batsql", "round", "command batsql.round(v:bat[:bte], d:int,
s:int, r:bte):bat[:bte] ", "bte_bat_round_wrap;", "round off the decimal
v(d,s) to r digits behind the dot (if r < 0, before the dot)" ]
[ "batsql", "round", "command batsql.round(v:bat[:dbl],
r:bte):bat[:dbl] ", "dbl_bat_round_wrap;", "round off the floating point v to
r digits behind the dot (if r < 0, before the dot)" ]
@@ -8396,6 +8434,37 @@ Ready.
[ "batsql", "round", "command batsql.round(v:bat[:lng], d:int,
s:int, r:bte):bat[:lng] ", "lng_bat_round_wrap;", "round off the decimal
v(d,s) to r digits behind the dot (if r < 0, before the dot)" ]
[ "batsql", "round", "command batsql.round(v:bat[:sht], d:int,
s:int, r:bte):bat[:sht] ", "sht_bat_round_wrap;", "round off the decimal
v(d,s) to r digits behind the dot (if r < 0, before the dot)" ]
[ "batsql", "row_number", "pattern batsql.row_number(b:bat[:any_1],
p:any_2, o:any_3):bat[:int] ", "SQLrow_number;", "return the
row_numer-ed groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:bte], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:dbl], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:flt], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:flt], s:bat[:lng],
e:bat[:lng]):bat[:flt] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:int], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:lng], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:sht], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:bte]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:dbl]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:flt]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:int]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:lng]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:sht]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bte):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:dbl):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:flt):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:int):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:lng):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:sht):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:bat[:bte]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:bat[:dbl]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:bat[:flt]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:bat[:int]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:bat[:lng]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:bat[:sht]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:bte):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:dbl):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:flt):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:int):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:lng):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:sht):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
[ "batstr", "endsWith", "command batstr.endsWith(s:bat[:str],
suffix:bat[:str]):bat[:bit] ", "STRbatSuffix;", "Suffix check." ]
[ "batstr", "endsWith", "command batstr.endsWith(s:bat[:str],
suffix:str):bat[:bit] ", "STRbatSuffixcst;", "Suffix check." ]
[ "batstr", "length", "command batstr.length(s:bat[:str]):bat[:int]
", "STRbatLength;", "Return the length of a string." ]
@@ -10915,6 +10984,12 @@ Ready.
[ "sql", "assert", "pattern sql.assert(b:bit, msg:str):void ",
"SQLassert;", "Generate an exception when b==true" ]
[ "sql", "assert", "pattern sql.assert(b:int, msg:str):void ",
"SQLassertInt;", "Generate an exception when b!=0" ]
[ "sql", "assert", "pattern sql.assert(b:lng, msg:str):void ",
"SQLassertLng;", "Generate an exception when b!=0" ]
+[ "sql", "avg", "pattern sql.avg(b:bte, s:lng, e:lng):dbl ",
"SQLavg;", "return the average of groups" ]
+[ "sql", "avg", "pattern sql.avg(b:dbl, s:lng, e:lng):dbl ",
"SQLavg;", "return the average of groups" ]
+[ "sql", "avg", "pattern sql.avg(b:flt, s:lng, e:lng):dbl ",
"SQLavg;", "return the average of groups" ]
+[ "sql", "avg", "pattern sql.avg(b:int, s:lng, e:lng):dbl ",
"SQLavg;", "return the average of groups" ]
+[ "sql", "avg", "pattern sql.avg(b:lng, s:lng, e:lng):dbl ",
"SQLavg;", "return the average of groups" ]
+[ "sql", "avg", "pattern sql.avg(b:sht, s:lng, e:lng):dbl ",
"SQLavg;", "return the average of groups" ]
[ "sql", "bind", "pattern sql.bind(mvc:int, schema:str, table:str,
column:str, access:int) (uid:bat[:oid], uval:bat[:any_1]) ", "mvc_bind_wrap;",
"Bind the 'schema.table.column' BAT with access kind:\n\t0 - base
table\n\t1 - inserts\n\t2 - updates" ]
[ "sql", "bind", "pattern sql.bind(mvc:int, schema:str, table:str,
column:str, access:int):bat[:any_1] ", "mvc_bind_wrap;", "Bind the
'schema.table.column' BAT with access kind:\n\t0 - base table\n\t1 -
inserts\n\t2 - updates" ]
[ "sql", "bind", "pattern sql.bind(mvc:int, schema:str, table:str,
column:str, access:int, part_nr:int, nr_parts:int) (uid:bat[:oid],
uval:bat[:any_1]) ", "mvc_bind_wrap;", "Bind the
'schema.table.column' BAT with access kind:\n\t0 - base table\n\t1 -
inserts\n\t2 - updates" ]
@@ -10928,7 +11003,9 @@ Ready.
[ "sql", "copy_from", "pattern sql.copy_from(t:ptr, sep:str,
rsep:str, ssep:str, ns:str, fname:str, nr:lng, offset:lng, locked:int,
best:int, fwf:str, onclient:int):bat[:any]... ", "mvc_import_table_wrap;",
"Import a table from bstream s with the \n\tgiven tuple and seperators
(sep/rsep)" ]
[ "sql", "copy_rejects", "pattern sql.copy_rejects() (rowid:bat[:lng],
fldid:bat[:int], msg:bat[:str], inp:bat[:str]) ", "COPYrejects;", "" ]
[ "sql", "copy_rejects_clear", "pattern sql.copy_rejects_clear():void
", "COPYrejects_clear;", "" ]
+[ "sql", "count", "pattern sql.count(b:any_1, ignils:bit, s:lng,
e:lng):lng ", "SQLcount;", "return count of groups" ]
[ "sql", "createorderindex", "pattern sql.createorderindex(sch:str,
tbl:str, col:str):void ", "sql_createorderindex;", "Instantiate
the order index on a column" ]
+[ "sql", "cume_dist", "pattern sql.cume_dist(b:any_1, p:bit,
o:bit):dbl ", "SQLcume_dist;", "return the accumulated distribution
of the number of rows per group to the total number of partition rows" ]
[ "sql", "current_time", "pattern sql.current_time():daytime ",
"SQLcurrent_daytime;", "Get the clients current daytime" ]
[ "sql", "current_timestamp", "pattern
sql.current_timestamp():timestamp ", "SQLcurrent_timestamp;", "Get the
clients current timestamp" ]
[ "sql", "db_users", "pattern sql.db_users():bat[:str] ",
"db_users_wrap;", "return table of users with sql scenario" ]
@@ -10968,6 +11045,7 @@ Ready.
[ "sql", "exportResult", "pattern sql.exportResult(s:streams,
res_id:int):void ", "mvc_export_result_wrap;", "Export a result (in
order) to stream s" ]
[ "sql", "export_table", "pattern sql.export_table(fname:str, fmt:str,
colsep:str, recsep:str, qout:str, nullrep:str, onclient:int, tbl:bat[:str],
attr:bat[:str], tpe:bat[:str], len:bat[:int], scale:bat[:int], cols:any...):int
", "mvc_export_row_wrap;", "Prepare a table result set for the COPY INTO
stream" ]
[ "sql", "export_table", "pattern sql.export_table(fname:str, fmt:str,
colsep:str, recsep:str, qout:str, nullrep:str, onclient:int, tbl:bat[:str],
attr:bat[:str], tpe:bat[:str], len:bat[:int], scale:bat[:int],
cols:bat[:any]...):int ", "mvc_export_table_wrap;", "Prepare a table
result set for the COPY INTO stream" ]
+[ "sql", "first_value", "pattern sql.first_value(b:any_1, s:lng,
e:lng):any_1 ", "SQLfirst_value;", "return the first value of
groups" ]
[ "sql", "flush_log", "command sql.flush_log():void ",
"SQLflush_log;", "flush the log now" ]
[ "sql", "getVariable", "pattern sql.getVariable(mvc:int,
varname:str):any_1 ", "getVariable;", "Get the value of a session variable" ]
[ "sql", "getVersion", "command sql.getVersion(clientid:int):lng ",
"mvc_getVersion;", "Return the database version identifier for a client."
]
@@ -10976,16 +11054,45 @@ Ready.
[ "sql", "importTable", "pattern sql.importTable(sname:str, tname:str,
onclient:int, fname:str...):bat[:any]... ", "mvc_bin_import_table_wrap;",
"Import a table from the files (fname)" ]
[ "sql", "include", "pattern sql.include(fname:str):void ",
"SQLinclude;", "Compile and execute a sql statements on the file" ]
[ "sql", "init", "pattern sql.init():void ", "SQLinitEnvironment;",
"Initialize the environment for MAL" ]
+[ "sql", "lag", "pattern sql.lag(b:any_1, l:any_2, d:any_1, p:any_3,
o:any_4):any_1 ", "SQLlag;", "return the value in the previous 'l' row in
the partition or 'd' if non existent" ]
+[ "sql", "lag", "pattern sql.lag(b:any_1, l:any_2, d:bat[:any_1],
p:any_3, o:any_4):any_1 ", "SQLlag;", "return the value in the previous
'l' row in the partition or 'd' if non existent" ]
+[ "sql", "lag", "pattern sql.lag(b:any_1, l:any_2, p:any_3,
o:any_4):any_1 ", "SQLlag;", "return the value in the previous 'l' row
in the partition or NULL if non existent" ]
+[ "sql", "lag", "pattern sql.lag(b:any_1, l:bat[:any_2], d:any_1,
p:any_3, o:any_4):any_1 ", "SQLlag;", "return the value in the previous
'l' row in the partition or 'd' if non existent" ]
+[ "sql", "lag", "pattern sql.lag(b:any_1, l:bat[:any_2], d:bat[:any_1],
p:any_3, o:any_4):any_1 ", "SQLlag;", "return the value in the
previous 'l' row in the partition or 'd' if non existent" ]
+[ "sql", "lag", "pattern sql.lag(b:any_1, l:bat[:any_2], p:any_3,
o:any_4):any_1 ", "SQLlag;", "return the value in the previous 'l' row
in the partition or NULL if non existent" ]
+[ "sql", "lag", "pattern sql.lag(b:any_1, p:any_3, o:any_4):any_1 ",
"SQLlag;", "return the value in the previous row in the partition or NULL
if non existent" ]
+[ "sql", "last_value", "pattern sql.last_value(b:any_1, s:lng,
e:lng):any_1 ", "SQLlast_value;", "return the last value of groups"
]
+[ "sql", "lead", "pattern sql.lead(b:any_1, l:any_2, d:any_1, p:any_3,
o:any_4):any_1 ", "SQLlead;", "return the value in the next 'l' row in the
partition or 'd' if non existent" ]
+[ "sql", "lead", "pattern sql.lead(b:any_1, l:any_2, d:bat[:any_1],
p:any_3, o:any_4):any_1 ", "SQLlead;", "return the value in the next 'l'
row in the partition or 'd' if non existent" ]
+[ "sql", "lead", "pattern sql.lead(b:any_1, l:any_2, p:any_3,
o:any_4):any_1 ", "SQLlead;", "return the value in the next 'l' row in the
partition or NULL if non existent" ]
+[ "sql", "lead", "pattern sql.lead(b:any_1, l:bat[:any_2], d:any_1,
p:any_3, o:any_4):any_1 ", "SQLlead;", "return the value in the next 'l'
row in the partition or 'd' if non existent" ]
+[ "sql", "lead", "pattern sql.lead(b:any_1, l:bat[:any_2],
d:bat[:any_1], p:any_3, o:any_4):any_1 ", "SQLlead;", "return the value
in the next 'l' row in the partition or 'd' if non existent" ]
+[ "sql", "lead", "pattern sql.lead(b:any_1, l:bat[:any_2], p:any_3,
o:any_4):any_1 ", "SQLlead;", "return the value in the next 'l' row in
the partition or NULL if non existent" ]
+[ "sql", "lead", "pattern sql.lead(b:any_1, p:any_3, o:any_4):any_1 ",
"SQLlead;", "return the value in the next row in the partition or NULL if
non existent" ]
[ "sql", "logfile", "pattern sql.logfile(filename:str):void ",
"mvc_logfile;", "Enable/disable saving the sql statement traces" ]
+[ "sql", "max", "pattern sql.max(b:any_1, s:lng, e:lng):any_1 ",
"SQLmax;", "return the maximum of groups" ]
+[ "sql", "min", "pattern sql.min(b:any_1, s:lng, e:lng):any_1 ",
"SQLmin;", "return the minimum of groups" ]
[ "sql", "ms_trunc", "command sql.ms_trunc(v:dbl, r:int):dbl ",
"dbl_trunc_wrap;", "truncate the floating point v to r digits behind the
dot (if r < 0, before the dot)" ]
[ "sql", "ms_trunc", "command sql.ms_trunc(v:flt, r:int):flt ",
"flt_trunc_wrap;", "truncate the floating point v to r digits behind the
dot (if r < 0, before the dot)" ]
[ "sql", "mvc", "pattern sql.mvc():int ", "SQLmvc;", "Get
the multiversion catalog context. \nNeeded for correct statement
dependencies\n(ie sql.update, should be after sql.bind in concurrent
execution)" ]
[ "sql", "next_value", "pattern sql.next_value(sname:str,
sequence:str):lng ", "mvc_next_value;", "return the next value of the
sequence" ]
[ "sql", "not_unique", "command sql.not_unique(b:bat[:oid]):bit ",
"not_unique;", "check if the tail sorted bat b doesn't have unique tail
values" ]
+[ "sql", "nth_value", "pattern sql.nth_value(b:any_1, n:any_2, s:lng,
e:lng):any_1 ", "SQLnth_value;", "return the nth value of each group"
]
+[ "sql", "nth_value", "pattern sql.nth_value(b:any_1, n:bat[:any_2],
s:lng, e:lng):any_1 ", "SQLnth_value;", "return the nth value of each
group" ]
+[ "sql", "ntile", "pattern sql.ntile(b:any_1, n:any_2, p:any_3,
o:any_4):any_2 ", "SQLntile;", "return the groups divided as equally as
possible" ]
+[ "sql", "ntile", "pattern sql.ntile(b:any_1, n:bat[:any_2],
p:any_3, o:any_4):any_2 ", "SQLntile;", "return the groups divided as
equally as possible" ]
[ "sql", "optimizer_updates", "pattern sql.optimizer_updates():void
", "SQLoptimizersUpdate;", "" ]
[ "sql", "optimizers", "command sql.optimizers() (X_0:bat[:str],
X_1:bat[:str], X_2:bat[:str]) ", "getPipeCatalog;", "" ]
[ "sql", "password", "pattern sql.password(user:str):str ",
"db_password_wrap;", "Return password hash of user" ]
+[ "sql", "percent_rank", "pattern sql.percent_rank(b:any_1, p:bit,
o:bit):dbl ", "SQLpercent_rank;", "return the percentage into the total
number of groups for each row" ]
[ "sql", "prelude", "pattern sql.prelude():void ", "SQLprelude;",
"" ]
+[ "sql", "prod", "pattern sql.prod(b:bte, s:lng, e:lng):lng ",
"SQLprod;", "return the product of groups" ]
+[ "sql", "prod", "pattern sql.prod(b:dbl, s:lng, e:lng):dbl ",
"SQLprod;", "return the product of groups" ]
+[ "sql", "prod", "pattern sql.prod(b:flt, s:lng, e:lng):dbl ",
"SQLprod;", "return the product of groups" ]
+[ "sql", "prod", "pattern sql.prod(b:flt, s:lng, e:lng):flt ",
"SQLprod;", "return the product of groups" ]
+[ "sql", "prod", "pattern sql.prod(b:int, s:lng, e:lng):lng ",
"SQLprod;", "return the product of groups" ]
+[ "sql", "prod", "pattern sql.prod(b:lng, s:lng, e:lng):lng ",
"SQLprod;", "return the product of groups" ]
+[ "sql", "prod", "pattern sql.prod(b:sht, s:lng, e:lng):lng ",
"SQLprod;", "return the product of groups" ]
[ "sql", "project", "command sql.project(col:bat[:oid],
l:bat[:oid], r:bat[:oid]):bat[:oid] ", "BATleftproject;", "Last step
of a left outer join, ie project the inner join (l,r) over the left input side
(col)" ]
[ "sql", "projectdelta", "command sql.projectdelta(select:bat[:oid],
col:bat[:any_3], uid:bat[:oid], uval:bat[:any_3]):bat[:any_3] ",
"DELTAproject2;", "Return column bat with delta's applied." ]
[ "sql", "projectdelta", "command sql.projectdelta(select:bat[:oid],
col:bat[:any_3], uid:bat[:oid], uval:bat[:any_3], ins:bat[:any_3]):bat[:any_3]
", "DELTAproject;", "Return column bat with delta's applied." ]
@@ -11031,6 +11138,13 @@ Ready.
[ "sql", "subdelta", "command sql.subdelta(col:bat[:oid],
cand:bat[:oid], uid:bat[:oid], uval:bat[:oid]):bat[:oid] ",
"DELTAsub2;", "Return a single bat of selected delta." ]
[ "sql", "subdelta", "command sql.subdelta(col:bat[:oid],
cand:bat[:oid], uid:bat[:oid], uval:bat[:oid], ins:bat[:oid]):bat[:oid] ",
"DELTAsub;", "Return a single bat of selected delta." ]
[ "sql", "subzero_or_one", "inline function
sql.subzero_or_one(b:bat[:any_1], gp:bat[:oid], gpe:bat[:oid],
no_nil:bit):bat[:any_1];", "", "" ]
+[ "sql", "sum", "pattern sql.sum(b:bte, s:lng, e:lng):lng ",
"SQLsum;", "return the sum of groups" ]
+[ "sql", "sum", "pattern sql.sum(b:dbl, s:lng, e:lng):dbl ",
"SQLsum;", "return the sum of groups" ]
+[ "sql", "sum", "pattern sql.sum(b:flt, s:lng, e:lng):dbl ",
"SQLsum;", "return the sum of groups" ]
+[ "sql", "sum", "pattern sql.sum(b:flt, s:lng, e:lng):flt ",
"SQLsum;", "return the sum of groups" ]
+[ "sql", "sum", "pattern sql.sum(b:int, s:lng, e:lng):lng ",
"SQLsum;", "return the sum of groups" ]
+[ "sql", "sum", "pattern sql.sum(b:lng, s:lng, e:lng):lng ",
"SQLsum;", "return the sum of groups" ]
+[ "sql", "sum", "pattern sql.sum(b:sht, s:lng, e:lng):lng ",
"SQLsum;", "return the sum of groups" ]
[ "sql", "sysmon_pause", "pattern sql.sysmon_pause(tag:int):void ",
"SYSMONpause;", "" ]
[ "sql", "sysmon_pause", "pattern sql.sysmon_pause(tag:lng):void ",
"SYSMONpause;", "" ]
[ "sql", "sysmon_pause", "pattern sql.sysmon_pause(tag:sht):void ",
"SYSMONpause;", "" ]
@@ -11053,6 +11167,18 @@ Ready.
[ "sql", "update_schemas", "pattern sql.update_schemas():void ",
"SYSupdate_schemas;", "Procedure triggered on update of the sys.schemas
table" ]
[ "sql", "update_tables", "pattern sql.update_tables():void ",
"SYSupdate_tables;", "Procedure triggered on update of the sys._tables
table" ]
[ "sql", "vacuum", "pattern sql.vacuum(sch:str, tbl:str):void ",
"SQLvacuum;", "Choose an approach to consolidate the deletions" ]
+[ "sql", "window_bound", "pattern sql.window_bound(b:any_1, unit:int,
bound:int, excl:int, limit:bte):lng ", "SQLwindow_bound;", "computes
window ranges for each row" ]
+[ "sql", "window_bound", "pattern sql.window_bound(b:any_1, unit:int,
bound:int, excl:int, limit:dbl):lng ", "SQLwindow_bound;", "computes
window ranges for each row" ]
+[ "sql", "window_bound", "pattern sql.window_bound(b:any_1, unit:int,
bound:int, excl:int, limit:flt):lng ", "SQLwindow_bound;", "computes
window ranges for each row" ]
+[ "sql", "window_bound", "pattern sql.window_bound(b:any_1, unit:int,
bound:int, excl:int, limit:int):lng ", "SQLwindow_bound;", "computes
window ranges for each row" ]
+[ "sql", "window_bound", "pattern sql.window_bound(b:any_1, unit:int,
bound:int, excl:int, limit:lng):lng ", "SQLwindow_bound;", "computes
window ranges for each row" ]
+[ "sql", "window_bound", "pattern sql.window_bound(b:any_1, unit:int,
bound:int, excl:int, limit:sht):lng ", "SQLwindow_bound;", "computes
window ranges for each row" ]
+[ "sql", "window_bound", "pattern sql.window_bound(p:bit, b:any_1,
unit:int, bound:int, excl:int, limit:bte):lng ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "sql", "window_bound", "pattern sql.window_bound(p:bit, b:any_1,
unit:int, bound:int, excl:int, limit:dbl):lng ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "sql", "window_bound", "pattern sql.window_bound(p:bit, b:any_1,
unit:int, bound:int, excl:int, limit:flt):lng ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "sql", "window_bound", "pattern sql.window_bound(p:bit, b:any_1,
unit:int, bound:int, excl:int, limit:int):lng ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "sql", "window_bound", "pattern sql.window_bound(p:bit, b:any_1,
unit:int, bound:int, excl:int, limit:lng):lng ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "sql", "window_bound", "pattern sql.window_bound(p:bit, b:any_1,
unit:int, bound:int, excl:int, limit:sht):lng ", "SQLwindow_bound;",
"computes window ranges for each row" ]
[ "sql", "zero_or_one", "command sql.zero_or_one(col:bat[:any_1]):any_1
", "zero_or_one;", "if col contains exactly one value return this. Incase
of more raise an exception else return nil" ]
[ "sqlblob", "#fromstr", "command sqlblob.#fromstr():void ",
"SQLBLOBfromstr;", "" ]
[ "sqlblob", "#tostr", "command sqlblob.#tostr():void ",
"SQLBLOBtostr;", "" ]
diff --git a/clients/Tests/MAL-signatures.stable.out.int128
b/clients/Tests/MAL-signatures.stable.out.int128
--- a/clients/Tests/MAL-signatures.stable.out.int128
+++ b/clients/Tests/MAL-signatures.stable.out.int128
@@ -11949,6 +11949,15 @@ Ready.
[ "batrapi", "subeval_aggr", "pattern batrapi.subeval_aggr(fptr:ptr,
expr:str, arg:any...):any... ", "RAPIevalAggr;", "grouped aggregates
through R" ]
[ "batsql", "alpha", "command batsql.alpha(dec:bat[:dbl],
theta:dbl):bat[:dbl] ", "SQLbat_alpha_cst;", "BAT implementation of
astronomy alpha function" ]
[ "batsql", "alpha", "command batsql.alpha(dec:dbl,
theta:bat[:dbl]):bat[:dbl] ", "SQLcst_alpha_bat;", "BAT implementation of
astronomy alpha function" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:bte], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:dbl], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:flt], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:hge], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:int], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:lng], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "avg", "pattern batsql.avg(b:bat[:sht], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLavg;", "return the average of groups" ]
+[ "batsql", "count", "pattern batsql.count(b:bat[:any_1],
ignils:bit, s:bat[:lng], e:bat[:lng]):bat[:lng] ", "SQLcount;", "return
count of groups" ]
+[ "batsql", "cume_dist", "pattern batsql.cume_dist(b:bat[:any_1],
p:any_2, o:any_3):bat[:dbl] ", "SQLcume_dist;", "return the accumulated
distribution of the number of rows per group to the total number of partition
rows" ]
[ "batsql", "dec_round", "command batsql.dec_round(v:bat[:bte],
r:bte):bat[:bte] ", "bte_bat_dec_round_wrap;", "round off the value v
to nearests multiple of r" ]
[ "batsql", "dec_round", "command batsql.dec_round(v:bat[:dbl],
r:dbl):bat[:dbl] ", "dbl_bat_dec_round_wrap;", "round off the value v
to nearests multiple of r" ]
[ "batsql", "dec_round", "command batsql.dec_round(v:bat[:flt],
r:flt):bat[:flt] ", "flt_bat_dec_round_wrap;", "round off the value v
to nearests multiple of r" ]
@@ -11959,8 +11968,43 @@ Ready.
[ "batsql", "dense_rank", "pattern batsql.dense_rank(b:bat[:any_1],
p:any_2, o:any_3):bat[:int] ", "SQLdense_rank;", "return the
densely ranked groups" ]
[ "batsql", "diff", "pattern batsql.diff(b:bat[:any_1]):bat[:bit] ",
"SQLdiff;", "return true if cur != prev row" ]
[ "batsql", "diff", "pattern batsql.diff(p:bat[:bit],
b:bat[:any_1]):bat[:bit] ", "SQLdiff;", "return true if cur != prev row"
]
+[ "batsql", "first_value", "pattern batsql.first_value(b:bat[:any_1],
s:bat[:lng], e:bat[:lng]):bat[:any_1] ", "SQLfirst_value;", "return
the first value of groups" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:any_2, d:any_1,
p:any_3, o:any_4):bat[:any_1] ", "SQLlag;", "return the value in the
previous 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:any_2,
d:bat[:any_1], p:any_3, o:any_4):bat[:any_1] ", "SQLlag;", "return the
value in the previous 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:any_2, p:any_3,
o:any_4):bat[:any_1] ", "SQLlag;", "return the value in the previous
'l' row in the partition or NULL if non existent" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:bat[:any_2],
d:any_1, p:any_3, o:any_4):bat[:any_1] ", "SQLlag;", "return the value
in the previous 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:bat[:any_2],
d:bat[:any_1], p:any_3, o:any_4):bat[:any_1] ", "SQLlag;", "return
the value in the previous 'l' row in the partition or 'd' if non existent"
]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], l:bat[:any_2],
p:any_3, o:any_4):bat[:any_1] ", "SQLlag;", "return the value in the
previous 'l' row in the partition or NULL if non existent" ]
+[ "batsql", "lag", "pattern batsql.lag(b:bat[:any_1], p:any_3,
o:any_4):bat[:any_1] ", "SQLlag;", "return the value in the previous
row in the partition or NULL if non existent" ]
+[ "batsql", "last_value", "pattern batsql.last_value(b:bat[:any_1],
s:bat[:lng], e:bat[:lng]):bat[:any_1] ", "SQLlast_value;", "return
the last value of groups" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:any_2, d:any_1,
p:any_3, o:any_4):bat[:any_1] ", "SQLlead;", "return the value in the next
'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:any_2,
d:bat[:any_1], p:any_3, o:any_4):bat[:any_1] ", "SQLlead;", "return the
value in the next 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:any_2, p:any_3,
o:any_4):bat[:any_1] ", "SQLlead;", "return the value in the next 'l' row
in the partition or NULL if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:bat[:any_2],
d:any_1, p:any_3, o:any_4):bat[:any_1] ", "SQLlead;", "return the value
in the next 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:bat[:any_2],
d:bat[:any_1], p:any_3, o:any_4):bat[:any_1] ", "SQLlead;", "return
the value in the next 'l' row in the partition or 'd' if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], l:bat[:any_2],
p:any_3, o:any_4):bat[:any_1] ", "SQLlead;", "return the value in the
next 'l' row in the partition or NULL if non existent" ]
+[ "batsql", "lead", "pattern batsql.lead(b:bat[:any_1], p:any_3,
o:any_4):bat[:any_1] ", "SQLlead;", "return the value in the next row in
the partition or NULL if non existent" ]
+[ "batsql", "max", "pattern batsql.max(b:bat[:any_1], s:bat[:lng],
e:bat[:lng]):bat[:any_1] ", "SQLmax;", "return the maximum of groups"
]
+[ "batsql", "min", "pattern batsql.min(b:bat[:any_1], s:bat[:lng],
e:bat[:lng]):bat[:any_1] ", "SQLmin;", "return the minimum of groups"
]
[ "batsql", "next_value", "pattern batsql.next_value(sname:bat[:str],
sequence:str):bat[:lng] ", "mvc_bat_next_value;", "return the next value of
the sequence" ]
+[ "batsql", "nth_value", "pattern batsql.nth_value(b:bat[:any_1],
n:any_2, s:bat[:lng], e:bat[:lng]):bat[:any_1] ", "SQLnth_value;",
"return the nth value of each group" ]
+[ "batsql", "nth_value", "pattern batsql.nth_value(b:bat[:any_1],
n:bat[:any_2], s:bat[:lng], e:bat[:lng]):bat[:any_1] ", "SQLnth_value;",
"return the nth value of each group" ]
+[ "batsql", "ntile", "pattern batsql.ntile(b:bat[:any_1], n:any_2,
p:any_3, o:any_4):bat[:any_2] ", "SQLntile;", "return the groups divided as
equally as possible" ]
+[ "batsql", "ntile", "pattern batsql.ntile(b:bat[:any_1],
n:bat[:any_2], p:any_3, o:any_4):bat[:any_2] ", "SQLntile;", "return the
groups divided as equally as possible" ]
[ "batsql", "password", "pattern
batsql.password(user:bat[:str]):bat[:str] ", "db_password_wrap;", "Return
password hash of user" ]
+[ "batsql", "percent_rank", "pattern batsql.percent_rank(b:bat[:any_1],
p:any_2, o:any_3):bat[:dbl] ", "SQLpercent_rank;", "return the
percentage into the total number of groups for each row" ]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:bte], s:bat[:lng],
e:bat[:lng]):bat[:hge] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:bte], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:dbl], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:flt], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:flt], s:bat[:lng],
e:bat[:lng]):bat[:flt] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:hge], s:bat[:lng],
e:bat[:lng]):bat[:hge] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:int], s:bat[:lng],
e:bat[:lng]):bat[:hge] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:int], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:lng], s:bat[:lng],
e:bat[:lng]):bat[:hge] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:lng], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:sht], s:bat[:lng],
e:bat[:lng]):bat[:hge] ", "SQLprod;", "return the product of groups"
]
+[ "batsql", "prod", "pattern batsql.prod(b:bat[:sht], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLprod;", "return the product of groups"
]
[ "batsql", "rank", "pattern batsql.rank(b:bat[:any_1], p:any_2,
o:any_3):bat[:int] ", "SQLrank;", "return the ranked groups" ]
[ "batsql", "round", "command batsql.round(v:bat[:bte], d:int,
s:int, r:bte):bat[:bte] ", "bte_bat_round_wrap;", "round off the decimal
v(d,s) to r digits behind the dot (if r < 0, before the dot)" ]
[ "batsql", "round", "command batsql.round(v:bat[:dbl],
r:bte):bat[:dbl] ", "dbl_bat_round_wrap;", "round off the floating point v to
r digits behind the dot (if r < 0, before the dot)" ]
@@ -11970,6 +12014,46 @@ Ready.
[ "batsql", "round", "command batsql.round(v:bat[:lng], d:int,
s:int, r:bte):bat[:lng] ", "lng_bat_round_wrap;", "round off the decimal
v(d,s) to r digits behind the dot (if r < 0, before the dot)" ]
[ "batsql", "round", "command batsql.round(v:bat[:sht], d:int,
s:int, r:bte):bat[:sht] ", "sht_bat_round_wrap;", "round off the decimal
v(d,s) to r digits behind the dot (if r < 0, before the dot)" ]
[ "batsql", "row_number", "pattern batsql.row_number(b:bat[:any_1],
p:any_2, o:any_3):bat[:int] ", "SQLrow_number;", "return the
row_numer-ed groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:bte], s:bat[:lng],
e:bat[:lng]):bat[:hge] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:bte], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:dbl], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:flt], s:bat[:lng],
e:bat[:lng]):bat[:dbl] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:flt], s:bat[:lng],
e:bat[:lng]):bat[:flt] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:hge], s:bat[:lng],
e:bat[:lng]):bat[:hge] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:int], s:bat[:lng],
e:bat[:lng]):bat[:hge] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:int], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:lng], s:bat[:lng],
e:bat[:lng]):bat[:hge] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:lng], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:sht], s:bat[:lng],
e:bat[:lng]):bat[:hge] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "sum", "pattern batsql.sum(b:bat[:sht], s:bat[:lng],
e:bat[:lng]):bat[:lng] ", "SQLsum;", "return the sum of groups" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:bte]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:dbl]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:flt]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:int]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:lng]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bat[:sht]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:bte):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:dbl):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:flt):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:int):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:lng):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, limit:sht):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, start:bat[:hge]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(b:bat[:any_1],
unit:int, bound:int, excl:int, start:hge):bat[:lng] ", "SQLwindow_bound;",
"computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:bat[:bte]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
+[ "batsql", "window_bound", "pattern batsql.window_bound(p:bat[:bit],
b:bat[:any_1], unit:int, bound:int, excl:int, limit:bat[:dbl]):bat[:lng] ",
"SQLwindow_bound;", "computes window ranges for each row" ]
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
