Changeset: f2a72ec2746a for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=f2a72ec2746a
Modified Files:
clients/Tests/MAL-signatures.stable.out
clients/Tests/MAL-signatures.stable.out.int128
monetdb5/mal/mal_parser.c
monetdb5/optimizer/Tests/inline06.stable.out
sql/backends/monet5/sql_execute.c
Branch: default
Log Message:
Merge with Aug2018 branch.
diffs (truncated from 687 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
@@ -512,13 +512,13 @@ Ready.
[ "aggr", "variancep", "command aggr.variancep(b:bat[:lng],
g:bat[:oid], e:bat[:any_1]):bat[:dbl] ", "AGGRvariancep3_dbl;", "Grouped
tail variance (population/biased) on lng" ]
[ "aggr", "variancep", "command aggr.variancep(b:bat[:sht],
g:bat[:oid], e:bat[:any_1]):bat[:dbl] ", "AGGRvariancep3_dbl;", "Grouped
tail variance (population/biased) on sht" ]
[ "aggr", "variancep", "command aggr.variancep(b:bat[:any_2]):dbl ",
"ALGvariancep;", "Gives the variance of all tail values" ]
-[ "alarm", "ctime", "command alarm.ctime():str ", "ALARMctime;",
"Return the current time as a C-time string." ]
+[ "alarm", "ctime", "unsafe command alarm.ctime():str ",
"ALARMctime;", "Return the current time as a C-time string." ]
[ "alarm", "epilogue", "command alarm.epilogue():void ",
"ALARMepilogue;", "Finalize alarm module." ]
-[ "alarm", "epoch", "command alarm.epoch():int ", "ALARMepoch;",
"Return the current time as UNIX epoch." ]
+[ "alarm", "epoch", "unsafe command alarm.epoch():int ",
"ALARMepoch;", "Return the current time as UNIX epoch." ]
[ "alarm", "prelude", "command alarm.prelude():void ",
"ALARMprelude;", "Initialize alarm module." ]
-[ "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." ]
+[ "alarm", "sleep", "unsafe command alarm.sleep(secs:int):void ",
"ALARMsleep;", "Sleep a few seconds" ]
+[ "alarm", "time", "unsafe command alarm.time():int ", "ALARMtime;",
"Return time in milliseconds." ]
+[ "alarm", "usec", "unsafe command alarm.usec():lng ", "ALARMusec;",
"Return time in microseconds." ]
[ "algebra", "antijoin", "function algebra.antijoin(l:bat[:any_1],
r:bat[:any_1], sl:bat[:oid], sr:bat[:oid], nil_matches:bit, estimate:lng)
(X_0:bat[:oid], X_1:bat[:oid]);", "", "" ]
[ "algebra", "bandjoin", "command algebra.bandjoin(l:bat[:any_1],
r:bat[:any_1], sl:bat[:oid], sr:bat[:oid], c1:any_1, c2:any_1, li:bit, hi:bit,
estimate:lng) (X_0:bat[:oid], X_1:bat[:oid]) ", "ALGbandjoin;", "Band join:
values in l and r match if r - c1 <[=] l <[=] r + c2" ]
[ "algebra", "copy", "command algebra.copy(b:bat[:any_1]):bat[:any_1] ",
"ALGcopy;", "Returns physical copy of a BAT." ]
@@ -8364,11 +8364,11 @@ Ready.
[ "batmtime", "year", "command batmtime.year(d:bat[:date]):bat[:int] ",
"MTIMEdate_extract_year_bulk;", "" ]
[ "batpcre", "replace", "command batpcre.replace(orig:bat[:str],
pat:str, repl:str, flag:str):bat[:str] ", "PCREreplace_bat_wrap;",
"" ]
[ "batpcre", "replace_first", "command
batpcre.replace_first(orig:bat[:str], pat:str, repl:str, flag:str):bat[:str] ",
"PCREreplacefirst_bat_wrap;", "" ]
-[ "batpyapi", "eval", "pattern batpyapi.eval(fptr:ptr, expr:str,
arg:any...):any... ", "PYAPI2PyAPIevalStd;", "Execute a simple Python
script value" ]
-[ "batpyapi", "eval_aggr", "pattern batpyapi.eval_aggr(fptr:ptr, expr:str,
arg:any...):any... ", "PYAPI2PyAPIevalAggr;", "grouped aggregates through
Python" ]
-[ "batpyapi", "eval_loader", "pattern batpyapi.eval_loader(fptr:ptr,
expr:str):any... ", "PYAPI2PyAPIevalLoader;", "loader functions
through Python" ]
-[ "batpyapi", "eval_loader", "pattern batpyapi.eval_loader(fptr:ptr,
expr:str, arg:any...):any... ", "PYAPI2PyAPIevalLoader;", "loader
functions through Python" ]
-[ "batpyapi", "subeval_aggr", "pattern batpyapi.subeval_aggr(fptr:ptr,
expr:str, arg:any...):any... ", "PYAPI2PyAPIevalAggr;", "grouped
aggregates through Python" ]
+[ "batpyapi", "eval", "unsafe pattern batpyapi.eval(fptr:ptr, expr:str,
arg:any...):any... ", "PYAPI2PyAPIevalStd;", "Execute a simple Python script
value" ]
+[ "batpyapi", "eval_aggr", "unsafe pattern batpyapi.eval_aggr(fptr:ptr,
expr:str, arg:any...):any... ", "PYAPI2PyAPIevalAggr;", "grouped aggregates
through Python" ]
+[ "batpyapi", "eval_loader", "unsafe pattern batpyapi.eval_loader(fptr:ptr,
expr:str):any... ", "PYAPI2PyAPIevalLoader;", "loader functions
through Python" ]
+[ "batpyapi", "eval_loader", "unsafe pattern batpyapi.eval_loader(fptr:ptr,
expr:str, arg:any...):any... ", "PYAPI2PyAPIevalLoader;", "loader
functions through Python" ]
+[ "batpyapi", "subeval_aggr", "unsafe pattern batpyapi.subeval_aggr(fptr:ptr,
expr:str, arg:any...):any... ", "PYAPI2PyAPIevalAggr;", "grouped aggregates
through Python" ]
[ "batpyapimap", "eval", "pattern batpyapimap.eval(fptr:ptr, expr:str,
arg:any...):any... ", "PYAPI2PyAPIevalStdMap;", "Execute a simple
Python script value" ]
[ "batpyapimap", "eval_aggr", "pattern
batpyapimap.eval_aggr(fptr:ptr, expr:str, arg:any...):any... ",
"PYAPI2PyAPIevalAggrMap;", "grouped aggregates through Python" ]
[ "batpyapimap", "subeval_aggr", "pattern
batpyapimap.subeval_aggr(fptr:ptr, expr:str, arg:any...):any... ",
"PYAPI2PyAPIevalAggrMap;", "grouped aggregates through Python" ]
@@ -8562,9 +8562,9 @@ Ready.
[ "blob", "toblob", "command blob.toblob(v:str):blob ",
"BLOBtoblob;", "store a string as a blob." ]
[ "blob", "tostring", "command blob.tostring(v:blob):str ",
"BLOBfromblob;", "get the bytes from blob as a string, till\n\tthe first
0 byte or the end of the blob" ]
[ "blob", "tostring", "command blob.tostring(v:blob, index:int):str
", "BLOBfromidx;", "get the bytes from blob as a string,\n\t starting at
byte 'index' till the first\n\t0 byte or the end of the blob." ]
-[ "bstream", "create", "command bstream.create(s:streams,
bufsize:int):bstream ", "bstream_create_wrapwrap;", "create a buffered
stream" ]
-[ "bstream", "destroy", "command bstream.destroy(s:bstream):void ",
"bstream_destroy_wrapwrap;", "destroy bstream" ]
-[ "bstream", "read", "command bstream.read(s:bstream, size:int):int ",
"bstream_read_wrapwrap;", "read at least size bytes into the buffer of s"
]
+[ "bstream", "create", "unsafe command bstream.create(s:streams,
bufsize:int):bstream ", "bstream_create_wrapwrap;", "create a
buffered stream" ]
+[ "bstream", "destroy", "unsafe command bstream.destroy(s:bstream):void
", "bstream_destroy_wrapwrap;", "destroy bstream" ]
+[ "bstream", "read", "unsafe command bstream.read(s:bstream, size:int):int
", "bstream_read_wrapwrap;", "read at least size bytes into the
buffer of s" ]
[ "calc", "!=", "pattern calc.!=(l:json, r:json):bit ", "CMDvarNE;",
"Return V1 != V2" ]
[ "calc", "!=", "pattern calc.!=(l:uuid, r:uuid):bit ", "CMDvarNE;",
"Return V1 != V2" ]
[ "calc", "!=", "pattern calc.!=(v1:bit, v2:bit):bit ", "CMDvarNE;",
"Return V1 != V2" ]
@@ -10505,20 +10505,20 @@ Ready.
[ "json", "unfold", "pattern json.unfold(val:json) (o:bat[:oid],
k:bat[:str], v:bat[:json]) ", "JSONunfold;", "Expands the outermost JSON
object into key-value pairs." ]
[ "json", "valuearray", "command json.valuearray(val:json):json ",
"JSONvalueArray;", "Expands the outermost JSON object values into a JSON
value array." ]
[ "json", "values", "command json.values(val:json):bat[:json] ",
"JSONvalueTable;", "Expands the outermost JSON values." ]
-[ "language", "assert", "command language.assert(v:bit, term:str):void
", "MALassertBit;", "" ]
-[ "language", "assert", "command language.assert(v:int, term:str):void
", "MALassertInt;", "" ]
-[ "language", "assert", "command language.assert(v:lng, term:str):void
", "MALassertLng;", "" ]
-[ "language", "assert", "command language.assert(v:oid, term:str):void
", "MALassertOid;", "" ]
-[ "language", "assert", "command language.assert(v:sht, term:str):void
", "MALassertSht;", "" ]
-[ "language", "assert", "command language.assert(v:str, term:str):void
", "MALassertStr;", "" ]
-[ "language", "assert", "pattern language.assert(v:any_1, pname:str,
oper:str, val:any_2):void ", "MALassertTriple;", "Assertion test."
]
+[ "language", "assert", "unsafe command language.assert(v:bit,
term:str):void ", "MALassertBit;", "" ]
+[ "language", "assert", "unsafe command language.assert(v:int,
term:str):void ", "MALassertInt;", "" ]
+[ "language", "assert", "unsafe command language.assert(v:lng,
term:str):void ", "MALassertLng;", "" ]
+[ "language", "assert", "unsafe command language.assert(v:oid,
term:str):void ", "MALassertOid;", "" ]
+[ "language", "assert", "unsafe command language.assert(v:sht,
term:str):void ", "MALassertSht;", "" ]
+[ "language", "assert", "unsafe command language.assert(v:str,
term:str):void ", "MALassertStr;", "" ]
+[ "language", "assert", "unsafe pattern language.assert(v:any_1,
pname:str, oper:str, val:any_2):void ", "MALassertTriple;",
"Assertion test." ]
[ "language", "block", "pattern language.block(v:int, w:any...):int ",
"deblockdataflow;", "Block on availability of all variables w, and then
pass on v" ]
[ "language", "call", "pattern language.call(s:bat[:str]):void ",
"CMDcallBAT;", "Evaluate a program stored in a BAT." ]
[ "language", "call", "pattern language.call(m:str, f:str):void ",
"CMDcallFunction;", "" ]
[ "language", "call", "pattern language.call(s:str):void ",
"CMDcallString;", "Evaluate a MAL string program." ]
[ "language", "dataflow", "pattern language.dataflow():bit ",
"MALstartDataflow;", "The current guarded block is executed using dataflow
control. " ]
[ "language", "pass", "pattern language.pass(v:any_1):void ", "MALpass;",
"Cheap instruction to disgard storage while retaining the dataflow dependency"
]
-[ "language", "raise", "command language.raise(msg:str):str ",
"CMDraise;", "Raise an exception labeled \n\twith a specific message."
]
+[ "language", "raise", "unsafe command language.raise(msg:str):str ",
"CMDraise;", "Raise an exception labeled \n\twith a specific message."
]
[ "language", "register", "pattern language.register(m:str, f:str,
code:str, help:str):void ", "CMDregisterFunction;", "Compile the code string
to MAL and register it as a function." ]
[ "language", "sink", "pattern language.sink(v:any...):void ",
"MALgarbagesink;", "Variables to be considered together when triggering
garbage collection.\nUsed in the dataflow blocks to avoid early release of
values." ]
[ "language", "source", "pattern language.source(f:str):void ",
"CMDevalFile;", "Merge the instructions stored in the file with the current
program." ]
@@ -10673,8 +10673,8 @@ Ready.
[ "mmath", "pow", "command mmath.pow(x:flt, y:flt):flt ",
"MATHbinary_POWflt;", "" ]
[ "mmath", "radians", "command mmath.radians(x:dbl):dbl ",
"MATHunary_RADIANSdbl;", "The radians() function converts degrees into
radians" ]
[ "mmath", "radians", "command mmath.radians(x:flt):flt ",
"MATHunary_RADIANSflt;", "" ]
-[ "mmath", "rand", "command mmath.rand():int ", "MATHrandint;", "return
a random number" ]
-[ "mmath", "rand", "command mmath.rand(v:int):int ",
"MATHrandintarg;", "return a random number" ]
+[ "mmath", "rand", "unsafe command mmath.rand():int ", "MATHrandint;",
"return a random number" ]
+[ "mmath", "rand", "unsafe command mmath.rand(v:int):int ",
"MATHrandintarg;", "return a random number" ]
[ "mmath", "round", "command mmath.round(x:dbl, y:int):dbl ",
"MATHbinary_ROUNDdbl;", "The round(n, m) returns n rounded to m places to the
right \n of the decimal point; if m is omitted, to 0 places. m can be
\n\tnegative to round off digits left of the decimal point. \n m must be
an integer." ]
[ "mmath", "round", "command mmath.round(x:flt, y:int):flt ",
"MATHbinary_ROUNDflt;", "" ]
[ "mmath", "sin", "command mmath.sin(x:dbl):dbl ",
"MATHunary_SINdbl;", "The sin(x) function returns the cosine of x, where x
is given in \n radians. The return value is between -1 and 1." ]
@@ -10750,7 +10750,7 @@ Ready.
[ "mtime", "month", "command mtime.month(t:timestamp):int ",
"MTIMEtimestamp_month;", "" ]
[ "mtime", "monthname", "command mtime.monthname(month:int):str ",
"MTIMEmonth_to_str;", "Returns month name from a number\n\tbetween [1-12],
str(nil) otherwise." ]
[ "mtime", "monthnum", "command mtime.monthnum(month:str):int ",
"MTIMEmonth_from_str;", "Returns month number [1-12] from a string\n\t or nil
if does not match any." ]
-[ "mtime", "msec", "command mtime.msec():lng ", "MTIMEmsec;", "get
time of day in msec since 1-1-1970." ]
+[ "mtime", "msec", "unsafe command mtime.msec():lng ", "MTIMEmsec;",
"get time of day in msec since 1-1-1970." ]
[ "mtime", "msecs", "command mtime.msecs(d:int, h:int, m:int,
s:int, ms:int):lng ", "MTIMEmsecs;", "convert date components to milliseconds"
]
[ "mtime", "prelude", "command mtime.prelude():void ",
"MTIMEprelude;", "" ]
[ "mtime", "quarter", "command mtime.quarter(d:date):int ",
"MTIMEdate_extract_quarter;", "extracts quarter from date" ]
@@ -10798,14 +10798,14 @@ Ready.
[ "netcdf", "importvar", "command netcdf.importvar(filename:str,
varid:int):str ", "NCDFimportVarStmt;", "Import variable: compose
create array string" ]
[ "netcdf", "importvariable", "pattern
netcdf.importvariable(fileid:int, varname:str):void ", "NCDFimportVariable;",
"Import variable: create array and load data from variable varname of file
fileid" ]
[ "netcdf", "test", "command netcdf.test(filename:str):int ",
"NCDFtest;", "Returns number of variables in a given NetCDF dataset (file)"
]
-[ "oltp", "disable", "pattern oltp.disable():void ", "OLTPdisable;",
"Disable the OLTP delay monitor" ]
-[ "oltp", "enable", "pattern oltp.enable():void ", "OLTPenable;",
"Enable the OLTP delay monitor" ]
-[ "oltp", "init", "pattern oltp.init():void ", "OLTPinit;",
"Initialize the lock table" ]
-[ "oltp", "isenabled", "command oltp.isenabled():int ",
"OLTPis_enabled;", "Query the OLTP state" ]
-[ "oltp", "lock", "pattern oltp.lock(lck:int...):void ", "OLTPlock;",
"Wait for all write locks needed" ]
-[ "oltp", "release", "pattern oltp.release(lck:int...):void ",
"OLTPrelease;", "Release for all write locks needed" ]
-[ "oltp", "reset", "pattern oltp.reset():void ", "OLTPreset;",
"Reset the OLTP lock table" ]
-[ "oltp", "table", "pattern oltp.table() (start:bat[:timestamp],
usr:bat[:str], unit:bat[:int], cnt:bat[:int]) ", "OLTPtable;", "Show status
of lock table" ]
+[ "oltp", "disable", "unsafe pattern oltp.disable():void ",
"OLTPdisable;", "Disable the OLTP delay monitor" ]
+[ "oltp", "enable", "unsafe pattern oltp.enable():void ",
"OLTPenable;", "Enable the OLTP delay monitor" ]
+[ "oltp", "init", "unsafe pattern oltp.init():void ", "OLTPinit;",
"Initialize the lock table" ]
+[ "oltp", "isenabled", "unsafe command oltp.isenabled():int ",
"OLTPis_enabled;", "Query the OLTP state" ]
+[ "oltp", "lock", "unsafe pattern oltp.lock(lck:int...):void ",
"OLTPlock;", "Wait for all write locks needed" ]
+[ "oltp", "release", "unsafe pattern oltp.release(lck:int...):void
", "OLTPrelease;", "Release for all write locks needed" ]
+[ "oltp", "reset", "unsafe pattern oltp.reset():void ",
"OLTPreset;", "Reset the OLTP lock table" ]
+[ "oltp", "table", "unsafe pattern oltp.table()
(start:bat[:timestamp], usr:bat[:str], unit:bat[:int], cnt:bat[:int]) ",
"OLTPtable;", "Show status of lock table" ]
[ "optimizer", "aliases", "pattern optimizer.aliases():str ",
"OPTwrapper;", "" ]
[ "optimizer", "aliases", "pattern optimizer.aliases(mod:str,
fcn:str):str ", "OPTwrapper;", "Alias removal optimizer" ]
[ "optimizer", "candidates", "pattern optimizer.candidates():str ",
"OPTwrapper;", "" ]
@@ -10910,13 +10910,13 @@ Ready.
[ "profiler", "stop", "pattern profiler.stop():void ",
"CMDstopProfiler;", "Stop offline performance profiling" ]
[ "profiler", "stoptrace", "command profiler.stoptrace():void ",
"CMDstopTrace;", "Stop collecting trace information" ]
[ "profiler", "stoptrace", "command profiler.stoptrace(path:str):void ",
"CMDstopTracePath;", "Stop collecting trace information" ]
-[ "pyapi", "eval", "pattern pyapi.eval(fptr:ptr, expr:str):any ",
"PYAPI2PyAPIevalStd;", "Execute a simple Python script returning a single
value" ]
-[ "pyapi", "eval", "pattern pyapi.eval(fptr:ptr, expr:str,
arg:any...):any... ", "PYAPI2PyAPIevalStd;", "Execute a simple Python script
value" ]
-[ "pyapi", "eval_aggr", "pattern pyapi.eval_aggr(fptr:ptr, expr:str,
arg:any...):any... ", "PYAPI2PyAPIevalAggr;", "grouped aggregates through
Python" ]
-[ "pyapi", "eval_loader", "pattern pyapi.eval_loader(fptr:ptr,
expr:str):any... ", "PYAPI2PyAPIevalLoader;", "loader functions
through Python" ]
-[ "pyapi", "eval_loader", "pattern pyapi.eval_loader(fptr:ptr, expr:str,
arg:any...):any... ", "PYAPI2PyAPIevalLoader;", "loader functions
through Python" ]
+[ "pyapi", "eval", "unsafe pattern pyapi.eval(fptr:ptr, expr:str):any ",
"PYAPI2PyAPIevalStd;", "Execute a simple Python script returning a single
value" ]
+[ "pyapi", "eval", "unsafe pattern pyapi.eval(fptr:ptr, expr:str,
arg:any...):any... ", "PYAPI2PyAPIevalStd;", "Execute a simple Python
script value" ]
+[ "pyapi", "eval_aggr", "unsafe pattern pyapi.eval_aggr(fptr:ptr,
expr:str, arg:any...):any... ", "PYAPI2PyAPIevalAggr;", "grouped
aggregates through Python" ]
+[ "pyapi", "eval_loader", "unsafe pattern pyapi.eval_loader(fptr:ptr,
expr:str):any... ", "PYAPI2PyAPIevalLoader;", "loader functions through
Python" ]
+[ "pyapi", "eval_loader", "unsafe pattern pyapi.eval_loader(fptr:ptr,
expr:str, arg:any...):any... ", "PYAPI2PyAPIevalLoader;", "loader
functions through Python" ]
[ "pyapi", "prelude", "command pyapi.prelude():void ",
"PYAPI2PyAPIprelude;", "" ]
-[ "pyapi", "subeval_aggr", "pattern pyapi.subeval_aggr(fptr:ptr, expr:str,
arg:any...):any... ", "PYAPI2PyAPIevalAggr;", "grouped aggregates through
Python" ]
+[ "pyapi", "subeval_aggr", "unsafe pattern pyapi.subeval_aggr(fptr:ptr,
expr:str, arg:any...):any... ", "PYAPI2PyAPIevalAggr;", "grouped aggregates
through Python" ]
[ "pyapimap", "eval", "pattern pyapimap.eval(fptr:ptr, expr:str):any ",
"PYAPI2PyAPIevalStdMap;", "Execute a simple Python script returning a
single value" ]
[ "pyapimap", "eval", "pattern pyapimap.eval(fptr:ptr, expr:str,
arg:any...):any... ", "PYAPI2PyAPIevalStdMap;", "Execute a simple
Python script value" ]
[ "pyapimap", "eval_aggr", "pattern pyapimap.eval_aggr(fptr:ptr, expr:str,
arg:any...):any... ", "PYAPI2PyAPIevalAggrMap;", "grouped aggregates
through Python" ]
@@ -10970,7 +10970,7 @@ Ready.
[ "shp", "import", "pattern shp.import(fileid:int):void ",
"SHPimport;", "Import an ESRI Shapefile with given id into the vault" ]
[ "shp", "import", "pattern shp.import(fileid:int, po:wkb):void ",
"SHPpartialimport;", "Partially import an ESRI Shapefile with given id into
the vault" ]
[ "sql", "abort", "pattern sql.abort():void ", "SQLabort;",
"Trigger the abort operation for a MAL block" ]
-[ "sql", "affectedRows", "pattern sql.affectedRows(mvc:int, nr:lng):int
", "mvc_affected_rows_wrap;", "export the number of affected rows by
the current query" ]
+[ "sql", "affectedRows", "unsafe pattern sql.affectedRows(mvc:int,
nr:lng):int ", "mvc_affected_rows_wrap;", "export the number of
affected rows by the current query" ]
[ "sql", "all", "inline function sql.all(b:bat[:any_1], gp:bat[:oid],
gpe:bat[:oid], no_nil:bit):bat[:any_1];", "", "" ]
[ "sql", "all", "command sql.all(col:bat[:any_1]):any_1 ",
"SQLall;", "if col contains exactly one value return this. Incase of more
raise an exception else return nil" ]
[ "sql", "alpha", "command sql.alpha(dec:dbl, theta:dbl):dbl ",
"SQLcst_alpha_cst;", "Implementation of astronomy alpha function: expands
the radius theta depending on the declination" ]
@@ -10998,9 +10998,9 @@ Ready.
[ "sql", "bind_idxbat", "pattern sql.bind_idxbat(mvc:int, schema:str,
table:str, index:str, access:int):bat[:any_1] ", "mvc_bind_idxbat_wrap;",
"Bind the 'schema.table.index' BAT with access kind:\n\t0 - base table\n\t1 -
inserts\n\t2 - updates" ]
[ "sql", "bind_idxbat", "pattern sql.bind_idxbat(mvc:int, schema:str,
table:str, index:str, access:int, part_nr:int, nr_parts:int) (uid:bat[:oid],
uval:bat[:any_1]) ", "mvc_bind_idxbat_wrap;", "Bind the
'schema.table.index' BAT with access kind:\n\t0 - base table\n\t1 -
inserts\n\t2 - updates" ]
[ "sql", "bind_idxbat", "pattern sql.bind_idxbat(mvc:int, schema:str,
table:str, index:str, access:int, part_nr:int, nr_parts:int):bat[:any_1] ",
"mvc_bind_idxbat_wrap;", "Bind the 'schema.table.index' BAT with
access kind:\n\t0 - base table\n\t1 - inserts\n\t2 - updates" ]
-[ "sql", "clear_table", "pattern sql.clear_table(sname:str,
tname:str):lng ", "mvc_clear_table_wrap;", "Clear the table
sname.tname." ]
+[ "sql", "clear_table", "unsafe pattern sql.clear_table(sname:str,
tname:str):lng ", "mvc_clear_table_wrap;", "Clear the table
sname.tname." ]
[ "sql", "commit", "pattern sql.commit():void ", "SQLcommit;",
"Trigger the commit operation for a MAL block" ]
-[ "sql", "copy_from", "pattern sql.copy_from(t:ptr, sep:str,
rsep:str, ssep:str, ns:str, fname:str, nr:lng, offset:lng, locked:int,
best:int, fwf:str, onclient:int):bat[:any]... ", "mvc_import_table_wrap;",
"Import a table from bstream s with the \n\tgiven tuple and seperators
(sep/rsep)" ]
+[ "sql", "copy_from", "unsafe pattern sql.copy_from(t:ptr, sep:str,
rsep:str, ssep:str, ns:str, fname:str, nr:lng, offset:lng, locked:int,
best:int, fwf:str, onclient:int):bat[:any]... ", "mvc_import_table_wrap;",
"Import a table from bstream s with the \n\tgiven tuple and seperators
(sep/rsep)" ]
[ "sql", "copy_rejects", "pattern sql.copy_rejects() (rowid:bat[:lng],
fldid:bat[:int], msg:bat[:str], inp:bat[:str]) ", "COPYrejects;", "" ]
[ "sql", "copy_rejects_clear", "pattern sql.copy_rejects_clear():void
", "COPYrejects_clear;", "" ]
[ "sql", "count", "pattern sql.count(b:any_1, ignils:bit, s:lng,
e:lng):lng ", "SQLcount;", "return count of groups" ]
@@ -11015,7 +11015,7 @@ Ready.
[ "sql", "dec_round", "command sql.dec_round(v:int, r:int):int ",
"int_dec_round_wrap;", "round off the value v to nearests multiple of r"
]
[ "sql", "dec_round", "command sql.dec_round(v:lng, r:lng):lng ",
"lng_dec_round_wrap;", "round off the value v to nearests multiple of r"
]
[ "sql", "dec_round", "command sql.dec_round(v:sht, r:sht):sht ",
"sht_dec_round_wrap;", "round off the value v to nearests multiple of r"
]
-[ "sql", "delete", "pattern sql.delete(mvc:int, sname:str,
tname:str, b:any):int ", "mvc_delete_wrap;", "Delete a row from a
table. Returns sequence number for order dependece." ]
+[ "sql", "delete", "unsafe pattern sql.delete(mvc:int, sname:str,
tname:str, b:any):int ", "mvc_delete_wrap;", "Delete a row from a table.
Returns sequence number for order dependece." ]
[ "sql", "delta", "command sql.delta(col:bat[:any_3],
uid:bat[:oid], uval:bat[:any_3]):bat[:any_3] ", "DELTAbat2;", "Return
column bat with delta's applied." ]
[ "sql", "delta", "command sql.delta(col:bat[:any_3],
uid:bat[:oid], uval:bat[:any_3], ins:bat[:any_3]):bat[:any_3] ",
"DELTAbat;", "Return column bat with delta's applied." ]
[ "sql", "dense_rank", "pattern sql.dense_rank(b:any_1, p:bit,
o:bit):int ", "SQLdense_rank;", "return the densely ranked groups"
]
@@ -11038,20 +11038,20 @@ Ready.
[ "sql", "eval", "pattern sql.eval(cmd:str):void ",
"SQLstatement;", "Compile and execute a single sql statement" ]
[ "sql", "eval", "pattern sql.eval(cmd:str, output:bit):void ",
"SQLstatement;", "Compile and execute a single sql statement (and
optionaly send output on the output stream)" ]
[ "sql", "evalAlgebra", "pattern sql.evalAlgebra(cmd:str,
optimize:bit):void ", "RAstatement;", "Compile and execute a single 'relational
algebra' statement" ]
-[ "sql", "exportChunk", "pattern sql.exportChunk(s:streams,
res_id:int):void ", "mvc_export_chunk_wrap;", "Export a chunk of the
result set (in order) to stream s" ]
-[ "sql", "exportChunk", "pattern sql.exportChunk(s:streams, res_id:int,
offset:int, nr:int):void ", "mvc_export_chunk_wrap;", "Export a chunk
of the result set (in order) to stream s" ]
-[ "sql", "exportHead", "pattern sql.exportHead(s:streams,
res_id:int):void ", "mvc_export_head_wrap;", "Export a result (in
order) to stream s" ]
-[ "sql", "exportOperation", "pattern sql.exportOperation():void ",
"mvc_export_operation_wrap;", "Export result of schema/transaction queries"
]
-[ "sql", "exportResult", "pattern sql.exportResult(s:streams,
res_id:int):void ", "mvc_export_result_wrap;", "Export a result (in
order) to stream s" ]
-[ "sql", "export_table", "pattern sql.export_table(fname:str, fmt:str,
colsep:str, recsep:str, qout:str, nullrep:str, onclient:int, tbl:bat[:str],
attr:bat[:str], tpe:bat[:str], len:bat[:int], scale:bat[:int], cols:any...):int
", "mvc_export_row_wrap;", "Prepare a table result set for the COPY INTO
stream" ]
-[ "sql", "export_table", "pattern sql.export_table(fname:str, fmt:str,
colsep:str, recsep:str, qout:str, nullrep:str, onclient:int, tbl:bat[:str],
attr:bat[:str], tpe:bat[:str], len:bat[:int], scale:bat[:int],
cols:bat[:any]...):int ", "mvc_export_table_wrap;", "Prepare a table
result set for the COPY INTO stream" ]
+[ "sql", "exportChunk", "unsafe pattern sql.exportChunk(s:streams,
res_id:int):void ", "mvc_export_chunk_wrap;", "Export a chunk of the
result set (in order) to stream s" ]
+[ "sql", "exportChunk", "unsafe pattern sql.exportChunk(s:streams,
res_id:int, offset:int, nr:int):void ", "mvc_export_chunk_wrap;",
"Export a chunk of the result set (in order) to stream s" ]
+[ "sql", "exportHead", "unsafe pattern sql.exportHead(s:streams,
res_id:int):void ", "mvc_export_head_wrap;", "Export a result (in
order) to stream s" ]
+[ "sql", "exportOperation", "unsafe pattern
sql.exportOperation():void ", "mvc_export_operation_wrap;", "Export result
of schema/transaction queries" ]
+[ "sql", "exportResult", "unsafe pattern sql.exportResult(s:streams,
res_id:int):void ", "mvc_export_result_wrap;", "Export a result (in order)
to stream s" ]
+[ "sql", "export_table", "unsafe pattern sql.export_table(fname:str,
fmt:str, colsep:str, recsep:str, qout:str, nullrep:str, onclient:int,
tbl:bat[:str], attr:bat[:str], tpe:bat[:str], len:bat[:int], scale:bat[:int],
cols:any...):int ", "mvc_export_row_wrap;", "Prepare a table result set for
the COPY INTO stream" ]
+[ "sql", "export_table", "unsafe pattern sql.export_table(fname:str,
fmt:str, colsep:str, recsep:str, qout:str, nullrep:str, onclient:int,
tbl:bat[:str], attr:bat[:str], tpe:bat[:str], len:bat[:int], scale:bat[:int],
cols:bat[:any]...):int ", "mvc_export_table_wrap;", "Prepare a
table result set for the COPY INTO stream" ]
[ "sql", "first_value", "pattern sql.first_value(b:any_1, s:lng,
e:lng):any_1 ", "SQLfirst_value;", "return the first value of
groups" ]
[ "sql", "flush_log", "command sql.flush_log():void ",
"SQLflush_log;", "flush the log now" ]
[ "sql", "getVariable", "pattern sql.getVariable(mvc:int,
varname:str):any_1 ", "getVariable;", "Get the value of a session variable" ]
[ "sql", "getVersion", "command sql.getVersion(clientid:int):lng ",
"mvc_getVersion;", "Return the database version identifier for a client."
]
[ "sql", "get_value", "pattern sql.get_value(sname:str,
sequence:str):lng ", "mvc_get_value;", "return the current value of the
sequence" ]
[ "sql", "grow", "pattern sql.grow(tid:bat[:oid], X_0:any_1):int ",
"mvc_grow_wrap;", "Resize the tid column of a declared table." ]
-[ "sql", "importTable", "pattern sql.importTable(sname:str, tname:str,
onclient:int, fname:str...):bat[:any]... ", "mvc_bin_import_table_wrap;",
"Import a table from the files (fname)" ]
+[ "sql", "importTable", "unsafe pattern sql.importTable(sname:str,
tname:str, onclient:int, fname:str...):bat[:any]... ",
"mvc_bin_import_table_wrap;", "Import a table from the files (fname)" ]
[ "sql", "include", "pattern sql.include(fname:str):void ",
"SQLinclude;", "Compile and execute a sql statements on the file" ]
[ "sql", "init", "pattern sql.init():void ", "SQLinitEnvironment;",
"Initialize the environment for MAL" ]
[ "sql", "lag", "pattern sql.lag(b:any_1, l:any_2, d:any_1, p:any_3,
o:any_4):any_1 ", "SQLlag;", "return the value in the previous 'l' row in
the partition or 'd' if non existent" ]
@@ -11069,7 +11069,7 @@ Ready.
[ "sql", "lead", "pattern sql.lead(b:any_1, l:bat[:any_2],
d:bat[:any_1], p:any_3, o:any_4):any_1 ", "SQLlead;", "return the value
in the next 'l' row in the partition or 'd' if non existent" ]
[ "sql", "lead", "pattern sql.lead(b:any_1, l:bat[:any_2], p:any_3,
o:any_4):any_1 ", "SQLlead;", "return the value in the next 'l' row in
the partition or NULL if non existent" ]
[ "sql", "lead", "pattern sql.lead(b:any_1, p:any_3, o:any_4):any_1 ",
"SQLlead;", "return the value in the next row in the partition or NULL if
non existent" ]
-[ "sql", "logfile", "pattern sql.logfile(filename:str):void ",
"mvc_logfile;", "Enable/disable saving the sql statement traces" ]
+[ "sql", "logfile", "unsafe pattern sql.logfile(filename:str):void
", "mvc_logfile;", "Enable/disable saving the sql statement traces"
]
[ "sql", "max", "pattern sql.max(b:any_1, s:lng, e:lng):any_1 ",
"SQLmax;", "return the maximum of groups" ]
[ "sql", "min", "pattern sql.min(b:any_1, s:lng, e:lng):any_1 ",
"SQLmin;", "return the minimum of groups" ]
[ "sql", "ms_trunc", "command sql.ms_trunc(v:dbl, r:int):dbl ",
"dbl_trunc_wrap;", "truncate the floating point v to r digits behind the
dot (if r < 0, before the dot)" ]
@@ -11104,10 +11104,10 @@ Ready.
[ "sql", "querylog_enable", "command
sql.querylog_enable(thres:int):void ", "QLOGenableThreshold;", "" ]
[ "sql", "rank", "pattern sql.rank(b:any_1, p:bit, o:bit):int ",
"SQLrank;", "return the ranked groups" ]
[ "sql", "register", "pattern sql.register(mod:str, fname:str,
rel_stmt:str, sig:str):int ", "RAstatement2;", "Compile the relational
statement (rel_smt) and register it as mal function, mod.fname(signature)"
]
-[ "sql", "restart", "pattern sql.restart(sname:str, sequence:str,
start:lng):lng ", "mvc_restart_seq;", "restart the sequence with value
start" ]
-[ "sql", "resultSet", "pattern sql.resultSet(tbl:bat[:str],
attr:bat[:str], tpe:bat[:str], len:bat[:int], scale:bat[:int], cols:any...):int
", "mvc_row_result_wrap;", "Prepare a table result set for the client
front-end" ]
-[ "sql", "resultSet", "pattern sql.resultSet(tbl:str, attr:str,
tpe:str, len:int, scale:int, eclass:int, val:any):int ",
"mvc_scalar_value_wrap;", "Prepare a table result set for the client
front-end." ]
-[ "sql", "resultSet", "pattern sql.resultSet(tbl:bat[:str],
attr:bat[:str], tpe:bat[:str], len:bat[:int], scale:bat[:int],
cols:bat[:any]...):int ", "mvc_table_result_wrap;", "Prepare a table
result set for the client in default CSV format" ]
+[ "sql", "restart", "unsafe pattern sql.restart(sname:str,
sequence:str, start:lng):lng ", "mvc_restart_seq;", "restart the sequence
with value start" ]
+[ "sql", "resultSet", "unsafe pattern sql.resultSet(tbl:bat[:str],
attr:bat[:str], tpe:bat[:str], len:bat[:int], scale:bat[:int], cols:any...):int
", "mvc_row_result_wrap;", "Prepare a table result set for the client
front-end" ]
+[ "sql", "resultSet", "unsafe pattern sql.resultSet(tbl:str,
attr:str, tpe:str, len:int, scale:int, eclass:int, val:any):int ",
"mvc_scalar_value_wrap;", "Prepare a table result set for the client
front-end." ]
+[ "sql", "resultSet", "unsafe pattern sql.resultSet(tbl:bat[:str],
attr:bat[:str], tpe:bat[:str], len:bat[:int], scale:bat[:int],
cols:bat[:any]...):int ", "mvc_table_result_wrap;", "Prepare a table
result set for the client in default CSV format" ]
[ "sql", "reuse", "pattern sql.reuse(sch:str, tbl:str):void ",
"SQLreuse;", "Consolidate the deletion table over all columns reusing
deleted slots" ]
[ "sql", "round", "command sql.round(v:bte, d:int, s:int,
r:bte):bte ", "bte_round_wrap;", "round off the decimal v(d,s) to r
digits behind the dot (if r < 0, before the dot)" ]
[ "sql", "round", "command sql.round(v:dbl, r:bte):dbl ",
"dbl_round_wrap;", "round off the floating point v to r digits behind the
dot (if r < 0, before the dot)" ]
@@ -11157,8 +11157,8 @@ Ready.
[ "sql", "sysmon_stop", "pattern sql.sysmon_stop(tag:sht):void ",
"SYSMONstop;", "" ]
[ "sql", "tid", "pattern sql.tid(mvc:int, sname:str,
tname:str):bat[:oid] ", "SQLtid;", "Return a column with the valid
tuple identifiers associated with the table sname.tname." ]
[ "sql", "tid", "pattern sql.tid(mvc:int, sname:str, tname:str,
part_nr:int, nr_parts:int):bat[:oid] ", "SQLtid;", "Return the tables tid
column." ]
-[ "sql", "transaction", "pattern sql.transaction():void ",
"SQLtransaction2;", "Start an autocommit transaction" ]
-[ "sql", "transaction", "pattern sql.transaction():void ",
"SQLtransaction2;", "Start an autocommit transaction" ]
+[ "sql", "transaction", "unsafe pattern sql.transaction():void ",
"SQLtransaction2;", "Start an autocommit transaction" ]
+[ "sql", "transaction", "unsafe pattern sql.transaction():void ",
"SQLtransaction2;", "Start an autocommit transaction" ]
[ "sql", "transaction_begin", "pattern
sql.transaction_begin(chain:int, name:str):void ", "SQLtransaction_begin;",
"A transaction statement (type can be commit,release,rollback or start)"
]
[ "sql", "transaction_commit", "pattern
sql.transaction_commit(chain:int, name:str):void ",
"SQLtransaction_commit;", "A transaction statement (type can be
commit,release,rollback or start)" ]
[ "sql", "transaction_release", "pattern
sql.transaction_release(chain:int, name:str):void ",
"SQLtransaction_release;", "A transaction statement (type can be
commit,release,rollback or start)" ]
@@ -11283,17 +11283,17 @@ Ready.
[ "str", "trim", "command str.trim(s:str):str ", "STRStrip;", "Strip
whitespaces around a string." ]
[ "str", "unicode", "command str.unicode(wchar:int):str ",
"STRFromWChr;", "convert a unicode to a character." ]
[ "str", "unicodeAt", "command str.unicodeAt(s:str, index:int):int ",
"STRWChrAt;", "get a unicode character\n\t(as an int) from a string
position." ]
-[ "streams", "blocked", "command streams.blocked(s:streams):streams ",
"open_block_streamwrap;", "open a block based stream" ]
-[ "streams", "close", "command streams.close(s:streams):void ",
"mnstr_close_streamwrap;", "close and destroy the stream s" ]
-[ "streams", "flush", "command streams.flush(s:streams):void ",
"mnstr_flush_streamwrap;", "flush the stream" ]
-[ "streams", "openRead", "command streams.openRead(filename:str):streams
", "mnstr_open_rastreamwrap;", "open ascii file stream for reading"
]
-[ "streams", "openReadBytes", "command
streams.openReadBytes(filename:str):streams ", "mnstr_open_rstreamwrap;",
"open a file stream for reading" ]
-[ "streams", "openWrite", "command
streams.openWrite(filename:str):streams ", "mnstr_open_wastreamwrap;",
"open ascii file stream for writing" ]
-[ "streams", "openWriteBytes", "command
streams.openWriteBytes(filename:str):streams ",
"mnstr_open_wstreamwrap;", "open a file stream for writing" ]
-[ "streams", "readInt", "command streams.readInt(s:streams):int ",
"mnstr_readIntwrap;", "read integer data from the stream" ]
-[ "streams", "readStr", "command streams.readStr(s:streams):str ",
"mnstr_read_stringwrap;", "read string data from the stream" ]
-[ "streams", "writeInt", "command streams.writeInt(s:streams,
data:int):void ", "mnstr_writeIntwrap;", "write data on the stream" ]
-[ "streams", "writeStr", "command streams.writeStr(s:streams,
data:str):void ", "mnstr_write_stringwrap;", "write data on the stream"
]
+[ "streams", "blocked", "unsafe command
streams.blocked(s:streams):streams ", "open_block_streamwrap;", "open a
block based stream" ]
+[ "streams", "close", "unsafe command streams.close(s:streams):void
", "mnstr_close_streamwrap;", "close and destroy the stream s"
]
+[ "streams", "flush", "unsafe command streams.flush(s:streams):void
", "mnstr_flush_streamwrap;", "flush the stream" ]
+[ "streams", "openRead", "unsafe command
streams.openRead(filename:str):streams ", "mnstr_open_rastreamwrap;",
"open ascii file stream for reading" ]
+[ "streams", "openReadBytes", "unsafe command
streams.openReadBytes(filename:str):streams ", "mnstr_open_rstreamwrap;",
"open a file stream for reading" ]
+[ "streams", "openWrite", "unsafe command
streams.openWrite(filename:str):streams ", "mnstr_open_wastreamwrap;",
"open ascii file stream for writing" ]
+[ "streams", "openWriteBytes", "unsafe command
streams.openWriteBytes(filename:str):streams ", "mnstr_open_wstreamwrap;",
"open a file stream for writing" ]
+[ "streams", "readInt", "unsafe command streams.readInt(s:streams):int
", "mnstr_readIntwrap;", "read integer data from the stream" ]
+[ "streams", "readStr", "unsafe command streams.readStr(s:streams):str
", "mnstr_read_stringwrap;", "read string data from the stream"
]
+[ "streams", "writeInt", "unsafe command streams.writeInt(s:streams,
data:int):void ", "mnstr_writeIntwrap;", "write data on the stream" ]
+[ "streams", "writeStr", "unsafe command streams.writeStr(s:streams,
data:str):void ", "mnstr_write_stringwrap;", "write data on the stream"
]
[ "sysmon", "pause", "pattern sysmon.pause(id:int):void ",
"SYSMONpause;", "Suspend a running query" ]
[ "sysmon", "pause", "pattern sysmon.pause(id:lng):void ",
"SYSMONpause;", "Suspend a running query" ]
[ "sysmon", "pause", "pattern sysmon.pause(id:sht):void ",
"SYSMONpause;", "Suspend a running query" ]
@@ -11312,12 +11312,12 @@ Ready.
[ "timestamp", "==", "pattern timestamp.==(v:timestamp, w:timestamp):bit ",
"CMDvarEQ;", "Equality of two timestamps" ]
[ "timestamp", ">", "pattern timestamp.>(v:timestamp, w:timestamp):bit ",
"CMDvarGT;", "Equality of two timestamps" ]
[ "timestamp", ">=", "pattern timestamp.>=(v:timestamp, w:timestamp):bit ",
"CMDvarGE;", "Equality of two timestamps" ]
-[ "timestamp", "epoch", "command timestamp.epoch():timestamp ",
"MTIMEcurrent_timestamp;", "unix-time (epoch) support: seconds since the
Unix epoch" ]
+[ "timestamp", "epoch", "unsafe command timestamp.epoch():timestamp ",
"MTIMEcurrent_timestamp;", "unix-time (epoch) support: seconds since the
Unix epoch" ]
[ "timestamp", "epoch", "command timestamp.epoch(t:timestamp):int ",
"MTIMEepoch2int;", "unix-time (epoch) support: seconds since epoch"
]
[ "timestamp", "epoch", "command timestamp.epoch(t:int):timestamp ",
"MTIMEtimestamp;", "convert seconds since epoch into a timestamp" ]
[ "timestamp", "epoch", "command timestamp.epoch(t:lng):timestamp ",
"MTIMEtimestamplng;", "convert milli seconds since epoch into a timestamp"
]
[ "timestamp", "isnil", "pattern timestamp.isnil(v:timestamp):bit ",
"CMDvarISNIL;", "Nil test for timestamp value" ]
-[ "timestamp", "unix_epoch", "command timestamp.unix_epoch():timestamp ",
"MTIMEunix_epoch;", "The Unix epoch time (00:00:00 UTC on January 1, 1970)"
]
+[ "timestamp", "unix_epoch", "unsafe command
timestamp.unix_epoch():timestamp ", "MTIMEunix_epoch;", "The Unix epoch
time (00:00:00 UTC on January 1, 1970)" ]
[ "timezone", "#fromstr", "command timezone.#fromstr():void ",
"tzone_fromstr;", "" ]
[ "timezone", "#tostr", "command timezone.#tostr():void ",
"tzone_tostr;", "" ]
[ "timezone", "str", "command timezone.str(z:timezone):str ",
"MTIMEtzone_tostr;", "" ]
@@ -11464,7 +11464,7 @@ Ready.
[ "wlc", "rollback", "pattern wlc.rollback():void ",
"WLCrollbackCmd;", "Mark the end of the work unit" ]
[ "wlc", "setmasterbeat", "pattern
wlc.setmasterbeat(duration:int):void ", "WLCsetmasterbeat;", "Maximal
delay for transaction log flushing" ]
[ "wlc", "stopmaster", "pattern wlc.stopmaster():void ",
"WLCstopmaster;", "Stop capturing the logs" ]
-[ "wlc", "transaction", "pattern wlc.transaction():void ",
"WLCgeneric;", "Start an autocommit transaction" ]
+[ "wlc", "transaction", "unsafe pattern wlc.transaction():void ",
"WLCgeneric;", "Start an autocommit transaction" ]
[ "wlc", "transaction_begin", "pattern
wlc.transaction_begin(chain:int, name:str):void ", "WLCgeneric;", "A
transaction statement (type can be commit,release,rollback or start)" ]
[ "wlc", "transaction_commit", "pattern
wlc.transaction_commit(chain:int, name:str):void ", "WLCgeneric;", "A
transaction statement (type can be commit,release,rollback or start)" ]
[ "wlc", "transaction_release", "pattern
wlc.transaction_release(chain:int, name:str):void ", "WLCgeneric;", "A
transaction statement (type can be commit,release,rollback or start)" ]
@@ -11530,7 +11530,7 @@ Ready.
[ "wlr", "revoke_roles", "pattern wlr.revoke_roles(sname:str, auth:str,
grantor:int, admin:int):void ", "WLRgeneric;", "Catalog operation
revoke_roles" ]
[ "wlr", "rollback", "pattern wlr.rollback():void ", "WLRrollback;",
"Mark the end of the work unit" ]
[ "wlr", "setreplicabeat", "pattern
wlr.setreplicabeat(dur:int):void ", "WLRsetreplicabeat;", "Threshold (in
seconds) for re-running queries" ]
-[ "wlr", "transaction", "pattern wlr.transaction():void ",
"WLRgeneric;", "Start an autocommit transaction" ]
+[ "wlr", "transaction", "unsafe pattern wlr.transaction():void ",
"WLRgeneric;", "Start an autocommit transaction" ]
[ "wlr", "transaction", "pattern wlr.transaction(tid:lng, started:str,
user:str):void ", "WLRtransaction;", "Mark the beginning of the
work unit which can be a compound transaction" ]
[ "wlr", "transaction_begin", "pattern
wlr.transaction_begin(chain:int, name:str):void ", "WLRgeneric;", "A
transaction statement (type can be commit,release,rollback or start)" ]
[ "wlr", "transaction_commit", "pattern
wlr.transaction_commit(chain:int, name:str):void ", "WLRgeneric;", "A
transaction statement (type can be commit,release,rollback or start)" ]
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
