Changeset: 4914ea697be5 for MonetDB URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=4914ea697be5 Modified Files: clients/Tests/exports.stable.out gdk/ChangeLog gdk/gdk.h gdk/gdk_aggr.c gdk/gdk_imprints.c gdk/gdk_join.c gdk/gdk_logger.c gdk/gdk_select.c gdk/gdk_unique.c monetdb5/mal/mal_authorize.c monetdb5/modules/kernel/algebra.c monetdb5/modules/mal/groupby.c monetdb5/modules/mal/pcre.c monetdb5/modules/mal/tokenizer.c sql/backends/monet5/sql.c sql/backends/monet5/sql_statistics.c sql/storage/bat/bat_storage.c sql/storage/bat/bat_table.c Branch: default Log Message:
Removed "sub" from the names of all GDK level functions that had them. The functions are BATsubselect, BATthetasubselect, BATsubcross, BATsubleftjoin, BATsubouterjoin, BATsubthetajoin, BATsubsemijoin, BATsubdiff, BATsubjoin, BATsubbandjoin, BATsubrangejoin, and BATsubunique. diffs (truncated from 1284 to 300 lines): 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 @@ -23,6 +23,7 @@ gdk_return BATappend(BAT *b, BAT *c, bit void BATassertProps(BAT *b); atomDesc BATatoms[]; BAT *BATattach(int tt, const char *heapfile, int role); +gdk_return BATbandjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, const void *c1, const void *c2, int li, int hi, BUN estimate); BAT *BATcalcabsolute(BAT *b, BAT *s); BAT *BATcalcadd(BAT *b1, BAT *b2, BAT *s, int tp, int abort_on_error); BAT *BATcalcaddcst(BAT *b, const ValRecord *v, BAT *s, int tp, int abort_on_error); @@ -111,6 +112,7 @@ gdk_return BATdel(BAT *b, BAT *c, bit fo BAT *BATdelta(BAT *b); void BATderiveHeadProps(BAT *b, int expensive); void BATderiveProps(BAT *b, int expensive); +BAT *BATdiff(BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); gdk_return BATextend(BAT *b, BUN newcap); void BATfakeCommit(BAT *b); gdk_return BATfirstn(BAT **topn, BAT **gids, BAT *b, BAT *cands, BAT *grps, BUN n, int asc, int distinct); @@ -136,7 +138,9 @@ gdk_return BAThash(BAT *b, BUN masksize) gdk_return BATimprints(BAT *b); gdk_return BATins(BAT *b, BAT *c, bit force); BAT *BATintersectcand(BAT *a, BAT *b); +gdk_return BATjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); gdk_return BATkey(BAT *b, int onoff); +gdk_return BATleftjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); BAT *BATmark(BAT *b, oid base); BAT *BATmark_grp(BAT *b, BAT *g, const oid *base); void *BATmax(BAT *b, void *aggr); @@ -150,37 +154,33 @@ int BATname(BAT *b, const char *nme); BAT *BATnew(int hdtype, int tltype, BUN capacity, int role) __attribute__((warn_unused_result)); int BATordered(BAT *b); int BATordered_rev(BAT *b); +gdk_return BATouterjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); BAT *BATprev(BAT *b); gdk_return BATprint(BAT *b); gdk_return BATprintcolumns(stream *s, int argc, BAT *argv[]); gdk_return BATprintf(stream *f, BAT *b); gdk_return BATprod(void *res, int tp, BAT *b, BAT *s, int skip_nils, int abort_on_error, int nil_if_empty); BAT *BATproject(BAT *l, BAT *r); +gdk_return BATrangejoin(BAT **r1p, BAT **r2p, BAT *l, BAT *rl, BAT *rh, BAT *sl, BAT *sr, int li, int hi, BUN estimate); gdk_return BATreplace(BAT *b, BAT *p, BAT *n, bit force); void BATroles(BAT *b, const char *hnme, const char *tnme); BAT *BATsample(BAT *b, BUN n); gdk_return BATsave(BAT *b); +BAT *BATselect(BAT *b, BAT *s, const void *tl, const void *th, int li, int hi, int anti); +gdk_return BATsemijoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); void BATseqbase(BAT *b, oid o); gdk_return BATsetaccess(BAT *b, int mode); void BATsetcapacity(BAT *b, BUN cnt); void BATsetcount(BAT *b, BUN cnt); void BATsetprop(BAT *b, int idx, int type, void *v); BAT *BATslice(BAT *b, BUN low, BUN high); -gdk_return BATsubbandjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, const void *c1, const void *c2, int li, int hi, BUN estimate); gdk_return BATsubcross(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr); -BAT *BATsubdiff(BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); -gdk_return BATsubjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); -gdk_return BATsubleftjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); -gdk_return BATsubouterjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); -gdk_return BATsubrangejoin(BAT **r1p, BAT **r2p, BAT *l, BAT *rl, BAT *rh, BAT *sl, BAT *sr, int li, int hi, BUN estimate); -BAT *BATsubselect(BAT *b, BAT *s, const void *tl, const void *th, int li, int hi, int anti); -gdk_return BATsubsemijoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); gdk_return BATsubsort(BAT **sorted, BAT **order, BAT **groups, BAT *b, BAT *o, BAT *g, int reverse, int stable); -gdk_return BATsubthetajoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int op, int nil_matches, BUN estimate); -BAT *BATsubunique(BAT *b, BAT *s); gdk_return BATsum(void *res, int tp, BAT *b, BAT *s, int skip_nils, int abort_on_error, int nil_if_empty); -BAT *BATthetasubselect(BAT *b, BAT *s, const void *val, const char *op); +gdk_return BATthetajoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int op, int nil_matches, BUN estimate); +BAT *BATthetaselect(BAT *b, BAT *s, const void *val, const char *op); void BATundo(BAT *b); +BAT *BATunique(BAT *b, BAT *s); BBPrec *BBP[N_BBPINIT]; void BBPaddfarm(const char *dirname, int rolemask); void BBPclear(bat bid); diff --git a/gdk/ChangeLog b/gdk/ChangeLog --- a/gdk/ChangeLog +++ b/gdk/ChangeLog @@ -2,6 +2,10 @@ # This file is updated with Maddlog * Thu Dec 3 2015 Sjoerd Mullender <[email protected]> +- Removed "sub" from the names of the function BATsubselect, + BATthetasubselect, BATsubcross, BATsubleftjoin, BATsubouterjoin, + BATsubthetajoin, BATsubsemijoin, BATsubdiff, BATsubjoin, BATsubbandjoin, + BATsubrangejoin, and BATsubunique. - Removed BATsubleftfetchjoin: it was not used. - Removed BATcross1. Use BATsubcross instead. diff --git a/gdk/gdk.h b/gdk/gdk.h --- a/gdk/gdk.h +++ b/gdk/gdk.h @@ -3024,26 +3024,26 @@ gdk_export void BATsetprop(BAT *b, int i #define JOIN_BAND 3 #define JOIN_NE (-3) -gdk_export BAT *BATsubselect(BAT *b, BAT *s, const void *tl, const void *th, int li, int hi, int anti); -gdk_export BAT *BATthetasubselect(BAT *b, BAT *s, const void *val, const char *op); +gdk_export BAT *BATselect(BAT *b, BAT *s, const void *tl, const void *th, int li, int hi, int anti); +gdk_export BAT *BATthetaselect(BAT *b, BAT *s, const void *val, const char *op); gdk_export BAT *BATconstant(int tt, const void *val, BUN cnt, int role); gdk_export BAT *BATconst(BAT *l, int tt, const void *val, int role); gdk_export gdk_return BATsubcross(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr); -gdk_export gdk_return BATsubleftjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); -gdk_export gdk_return BATsubouterjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); -gdk_export gdk_return BATsubthetajoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int op, int nil_matches, BUN estimate); -gdk_export gdk_return BATsubsemijoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); -gdk_export BAT *BATsubdiff(BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); -gdk_export gdk_return BATsubjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); -gdk_export gdk_return BATsubbandjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, const void *c1, const void *c2, int li, int hi, BUN estimate); -gdk_export gdk_return BATsubrangejoin(BAT **r1p, BAT **r2p, BAT *l, BAT *rl, BAT *rh, BAT *sl, BAT *sr, int li, int hi, BUN estimate); +gdk_export gdk_return BATleftjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); +gdk_export gdk_return BATouterjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); +gdk_export gdk_return BATthetajoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int op, int nil_matches, BUN estimate); +gdk_export gdk_return BATsemijoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); +gdk_export BAT *BATdiff(BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); +gdk_export gdk_return BATjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate); +gdk_export gdk_return BATbandjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, const void *c1, const void *c2, int li, int hi, BUN estimate); +gdk_export gdk_return BATrangejoin(BAT **r1p, BAT **r2p, BAT *l, BAT *rl, BAT *rh, BAT *sl, BAT *sr, int li, int hi, BUN estimate); gdk_export BAT *BATproject(BAT *l, BAT *r); gdk_export BAT *BATslice(BAT *b, BUN low, BUN high); -gdk_export BAT *BATsubunique(BAT *b, BAT *s); +gdk_export BAT *BATunique(BAT *b, BAT *s); gdk_export BAT *BATmergecand(BAT *a, BAT *b); gdk_export BAT *BATintersectcand(BAT *a, BAT *b); diff --git a/gdk/gdk_aggr.c b/gdk/gdk_aggr.c --- a/gdk/gdk_aggr.c +++ b/gdk/gdk_aggr.c @@ -29,7 +29,7 @@ * The tail values of s refer to the head of b and g. Only entries at * the specified ids are taken into account for the grouped * aggregates. All other values are ignored. s is compatible with - * the result of BATsubselect(). + * the result of BATselect(). * * If e is not specified, we need to do an extra scan over g to find * out the range of the group ids that are used. e is defined in such diff --git a/gdk/gdk_imprints.c b/gdk/gdk_imprints.c --- a/gdk/gdk_imprints.c +++ b/gdk/gdk_imprints.c @@ -718,7 +718,7 @@ BATimprints(BAT *b) GDKfree(imprints); return GDK_FAIL; } - smp = BATsubunique(b, s); + smp = BATunique(b, s); BBPunfix(s->batCacheid); if (smp == NULL) { MT_lock_unset(&GDKimprintsLock(abs(b->batCacheid))); diff --git a/gdk/gdk_join.c b/gdk/gdk_join.c --- a/gdk/gdk_join.c +++ b/gdk/gdk_join.c @@ -32,31 +32,31 @@ * whether NIL must be considered to never match. * * The join functions that are provided here are: - * BATsubjoin + * BATjoin * normal equi-join - * BATsubleftjoin + * BATleftjoin * normal equi-join, but the left output is sorted - * BATsubouterjoin + * BATouterjoin * equi-join, but the left output is sorted, and if there is no * match for a value in the left input, there is still an output * with NIL in the right output - * BATsubsemijoin + * BATsemijoin * equi-join, but the left output is sorted, and if there are * multiple matches, only one is returned (i.e., the left output * is also key) - * BATsubthetajoin + * BATthetajoin * theta-join: an extra operator must be provided encoded as an * integer (macros JOIN_EQ, JOIN_NE, JOIN_LT, JOIN_LE, JOIN_GT, * JOIN_GE); value match if the left input has the given * relationship with the right input; order of the outputs is not * guaranteed - * BATsubbandjoin + * BATbandjoin * band-join: two extra input values (c1, c2) must be provided as * well as Booleans (li, hi) that indicate whether the value * ranges are inclusive or not; values in the left and right * inputs match if right - c1 <[=] left <[=] right + c2; if c1 or * c2 is NIL, there are no matches - * BATsubrangejoin + * BATrangejoin * range-join: the right input consists of two aligned BATs, * values match if the left value is between two corresponding * right values; two extra Boolean parameters, li and hi, @@ -64,7 +64,7 @@ * * In addition to these functions, there are two more functions that * are closely related: - * BATsubdiff + * BATdiff * difference: return a candidate list compatible list of OIDs of * tuples in the left input whose value does not occur in the * right input @@ -2693,7 +2693,7 @@ bandjoin(BAT *r1, BAT *r2, BAT *l, BAT * return GDK_SUCCEED; break; default: - GDKerror("BATsubbandjoin: unsupported type\n"); + GDKerror("BATbandjoin: unsupported type\n"); goto bailout; } @@ -3059,10 +3059,10 @@ subleftjoin(BAT **r1p, BAT **r2p, BAT *l * matching tuples. The result is in the same order as l (i.e. r1 is * sorted). */ gdk_return -BATsubleftjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate) +BATleftjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate) { return subleftjoin(r1p, r2p, l, r, sl, sr, nil_matches, - 0, 0, 0, estimate, "BATsubleftjoin"); + 0, 0, 0, estimate, "BATleftjoin"); } /* Performs a left outer join over l and r. Returns two new, aligned, @@ -3071,10 +3071,10 @@ BATsubleftjoin(BAT **r1p, BAT **r2p, BAT * second output bat if the value in l does not occur in r. The * result is in the same order as l (i.e. r1 is sorted). */ gdk_return -BATsubouterjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate) +BATouterjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate) { return subleftjoin(r1p, r2p, l, r, sl, sr, nil_matches, - 1, 0, 0, estimate, "BATsubouterjoin"); + 1, 0, 0, estimate, "BATouterjoin"); } /* Perform a semi-join over l and r. Returns two new, aligned, @@ -3082,10 +3082,10 @@ BATsubouterjoin(BAT **r1p, BAT **r2p, BA * matching tuples. The result is in the same order as l (i.e. r1 is * sorted). */ gdk_return -BATsubsemijoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate) +BATsemijoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate) { return subleftjoin(r1p, r2p, l, r, sl, sr, nil_matches, - 0, 1, 0, estimate, "BATsubsemijoin"); + 0, 1, 0, estimate, "BATsemijoin"); } /* Return the difference of l and r. The result is a BAT with in the @@ -3093,18 +3093,18 @@ BATsubsemijoin(BAT **r1p, BAT **r2p, BAT * what you might call an anti-semi-join. The result can be used as a * candidate list. */ BAT * -BATsubdiff(BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate) +BATdiff(BAT *l, BAT *r, BAT *sl, BAT *sr, int nil_matches, BUN estimate) { BAT *bn; if (subleftjoin(&bn, NULL, l, r, sl, sr, nil_matches, - 0, 0, 1, estimate, "BATsubdiff") == GDK_SUCCEED) + 0, 0, 1, estimate, "BATdiff") == GDK_SUCCEED) return bn; return NULL; } gdk_return -BATsubthetajoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int op, int nil_matches, BUN estimate) +BATthetajoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT *sl, BAT *sr, int op, int nil_matches, BUN estimate) { BAT *r1, *r2; BUN maxsize; @@ -3113,7 +3113,7 @@ BATsubthetajoin(BAT **r1p, BAT **r2p, BA /* encode operator as a bit mask into opcode */ switch (op) { case JOIN_EQ: - return BATsubjoin(r1p, r2p, l, r, sl, sr, nil_matches, estimate); + return BATjoin(r1p, r2p, l, r, sl, sr, nil_matches, estimate); case JOIN_NE: opcode = MASK_NE; break; @@ -3130,13 +3130,13 @@ BATsubthetajoin(BAT **r1p, BAT **r2p, BA opcode = MASK_GE; break; default: - GDKerror("BATsubthetajoin: unknown operator %d.\n", op); + GDKerror("BATthetajoin: unknown operator %d.\n", op); return GDK_FAIL; } *r1p = NULL; *r2p = NULL; - if (joinparamcheck(l, r, NULL, sl, sr, "BATsubthetajoin") != GDK_SUCCEED) + if (joinparamcheck(l, r, NULL, sl, sr, "BATthetajoin") != GDK_SUCCEED) return GDK_FAIL; if ((maxsize = joininitresults(&r1, &r2, sl ? BATcount(sl) : BATcount(l), sr ? BATcount(sr) : BATcount(r), 0, 0, 0, 0, 0, estimate)) == BUN_NONE) return GDK_FAIL; @@ -3147,7 +3147,7 @@ BATsubthetajoin(BAT **r1p, BAT **r2p, BA _______________________________________________ checkin-list mailing list [email protected] https://www.monetdb.org/mailman/listinfo/checkin-list
