Changeset: 047b232bf1ee for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=047b232bf1ee
Modified Files:
gdk/gdk_analytic.h
gdk/gdk_analytic_func.c
sql/backends/monet5/sql.c
sql/backends/monet5/sql_rank.c
sql/common/sql_types.c
Branch: window-tunning
Log Message:
Nth_value is getting hard, I have to go through the old way, it still scales
well
diffs (truncated from 860 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
@@ -27,7 +27,7 @@ gdk_export gdk_return GDKanalyticalwindo
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 *s,
BAT *e, BAT *l, const void *restrict bound, int tp1, int tp2, 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 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
@@ -434,351 +434,337 @@ GDKanalyticallast(BAT *r, BAT *p, BAT *o
return GDK_SUCCEED;
}
-#define ANALYTICAL_NTHVALUE_IMP_SINGLE_FIXED_TRIVIAL(TPE1)
\
- do { \
- TPE1 *bp = (TPE1*)Tloc(b, 0), *restrict rb = (TPE1*)Tloc(r, 0);
\
- TPE1 curval = !is_lng_nil(nth) && nth <= i - k ? bp[nth - 1 +
k] : TPE1##_nil; \
- for (; k < i; k++) \
- rb[k] = curval; \
- has_nils |= is_##TPE1##_nil(curval); \
+//lnth - 1 > end[k] - start[k]
+
+#define ANALYTICAL_NTHVALUE_IMP_FIXED_UNBOUNDED_TILL_CURRENT_ROW(TPE) \
+ do { \
+ if (t) { \
+ for (; k < i; k++) { \
+ if (!is_lng_nil(tp[k]) && tp[k] <= 0) goto
invalidnth; \
+ TPE curval = !is_lng_nil(tp[k]) && i - l >=
tp[k] ? bp[l + tp[k] - 1] : TPE##_nil; \
+ rb[k] = curval; \
+ has_nils |= is_##TPE##_nil(curval); \
+ } \
+ } else { \
+ for (; k < i; k++) { \
+ TPE curval = !is_lng_nil(nth) && i - l >= nth ?
bp[l + nth - 1] : TPE##_nil; \
+ rb[k] = curval; \
+ has_nils |= is_##TPE##_nil(curval); \
+ } \
+ } \
+ l = k; \
} while (0)
-#define ANALYTICAL_NTHVALUE_IMP_SINGLE_FIXED_CURRENT_ROW(TPE1)
\
- do { \
- TPE1 *bp = (TPE1*)Tloc(b, 0), *restrict rb = (TPE1*)Tloc(r, 0);
\
- for (; k < i; k++) { \
- rb[k] = nth == 1 ? bp[k] : TPE1##_nil; \
- has_nils |= is_##TPE1##_nil(rb[k]); \
+#define ANALYTICAL_NTHVALUE_IMP_FIXED_CURRENT_ROW_TILL_UNBOUNDED(TPE) \
+ do { \
+ if (t) { \
+ for (; k < i; k++) { \
+ if (!is_lng_nil(tp[k]) && tp[k] <= 0) goto
invalidnth; \
+ TPE curval = !is_lng_nil(tp[k]) && i - k >=
tp[k] ? bp[k + tp[k] - 1] : TPE##_nil; \
+ rb[k] = curval; \
+ has_nils |= is_##TPE##_nil(curval); \
+ } \
+ } else { \
+ for (; k < i; k++) { \
+ TPE curval = !is_lng_nil(nth) && i - k >= nth ?
bp[k + nth - 1] : TPE##_nil; \
+ rb[k] = curval; \
+ has_nils |= is_##TPE##_nil(curval); \
+ } \
} \
+ l = k; \
+ } while (0)
+
+#define ANALYTICAL_NTHVALUE_IMP_FIXED_ALL_ROWS(TPE) \
+ do { \
+ if (t) { \
+ for (; k < i; k++) { \
+ if (!is_lng_nil(tp[k]) && tp[k] <= 0) goto
invalidnth; \
+ rb[k] = !is_lng_nil(tp[k]) && tp[k] <= i - l ?
bp[l + tp[k] - 1] : TPE##_nil; \
+ has_nils |= is_##TPE##_nil(rb[k]); \
+ } \
+ } else { \
+ TPE curval = !is_lng_nil(nth) && nth <= i - l ? bp[l +
nth - 1] : TPE##_nil; \
+ for (; k < i; k++) \
+ rb[k] = curval; \
+ has_nils |= is_##TPE##_nil(curval); \
+ } \
+ l = k; \
} while (0)
-#define ANALYTICAL_NTHVALUE_IMP_SINGLE_FIXED_OTHERS(TPE1)
\
+#define ANALYTICAL_NTHVALUE_IMP_FIXED_CURRENT_ROW(TPE) \
do { \
- TPE1 *bp = (TPE1*)Tloc(b, 0), *restrict rb = (TPE1*)Tloc(r, 0);
\
- if (is_lng_nil(nth)) { \
- has_nils = true; \
- for (; k < i; k++) \
- rb[k] = TPE1##_nil; \
- } else { \
- nth--; \
- for (; k < i; k++) { \
- TPE1 *bs = bp + start[k];
\
- TPE1 *be = bp + end[k]; \
- TPE1 curval = (be > bs && nth < (end[k] -
start[k])) ? *(bs + nth) : TPE1##_nil; \
- rb[k] = curval; \
- has_nils |= is_##TPE1##_nil(curval); \
- } \
- } \
+ if (t) { \
+ for (; k < i; k++) { \
+ if (!is_lng_nil(tp[k]) && tp[k] <= 0) goto
invalidnth; \
+ rb[k] = tp[k] == 1 ? bp[k] : TPE##_nil; \
+ has_nils |= is_##TPE##_nil(rb[k]); \
+ } \
+ } else { \
+ for (; k < i; k++) { \
+ rb[k] = nth == 1 ? bp[k] : TPE##_nil; \
+ has_nils |= is_##TPE##_nil(rb[k]); \
+ } \
+ } \
} while (0)
-#define ANALYTICAL_NTHVALUE_IMP_SINGLE_VARSIZED_TRIVIAL \
+#define ANALYTICAL_NTHVALUE_IMP_FIXED_OTHERS(TPE) \
do { \
- const void *curval = !is_lng_nil(nth) && nth <= i - k ?
BUNtail(bpi, (BUN) (nth - 1 + k)) : nil; \
- for (; k < i; k++) \
- if (tfastins_nocheckVAR(r, k, curval, Tsize(r)) !=
GDK_SUCCEED) \
- return GDK_FAIL; \
- has_nils |= atomcmp(curval, nil) == 0; \
+ TPE curval; \
+ if (t) { \
+ for (; k < i; k++) { \
+ lng lnth = tp[k];
\
+ TPE *bs = bp + start[k];
\
+ TPE *be = bp + end[k];
\
+ if (!is_lng_nil(nth) && nth <= 0) goto
invalidnth; \
+ if (is_lng_nil(lnth) || be <= bs || lnth - 1 >
end[k] - start[k]) { \
+ curval = TPE##_nil; \
+ has_nils = true; \
+ } else {
\
+ curval = *(bs + lnth - 1);
\
+ has_nils |= is_##TPE##_nil(curval);
\
+ } \
+ rb[k] = curval; \
+ }
\
+ } else { \
+ if (is_lng_nil(nth)) {
\
+ has_nils = true;
\
+ for (; k < i; k++) \
+ rb[k] = TPE##_nil;
\
+ } else {
\
+ nth--;
\
+ for (; k < i; k++) { \
+ TPE *bs = bp + start[k];
\
+ TPE *be = bp + end[k];
\
+ TPE curval = (be > bs && nth < (end[k]
- start[k])) ? *(bs + nth) : TPE##_nil; \
+ rb[k] = curval;
\
+ has_nils |= is_##TPE##_nil(curval);
\
+ }
\
+ }
\
+ } \
} while (0)
-#define ANALYTICAL_NTHVALUE_IMP_SINGLE_VARSIZED_CURRENT_ROW
\
- do { \
- for (; k < i; k++) { \
- const void *curval = nth == 1 ? BUNtail(bpi, (BUN) k) :
nil; \
- if (tfastins_nocheckVAR(r, k, curval, Tsize(r)) !=
GDK_SUCCEED) \
- return GDK_FAIL; \
- has_nils |= atomcmp(curval, nil) == 0; \
- } \
+#define ANALYTICAL_NTHVALUE_IMP_VARSIZED_UNBOUNDED_TILL_CURRENT_ROW \
+ do { \
+ if (t) { \
+ for (; k < i; k++) { \
+ if (!is_lng_nil(tp[k]) && tp[k] <= 0) goto
invalidnth; \
+ const void *curval = !is_lng_nil(tp[k]) && i -
l >= tp[k] ? BUNtail(bpi, (BUN) (l + tp[k] - 1)) : nil; \
+ if (tfastins_nocheckVAR(r, k, curval, Tsize(r))
!= GDK_SUCCEED) \
+ return GDK_FAIL; \
+ has_nils |= atomcmp(curval, nil) == 0; \
+ } \
+ } else { \
+ for (; k < i; k++) { \
+ const void *curval = !is_lng_nil(nth) && i - l
>= nth ? BUNtail(bpi, (BUN) (l + nth - 1)) : nil; \
+ if (tfastins_nocheckVAR(r, k, curval, Tsize(r))
!= GDK_SUCCEED) \
+ return GDK_FAIL; \
+ has_nils |= atomcmp(curval, nil) == 0; \
+ } \
+ } \
+ l = k; \
} while (0)
-#define ANALYTICAL_NTHVALUE_IMP_SINGLE_VARSIZED_OTHERS \
- do { \
- if (is_lng_nil(nth)) { \
- has_nils = true; \
- for (; k < i; k++) \
- if (tfastins_nocheckVAR(r, k, nil, Tsize(r)) !=
GDK_SUCCEED) \
- return GDK_FAIL; \
- } else { \
- nth--; \
- for (; k < i; k++) { \
- const void *curval = (end[k] > start[k] && nth
< (end[k] - start[k])) ? BUNtail(bpi, (BUN) (start[k] + nth)) : nil; \
+#define ANALYTICAL_NTHVALUE_IMP_VARSIZED_CURRENT_ROW_TILL_UNBOUNDED \
+ do { \
+ if (t) { \
+ for (; k < i; k++) { \
+ if (!is_lng_nil(tp[k]) && tp[k] <= 0) goto
invalidnth; \
+ const void *curval = !is_lng_nil(tp[k]) && i -
k >= tp[k] ? BUNtail(bpi, (BUN) (k + tp[k] - 1)) : nil; \
if (tfastins_nocheckVAR(r, k, curval, Tsize(r))
!= GDK_SUCCEED) \
return GDK_FAIL; \
has_nils |= atomcmp(curval, nil) == 0; \
} \
- } \
+ } else { \
+ for (; k < i; k++) { \
+ const void *curval = !is_lng_nil(nth) && i - k
>= nth ? BUNtail(bpi, (BUN) (k + nth - 1)) : nil; \
+ if (tfastins_nocheckVAR(r, k, curval, Tsize(r))
!= GDK_SUCCEED) \
+ return GDK_FAIL; \
+ has_nils |= atomcmp(curval, nil) == 0; \
+ } \
+ } \
+ l = k; \
} while (0)
-#define ANALYTICAL_NTHVALUE_IMP_MULTI_FIXED_TRIVIAL(TPE1, TPE2, TPE3)
\
+#define ANALYTICAL_NTHVALUE_IMP_VARSIZED_ALL_ROWS \
+ do { \
+ if (t) { \
+ for (; k < i; k++) { \
+ if (!is_lng_nil(tp[k]) && tp[k] <= 0) goto
invalidnth; \
+ const void *curval = !is_lng_nil(tp[k]) &&
tp[k] <= i - l ? BUNtail(bpi, (BUN) (l + tp[k] - 1)) : nil; \
+ if (tfastins_nocheckVAR(r, k, curval, Tsize(r))
!= GDK_SUCCEED) \
+ return GDK_FAIL; \
+ has_nils |= atomcmp(curval, nil) == 0; \
+ } \
+ } else { \
+ const void *curval = !is_lng_nil(nth) && nth <= i - l ?
BUNtail(bpi, (BUN) (l + nth - 1)) : nil; \
+ for (; k < i; k++) { \
+ if (tfastins_nocheckVAR(r, k, curval, Tsize(r))
!= GDK_SUCCEED) \
+ return GDK_FAIL; \
+ } \
+ has_nils |= atomcmp(curval, nil) == 0; \
+ } \
+ l = k; \
+ } while (0)
+
+#define ANALYTICAL_NTHVALUE_IMP_VARSIZED_CURRENT_ROW \
do { \
- TPE2 *restrict lp = (TPE2*)Tloc(l, 0); \
- for (; k < i; k++) { \
- if (!is_##TPE2##_nil(lp[k]) && lp[k] <= 0) goto
invalidnth; \
- rb[k] = !is_##TPE2##_nil(lp[k]) && lp[k] <= i - k ?
bp[lp[k] - 1 + k] : TPE1##_nil; \
- has_nils |= is_##TPE1##_nil(rb[k]); \
+ if (t) { \
+ const void *curval = nil; \
+ for (; k < i; k++) { \
+ if (!is_lng_nil(tp[k]) && tp[k] <= 0) goto
invalidnth; \
+ curval = tp[k] == 1 ? BUNtail(bpi, (BUN) tp[k])
: nil; \
+ if (tfastins_nocheckVAR(r, k, curval, Tsize(r))
!= GDK_SUCCEED) \
+ return GDK_FAIL; \
+ has_nils |= atomcmp(curval, nil) == 0; \
+ } \
+ } else { \
+ for (; k < i; k++) { \
+ const void *curval = nth == 1 ? BUNtail(bpi,
(BUN) k) : nil; \
+ if (tfastins_nocheckVAR(r, k, curval, Tsize(r))
!= GDK_SUCCEED) \
+ return GDK_FAIL; \
+ has_nils |= atomcmp(curval, nil) == 0; \
+ } \
} \
} while (0)
-#define ANALYTICAL_NTHVALUE_IMP_MULTI_FIXED_CURRENT_ROW(TPE1, TPE2, TPE3)
\
+#define ANALYTICAL_NTHVALUE_IMP_VARSIZED_OTHERS \
do { \
- TPE2 *restrict lp = (TPE2*)Tloc(l, 0); \
- for (; k < i; k++) { \
- if (!is_##TPE2##_nil(lp[k]) && lp[k] <= 0) goto
invalidnth; \
- rb[k] = lp[k] == 1 ? bp[k] : TPE1##_nil; \
- has_nils |= is_##TPE1##_nil(rb[k]); \
- } \
+ if (t) { \
+ const void *curval = nil; \
+ for (; k < i; k++) {
\
+ lng lnth = tp[k];
\
+ if (!is_lng_nil(nth) && nth <= 0) goto
invalidnth; \
+ if (is_lng_nil(lnth) || end[k] <= start[k] ||
(lng)(lnth - 1) > (lng)(end[k] - start[k])) { \
+ curval = (void *) nil;
\
+ has_nils = true; \
+ } else { \
+ curval = BUNtail(bpi, (BUN) (start[k] +
lnth - 1)); \
+ has_nils |= atomcmp(curval, nil) == 0;
\
+ } \
+ if (tfastins_nocheckVAR(r, k, curval, Tsize(r))
!= GDK_SUCCEED) \
+ return GDK_FAIL; \
+ }
\
+ } else { \
+ if (is_lng_nil(nth)) { \
+ has_nils = true; \
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
