Changeset: 85e32a4ed063 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=85e32a4ed063
Modified Files:
clients/Tests/MAL-signatures.stable.out
monetdb5/extras/mal_optimizer_template/Tests/opt_sql_append.stable.out
monetdb5/mal/Tests/tst005.stable.out
monetdb5/mal/Tests/tst006.stable.out
monetdb5/mal/Tests/tst019.stable.err
monetdb5/mal/Tests/tst027.stable.err
monetdb5/mal/Tests/tst038.stable.err
monetdb5/mal/Tests/tst070.stable.err
monetdb5/mal/Tests/tst071.stable.err
monetdb5/mal/Tests/tst077.stable.out
monetdb5/mal/Tests/tst1002.stable.out
monetdb5/mal/Tests/tst102.stable.err
monetdb5/mal/Tests/tst163.stable.err
monetdb5/mal/Tests/tst303.stable.out
monetdb5/mal/Tests/tst400.stable.out
monetdb5/mal/Tests/tst401.stable.out
monetdb5/mal/Tests/tst661.stable.out
monetdb5/mal/Tests/tst662.stable.out
monetdb5/mal/Tests/tst755.stable.err
monetdb5/mal/Tests/tst760.stable.err
monetdb5/mal/Tests/tst810.stable.out
monetdb5/mal/Tests/tst819.stable.out
monetdb5/mal/Tests/tst830.stable.out
monetdb5/mal/Tests/tst840.stable.out
monetdb5/mal/Tests/tst850.stable.out
monetdb5/mal/Tests/tst866.stable.out
monetdb5/mal/Tests/tst870.stable.out
monetdb5/mal/Tests/tst880.stable.out
monetdb5/mal/Tests/tst890.stable.out
monetdb5/mal/Tests/tst901.stable.out
monetdb5/mal/Tests/tst901a.stable.out
monetdb5/mal/Tests/tst902.stable.out
monetdb5/mal/Tests/tst903.stable.out
monetdb5/mal/Tests/tst904.stable.out
monetdb5/mal/Tests/tst906.stable.out
monetdb5/mal/Tests/tst907.stable.out
monetdb5/mal/Tests/tst908.stable.out
monetdb5/mal/Tests/tst911.stable.out
monetdb5/mal/Tests/tst913.stable.out
monetdb5/mal/Tests/tst920.stable.out
monetdb5/mal/Tests/tst960.stable.out
monetdb5/mal/mal_listing.c
monetdb5/mal/mal_profiler.c
monetdb5/modules/mal/Tests/call00.stable.out
monetdb5/modules/mal/Tests/inspect00.stable.out
monetdb5/modules/mal/Tests/inspect05.stable.out.int128
monetdb5/modules/mal/Tests/partition.stable.out
monetdb5/optimizer/Tests/ARexample.stable.out
monetdb5/optimizer/Tests/CXexample.stable.out
monetdb5/optimizer/Tests/DCexample2.stable.out
monetdb5/optimizer/Tests/GCexample01.stable.out
monetdb5/optimizer/Tests/JPexample.stable.out
monetdb5/optimizer/Tests/Mexample.stable.out
monetdb5/optimizer/Tests/dataflow.stable.out
monetdb5/optimizer/Tests/dataflow3.stable.out
monetdb5/optimizer/Tests/dataflow5.stable.out
monetdb5/optimizer/Tests/inline00.stable.out
monetdb5/optimizer/Tests/inline01.stable.out
monetdb5/optimizer/Tests/inline02.stable.out
monetdb5/optimizer/Tests/inline03.stable.out
monetdb5/optimizer/Tests/inline04.stable.out
monetdb5/optimizer/Tests/inline05.stable.out
monetdb5/optimizer/Tests/inline06.stable.out
monetdb5/optimizer/Tests/inline07.stable.out
monetdb5/optimizer/Tests/inline08.stable.out
monetdb5/optimizer/Tests/inline09.stable.out
monetdb5/optimizer/Tests/inline10.stable.out
monetdb5/optimizer/Tests/inline12.stable.out
monetdb5/optimizer/Tests/inlineCst.stable.out
monetdb5/optimizer/Tests/inlineFunction2.stable.out
monetdb5/optimizer/Tests/inlineIfthen.stable.out
monetdb5/optimizer/Tests/manifold2.stable.out
monetdb5/optimizer/Tests/projectionchain.stable.out
monetdb5/optimizer/Tests/remap.stable.out
monetdb5/optimizer/Tests/reorder00.stable.out
monetdb5/optimizer/Tests/tst4000.stable.out
monetdb5/optimizer/Tests/tst4001.stable.out
monetdb5/optimizer/Tests/tst4003.stable.out
monetdb5/optimizer/Tests/tst4005.stable.out
monetdb5/optimizer/Tests/tst4010.stable.out
monetdb5/optimizer/Tests/tst4030.stable.out
monetdb5/optimizer/Tests/tst4601.stable.out
monetdb5/optimizer/Tests/tst4630.stable.out
monetdb5/optimizer/opt_profiler.c
sql/backends/monet5/Tests/simpleSQL.stable.out
sql/backends/monet5/UDF/cudf/Tests/udf-fuse.stable.out
sql/backends/monet5/UDF/cudf/Tests/udf-reverse.stable.out
sql/test/BugTracker-2009/Tests/POWER_vs_prod.SF-2596114.stable.out
sql/test/BugTracker-2009/Tests/segfault_when_quitting_debugger.SF-2538837.stable.out
sql/test/BugTracker-2010/Tests/LIMIT_OFFSET_big-endian.Bug-2622.stable.out
sql/test/BugTracker-2012/Tests/rewrite_like_into_likesubselect.Bug-3179.stable.out
sql/test/BugTracker-2014/Tests/manifold.Bug-3556.stable.out
sql/test/BugTracker-2016/Tests/decimal_vs_integer.Bug-3941.stable.out
sql/test/mapi/Tests/sql_int128.stable.out
sql/test/mergetables/Tests/mergequery.stable.out
sql/test/remote/Tests/partition_elim.stable.out
Branch: default
Log Message:
Change rendering
diffs (truncated from 6328 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,92 +461,92 @@ 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", "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." ]
-[ "algebra", "firstn", "pattern
algebra.firstn(b:bat[:any],n:lng,asc:bit,distinct:bit)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGfirstn;", "Calculate first N
values of B" ]
-[ "algebra", "firstn", "pattern
algebra.firstn(b:bat[:any],n:lng,asc:bit,distinct:bit):bat[:oid] ",
"ALGfirstn;", "Calculate first N values of B" ]
-[ "algebra", "firstn", "pattern
algebra.firstn(b:bat[:any],s:bat[:oid],g:bat[:oid],n:lng,asc:bit,distinct:bit)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGfirstn;", "Calculate first N
values of B with candidate list S" ]
-[ "algebra", "firstn", "pattern
algebra.firstn(b:bat[:any],s:bat[:oid],g:bat[:oid],n:lng,asc:bit,distinct:bit):bat[:oid]
", "ALGfirstn;", "Calculate first N values of B with candidate list S" ]
-[ "algebra", "firstn", "pattern
algebra.firstn(b:bat[:any],s:bat[:oid],n:lng,asc:bit,distinct:bit)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGfirstn;", "Calculate first N values
of B with candidate list S" ]
-[ "algebra", "firstn", "pattern
algebra.firstn(b:bat[:any],s:bat[:oid],n:lng,asc:bit,distinct:bit):bat[:oid] ",
"ALGfirstn;", "Calculate first N values of B with candidate list S" ]
-[ "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", "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", "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", "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." ]
+[ "algebra", "firstn", "pattern algebra.firstn(b:bat[:any], n:lng,
asc:bit, distinct:bit) (X_0:bat[:oid], X_1:bat[:oid]) ", "ALGfirstn;",
"Calculate first N values of B" ]
+[ "algebra", "firstn", "pattern algebra.firstn(b:bat[:any], n:lng,
asc:bit, distinct:bit):bat[:oid] ", "ALGfirstn;", "Calculate first N values
of B" ]
+[ "algebra", "firstn", "pattern algebra.firstn(b:bat[:any],
s:bat[:oid], g:bat[:oid], n:lng, asc:bit, distinct:bit) (X_0:bat[:oid],
X_1:bat[:oid]) ", "ALGfirstn;", "Calculate first N values of B with
candidate list S" ]
+[ "algebra", "firstn", "pattern algebra.firstn(b:bat[:any],
s:bat[:oid], g:bat[:oid], n:lng, asc:bit, distinct:bit):bat[:oid] ",
"ALGfirstn;", "Calculate first N values of B with candidate list S" ]
+[ "algebra", "firstn", "pattern algebra.firstn(b:bat[:any],
s:bat[:oid], n:lng, asc:bit, distinct:bit) (X_0:bat[:oid], X_1:bat[:oid]) ",
"ALGfirstn;", "Calculate first N values of B with candidate list S" ]
+[ "algebra", "firstn", "pattern algebra.firstn(b:bat[:any],
s:bat[:oid], n:lng, asc:bit, distinct:bit):bat[:oid] ", "ALGfirstn;",
"Calculate first N values of B with candidate list S" ]
+[ "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", "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", "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", "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", "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 th
e output 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", "sort", "command
algebra.sort(b:bat[:any_1],reverse:bit,stable:bit):bat[:any_1] ",
"ALGsort11;", "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", "sort", "command
algebra.sort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsort12;", "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", "sort", "command
algebra.sort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsort13;", "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", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit):bat[:any_1] ",
"ALGsort21;", "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", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsort22;", "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", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsort23;",
"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", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit):bat[:any_1]
", "ALGsort31;", "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", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsort32;", "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", "sort", "command
algebra.sort(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]) ", "ALGsort33;", "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", "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", "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", "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", "sort", "command algebra.sort(b:bat[:any_1], reverse:bit,
stable:bit):bat[:any_1] ", "ALGsort11;", "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", "sort", "command algebra.sort(b:bat[:any_1], reverse:bit,
stable:bit) (X_0:bat[:any_1], X_1:bat[:oid]) ", "ALGsort12;", "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", "sort", "command algebra.sort(b:bat[:any_1], reverse:bit,
stable:bit) (X_0:bat[:any_1], X_1:bat[:oid], X_2:bat[:oid]) ",
"ALGsort13;", "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", "sort", "command algebra.sort(b:bat[:any_1], o:bat[:oid],
reverse:bit, stable:bit):bat[:any_1] ", "ALGsort21;", "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", "sort", "command algebra.sort(b:bat[:any_1], o:bat[:oid],
reverse:bit, stable:bit) (X_0:bat[:any_1], X_1:bat[:oid]) ", "ALGsort22;",
"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", "sort", "command algebra.sort(b:bat[:any_1], o:bat[:oid],
reverse:bit, stable:bit) (X_0:bat[:any_1], X_1:bat[:oid], X_2:bat[:oid]) ",
"ALGsort23;", "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", "sort", "command algebra.sort(b:bat[:any_1], o:bat[:oid],
g:bat[:oid], reverse:bit, stable:bit):bat[:any_1] ", "ALGsort31;", "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", "sort", "command algebra.sort(b:bat[:any_1], o:bat[:oid],
g:bat[:oid], reverse:bit, stable:bit) (X_0:bat[:any_1], X_1:bat[:oid]) ",
"ALGsort32;", "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", "sort", "command algebra.sort(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]) ", "ALGsort33;", "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", "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", "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"
]
+[ "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." ]
-[ "bam", "bam_loader_file", "pattern
bam.bam_loader_file(bam_file:str,dbschema:sht):void ", "bam_loader_file;",
"Read bam_file and store it in the given dbschema" ]
-[ "bam", "bam_loader_files", "pattern
bam.bam_loader_files(bam_files:str,dbschema:sht):void ",
"bam_loader_files;", "Read all bam files in the file list stored in the file
bam_files (separated by a newline) and store them in the given dbschema"
]
-[ "bam", "bam_loader_repos", "pattern
bam.bam_loader_repos(bam_repos:str,dbschema:sht):void ",
"bam_loader_repos;", "Read all bam files in the given bam_repos directory
(non-recursive) and store them in the given dbschema" ]
+[ "bam", "bam_flag", "command bam.bam_flag(flag:sht, name:str):bit
", "bam_flag;", "Get bam flag by name." ]
+[ "bam", "bam_loader_file", "pattern
bam.bam_loader_file(bam_file:str, dbschema:sht):void ",
"bam_loader_file;", "Read bam_file and store it in the given dbschema"
]
+[ "bam", "bam_loader_files", "pattern
bam.bam_loader_files(bam_files:str, dbschema:sht):void ",
"bam_loader_files;", "Read all bam files in the file list stored in the file
bam_files (separated by a newline) and store them in the given dbschema"
]
+[ "bam", "bam_loader_repos", "pattern
bam.bam_loader_repos(bam_repos:str, dbschema:sht):void ",
"bam_loader_repos;", "Read all bam files in the given bam_repos directory
(non-recursive) and store them in the given dbschema" ]
[ "bam", "reverse_qual", "command bam.reverse_qual(qual:str):str ",
"reverse_qual;", "Reverse a DNA Quality string." ]
[ "bam", "reverse_seq", "command bam.reverse_seq(seq:str):str ",
"reverse_seq;", "Reverse a DNA sequence." ]
[ "bam", "sam_export", "pattern bam.sam_export(output_path:str):void
", "sam_exportf;", "Export results in the bam.export table to a SAM
file" ]
-[ "bam", "seq_char", "command
bam.seq_char(ref_pos:int,alg_seq:str,alg_pos:int,alg_cigar:str):str ",
"seq_char;", "Calculate the character in the alignment string (alg_str) that
is aligned to position 'ref_pos', conforming to the given cigar string" ]
+[ "bam", "seq_char", "command bam.seq_char(ref_pos:int, alg_seq:str,
alg_pos:int, alg_cigar:str):str ", "seq_char;", "Calculate the
character in the alignment string (alg_str) that is aligned to position
'ref_pos', conforming to the given cigar string" ]
[ "bam", "seq_length", "command bam.seq_length(cigar:str):int ",
"seq_length;", "Calculate the real length of a DNA sequence, given its CIGAR
string." ]
-[ "bat", "append", "command
bat.append(i:bat[:any_1],u:bat[:any_1],s:bat[:oid],force:bit):bat[:any_1] ",
"BKCappend_cand_force_wrap;", "append the content of u with candidate list s
to i" ]
-[ "bat", "append", "command
bat.append(i:bat[:any_1],u:bat[:any_1],s:bat[:oid]):bat[:any_1] ",
"BKCappend_cand_wrap;", "append the content of u with candidate list s to i"
]
-[ "bat", "append", "command
bat.append(i:bat[:any_1],u:bat[:any_1],force:bit):bat[:any_1] ",
"BKCappend_force_wrap;", "append the content of u to i" ]
-[ "bat", "append", "command
bat.append(i:bat[:any_1],u:any_1,force:bit):bat[:any_1] ",
"BKCappend_val_force_wrap;", "append the value u to i" ]
-[ "bat", "append", "command
bat.append(i:bat[:any_1],u:any_1):bat[:any_1] ", "BKCappend_val_wrap;",
"append the value u to i" ]
-[ "bat", "append", "command
bat.append(i:bat[:any_1],u:bat[:any_1]):bat[:any_1] ", "BKCappend_wrap;",
"append the content of u to i" ]
-[ "bat", "attach", "command
bat.attach(tt:int,heapfile:str):bat[:any_1] ", "BKCattach;", "Returns a new
BAT with dense head and tail of the given type and uses\n the given file
to initialize the tail. The file will be owned by the\n server." ]
-[ "bat", "delete", "command
bat.delete(b:bat[:any_1],h:oid):bat[:any_1] ", "BKCdelete;", "Delete BUN
indicated by head value, exchanging with last BUN" ]
+[ "bat", "append", "command bat.append(i:bat[:any_1],
u:bat[:any_1], s:bat[:oid], force:bit):bat[:any_1] ",
"BKCappend_cand_force_wrap;", "append the content of u with candidate list s
to i" ]
+[ "bat", "append", "command bat.append(i:bat[:any_1],
u:bat[:any_1], s:bat[:oid]):bat[:any_1] ", "BKCappend_cand_wrap;", "append
the content of u with candidate list s to i" ]
+[ "bat", "append", "command bat.append(i:bat[:any_1],
u:bat[:any_1], force:bit):bat[:any_1] ", "BKCappend_force_wrap;",
"append the content of u to i" ]
+[ "bat", "append", "command bat.append(i:bat[:any_1], u:any_1,
force:bit):bat[:any_1] ", "BKCappend_val_force_wrap;", "append the value u
to i" ]
+[ "bat", "append", "command bat.append(i:bat[:any_1],
u:any_1):bat[:any_1] ", "BKCappend_val_wrap;", "append the value u to i"
]
+[ "bat", "append", "command bat.append(i:bat[:any_1],
u:bat[:any_1]):bat[:any_1] ", "BKCappend_wrap;", "append the
content of u to i" ]
+[ "bat", "attach", "command bat.attach(tt:int,
heapfile:str):bat[:any_1] ", "BKCattach;", "Returns a new BAT with
dense head and tail of the given type and uses\n the given file to
initialize the tail. The file will be owned by the\n server." ]
+[ "bat", "delete", "command bat.delete(b:bat[:any_1],
h:oid):bat[:any_1] ", "BKCdelete;", "Delete BUN indicated by head
value, exchanging with last BUN" ]
[ "bat", "delete", "command bat.delete(b:bat[:any_1]):bat[:any_1]
", "BKCdelete_all;", "Delete all entries." ]
-[ "bat", "delete", "command
bat.delete(b:bat[:any_1],d:bat[:oid]):bat[:any_1] ", "BKCdelete_multi;",
"Delete multiple BUN, shifting BUNs up" ]
+[ "bat", "delete", "command bat.delete(b:bat[:any_1],
d:bat[:oid]):bat[:any_1] ", "BKCdelete_multi;", "Delete multiple BUN,
shifting BUNs up" ]
[ "bat", "densebat", "command bat.densebat(sz:lng):bat[:oid] ",
"BKCdensebat;", "Creates a new [void,void] BAT of size 'sz'." ]
[ "bat", "getAccess", "command bat.getAccess(b:bat[:any_1]):str ",
"BKCgetAccess;", "Return the access mode attached to this BAT as a
character." ]
[ "bat", "getCapacity", "command bat.getCapacity(b:bat[:any_1]):lng ",
"BKCgetCapacity;", "Returns the current allocation size (in max number of
elements) of a BAT." ]
@@ -6010,14 +6010,14 @@ Ready.
[ "batgeom", "YMinFromMBR", "function
batgeom.YMinFromMBR(b:bat[:mbr]):bat[:dbl];", "", "" ]
[ "batgeom", "YMinFromWKB", "function
batgeom.YMinFromWKB(g:bat[:wkb]):bat[:dbl];", "", "" ]
[ "batgeom", "Z", "function batgeom.Z(w:bat[:wkb]):bat[:dbl];", "",
"" ]
-[ "batgeom", "coordinateFromMBR", "command
batgeom.coordinateFromMBR(X_0:bat[:mbr],X_1:int):bat[:dbl] ",
"wkbCoordinateFromMBR_bat;", "returns xmin (=1), ymin (=2), xmax (=3) or
ymax(=4) of the provided mbr" ]
-[ "batgeom", "coordinateFromWKB", "command
batgeom.coordinateFromWKB(X_0:bat[:wkb],X_1:int):bat[:dbl] ",
"wkbCoordinateFromWKB_bat;", "returns xmin (=1), ymin (=2), xmax (=3) or
ymax(=4) of the provided geometry" ]
+[ "batgeom", "coordinateFromMBR", "command
batgeom.coordinateFromMBR(X_0:bat[:mbr], X_1:int):bat[:dbl] ",
"wkbCoordinateFromMBR_bat;", "returns xmin (=1), ymin (=2), xmax (=3) or
ymax(=4) of the provided mbr" ]
+[ "batgeom", "coordinateFromWKB", "command
batgeom.coordinateFromWKB(X_0:bat[:wkb], X_1:int):bat[:dbl] ",
"wkbCoordinateFromWKB_bat;", "returns xmin (=1), ymin (=2), xmax (=3) or
ymax(=4) of the provided geometry" ]
[ "batgeom", "mbr", "command batgeom.mbr(X_0:bat[:wkb]):bat[:mbr] ",
"wkbMBR_bat;", "Creates the mbr for the given wkb." ]
-[ "batgeom", "setSRID", "command
batgeom.setSRID(w:bat[:wkb],srid:int):bat[:wkb] ", "wkbSetSRID_bat;",
"Sets the Reference System ID for this Geometry." ]
-[ "batgsl", "chi2prob", "command
batgsl.chi2prob(d:bat[:dbl],i:bat[:dbl]):bat[:dbl] ", "GSLbat_chisqProb_bat;",
"Chi Squared probability" ]
-[ "batgsl", "chi2prob", "command
batgsl.chi2prob(d:bat[:dbl],i:dbl):bat[:dbl] ", "GSLbat_chisqProb_cst;",
"Chi Squared probability" ]
-[ "batgsl", "chi2prob", "command
batgsl.chi2prob(d:dbl,i:bat[:dbl]):bat[:dbl] ", "GSLcst_chisqProb_bat;",
"Chi Squared probability" ]
-[ "batmal", "multiplex", "pattern
batmal.multiplex(mod:str,fcn:str,a:any...):any... ",
"MANIFOLDremapMultiplex;", "" ]
+[ "batgeom", "setSRID", "command batgeom.setSRID(w:bat[:wkb],
srid:int):bat[:wkb] ", "wkbSetSRID_bat;", "Sets the Reference System ID
for this Geometry." ]
+[ "batgsl", "chi2prob", "command batgsl.chi2prob(d:bat[:dbl],
i:bat[:dbl]):bat[:dbl] ", "GSLbat_chisqProb_bat;", "Chi Squared
probability" ]
+[ "batgsl", "chi2prob", "command batgsl.chi2prob(d:bat[:dbl],
i:dbl):bat[:dbl] ", "GSLbat_chisqProb_cst;", "Chi Squared
probability" ]
+[ "batgsl", "chi2prob", "command batgsl.chi2prob(d:dbl,
i:bat[:dbl]):bat[:dbl] ", "GSLcst_chisqProb_bat;", "Chi Squared
probability" ]
+[ "batmal", "multiplex", "pattern batmal.multiplex(mod:str, fcn:str,
a:any...):any... ", "MANIFOLDremapMultiplex;", "" ]
[ "batmkey", "hash", "command batmkey.hash(b:bat[:any_1]):bat[:lng] ",
"MKEYbathash;", "calculate a hash value" ]
[ "batmmath", "acos", "command batmmath.acos(x:bat[:dbl]):bat[:dbl] ",
"CMDscience_bat_dbl_acos;", "" ]
[ "batmmath", "acos", "command batmmath.acos(x:bat[:flt]):bat[:flt] ",
"CMDscience_bat_flt_acos;", "" ]
@@ -6025,10 +6025,10 @@ Ready.
[ "batmmath", "asin", "command batmmath.asin(x:bat[:flt]):bat[:flt] ",
"CMDscience_bat_flt_asin;", "" ]
[ "batmmath", "atan", "command batmmath.atan(x:bat[:dbl]):bat[:dbl] ",
"CMDscience_bat_dbl_atan;", "" ]
[ "batmmath", "atan", "command batmmath.atan(x:bat[:flt]):bat[:flt] ",
"CMDscience_bat_flt_atan;", "" ]
-[ "batmmath", "atan2", "command
batmmath.atan2(x:bat[:dbl],y:dbl):bat[:dbl] ", "CMDscience_bat_cst_atan2_dbl;",
"" ]
-[ "batmmath", "atan2", "command
batmmath.atan2(x:bat[:flt],y:flt):bat[:flt] ", "CMDscience_bat_cst_atan2_flt;",
"" ]
-[ "batmmath", "atan2", "command
batmmath.atan2(x:dbl,y:bat[:dbl]):bat[:dbl] ", "CMDscience_cst_bat_atan2_dbl;",
"" ]
-[ "batmmath", "atan2", "command
batmmath.atan2(x:flt,y:bat[:flt]):bat[:flt] ", "CMDscience_cst_bat_atan2_flt;",
"" ]
+[ "batmmath", "atan2", "command batmmath.atan2(x:bat[:dbl],
y:dbl):bat[:dbl] ", "CMDscience_bat_cst_atan2_dbl;", "" ]
+[ "batmmath", "atan2", "command batmmath.atan2(x:bat[:flt],
y:flt):bat[:flt] ", "CMDscience_bat_cst_atan2_flt;", "" ]
+[ "batmmath", "atan2", "command batmmath.atan2(x:dbl,
y:bat[:dbl]):bat[:dbl] ", "CMDscience_cst_bat_atan2_dbl;", ""
]
+[ "batmmath", "atan2", "command batmmath.atan2(x:flt,
y:bat[:flt]):bat[:flt] ", "CMDscience_cst_bat_atan2_flt;", ""
]
[ "batmmath", "cbrt", "command batmmath.cbrt(x:bat[:dbl]):bat[:dbl] ",
"CMDscience_bat_dbl_cbrt;", "" ]
[ "batmmath", "cbrt", "command batmmath.cbrt(x:bat[:flt]):bat[:flt] ",
"CMDscience_bat_flt_cbrt;", "" ]
[ "batmmath", "ceil", "command batmmath.ceil(x:bat[:dbl]):bat[:dbl] ",
"CMDscience_bat_dbl_ceil;", "" ]
@@ -6045,16 +6045,16 @@ Ready.
[ "batmmath", "fabs", "command batmmath.fabs(x:bat[:flt]):bat[:flt] ",
"CMDscience_bat_flt_fabs;", "" ]
[ "batmmath", "floor", "command batmmath.floor(x:bat[:dbl]):bat[:dbl]
", "CMDscience_bat_dbl_floor;", "" ]
[ "batmmath", "floor", "command batmmath.floor(x:bat[:flt]):bat[:flt]
", "CMDscience_bat_flt_floor;", "" ]
-[ "batmmath", "fmod", "pattern batmmath.fmod(x:bat[:dbl],y:dbl):bat[:dbl] ",
"CMDbatMODsignal;", "" ]
-[ "batmmath", "fmod", "pattern batmmath.fmod(x:bat[:flt],y:flt):bat[:flt] ",
"CMDbatMODsignal;", "" ]
+[ "batmmath", "fmod", "pattern batmmath.fmod(x:bat[:dbl], y:dbl):bat[:dbl] ",
"CMDbatMODsignal;", "" ]
+[ "batmmath", "fmod", "pattern batmmath.fmod(x:bat[:flt], y:flt):bat[:flt] ",
"CMDbatMODsignal;", "" ]
[ "batmmath", "log", "command batmmath.log(x:bat[:dbl]):bat[:dbl] ",
"CMDscience_bat_dbl_log;", "" ]
[ "batmmath", "log", "command batmmath.log(x:bat[:flt]):bat[:flt] ",
"CMDscience_bat_flt_log;", "" ]
[ "batmmath", "log10", "command batmmath.log10(x:bat[:dbl]):bat[:dbl]
", "CMDscience_bat_dbl_log10;", "" ]
[ "batmmath", "log10", "command batmmath.log10(x:bat[:flt]):bat[:flt]
", "CMDscience_bat_flt_log10;", "" ]
-[ "batmmath", "pow", "command batmmath.pow(x:bat[:dbl],y:dbl):bat[:dbl] ",
"CMDscience_bat_cst_pow_dbl;", "" ]
-[ "batmmath", "pow", "command batmmath.pow(x:bat[:flt],y:flt):bat[:flt] ",
"CMDscience_bat_cst_pow_flt;", "" ]
-[ "batmmath", "pow", "command batmmath.pow(x:dbl,y:bat[:dbl]):bat[:dbl] ",
"CMDscience_cst_bat_pow_dbl;", "" ]
-[ "batmmath", "pow", "command batmmath.pow(x:flt,y:bat[:flt]):bat[:flt] ",
"CMDscience_cst_bat_pow_flt;", "" ]
+[ "batmmath", "pow", "command batmmath.pow(x:bat[:dbl], y:dbl):bat[:dbl] ",
"CMDscience_bat_cst_pow_dbl;", "" ]
+[ "batmmath", "pow", "command batmmath.pow(x:bat[:flt], y:flt):bat[:flt] ",
"CMDscience_bat_cst_pow_flt;", "" ]
+[ "batmmath", "pow", "command batmmath.pow(x:dbl, y:bat[:dbl]):bat[:dbl] ",
"CMDscience_cst_bat_pow_dbl;", "" ]
+[ "batmmath", "pow", "command batmmath.pow(x:flt, y:bat[:flt]):bat[:flt] ",
"CMDscience_cst_bat_pow_flt;", "" ]
[ "batmmath", "radians", "command
batmmath.radians(x:bat[:dbl]):bat[:dbl] ", "CMDscience_bat_dbl_radians;",
"" ]
[ "batmmath", "radians", "command
batmmath.radians(x:bat[:flt]):bat[:flt] ", "CMDscience_bat_flt_radians;",
"" ]
[ "batmmath", "sin", "command batmmath.sin(x:bat[:dbl]):bat[:dbl] ",
"CMDscience_bat_dbl_sin;", "" ]
@@ -6068,8 +6068,8 @@ Ready.
[ "batmmath", "tanh", "command batmmath.tanh(x:bat[:dbl]):bat[:dbl] ",
"CMDscience_bat_dbl_tanh;", "" ]
[ "batmmath", "tanh", "command batmmath.tanh(x:bat[:flt]):bat[:flt] ",
"CMDscience_bat_flt_tanh;", "" ]
[ "batmtime", "day", "command batmtime.day(d:bat[:date]):bat[:int] ",
"MTIMEdate_extract_day_bulk;", "" ]
-[ "batmtime", "diff", "command
batmtime.diff(b1:bat[:date],b2:bat[:date]):bat[:int] ",
"MTIMEdate_diff_bulk;", "Difference of two sets of date." ]
-[ "batmtime", "diff", "command
batmtime.diff(b1:bat[:timestamp],b2:bat[:timestamp]):bat[:lng] ",
"MTIMEtimestamp_diff_bulk;", "Difference of two sets of timestamp." ]
+[ "batmtime", "diff", "command batmtime.diff(b1:bat[:date],
b2:bat[:date]):bat[:int] ", "MTIMEdate_diff_bulk;", "Difference of two
sets of date." ]
+[ "batmtime", "diff", "command batmtime.diff(b1:bat[:timestamp],
b2:bat[:timestamp]):bat[:lng] ", "MTIMEtimestamp_diff_bulk;",
"Difference of two sets of timestamp." ]
[ "batmtime", "hours", "command
batmtime.hours(d:bat[:daytime]):bat[:int] ",
"MTIMEdaytime_extract_hours_bulk;", "" ]
[ "batmtime", "milliseconds", "command
batmtime.milliseconds(d:bat[:daytime]):bat[:int] ",
"MTIMEdaytime_extract_milliseconds_bulk;", "" ]
[ "batmtime", "minutes", "command
batmtime.minutes(d:bat[:daytime]):bat[:int] ",
"MTIMEdaytime_extract_minutes_bulk;", "" ]
@@ -6186,7 +6186,7 @@ Ready.
[ "bbp", "getRefCount", "command bbp.getRefCount():bat[:int] ",
"CMDbbpRefCount;", "Create a BAT with the (hard) reference counts" ]
[ "bbp", "getRefCount", "command bbp.getRefCount(b:bat[:any_1]):int ",
"CMDgetBATrefcnt;", "Utility for debugging MAL interpreter" ]
[ "bbp", "getStatus", "command bbp.getStatus():bat[:str] ",
"CMDbbpStatus;", "Create a BAT with the disk/load status" ]
-[ "bbp", "setName", "command bbp.setName(b:bat[:any_1],n:str):str
", "CMDsetName;", "Rename a BAT" ]
+[ "bbp", "setName", "command bbp.setName(b:bat[:any_1], n:str):str
", "CMDsetName;", "Rename a BAT" ]
[ "blob", "#del", "command blob.#del():void ", "BLOBdel;", ""
]
[ "blob", "#fromstr", "command blob.#fromstr():void ",
"BLOBfromstr;", "" ]
[ "blob", "#hash", "command blob.#hash():void ", "BLOBhash;",
"" ]
@@ -6942,14 +6942,14 @@ Ready.
[ "calc", "daytime", "command calc.daytime(s:str):daytime ",
"MTIMEdaytime_fromstr;", "" ]
[ "calc", "daytime", "command calc.daytime(s:lng):daytime ",
"MTIMEsecs2daytime;", "" ]
[ "calc", "daytime", "command calc.daytime(t:timestamp):daytime ",
"MTIMEtimestamp_extract_daytime_default;", "" ]
-[ "calc", "daytime", "command
calc.daytime(v:daytime,digits:int):daytime ", "daytime_2time_daytime;",
"cast daytime to daytime and check for overflow" ]
+[ "calc", "daytime", "command calc.daytime(v:daytime,
digits:int):daytime ", "daytime_2time_daytime;", "cast daytime to daytime
and check for overflow" ]
[ "calc", "daytime", "command calc.daytime(v:void):daytime ",
"nil_2_daytime;", "Cast to daytime" ]
-[ "calc", "daytime", "command
calc.daytime(v:void,digits:int):daytime ", "nil_2time_daytime;", "cast to
daytime and check for overflow" ]
-[ "calc", "daytime", "command calc.daytime(v:lng,d:int):daytime ",
"second_interval_2_daytime;", "cast second_interval to a daytime and check
for overflow" ]
+[ "calc", "daytime", "command calc.daytime(v:void,
digits:int):daytime ", "nil_2time_daytime;", "cast to daytime and check
for overflow" ]
+[ "calc", "daytime", "command calc.daytime(v:lng, d:int):daytime ",
"second_interval_2_daytime;", "cast second_interval to a daytime and check
for overflow" ]
[ "calc", "daytime", "command calc.daytime(v:str):daytime ",
"str_2_daytime;", "Cast to daytime" ]
-[ "calc", "daytime", "command calc.daytime(v:str,digits:int):daytime
", "str_2time_daytime;", "cast to daytime and check for overflow"
]
-[ "calc", "daytime", "command
calc.daytime(v:str,digits:int,has_tz:int):daytime ", "str_2time_daytimetz;",
"cast to daytime and check for overflow" ]
-[ "calc", "daytime", "command
calc.daytime(v:timestamp,d:int):daytime ", "timestamp_2_daytime;", "cast
timestamp to a daytime and check for overflow" ]
+[ "calc", "daytime", "command calc.daytime(v:str,
digits:int):daytime ", "str_2time_daytime;", "cast to daytime and check
for overflow" ]
+[ "calc", "daytime", "command calc.daytime(v:str, digits:int,
has_tz:int):daytime ", "str_2time_daytimetz;", "cast to daytime and check for
overflow" ]
+[ "calc", "daytime", "command calc.daytime(v:timestamp,
d:int):daytime ", "timestamp_2_daytime;", "cast timestamp to a daytime and
check for overflow" ]
[ "calc", "dbl", "pattern calc.dbl(v:bit):dbl ", "CMDvarCONVERT;",
"Cast VALUE to dbl" ]
[ "calc", "dbl", "pattern calc.dbl(v:bte):dbl ", "CMDvarCONVERT;",
"Cast VALUE to dbl" ]
[ "calc", "dbl", "pattern calc.dbl(v:dbl):dbl ", "CMDvarCONVERT;",
"Cast VALUE to dbl" ]
@@ -7401,15 +7401,15 @@ Ready.
[ "clients", "removeUser", "pattern clients.removeUser(nme:str):void ",
"CLTremoveUser;", "Remove the given user from the system" ]
[ "clients", "ripemd160sum", "command clients.ripemd160sum(pw:str):str ",
"CLTripemd160sum;", "Return hex string representation of the RIPEMD160 hash
of the given string" ]
[ "clients", "setListing", "pattern clients.setListing(flag:int):int ",
"CLTsetListing;", "Turn on/off echo of MAL instructions:\n\t1 - echo
input,\n\t2 - show mal instruction,\n\t4 - show details of type resolutoin,
\n\t8 - show binding information." ]
-[ "clients", "setPassword", "pattern
clients.setPassword(user:str,pass:str):void ", "CLTsetPassword;", "Set the
password for the given user" ]
+[ "clients", "setPassword", "pattern clients.setPassword(user:str,
pass:str):void ", "CLTsetPassword;", "Set the password for the
given user" ]
[ "clients", "setScenario", "pattern clients.setScenario(msg:str):str ",
"CLTsetScenario;", "Switch to other scenario handler, return previous
one." ]
[ "clients", "setsession", "pattern clients.setsession(n:lng):void ",
"CLTsetSessionTimeout;", "Abort a session after n seconds." ]
[ "clients", "settimeout", "pattern clients.settimeout(n:lng):void ",
"CLTsetTimeout;", "Abort a query after n seconds." ]
-[ "clients", "settimeout", "pattern clients.settimeout(q:lng,s:lng):void
", "CLTsetTimeout;", "Abort a query after q seconds (q=0 means run
undisturbed).\nThe session timeout aborts the connection after spending
too\nmany seconds on query processing." ]
+[ "clients", "settimeout", "pattern clients.settimeout(q:lng, s:lng):void
", "CLTsetTimeout;", "Abort a query after q seconds (q=0 means run
undisturbed).\nThe session timeout aborts the connection after spending
too\nmany seconds on query processing." ]
[ "clients", "sha1sum", "command clients.sha1sum(pw:str):str ",
"CLTsha1sum;", "Return hex string representation of the SHA-1 hash of the
given string" ]
-[ "clients", "sha2sum", "command clients.sha2sum(pw:str,bits:int):str
", "CLTsha2sum;", "Return hex string representation of the SHA-2 hash
with bits of the given string" ]
+[ "clients", "sha2sum", "command clients.sha2sum(pw:str, bits:int):str
", "CLTsha2sum;", "Return hex string representation of the SHA-2 hash
with bits of the given string" ]
[ "clients", "shutdown", "pattern clients.shutdown(delay:int):str ",
"CLTshutdown;", "" ]
-[ "clients", "shutdown", "pattern
clients.shutdown(delay:int,forced:bit):str ", "CLTshutdown;", "Close all other
client connections. Return if it succeeds.\nIf forced is set then always stop
the system the hard way" ]
+[ "clients", "shutdown", "pattern clients.shutdown(delay:int,
forced:bit):str ", "CLTshutdown;", "Close all other client connections. Return
if it succeeds.\nIf forced is set then always stop the system the hard way" ]
[ "clients", "stop", "pattern clients.stop(id:int):void ", "CLTstop;",
"Stop the query execution at the next eligble statement." ]
[ "clients", "suspend", "pattern clients.suspend(id:int):void ",
"CLTsuspend;", "Put a client process to sleep for some time.\nIt will simple
sleep for a second at a time, until\nthe awake bit has been set in its
descriptor" ]
[ "clients", "wakeup", "command clients.wakeup(id:int):void ",
"CLTwakeup;", "Wakeup a client process" ]
@@ -7593,54 +7593,54 @@ Ready.
[ "geom", "IsValidReason", "command geom.IsValidReason(w:wkb):str
", "wkbIsValidReason;", "Returns text stating if a geometry is valid
or not and if not valid, a reason why." ]
[ "geom", "Length", "command geom.Length(w:wkb):dbl ",
"wkbLength;", "Returns the cartesian 2D length of the geometry if it is a
linestrin or multilinestring" ]
[ "geom", "LineFromText", "function geom.LineFromText(wkt:str):wkb;",
"", "" ]
-[ "geom", "LineFromText", "function
geom.LineFromText(wkt:str,srid:int):wkb;", "", "" ]
+[ "geom", "LineFromText", "function geom.LineFromText(wkt:str,
srid:int):wkb;", "", "" ]
[ "geom", "MLineFromText", "function
geom.MLineFromText(wkt:str):wkb;", "", "" ]
-[ "geom", "MLineFromText", "function
geom.MLineFromText(wkt:str,srid:int):wkb;", "", "" ]
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
