Changeset: 35648dc51067 for MonetDB URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=35648dc51067 Added Files: monetdb5/modules/kernel/mmath_private.h Modified Files: clients/Tests/MAL-signatures.stable.out clients/Tests/MAL-signatures.stable.out.int128 clients/Tests/exports.stable.out common/stream/stream.c configure.ag gdk/gdk_bbp.c monetdb5/ChangeLog.Apr2019 monetdb5/extras/rapi/rapi.c monetdb5/mal/Tests/tst016.stable.out monetdb5/modules/atoms/blob.c monetdb5/modules/atoms/blob.h monetdb5/modules/atoms/blob.mal monetdb5/modules/kernel/batmmath.c monetdb5/modules/kernel/batmmath.h monetdb5/modules/kernel/batmmath.mal monetdb5/modules/kernel/mmath.c monetdb5/modules/kernel/mmath.h monetdb5/modules/kernel/mmath.mal monetdb5/modules/mal/01_batcalc.mal monetdb5/modules/mal/01_batcalc.mal.sh monetdb5/modules/mal/01_calc.mal monetdb5/modules/mal/01_calc.mal.sh sql/ChangeLog.Apr2019 sql/backends/monet5/UDF/capi/capi.c sql/backends/monet5/UDF/pyapi/conversion.c sql/backends/monet5/UDF/pyapi/emit.c sql/backends/monet5/UDF/pyapi/pytypes.c sql/backends/monet5/sql.h sql/backends/monet5/sql.mal sql/backends/monet5/sql_cast.c sql/backends/monet5/vaults/fits/fits.c sql/common/sql_types.c sql/server/rel_exp.c sql/test/Tests/systemfunctions.stable.out sql/test/Tests/systemfunctions.stable.out.int128 sql/test/emptydb-upgrade-chain-hge/Tests/upgrade.stable.out.int128 sql/test/emptydb-upgrade-chain-hge/Tests/upgrade.stable.out.powerpc64.int128 sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out.32bit sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out.int128 sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out.powerpc64 sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out.powerpc64.int128 sql/test/emptydb-upgrade-hge/Tests/upgrade.stable.out.int128 sql/test/emptydb-upgrade/Tests/upgrade.stable.out sql/test/emptydb-upgrade/Tests/upgrade.stable.out.32bit sql/test/emptydb-upgrade/Tests/upgrade.stable.out.int128 sql/test/emptydb/Tests/check.stable.out sql/test/emptydb/Tests/check.stable.out.32bit sql/test/emptydb/Tests/check.stable.out.int128 sql/test/testdb-upgrade-chain-hge/Tests/upgrade.stable.out.int128 sql/test/testdb-upgrade-chain/Tests/upgrade.stable.out sql/test/testdb-upgrade-chain/Tests/upgrade.stable.out.32bit sql/test/testdb-upgrade-chain/Tests/upgrade.stable.out.int128 sql/test/testdb-upgrade-hge/Tests/upgrade.stable.out.int128 sql/test/testdb-upgrade/Tests/upgrade.stable.out sql/test/testdb-upgrade/Tests/upgrade.stable.out.32bit sql/test/testdb-upgrade/Tests/upgrade.stable.out.int128 sql/test/testdb-upgrade/Tests/upgrade.stable.out.powerpc64.int128 testing/malcheck.py Branch: default Log Message:
Merge with Apr2019 branch. diffs (truncated from 201195 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 @@ -681,6 +681,10 @@ Ready. [ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bit], b2:bat[:bit], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ] [ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bit], b2:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with candidates list" ] [ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bit], b2:bat[:bit], s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with candidates list" ] +[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:blob], b2:bat[:blob]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ] +[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:blob], b2:bat[:blob], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ] +[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:blob], b2:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with candidates list" ] +[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:blob], b2:bat[:blob], s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with candidates list" ] [ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:bte]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ] [ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:bte], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ] [ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with candidates list" ] @@ -853,6 +857,10 @@ Ready. [ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bit], v:bit, nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ] [ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bit], v:bit, s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates list" ] [ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bit], v:bit, s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates list" ] +[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:blob], v:blob):bat[:bit] ", "CMDbatNE;", "Return B != V" ] +[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:blob], v:blob, nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ] +[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:blob], v:blob, s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates list" ] +[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:blob], v:blob, s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates list" ] [ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:bte):bat[:bit] ", "CMDbatNE;", "Return B != V" ] [ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:bte, nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ] [ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:bte, s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates list" ] @@ -1021,6 +1029,10 @@ Ready. [ "batcalc", "!=", "pattern batcalc.!=(v:bit, b:bat[:bit], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return V != B" ] [ "batcalc", "!=", "pattern batcalc.!=(v:bit, b:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return V != B with candidates list" ] [ "batcalc", "!=", "pattern batcalc.!=(v:bit, b:bat[:bit], s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return V != B with candidates list" ] +[ "batcalc", "!=", "pattern batcalc.!=(v:blob, b:bat[:blob]):bat[:bit] ", "CMDbatNE;", "Return V != B" ] +[ "batcalc", "!=", "pattern batcalc.!=(v:blob, b:bat[:blob], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return V != B" ] +[ "batcalc", "!=", "pattern batcalc.!=(v:blob, b:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return V != B with candidates list" ] +[ "batcalc", "!=", "pattern batcalc.!=(v:blob, b:bat[:blob], s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return V != B with candidates list" ] [ "batcalc", "!=", "pattern batcalc.!=(v:bte, b:bat[:bte]):bat[:bit] ", "CMDbatNE;", "Return V != B" ] [ "batcalc", "!=", "pattern batcalc.!=(v:bte, b:bat[:bte], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return V != B" ] [ "batcalc", "!=", "pattern batcalc.!=(v:bte, b:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return V != B with candidates list" ] @@ -4043,6 +4055,8 @@ Ready. [ "batcalc", "/", "pattern batcalc./(v:sht, b:bat[:sht], s:bat[:oid]):bat[:sht] ", "CMDbatDIVsignal;", "Return V / B with candidates list, signal error on overflow" ] [ "batcalc", "<", "pattern batcalc.<(b1:bat[:bit], b2:bat[:bit]):bat[:bit] ", "CMDbatLT;", "Return B1 < B2" ] [ "batcalc", "<", "pattern batcalc.<(b1:bat[:bit], b2:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatLT;", "Return B1 < B2 with candidates list" ] +[ "batcalc", "<", "pattern batcalc.<(b1:bat[:blob], b2:bat[:blob]):bat[:bit] ", "CMDbatLT;", "Return B1 < B2" ] +[ "batcalc", "<", "pattern batcalc.<(b1:bat[:blob], b2:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatLT;", "Return B1 < B2 with candidates list" ] [ "batcalc", "<", "pattern batcalc.<(b1:bat[:bte], b2:bat[:bte]):bat[:bit] ", "CMDbatLT;", "Return B1 < B2" ] [ "batcalc", "<", "pattern batcalc.<(b1:bat[:bte], b2:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatLT;", "Return B1 < B2 with candidates list" ] [ "batcalc", "<", "pattern batcalc.<(b1:bat[:bte], b2:bat[:dbl]):bat[:bit] ", "CMDbatLT;", "Return B1 < B2" ] @@ -4129,6 +4143,8 @@ Ready. [ "batcalc", "<", "pattern batcalc.<(b1:bat[:uuid], b2:bat[:uuid]):bat[:bit] ", "CMDbatLT;", "Return B1 < B2" ] [ "batcalc", "<", "pattern batcalc.<(b:bat[:bit], v:bit):bat[:bit] ", "CMDbatLT;", "Return B < V" ] [ "batcalc", "<", "pattern batcalc.<(b:bat[:bit], v:bit, s:bat[:oid]):bat[:bit] ", "CMDbatLT;", "Return B < V with candidates list" ] +[ "batcalc", "<", "pattern batcalc.<(b:bat[:blob], v:blob):bat[:bit] ", "CMDbatLT;", "Return B < V" ] +[ "batcalc", "<", "pattern batcalc.<(b:bat[:blob], v:blob, s:bat[:oid]):bat[:bit] ", "CMDbatLT;", "Return B < V with candidates list" ] [ "batcalc", "<", "pattern batcalc.<(b:bat[:bte], v:bte):bat[:bit] ", "CMDbatLT;", "Return B < V" ] [ "batcalc", "<", "pattern batcalc.<(b:bat[:bte], v:bte, s:bat[:oid]):bat[:bit] ", "CMDbatLT;", "Return B < V with candidates list" ] [ "batcalc", "<", "pattern batcalc.<(b:bat[:bte], v:dbl):bat[:bit] ", "CMDbatLT;", "Return B < V" ] @@ -4213,6 +4229,8 @@ Ready. [ "batcalc", "<", "pattern batcalc.<(b:bat[:timestamp], v:timestamp, s:bat[:oid]):bat[:bit] ", "CMDbatLT;", "Return B < V with candidates list" ] [ "batcalc", "<", "pattern batcalc.<(v:bit, b:bat[:bit]):bat[:bit] ", "CMDbatLT;", "Return V < B" ] [ "batcalc", "<", "pattern batcalc.<(v:bit, b:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatLT;", "Return V < B with candidates list" ] +[ "batcalc", "<", "pattern batcalc.<(v:blob, b:bat[:blob]):bat[:bit] ", "CMDbatLT;", "Return V < B" ] +[ "batcalc", "<", "pattern batcalc.<(v:blob, b:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatLT;", "Return V < B with candidates list" ] [ "batcalc", "<", "pattern batcalc.<(v:bte, b:bat[:bte]):bat[:bit] ", "CMDbatLT;", "Return V < B" ] [ "batcalc", "<", "pattern batcalc.<(v:bte, b:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatLT;", "Return V < B with candidates list" ] [ "batcalc", "<", "pattern batcalc.<(v:bte, b:bat[:dbl]):bat[:bit] ", "CMDbatLT;", "Return V < B" ] @@ -4393,6 +4411,8 @@ Ready. [ "batcalc", "<<", "pattern batcalc.<<(v:sht, b:bat[:sht], s:bat[:oid]):bat[:sht] ", "CMDbatLSHsignal;", "Return V << B with candidates list, raise error on out of range second operand" ] [ "batcalc", "<=", "pattern batcalc.<=(b1:bat[:bit], b2:bat[:bit]):bat[:bit] ", "CMDbatLE;", "Return B1 <= B2" ] [ "batcalc", "<=", "pattern batcalc.<=(b1:bat[:bit], b2:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatLE;", "Return B1 <= B2 with candidates list" ] +[ "batcalc", "<=", "pattern batcalc.<=(b1:bat[:blob], b2:bat[:blob]):bat[:bit] ", "CMDbatLE;", "Return B1 <= B2" ] +[ "batcalc", "<=", "pattern batcalc.<=(b1:bat[:blob], b2:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatLE;", "Return B1 <= B2 with candidates list" ] [ "batcalc", "<=", "pattern batcalc.<=(b1:bat[:bte], b2:bat[:bte]):bat[:bit] ", "CMDbatLE;", "Return B1 <= B2" ] [ "batcalc", "<=", "pattern batcalc.<=(b1:bat[:bte], b2:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatLE;", "Return B1 <= B2 with candidates list" ] [ "batcalc", "<=", "pattern batcalc.<=(b1:bat[:bte], b2:bat[:dbl]):bat[:bit] ", "CMDbatLE;", "Return B1 <= B2" ] @@ -4479,6 +4499,8 @@ Ready. [ "batcalc", "<=", "pattern batcalc.<=(b1:bat[:uuid], b2:bat[:uuid]):bat[:bit] ", "CMDbatLE;", "Return B1 <= B2" ] [ "batcalc", "<=", "pattern batcalc.<=(b:bat[:bit], v:bit):bat[:bit] ", "CMDbatLE;", "Return B <= V" ] [ "batcalc", "<=", "pattern batcalc.<=(b:bat[:bit], v:bit, s:bat[:oid]):bat[:bit] ", "CMDbatLE;", "Return B <= V with candidates list" ] +[ "batcalc", "<=", "pattern batcalc.<=(b:bat[:blob], v:blob):bat[:bit] ", "CMDbatLE;", "Return B <= V" ] +[ "batcalc", "<=", "pattern batcalc.<=(b:bat[:blob], v:blob, s:bat[:oid]):bat[:bit] ", "CMDbatLE;", "Return B <= V with candidates list" ] [ "batcalc", "<=", "pattern batcalc.<=(b:bat[:bte], v:bte):bat[:bit] ", "CMDbatLE;", "Return B <= V" ] [ "batcalc", "<=", "pattern batcalc.<=(b:bat[:bte], v:bte, s:bat[:oid]):bat[:bit] ", "CMDbatLE;", "Return B <= V with candidates list" ] [ "batcalc", "<=", "pattern batcalc.<=(b:bat[:bte], v:dbl):bat[:bit] ", "CMDbatLE;", "Return B <= V" ] @@ -4563,6 +4585,8 @@ Ready. [ "batcalc", "<=", "pattern batcalc.<=(b:bat[:timestamp], v:timestamp, s:bat[:oid]):bat[:bit] ", "CMDbatLE;", "Return B <= V with candidates list" ] [ "batcalc", "<=", "pattern batcalc.<=(v:bit, b:bat[:bit]):bat[:bit] ", "CMDbatLE;", "Return V <= B" ] [ "batcalc", "<=", "pattern batcalc.<=(v:bit, b:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatLE;", "Return V <= B with candidates list" ] +[ "batcalc", "<=", "pattern batcalc.<=(v:blob, b:bat[:blob]):bat[:bit] ", "CMDbatLE;", "Return V <= B" ] +[ "batcalc", "<=", "pattern batcalc.<=(v:blob, b:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatLE;", "Return V <= B with candidates list" ] [ "batcalc", "<=", "pattern batcalc.<=(v:bte, b:bat[:bte]):bat[:bit] ", "CMDbatLE;", "Return V <= B" ] [ "batcalc", "<=", "pattern batcalc.<=(v:bte, b:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatLE;", "Return V <= B with candidates list" ] [ "batcalc", "<=", "pattern batcalc.<=(v:bte, b:bat[:dbl]):bat[:bit] ", "CMDbatLE;", "Return V <= B" ] @@ -4649,6 +4673,10 @@ Ready. [ "batcalc", "==", "pattern batcalc.==(b1:bat[:bit], b2:bat[:bit], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return B1 == B2" ] [ "batcalc", "==", "pattern batcalc.==(b1:bat[:bit], b2:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatEQ;", "Return B1 == B2 with candidates list" ] [ "batcalc", "==", "pattern batcalc.==(b1:bat[:bit], b2:bat[:bit], s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return B1 == B2 with candidates list" ] +[ "batcalc", "==", "pattern batcalc.==(b1:bat[:blob], b2:bat[:blob]):bat[:bit] ", "CMDbatEQ;", "Return B1 == B2" ] +[ "batcalc", "==", "pattern batcalc.==(b1:bat[:blob], b2:bat[:blob], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return B1 == B2" ] +[ "batcalc", "==", "pattern batcalc.==(b1:bat[:blob], b2:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatEQ;", "Return B1 == B2 with candidates list" ] +[ "batcalc", "==", "pattern batcalc.==(b1:bat[:blob], b2:bat[:blob], s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return B1 == B2 with candidates list" ] [ "batcalc", "==", "pattern batcalc.==(b1:bat[:bte], b2:bat[:bte]):bat[:bit] ", "CMDbatEQ;", "Return B1 == B2" ] [ "batcalc", "==", "pattern batcalc.==(b1:bat[:bte], b2:bat[:bte], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return B1 == B2" ] [ "batcalc", "==", "pattern batcalc.==(b1:bat[:bte], b2:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatEQ;", "Return B1 == B2 with candidates list" ] @@ -4821,6 +4849,10 @@ Ready. [ "batcalc", "==", "pattern batcalc.==(b:bat[:bit], v:bit, nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return B == V" ] [ "batcalc", "==", "pattern batcalc.==(b:bat[:bit], v:bit, s:bat[:oid]):bat[:bit] ", "CMDbatEQ;", "Return B == V with candidates list" ] [ "batcalc", "==", "pattern batcalc.==(b:bat[:bit], v:bit, s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return B == V with candidates list" ] +[ "batcalc", "==", "pattern batcalc.==(b:bat[:blob], v:blob):bat[:bit] ", "CMDbatEQ;", "Return B == V" ] +[ "batcalc", "==", "pattern batcalc.==(b:bat[:blob], v:blob, nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return B == V" ] +[ "batcalc", "==", "pattern batcalc.==(b:bat[:blob], v:blob, s:bat[:oid]):bat[:bit] ", "CMDbatEQ;", "Return B == V with candidates list" ] +[ "batcalc", "==", "pattern batcalc.==(b:bat[:blob], v:blob, s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return B == V with candidates list" ] [ "batcalc", "==", "pattern batcalc.==(b:bat[:bte], v:bte):bat[:bit] ", "CMDbatEQ;", "Return B == V" ] [ "batcalc", "==", "pattern batcalc.==(b:bat[:bte], v:bte, nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return B == V" ] [ "batcalc", "==", "pattern batcalc.==(b:bat[:bte], v:bte, s:bat[:oid]):bat[:bit] ", "CMDbatEQ;", "Return B == V with candidates list" ] @@ -4989,6 +5021,10 @@ Ready. [ "batcalc", "==", "pattern batcalc.==(v:bit, b:bat[:bit], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return V == B" ] [ "batcalc", "==", "pattern batcalc.==(v:bit, b:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatEQ;", "Return V == B with candidates list" ] [ "batcalc", "==", "pattern batcalc.==(v:bit, b:bat[:bit], s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return V == B with candidates list" ] +[ "batcalc", "==", "pattern batcalc.==(v:blob, b:bat[:blob]):bat[:bit] ", "CMDbatEQ;", "Return V == B" ] +[ "batcalc", "==", "pattern batcalc.==(v:blob, b:bat[:blob], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return V == B" ] +[ "batcalc", "==", "pattern batcalc.==(v:blob, b:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatEQ;", "Return V == B with candidates list" ] +[ "batcalc", "==", "pattern batcalc.==(v:blob, b:bat[:blob], s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return V == B with candidates list" ] [ "batcalc", "==", "pattern batcalc.==(v:bte, b:bat[:bte]):bat[:bit] ", "CMDbatEQ;", "Return V == B" ] [ "batcalc", "==", "pattern batcalc.==(v:bte, b:bat[:bte], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return V == B" ] [ "batcalc", "==", "pattern batcalc.==(v:bte, b:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatEQ;", "Return V == B with candidates list" ] @@ -5155,6 +5191,8 @@ Ready. [ "batcalc", "==", "pattern batcalc.==(v:timestamp, b:bat[:timestamp], s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatEQ;", "Return V == B with candidates list" ] [ "batcalc", ">", "pattern batcalc.>(b1:bat[:bit], b2:bat[:bit]):bat[:bit] ", "CMDbatGT;", "Return B1 > B2" ] [ "batcalc", ">", "pattern batcalc.>(b1:bat[:bit], b2:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatGT;", "Return B1 > B2 with candidates list" ] +[ "batcalc", ">", "pattern batcalc.>(b1:bat[:blob], b2:bat[:blob]):bat[:bit] ", "CMDbatGT;", "Return B1 > B2" ] +[ "batcalc", ">", "pattern batcalc.>(b1:bat[:blob], b2:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatGT;", "Return B1 > B2 with candidates list" ] [ "batcalc", ">", "pattern batcalc.>(b1:bat[:bte], b2:bat[:bte]):bat[:bit] ", "CMDbatGT;", "Return B1 > B2" ] [ "batcalc", ">", "pattern batcalc.>(b1:bat[:bte], b2:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatGT;", "Return B1 > B2 with candidates list" ] [ "batcalc", ">", "pattern batcalc.>(b1:bat[:bte], b2:bat[:dbl]):bat[:bit] ", "CMDbatGT;", "Return B1 > B2" ] @@ -5241,6 +5279,8 @@ Ready. [ "batcalc", ">", "pattern batcalc.>(b1:bat[:uuid], b2:bat[:uuid]):bat[:bit] ", "CMDbatGT;", "Return B1 > B2" ] [ "batcalc", ">", "pattern batcalc.>(b:bat[:bit], v:bit):bat[:bit] ", "CMDbatGT;", "Return B > V" ] [ "batcalc", ">", "pattern batcalc.>(b:bat[:bit], v:bit, s:bat[:oid]):bat[:bit] ", "CMDbatGT;", "Return B > V with candidates list" ] +[ "batcalc", ">", "pattern batcalc.>(b:bat[:blob], v:blob):bat[:bit] ", "CMDbatGT;", "Return B > V" ] +[ "batcalc", ">", "pattern batcalc.>(b:bat[:blob], v:blob, s:bat[:oid]):bat[:bit] ", "CMDbatGT;", "Return B > V with candidates list" ] [ "batcalc", ">", "pattern batcalc.>(b:bat[:bte], v:bte):bat[:bit] ", "CMDbatGT;", "Return B > V" ] [ "batcalc", ">", "pattern batcalc.>(b:bat[:bte], v:bte, s:bat[:oid]):bat[:bit] ", "CMDbatGT;", "Return B > V with candidates list" ] [ "batcalc", ">", "pattern batcalc.>(b:bat[:bte], v:dbl):bat[:bit] ", "CMDbatGT;", "Return B > V" ] @@ -5325,6 +5365,8 @@ Ready. [ "batcalc", ">", "pattern batcalc.>(b:bat[:timestamp], v:timestamp, s:bat[:oid]):bat[:bit] ", "CMDbatGT;", "Return B > V with candidates list" ] [ "batcalc", ">", "pattern batcalc.>(v:bit, b:bat[:bit]):bat[:bit] ", "CMDbatGT;", "Return V > B" ] [ "batcalc", ">", "pattern batcalc.>(v:bit, b:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatGT;", "Return V > B with candidates list" ] +[ "batcalc", ">", "pattern batcalc.>(v:blob, b:bat[:blob]):bat[:bit] ", "CMDbatGT;", "Return V > B" ] +[ "batcalc", ">", "pattern batcalc.>(v:blob, b:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatGT;", "Return V > B with candidates list" ] [ "batcalc", ">", "pattern batcalc.>(v:bte, b:bat[:bte]):bat[:bit] ", "CMDbatGT;", "Return V > B" ] [ "batcalc", ">", "pattern batcalc.>(v:bte, b:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatGT;", "Return V > B with candidates list" ] [ "batcalc", ">", "pattern batcalc.>(v:bte, b:bat[:dbl]):bat[:bit] ", "CMDbatGT;", "Return V > B" ] @@ -5409,6 +5451,8 @@ Ready. [ "batcalc", ">", "pattern batcalc.>(v:timestamp, b:bat[:timestamp], s:bat[:oid]):bat[:bit] ", "CMDbatGT;", "Return V > B with candidates list" ] [ "batcalc", ">=", "pattern batcalc.>=(b1:bat[:bit], b2:bat[:bit]):bat[:bit] ", "CMDbatGE;", "Return B1 >= B2" ] [ "batcalc", ">=", "pattern batcalc.>=(b1:bat[:bit], b2:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatGE;", "Return B1 >= B2 with candidates list" ] +[ "batcalc", ">=", "pattern batcalc.>=(b1:bat[:blob], b2:bat[:blob]):bat[:bit] ", "CMDbatGE;", "Return B1 >= B2" ] +[ "batcalc", ">=", "pattern batcalc.>=(b1:bat[:blob], b2:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatGE;", "Return B1 >= B2 with candidates list" ] [ "batcalc", ">=", "pattern batcalc.>=(b1:bat[:bte], b2:bat[:bte]):bat[:bit] ", "CMDbatGE;", "Return B1 >= B2" ] [ "batcalc", ">=", "pattern batcalc.>=(b1:bat[:bte], b2:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatGE;", "Return B1 >= B2 with candidates list" ] [ "batcalc", ">=", "pattern batcalc.>=(b1:bat[:bte], b2:bat[:dbl]):bat[:bit] ", "CMDbatGE;", "Return B1 >= B2" ] @@ -5495,6 +5539,8 @@ Ready. [ "batcalc", ">=", "pattern batcalc.>=(b1:bat[:uuid], b2:bat[:uuid]):bat[:bit] ", "CMDbatGE;", "Return B1 >= B2" ] [ "batcalc", ">=", "pattern batcalc.>=(b:bat[:bit], v:bit):bat[:bit] ", "CMDbatGE;", "Return B >= V" ] [ "batcalc", ">=", "pattern batcalc.>=(b:bat[:bit], v:bit, s:bat[:oid]):bat[:bit] ", "CMDbatGE;", "Return B >= V with candidates list" ] +[ "batcalc", ">=", "pattern batcalc.>=(b:bat[:blob], v:blob):bat[:bit] ", "CMDbatGE;", "Return B >= V" ] +[ "batcalc", ">=", "pattern batcalc.>=(b:bat[:blob], v:blob, s:bat[:oid]):bat[:bit] ", "CMDbatGE;", "Return B >= V with candidates list" ] [ "batcalc", ">=", "pattern batcalc.>=(b:bat[:bte], v:bte):bat[:bit] ", "CMDbatGE;", "Return B >= V" ] [ "batcalc", ">=", "pattern batcalc.>=(b:bat[:bte], v:bte, s:bat[:oid]):bat[:bit] ", "CMDbatGE;", "Return B >= V with candidates list" ] [ "batcalc", ">=", "pattern batcalc.>=(b:bat[:bte], v:dbl):bat[:bit] ", "CMDbatGE;", "Return B >= V" ] @@ -5579,6 +5625,8 @@ Ready. [ "batcalc", ">=", "pattern batcalc.>=(b:bat[:timestamp], v:timestamp, s:bat[:oid]):bat[:bit] ", "CMDbatGE;", "Return B >= V with candidates list" ] [ "batcalc", ">=", "pattern batcalc.>=(v:bit, b:bat[:bit]):bat[:bit] ", "CMDbatGE;", "Return V >= B" ] [ "batcalc", ">=", "pattern batcalc.>=(v:bit, b:bat[:bit], s:bat[:oid]):bat[:bit] ", "CMDbatGE;", "Return V >= B with candidates list" ] +[ "batcalc", ">=", "pattern batcalc.>=(v:blob, b:bat[:blob]):bat[:bit] ", "CMDbatGE;", "Return V >= B" ] +[ "batcalc", ">=", "pattern batcalc.>=(v:blob, b:bat[:blob], s:bat[:oid]):bat[:bit] ", "CMDbatGE;", "Return V >= B with candidates list" ] [ "batcalc", ">=", "pattern batcalc.>=(v:bte, b:bat[:bte]):bat[:bit] ", "CMDbatGE;", "Return V >= B" ] [ "batcalc", ">=", "pattern batcalc.>=(v:bte, b:bat[:bte], s:bat[:oid]):bat[:bit] ", "CMDbatGE;", "Return V >= B with candidates list" ] [ "batcalc", ">=", "pattern batcalc.>=(v:bte, b:bat[:dbl]):bat[:bit] ", "CMDbatGE;", "Return V >= B" ] @@ -6115,6 +6163,7 @@ Ready. [ "batcalc", "bit_noerror", "pattern batcalc.bit_noerror(b:bat[:sht], s:bat[:oid]):bat[:bit] ", "CMDconvert_bit;", "cast from sht to bit with candidates list" ] [ "batcalc", "bit_noerror", "pattern batcalc.bit_noerror(b:bat[:str]):bat[:bit] ", "CMDconvert_bit;", "cast from str to bit" ] [ "batcalc", "bit_noerror", "pattern batcalc.bit_noerror(b:bat[:str], s:bat[:oid]):bat[:bit] ", "CMDconvert_bit;", "cast from str to bit with candidates list" ] +[ "batcalc", "blob", "command batcalc.blob(v:bat[:str]):bat[:blob] ", "batstr_2_blob;", "cast to blob" ] [ "batcalc", "bte", "pattern batcalc.bte(b:bat[:bit]):bat[:bte] ", "CMDconvertsignal_bte;", "cast from bit to bte, signal error on overflow" ] [ "batcalc", "bte", "pattern batcalc.bte(b:bat[:bit], s:bat[:oid]):bat[:bte] ", "CMDconvertsignal_bte;", "cast from bit to bte with candidates list, signal error on overflow" ] [ "batcalc", "bte", "pattern batcalc.bte(b:bat[:bte]):bat[:bte] ", "CMDconvertsignal_bte;", "cast from bte to bte, signal error on overflow" ] @@ -8406,7 +8455,6 @@ Ready. [ "batcalc", "sign", "pattern batcalc.sign(b:bat[:lng], s:bat[:oid]):bat[:bte] ", "CMDbatSIGN;", "Unary sign (-1,0,1) over the tail of the bat with candidates list" ] [ "batcalc", "sign", "pattern batcalc.sign(b:bat[:sht]):bat[:bte] ", "CMDbatSIGN;", "Unary sign (-1,0,1) over the tail of the bat" ] [ "batcalc", "sign", "pattern batcalc.sign(b:bat[:sht], s:bat[:oid]):bat[:bte] ", "CMDbatSIGN;", "Unary sign (-1,0,1) over the tail of the bat with candidates list" ] -[ "batcalc", "sqlblob", "command batcalc.sqlblob(v:bat[:str]):bat[:sqlblob] ", "batstr_2_sqlblob;", "cast to sqlblob" ] [ "batcalc", "str", "pattern batcalc.str(b:bat[:any]):bat[:str] ", "CMDconvertsignal_str;", "cast from any to str, signal error on overflow" ] [ "batcalc", "str", "pattern batcalc.str(b:bat[:any], s:bat[:oid]):bat[:str] ", "CMDconvertsignal_str;", "cast from any to str with candidates list, signal error on overflow" ] [ "batcalc", "str", "pattern batcalc.str(eclass:int, d1:int, s1:int, has_tz:int, v:bat[:any_1], digits:int):bat[:str] ", "SQLbatstr_cast;", "cast to string and check for overflow" ] @@ -8819,14 +8867,26 @@ Ready. [ "batmmath", "fmod", "pattern batmmath.fmod(x:bat[:dbl], y:dbl, s:bat[:oid]):bat[:dbl] ", "CMDbatMODsignal;", "" ] [ "batmmath", "fmod", "pattern batmmath.fmod(x:bat[:flt], y:flt):bat[:flt] ", "CMDbatMODsignal;", "" ] [ "batmmath", "fmod", "pattern batmmath.fmod(x:bat[:flt], y:flt, s:bat[:oid]):bat[:flt] ", "CMDbatMODsignal;", "" ] +[ "batmmath", "log", "command batmmath.log(x:bat[:dbl], y:dbl):bat[:dbl] ", "CMDscience_bat_cst_log_dbl;", "" ] +[ "batmmath", "log", "command batmmath.log(x:bat[:dbl], y:dbl, s:bat[:oid]):bat[:dbl] ", "CMDscience_bat_cst_log_dbl_cand;", "" ] +[ "batmmath", "log", "command batmmath.log(x:bat[:flt], y:flt):bat[:flt] ", "CMDscience_bat_cst_log_flt;", "" ] +[ "batmmath", "log", "command batmmath.log(x:bat[:flt], y:flt, s:bat[:oid]):bat[:flt] ", "CMDscience_bat_cst_log_flt_cand;", "" ] [ "batmmath", "log", "command batmmath.log(x:bat[:dbl]):bat[:dbl] ", "CMDscience_bat_dbl_log;", "" ] [ "batmmath", "log", "command batmmath.log(x:bat[:dbl], s:bat[:oid]):bat[:dbl] ", "CMDscience_bat_dbl_log_cand;", "" ] [ "batmmath", "log", "command batmmath.log(x:bat[:flt]):bat[:flt] ", "CMDscience_bat_flt_log;", "" ] [ "batmmath", "log", "command batmmath.log(x:bat[:flt], s:bat[:oid]):bat[:flt] ", "CMDscience_bat_flt_log_cand;", "" ] +[ "batmmath", "log", "command batmmath.log(x:dbl, y:bat[:dbl]):bat[:dbl] ", "CMDscience_cst_bat_log_dbl;", "" ] +[ "batmmath", "log", "command batmmath.log(x:dbl, y:bat[:dbl], s:bat[:oid]):bat[:dbl] ", "CMDscience_cst_bat_log_dbl_cand;", "" ] +[ "batmmath", "log", "command batmmath.log(x:flt, y:bat[:flt]):bat[:flt] ", "CMDscience_cst_bat_log_flt;", "" ] +[ "batmmath", "log", "command batmmath.log(x:flt, y:bat[:flt], s:bat[:oid]):bat[:flt] ", "CMDscience_cst_bat_log_flt_cand;", "" ] [ "batmmath", "log10", "command batmmath.log10(x:bat[:dbl]):bat[:dbl] ", "CMDscience_bat_dbl_log10;", "" ] [ "batmmath", "log10", "command batmmath.log10(x:bat[:dbl], s:bat[:oid]):bat[:dbl] ", "CMDscience_bat_dbl_log10_cand;", "" ] [ "batmmath", "log10", "command batmmath.log10(x:bat[:flt]):bat[:flt] ", "CMDscience_bat_flt_log10;", "" ] [ "batmmath", "log10", "command batmmath.log10(x:bat[:flt], s:bat[:oid]):bat[:flt] ", "CMDscience_bat_flt_log10_cand;", "" ] +[ "batmmath", "log2", "command batmmath.log2(x:bat[:dbl]):bat[:dbl] ", "CMDscience_bat_dbl_log2;", "" ] +[ "batmmath", "log2", "command batmmath.log2(x:bat[:dbl], s:bat[:oid]):bat[:dbl] ", "CMDscience_bat_dbl_log2_cand;", "" ] +[ "batmmath", "log2", "command batmmath.log2(x:bat[:flt]):bat[:flt] ", "CMDscience_bat_flt_log2;", "" ] +[ "batmmath", "log2", "command batmmath.log2(x:bat[:flt], s:bat[:oid]):bat[:flt] ", "CMDscience_bat_flt_log2_cand;", "" ] [ "batmmath", "pow", "command batmmath.pow(x:bat[:dbl], y:dbl):bat[:dbl] ", "CMDscience_bat_cst_pow_dbl;", "" ] [ "batmmath", "pow", "command batmmath.pow(x:bat[:dbl], y:dbl, s:bat[:oid]):bat[:dbl] ", "CMDscience_bat_cst_pow_dbl_cand;", "" ] [ "batmmath", "pow", "command batmmath.pow(x:bat[:flt], y:flt):bat[:flt] ", "CMDscience_bat_cst_pow_flt;", "" ] @@ -9065,7 +9125,7 @@ Ready. [ "blob", "#write", "command blob.#write():void ", "BLOBwrite;", "" ] [ "blob", "blob", "command blob.blob(s:blob):blob ", "BLOBblob_blob;", "Noop routine." ] [ "blob", "blob", "command blob.blob(s:str):blob ", "BLOBblob_fromstr;", "" ] -[ "blob", "nitems", "command blob.nitems(b:blob):int ", "BLOBnitems;", " get the number of bytes in this blob." ] +[ "blob", "nitems", "command blob.nitems(b:blob):int ", "BLOBnitems;", "get the number of bytes in this blob." ] [ "blob", "prelude", "command blob.prelude():void ", "BLOBprelude;", "" ] [ "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" ] @@ -9079,6 +9139,8 @@ Ready. [ "calc", "!=", "pattern calc.!=(l:uuid, r:uuid, nil_matches:bit):bit ", "CMDvarNE;", "Return V1 != V2" ] [ "calc", "!=", "pattern calc.!=(v1:bit, v2:bit):bit ", "CMDvarNE;", "Return V1 != V2" ] [ "calc", "!=", "pattern calc.!=(v1:bit, v2:bit, nil_matches:bit):bit ", "CMDvarNE;", "Return V1 != V2" ] +[ "calc", "!=", "pattern calc.!=(v1:blob, v2:blob):bit ", "CMDvarNE;", "Return V1 != V2" ] +[ "calc", "!=", "pattern calc.!=(v1:blob, v2:blob, nil_matches:bit):bit ", "CMDvarNE;", "Return V1 != V2" ] [ "calc", "!=", "pattern calc.!=(v1:bte, v2:bte):bit ", "CMDvarNE;", "Return V1 != V2" ] [ "calc", "!=", "pattern calc.!=(v1:bte, v2:bte, nil_matches:bit):bit ", "CMDvarNE;", "Return V1 != V2" ] [ "calc", "!=", "pattern calc.!=(v1:bte, v2:dbl):bit ", "CMDvarNE;", "Return V1 != V2" ] @@ -9654,6 +9716,7 @@ Ready. [ "calc", "<", "pattern calc.<(l:json, r:json):bit ", "CMDvarLT;", "Return V1 < V2" ] [ "calc", "<", "pattern calc.<(l:uuid, r:uuid):bit ", "CMDvarLT;", "Return V1 < V2" ] [ "calc", "<", "pattern calc.<(v1:bit, v2:bit):bit ", "CMDvarLT;", "Return V1 < V2" ] +[ "calc", "<", "pattern calc.<(v1:blob, v2:blob):bit ", "CMDvarLT;", "Return V1 < V2" ] [ "calc", "<", "pattern calc.<(v1:bte, v2:bte):bit ", "CMDvarLT;", "Return V1 < V2" ] [ "calc", "<", "pattern calc.<(v1:bte, v2:dbl):bit ", "CMDvarLT;", "Return V1 < V2" ] [ "calc", "<", "pattern calc.<(v1:bte, v2:flt):bit ", "CMDvarLT;", "Return V1 < V2" ] @@ -9715,6 +9778,7 @@ Ready. [ "calc", "<=", "pattern calc.<=(l:json, r:json):bit ", "CMDvarLE;", "Return V1 <= V2" ] [ "calc", "<=", "pattern calc.<=(l:uuid, r:uuid):bit ", "CMDvarLE;", "Return V1 <= V2" ] [ "calc", "<=", "pattern calc.<=(v1:bit, v2:bit):bit ", "CMDvarLE;", "Return V1 <= V2" ] +[ "calc", "<=", "pattern calc.<=(v1:blob, v2:blob):bit ", "CMDvarLE;", "Return V1 <= V2" ] [ "calc", "<=", "pattern calc.<=(v1:bte, v2:bte):bit ", "CMDvarLE;", "Return V1 <= V2" ] [ "calc", "<=", "pattern calc.<=(v1:bte, v2:dbl):bit ", "CMDvarLE;", "Return V1 <= V2" ] [ "calc", "<=", "pattern calc.<=(v1:bte, v2:flt):bit ", "CMDvarLE;", "Return V1 <= V2" ] @@ -9763,6 +9827,8 @@ Ready. [ "calc", "==", "pattern calc.==(l:uuid, r:uuid, nil_matches:bit):bit ", "CMDvarEQ;", "Return V1 == V2" ] [ "calc", "==", "pattern calc.==(v1:bit, v2:bit):bit ", "CMDvarEQ;", "Return V1 == V2" ] [ "calc", "==", "pattern calc.==(v1:bit, v2:bit, nil_matches:bit):bit ", "CMDvarEQ;", "Return V1 == V2" ] +[ "calc", "==", "pattern calc.==(v1:blob, v2:blob):bit ", "CMDvarEQ;", "Return V1 == V2" ] +[ "calc", "==", "pattern calc.==(v1:blob, v2:blob, nil_matches:bit):bit ", "CMDvarEQ;", "Return V1 == V2" ] [ "calc", "==", "pattern calc.==(v1:bte, v2:bte):bit ", "CMDvarEQ;", "Return V1 == V2" ] [ "calc", "==", "pattern calc.==(v1:bte, v2:bte, nil_matches:bit):bit ", "CMDvarEQ;", "Return V1 == V2" ] [ "calc", "==", "pattern calc.==(v1:bte, v2:dbl):bit ", "CMDvarEQ;", "Return V1 == V2" ] @@ -9849,6 +9915,7 @@ Ready. [ "calc", ">", "pattern calc.>(l:json, r:json):bit ", "CMDvarGT;", "Return V1 > V2" ] [ "calc", ">", "pattern calc.>(l:uuid, r:uuid):bit ", "CMDvarGT;", "Return V1 > V2" ] [ "calc", ">", "pattern calc.>(v1:bit, v2:bit):bit ", "CMDvarGT;", "Return V1 > V2" ] +[ "calc", ">", "pattern calc.>(v1:blob, v2:blob):bit ", "CMDvarGT;", "Return V1 > V2" ] [ "calc", ">", "pattern calc.>(v1:bte, v2:bte):bit ", "CMDvarGT;", "Return V1 > V2" ] [ "calc", ">", "pattern calc.>(v1:bte, v2:dbl):bit ", "CMDvarGT;", "Return V1 > V2" ] [ "calc", ">", "pattern calc.>(v1:bte, v2:flt):bit ", "CMDvarGT;", "Return V1 > V2" ] @@ -9894,6 +9961,7 @@ Ready. [ "calc", ">=", "pattern calc.>=(l:json, r:json):bit ", "CMDvarGE;", "Return V1 >= V2" ] [ "calc", ">=", "pattern calc.>=(l:uuid, r:uuid):bit ", "CMDvarGE;", "Return V1 >= V2" ] [ "calc", ">=", "pattern calc.>=(v1:bit, v2:bit):bit ", "CMDvarGE;", "Return V1 >= V2" ] +[ "calc", ">=", "pattern calc.>=(v1:blob, v2:blob):bit ", "CMDvarGE;", "Return V1 >= V2" ] [ "calc", ">=", "pattern calc.>=(v1:bte, v2:bte):bit ", "CMDvarGE;", "Return V1 >= V2" ] [ "calc", ">=", "pattern calc.>=(v1:bte, v2:dbl):bit ", "CMDvarGE;", "Return V1 >= V2" ] [ "calc", ">=", "pattern calc.>=(v1:bte, v2:flt):bit ", "CMDvarGE;", "Return V1 >= V2" ] @@ -10013,6 +10081,7 @@ Ready. [ "calc", "bit", "pattern calc.bit(v:void):bit ", "CMDvarCONVERT;", "Cast VALUE to bit" ] [ "calc", "blob", "command calc.blob(b:blob):blob ", "BLOBblob_blob;", "" ] [ "calc", "blob", "command calc.blob(s:str):blob ", "BLOBblob_fromstr;", "" ] +[ "calc", "blob", "command calc.blob(v:str):blob ", "str_2_blob;", "cast to blob" ] [ "calc", "bte", "pattern calc.bte(v:bit):bte ", "CMDvarCONVERT;", "Cast VALUE to bte" ] [ "calc", "bte", "pattern calc.bte(v:bte):bte ", "CMDvarCONVERT;", "Cast VALUE to bte" ] [ "calc", "bte", "pattern calc.bte(v:dbl):bte ", "CMDvarCONVERT;", "Cast VALUE to bte" ] @@ -10566,12 +10635,9 @@ Ready. [ "calc", "sign", "pattern calc.sign(v:int):bte ", "CMDvarSIGN;", "Unary sign (-1,0,1) of V" ] [ "calc", "sign", "pattern calc.sign(v:lng):bte ", "CMDvarSIGN;", "Unary sign (-1,0,1) of V" ] [ "calc", "sign", "pattern calc.sign(v:sht):bte ", "CMDvarSIGN;", "Unary sign (-1,0,1) of V" ] -[ "calc", "sqlblob", "command calc.sqlblob(b:sqlblob):sqlblob ", "BLOBblob_blob;", "" ] -[ "calc", "sqlblob", "command calc.sqlblob(s:str):sqlblob ", "BLOBsqlblob_fromstr;", "" ] -[ "calc", "sqlblob", "command calc.sqlblob(v:str):sqlblob ", "str_2_sqlblob;", "cast to sqlblob" ] [ "calc", "str", "pattern calc.str(v:any):str ", "CMDvarCONVERT;", "Cast VALUE to str" ] +[ "calc", "str", "command calc.str(v:blob):str ", "SQLblob_2_str;", "cast blob to str" ] [ "calc", "str", "command calc.str(v:date):str ", "SQLdate_2_str;", "cast date to str" ] -[ "calc", "str", "command calc.str(v:sqlblob):str ", "SQLsqlblob_2_str;", "cast sqlblob to str" ] [ "calc", "str", "pattern calc.str(eclass:int, d1:int, s1:int, has_tz:int, v:any_1, digits:int):str ", "SQLstr_cast;", "cast to string and check for overflow" ] [ "calc", "str", "command calc.str(s:uuid):str ", "UUIDuuid2str;", "Coerce a uuid to a string type" ] _______________________________________________ checkin-list mailing list [email protected] https://www.monetdb.org/mailman/listinfo/checkin-list
