Changeset: d039193fe960 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=d039193fe960
Modified Files:
clients/Tests/MAL-signatures.stable.out
clients/Tests/MAL-signatures.stable.out.int128
clients/Tests/exports.stable.out
monetdb5/mal/Tests/tst1502.malC
monetdb5/mal/Tests/tst233.malC
monetdb5/mal/Tests/tst234.malC
monetdb5/mal/Tests/tst235.malC
monetdb5/mal/Tests/tst903.malC
monetdb5/mal/Tests/tst903.stable.out
monetdb5/modules/atoms/Tests/xml10.malC
monetdb5/modules/kernel/Tests/time01.malC
monetdb5/modules/kernel/algebra.c
monetdb5/modules/kernel/algebra.h
monetdb5/modules/kernel/algebra.mal
monetdb5/modules/mal/Tests/inspect05.malC
monetdb5/modules/mal/Tests/orderidx00.malC
monetdb5/modules/mal/Tests/orderidx04.malC
monetdb5/optimizer/Tests/DCexample2.malC
monetdb5/optimizer/Tests/DCexample2.stable.out
monetdb5/optimizer/Tests/reorder00.malC
monetdb5/optimizer/Tests/reorder00.stable.out
monetdb5/optimizer/Tests/tst4700.malC
monetdb5/optimizer/Tests/tst4700.stable.out
monetdb5/optimizer/opt_candidates.c
monetdb5/optimizer/opt_costModel.c
monetdb5/optimizer/opt_prelude.c
monetdb5/optimizer/opt_prelude.h
sql/backends/monet5/rel_bin.c
sql/backends/monet5/sql_statement.c
sql/test/BugTracker-2010/Tests/LIMIT_OFFSET_big-endian.Bug-2622.stable.out
Branch: default
Log Message:
Rename subsort ->sort again
diffs (truncated from 707 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
@@ -511,16 +511,16 @@ Ready.
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:int,y:int):bat[:any_1] ", "ALGslice_int;",
"Return the slice with the BUNs at position x till y." ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:lng,y:lng):bat[:any_1] ", "ALGslice_lng;",
"Return the slice with the BUNs at position x till y." ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:oid,y:oid):bat[:any_1] ", "ALGslice_oid;",
"Return the slice based on head oid x till y (exclusive)." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],reverse:bit,stable:bit):bat[:any_1] ",
"ALGsort11;", "Returns a copy of the BAT sorted on tail values.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsort12;", "Returns a copy of the BAT
sorted on tail values and a BAT that\n specifies how the input was
reordered.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsort13;", "Returns a
copy of the BAT sorted on tail values, a BAT that specifies\n how the
input was reordered, and a BAT with group information.\n The input and
output are (must be) dense headed.\n The order is descending if the
reverse bit is set.\n\t\t This is a stable sort if the stable bit is set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit):bat[:any_1] ",
"ALGsort21;", "Returns a copy of the BAT sorted on tail values.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsort22;", "Returns a copy of the
BAT sorted on tail values and a BAT that\n specifies how the input was
reordered.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsort23;",
"Returns a copy of the BAT sorted on tail values, a BAT that specifies\n
how the input was reordered, and a BAT with group information.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit):bat[:any_1]
", "ALGsort31;", "Returns a copy of the BAT sorted on tail values.\n
The input and output are (must be) dense headed.\n The order is
descending if the reverse bit is set.\n\t\t This is a stable sort if the stable
bit is set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsort32;", "Returns a copy of the BAT
sorted on tail values and a BAT that\n specifies how the input was
reordered.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsort33;", "Returns a
copy of the BAT sorted on tail values, a BAT that specifies\n how the
input was reordered, and a BAT with group information.\n The input and
output are (must be) dense headed.\n The order is descending if the
reverse bit is set.\n\t\t This is a stable sort if the stable bit is set." ]
[ "algebra", "subslice", "command
algebra.subslice(b:bat[:any_1],x:lng,y:lng):bat[:oid] ",
"ALGsubslice_lng;", "Return the oids of the slice with the BUNs at position
x till y." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],reverse:bit,stable:bit):bat[:any_1] ",
"ALGsubsort11;", "Returns a copy of the BAT sorted on tail values.\n
The input and output are (must be) dense headed.\n The order is
descending if the reverse bit is set.\n\t\t This is a stable sort if the stable
bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsubsort12;", "Returns a
copy of the BAT sorted on tail values and a BAT that\n specifies how
the input was reordered.\n The input and output are (must be) dense
headed.\n The order is descending if the reverse bit is set.\n\t\t This
is a stable sort if the stable bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsubsort13;",
"Returns a copy of the BAT sorted on tail values, a BAT that specifies\n
how the input was reordered, and a BAT with group information.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit):bat[:any_1]
", "ALGsubsort21;", "Returns a copy of the BAT sorted on tail
values.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsubsort22;", "Returns a copy of
the BAT sorted on tail values and a BAT that\n specifies how the input
was reordered.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable
sort if the stable bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsubsort23;",
"Returns a copy of the BAT sorted on tail values, a BAT that specifies\n
how the input was reordered, and a BAT with group information.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit):bat[:any_1]
", "ALGsubsort31;", "Returns a copy of the BAT sorted on tail
values.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsubsort32;", "Returns a
copy of the BAT sorted on tail values and a BAT that\n specifies how
the input was reordered.\n The input and output are (must be) dense
headed.\n The order is descending if the reverse bit is set.\n\t\t This
is a stable sort if the stable bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsubsort33;",
"Returns a copy of the BAT sorted on tail values, a BAT that specifies\n
how the input was reordered, and a BAT with group information.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
[ "algebra", "thetajoin", "command
algebra.thetajoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],op:int,nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGthetajoin;", "Theta join with
candidate lists" ]
[ "algebra", "thetaselect", "command
algebra.thetaselect(b:bat[:any_1],val:any_1,op:str):bat[:oid] ",
"ALGthetaselect1;", "Select all head values for which the tail value obeys
the relation\n\tvalue OP VAL.\n\tInput is a dense-headed BAT, output is a
dense-headed BAT with in\n\tthe tail the head value of the input BAT for which
the\n\trelationship holds. The output BAT is sorted on the tail value."
]
[ "algebra", "thetaselect", "command
algebra.thetaselect(b:bat[:any_1],s:bat[:oid],val:any_1,op:str):bat[:oid] ",
"ALGthetaselect2;", "Select all head values of the first input BAT for
which the tail value\n\tobeys the relation value OP VAL and for which the head
value occurs in\n\tthe tail of the second input BAT.\n\tInput is a dense-headed
BAT, output is a dense-headed BAT with in\n\tthe tail the head value of the
input BAT for which the\n\trelationship holds. The output BAT is sorted on the
tail value." ]
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
@@ -615,16 +615,16 @@ Ready.
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:int,y:int):bat[:any_1] ", "ALGslice_int;",
"Return the slice with the BUNs at position x till y." ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:lng,y:lng):bat[:any_1] ", "ALGslice_lng;",
"Return the slice with the BUNs at position x till y." ]
[ "algebra", "slice", "command
algebra.slice(b:bat[:any_1],x:oid,y:oid):bat[:any_1] ", "ALGslice_oid;",
"Return the slice based on head oid x till y (exclusive)." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],reverse:bit,stable:bit):bat[:any_1] ",
"ALGsort11;", "Returns a copy of the BAT sorted on tail values.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsort12;", "Returns a copy of the BAT
sorted on tail values and a BAT that\n specifies how the input was
reordered.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsort13;", "Returns a
copy of the BAT sorted on tail values, a BAT that specifies\n how the
input was reordered, and a BAT with group information.\n The input and
output are (must be) dense headed.\n The order is descending if the
reverse bit is set.\n\t\t This is a stable sort if the stable bit is set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit):bat[:any_1] ",
"ALGsort21;", "Returns a copy of the BAT sorted on tail values.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsort22;", "Returns a copy of the
BAT sorted on tail values and a BAT that\n specifies how the input was
reordered.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsort23;",
"Returns a copy of the BAT sorted on tail values, a BAT that specifies\n
how the input was reordered, and a BAT with group information.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit):bat[:any_1]
", "ALGsort31;", "Returns a copy of the BAT sorted on tail values.\n
The input and output are (must be) dense headed.\n The order is
descending if the reverse bit is set.\n\t\t This is a stable sort if the stable
bit is set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsort32;", "Returns a copy of the BAT
sorted on tail values and a BAT that\n specifies how the input was
reordered.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
+[ "algebra", "sort", "command
algebra.sort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsort33;", "Returns a
copy of the BAT sorted on tail values, a BAT that specifies\n how the
input was reordered, and a BAT with group information.\n The input and
output are (must be) dense headed.\n The order is descending if the
reverse bit is set.\n\t\t This is a stable sort if the stable bit is set." ]
[ "algebra", "subslice", "command
algebra.subslice(b:bat[:any_1],x:lng,y:lng):bat[:oid] ",
"ALGsubslice_lng;", "Return the oids of the slice with the BUNs at position
x till y." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],reverse:bit,stable:bit):bat[:any_1] ",
"ALGsubsort11;", "Returns a copy of the BAT sorted on tail values.\n
The input and output are (must be) dense headed.\n The order is
descending if the reverse bit is set.\n\t\t This is a stable sort if the stable
bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsubsort12;", "Returns a
copy of the BAT sorted on tail values and a BAT that\n specifies how
the input was reordered.\n The input and output are (must be) dense
headed.\n The order is descending if the reverse bit is set.\n\t\t This
is a stable sort if the stable bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsubsort13;",
"Returns a copy of the BAT sorted on tail values, a BAT that specifies\n
how the input was reordered, and a BAT with group information.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit):bat[:any_1]
", "ALGsubsort21;", "Returns a copy of the BAT sorted on tail
values.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsubsort22;", "Returns a copy of
the BAT sorted on tail values and a BAT that\n specifies how the input
was reordered.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable
sort if the stable bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsubsort23;",
"Returns a copy of the BAT sorted on tail values, a BAT that specifies\n
how the input was reordered, and a BAT with group information.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit):bat[:any_1]
", "ALGsubsort31;", "Returns a copy of the BAT sorted on tail
values.\n The input and output are (must be) dense headed.\n
The order is descending if the reverse bit is set.\n\t\t This is a stable sort
if the stable bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid]) ", "ALGsubsort32;", "Returns a
copy of the BAT sorted on tail values and a BAT that\n specifies how
the input was reordered.\n The input and output are (must be) dense
headed.\n The order is descending if the reverse bit is set.\n\t\t This
is a stable sort if the stable bit is set." ]
-[ "algebra", "subsort", "command
algebra.subsort(b:bat[:any_1],o:bat[:oid],g:bat[:oid],reverse:bit,stable:bit)
(X_0:bat[:any_1],X_1:bat[:oid],X_2:bat[:oid]) ", "ALGsubsort33;",
"Returns a copy of the BAT sorted on tail values, a BAT that specifies\n
how the input was reordered, and a BAT with group information.\n The
input and output are (must be) dense headed.\n The order is descending
if the reverse bit is set.\n\t\t This is a stable sort if the stable bit is
set." ]
[ "algebra", "thetajoin", "command
algebra.thetajoin(l:bat[:any_1],r:bat[:any_1],sl:bat[:oid],sr:bat[:oid],op:int,nil_matches:bit,estimate:lng)
(X_0:bat[:oid],X_1:bat[:oid]) ", "ALGthetajoin;", "Theta join with
candidate lists" ]
[ "algebra", "thetaselect", "command
algebra.thetaselect(b:bat[:any_1],val:any_1,op:str):bat[:oid] ",
"ALGthetaselect1;", "Select all head values for which the tail value obeys
the relation\n\tvalue OP VAL.\n\tInput is a dense-headed BAT, output is a
dense-headed BAT with in\n\tthe tail the head value of the input BAT for which
the\n\trelationship holds. The output BAT is sorted on the tail value."
]
[ "algebra", "thetaselect", "command
algebra.thetaselect(b:bat[:any_1],s:bat[:oid],val:any_1,op:str):bat[:oid] ",
"ALGthetaselect2;", "Select all head values of the first input BAT for
which the tail value\n\tobeys the relation value OP VAL and for which the head
value occurs in\n\tthe tail of the second input BAT.\n\tInput is a dense-headed
BAT, output is a dense-headed BAT with in\n\tthe tail the head value of the
input BAT for which the\n\trelationship holds. The output BAT is sorted on the
tail value." ]
diff --git a/clients/Tests/exports.stable.out b/clients/Tests/exports.stable.out
--- a/clients/Tests/exports.stable.out
+++ b/clients/Tests/exports.stable.out
@@ -716,18 +716,18 @@ str ALGslice(bat *ret, const bat *bid, c
str ALGslice_int(bat *ret, const bat *bid, const int *start, const int *end);
str ALGslice_lng(bat *ret, const bat *bid, const lng *start, const lng *end);
str ALGslice_oid(bat *ret, const bat *bid, const oid *start, const oid *end);
+str ALGsort11(bat *result, const bat *bid, const bit *reverse, const bit
*stable);
+str ALGsort12(bat *result, bat *norder, const bat *bid, const bit *reverse,
const bit *stable);
+str ALGsort13(bat *result, bat *norder, bat *ngroup, const bat *bid, const bit
*reverse, const bit *stable);
+str ALGsort21(bat *result, const bat *bid, const bat *order, const bit
*reverse, const bit *stable);
+str ALGsort22(bat *result, bat *norder, const bat *bid, const bat *order,
const bit *reverse, const bit *stable);
+str ALGsort23(bat *result, bat *norder, bat *ngroup, const bat *bid, const bat
*order, const bit *reverse, const bit *stable);
+str ALGsort31(bat *result, const bat *bid, const bat *order, const bat *group,
const bit *reverse, const bit *stable);
+str ALGsort32(bat *result, bat *norder, const bat *bid, const bat *order,
const bat *group, const bit *reverse, const bit *stable);
+str ALGsort33(bat *result, bat *norder, bat *ngroup, const bat *bid, const bat
*order, const bat *group, const bit *reverse, const bit *stable);
str ALGstdev(dbl *res, const bat *bid);
str ALGstdevp(dbl *res, const bat *bid);
str ALGsubslice_lng(bat *ret, const bat *bid, const lng *start, const lng
*end);
-str ALGsubsort11(bat *result, const bat *bid, const bit *reverse, const bit
*stable);
-str ALGsubsort12(bat *result, bat *norder, const bat *bid, const bit *reverse,
const bit *stable);
-str ALGsubsort13(bat *result, bat *norder, bat *ngroup, const bat *bid, const
bit *reverse, const bit *stable);
-str ALGsubsort21(bat *result, const bat *bid, const bat *order, const bit
*reverse, const bit *stable);
-str ALGsubsort22(bat *result, bat *norder, const bat *bid, const bat *order,
const bit *reverse, const bit *stable);
-str ALGsubsort23(bat *result, bat *norder, bat *ngroup, const bat *bid, const
bat *order, const bit *reverse, const bit *stable);
-str ALGsubsort31(bat *result, const bat *bid, const bat *order, const bat
*group, const bit *reverse, const bit *stable);
-str ALGsubsort32(bat *result, bat *norder, const bat *bid, const bat *order,
const bat *group, const bit *reverse, const bit *stable);
-str ALGsubsort33(bat *result, bat *norder, bat *ngroup, const bat *bid, const
bat *order, const bat *group, const bit *reverse, const bit *stable);
str ALGtdiff(bat *result, const bat *lid, const bat *rid);
str ALGthetajoin(bat *r1, bat *r2, const bat *l, const bat *r, const bat *sl,
const bat *sr, const int *op, const bit *nil_matches, const lng *estimate);
str ALGthetaselect1(bat *result, const bat *bid, const void *val, const char
**op);
@@ -2414,6 +2414,7 @@ str schedulerRef;
str selectNotNilRef;
str selectRef;
str semaRef;
+str semijoinRef;
str seriesRef;
str setAccessRef;
void setArgType(MalBlkPtr mb, InstrPtr p, int i, int tpe);
@@ -2447,6 +2448,7 @@ str sinkRef;
void slash_2_dir_sep(str fname);
str sliceRef;
str sortRef;
+str sortRef;
str sortReverseRef;
str soundex_impl(str *res, str *Name);
str sqlRef;
@@ -2479,7 +2481,6 @@ str submedianRef;
str subminRef;
str subprodRef;
str subsliceRef;
-str subsortRef;
str subsumRef;
str subuniformRef;
str sumRef;
diff --git a/monetdb5/mal/Tests/tst1502.malC b/monetdb5/mal/Tests/tst1502.malC
--- a/monetdb5/mal/Tests/tst1502.malC
+++ b/monetdb5/mal/Tests/tst1502.malC
@@ -36,9 +36,9 @@
bat.append(z,"c");
bat.append(z,"a");
io.print("sort x");
- xs:=algebra.subsort(x,false:bit,false:bit);
+ xs:=algebra.sort(x,false:bit,false:bit);
io.print(xs);
io.print("hsort xrev");
- xrev:=algebra.subsort(x,true:bit,false:bit);
+ xrev:=algebra.sort(x,true:bit,false:bit);
io.print(xrev);
diff --git a/monetdb5/mal/Tests/tst233.malC b/monetdb5/mal/Tests/tst233.malC
--- a/monetdb5/mal/Tests/tst233.malC
+++ b/monetdb5/mal/Tests/tst233.malC
@@ -4,7 +4,7 @@ function dir():void;
d:= bbp.getRefCount();
dl:=bbp.getLRefCount();
dn:= bbp.getNames();
- ds:= algebra.subsort(dn,false,false);
+ ds:= algebra.sort(dn,false,false);
io.print(ds,d,dl);
end dir;
diff --git a/monetdb5/mal/Tests/tst234.malC b/monetdb5/mal/Tests/tst234.malC
--- a/monetdb5/mal/Tests/tst234.malC
+++ b/monetdb5/mal/Tests/tst234.malC
@@ -4,7 +4,7 @@ function dir():void;
d:= bbp.getRefCount();
dl:=bbp.getLRefCount();
dn:= bbp.getNames();
- ds:= algebra.subsort(dn,false,false);
+ ds:= algebra.sort(dn,false,false);
io.print(ds,d,dl);
end dir;
diff --git a/monetdb5/mal/Tests/tst235.malC b/monetdb5/mal/Tests/tst235.malC
--- a/monetdb5/mal/Tests/tst235.malC
+++ b/monetdb5/mal/Tests/tst235.malC
@@ -5,7 +5,7 @@ function dir():void;
d:= bbp.getRefCount();
dl:=bbp.getLRefCount();
dn:= bbp.getNames();
- ds:= algebra.subsort(dn,false,false);
+ ds:= algebra.sort(dn,false,false);
io.print(ds,d,dl);
end dir;
diff --git a/monetdb5/mal/Tests/tst903.malC b/monetdb5/mal/Tests/tst903.malC
--- a/monetdb5/mal/Tests/tst903.malC
+++ b/monetdb5/mal/Tests/tst903.malC
@@ -111,7 +111,7 @@ io.printf("#select 1.0 %d",d0);
cnt:= aggr.count(z9);
io.printf(" count %d\n",cnt);
t0:= alarm.usec();
-s:= algebra.subsort(b,false,false);
+s:= algebra.sort(b,false,false);
t1:= alarm.usec();
d0:= t1-t0;
io.printf("#head sort %d",d0);
diff --git a/monetdb5/mal/Tests/tst903.stable.out
b/monetdb5/mal/Tests/tst903.stable.out
--- a/monetdb5/mal/Tests/tst903.stable.out
+++ b/monetdb5/mal/Tests/tst903.stable.out
@@ -130,7 +130,7 @@ exit i;
cnt := aggr.count(z9);
io.printf(" count %d\n",cnt);
t0 := alarm.usec();
- s := algebra.subsort(b,false,false);
+ s := algebra.sort(b,false,false);
t1 := alarm.usec();
d0 := calc.-(t1,t0);
io.printf("#head sort %d",d0);
diff --git a/monetdb5/modules/atoms/Tests/xml10.malC
b/monetdb5/modules/atoms/Tests/xml10.malC
--- a/monetdb5/modules/atoms/Tests/xml10.malC
+++ b/monetdb5/modules/atoms/Tests/xml10.malC
@@ -40,7 +40,7 @@ bat.append(e,0);
k:= algebra.projection(g,te);
io.print(k);
-l:= algebra.subsort(k,false,false);
+l:= algebra.sort(k,false,false);
io.print(l);
ag:= xml.subaggr(te,g,e,true);
diff --git a/monetdb5/modules/kernel/Tests/time01.malC
b/monetdb5/modules/kernel/Tests/time01.malC
--- a/monetdb5/modules/kernel/Tests/time01.malC
+++ b/monetdb5/modules/kernel/Tests/time01.malC
@@ -7,7 +7,7 @@ b0 := bat.new(:daytime);
bat.append(b0, x0);
bat.append(b0, x1);
bat.append(b0, x2);
-b2 := algebra.subsort(b0,false,false);
+b2 := algebra.sort(b0,false,false);
b1 := bat.new(:daytime);
bat.append(b1, x0);
diff --git a/monetdb5/modules/kernel/algebra.c
b/monetdb5/modules/kernel/algebra.c
--- a/monetdb5/modules/kernel/algebra.c
+++ b/monetdb5/modules/kernel/algebra.c
@@ -682,22 +682,22 @@ ALGprojection(bat *result, const bat *li
}
str
-ALGsubsort33(bat *result, bat *norder, bat *ngroup, const bat *bid, const bat
*order, const bat *group, const bit *reverse, const bit *stable)
+ALGsort33(bat *result, bat *norder, bat *ngroup, const bat *bid, const bat
*order, const bat *group, const bit *reverse, const bit *stable)
{
BAT *bn = NULL, *on = NULL, *gn = NULL;
BAT *b = NULL, *o = NULL, *g = NULL;
if ((b = BATdescriptor(*bid)) == NULL)
- throw(MAL, "algebra.subsort", RUNTIME_OBJECT_MISSING);
+ throw(MAL, "algebra.sort", RUNTIME_OBJECT_MISSING);
if (order && *order != bat_nil && (o = BATdescriptor(*order)) == NULL) {
BBPunfix(b->batCacheid);
- throw(MAL, "algebra.subsort", RUNTIME_OBJECT_MISSING);
+ throw(MAL, "algebra.sort", RUNTIME_OBJECT_MISSING);
}
if (group && *group != bat_nil && (g = BATdescriptor(*group)) == NULL) {
if (o)
BBPunfix(o->batCacheid);
BBPunfix(b->batCacheid);
- throw(MAL, "algebra.subsort", RUNTIME_OBJECT_MISSING);
+ throw(MAL, "algebra.sort", RUNTIME_OBJECT_MISSING);
}
if (BATsort(result ? &bn : NULL,
norder ? &on : NULL,
@@ -708,7 +708,7 @@ ALGsubsort33(bat *result, bat *norder, b
if (g)
BBPunfix(g->batCacheid);
BBPunfix(b->batCacheid);
- throw(MAL, "algebra.subsort", OPERATION_FAILED);
+ throw(MAL, "algebra.sort", OPERATION_FAILED);
}
BBPunfix(b->batCacheid);
if (o)
@@ -725,51 +725,51 @@ ALGsubsort33(bat *result, bat *norder, b
}
str
-ALGsubsort32(bat *result, bat *norder, const bat *bid, const bat *order, const
bat *group, const bit *reverse, const bit *stable)
+ALGsort32(bat *result, bat *norder, const bat *bid, const bat *order, const
bat *group, const bit *reverse, const bit *stable)
{
- return ALGsubsort33(result, norder, NULL, bid, order, group, reverse,
stable);
+ return ALGsort33(result, norder, NULL, bid, order, group, reverse,
stable);
}
str
-ALGsubsort31(bat *result, const bat *bid, const bat *order, const bat *group,
const bit *reverse, const bit *stable)
+ALGsort31(bat *result, const bat *bid, const bat *order, const bat *group,
const bit *reverse, const bit *stable)
{
- return ALGsubsort33(result, NULL, NULL, bid, order, group, reverse,
stable);
+ return ALGsort33(result, NULL, NULL, bid, order, group, reverse,
stable);
}
str
-ALGsubsort23(bat *result, bat *norder, bat *ngroup, const bat *bid, const bat
*order, const bit *reverse, const bit *stable)
+ALGsort23(bat *result, bat *norder, bat *ngroup, const bat *bid, const bat
*order, const bit *reverse, const bit *stable)
{
- return ALGsubsort33(result, norder, ngroup, bid, order, NULL, reverse,
stable);
+ return ALGsort33(result, norder, ngroup, bid, order, NULL, reverse,
stable);
}
str
-ALGsubsort22(bat *result, bat *norder, const bat *bid, const bat *order, const
bit *reverse, const bit *stable)
+ALGsort22(bat *result, bat *norder, const bat *bid, const bat *order, const
bit *reverse, const bit *stable)
{
- return ALGsubsort33(result, norder, NULL, bid, order, NULL, reverse,
stable);
+ return ALGsort33(result, norder, NULL, bid, order, NULL, reverse,
stable);
}
str
-ALGsubsort21(bat *result, const bat *bid, const bat *order, const bit
*reverse, const bit *stable)
+ALGsort21(bat *result, const bat *bid, const bat *order, const bit *reverse,
const bit *stable)
{
- return ALGsubsort33(result, NULL, NULL, bid, order, NULL, reverse,
stable);
+ return ALGsort33(result, NULL, NULL, bid, order, NULL, reverse, stable);
}
str
-ALGsubsort13(bat *result, bat *norder, bat *ngroup, const bat *bid, const bit
*reverse, const bit *stable)
+ALGsort13(bat *result, bat *norder, bat *ngroup, const bat *bid, const bit
*reverse, const bit *stable)
{
- return ALGsubsort33(result, norder, ngroup, bid, NULL, NULL, reverse,
stable);
+ return ALGsort33(result, norder, ngroup, bid, NULL, NULL, reverse,
stable);
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
