Changeset: d78c91d71743 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=d78c91d71743
Modified Files:
clients/Tests/MAL-signatures.stable.out
clients/Tests/MAL-signatures.stable.out.int128
clients/Tests/exports.stable.out
sql/backends/monet5/LSST/lsst.c
sql/backends/monet5/LSST/lsst.h
sql/backends/monet5/LSST/lsst.mal
Branch: default
Log Message:
A few more sub*
diffs (truncated from 406 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
@@ -461,8 +461,11 @@ Ready.
[ "alarm", "sleep", "command alarm.sleep(secs:int):void ",
"ALARMsleep;", "Sleep a few seconds" ]
[ "alarm", "time", "command alarm.time():int ", "ALARMtime;", "Return
time in milliseconds." ]
[ "alarm", "usec", "command alarm.usec():lng ", "ALARMusec;", "Return
time in microseconds." ]
+[ "algebra", "antijoin", "function
algebra.antijoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]);", "", "" ]
+[ "algebra", "bandjoin", "command
algebra.bandjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],c1:any_1,c2:any_1,li:bit,hi:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGbandjoin;", "Band join: values in l and
r match if r - c1 <[=] l <[=] r + c2" ]
[ "algebra", "copy", "command algebra.copy(b:bat[:any_1]):bat[:any_1] ",
"ALGcopy;", "Returns physical copy of a BAT." ]
[ "algebra", "crossproduct", "command
algebra.crossproduct(left:bat[:any_1],right:bat[:any_2])
(l:bat[:oid],r:bat[:oid]) ", "ALGcrossproduct2;", "Returns 2 columns with
all BUNs, consisting of the head-oids\n\t from 'left' and 'right' for which
there are BUNs in 'left'\n\t and 'right' with equal tails" ]
+[ "algebra", "difference", "command
algebra.difference(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng):bat[:oid]
", "ALGdifference;", "Difference of l and r with candidate lists" ]
[ "algebra", "exist", "command
algebra.exist(b:bat[:any_1],val:any_1):bit ", "ALGexist;", "Returns whether
'val' occurs in b." ]
[ "algebra", "fetch", "command
algebra.fetch(b:bat[:any_1],x:oid):any_1 ", "ALGfetchoid;", "Returns the
value of the BUN at x-th position with 0 <= x < b.count" ]
[ "algebra", "find", "command algebra.find(b:bat[:any_1],t:any_1):oid ",
"ALGfind;", "Returns the index position of a value. If no such BUN exists
return OID-nil." ]
@@ -475,42 +478,39 @@ Ready.
[ "algebra", "groupby", "command
algebra.groupby(gids:bat[:oid],cnts:bat[:lng]):bat[:oid] ", "ALGgroupby;",
"Produces a new BAT with groups identified by the head column. The result
contains tail times the head value, ie the tail contains the result group
sizes." ]
[ "algebra", "ilike", "command algebra.ilike(s:str,pat:str):bit ",
"PCREilike2;", "" ]
[ "algebra", "ilike", "command
algebra.ilike(s:str,pat:str,esc:str):bit ", "PCREilike3;", "" ]
+[ "algebra", "ilikejoin", "command
algebra.ilikejoin(l:bat[:str],r:bat[:str],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ILIKEjoin1;", "" ]
+[ "algebra", "ilikejoin", "command
algebra.ilikejoin(l:bat[:str],r:bat[:str],esc:str,sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ILIKEjoin;", "Join the string bat L
with the pattern bat R\nwith optional candidate lists SL and SR using pattern
escape string ESC\nand doing a case insensitive match.\nThe result is two
aligned bats with oids of matching rows." ]
[ "algebra", "ilikeselect", "command
algebra.ilikeselect(b:bat[:str],cand:bat[:oid],pat:str,esc:str,anti:bit):bat[:oid]
", "PCRElikeselect1;", "" ]
[ "algebra", "ilikeselect", "command
algebra.ilikeselect(b:bat[:str],cand:bat[:oid],pat:str,anti:bit):bat[:oid] ",
"PCRElikeselect4;", "" ]
-[ "algebra", "ilikesubjoin", "command
algebra.ilikesubjoin(l:bat[:str],r:bat[:str],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ILIKEsubjoin1;", "" ]
-[ "algebra", "ilikesubjoin", "command
algebra.ilikesubjoin(l:bat[:str],r:bat[:str],esc:str,sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ILIKEsubjoin;", "Join the string bat
L with the pattern bat R\nwith optional candidate lists SL and SR using pattern
escape string ESC\nand doing a case insensitive match.\nThe result is two
aligned bats with oids of matching rows." ]
+[ "algebra", "intersect", "command
algebra.intersect(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng):bat[:oid]
", "ALGintersect;", "Intersection of l and r with candidate lists
(i.e. half of semi-join)" ]
+[ "algebra", "join", "command
algebra.join(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGjoin;", "Join" ]
+[ "algebra", "leftjoin", "command
algebra.leftjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGleftjoin;", "Left join with candidate
lists" ]
[ "algebra", "like", "command algebra.like(s:str,pat:str):bit ",
"PCRElike2;", "" ]
[ "algebra", "like", "command algebra.like(s:str,pat:str,esc:str):bit ",
"PCRElike3;", "" ]
+[ "algebra", "likejoin", "command
algebra.likejoin(l:bat[:str],r:bat[:str],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "LIKEjoin1;", "" ]
+[ "algebra", "likejoin", "command
algebra.likejoin(l:bat[:str],r:bat[:str],esc:str,sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "LIKEjoin;", "Join the string bat L
with the pattern bat R\nwith optional candidate lists SL and SR using pattern
escape string ESC\nand doing a case sensitive match.\nThe result is two aligned
bats with oids of matching rows." ]
[ "algebra", "likeselect", "command
algebra.likeselect(b:bat[:str],s:bat[:oid],pat:str,esc:str,caseignore:bit,anti:bit):bat[:oid]
", "PCRElikeselect2;", "Select all head values of the first input
BAT for which the\n\ttail value is \"like\" the given (SQL-style) pattern and
for\n\twhich the head value occurs in the tail of the second
input\n\tBAT.\n\tInput is a dense-headed BAT, output is a dense-headed BAT with
in\n\tthe tail the head value of the input BAT for which the\n\trelationship
holds. The output BAT is sorted on the tail value." ]
[ "algebra", "likeselect", "command
algebra.likeselect(b:bat[:str],cand:bat[:oid],pat:str,esc:str,anti:bit):bat[:oid]
", "PCRElikeselect3;", "" ]
[ "algebra", "likeselect", "command
algebra.likeselect(b:bat[:str],cand:bat[:oid],pat:str,anti:bit):bat[:oid] ",
"PCRElikeselect5;", "" ]
-[ "algebra", "likesubjoin", "command
algebra.likesubjoin(l:bat[:str],r:bat[:str],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "LIKEsubjoin1;", "" ]
-[ "algebra", "likesubjoin", "command
algebra.likesubjoin(l:bat[:str],r:bat[:str],esc:str,sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "LIKEsubjoin;", "Join the string bat L with
the pattern bat R\nwith optional candidate lists SL and SR using pattern escape
string ESC\nand doing a case sensitive match.\nThe result is two aligned bats
with oids of matching rows." ]
[ "algebra", "not_ilike", "command algebra.not_ilike(s:str,pat:str):bit
", "PCREnotilike2;", "" ]
[ "algebra", "not_ilike", "command
algebra.not_ilike(s:str,pat:str,esc:str):bit ", "PCREnotilike3;",
"" ]
[ "algebra", "not_like", "command algebra.not_like(s:str,pat:str):bit ",
"PCREnotlike2;", "" ]
[ "algebra", "not_like", "command
algebra.not_like(s:str,pat:str,esc:str):bit ", "PCREnotlike3;", "" ]
[ "algebra", "orderidx", "command
algebra.orderidx(bv:bat[:any_1],stable:bit):bat[:any_1] ", "OIDXorderidx;",
"Create an order index" ]
+[ "algebra", "outerjoin", "command
algebra.outerjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGouterjoin;", "Left outer join with
candidate lists" ]
[ "algebra", "project", "pattern
algebra.project(b:bat[:any_1],v:any_3):bat[:any_3] ", "ALGprojecttail;",
"Fill the tail with a constant" ]
[ "algebra", "projection", "command
algebra.projection(left:bat[:oid],right:bat[:any_3]):bat[:any_3] ",
"ALGprojection;", "Project left input onto right input." ]
[ "algebra", "projectionpath", "pattern
algebra.projectionpath(l:bat[:any]...):bat[:any] ", "ALGprojectionpath;",
"Routine to handle join paths. The type analysis is rather tricky." ]
+[ "algebra", "rangejoin", "command
algebra.rangejoin(l:bat[:any_1],r1:bat[:any_1],r2:bat[:any_1],sl:bat[:oid],sr:bat[:oid],li:bit,hi:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGrangejoin;", "Range join: values
in l and r1/r2 match if r1 <[=] l <[=] r2" ]
[ "algebra", "reuse", "command
algebra.reuse(b:bat[:any_1]):bat[:any_1] ", "ALGreuse;", "Reuse a
temporary BAT if you can. Otherwise,\n\tallocate enough storage to accept
result of an\n \toperation (not involving the heap)" ]
[ "algebra", "select", "command
algebra.select(b:bat[:any_1],low:any_1,high:any_1,li:bit,hi:bit,anti:bit):bat[:oid]
", "ALGselect1;", "Select all head values for which the tail value is in
range.\n\tInput is a dense-headed BAT, output is a dense-headed BAT with
in\n\tthe tail the head value of the input BAT for which the tail value\n\tis
between the values low and high (inclusive if li respectively\n\thi is set).
The output BAT is sorted on the tail value. If low\n\tor high is nil, the
boundary is not considered (effectively - and\n\t+ infinity). If anti is set,
the result is the complement. Nil\n\tvalues in the tail are never matched,
unless low=nil, high=nil,\n\tli=1, hi=1, anti=0. All non-nil values are
returned if low=nil,\n\thigh=nil, and li, hi are not both 1, or anti=1.\n\tNote
that the output is suitable as second input for the other\n\tversion of this
function." ]
[ "algebra", "select", "command
algebra.select(b:bat[:any_1],s:bat[:oid],low:any_1,high:any_1,li:bit,hi:bit,anti:bit):bat[:oid]
", "ALGselect2;", "Select all head values of the first input BAT for
which the tail value\n\tis in range and for which the head value occurs in the
tail of the\n\tsecond input BAT.\n\tThe first input is a dense-headed BAT, the
second input is a\n\tdense-headed BAT with sorted tail, output is a
dense-headed BAT\n\twith in the tail the head value of the input BAT for which
the\n\ttail value is between the values low and high (inclusive if
li\n\trespectively hi is set). The output BAT is sorted on the tail\n\tvalue.
If low or high is nil, the boundary is not considered\n\t(effectively - and +
infinity). If anti is set, the result is the\n\tcomplement. Nil values in the
tail are never matched, unless\n\tlow=nil, high=nil, li=1, hi=1, anti=0. All
non-nil values are\n\treturned if low=nil, high=nil, and li, hi are not both 1,
or anti=1.\n\tNote that the outp
ut is suitable as second input for this\n\tfunction." ]
[ "algebra", "selectNotNil", "command
algebra.selectNotNil(b:bat[:any_2]):bat[:any_2] ", "ALGselectNotNil;",
"Select all not-nil values" ]
+[ "algebra", "semijoin", "command
algebra.semijoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsemijoin;", "Semi join with candidate
lists" ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:lng,y:lng):bat[:any_1] ", "ALGslice;",
"Return the slice with the BUNs at position x till y." ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:int,y:int):bat[:any_1] ", "ALGslice_int;",
"Return the slice with the BUNs at position x till y." ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:lng,y:lng):bat[:any_1] ", "ALGslice_lng;",
"Return the slice with the BUNs at position x till y." ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:oid,y:oid):bat[:any_1] ", "ALGslice_oid;",
"Return the slice based on head oid x till y (exclusive)." ]
-[ "algebra", "subantijoin", "function
algebra.subantijoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]);", "", "" ]
-[ "algebra", "subbandjoin", "command
algebra.subbandjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],c1:any_1,c2:any_1,li:bit,hi:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubbandjoin;", "Band join:
values in l and r match if r - c1 <[=] l <[=] r + c2" ]
-[ "algebra", "subdiff", "command
algebra.subdiff(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng):bat[:oid]
", "ALGsubdiff;", "Difference of l and r with candidate lists" ]
-[ "algebra", "subinter", "command
algebra.subinter(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng):bat[:oid]
", "ALGsubinter;", "Intersection of l and r with candidate lists (i.e.
half of semi-join)" ]
-[ "algebra", "subjoin", "command
algebra.subjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubjoin;", "Join" ]
-[ "algebra", "subleftjoin", "command
algebra.subleftjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubleftjoin;", "Left join with
candidate lists" ]
-[ "algebra", "subouterjoin", "command
algebra.subouterjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubouterjoin;", "Left outer join
with candidate lists" ]
-[ "algebra", "subrangejoin", "command
algebra.subrangejoin(l:bat[:any_1],r1:bat[:any_1],r2:bat[:any_1],sl:bat[:oid],sr:bat[:oid],li:bit,hi:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubrangejoin;", "Range join:
values in l and r1/r2 match if r1 <[=] l <[=] r2" ]
-[ "algebra", "subsemijoin", "command
algebra.subsemijoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubsemijoin;", "Semi join with
candidate lists" ]
[ "algebra", "subslice", "command
algebra.subslice(b:bat[:any_1],x:lng,y:lng):bat[:oid] ",
"ALGsubslice_lng;", "Return the oids of the slice with the BUNs at position
x till y." ]
[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],reverse:bit,stable:bit):bat[:any_1] ",
"ALGsubsort11;", "Returns a copy of the BAT sorted on tail values.\n
The input and output are (must be) dense headed.\n The order is
descending if the reverse bit is set.\n\t\t This is a stable sort if the stable
bit is set." ]
[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsubsort12;", "Returns a
copy of the BAT sorted on tail values and a BAT that\n specifies how
the input was reordered.\n The input and output are (must be) dense
headed.\n The order is descending if the reverse bit is set.\n\t\t This
is a stable sort if the stable bit is set." ]
@@ -521,11 +521,11 @@ Ready.
[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit):bat[:any_1]
", "ALGsubsort31;", "Returns a copy of the BAT sorted on tail
values.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsubsort32;", "Returns a
copy of the BAT sorted on tail values and a BAT that\n specifies how
the input was reordered.\n The input and output are (must be) dense
headed.\n The order is descending if the reverse bit is set.\n\t\t This
is a stable sort if the stable bit is set." ]
[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsubsort33;",
"Returns a copy of the BAT sorted on tail values, a BAT that specifies\n
how the input was reordered, and a BAT with group information.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
-[ "algebra", "subthetajoin", "command
algebra.subthetajoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],op:int,nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubthetajoin;", "Theta join
with candidate lists" ]
-[ "algebra", "subunique", "command
algebra.subunique(b:bat[:any_1]):bat[:oid] ", "ALGsubunique1;", "Select
all unique values from the tail of the input.\n\tInput is a dense-headed BAT,
output is a dense-headed BAT with\n\tin the tail the head value of the input
BAT that was selected.\n\tThe output BAT is sorted on the tail value." ]
-[ "algebra", "subunique", "command
algebra.subunique(b:bat[:any_1],s:bat[:oid]):bat[:oid] ",
"ALGsubunique2;", "Select all unique values from the tail of the first
input.\n\tInput is a dense-headed BAT, the second input is a\n\tdense-headed
BAT with sorted tail, output is a dense-headed\n\tBAT with in the tail the head
value of the input BAT that was\n\tselected. The output BAT is sorted on the
tail value. The\n\tsecond input BAT is a list of candidates." ]
+[ "algebra", "thetajoin", "command
algebra.thetajoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],op:int,nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGthetajoin;", "Theta join with
candidate lists" ]
[ "algebra", "thetaselect", "command
algebra.thetaselect(b:bat[:any_1],val:any_1,op:str):bat[:oid] ",
"ALGthetaselect1;", "Select all head values for which the tail value obeys
the relation\n\tvalue OP VAL.\n\tInput is a dense-headed BAT, output is a
dense-headed BAT with in\n\tthe tail the head value of the input BAT for which
the\n\trelationship holds. The output BAT is sorted on the tail value."
]
[ "algebra", "thetaselect", "command
algebra.thetaselect(b:bat[:any_1],s:bat[:oid],val:any_1,op:str):bat[:oid] ",
"ALGthetaselect2;", "Select all head values of the first input BAT for
which the tail value\n\tobeys the relation value OP VAL and for which the head
value occurs in\n\tthe tail of the second input BAT.\n\tInput is a dense-headed
BAT, output is a dense-headed BAT with in\n\tthe tail the head value of the
input BAT for which the\n\trelationship holds. The output BAT is sorted on the
tail value." ]
+[ "algebra", "unique", "command
algebra.unique(b:bat[:any_1]):bat[:oid] ", "ALGunique1;", "Select all
unique values from the tail of the input.\n\tInput is a dense-headed BAT,
output is a dense-headed BAT with\n\tin the tail the head value of the input
BAT that was selected.\n\tThe output BAT is sorted on the tail value." ]
+[ "algebra", "unique", "command
algebra.unique(b:bat[:any_1],s:bat[:oid]):bat[:oid] ", "ALGunique2;", "Select
all unique values from the tail of the first input.\n\tInput is a dense-headed
BAT, the second input is a\n\tdense-headed BAT with sorted tail, output is a
dense-headed\n\tBAT with in the tail the head value of the input BAT that
was\n\tselected. The output BAT is sorted on the tail value. The\n\tsecond
input BAT is a list of candidates." ]
[ "bam", "bam_drop_file", "pattern
bam.bam_drop_file(file_id:lng,dbschema:sht):void ", "bam_drop_file;",
"Drop alignment tables and header data for the bam file with the given file_id"
]
[ "bam", "bam_export", "pattern bam.bam_export(output_path:str):void
", "bam_exportf;", "Export results in the bam.export table to a BAM
file" ]
[ "bam", "bam_flag", "command bam.bam_flag(flag:sht,name:str):bit ",
"bam_flag;", "Get bam flag by name." ]
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
@@ -565,8 +565,11 @@ Ready.
[ "alarm", "sleep", "command alarm.sleep(secs:int):void ",
"ALARMsleep;", "Sleep a few seconds" ]
[ "alarm", "time", "command alarm.time():int ", "ALARMtime;", "Return
time in milliseconds." ]
[ "alarm", "usec", "command alarm.usec():lng ", "ALARMusec;", "Return
time in microseconds." ]
+[ "algebra", "antijoin", "function
algebra.antijoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]);", "", "" ]
+[ "algebra", "bandjoin", "command
algebra.bandjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],c1:any_1,c2:any_1,li:bit,hi:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGbandjoin;", "Band join: values in l and
r match if r - c1 <[=] l <[=] r + c2" ]
[ "algebra", "copy", "command algebra.copy(b:bat[:any_1]):bat[:any_1] ",
"ALGcopy;", "Returns physical copy of a BAT." ]
[ "algebra", "crossproduct", "command
algebra.crossproduct(left:bat[:any_1],right:bat[:any_2])
(l:bat[:oid],r:bat[:oid]) ", "ALGcrossproduct2;", "Returns 2 columns with
all BUNs, consisting of the head-oids\n\t from 'left' and 'right' for which
there are BUNs in 'left'\n\t and 'right' with equal tails" ]
+[ "algebra", "difference", "command
algebra.difference(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng):bat[:oid]
", "ALGdifference;", "Difference of l and r with candidate lists" ]
[ "algebra", "exist", "command
algebra.exist(b:bat[:any_1],val:any_1):bit ", "ALGexist;", "Returns whether
'val' occurs in b." ]
[ "algebra", "fetch", "command
algebra.fetch(b:bat[:any_1],x:oid):any_1 ", "ALGfetchoid;", "Returns the
value of the BUN at x-th position with 0 <= x < b.count" ]
[ "algebra", "find", "command algebra.find(b:bat[:any_1],t:any_1):oid ",
"ALGfind;", "Returns the index position of a value. If no such BUN exists
return OID-nil." ]
@@ -579,42 +582,39 @@ Ready.
[ "algebra", "groupby", "command
algebra.groupby(gids:bat[:oid],cnts:bat[:lng]):bat[:oid] ", "ALGgroupby;",
"Produces a new BAT with groups identified by the head column. The result
contains tail times the head value, ie the tail contains the result group
sizes." ]
[ "algebra", "ilike", "command algebra.ilike(s:str,pat:str):bit ",
"PCREilike2;", "" ]
[ "algebra", "ilike", "command
algebra.ilike(s:str,pat:str,esc:str):bit ", "PCREilike3;", "" ]
+[ "algebra", "ilikejoin", "command
algebra.ilikejoin(l:bat[:str],r:bat[:str],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ILIKEjoin1;", "" ]
+[ "algebra", "ilikejoin", "command
algebra.ilikejoin(l:bat[:str],r:bat[:str],esc:str,sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ILIKEjoin;", "Join the string bat L
with the pattern bat R\nwith optional candidate lists SL and SR using pattern
escape string ESC\nand doing a case insensitive match.\nThe result is two
aligned bats with oids of matching rows." ]
[ "algebra", "ilikeselect", "command
algebra.ilikeselect(b:bat[:str],cand:bat[:oid],pat:str,esc:str,anti:bit):bat[:oid]
", "PCRElikeselect1;", "" ]
[ "algebra", "ilikeselect", "command
algebra.ilikeselect(b:bat[:str],cand:bat[:oid],pat:str,anti:bit):bat[:oid] ",
"PCRElikeselect4;", "" ]
-[ "algebra", "ilikesubjoin", "command
algebra.ilikesubjoin(l:bat[:str],r:bat[:str],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ILIKEsubjoin1;", "" ]
-[ "algebra", "ilikesubjoin", "command
algebra.ilikesubjoin(l:bat[:str],r:bat[:str],esc:str,sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ILIKEsubjoin;", "Join the string bat
L with the pattern bat R\nwith optional candidate lists SL and SR using pattern
escape string ESC\nand doing a case insensitive match.\nThe result is two
aligned bats with oids of matching rows." ]
+[ "algebra", "intersect", "command
algebra.intersect(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng):bat[:oid]
", "ALGintersect;", "Intersection of l and r with candidate lists
(i.e. half of semi-join)" ]
+[ "algebra", "join", "command
algebra.join(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGjoin;", "Join" ]
+[ "algebra", "leftjoin", "command
algebra.leftjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGleftjoin;", "Left join with candidate
lists" ]
[ "algebra", "like", "command algebra.like(s:str,pat:str):bit ",
"PCRElike2;", "" ]
[ "algebra", "like", "command algebra.like(s:str,pat:str,esc:str):bit ",
"PCRElike3;", "" ]
+[ "algebra", "likejoin", "command
algebra.likejoin(l:bat[:str],r:bat[:str],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "LIKEjoin1;", "" ]
+[ "algebra", "likejoin", "command
algebra.likejoin(l:bat[:str],r:bat[:str],esc:str,sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "LIKEjoin;", "Join the string bat L
with the pattern bat R\nwith optional candidate lists SL and SR using pattern
escape string ESC\nand doing a case sensitive match.\nThe result is two aligned
bats with oids of matching rows." ]
[ "algebra", "likeselect", "command
algebra.likeselect(b:bat[:str],s:bat[:oid],pat:str,esc:str,caseignore:bit,anti:bit):bat[:oid]
", "PCRElikeselect2;", "Select all head values of the first input
BAT for which the\n\ttail value is \"like\" the given (SQL-style) pattern and
for\n\twhich the head value occurs in the tail of the second
input\n\tBAT.\n\tInput is a dense-headed BAT, output is a dense-headed BAT with
in\n\tthe tail the head value of the input BAT for which the\n\trelationship
holds. The output BAT is sorted on the tail value." ]
[ "algebra", "likeselect", "command
algebra.likeselect(b:bat[:str],cand:bat[:oid],pat:str,esc:str,anti:bit):bat[:oid]
", "PCRElikeselect3;", "" ]
[ "algebra", "likeselect", "command
algebra.likeselect(b:bat[:str],cand:bat[:oid],pat:str,anti:bit):bat[:oid] ",
"PCRElikeselect5;", "" ]
-[ "algebra", "likesubjoin", "command
algebra.likesubjoin(l:bat[:str],r:bat[:str],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "LIKEsubjoin1;", "" ]
-[ "algebra", "likesubjoin", "command
algebra.likesubjoin(l:bat[:str],r:bat[:str],esc:str,sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "LIKEsubjoin;", "Join the string bat L with
the pattern bat R\nwith optional candidate lists SL and SR using pattern escape
string ESC\nand doing a case sensitive match.\nThe result is two aligned bats
with oids of matching rows." ]
[ "algebra", "not_ilike", "command algebra.not_ilike(s:str,pat:str):bit
", "PCREnotilike2;", "" ]
[ "algebra", "not_ilike", "command
algebra.not_ilike(s:str,pat:str,esc:str):bit ", "PCREnotilike3;",
"" ]
[ "algebra", "not_like", "command algebra.not_like(s:str,pat:str):bit ",
"PCREnotlike2;", "" ]
[ "algebra", "not_like", "command
algebra.not_like(s:str,pat:str,esc:str):bit ", "PCREnotlike3;", "" ]
[ "algebra", "orderidx", "command
algebra.orderidx(bv:bat[:any_1],stable:bit):bat[:any_1] ", "OIDXorderidx;",
"Create an order index" ]
+[ "algebra", "outerjoin", "command
algebra.outerjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGouterjoin;", "Left outer join with
candidate lists" ]
[ "algebra", "project", "pattern
algebra.project(b:bat[:any_1],v:any_3):bat[:any_3] ", "ALGprojecttail;",
"Fill the tail with a constant" ]
[ "algebra", "projection", "command
algebra.projection(left:bat[:oid],right:bat[:any_3]):bat[:any_3] ",
"ALGprojection;", "Project left input onto right input." ]
[ "algebra", "projectionpath", "pattern
algebra.projectionpath(l:bat[:any]...):bat[:any] ", "ALGprojectionpath;",
"Routine to handle join paths. The type analysis is rather tricky." ]
+[ "algebra", "rangejoin", "command
algebra.rangejoin(l:bat[:any_1],r1:bat[:any_1],r2:bat[:any_1],sl:bat[:oid],sr:bat[:oid],li:bit,hi:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGrangejoin;", "Range join: values
in l and r1/r2 match if r1 <[=] l <[=] r2" ]
[ "algebra", "reuse", "command
algebra.reuse(b:bat[:any_1]):bat[:any_1] ", "ALGreuse;", "Reuse a
temporary BAT if you can. Otherwise,\n\tallocate enough storage to accept
result of an\n \toperation (not involving the heap)" ]
[ "algebra", "select", "command
algebra.select(b:bat[:any_1],low:any_1,high:any_1,li:bit,hi:bit,anti:bit):bat[:oid]
", "ALGselect1;", "Select all head values for which the tail value is in
range.\n\tInput is a dense-headed BAT, output is a dense-headed BAT with
in\n\tthe tail the head value of the input BAT for which the tail value\n\tis
between the values low and high (inclusive if li respectively\n\thi is set).
The output BAT is sorted on the tail value. If low\n\tor high is nil, the
boundary is not considered (effectively - and\n\t+ infinity). If anti is set,
the result is the complement. Nil\n\tvalues in the tail are never matched,
unless low=nil, high=nil,\n\tli=1, hi=1, anti=0. All non-nil values are
returned if low=nil,\n\thigh=nil, and li, hi are not both 1, or anti=1.\n\tNote
that the output is suitable as second input for the other\n\tversion of this
function." ]
[ "algebra", "select", "command
algebra.select(b:bat[:any_1],s:bat[:oid],low:any_1,high:any_1,li:bit,hi:bit,anti:bit):bat[:oid]
", "ALGselect2;", "Select all head values of the first input BAT for
which the tail value\n\tis in range and for which the head value occurs in the
tail of the\n\tsecond input BAT.\n\tThe first input is a dense-headed BAT, the
second input is a\n\tdense-headed BAT with sorted tail, output is a
dense-headed BAT\n\twith in the tail the head value of the input BAT for which
the\n\ttail value is between the values low and high (inclusive if
li\n\trespectively hi is set). The output BAT is sorted on the tail\n\tvalue.
If low or high is nil, the boundary is not considered\n\t(effectively - and +
infinity). If anti is set, the result is the\n\tcomplement. Nil values in the
tail are never matched, unless\n\tlow=nil, high=nil, li=1, hi=1, anti=0. All
non-nil values are\n\treturned if low=nil, high=nil, and li, hi are not both 1,
or anti=1.\n\tNote that the outp
ut is suitable as second input for this\n\tfunction." ]
[ "algebra", "selectNotNil", "command
algebra.selectNotNil(b:bat[:any_2]):bat[:any_2] ", "ALGselectNotNil;",
"Select all not-nil values" ]
+[ "algebra", "semijoin", "command
algebra.semijoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsemijoin;", "Semi join with candidate
lists" ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:lng,y:lng):bat[:any_1] ", "ALGslice;",
"Return the slice with the BUNs at position x till y." ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:int,y:int):bat[:any_1] ", "ALGslice_int;",
"Return the slice with the BUNs at position x till y." ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:lng,y:lng):bat[:any_1] ", "ALGslice_lng;",
"Return the slice with the BUNs at position x till y." ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:oid,y:oid):bat[:any_1] ", "ALGslice_oid;",
"Return the slice based on head oid x till y (exclusive)." ]
-[ "algebra", "subantijoin", "function
algebra.subantijoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]);", "", "" ]
-[ "algebra", "subbandjoin", "command
algebra.subbandjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],c1:any_1,c2:any_1,li:bit,hi:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubbandjoin;", "Band join:
values in l and r match if r - c1 <[=] l <[=] r + c2" ]
-[ "algebra", "subdiff", "command
algebra.subdiff(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng):bat[:oid]
", "ALGsubdiff;", "Difference of l and r with candidate lists" ]
-[ "algebra", "subinter", "command
algebra.subinter(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng):bat[:oid]
", "ALGsubinter;", "Intersection of l and r with candidate lists (i.e.
half of semi-join)" ]
-[ "algebra", "subjoin", "command
algebra.subjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubjoin;", "Join" ]
-[ "algebra", "subleftjoin", "command
algebra.subleftjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubleftjoin;", "Left join with
candidate lists" ]
-[ "algebra", "subouterjoin", "command
algebra.subouterjoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubouterjoin;", "Left outer join
with candidate lists" ]
-[ "algebra", "subrangejoin", "command
algebra.subrangejoin(l:bat[:any_1],r1:bat[:any_1],r2:bat[:any_1],sl:bat[:oid],sr:bat[:oid],li:bit,hi:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubrangejoin;", "Range join:
values in l and r1/r2 match if r1 <[=] l <[=] r2" ]
-[ "algebra", "subsemijoin", "command
algebra.subsemijoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubsemijoin;", "Semi join with
candidate lists" ]
[ "algebra", "subslice", "command
algebra.subslice(b:bat[:any_1],x:lng,y:lng):bat[:oid] ",
"ALGsubslice_lng;", "Return the oids of the slice with the BUNs at position
x till y." ]
[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],reverse:bit,stable:bit):bat[:any_1] ",
"ALGsubsort11;", "Returns a copy of the BAT sorted on tail values.\n
The input and output are (must be) dense headed.\n The order is
descending if the reverse bit is set.\n\t\t This is a stable sort if the stable
bit is set." ]
[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsubsort12;", "Returns a
copy of the BAT sorted on tail values and a BAT that\n specifies how
the input was reordered.\n The input and output are (must be) dense
headed.\n The order is descending if the reverse bit is set.\n\t\t This
is a stable sort if the stable bit is set." ]
@@ -625,11 +625,11 @@ Ready.
[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit):bat[:any_1]
", "ALGsubsort31;", "Returns a copy of the BAT sorted on tail
values.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsubsort32;", "Returns a
copy of the BAT sorted on tail values and a BAT that\n specifies how
the input was reordered.\n The input and output are (must be) dense
headed.\n The order is descending if the reverse bit is set.\n\t\t This
is a stable sort if the stable bit is set." ]
[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsubsort33;",
"Returns a copy of the BAT sorted on tail values, a BAT that specifies\n
how the input was reordered, and a BAT with group information.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
-[ "algebra", "subthetajoin", "command
algebra.subthetajoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],op:int,nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGsubthetajoin;", "Theta join
with candidate lists" ]
-[ "algebra", "subunique", "command
algebra.subunique(b:bat[:any_1]):bat[:oid] ", "ALGsubunique1;", "Select
all unique values from the tail of the input.\n\tInput is a dense-headed BAT,
output is a dense-headed BAT with\n\tin the tail the head value of the input
BAT that was selected.\n\tThe output BAT is sorted on the tail value." ]
-[ "algebra", "subunique", "command
algebra.subunique(b:bat[:any_1],s:bat[:oid]):bat[:oid] ",
"ALGsubunique2;", "Select all unique values from the tail of the first
input.\n\tInput is a dense-headed BAT, the second input is a\n\tdense-headed
BAT with sorted tail, output is a dense-headed\n\tBAT with in the tail the head
value of the input BAT that was\n\tselected. The output BAT is sorted on the
tail value. The\n\tsecond input BAT is a list of candidates." ]
+[ "algebra", "thetajoin", "command
algebra.thetajoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],op:int,nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGthetajoin;", "Theta join with
candidate lists" ]
[ "algebra", "thetaselect", "command
algebra.thetaselect(b:bat[:any_1],val:any_1,op:str):bat[:oid] ",
"ALGthetaselect1;", "Select all head values for which the tail value obeys
the relation\n\tvalue OP VAL.\n\tInput is a dense-headed BAT, output is a
dense-headed BAT with in\n\tthe tail the head value of the input BAT for which
the\n\trelationship holds. The output BAT is sorted on the tail value."
]
[ "algebra", "thetaselect", "command
algebra.thetaselect(b:bat[:any_1],s:bat[:oid],val:any_1,op:str):bat[:oid] ",
"ALGthetaselect2;", "Select all head values of the first input BAT for
which the tail value\n\tobeys the relation value OP VAL and for which the head
value occurs in\n\tthe tail of the second input BAT.\n\tInput is a dense-headed
BAT, output is a dense-headed BAT with in\n\tthe tail the head value of the
input BAT for which the\n\trelationship holds. The output BAT is sorted on the
tail value." ]
+[ "algebra", "unique", "command
algebra.unique(b:bat[:any_1]):bat[:oid] ", "ALGunique1;", "Select all
unique values from the tail of the input.\n\tInput is a dense-headed BAT,
output is a dense-headed BAT with\n\tin the tail the head value of the input
BAT that was selected.\n\tThe output BAT is sorted on the tail value." ]
+[ "algebra", "unique", "command
algebra.unique(b:bat[:any_1],s:bat[:oid]):bat[:oid] ", "ALGunique2;", "Select
all unique values from the tail of the first input.\n\tInput is a dense-headed
BAT, the second input is a\n\tdense-headed BAT with sorted tail, output is a
dense-headed\n\tBAT with in the tail the head value of the input BAT that
was\n\tselected. The output BAT is sorted on the tail value. The\n\tsecond
input BAT is a list of candidates." ]
[ "bam", "bam_drop_file", "pattern
bam.bam_drop_file(file_id:lng,dbschema:sht):void ", "bam_drop_file;",
"Drop alignment tables and header data for the bam file with the given file_id"
]
[ "bam", "bam_export", "pattern bam.bam_export(output_path:str):void
", "bam_exportf;", "Export results in the bam.export table to a BAM
file" ]
[ "bam", "bam_flag", "command bam.bam_flag(flag:sht,name:str):bit ",
"bam_flag;", "Get bam flag by name." ]
diff --git a/clients/Tests/exports.stable.out b/clients/Tests/exports.stable.out
--- a/clients/Tests/exports.stable.out
+++ b/clients/Tests/exports.stable.out
@@ -683,41 +683,41 @@ str ALARMsleep(void *res, int *secs);
str ALARMtime(int *res);
str ALARMtimers(bat *res, bat *actions);
str ALARMusec(lng *ret);
+str ALGbandjoin(bat *r1, bat *r2, const bat *lid, const bat *rid, const bat
*slid, const bat *srid, const void *low, const void *high, const bit *li, const
bit *hi, const lng *estimate);
str ALGcard(lng *result, const bat *bid);
str ALGcopy(bat *result, const bat *bid);
str ALGcount_bat(lng *result, const bat *bid);
str ALGcount_nil(lng *result, const bat *bid, const bit *ignore_nils);
str ALGcount_no_nil(lng *result, const bat *bid);
str ALGcrossproduct2(bat *l, bat *r, const bat *lid, const bat *rid);
+str ALGdifference(bat *r1, const bat *lid, const bat *rid, const bat *slid,
const bat *srid, const bit *nil_matches, const lng *estimate);
str ALGexist(bit *ret, const bat *bid, const void *val);
str ALGfetchoid(ptr ret, const bat *bid, const oid *pos);
str ALGfind(oid *ret, const bat *bid, ptr val);
str ALGfirstn(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
str ALGgroupby(bat *res, const bat *gids, const bat *cnts);
+str ALGintersect(bat *r1, const bat *lid, const bat *rid, const bat *slid,
const bat *srid, const bit *nil_matches, const lng *estimate);
+str ALGjoin(bat *r1, bat *r2, const bat *l, const bat *r, const bat *sl, const
bat *sr, const bit *nil_matches, const lng *estimate);
+str ALGleftjoin(bat *r1, bat *r2, const bat *l, const bat *r, const bat *sl,
const bat *sr, const bit *nil_matches, const lng *estimate);
str ALGmaxany(ptr result, const bat *bid);
str ALGminany(ptr result, const bat *bid);
+str ALGouterjoin(bat *r1, bat *r2, const bat *l, const bat *r, const bat *sl,
const bat *sr, const bit *nil_matches, const lng *estimate);
str ALGprojection(bat *result, const bat *lid, const bat *rid);
str ALGprojectionpath(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
str ALGprojecttail(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
+str ALGrangejoin(bat *r1, bat *r2, const bat *lid, const bat *rlid, const bat
*rhid, const bat *slid, const bat *srid, const bit *li, const bit *hi, const
lng *estimate);
str ALGreuse(bat *ret, const bat *bid);
str ALGsample(bat *result, const bat *bid, const int *param);
str ALGselect1(bat *result, const bat *bid, const void *low, const void *high,
const bit *li, const bit *hi, const bit *anti);
str ALGselect2(bat *result, const bat *bid, const bat *sid, const void *low,
const void *high, const bit *li, const bit *hi, const bit *anti);
str ALGselectNotNil(bat *result, const bat *bid);
+str ALGsemijoin(bat *r1, bat *r2, const bat *l, const bat *r, const bat *sl,
const bat *sr, const bit *nil_matches, const lng *estimate);
str ALGslice(bat *ret, const bat *bid, const lng *start, const lng *end);
str ALGslice_int(bat *ret, const bat *bid, const int *start, const int *end);
str ALGslice_lng(bat *ret, const bat *bid, const lng *start, const lng *end);
str ALGslice_oid(bat *ret, const bat *bid, const oid *start, const oid *end);
str ALGstdev(dbl *res, const bat *bid);
str ALGstdevp(dbl *res, const bat *bid);
-str ALGsubbandjoin(bat *r1, bat *r2, const bat *lid, const bat *rid, const bat
*slid, const bat *srid, const void *low, const void *high, const bit *li, const
bit *hi, const lng *estimate);
-str ALGsubdiff(bat *r1, const bat *lid, const bat *rid, const bat *slid, const
bat *srid, const bit *nil_matches, const lng *estimate);
-str ALGsubinter(bat *r1, const bat *lid, const bat *rid, const bat *slid,
const bat *srid, const bit *nil_matches, const lng *estimate);
-str ALGsubjoin(bat *r1, bat *r2, const bat *l, const bat *r, const bat *sl,
const bat *sr, const bit *nil_matches, const lng *estimate);
-str ALGsubleftjoin(bat *r1, bat *r2, const bat *l, const bat *r, const bat
*sl, const bat *sr, const bit *nil_matches, const lng *estimate);
-str ALGsubouterjoin(bat *r1, bat *r2, const bat *l, const bat *r, const bat
*sl, const bat *sr, const bit *nil_matches, const lng *estimate);
-str ALGsubrangejoin(bat *r1, bat *r2, const bat *lid, const bat *rlid, const
bat *rhid, const bat *slid, const bat *srid, const bit *li, const bit *hi,
const lng *estimate);
-str ALGsubsemijoin(bat *r1, bat *r2, const bat *l, const bat *r, const bat
*sl, const bat *sr, const bit *nil_matches, const lng *estimate);
str ALGsubslice_lng(bat *ret, const bat *bid, const lng *start, const lng
*end);
str ALGsubsort11(bat *result, const bat *bid, const bit *reverse, const bit
*stable);
str ALGsubsort12(bat *result, bat *norder, const bat *bid, const bit *reverse,
const bit *stable);
@@ -728,16 +728,16 @@ str ALGsubsort23(bat *result, bat *norde
str ALGsubsort31(bat *result, const bat *bid, const bat *order, const bat
*group, const bit *reverse, const bit *stable);
str ALGsubsort32(bat *result, bat *norder, const bat *bid, const bat *order,
const bat *group, const bit *reverse, const bit *stable);
str ALGsubsort33(bat *result, bat *norder, bat *ngroup, const bat *bid, const
bat *order, const bat *group, const bit *reverse, const bit *stable);
-str ALGsubthetajoin(bat *r1, bat *r2, const bat *l, const bat *r, const bat
*sl, const bat *sr, const int *op, const bit *nil_matches, const lng *estimate);
-str ALGsubunique1(bat *result, const bat *bid);
-str ALGsubunique2(bat *result, const bat *bid, const bat *sid);
str ALGtdiff(bat *result, const bat *lid, const bat *rid);
+str ALGthetajoin(bat *r1, bat *r2, const bat *l, const bat *r, const bat *sl,
const bat *sr, const int *op, const bit *nil_matches, const lng *estimate);
str ALGthetaselect1(bat *result, const bat *bid, const void *val, const char
**op);
str ALGthetaselect2(bat *result, const bat *bid, const bat *sid, const void
*val, const char **op);
str ALGtinter(bat *result, const bat *lid, const bat *rid);
str ALGtmark(bat *result, const bat *bid, const oid *base);
str ALGtmark_default(bat *result, const bat *bid);
str ALGtmarkp(bat *result, const bat *bid, const int *nr_parts, const int
*part_nr);
+str ALGunique1(bat *result, const bat *bid);
+str ALGunique2(bat *result, const bat *bid, const bat *sid);
str ALGvariance(dbl *res, const bat *bid);
str ALGvariancep(dbl *res, const bat *bid);
str AUTHaddUser(oid *ret, Client c, str *user, str *pass);
@@ -1147,8 +1147,8 @@ str IDentifier(identifier *retval, str *
int IDfromString(str src, int *len, identifier *retval);
str IDprelude(void *ret);
int IDtoString(str *retval, int *len, identifier handle);
-str ILIKEsubjoin(bat *r1, bat *r2, const bat *lid, const bat *rid, const str
*esc, const bat *slid, const bat *srid, const bit *nil_matches, const lng
*estimate);
-str ILIKEsubjoin1(bat *r1, bat *r2, const bat *lid, const bat *rid, const bat
*slid, const bat *srid, const bit *nil_matches, const lng *estimate);
+str ILIKEjoin(bat *r1, bat *r2, const bat *lid, const bat *rid, const str
*esc, const bat *slid, const bat *srid, const bit *nil_matches, const lng
*estimate);
+str ILIKEjoin1(bat *r1, bat *r2, const bat *lid, const bat *rid, const bat
*slid, const bat *srid, const bit *nil_matches, const lng *estimate);
str INET_comp_CS(bit *retval, const inet *val1, const inet *val2);
str INET_comp_CSE(bit *retval, const inet *val1, const inet *val2);
str INET_comp_CW(bit *retval, const inet *val1, const inet *val2);
@@ -1254,8 +1254,8 @@ int JSONtoString(str *s, int *len, json
str JSONunfold(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
str JSONvalueArray(json *ret, json *arg);
str JSONvalueTable(bat *ret, json *j);
-str LIKEsubjoin(bat *r1, bat *r2, const bat *lid, const bat *rid, const str
*esc, const bat *slid, const bat *srid, const bit *nil_matches, const lng
*estimate);
-str LIKEsubjoin1(bat *r1, bat *r2, const bat *lid, const bat *rid, const bat
*slid, const bat *srid, const bit *nil_matches, const lng *estimate);
+str LIKEjoin(bat *r1, bat *r2, const bat *lid, const bat *rid, const str *esc,
const bat *slid, const bat *srid, const bit *nil_matches, const lng *estimate);
+str LIKEjoin1(bat *r1, bat *r2, const bat *lid, const bat *rid, const bat
*slid, const bat *srid, const bit *nil_matches, const lng *estimate);
str MACROprocessor(Client cntxt, MalBlkPtr mb, Symbol t);
int MAL_MAXCLIENTS;
int MALadmission(lng argclaim, lng hotclaim);
@@ -1912,12 +1912,14 @@ str aggrRef;
str alarmRef;
str algebraRef;
str andRef;
+str antijoinRef;
str appendRef;
str appendidxRef;
str arrayRef;
str assertRef;
str attachRef;
str avgRef;
+str bandjoinRef;
str basketRef;
void batAfterCall(ValPtr v, ValPtr bak);
void batBeforeCall(ValPtr v, ValPtr bak);
@@ -2012,7 +2014,7 @@ str deltaRef;
str dense_rankRef;
str depositRef;
malType destinationType(MalBlkPtr mb, InstrPtr p);
-str diffRef;
+str differenceRef;
str disconnectRef;
str divRef;
void dumpExceptionsToStream(stream *out, str msg);
@@ -2131,6 +2133,7 @@ void insertSymbol(Module scope, Symbol p
str instruction2str(MalBlkPtr mb, MalStkPtr stl, InstrPtr p, int hidden);
str instructionCall(MalBlkPtr mb, InstrPtr p, str s, str base, size_t len);
str intRef;
+str intersectRef;
str intersectcandRef;
str ioRef;
str io_stderr(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
@@ -2168,8 +2171,10 @@ int isUnsafeInstruction(InstrPtr q);
int isUpdateInstruction(InstrPtr p);
str iteratorRef;
str jitRef;
+str joinRef;
str jsonRef;
str languageRef;
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
