Changeset: 269bb696de6a for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=269bb696de6a
Modified Files:
        gdk/gdk_analytic.c
        gdk/gdk_analytic.h
        sql/backends/monet5/sql_rank.c
        sql/backends/monet5/sql_rank.mal
        sql/backends/monet5/sql_rank.mal.sh
        sql/backends/monet5/sql_rank_hge.mal
        sql/backends/monet5/sql_rank_hge.mal.sh
        sql/common/sql_types.c
        sql/server/rel_select.c
        sql/test/analytics/Tests/analytics04.sql
        sql/test/analytics/Tests/analytics04.stable.out
Branch: analytics
Log Message:

Progress for non-centered window bounds.

Range and groups frames are way too complex to handle :(


diffs (truncated from 1643 to 300 lines):

diff --git a/gdk/gdk_analytic.c b/gdk/gdk_analytic.c
--- a/gdk/gdk_analytic.c
+++ b/gdk/gdk_analytic.c
@@ -102,318 +102,280 @@ GDKanalyticaldiff(BAT *r, BAT *b, BAT *p
 
 #undef ANALYTICAL_DIFF_IMP
 
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_ROWS_PRECEDING(TPE, BOUNDF) \
-       do {                                             \
-               TPE *bl = pbp;                               \
-               for(; pbp<bp; pbp++, rb++) {                 \
-                       lng rlimit = BOUNDF;                     \
-                       *rb = -MIN(pbp - bl, rlimit - inc_last); \
-               }                                            \
-       } while(0);
-
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_ROWS_FOLLOWING(TPE, BOUNDF) \
-       do {                                             \
-               for(; pbp<bp; pbp++, rb++) {                 \
-                       lng rlimit = BOUNDF;                     \
-                       *rb = MIN(bp - pbp - inc_last, rlimit) + inc_last; \
-               }                                            \
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_ROWS_FIRST_PRECEDING(TPE, LIMIT) \
+       do {                                            \
+               j = k;                                      \
+               for(; k<i; k++, rb++) {                     \
+                       lng rlimit = LIMIT;                     \
+                       *rb = MAX(k - rlimit + !first_half, j); \
+               }                                           \
        } while(0);
 
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_UNBOUNDED_PRECEDING(TPE, BOUNDF) \
-       do {                                                  \
-               TPE *bl = pbp;                                    \
-               for(; pbp<bp; pbp++, rb++)                        \
-                       *rb = -(lng)(pbp - bl);                       \
-       } while(0);
-
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_UNBOUNDED_FOLLOWING(TPE, BOUNDF) \
-       do {                                                  \
-               for(; pbp<bp; pbp++, rb++)                        \
-                       *rb = (lng)(bp - pbp);                        \
-       } while(0);
-
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_PRECEDING(TPE, BOUNDF) \
-       do {                                                \
-               TPE *bl = pbp-1, *bs, v, rlimit;                \
-               for(; pbp<bp; pbp++, rb++) {                    \
-                       lng curval = -inc_last;                     \
-                       rlimit = (TPE) BOUNDF;                      \
-                       v = *pbp;                                   \
-                       for(bs=pbp-1; bs>bl; bs--, curval--) {      \
-                               TPE calc;                               \
-                               SUB_WITH_CHECK(TPE, v, TPE, *bs, TPE, calc, 
GDK_##TPE##_max, goto calc_overflow); \
-                               if (ABSOLUTE(calc) > rlimit)            \
-                                       break;                              \
-                       }                                           \
-                       *rb = curval;                               \
-               }                                               \
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_ROWS_FIRST_FOLLOWING(TPE, LIMIT) \
+       do {                                            \
+               for(; k<i; k++, rb++) {                     \
+                       lng rlimit = LIMIT;                     \
+                       *rb = MIN(k + rlimit + !first_half, i); \
+               }                                           \
        } while(0);
 
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_FOLLOWING(TPE, BOUNDF) \
-       do {                                              \
-               TPE *bs, v, rlimit;                           \
-               for(; pbp<bp; pbp++, rb++) {                  \
-                       lng curval = inc_last;                    \
-                       rlimit = (TPE) BOUNDF;                    \
-                       v = *pbp;                                 \
-                       for(bs=pbp+1; bs<bp; bs++, curval++) {    \
-                               TPE calc;                             \
-                               SUB_WITH_CHECK(TPE, v, TPE, *bs, TPE, calc, 
GDK_##TPE##_max, goto calc_overflow); \
-                               if (ABSOLUTE(calc) > rlimit)          \
-                                       break;                            \
-                       }                                         \
-                       *rb = curval;                             \
-               }                                             \
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_ROWS_SECOND_PRECEDING(TPE, LIMIT) 
ANALYTICAL_WINDOW_BOUNDS_FIXED_ROWS_FIRST_PRECEDING(TPE, LIMIT)
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_ROWS_SECOND_FOLLOWING(TPE, LIMIT) 
ANALYTICAL_WINDOW_BOUNDS_FIXED_ROWS_FIRST_FOLLOWING(TPE, LIMIT)
+
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_FIRST_PRECEDING(TPE, LIMIT) \
+       do {                                       \
+               lng m = k;                             \
+               TPE v, rlimit, calc;                   \
+               for(; k<i; k++, rb++) {                \
+                       rlimit = LIMIT;                    \
+                       v = bp[k];                         \
+                       for(j=k; j>m; j--) {               \
+                               SUB_WITH_CHECK(TPE, v, TPE, bp[j], TPE, calc, 
GDK_##TPE##_max, goto calc_overflow); \
+                               if (ABSOLUTE(calc) > rlimit) { \
+                                       j++;                       \
+                                       break;                     \
+                               }                              \
+                       }                                  \
+                       *rb = j;                           \
+               }                                      \
        } while(0);
 
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_PRECEDING(TPE, BOUNDF) \
-       do {                                                 \
-               TPE *bl = pbp-1, *bs, v;                         \
-               for(; pbp<bp; pbp++, rb++) {                     \
-                       lng curval = -inc_last;                      \
-                       BUN rlimit = (BUN) BOUNDF;                   \
-                       v = *pbp;                                    \
-                       for(bs=pbp-1; bs>bl; bs--, curval--) {       \
-                               if(v != *bs) {                           \
-                                       if(rlimit == 0)                      \
-                                               break;                          
 \
-                                       rlimit--;                            \
-                                       v = *bs;                             \
-                               }                                        \
-                       }                                            \
-                       *rb = curval;                                \
-               }                                                \
-       } while(0);
-
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_FOLLOWING(TPE, BOUNDF) \
-       do {                                               \
-               TPE *bs, v;                                    \
-               for(; pbp<bp; pbp++, rb++) {                   \
-                       lng curval = inc_last;                     \
-                       BUN rlimit = (BUN) BOUNDF;                 \
-                       v = *pbp;                                  \
-                       for(bs=pbp+1; bs<bp; bs++, curval++) {     \
-                               if(v != *bs) {                         \
-                                       if(rlimit == 0)                    \
-                                               break;                         \
-                                       rlimit--;                          \
-                                       v = *bs;                           \
-                               }                                      \
-                       }                                          \
-                       *rb = curval;                              \
-               }                                              \
-       } while(0);
-
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_ALL_PRECEDING(TPE, BOUNDF) \
-       do {                                              \
-               lng curval = 0;                               \
-               for(; pbp<bp; pbp++, rb++)                    \
-                       *rb = curval--;                           \
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_FIRST_FOLLOWING(TPE, LIMIT) \
+       do {                                     \
+               TPE v, rlimit, calc;                 \
+               for(; k<i; k++, rb++) {              \
+                       rlimit = LIMIT;                  \
+                       v = bp[k];                       \
+                       for(j=k+1; j<i; j++) {           \
+                               SUB_WITH_CHECK(TPE, v, TPE, bp[j], TPE, calc, 
GDK_##TPE##_max, goto calc_overflow); \
+                               if (ABSOLUTE(calc) > rlimit) \
+                                       break;                   \
+                       }                                \
+                       *rb = j;                         \
+               }                                    \
        } while(0);
 
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_ALL_FOLLOWING(TPE, BOUNDF) \
-       do {                                            \
-               lng curval = ncnt + 1;                      \
-               for(; pbp<bp; pbp++, rb++)                  \
-                       *rb = --curval;                         \
-       } while(0);
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_SECOND_FOLLOWING(TPE, LIMIT) 
ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_FIRST_FOLLOWING(TPE, LIMIT)
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_SECOND_PRECEDING(TPE, LIMIT) 
ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_FIRST_PRECEDING(TPE, LIMIT)
 
-#define ANALYTICAL_WINDOW_BOUNDS_CALC_FIXED(TPE, IMP, BOUNDF) \
-       do {                                   \
-               TPE *pbp, *bp;                     \
-               pbp = bp = (TPE*)Tloc(b, 0);       \
-               if(preceding) {                    \
-                       if(np) {                       \
-                               nend += cnt;               \
-                               for(; np<nend; np++) {     \
-                                       if (*np) {             \
-                                               ncnt = (np - pnp); \
-                                               bp += ncnt;        \
-                                               IMP##_PRECEDING(TPE, BOUNDF) \
-                                               pnp = np;          \
-                                               pbp = bp;          \
-                                       }                      \
-                               }                          \
-                               ncnt = (np - pnp);         \
-                               bp += ncnt;                \
-                               IMP##_PRECEDING(TPE, BOUNDF) \
-                       } else {                       \
-                               ncnt = cnt;                \
-                               bp += ncnt;                \
-                               IMP##_PRECEDING(TPE, BOUNDF) \
-                       }                              \
-               } else if(np) {                    \
-                       nend += cnt;                   \
-                       for(; np<nend; np++) {         \
-                               if (*np) {                 \
-                               ncnt = (np - pnp);         \
-                                       bp += ncnt;            \
-                                       IMP##_FOLLOWING(TPE, BOUNDF) \
-                                       pnp = np;              \
-                                       pbp = bp;              \
-                               }                          \
-                       }                              \
-                       ncnt = (np - pnp);             \
-                       bp += ncnt;                    \
-                       IMP##_FOLLOWING(TPE, BOUNDF)   \
-               } else {                           \
-                       ncnt = cnt;                    \
-                       bp += ncnt;                    \
-                       IMP##_FOLLOWING(TPE, BOUNDF)   \
-               }                                  \
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_FIRST_PRECEDING(TPE, LIMIT) \
+       do {                              \
+               lng m = k;                    \
+               for(; k<i; k++, rb++) {       \
+                       lng rlimit = LIMIT;       \
+                       TPE v = bp[k];            \
+                       for(j=k; j>m; j--) {      \
+                               if(v != bp[j]) {      \
+                                       if(rlimit == 0) { \
+                                               j++;          \
+                                               break;        \
+                                       }                 \
+                                       rlimit--;         \
+                                       v = bp[j];        \
+                               }                     \
+                       }                         \
+                       *rb = j;                  \
+               }                             \
        } while(0);
 
-#define ANALYTICAL_WINDOW_BOUNDS_VARSIZED_ROWS_PRECEDING(BOUNDF) \
-       do {                                             \
-               BUN m = k;                                   \
-               for(; k<i; k++, rb++) {                      \
-                       lng rlimit = BOUNDF;                     \
-                       *rb = -MIN((lng)(k - m), rlimit);        \
-               }                                            \
-       } while(0);
-
-#define ANALYTICAL_WINDOW_BOUNDS_VARSIZED_ROWS_FOLLOWING(BOUNDF) \
-       do {                                             \
-               for(; k<i; k++, rb++) {                      \
-                       lng rlimit = BOUNDF;                     \
-                       *rb = MIN((lng)(i - k - 1), rlimit) + 1; \
-               }                                            \
-       } while(0);
-
-#define ANALYTICAL_WINDOW_BOUNDS_VARSIZED_UNBOUNDED_PRECEDING(BOUNDV) \
-       do {                                                  \
-               BUN j = k;                                        \
-               for(; k<i; k++, rb++)                             \
-                       *rb = -(lng)(k - j);                          \
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_FIRST_FOLLOWING(TPE, LIMIT) \
+       do {                            \
+               for(; k<i; k++, rb++) {     \
+                       lng rlimit = LIMIT;     \
+                       TPE v = bp[k];          \
+                       for(j=k+1; j<i; j++) {  \
+                               if(v != bp[j]) {    \
+                                       if(rlimit == 0) \
+                                               break;      \
+                                       rlimit--;       \
+                                       v = bp[j];      \
+                               }                   \
+                       }                       \
+                       *rb = j;                \
+               }                           \
        } while(0);
 
-#define ANALYTICAL_WINDOW_BOUNDS_VARSIZED_UNBOUNDED_FOLLOWING(BOUNDV) \
-       do {                                                \
-               for(; k<i; k++, rb++)                           \
-                       *rb = (i - k);                              \
-       } while(0);
-
-#define ANALYTICAL_WINDOW_BOUNDS_VARSIZED_RANGE_PRECEDING(BOUNDV) \
-       do {                                              \
-               BUN j;                                        \
-               *rb = 0; /* the first element's window size is hardcoded to 
avoid overflow in BUN */ \
-               rb++;                                         \
-               k++;                                          \
-               j = k - 1;                                    \
-               for(; k<i; k++, rb++) {                       \
-                       lng curval = -inc_last;                   \
-                       void *v = BUNtail(bpi, k);                \
-                       for(BUN l=k-1; l>j; l--, curval--) {      \
-                               if (ABSOLUTE(atomcmp(v, BUNtail(bpi, l))) > 
BOUNDV) \
-                                       break;                            \
-                       }                                         \
-                       *rb = curval;                             \
-               }                                             \
-       } while(0);
-
-#define ANALYTICAL_WINDOW_BOUNDS_VARSIZED_RANGE_FOLLOWING(BOUNDV) \
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_SECOND_FOLLOWING(TPE, LIMIT) 
ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_FIRST_FOLLOWING(TPE, LIMIT)
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_SECOND_PRECEDING(TPE, LIMIT) 
ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_FIRST_PRECEDING(TPE, LIMIT)
+       
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to