Changeset: e1ad93dcc00b for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=e1ad93dcc00b
Modified Files:
gdk/gdk_analytic.h
gdk/gdk_analytic_func.c
sql/backends/monet5/sql.c
sql/backends/monet5/sql_rank.c
sql/backends/monet5/sql_rank.h
sql/server/rel_select.c
sql/test/analytics/Tests/analytics06.stable.err
sql/test/analytics/Tests/analytics06.stable.out
Branch: window-tunning
Log Message:
For first, last and nth-value functions fallback to the previous path. It will
scale in o(n) - o(nlogn) with my future changes. Now the first batch of
analytics tests are passing
diffs (truncated from 1256 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
@@ -25,9 +25,9 @@ gdk_export gdk_return GDKanalyticalwindo
int tp1, int tp2, int unit,
bool preceding, lng first_half);
-gdk_export gdk_return GDKanalyticalfirst(BAT *r, BAT *p, BAT *o, BAT *b, BAT
*s, BAT *e, int tpe, int frame_type);
-gdk_export gdk_return GDKanalyticallast(BAT *r, BAT *p, BAT *o, BAT *b, BAT
*s, BAT *e, int tpe, int frame_type);
-gdk_export gdk_return GDKanalyticalnthvalue(BAT *r, BAT *b, BAT *p, BAT *o,
BAT *s, BAT *e, BAT *l, lng *nth, int tp1, int frame_type);
+gdk_export gdk_return GDKanalyticalfirst(BAT *r, BAT *b, BAT *s, BAT *e, int
tpe);
+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, lng *nth, int tp1);
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);
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
@@ -152,99 +152,10 @@ nosupport:
return GDK_FAIL;
}
-#define ANALYTICAL_FIRST_LAST_PARTITIONS(TPE, IMP) \
- do { \
- TPE *bp = (TPE*)Tloc(b, 0), *restrict rb = (TPE*)Tloc(r, 0); \
- if (p) { \
- for (; i < cnt; i++) { \
- if (np[i]) \
- ANALYTICAL_FIRST_LAST_FIXED_##IMP(TPE);
\
- } \
- } \
- i = cnt; \
- ANALYTICAL_FIRST_LAST_FIXED_##IMP(TPE); \
- } while (0)
-
-#ifdef HAVE_HGE
-#define ANALYTICAL_FIRST_LAST_LIMIT(IMP) \
- case TYPE_hge: \
- ANALYTICAL_FIRST_LAST_PARTITIONS(hge, IMP); \
- break;
-#else
-#define ANALYTICAL_FIRST_LAST_LIMIT(IMP)
-#endif
-
-#define ANALYTICAL_FIRST_LAST_BRANCHES(IMP) \
- do { \
- switch (ATOMbasetype(tpe)) { \
- case TYPE_bte:
\
- ANALYTICAL_FIRST_LAST_PARTITIONS(bte, IMP);
\
- break;
\
- case TYPE_sht:
\
- ANALYTICAL_FIRST_LAST_PARTITIONS(sht, IMP);
\
- break;
\
- case TYPE_int:
\
- ANALYTICAL_FIRST_LAST_PARTITIONS(int, IMP);
\
- break;
\
- case TYPE_lng:
\
- ANALYTICAL_FIRST_LAST_PARTITIONS(lng, IMP);
\
- break;
\
- ANALYTICAL_FIRST_LAST_LIMIT(IMP)
\
- case TYPE_flt:
\
- ANALYTICAL_FIRST_LAST_PARTITIONS(flt, IMP);
\
- break;
\
- case TYPE_dbl:
\
- ANALYTICAL_FIRST_LAST_PARTITIONS(dbl, IMP);
\
- break;
\
- default: {
\
- if (p) {
\
- for (; i < cnt; i++) { \
- if (np[i]) \
-
ANALYTICAL_FIRST_LAST_VARSIZED_##IMP; \
- }
\
- } \
- i = cnt; \
- ANALYTICAL_FIRST_LAST_VARSIZED_##IMP; \
- }
\
- }
\
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_FIXED_F_CURRENT_ROW_TILL_UNBOUNDED(TPE) \
- do { \
- for (j = l; ; j--) { \
- if (op[j] || j == k) { \
- TPE curval = bp[j]; \
- for (; l >= j; l--) \
- rb[l] = curval; \
- has_nils |= is_##TPE##_nil(curval); \
- if (j == k) \
- break; \
- l = j - 1; \
- } \
- } \
- k = i; \
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_FIXED_F_ALL_ROWS(TPE) \
- do { \
- TPE v = bp[k]; \
- for (; k < i; k++) \
- rb[k] = v; \
- has_nils |= is_##TPE##_nil(v); \
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_FIXED_F_CURRENT_ROW(TPE) \
- do { \
- for (; k < i; k++) { \
- TPE v = bp[k]; \
- rb[k] = v; \
- has_nils |= is_##TPE##_nil(v); \
- } \
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_FIXED_F_OTHERS(TPE)
\
+#define ANALYTICAL_FIRST_FIXED(TPE) \
do { \
- for (; k < i; k++) { \
+ TPE *bp = (TPE*)Tloc(b, 0), *restrict rb = (TPE*)Tloc(r, 0);
\
+ for (; k < cnt; k++) { \
TPE *bs = bp + start[k], *be = bp + end[k];
\
TPE curval = (be > bs) ? *bs : TPE##_nil; \
rb[k] = curval; \
@@ -252,179 +163,47 @@ nosupport:
} \
} while (0)
-#define ANALYTICAL_FIRST_LAST_VARSIZED_F_CURRENT_ROW_TILL_UNBOUNDED \
- do { \
- for (j = l; ; j--) { \
- if (op[j] || j == k) { \
- const void *curval = BUNtail(bpi, j); \
- for (; l >= j; l--) \
- if (tfastins_nocheckVAR(r, l, curval,
Tsize(r)) != GDK_SUCCEED) \
- return GDK_FAIL; \
- has_nils |= atomcmp(curval, nil) == 0; \
- if (j == k) \
- break; \
- l = j - 1; \
- } \
- } \
- k = i; \
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_VARSIZED_F_ALL_ROWS \
- do { \
- const void *curval = BUNtail(bpi, k); \
- for (; k < i; k++) \
- if (tfastins_nocheckVAR(r, k, curval, Tsize(r)) !=
GDK_SUCCEED) \
- return GDK_FAIL; \
- has_nils |= atomcmp(curval, nil) == 0; \
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_VARSIZED_F_CURRENT_ROW \
- do { \
- for (; k < i; k++) { \
- const void *curval = BUNtail(bpi, k); \
- if (tfastins_nocheckVAR(r, k, curval, Tsize(r)) !=
GDK_SUCCEED) \
- return GDK_FAIL; \
- has_nils |= atomcmp(curval, nil) == 0; \
- } \
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_VARSIZED_F_OTHERS
\
- do { \
- for (; k < i; k++) { \
- const void *curval = (end[k] > start[k]) ? BUNtail(bpi,
start[k]) : nil; \
- if (tfastins_nocheckVAR(r, k, curval, Tsize(r)) !=
GDK_SUCCEED) \
- return GDK_FAIL; \
- has_nils |= atomcmp(curval, nil) == 0; \
- } \
- } while (0)
-
gdk_return
-GDKanalyticalfirst(BAT *r, BAT *p, BAT *o, BAT *b, BAT *s, BAT *e, int tpe,
int frame_type)
+GDKanalyticalfirst(BAT *r, BAT *b, BAT *s, BAT *e, int tpe)
{
bool has_nils = false;
- lng i = 0, j = 0, k = 0, l = 0, cnt = (lng) BATcount(b);
- lng *restrict start = s ? (lng*)Tloc(s, 0) : NULL, *restrict end = e ?
(lng*)Tloc(e, 0) : NULL;
- bit *np = p ? Tloc(p, 0) : NULL, *op = o ? Tloc(o, 0) : NULL;
+ lng k = 0, cnt = (lng) BATcount(b);
+ lng *restrict start = (lng*)Tloc(s, 0), *restrict end = (lng*)Tloc(e,
0);
BATiter bpi = bat_iterator(b);
const void *nil = ATOMnilptr(tpe);
int (*atomcmp)(const void *, const void *) = ATOMcompare(tpe);
- switch (frame_type) {
- case 4: /* current row until unbounded */ {
- ANALYTICAL_FIRST_LAST_BRANCHES(F_CURRENT_ROW_TILL_UNBOUNDED);
- } break;
- case 3: /* unbounded until current row */
- case 5: /* all rows */ {
- ANALYTICAL_FIRST_LAST_BRANCHES(F_ALL_ROWS);
- } break;
- case 6: /* current row */ {
- ANALYTICAL_FIRST_LAST_BRANCHES(F_CURRENT_ROW);
- } break;
- default: {
- ANALYTICAL_FIRST_LAST_BRANCHES(F_OTHERS);
- }
- }
-
- BATsetcount(r, (BUN) cnt);
- r->tnonil = !has_nils;
- r->tnil = has_nils;
- return GDK_SUCCEED;
-}
-
-#define ANALYTICAL_FIRST_LAST_FIXED_L_UNBOUNDED_TILL_CURRENT_ROW(TPE) \
- do { \
- for (; k < i;) { \
- j = k; \
- do { \
- k++; \
- } while (k < i && !op[k]); \
- TPE curval = bp[k - 1]; \
- for (; j < k; j++) \
- rb[j] = curval; \
- has_nils |= is_##TPE##_nil(curval); \
- } \
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_FIXED_L_ALL_ROWS(TPE) \
- do { \
- TPE v = bp[i - 1]; \
- for (; k < i; k++) \
- rb[k] = v; \
- has_nils |= is_##TPE##_nil(v); \
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_FIXED_L_CURRENT_ROW(TPE)
ANALYTICAL_FIRST_LAST_FIXED_F_CURRENT_ROW(TPE)
-
-#define ANALYTICAL_FIRST_LAST_FIXED_L_OTHERS(TPE)
\
- do { \
- for (; k < i; k++) { \
- TPE *bs = bp + start[k], *be = bp + end[k];
\
- TPE curval = (be > bs) ? *(be - 1) : TPE##_nil; \
- rb[k] = curval; \
- has_nils |= is_##TPE##_nil(curval); \
- } \
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_VARSIZED_L_UNBOUNDED_TILL_CURRENT_ROW \
- do { \
- for (; k < i;) { \
- j = k; \
- do { \
- k++; \
- } while (k < i && !op[k]); \
- const void *curval = BUNtail(bpi, k - 1); \
- for (; j < k; j++) \
- if (tfastins_nocheckVAR(r, j, curval, Tsize(r))
!= GDK_SUCCEED) \
- return GDK_FAIL; \
- has_nils |= atomcmp(curval, nil) == 0; \
- } \
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_VARSIZED_L_ALL_ROWS \
- do { \
- const void *curval = BUNtail(bpi, i - 1); \
- for (; k < i; k++) \
- if (tfastins_nocheckVAR(r, k, curval, Tsize(r)) !=
GDK_SUCCEED) \
- return GDK_FAIL; \
- has_nils |= atomcmp(curval, nil) == 0; \
- } while (0)
-
-#define ANALYTICAL_FIRST_LAST_VARSIZED_L_CURRENT_ROW
ANALYTICAL_FIRST_LAST_VARSIZED_F_CURRENT_ROW
-
-#define ANALYTICAL_FIRST_LAST_VARSIZED_L_OTHERS \
- do { \
- for (; k < i; k++) { \
- const void *curval = (end[k] > start[k]) ? BUNtail(bpi,
(BUN) (end[k] - 1)) : nil; \
- if (tfastins_nocheckVAR(r, k, curval, Tsize(r)) !=
GDK_SUCCEED) \
- return GDK_FAIL; \
- has_nils |= atomcmp(curval, nil) == 0; \
- } \
- } while (0)
-
-gdk_return
-GDKanalyticallast(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, cnt = (lng) BATcount(b);
- lng *restrict start = s ? (lng*)Tloc(s, 0) : NULL, *restrict end = e ?
(lng*)Tloc(e, 0) : NULL;
- bit *np = p ? Tloc(p, 0) : NULL, *op = o ? Tloc(o, 0) : NULL;
- BATiter bpi = bat_iterator(b);
- const void *nil = ATOMnilptr(tpe);
- int (*atomcmp)(const void *, const void *) = ATOMcompare(tpe);
-
- switch (frame_type) {
- case 3: /* unbounded until current row */ {
- ANALYTICAL_FIRST_LAST_BRANCHES(L_UNBOUNDED_TILL_CURRENT_ROW);
- } break;
- case 4: /* current row until unbounded */
- case 5: /* all rows */ {
- ANALYTICAL_FIRST_LAST_BRANCHES(L_ALL_ROWS);
- } break;
- case 6: /* current row */ {
- ANALYTICAL_FIRST_LAST_BRANCHES(L_CURRENT_ROW);
- } break;
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
