Changeset: aabebd926bec for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=aabebd926bec
Modified Files:
clients/Tests/MAL-signatures.stable.out
clients/Tests/MAL-signatures.stable.out.int128
clients/Tests/exports.stable.out
monetdb5/mal/Tests/dataflow01.malC
monetdb5/mal/Tests/selecttest.malC
monetdb5/mal/Tests/tst023.malC
monetdb5/mal/Tests/tst033.malC
monetdb5/mal/Tests/tst034.malC
monetdb5/mal/Tests/tst201.malC
monetdb5/mal/Tests/tst220.malC
monetdb5/mal/Tests/tst285.malC
monetdb5/mal/Tests/tst903.malC
monetdb5/mal/Tests/tst903.stable.out
monetdb5/mal/Tests/tst911.malC
monetdb5/mal/Tests/tst911.stable.out
monetdb5/mal/Tests/tst912.malC
monetdb5/modules/mal/Tests/inspect05.malC
monetdb5/modules/mal/Tests/mapi01.malC
monetdb5/modules/mal/Tests/mapi07.malC
monetdb5/modules/mal/Tests/orderidx01.malC
monetdb5/modules/mal/Tests/orderidx02.malC
monetdb5/modules/mal/Tests/remote04.malC
monetdb5/optimizer/Tests/CMexample.malC
monetdb5/optimizer/Tests/CRexample.malC
monetdb5/optimizer/Tests/CXexample.malC
monetdb5/optimizer/Tests/CXexample.stable.out
monetdb5/optimizer/Tests/FTexample.malC
monetdb5/optimizer/Tests/dataflow.malC
monetdb5/optimizer/Tests/dataflow.stable.out
monetdb5/optimizer/Tests/qep01.malC
monetdb5/optimizer/Tests/reorder00.malC
monetdb5/optimizer/Tests/reorder00.stable.out
monetdb5/optimizer/Tests/tst4000.malC
monetdb5/optimizer/Tests/tst4003.malC
monetdb5/optimizer/Tests/tst4003.stable.out
monetdb5/optimizer/Tests/tst4030.malC
monetdb5/optimizer/Tests/tst4030.stable.out
monetdb5/optimizer/Tests/tst4700.malC
sql/test/BugTracker-2012/Tests/rewrite_like_into_likesubselect.Bug-3179.stable.out
sql/test/BugTracker-2015/Tests/crash.Bug-3736.stable.out
sql/test/BugTracker-2016/Tests/decimal_vs_integer.Bug-3941.stable.out
sql/test/mergetables/Tests/mergequery.stable.out
sql/test/remote/Tests/partition_elim.stable.out
Branch: default
Log Message:
Replace subselect ->select
diffs (truncated from 1875 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
@@ -475,17 +475,17 @@ 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", "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", "ilikesubselect", "command
algebra.ilikesubselect(b:bat[:str],cand:bat[:oid],pat:str,esc:str,anti:bit):bat[:oid]
", "PCRElikesubselect1;", "" ]
-[ "algebra", "ilikesubselect", "command
algebra.ilikesubselect(b:bat[:str],cand:bat[:oid],pat:str,anti:bit):bat[:oid]
", "PCRElikesubselect4;", "" ]
[ "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", "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", "likesubselect", "command
algebra.likesubselect(b:bat[:str],s:bat[:oid],pat:str,esc:str,caseignore:bit,anti:bit):bat[:oid]
", "PCRElikesubselect2;", "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", "likesubselect", "command
algebra.likesubselect(b:bat[:str],cand:bat[:oid],pat:str,esc:str,anti:bit):bat[:oid]
", "PCRElikesubselect3;", "" ]
-[ "algebra", "likesubselect", "command
algebra.likesubselect(b:bat[:str],cand:bat[:oid],pat:str,anti:bit):bat[:oid] ",
"PCRElikesubselect5;", "" ]
[ "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;", "" ]
@@ -495,6 +495,8 @@ Ready.
[ "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", "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", "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." ]
@@ -508,8 +510,6 @@ Ready.
[ "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", "subselect", "command
algebra.subselect(b:bat[:any_1],low:any_1,high:any_1,li:bit,hi:bit,anti:bit):bat[:oid]
", "ALGsubselect1;", "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", "subselect", "command
algebra.subselect(b:bat[:any_1],s:bat[:oid],low:any_1,high:any_1,li:bit,hi:bit,anti:bit):bat[:oid]
", "ALGsubselect2;", "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 output is suitable as second input for this\n\tfunction." ]
[ "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." ]
@@ -524,8 +524,8 @@ Ready.
[ "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", "thetasubselect", "command
algebra.thetasubselect(b:bat[:any_1],val:any_1,op:str):bat[:oid] ",
"ALGthetasubselect1;", "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", "thetasubselect", "command
algebra.thetasubselect(b:bat[:any_1],s:bat[:oid],val:any_1,op:str):bat[:oid] ",
"ALGthetasubselect2;", "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", "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." ]
[ "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." ]
@@ -8396,8 +8396,8 @@ Ready.
[ "sql", "password", "pattern sql.password(user:str):str ",
"db_password_wrap;", "Return password hash of user" ]
[ "sql", "prelude", "command sql.prelude():void ", "SQLprelude;",
"" ]
[ "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(subselect: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(subselect: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." ]
+[ "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."
]
[ "sql", "querylog_calls", "pattern sql.querylog_calls()
(id:bat[:oid],start:bat[:timestamp],stop:bat[:timestamp],arguments:bat[:str],tuples:bat[:lng],exec:bat[:lng],result:bat[:lng],cpuload:bat[:int],iowait:bat[:int])
", "sql_querylog_calls;", "Obtain the query log calls" ]
[ "sql", "querylog_catalog", "pattern sql.querylog_catalog()
(id:bat[:oid],user:bat[:str],defined:bat[:timestamp],query:bat[:str],pipe:bat[:str],plan:bat[:str],mal:bat[:int],optimize:bat[:lng])
", "sql_querylog_catalog;", "Obtain the query log catalog" ]
[ "sql", "querylog_disable", "command sql.querylog_disable():void ",
"QLOGdisable;", "" ]
@@ -8436,8 +8436,8 @@ Ready.
[ "sql", "storage", "pattern sql.storage(sname:str)
(schema:bat[:str],table:bat[:str],column:bat[:str],type:bat[:str],mode:bat[:str],location:bat[:str],count:bat[:lng],atomwidth:bat[:int],columnsize:bat[:lng],heap:bat[:lng],hashes:bat[:lng],phash:bat[:bit],imprints:bat[:lng],sorted:bat[:bit],revsorted:bat[:bit],key:bat[:bit],orderidx:bat[:lng])
", "sql_storage;", "return a table with storage information for a
particular schema " ]
[ "sql", "storage", "pattern sql.storage(sname:str,tname:str)
(schema:bat[:str],table:bat[:str],column:bat[:str],type:bat[:str],mode:bat[:str],location:bat[:str],count:bat[:lng],atomwidth:bat[:int],columnsize:bat[:lng],heap:bat[:lng],hashes:bat[:lng],phash:bat[:bit],imprints:bat[:lng],sorted:bat[:bit],revsorted:bat[:bit],key:bat[:bit],orderidx:bat[:lng])
", "sql_storage;", "return a table with storage information for a
particular table" ]
[ "sql", "storage", "pattern
sql.storage(sname:str,tname:str,cname:str)
(schema:bat[:str],table:bat[:str],column:bat[:str],type:bat[:str],mode:bat[:str],location:bat[:str],count:bat[:lng],atomwidth:bat[:int],columnsize:bat[:lng],heap:bat[:lng],hashes:bat[:lng],phash:bat[:bit],imprints:bat[:lng],sorted:bat[:bit],revsorted:bat[:bit],key:bat[:bit],orderidx:bat[:lng])
", "sql_storage;", "return a table with storage information for a particular
column" ]
-[ "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 subselected 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 subselected delta." ]
+[ "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", "sysmon_pause", "pattern sql.sysmon_pause(tag:int):void ",
"SYSMONpause;", "" ]
[ "sql", "sysmon_pause", "pattern sql.sysmon_pause(tag:lng):void ",
"SYSMONpause;", "" ]
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
@@ -579,17 +579,17 @@ 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", "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", "ilikesubselect", "command
algebra.ilikesubselect(b:bat[:str],cand:bat[:oid],pat:str,esc:str,anti:bit):bat[:oid]
", "PCRElikesubselect1;", "" ]
-[ "algebra", "ilikesubselect", "command
algebra.ilikesubselect(b:bat[:str],cand:bat[:oid],pat:str,anti:bit):bat[:oid]
", "PCRElikesubselect4;", "" ]
[ "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", "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", "likesubselect", "command
algebra.likesubselect(b:bat[:str],s:bat[:oid],pat:str,esc:str,caseignore:bit,anti:bit):bat[:oid]
", "PCRElikesubselect2;", "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", "likesubselect", "command
algebra.likesubselect(b:bat[:str],cand:bat[:oid],pat:str,esc:str,anti:bit):bat[:oid]
", "PCRElikesubselect3;", "" ]
-[ "algebra", "likesubselect", "command
algebra.likesubselect(b:bat[:str],cand:bat[:oid],pat:str,anti:bit):bat[:oid] ",
"PCRElikesubselect5;", "" ]
[ "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;", "" ]
@@ -599,6 +599,8 @@ Ready.
[ "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", "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", "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." ]
@@ -612,8 +614,6 @@ Ready.
[ "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", "subselect", "command
algebra.subselect(b:bat[:any_1],low:any_1,high:any_1,li:bit,hi:bit,anti:bit):bat[:oid]
", "ALGsubselect1;", "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", "subselect", "command
algebra.subselect(b:bat[:any_1],s:bat[:oid],low:any_1,high:any_1,li:bit,hi:bit,anti:bit):bat[:oid]
", "ALGsubselect2;", "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 output is suitable as second input for this\n\tfunction." ]
[ "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." ]
@@ -628,8 +628,8 @@ Ready.
[ "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", "thetasubselect", "command
algebra.thetasubselect(b:bat[:any_1],val:any_1,op:str):bat[:oid] ",
"ALGthetasubselect1;", "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", "thetasubselect", "command
algebra.thetasubselect(b:bat[:any_1],s:bat[:oid],val:any_1,op:str):bat[:oid] ",
"ALGthetasubselect2;", "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", "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." ]
[ "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." ]
@@ -10759,8 +10759,8 @@ Ready.
[ "sql", "password", "pattern sql.password(user:str):str ",
"db_password_wrap;", "Return password hash of user" ]
[ "sql", "prelude", "command sql.prelude():void ", "SQLprelude;",
"" ]
[ "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(subselect: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(subselect: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." ]
+[ "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."
]
[ "sql", "querylog_calls", "pattern sql.querylog_calls()
(id:bat[:oid],start:bat[:timestamp],stop:bat[:timestamp],arguments:bat[:str],tuples:bat[:lng],exec:bat[:lng],result:bat[:lng],cpuload:bat[:int],iowait:bat[:int])
", "sql_querylog_calls;", "Obtain the query log calls" ]
[ "sql", "querylog_catalog", "pattern sql.querylog_catalog()
(id:bat[:oid],user:bat[:str],defined:bat[:timestamp],query:bat[:str],pipe:bat[:str],plan:bat[:str],mal:bat[:int],optimize:bat[:lng])
", "sql_querylog_catalog;", "Obtain the query log catalog" ]
[ "sql", "querylog_disable", "command sql.querylog_disable():void ",
"QLOGdisable;", "" ]
@@ -10800,8 +10800,8 @@ Ready.
[ "sql", "storage", "pattern sql.storage(sname:str)
(schema:bat[:str],table:bat[:str],column:bat[:str],type:bat[:str],mode:bat[:str],location:bat[:str],count:bat[:lng],atomwidth:bat[:int],columnsize:bat[:lng],heap:bat[:lng],hashes:bat[:lng],phash:bat[:bit],imprints:bat[:lng],sorted:bat[:bit],revsorted:bat[:bit],key:bat[:bit],orderidx:bat[:lng])
", "sql_storage;", "return a table with storage information for a
particular schema " ]
[ "sql", "storage", "pattern sql.storage(sname:str,tname:str)
(schema:bat[:str],table:bat[:str],column:bat[:str],type:bat[:str],mode:bat[:str],location:bat[:str],count:bat[:lng],atomwidth:bat[:int],columnsize:bat[:lng],heap:bat[:lng],hashes:bat[:lng],phash:bat[:bit],imprints:bat[:lng],sorted:bat[:bit],revsorted:bat[:bit],key:bat[:bit],orderidx:bat[:lng])
", "sql_storage;", "return a table with storage information for a
particular table" ]
[ "sql", "storage", "pattern
sql.storage(sname:str,tname:str,cname:str)
(schema:bat[:str],table:bat[:str],column:bat[:str],type:bat[:str],mode:bat[:str],location:bat[:str],count:bat[:lng],atomwidth:bat[:int],columnsize:bat[:lng],heap:bat[:lng],hashes:bat[:lng],phash:bat[:bit],imprints:bat[:lng],sorted:bat[:bit],revsorted:bat[:bit],key:bat[:bit],orderidx:bat[:lng])
", "sql_storage;", "return a table with storage information for a particular
column" ]
-[ "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 subselected 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 subselected delta." ]
+[ "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", "sysmon_pause", "pattern sql.sysmon_pause(tag:int):void ",
"SYSMONpause;", "" ]
[ "sql", "sysmon_pause", "pattern sql.sysmon_pause(tag:lng):void ",
"SYSMONpause;", "" ]
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
@@ -701,6 +701,8 @@ str ALGprojectionpath(Client cntxt, MalB
str ALGprojecttail(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
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 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);
@@ -715,8 +717,6 @@ str ALGsubjoin(bat *r1, bat *r2, const b
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 ALGsubselect1(bat *result, const bat *bid, const void *low, const void
*high, const bit *li, const bit *hi, const bit *anti);
-str ALGsubselect2(bat *result, const bat *bid, const bat *sid, const void
*low, const void *high, const bit *li, const bit *hi, const bit *anti);
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);
@@ -732,8 +732,8 @@ str ALGsubthetajoin(bat *r1, bat *r2, co
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 ALGthetasubselect1(bat *result, const bat *bid, const void *val, const
char **op);
-str ALGthetasubselect2(bat *result, const bat *bid, const bat *sid, const void
*val, const char **op);
+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);
@@ -1579,11 +1579,11 @@ str PCREimatch(bit *ret, const str *val,
str PCREindex(int *ret, const pcre *pat, const str *val);
str PCRElike2(bit *ret, const str *s, const str *pat);
str PCRElike3(bit *ret, const str *s, const str *pat, const str *esc);
-str PCRElikesubselect1(bat *ret, const bat *bid, const bat *cid, const str
*pat, const str *esc, const bit *anti);
-str PCRElikesubselect2(bat *ret, const bat *bid, const bat *sid, const str
*pat, const str *esc, const bit *caseignore, const bit *anti);
-str PCRElikesubselect3(bat *ret, const bat *bid, const bat *sid, const str
*pat, const str *esc, const bit *anti);
-str PCRElikesubselect4(bat *ret, const bat *bid, const bat *cid, const str
*pat, const bit *anti);
-str PCRElikesubselect5(bat *ret, const bat *bid, const bat *sid, const str
*pat, const bit *anti);
+str PCRElikeselect1(bat *ret, const bat *bid, const bat *cid, const str *pat,
const str *esc, const bit *anti);
+str PCRElikeselect2(bat *ret, const bat *bid, const bat *sid, const str *pat,
const str *esc, const bit *caseignore, const bit *anti);
+str PCRElikeselect3(bat *ret, const bat *bid, const bat *sid, const str *pat,
const str *esc, const bit *anti);
+str PCRElikeselect4(bat *ret, const bat *bid, const bat *cid, const str *pat,
const bit *anti);
+str PCRElikeselect5(bat *ret, const bat *bid, const bat *sid, const str *pat,
const bit *anti);
str PCREmatch(bit *ret, const str *val, const str *pat);
str PCREnotilike2(bit *ret, const str *s, const str *pat);
str PCREnotilike3(bit *ret, const str *s, const str *pat, const str *esc);
@@ -2115,8 +2115,8 @@ str identityRef;
str ifthenelseRef;
str ilikeRef;
str ilikeselectRef;
-str ilikesubselectRef;
-str ilikethetasubselectRef;
+str ilikeselectRef;
+str ilikethetaselectRef;
str ilikeuselectRef;
void initHeartbeat(void);
void initNamespace(void);
@@ -2158,10 +2158,10 @@ int isOptimizerPipe(str name);
int isOrderby(InstrPtr q);
int isProcedure(MalBlkPtr mb, InstrPtr p);
int isSample(InstrPtr q);
+int isSelect(InstrPtr q);
int isSideEffectFree(MalBlkPtr mb);
int isSlice(InstrPtr q);
int isSubJoin(InstrPtr q);
-int isSubSelect(InstrPtr q);
int isTopn(InstrPtr q);
int isUnsafeFunction(InstrPtr q);
int isUnsafeInstruction(InstrPtr q);
@@ -2175,8 +2175,8 @@ str levenshteinbasic2_impl(int *result,
str levenshteinbasic_impl(int *result, str *s, str *t);
str likeRef;
str likeselectRef;
-str likesubselectRef;
-str likethetasubselectRef;
+str likeselectRef;
+str likethetaselectRef;
str likeuselectRef;
str listRef;
str loadLibrary(str modulename, int flag);
@@ -2406,6 +2406,7 @@ int safetyBarrier(InstrPtr p, InstrPtr q
str sampleRef;
str schedulerRef;
str selectNotNilRef;
+str selectRef;
str semaRef;
str seriesRef;
str setAccessRef;
@@ -2478,7 +2479,6 @@ str submedianRef;
str subminRef;
str subprodRef;
str subrangejoinRef;
-str subselectRef;
str subsliceRef;
str subsortRef;
str subsumRef;
@@ -2488,7 +2488,7 @@ str subuniqueRef;
str sumRef;
str takeOid(oid id, str *val);
str takeRef;
-str thetasubselectRef;
+str thetaselectRef;
str tidRef;
str timestampRef;
int timestamp_fromstr(const char *buf, int *len, timestamp **ret);
diff --git a/monetdb5/mal/Tests/dataflow01.malC
b/monetdb5/mal/Tests/dataflow01.malC
--- a/monetdb5/mal/Tests/dataflow01.malC
+++ b/monetdb5/mal/Tests/dataflow01.malC
@@ -26,7 +26,7 @@ end load;
function qry(z:bat[:lng],low:int,hgh:int):lng;
l:= calc.lng(low);
h:= calc.lng(hgh);
- s:= algebra.subselect(z,l,h,true,true,false);
+ s:= algebra.select(z,l,h,true,true,false);
c:= aggr.count(s);
return qry:= c;
end qry;
diff --git a/monetdb5/mal/Tests/selecttest.malC
b/monetdb5/mal/Tests/selecttest.malC
--- a/monetdb5/mal/Tests/selecttest.malC
+++ b/monetdb5/mal/Tests/selecttest.malC
@@ -6,23 +6,23 @@ b := microbenchmark.uniform(0:oid,100000
function user.doit ( b:bat[:int] , n:int , x1:int , x2:int ) :void;
- a := algebra.subselect(b,nil:bat[:oid],x1,x2,true,true,false);
+ a := algebra.select(b,nil:bat[:oid],x1,x2,true,true,false);
c := aggr.count(a);
io.printf("\npredicate: %9d <= x <= %9d; result count: %9lld\n", x1,
x2, c);
io.printf("1 slice, sequential:\ttime:");
t0 := alarm.time();
- a1 := algebra.subselect(b,nil:bat[:oid],x1,x2,true,true,false);
+ a1 := algebra.select(b,nil:bat[:oid],x1,x2,true,true,false);
t1 := alarm.time();
t := t1 - t0;
io.printf(" %5lld ms", t);
t0 := alarm.time();
- a1 := algebra.subselect(b,nil:bat[:oid],x1,x2,true,true,false);
+ a1 := algebra.select(b,nil:bat[:oid],x1,x2,true,true,false);
t1 := alarm.time();
t := t1 - t0;
io.printf(" %5lld ms", t);
t0 := alarm.time();
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
