Changeset: 374986196f7a for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=374986196f7a
Modified Files:
clients/Tests/MAL-signatures_all.stable.out
clients/Tests/MAL-signatures_fits_geom.stable.out
clients/Tests/MAL-signatures_geom.stable.out
clients/Tests/MAL-signatures_none.stable.out
clients/Tests/exports.stable.out
gdk/gdk.h
gdk/gdk_select_legacy.c
monetdb5/ChangeLog.Oct2014
monetdb5/modules/kernel/algebra.c
monetdb5/modules/kernel/algebra.h
monetdb5/modules/kernel/algebra.mal
monetdb5/modules/mal/pcre.c
monetdb5/modules/mal/pcre.mal
monetdb5/modules/mal/tokenizer.c
monetdb5/optimizer/opt_centipede.c
monetdb5/optimizer/opt_costModel.c
monetdb5/optimizer/opt_emptySet.c
monetdb5/optimizer/opt_prelude.c
monetdb5/optimizer/opt_prelude.h
monetdb5/optimizer/opt_pushranges.c
monetdb5/optimizer/opt_support.c
sql/backends/monet5/rel_bin.c
sql/backends/monet5/sql_statement.c
sql/backends/monet5/sql_statement.h
sql/backends/monet5/sql_statistics.c
sql/test/Dump/Tests/dump.stable.out.Windows
sql/test/testdb/Tests/testdb-dump.stable.out.Windows
Branch: default
Log Message:
Merge with Oct2014 branch.
diffs (truncated from 1304 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
@@ -2262,14 +2262,6 @@ command algebra.antijoin(left:bat[:oid,:
address ALGantijoin2;
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
-command
algebra.antiuselect(b:bat[:any_1,:any_2],low:any_2,high:any_2,li:bit,hi:bit):bat[:any_1,:void]
-address ALGantiuselectInclusive;
-comment See select() but limited to head values
-
-command
algebra.antiuselect(b:bat[:any_1,:any_2],value:any_2):bat[:any_1,:void]
-address ALGantiuselect1;
-comment Value select, but returning only the head values. SEE
ALSO:select(bat,val)
-
command
algebra.bandjoin(outer:bat[:any_1,:any_2],inner:bat[:any_2,:any_3],minus:any_2,plus:any_2,li:bit,hi:bit):bat[:any_1,:any_3]
address ALGbandjoin;
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.
@@ -2339,7 +2331,7 @@ address ALGgroupby;
comment Produces a new BAT with groups identified by the head column. The
result contains tail times the head value, ie the tail contains the result
group sizes.
command algebra.ilikesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCREilike_join_pcr5;
+address PCREilike_join_pcre;
function
algebra.ilikesubselect(b:bat[:oid,:str],cand:bat[:oid,:oid],pat:str,esc:str,anti:bit):bat[:oid,:oid];
function
algebra.ilikesubselect(b:bat[:oid,:str],pat:str,esc:str,anti:bit):bat[:oid,:oid];
command
algebra.indexjoin(left:bat[:any_1,:any_2],right:bat[:any_2,:any_3]):bat[:any_1,:any_3]
@@ -2663,10 +2655,6 @@ command algebra.tunique(b:bat[:any_1,:an
address ALGtunique;
comment Select unique tuples from the input BAT. Double elimination is
done over the BUNs tail. The result is a BAT with property
tkeyd()== true
-command
algebra.thetauselect(b:bat[:any_1,:any_2],val:any_2,op:str):bat[:any_1,:void]
-address ALGthetauselect;
-comment The theta (<=,<,=,>,>=) select() limited to head values
-
command
algebra.thetasubselect(b:bat[:oid,:any_1],s:bat[:oid,:oid],val:any_1,op:str):bat[:oid,:oid]
address ALGthetasubselect2;
comment Select all head values of the first input BAT for which the tail value
obeys the relation value OP VAL and for which the head value occurs in the
tail of the second input BAT. Input is a dense-headed BAT, output is a
dense-headed BAT with in the tail the head value of the input BAT for
which the relationship holds. The output BAT is sorted on the tail value.
@@ -40885,14 +40873,10 @@ command pcre.imatch(s:str,pat:str):bit
address PCREimatch;
comment Caseless Perl Compatible Regular Expression pattern matching against a
string
-command pcre.ilikesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCREilike_join_pcre;
command pcre.index(pat:pcre,s:str):int
address PCREindex;
comment match a pattern, return matched position (or 0 when not found)
-command pcre.likesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCRElike_join_pcre;
command pcre.match(s:str,pat:str):bit
address PCREmatch;
comment Perl Compatible Regular Expression pattern matching against a string
@@ -40919,10 +40903,6 @@ command pcre.sql2pcre(pat:str,esc:str):s
address PCREsql2pcre;
comment Convert a SQL like pattern with the given escape character into a PCRE
pattern.
-command pcre.select(pat:str,strs:bat[:oid,:str]):bat[:oid,:str]
-address PCREselectDef;
-comment Select tuples based on the pattern
-
pattern profiler.activate(name:str...):void
address CMDactivateProfiler;
comment A list of counters to be activated.
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
@@ -2263,14 +2263,6 @@ command algebra.antijoin(left:bat[:oid,:
address ALGantijoin2;
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
-command
algebra.antiuselect(b:bat[:any_1,:any_2],low:any_2,high:any_2,li:bit,hi:bit):bat[:any_1,:void]
-address ALGantiuselectInclusive;
-comment See select() but limited to head values
-
-command
algebra.antiuselect(b:bat[:any_1,:any_2],value:any_2):bat[:any_1,:void]
-address ALGantiuselect1;
-comment Value select, but returning only the head values. SEE
ALSO:select(bat,val)
-
command
algebra.bandjoin(outer:bat[:any_1,:any_2],inner:bat[:any_2,:any_3],minus:any_2,plus:any_2,li:bit,hi:bit):bat[:any_1,:any_3]
address ALGbandjoin;
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.
@@ -2340,7 +2332,7 @@ address ALGgroupby;
comment Produces a new BAT with groups identified by the head column. The
result contains tail times the head value, ie the tail contains the result
group sizes.
command algebra.ilikesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCREilike_join_pcr5;
+address PCREilike_join_pcre;
function
algebra.ilikesubselect(b:bat[:oid,:str],cand:bat[:oid,:oid],pat:str,esc:str,anti:bit):bat[:oid,:oid];
function
algebra.ilikesubselect(b:bat[:oid,:str],pat:str,esc:str,anti:bit):bat[:oid,:oid];
command
algebra.indexjoin(left:bat[:any_1,:any_2],right:bat[:any_2,:any_3]):bat[:any_1,:any_3]
@@ -2664,10 +2656,6 @@ command algebra.tunique(b:bat[:any_1,:an
address ALGtunique;
comment Select unique tuples from the input BAT. Double elimination is
done over the BUNs tail. The result is a BAT with property
tkeyd()== true
-command
algebra.thetauselect(b:bat[:any_1,:any_2],val:any_2,op:str):bat[:any_1,:void]
-address ALGthetauselect;
-comment The theta (<=,<,=,>,>=) select() limited to head values
-
command
algebra.thetasubselect(b:bat[:oid,:any_1],s:bat[:oid,:oid],val:any_1,op:str):bat[:oid,:oid]
address ALGthetasubselect2;
comment Select all head values of the first input BAT for which the tail value
obeys the relation value OP VAL and for which the head value occurs in the
tail of the second input BAT. Input is a dense-headed BAT, output is a
dense-headed BAT with in the tail the head value of the input BAT for
which the relationship holds. The output BAT is sorted on the tail value.
@@ -40802,14 +40790,10 @@ command pcre.imatch(s:str,pat:str):bit
address PCREimatch;
comment Caseless Perl Compatible Regular Expression pattern matching against a
string
-command pcre.ilikesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCREilike_join_pcre;
command pcre.index(pat:pcre,s:str):int
address PCREindex;
comment match a pattern, return matched position (or 0 when not found)
-command pcre.likesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCRElike_join_pcre;
command pcre.match(s:str,pat:str):bit
address PCREmatch;
comment Perl Compatible Regular Expression pattern matching against a string
@@ -40836,10 +40820,6 @@ command pcre.sql2pcre(pat:str,esc:str):s
address PCREsql2pcre;
comment Convert a SQL like pattern with the given escape character into a PCRE
pattern.
-command pcre.select(pat:str,strs:bat[:oid,:str]):bat[:oid,:str]
-address PCREselectDef;
-comment Select tuples based on the pattern
-
pattern profiler.activate(name:str...):void
address CMDactivateProfiler;
comment A list of counters to be activated.
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
@@ -2263,14 +2263,6 @@ command algebra.antijoin(left:bat[:oid,:
address ALGantijoin2;
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
-command
algebra.antiuselect(b:bat[:any_1,:any_2],low:any_2,high:any_2,li:bit,hi:bit):bat[:any_1,:void]
-address ALGantiuselectInclusive;
-comment See select() but limited to head values
-
-command
algebra.antiuselect(b:bat[:any_1,:any_2],value:any_2):bat[:any_1,:void]
-address ALGantiuselect1;
-comment Value select, but returning only the head values. SEE
ALSO:select(bat,val)
-
command
algebra.bandjoin(outer:bat[:any_1,:any_2],inner:bat[:any_2,:any_3],minus:any_2,plus:any_2,li:bit,hi:bit):bat[:any_1,:any_3]
address ALGbandjoin;
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.
@@ -2340,7 +2332,7 @@ address ALGgroupby;
comment Produces a new BAT with groups identified by the head column. The
result contains tail times the head value, ie the tail contains the result
group sizes.
command algebra.ilikesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCREilike_join_pcr5;
+address PCREilike_join_pcre;
function
algebra.ilikesubselect(b:bat[:oid,:str],cand:bat[:oid,:oid],pat:str,esc:str,anti:bit):bat[:oid,:oid];
function
algebra.ilikesubselect(b:bat[:oid,:str],pat:str,esc:str,anti:bit):bat[:oid,:oid];
command
algebra.indexjoin(left:bat[:any_1,:any_2],right:bat[:any_2,:any_3]):bat[:any_1,:any_3]
@@ -2664,10 +2656,6 @@ command algebra.tunique(b:bat[:any_1,:an
address ALGtunique;
comment Select unique tuples from the input BAT. Double elimination is
done over the BUNs tail. The result is a BAT with property
tkeyd()== true
-command
algebra.thetauselect(b:bat[:any_1,:any_2],val:any_2,op:str):bat[:any_1,:void]
-address ALGthetauselect;
-comment The theta (<=,<,=,>,>=) select() limited to head values
-
command
algebra.thetasubselect(b:bat[:oid,:any_1],s:bat[:oid,:oid],val:any_1,op:str):bat[:oid,:oid]
address ALGthetasubselect2;
comment Select all head values of the first input BAT for which the tail value
obeys the relation value OP VAL and for which the head value occurs in the
tail of the second input BAT. Input is a dense-headed BAT, output is a
dense-headed BAT with in the tail the head value of the input BAT for
which the relationship holds. The output BAT is sorted on the tail value.
@@ -40778,14 +40766,10 @@ command pcre.imatch(s:str,pat:str):bit
address PCREimatch;
comment Caseless Perl Compatible Regular Expression pattern matching against a
string
-command pcre.ilikesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCREilike_join_pcre;
command pcre.index(pat:pcre,s:str):int
address PCREindex;
comment match a pattern, return matched position (or 0 when not found)
-command pcre.likesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCRElike_join_pcre;
command pcre.match(s:str,pat:str):bit
address PCREmatch;
comment Perl Compatible Regular Expression pattern matching against a string
@@ -40812,10 +40796,6 @@ command pcre.sql2pcre(pat:str,esc:str):s
address PCREsql2pcre;
comment Convert a SQL like pattern with the given escape character into a PCRE
pattern.
-command pcre.select(pat:str,strs:bat[:oid,:str]):bat[:oid,:str]
-address PCREselectDef;
-comment Select tuples based on the pattern
-
pattern profiler.activate(name:str...):void
address CMDactivateProfiler;
comment A list of counters to be activated.
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
@@ -2262,14 +2262,6 @@ command algebra.antijoin(left:bat[:oid,:
address ALGantijoin2;
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
-command
algebra.antiuselect(b:bat[:any_1,:any_2],low:any_2,high:any_2,li:bit,hi:bit):bat[:any_1,:void]
-address ALGantiuselectInclusive;
-comment See select() but limited to head values
-
-command
algebra.antiuselect(b:bat[:any_1,:any_2],value:any_2):bat[:any_1,:void]
-address ALGantiuselect1;
-comment Value select, but returning only the head values. SEE
ALSO:select(bat,val)
-
command
algebra.bandjoin(outer:bat[:any_1,:any_2],inner:bat[:any_2,:any_3],minus:any_2,plus:any_2,li:bit,hi:bit):bat[:any_1,:any_3]
address ALGbandjoin;
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.
@@ -2339,7 +2331,7 @@ address ALGgroupby;
comment Produces a new BAT with groups identified by the head column. The
result contains tail times the head value, ie the tail contains the result
group sizes.
command algebra.ilikesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCREilike_join_pcr5;
+address PCREilike_join_pcre;
function
algebra.ilikesubselect(b:bat[:oid,:str],cand:bat[:oid,:oid],pat:str,esc:str,anti:bit):bat[:oid,:oid];
function
algebra.ilikesubselect(b:bat[:oid,:str],pat:str,esc:str,anti:bit):bat[:oid,:oid];
command
algebra.indexjoin(left:bat[:any_1,:any_2],right:bat[:any_2,:any_3]):bat[:any_1,:any_3]
@@ -2663,10 +2655,6 @@ command algebra.tunique(b:bat[:any_1,:an
address ALGtunique;
comment Select unique tuples from the input BAT. Double elimination is
done over the BUNs tail. The result is a BAT with property
tkeyd()== true
-command
algebra.thetauselect(b:bat[:any_1,:any_2],val:any_2,op:str):bat[:any_1,:void]
-address ALGthetauselect;
-comment The theta (<=,<,=,>,>=) select() limited to head values
-
command
algebra.thetasubselect(b:bat[:oid,:any_1],s:bat[:oid,:oid],val:any_1,op:str):bat[:oid,:oid]
address ALGthetasubselect2;
comment Select all head values of the first input BAT for which the tail value
obeys the relation value OP VAL and for which the head value occurs in the
tail of the second input BAT. Input is a dense-headed BAT, output is a
dense-headed BAT with in the tail the head value of the input BAT for
which the relationship holds. The output BAT is sorted on the tail value.
@@ -40591,14 +40579,10 @@ command pcre.imatch(s:str,pat:str):bit
address PCREimatch;
comment Caseless Perl Compatible Regular Expression pattern matching against a
string
-command pcre.ilikesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCREilike_join_pcre;
command pcre.index(pat:pcre,s:str):int
address PCREindex;
comment match a pattern, return matched position (or 0 when not found)
-command pcre.likesubselect(s:bat[:oid,:str],pat:bat[:oid,:str],esc:str)
(l:bat[:oid,:oid],r:bat[:oid,:oid])
-address PCRElike_join_pcre;
command pcre.match(s:str,pat:str):bit
address PCREmatch;
comment Perl Compatible Regular Expression pattern matching against a string
@@ -40625,10 +40609,6 @@ command pcre.sql2pcre(pat:str,esc:str):s
address PCREsql2pcre;
comment Convert a SQL like pattern with the given escape character into a PCRE
pattern.
-command pcre.select(pat:str,strs:bat[:oid,:str]):bat[:oid,:str]
-address PCREselectDef;
-comment Select tuples based on the pattern
-
pattern profiler.activate(name:str...):void
address CMDactivateProfiler;
comment A list of counters to be activated.
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
@@ -20,7 +20,6 @@ ptr ATOMnil(int id);
int ATOMprint(int id, const void *val, stream *fd);
BAT *BATalpha(BAT *b);
BAT *BATantijoin(BAT *l, BAT *r);
-BAT *BATantiuselect_(BAT *b, const void *tl, const void *th, bit li, bit hi);
BAT *BATappend(BAT *b, BAT *c, bit force);
void BATassertProps(BAT *b);
atomDesc BATatoms[];
@@ -734,8 +733,6 @@ str ALARMtimers(int *res);
str ALARMusec(lng *ret);
str ALGantijoin(int *result, int *lid, int *rid);
str ALGantijoin2(int *l, int *r, int *lid, int *rid);
-str ALGantiuselect1(int *result, int *bid, ptr value);
-str ALGantiuselectInclusive(int *result, int *bid, ptr low, ptr high, bit
*lin, bit *rin);
str ALGavg(dbl *res, int *bid);
str ALGbandjoin(int *result, int *lid, int *rid, const void *minus, const void
*plus, bit *li, bit *hi);
str ALGbandjoin2(int *l, int *r, int *lid, int *rid, const void *minus, const
void *plus, bit *li, bit *hi);
@@ -825,10 +822,8 @@ str ALGtdifference(int *result, int *lid
str ALGthetajoin(int *result, int *lid, int *rid, int *opc);
str ALGthetajoin2(int *l, int *r, int *lid, int *rid, int *opc);
str ALGthetajoinEstimate(int *result, int *lid, int *rid, int *opc, lng
*estimate);
-str ALGthetaselect(int *result, int *bid, ptr low, str *op);
str ALGthetasubselect1(bat *result, bat *bid, const void *val, const char
**op);
str ALGthetasubselect2(bat *result, bat *bid, bat *sid, const void *val, const
char **op);
-str ALGthetauselect(int *result, int *bid, ptr value, str *op);
str ALGthsort(int *result, int *lid);
str ALGtinter(int *result, int *lid, int *rid);
str ALGtintersect(int *result, int *lid, int *rid);
@@ -1764,7 +1759,7 @@ str PCREpatindex(int *ret, str *pat, str
str PCREquote(str *r, str *v);
str PCREreplace_bat_wrap(int *res, int *or, str *pat, str *repl, str *flags);
str PCREreplace_wrap(str *res, str *or, str *pat, str *repl, str *flags);
-str PCREselectDef(int *res, str *pattern, int *bid);
+str PCREselect(int *res, str *pattern, int *bid);
str PCREsql2pcre(str *ret, str *pat, str *esc);
sht PropertyIndex(str name);
str PropertyName(sht idx);
@@ -2135,7 +2130,6 @@ str alarmRef;
str algebraRef;
int allTargetsVisible(MalBlkPtr mb, Lifespan span, int pc, int qc);
str antijoinRef;
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
