Changeset: a196a8002c2f for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=a196a8002c2f
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
Branch: Jul2017
Log Message:
Save the unsafe property in the correct place.
diffs (truncated from 575 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
@@ -456,13 +456,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." ]
@@ -6204,9 +6204,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" ]
@@ -7813,20 +7813,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." ]
@@ -7993,8 +7993,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." ]
@@ -8070,7 +8070,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", "rule", "command mtime.rule(mo:int, d:int, wkday:int,
mi:int):zrule ", "MTIMErule_create;", "create a DST start/end date rule."
]
@@ -8115,14 +8115,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;", "" ]
@@ -8274,7 +8274,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" ]
@@ -8296,9 +8296,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):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):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", "create_func_upgrade_oct2014", "pattern
sql.create_func_upgrade_oct2014(sname:str, f:str):int ",
"UPGcreate_func;", "Create the function described by f, needed for the
Oct2014 upgrade" ]
@@ -8313,19 +8313,19 @@ 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", "declaredTable", "pattern
sql.declaredTable(name:str):int ", "mvc_declared_table_wrap;", "Prepare
a declared table" ]
-[ "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", "declaredTable", "unsafe pattern
sql.declaredTable(name:str):int ", "mvc_declared_table_wrap;",
"Prepare a declared table" ]
+[ "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"
]
[ "sql", "diff", "pattern sql.diff(b:any_1):bit ", "SQLdiff;",
"return true if cur != prev row" ]
[ "sql", "diff", "pattern sql.diff(p:bit, b:any_1):bit ",
"SQLdiff;", "return true if cur != prev row" ]
-[ "sql", "dropDeclaredTable", "pattern
sql.dropDeclaredTable(name:str):void ", "mvc_drop_declared_table_wrap;",
"drop a declared table" ]
-[ "sql", "dropDeclaredTables", "pattern
sql.dropDeclaredTables(nr:int):void ", "mvc_drop_declared_tables_wrap;",
"drop top n declared tables" ]
+[ "sql", "dropDeclaredTable", "unsafe pattern
sql.dropDeclaredTable(name:str):void ", "mvc_drop_declared_table_wrap;",
"drop a declared table" ]
+[ "sql", "dropDeclaredTables", "unsafe pattern
sql.dropDeclaredTables(nr:int):void ", "mvc_drop_declared_tables_wrap;",
"drop top n declared tables" ]
[ "sql", "drop_func_upgrade_oct2014", "pattern
sql.drop_func_upgrade_oct2014(id:int):int ", "UPGdrop_func;", "Drop
the function identified by id, needed for the Oct2014 upgrade" ]
[ "sql", "drop_hash", "pattern sql.drop_hash(sch:str, tbl:str):void
", "SQLdrop_hash;", "Drop hash indices for the given table" ]
[ "sql", "droporderindex", "pattern sql.droporderindex(sch:str,
tbl:str, col:str):void ", "sql_droporderindex;", "Drop the order index on a
column" ]
-[ "sql", "dtColumn", "pattern sql.dtColumn(rs:int, tname:str,
name:str, typename:str, digits:int, scale:int):void ",
"mvc_declared_table_column_wrap;", "" ]
+[ "sql", "dtColumn", "unsafe pattern sql.dtColumn(rs:int, tname:str,
name:str, typename:str, digits:int, scale:int):void ",
"mvc_declared_table_column_wrap;", "" ]
[ "sql", "dump_cache", "pattern sql.dump_cache() (query:bat[:str],
count:bat[:int]) ", "dump_cache;", "dump the content of the query cache" ]
[ "sql", "dump_opt_stats", "pattern sql.dump_opt_stats()
(rewrite:bat[:str], count:bat[:int]) ", "dump_opt_stats;", "dump the
optimizer rewrite statistics" ]
[ "sql", "dump_trace", "pattern sql.dump_trace() (event:bat[:int],
clk:bat[:str], pc:bat[:str], thread:bat[:int], ticks:bat[:lng],
rssMB:bat[:lng], vmMB:bat[:lng], reads:bat[:lng], writes:bat[:lng],
minflt:bat[:lng], majflt:bat[:lng], nvcsw:bat[:lng], stmt:bat[:str]) ",
"dump_trace;", "dump the trace statistics" ]
@@ -8341,21 +8341,21 @@ 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, 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, 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, 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, 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", "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", "importTable", "pattern sql.importTable(sname:str, tname:str,
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, 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", "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", "ms_trunc", "command sql.ms_trunc(v:dbl, r:int):dbl ",
"dbl_trunc_wrap;", "truncate the floating point v to r digits behind the
dot (if r < 0, before the dot)" ]
[ "sql", "ms_trunc", "command sql.ms_trunc(v:flt, r:int):flt ",
"flt_trunc_wrap;", "truncate the floating point v to r digits behind the
dot (if r < 0, before the dot)" ]
[ "sql", "mvc", "pattern sql.mvc():int ", "SQLmvc;", "Get
the multiversion catalog context. \nNeeded for correct statement
dependencies\n(ie sql.update, should be after sql.bind in concurrent
execution)" ]
@@ -8376,10 +8376,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)" ]
@@ -8421,8 +8421,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)" ]
@@ -8529,23 +8529,23 @@ 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", "openRead", "command streams.openRead(s:streams):streams ",
"mnstr_stream_rstreamwrap;", "convert an ascii stream to binary" ]
-[ "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", "openWrite", "command streams.openWrite(s:streams):streams
", "mnstr_stream_wstreamwrap;", "convert an ascii stream to binary"
]
-[ "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", "socketRead", "command streams.socketRead(skt:int,
name:str):streams ", "mnstr_socket_rastreamwrap;", "open ascii socket
stream for reading" ]
-[ "streams", "socketReadBytes", "command
streams.socketReadBytes(skt:int, name:str):streams ",
"mnstr_socket_rstreamwrap;", "open a socket stream for reading" ]
-[ "streams", "socketWrite", "command streams.socketWrite(skt:int,
name:str):streams ", "mnstr_socket_wastreamwrap;", "open ascii socket
stream for writing" ]
-[ "streams", "socketWriteBytes", "command
streams.socketWriteBytes(skt:int, name:str):streams ",
"mnstr_socket_wstreamwrap;", "open a socket stream for writing" ]
-[ "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", "openRead", "unsafe command
streams.openRead(s:streams):streams ", "mnstr_stream_rstreamwrap;",
"convert an ascii stream to binary" ]
+[ "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", "openWrite", "unsafe command
streams.openWrite(s:streams):streams ", "mnstr_stream_wstreamwrap;",
"convert an ascii stream to binary" ]
+[ "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", "socketRead", "unsafe command streams.socketRead(skt:int,
name:str):streams ", "mnstr_socket_rastreamwrap;", "open ascii socket
stream for reading" ]
+[ "streams", "socketReadBytes", "unsafe command
streams.socketReadBytes(skt:int, name:str):streams ",
"mnstr_socket_rstreamwrap;", "open a socket stream for reading" ]
+[ "streams", "socketWrite", "unsafe command streams.socketWrite(skt:int,
name:str):streams ", "mnstr_socket_wastreamwrap;", "open ascii socket
stream for writing" ]
+[ "streams", "socketWriteBytes", "unsafe command
streams.socketWriteBytes(skt:int, name:str):streams ",
"mnstr_socket_wstreamwrap;", "open a socket stream for writing" ]
+[ "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" ]
@@ -8564,12 +8564,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;", "" ]
diff --git a/clients/Tests/MAL-signatures.stable.out.int128
b/clients/Tests/MAL-signatures.stable.out.int128
--- a/clients/Tests/MAL-signatures.stable.out.int128
+++ b/clients/Tests/MAL-signatures.stable.out.int128
@@ -560,13 +560,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." ]
@@ -8173,9 +8173,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" ]
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list
