Changeset: c2402feef4db for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=c2402feef4db
Modified Files:
clients/Tests/MAL-signatures_all.stable.out
clients/Tests/MAL-signatures_all.stable.out.int128
clients/Tests/MAL-signatures_fits_geom.stable.out
clients/Tests/MAL-signatures_fits_geom.stable.out.int128
clients/Tests/MAL-signatures_geom.stable.out
clients/Tests/MAL-signatures_geom.stable.out.int128
clients/Tests/MAL-signatures_none.stable.out
clients/Tests/MAL-signatures_none.stable.out.int128
clients/Tests/exports.stable.out
monetdb5/mal/Tests/tst029.mal
monetdb5/mal/Tests/tst029.stable.out
monetdb5/mal/Tests/tst237.mal
monetdb5/mal/Tests/tst280.mal
monetdb5/mal/Tests/tst280.stable.out
monetdb5/modules/kernel/aggr.mal
monetdb5/modules/kernel/aggr.mal.sh
monetdb5/modules/kernel/algebra.mal
monetdb5/modules/kernel/batmmath.c
monetdb5/modules/kernel/mmath.c
monetdb5/modules/mal/Tests/ascii_io2.mal
monetdb5/modules/mal/Tests/ascii_io2.stable.out
monetdb5/modules/mal/Tests/inspect05.stable.out
monetdb5/modules/mal/Tests/manifold.mal
monetdb5/modules/mal/Tests/manifold.stable.out
monetdb5/modules/mal/Tests/manifoldstr.mal
monetdb5/modules/mal/Tests/manifoldstr.stable.out
monetdb5/tests/suite_00/Tests/test_40.mal
monetdb5/tests/suite_00/Tests/test_40.stable.out
Branch: default
Log Message:
Merge with Oct2014 branch.
diffs (truncated from 755 to 300 lines):
diff --git a/clients/Tests/MAL-signatures_all.stable.out
b/clients/Tests/MAL-signatures_all.stable.out
--- a/clients/Tests/MAL-signatures_all.stable.out
+++ b/clients/Tests/MAL-signatures_all.stable.out
@@ -2274,10 +2274,6 @@ command algebra.bandjoin(outer:bat[:oid,
address ALGbandjoin2;
comment This is a join() for which the predicate is that two BUNs match
if the left-tail value is within the range [right-head - minus,
right-head + plus], depending on (l_in/h_in), the bounds are
included. Works only for the builtin numerical types, and their
derivates.
-command
algebra.crossproduct(left:bat[:any_1,:any_2],right:bat[:any_3,:any_4]):bat[:any_1,:any_4]
-address ALGcross;
-comment Returns the cross product
-
command algebra.crossproduct(left:bat[:oid,:any_1],right:bat[:oid,:any_2])
(l:bat[:oid,:oid],r:bat[:oid,:oid])
address ALGcrossproduct2;
comment Returns 2 columns with all BUNs, consisting of the head-oids from
'left' and 'right' for which there are BUNs in 'left' and 'right' with
equal tails
@@ -2429,18 +2425,6 @@ command algebra.mark_grp(b:bat[:any_1,:o
address ALGmark_grp_1;
comment "grouped mark": Produces a new BAT with per group a locally unique
dense ascending sequence of OIDs in the tail. The tail of the first BAT (b)
identifies the group that each BUN of b belongs to. The second BAT (g)
represents the group extent, i.e., the head is the unique list of group IDs
from b's tail. The tail of g gives for each group the base value for the new
OID sequence.
-command
algebra.markH(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:oid,:any_2]
-address ALGhmarkp;
-comment Produces a BAT with fresh unique dense sequense of OIDs in the
head that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
-
-command algebra.markH(b:bat[:any_1,:any_2],base:oid):bat[:oid,:any_2]
-address ALGmarkHead;
-comment Produces a new BAT with fresh unique dense sequense of OIDs in
the head that starts at base (i.e. [base,..base+b.count()-1] ).
-
-command algebra.markH(b:bat[:any_1,:any_2]):bat[:oid,:any_2]
-address ALGmarkHead_default;
-comment Produces a BAT with fresh OIDs in the head starting at 0@0.
-
command
algebra.mark(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:any_1,:oid]
address ALGtmarkp;
comment Produces a BAT with fresh unique dense sequense of OIDs in the
tail that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
diff --git a/clients/Tests/MAL-signatures_all.stable.out.int128
b/clients/Tests/MAL-signatures_all.stable.out.int128
--- a/clients/Tests/MAL-signatures_all.stable.out.int128
+++ b/clients/Tests/MAL-signatures_all.stable.out.int128
@@ -2791,10 +2791,6 @@ command algebra.bandjoin(outer:bat[:oid,
address ALGbandjoin2;
comment This is a join() for which the predicate is that two BUNs match
if the left-tail value is within the range [right-head - minus,
right-head + plus], depending on (l_in/h_in), the bounds are
included. Works only for the builtin numerical types, and their
derivates.
-command
algebra.crossproduct(left:bat[:any_1,:any_2],right:bat[:any_3,:any_4]):bat[:any_1,:any_4]
-address ALGcross;
-comment Returns the cross product
-
command algebra.crossproduct(left:bat[:oid,:any_1],right:bat[:oid,:any_2])
(l:bat[:oid,:oid],r:bat[:oid,:oid])
address ALGcrossproduct2;
comment Returns 2 columns with all BUNs, consisting of the head-oids from
'left' and 'right' for which there are BUNs in 'left' and 'right' with
equal tails
@@ -2937,18 +2933,6 @@ command algebra.mark_grp(b:bat[:any_1,:o
address ALGmark_grp_1;
comment "grouped mark": Produces a new BAT with per group a locally unique
dense ascending sequence of OIDs in the tail. The tail of the first BAT (b)
identifies the group that each BUN of b belongs to. The second BAT (g)
represents the group extent, i.e., the head is the unique list of group IDs
from b's tail. The tail of g gives for each group the base value for the new
OID sequence.
-command
algebra.markH(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:oid,:any_2]
-address ALGhmarkp;
-comment Produces a BAT with fresh unique dense sequense of OIDs in the
head that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
-
-command algebra.markH(b:bat[:any_1,:any_2],base:oid):bat[:oid,:any_2]
-address ALGmarkHead;
-comment Produces a new BAT with fresh unique dense sequense of OIDs in
the head that starts at base (i.e. [base,..base+b.count()-1] ).
-
-command algebra.markH(b:bat[:any_1,:any_2]):bat[:oid,:any_2]
-address ALGmarkHead_default;
-comment Produces a BAT with fresh OIDs in the head starting at 0@0.
-
command
algebra.markT(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:any_1,:oid]
address ALGtmarkp;
comment Produces a BAT with fresh unique dense sequense of OIDs in the
tail that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
diff --git a/clients/Tests/MAL-signatures_fits_geom.stable.out
b/clients/Tests/MAL-signatures_fits_geom.stable.out
--- a/clients/Tests/MAL-signatures_fits_geom.stable.out
+++ b/clients/Tests/MAL-signatures_fits_geom.stable.out
@@ -2275,10 +2275,6 @@ command algebra.bandjoin(outer:bat[:oid,
address ALGbandjoin2;
comment This is a join() for which the predicate is that two BUNs match
if the left-tail value is within the range [right-head - minus,
right-head + plus], depending on (l_in/h_in), the bounds
are included. Works only for the builtin numerical types, and
their derivates.
-command
algebra.crossproduct(left:bat[:any_1,:any_2],right:bat[:any_3,:any_4]):bat[:any_1,:any_4]
-address ALGcross;
-comment Returns the cross product
-
command algebra.crossproduct(left:bat[:oid,:any_1],right:bat[:oid,:any_2])
(l:bat[:oid,:oid],r:bat[:oid,:oid])
address ALGcrossproduct2;
comment Returns 2 columns with all BUNs, consisting of the head-oids from
'left' and 'right' for which there are BUNs in 'left' and 'right' with
equal tails
@@ -2430,18 +2426,6 @@ command algebra.mark_grp(b:bat[:any_1,:o
address ALGmark_grp_1;
comment "grouped mark": Produces a new BAT with per group a locally unique
dense ascending sequence of OIDs in the tail. The tail of the first BAT (b)
identifies the group that each BUN of b belongs to. The second BAT (g)
represents the group extent, i.e., the head is the unique list of group IDs
from b's tail. The tail of g gives for each group the base value for the new
OID sequence.
-command
algebra.markH(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:oid,:any_2]
-address ALGhmarkp;
-comment Produces a BAT with fresh unique dense sequense of OIDs in the
head that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
-
-command algebra.markH(b:bat[:any_1,:any_2],base:oid):bat[:oid,:any_2]
-address ALGmarkHead;
-comment Produces a new BAT with fresh unique dense sequense of OIDs in
the head that starts at base (i.e. [base,..base+b.count()-1] ).
-
-command algebra.markH(b:bat[:any_1,:any_2]):bat[:oid,:any_2]
-address ALGmarkHead_default;
-comment Produces a BAT with fresh OIDs in the head starting at 0@0.
-
command
algebra.mark(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:any_1,:oid]
address ALGtmarkp;
comment Produces a BAT with fresh unique dense sequense of OIDs in the
tail that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
diff --git a/clients/Tests/MAL-signatures_fits_geom.stable.out.int128
b/clients/Tests/MAL-signatures_fits_geom.stable.out.int128
--- a/clients/Tests/MAL-signatures_fits_geom.stable.out.int128
+++ b/clients/Tests/MAL-signatures_fits_geom.stable.out.int128
@@ -2791,10 +2791,6 @@ command algebra.bandjoin(outer:bat[:oid,
address ALGbandjoin2;
comment This is a join() for which the predicate is that two BUNs match
if the left-tail value is within the range [right-head - minus,
right-head + plus], depending on (l_in/h_in), the bounds
are included. Works only for the builtin numerical types, and
their derivates.
-command
algebra.crossproduct(left:bat[:any_1,:any_2],right:bat[:any_3,:any_4]):bat[:any_1,:any_4]
-address ALGcross;
-comment Returns the cross product
-
command algebra.crossproduct(left:bat[:oid,:any_1],right:bat[:oid,:any_2])
(l:bat[:oid,:oid],r:bat[:oid,:oid])
address ALGcrossproduct2;
comment Returns 2 columns with all BUNs, consisting of the head-oids from
'left' and 'right' for which there are BUNs in 'left' and 'right' with
equal tails
@@ -2937,18 +2933,6 @@ command algebra.mark_grp(b:bat[:any_1,:o
address ALGmark_grp_1;
comment "grouped mark": Produces a new BAT with per group a locally unique
dense ascending sequence of OIDs in the tail. The tail of the first BAT (b)
identifies the group that each BUN of b belongs to. The second BAT (g)
represents the group extent, i.e., the head is the unique list of group IDs
from b's tail. The tail of g gives for each group the base value for the new
OID sequence.
-command
algebra.markH(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:oid,:any_2]
-address ALGhmarkp;
-comment Produces a BAT with fresh unique dense sequense of OIDs in the
head that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
-
-command algebra.markH(b:bat[:any_1,:any_2],base:oid):bat[:oid,:any_2]
-address ALGmarkHead;
-comment Produces a new BAT with fresh unique dense sequense of OIDs in
the head that starts at base (i.e. [base,..base+b.count()-1] ).
-
-command algebra.markH(b:bat[:any_1,:any_2]):bat[:oid,:any_2]
-address ALGmarkHead_default;
-comment Produces a BAT with fresh OIDs in the head starting at 0@0.
-
command
algebra.markT(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:any_1,:oid]
address ALGtmarkp;
comment Produces a BAT with fresh unique dense sequense of OIDs in the
tail that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
diff --git a/clients/Tests/MAL-signatures_geom.stable.out
b/clients/Tests/MAL-signatures_geom.stable.out
--- a/clients/Tests/MAL-signatures_geom.stable.out
+++ b/clients/Tests/MAL-signatures_geom.stable.out
@@ -2275,10 +2275,6 @@ command algebra.bandjoin(outer:bat[:oid,
address ALGbandjoin2;
comment This is a join() for which the predicate is that two BUNs match
if the left-tail value is within the range [right-head - minus,
right-head + plus], depending on (l_in/h_in), the bounds
are included. Works only for the builtin numerical types, and
their derivates.
-command
algebra.crossproduct(left:bat[:any_1,:any_2],right:bat[:any_3,:any_4]):bat[:any_1,:any_4]
-address ALGcross;
-comment Returns the cross product
-
command algebra.crossproduct(left:bat[:oid,:any_1],right:bat[:oid,:any_2])
(l:bat[:oid,:oid],r:bat[:oid,:oid])
address ALGcrossproduct2;
comment Returns 2 columns with all BUNs, consisting of the head-oids from
'left' and 'right' for which there are BUNs in 'left' and 'right' with
equal tails
@@ -2430,18 +2426,6 @@ command algebra.mark_grp(b:bat[:any_1,:o
address ALGmark_grp_1;
comment "grouped mark": Produces a new BAT with per group a locally unique
dense ascending sequence of OIDs in the tail. The tail of the first BAT (b)
identifies the group that each BUN of b belongs to. The second BAT (g)
represents the group extent, i.e., the head is the unique list of group IDs
from b's tail. The tail of g gives for each group the base value for the new
OID sequence.
-command
algebra.markH(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:oid,:any_2]
-address ALGhmarkp;
-comment Produces a BAT with fresh unique dense sequense of OIDs in the
head that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
-
-command algebra.markH(b:bat[:any_1,:any_2],base:oid):bat[:oid,:any_2]
-address ALGmarkHead;
-comment Produces a new BAT with fresh unique dense sequense of OIDs in
the head that starts at base (i.e. [base,..base+b.count()-1] ).
-
-command algebra.markH(b:bat[:any_1,:any_2]):bat[:oid,:any_2]
-address ALGmarkHead_default;
-comment Produces a BAT with fresh OIDs in the head starting at 0@0.
-
command
algebra.mark(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:any_1,:oid]
address ALGtmarkp;
comment Produces a BAT with fresh unique dense sequense of OIDs in the
tail that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
diff --git a/clients/Tests/MAL-signatures_geom.stable.out.int128
b/clients/Tests/MAL-signatures_geom.stable.out.int128
--- a/clients/Tests/MAL-signatures_geom.stable.out.int128
+++ b/clients/Tests/MAL-signatures_geom.stable.out.int128
@@ -2791,10 +2791,6 @@ command algebra.bandjoin(outer:bat[:oid,
address ALGbandjoin2;
comment This is a join() for which the predicate is that two BUNs match
if the left-tail value is within the range [right-head - minus,
right-head + plus], depending on (l_in/h_in), the bounds
are included. Works only for the builtin numerical types, and
their derivates.
-command
algebra.crossproduct(left:bat[:any_1,:any_2],right:bat[:any_3,:any_4]):bat[:any_1,:any_4]
-address ALGcross;
-comment Returns the cross product
-
command algebra.crossproduct(left:bat[:oid,:any_1],right:bat[:oid,:any_2])
(l:bat[:oid,:oid],r:bat[:oid,:oid])
address ALGcrossproduct2;
comment Returns 2 columns with all BUNs, consisting of the head-oids from
'left' and 'right' for which there are BUNs in 'left' and 'right' with
equal tails
@@ -2937,18 +2933,6 @@ command algebra.mark_grp(b:bat[:any_1,:o
address ALGmark_grp_1;
comment "grouped mark": Produces a new BAT with per group a locally unique
dense ascending sequence of OIDs in the tail. The tail of the first BAT (b)
identifies the group that each BUN of b belongs to. The second BAT (g)
represents the group extent, i.e., the head is the unique list of group IDs
from b's tail. The tail of g gives for each group the base value for the new
OID sequence.
-command
algebra.markH(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:oid,:any_2]
-address ALGhmarkp;
-comment Produces a BAT with fresh unique dense sequense of OIDs in the
head that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
-
-command algebra.markH(b:bat[:any_1,:any_2],base:oid):bat[:oid,:any_2]
-address ALGmarkHead;
-comment Produces a new BAT with fresh unique dense sequense of OIDs in
the head that starts at base (i.e. [base,..base+b.count()-1] ).
-
-command algebra.markH(b:bat[:any_1,:any_2]):bat[:oid,:any_2]
-address ALGmarkHead_default;
-comment Produces a BAT with fresh OIDs in the head starting at 0@0.
-
command
algebra.markT(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:any_1,:oid]
address ALGtmarkp;
comment Produces a BAT with fresh unique dense sequense of OIDs in the
tail that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
diff --git a/clients/Tests/MAL-signatures_none.stable.out
b/clients/Tests/MAL-signatures_none.stable.out
--- a/clients/Tests/MAL-signatures_none.stable.out
+++ b/clients/Tests/MAL-signatures_none.stable.out
@@ -2274,10 +2274,6 @@ command algebra.bandjoin(outer:bat[:oid,
address ALGbandjoin2;
comment This is a join() for which the predicate is that two BUNs match
if the left-tail value is within the range [right-head - minus,
right-head + plus], depending on (l_in/h_in), the bounds are
included. Works only for the builtin numerical types, and their
derivates.
-command
algebra.crossproduct(left:bat[:any_1,:any_2],right:bat[:any_3,:any_4]):bat[:any_1,:any_4]
-address ALGcross;
-comment Returns the cross product
-
command algebra.crossproduct(left:bat[:oid,:any_1],right:bat[:oid,:any_2])
(l:bat[:oid,:oid],r:bat[:oid,:oid])
address ALGcrossproduct2;
comment Returns 2 columns with all BUNs, consisting of the head-oids from
'left' and 'right' for which there are BUNs in 'left' and 'right' with
equal tails
@@ -2429,18 +2425,6 @@ command algebra.mark_grp(b:bat[:any_1,:o
address ALGmark_grp_1;
comment "grouped mark": Produces a new BAT with per group a locally unique
dense ascending sequence of OIDs in the tail. The tail of the first BAT (b)
identifies the group that each BUN of b belongs to. The second BAT (g)
represents the group extent, i.e., the head is the unique list of group IDs
from b's tail. The tail of g gives for each group the base value for the new
OID sequence.
-command
algebra.markH(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:oid,:any_2]
-address ALGhmarkp;
-comment Produces a BAT with fresh unique dense sequense of OIDs in the
head that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
-
-command algebra.markH(b:bat[:any_1,:any_2],base:oid):bat[:oid,:any_2]
-address ALGmarkHead;
-comment Produces a new BAT with fresh unique dense sequense of OIDs in
the head that starts at base (i.e. [base,..base+b.count()-1] ).
-
-command algebra.markH(b:bat[:any_1,:any_2]):bat[:oid,:any_2]
-address ALGmarkHead_default;
-comment Produces a BAT with fresh OIDs in the head starting at 0@0.
-
command
algebra.mark(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:any_1,:oid]
address ALGtmarkp;
comment Produces a BAT with fresh unique dense sequense of OIDs in the
tail that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
diff --git a/clients/Tests/MAL-signatures_none.stable.out.int128
b/clients/Tests/MAL-signatures_none.stable.out.int128
--- a/clients/Tests/MAL-signatures_none.stable.out.int128
+++ b/clients/Tests/MAL-signatures_none.stable.out.int128
@@ -2789,10 +2789,6 @@ command algebra.bandjoin(outer:bat[:oid,
address ALGbandjoin2;
comment This is a join() for which the predicate is that two BUNs match
if the left-tail value is within the range [right-head - minus,
right-head + plus], depending on (l_in/h_in), the bounds are
included. Works only for the builtin numerical types, and their
derivates.
-command
algebra.crossproduct(left:bat[:any_1,:any_2],right:bat[:any_3,:any_4]):bat[:any_1,:any_4]
-address ALGcross;
-comment Returns the cross product
-
command algebra.crossproduct(left:bat[:oid,:any_1],right:bat[:oid,:any_2])
(l:bat[:oid,:oid],r:bat[:oid,:oid])
address ALGcrossproduct2;
comment Returns 2 columns with all BUNs, consisting of the head-oids from
'left' and 'right' for which there are BUNs in 'left' and 'right' with
equal tails
@@ -2944,18 +2940,6 @@ command algebra.mark_grp(b:bat[:any_1,:o
address ALGmark_grp_1;
comment "grouped mark": Produces a new BAT with per group a locally unique
dense ascending sequence of OIDs in the tail. The tail of the first BAT (b)
identifies the group that each BUN of b belongs to. The second BAT (g)
represents the group extent, i.e., the head is the unique list of group IDs
from b's tail. The tail of g gives for each group the base value for the new
OID sequence.
-command
algebra.markH(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:oid,:any_2]
-address ALGhmarkp;
-comment Produces a BAT with fresh unique dense sequense of OIDs in the
head that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
-
-command algebra.markH(b:bat[:any_1,:any_2],base:oid):bat[:oid,:any_2]
-address ALGmarkHead;
-comment Produces a new BAT with fresh unique dense sequense of OIDs in
the head that starts at base (i.e. [base,..base+b.count()-1] ).
-
-command algebra.markH(b:bat[:any_1,:any_2]):bat[:oid,:any_2]
-address ALGmarkHead_default;
-comment Produces a BAT with fresh OIDs in the head starting at 0@0.
-
command
algebra.markT(b:bat[:any_1,:any_2],nr_parts:int,part_nr:int):bat[:any_1,:oid]
address ALGtmarkp;
comment Produces a BAT with fresh unique dense sequense of OIDs in the
tail that starts at base (i.e. [base,..base+b.count()-1] ). The base is
uniquely defined by the part_nr (ie we set the highest bits based on the
part_nr/nr_parts)
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
@@ -765,7 +765,6 @@ str ALGleftfetchjoin(bat *result, const
str ALGleftjoin(bat *result, const bat *lid, const bat *rid);
str ALGleftjoinestimate(bat *result, const bat *lid, const bat *rid, const lng
*estimate);
str ALGlike(bat *ret, const bat *bid, const str *k);
-str ALGmarkHead(bat *result, const bat *bid, const oid *base);
str ALGmarkHead_default(bat *result, const bat *bid);
str ALGmark_grp_1(bat *result, const bat *bid, const bat *gid);
str ALGmark_grp_2(bat *result, const bat *bid, const bat *gid, const oid
*base);
@@ -2548,7 +2547,6 @@ char *mal_trace;
void mal_unquote(char *msg);
str manifoldRef;
str mapiRef;
-str markHRef;
str markRef;
str mark_grpRef;
str matRef;
diff --git a/monetdb5/mal/Tests/tst029.mal b/monetdb5/mal/Tests/tst029.mal
--- a/monetdb5/mal/Tests/tst029.mal
+++ b/monetdb5/mal/Tests/tst029.mal
@@ -3,5 +3,5 @@ bat.append(b, "io.print(1);");
bat.append(b, "io.print(\"hello\");");
bat.append(b,"s:=\"goodbye\";io.print(s);");
io.print(b);
-s:= algebra.fetch(b,2);
+s:= algebra.fetch(b,2@0);
io.printf("%s\n",s);
diff --git a/monetdb5/mal/Tests/tst029.stable.out
b/monetdb5/mal/Tests/tst029.stable.out
--- a/monetdb5/mal/Tests/tst029.stable.out
+++ b/monetdb5/mal/Tests/tst029.stable.out
@@ -17,7 +17,7 @@ stdout of test 'tst029` in directory 'mo
#bat.insert(b,2, "io.print(\"hello\");");
#bat.insert(b,3,"s:=\"goodbye\";io.print(s);");
#io.print(b);
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
