Changeset: f1a38bed20d5 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=f1a38bed20d5
Modified Files:
gdk/gdk_analytic.h
gdk/gdk_analytic_func.c
sql/backends/monet5/sql.c
sql/backends/monet5/sql_rank.c
sql/server/rel_select.c
Branch: window-tunning
Log Message:
Pass ordering information for FRAME_UNBOUNDED_TILL_CURRENT_ROW and
FRAME_CURRENT_ROW_TILL_UNBOUNDED cases. Cleaned the rest
diffs (truncated from 1404 to 300 lines):
diff --git a/gdk/gdk_analytic.h b/gdk/gdk_analytic.h
--- a/gdk/gdk_analytic.h
+++ b/gdk/gdk_analytic.h
@@ -29,13 +29,13 @@ gdk_export gdk_return GDKanalyticalfirst
gdk_export gdk_return GDKanalyticallast(BAT *r, BAT *b, BAT *s, BAT *e, int
tpe);
gdk_export gdk_return GDKanalyticalnthvalue(BAT *r, BAT *b, BAT *s, BAT *e,
BAT *l, const void *restrict bound, int tp1, int tp2);
-gdk_export gdk_return GDKanalyticalmin(BAT *r, BAT *p, BAT *b, BAT *s, BAT *e,
int tpe, int frame_type);
-gdk_export gdk_return GDKanalyticalmax(BAT *r, BAT *p, BAT *b, BAT *s, BAT *e,
int tpe, int frame_type);
-gdk_export gdk_return GDKanalyticalcount(BAT *r, BAT *p, BAT *b, BAT *s, BAT
*e, bit ignore_nils, int tpe, int frame_type);
-gdk_export gdk_return GDKanalyticalsum(BAT *r, BAT *p, BAT *b, BAT *s, BAT *e,
int tp1, int tp2, int frame_type);
-gdk_export gdk_return GDKanalyticalprod(BAT *r, BAT *p, BAT *b, BAT *s, BAT
*e, int tp1, int tp2, int frame_type);
-gdk_export gdk_return GDKanalyticalavg(BAT *r, BAT *p, BAT *b, BAT *s, BAT *e,
int tpe, int frame_type);
-gdk_export gdk_return GDKanalyticalavginteger(BAT *r, BAT *p, BAT *b, BAT *s,
BAT *e, int tpe, int frame_type);
+gdk_export gdk_return GDKanalyticalmin(BAT *r, BAT *p, BAT *o, BAT *b, BAT *s,
BAT *e, int tpe, int frame_type);
+gdk_export gdk_return GDKanalyticalmax(BAT *r, BAT *p, BAT *o, BAT *b, BAT *s,
BAT *e, int tpe, int frame_type);
+gdk_export gdk_return GDKanalyticalcount(BAT *r, BAT *p, BAT *o, BAT *b, BAT
*s, BAT *e, bit ignore_nils, int tpe, int frame_type);
+gdk_export gdk_return GDKanalyticalsum(BAT *r, BAT *p, BAT *o, BAT *b, BAT *s,
BAT *e, int tp1, int tp2, int frame_type);
+gdk_export gdk_return GDKanalyticalprod(BAT *r, BAT *p, BAT *o, BAT *b, BAT
*s, BAT *e, int tp1, int tp2, int frame_type);
+gdk_export gdk_return GDKanalyticalavg(BAT *r, BAT *p, BAT *o, BAT *b, BAT *s,
BAT *e, int tpe, int frame_type);
+gdk_export gdk_return GDKanalyticalavginteger(BAT *r, BAT *p, BAT *o, BAT *b,
BAT *s, BAT *e, int tpe, int frame_type);
gdk_export gdk_return GDKanalytical_stddev_samp(BAT *r, BAT *b, BAT *s, BAT
*e, int tpe);
gdk_export gdk_return GDKanalytical_stddev_pop(BAT *r, BAT *b, BAT *s, BAT *e,
int tpe);
diff --git a/gdk/gdk_analytic_func.c b/gdk/gdk_analytic_func.c
--- a/gdk/gdk_analytic_func.c
+++ b/gdk/gdk_analytic_func.c
@@ -790,10 +790,9 @@ GDKanalyticallead(BAT *r, BAT *b, BAT *p
#define ANALYTICAL_MIN_MAX_CALC_FIXED_UNBOUNDED_TILL_CURRENT_ROW(TPE, MIN_MAX)
\
do { \
for (; k < i;) { \
- TPE v = bp[k]; \
- TPE curval = v; \
j = k++; \
- while (k < i && bp[k] == v) { \
+ TPE curval = bp[j]; \
+ while (k < i && !op[k]) { \
if (!is_##TPE##_nil(bp[k])) { \
if (is_##TPE##_nil(curval)) \
curval = bp[k]; \
@@ -811,10 +810,9 @@ GDKanalyticallead(BAT *r, BAT *b, BAT *p
#define ANALYTICAL_MIN_MAX_CALC_FIXED_CURRENT_ROW_TILL_UNBOUNDED(TPE, MIN_MAX)
\
do { \
for (j = i - 1; j >= k; ) { \
- TPE v = bp[j]; \
- TPE curval = v; \
l = j--; \
- while (j >= k && bp[j] == v) { \
+ TPE curval = bp[l]; \
+ while (j >= k && !op[j]) { \
if (!is_##TPE##_nil(bp[j])) { \
if (is_##TPE##_nil(curval)) \
curval = bp[j]; \
@@ -883,15 +881,15 @@ GDKanalyticallead(BAT *r, BAT *b, BAT *p
#define ANALYTICAL_MIN_MAX_CALC_VARSIZED_UNBOUNDED_TILL_CURRENT_ROW(GT_LT)
\
do { \
for (; k < i;) { \
- void *next = BUNtail(bpi, k), *curval = next; \
j = k++; \
- while (k < i && atomcmp(BUNtail(bpi, k), next) == 0) { \
- void *nnext = BUNtail(bpi, k); \
- if (atomcmp(nnext, nil) != 0) { \
+ void *curval = BUNtail(bpi, j); \
+ while (k < i && !op[k]) { \
+ void *next = BUNtail(bpi, k); \
+ if (atomcmp(next, nil) != 0) { \
if (atomcmp(curval, nil) == 0) \
- curval = nnext; \
+ curval = next; \
else \
- curval = atomcmp(nnext, curval)
GT_LT 0 ? curval : nnext; \
+ curval = atomcmp(next, curval)
GT_LT 0 ? curval : next; \
} \
k++; \
} \
@@ -905,15 +903,15 @@ GDKanalyticallead(BAT *r, BAT *b, BAT *p
#define ANALYTICAL_MIN_MAX_CALC_VARSIZED_CURRENT_ROW_TILL_UNBOUNDED(GT_LT)
\
do { \
for (j = i - 1; j >= k; ) { \
- void *next = BUNtail(bpi, j), *curval = next; \
l = j--; \
- while (j >= k && atomcmp(BUNtail(bpi, j), next) == 0) {
\
- void *nnext = BUNtail(bpi, j); \
- if (atomcmp(nnext, nil) != 0) { \
+ void *curval = BUNtail(bpi, l); \
+ while (j >= k && !op[j]) { \
+ void *next = BUNtail(bpi, j); \
+ if (atomcmp(next, nil) != 0) { \
if (atomcmp(curval, nil) == 0) \
- curval = nnext; \
+ curval = next; \
else \
- curval = atomcmp(nnext, curval)
GT_LT 0 ? curval : nnext; \
+ curval = atomcmp(next, curval)
GT_LT 0 ? curval : next; \
} \
j--; \
} \
@@ -1035,12 +1033,12 @@ GDKanalyticallead(BAT *r, BAT *b, BAT *p
#define ANALYTICAL_MIN_MAX(OP, MIN_MAX, GT_LT) \
gdk_return \
-GDKanalytical##OP(BAT *r, BAT *p, BAT *b, BAT *s, BAT *e, int tpe, int
frame_type) \
+GDKanalytical##OP(BAT *r, BAT *p, BAT *o, BAT *b, BAT *s, BAT *e, int tpe, int
frame_type) \
{ \
bool has_nils = false; \
lng i = 0, j = 0, k = 0, l = 0, m = 0, cnt = (lng) BATcount(b);
\
lng *restrict start = s ? (lng*)Tloc(s, 0) : NULL, *restrict end = e ?
(lng*)Tloc(e, 0) : NULL; \
- bit *restrict np = p ? Tloc(p, 0) : NULL; \
+ bit *restrict np = p ? Tloc(p, 0) : NULL, *restrict op = o ? Tloc(o, 0)
: NULL; \
BATiter bpi = bat_iterator(b); \
const void *nil = ATOMnilptr(tpe); \
int (*atomcmp)(const void *, const void *) = ATOMcompare(tpe); \
@@ -1077,10 +1075,9 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
curval = 0; \
if (count_all) { \
for (; k < i;) { \
- TPE v = bp[k]; \
j = k++; \
curval++; \
- while (k < i && bp[k] == v) { \
+ while (k < i && !op[k]) { \
curval++; \
k++; \
} \
@@ -1089,10 +1086,9 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
} \
} else { \
for (; k < i;) { \
- TPE v = bp[k]; \
j = k++; \
- curval += !is_##TPE##_nil(v); \
- while (k < i && bp[k] == v) { \
+ curval += !is_##TPE##_nil(bp[j]); \
+ while (k < i && !op[k]) { \
curval += !is_##TPE##_nil(bp[k]); \
k++; \
} \
@@ -1107,10 +1103,9 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
curval = 0; \
if (count_all) { \
for (j = i - 1; j >= k; ) { \
- TPE v = bp[j]; \
l = j--; \
curval++; \
- while (j >= k && bp[j] == v) { \
+ while (j >= k && !op[j]) { \
curval++; \
j--; \
} \
@@ -1120,10 +1115,9 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
} \
} else { \
for (j = i - 1; j >= k; ) { \
- TPE v = bp[j]; \
l = j--; \
- curval += !is_##TPE##_nil(bp[j]); \
- while (j >= k && bp[j] == v) { \
+ curval += !is_##TPE##_nil(bp[l]); \
+ while (j >= k && !op[j]) { \
curval += !is_##TPE##_nil(bp[j]); \
j--; \
} \
@@ -1186,10 +1180,9 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
if (count_all) { \
if (isvarsized) { \
for (; k < i; ) { \
- const void *v = base + ((const var_t *)
bheap)[k]; \
j = k++; \
curval++; \
- while (k < i && cmp(base + ((const
var_t *) bheap)[k], v) == 0) { \
+ while (k < i && !op[k]) { \
curval++; \
k++; \
} \
@@ -1198,10 +1191,9 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
} \
} else { \
for (; k < i; ) { \
- const void *v = Tloc(b, k); \
j = k++; \
curval++; \
- while (k < i && cmp(Tloc(b, k), v) ==
0) { \
+ while (k < i && !op[k]) { \
curval++; \
k++; \
} \
@@ -1212,10 +1204,10 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
} else { \
if (isvarsized) { \
for (; k < i; ) { \
- const void *v = base + ((const var_t *)
bheap)[k]; \
j = k++; \
+ const void *v = base + ((const var_t *)
bheap)[j]; \
curval += cmp(v, nil) != 0; \
- while (k < i && cmp(base + ((const
var_t *) bheap)[k], v) == 0) { \
+ while (k < i && !op[k]) { \
curval += cmp(base + ((const
var_t *) bheap)[k], nil) != 0; \
k++; \
} \
@@ -1224,11 +1216,11 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
} \
} else { \
for (; k < i; ) { \
- const void *v = Tloc(b, k); \
j = k++; \
+ const void *v = BUNtail(bpi, j); \
curval += cmp(v, nil) != 0; \
- while (k < i && cmp(Tloc(b, k), v) ==
0) { \
- curval += cmp(Tloc(b, k), nil)
!= 0; \
+ while (k < i && !op[k]) { \
+ curval += cmp(BUNtail(bpi, k),
nil) != 0; \
k++; \
} \
for (; j < k; j++) \
@@ -1244,10 +1236,9 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
if (count_all) { \
if (isvarsized) { \
for (j = i - 1; j >= k; ) { \
- const void *v = base + ((const var_t *)
bheap)[j]; \
l = j--; \
curval++; \
- while (j >= k && cmp(base + ((const
var_t *) bheap)[j], v) == 0) { \
+ while (j >= k && !op[j]) { \
curval++; \
j--; \
} \
@@ -1257,10 +1248,9 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
} \
} else { \
for (j = i - 1; j >= k; ) { \
- void *v = Tloc(b, j); \
l = j--; \
curval++; \
- while (j >= k && cmp(Tloc(b, j), v) ==
0) { \
+ while (j >= k && !op[j]) { \
curval++; \
j--; \
} \
@@ -1272,10 +1262,10 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
} else { \
if (isvarsized) { \
for (j = i - 1; j >= k; ) { \
- const void *v = base + ((const var_t *)
bheap)[j]; \
l = j--; \
+ const void *v = base + ((const var_t *)
bheap)[l]; \
curval += cmp(v, nil) != 0; \
- while (j >= k && cmp(base + ((const
var_t *) bheap)[j], v) == 0) { \
+ while (j >= k && !op[j]) { \
curval += cmp(base + ((const
var_t *) bheap)[j], nil) != 0; \
j--; \
} \
@@ -1285,11 +1275,11 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
} \
} else { \
for (j = i - 1; j >= k; ) { \
- void *v = Tloc(b, j); \
l = j--; \
+ const void *v = Tloc(b, l); \
curval += cmp(v, nil) != 0; \
- while (j >= k && cmp(Tloc(b, j), v) ==
0) { \
- curval += cmp(Tloc(b, j), nil)
!= 0; \
+ while (j >= k && !op[j]) { \
+ curval += cmp(BUNtail(bpi, j),
nil) != 0; \
j--; \
} \
m = MAX(k, j); \
@@ -1312,7 +1302,7 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
curval += cmp(nil, base + ((const var_t
*) bheap)[j]) != 0; \
} else { \
for (; j < i; j++) \
- curval += cmp(Tloc(b, j), nil) != 0; \
+ curval += cmp(BUNtail(bpi, j), nil) !=
0; \
} \
} \
for (; k < i; k++) \
@@ -1330,7 +1320,7 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
rb[k] = cmp(nil, base + ((const var_t
*) bheap)[k]) != 0; \
} else { \
for (; k < i; k++) \
- rb[k] = cmp(Tloc(b, k), nil) != 0; \
+ rb[k] = cmp(BUNtail(bpi, k), nil) != 0;
\
} \
} \
} while (0)
@@ -1356,7 +1346,7 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
j = start[k]; \
l = end[k]; \
for (; j < l; j++) \
- curval += cmp(Tloc(b, j), nil)
!= 0; \
+ curval += cmp(BUNtail(bpi, j),
nil) != 0; \
rb[k] = curval; \
curval = 0; \
} \
@@ -1423,16 +1413,17 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
} while (0)
gdk_return
-GDKanalyticalcount(BAT *r, BAT *p, BAT *b, BAT *s, BAT *e, bit ignore_nils,
int tpe, int frame_type)
+GDKanalyticalcount(BAT *r, BAT *p, BAT *o, BAT *b, BAT *s, BAT *e, bit
ignore_nils, int tpe, int frame_type)
{
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
