Changeset: f28c64889f73 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=f28c64889f73
Modified Files:
        gdk/gdk_analytic.h
        gdk/gdk_analytic_bounds.c
        gdk/gdk_analytic_func.c
        sql/backends/monet5/sql_rank.c
        sql/backends/monet5/sql_rank.mal
        sql/backends/monet5/sql_rank.mal.sh
        sql/common/sql_types.c
        sql/server/rel_select.c
        sql/test/analytics/Tests/analytics00.stable.out
        sql/test/analytics/Tests/analytics01.stable.err
        sql/test/analytics/Tests/analytics01.stable.out
        sql/test/analytics/Tests/analytics02.sql
        sql/test/analytics/Tests/analytics02.stable.err
        sql/test/analytics/Tests/analytics02.stable.out
        sql/test/analytics/Tests/analytics06.sql
        sql/test/analytics/Tests/analytics06.stable.out
Branch: analytics
Log Message:

Allow first_value, last_value and nth_value functions to use frames, and fixed 
nulls values handling in range and groups frames.


diffs (truncated from 1589 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
@@ -21,13 +21,13 @@ gdk_export gdk_return GDKanalyticaldiff(
 gdk_export gdk_return GDKanalyticalntile(BAT *r, BAT *b, BAT *p, int tpe, 
const void* restrict ntile);
 gdk_export gdk_return GDKanalyticallag(BAT *r, BAT *b, BAT *p, BUN lag, const 
void* restrict default_value, int tpe);
 gdk_export gdk_return GDKanalyticallead(BAT *r, BAT *b, BAT *p, BUN lead, 
const void* restrict default_value, int tpe);
-gdk_export gdk_return GDKanalyticalfirst(BAT *r, BAT *b, BAT *p, int tpe);
-gdk_export gdk_return GDKanalyticallast(BAT *r, BAT *b, BAT *p, int tpe);
-gdk_export gdk_return GDKanalyticalnthvalue(BAT *r, BAT *b, BAT *p, BUN nth, 
int tpe);
 
 gdk_export gdk_return GDKanalyticalwindowbounds(BAT *r, BAT *b, BAT *p, BAT 
*l, const void* restrict bound,
                                                                                
                int tp1, int tp2, int unit, bool preceding, lng first_half);
 
+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, 
BUN nth, int tpe);
 gdk_export gdk_return GDKanalyticalmin(BAT *r, BAT *b, BAT *s, BAT *e, int 
tpe);
 gdk_export gdk_return GDKanalyticalmax(BAT *r, BAT *b, BAT *s, BAT *e, int 
tpe);
 gdk_export gdk_return GDKanalyticalcount(BAT *r, BAT *b, BAT *s, BAT *e, const 
bit* restrict ignore_nils, int tpe);
diff --git a/gdk/gdk_analytic_bounds.c b/gdk/gdk_analytic_bounds.c
--- a/gdk/gdk_analytic_bounds.c
+++ b/gdk/gdk_analytic_bounds.c
@@ -42,18 +42,22 @@
                for(; k<i; k++, rb++) {                    \
                        rlimit = (TPE2) LIMIT;                 \
                        v = bp[k];                             \
-                       if(is_##TPE1##_nil(v))                 \
-                               j = m;                             \
-                       else                                   \
+                       if(is_##TPE1##_nil(v)) {               \
+                               for(j=k; j>m; j--) {               \
+                                       if(!is_##TPE1##_nil(bp[j]))    \
+                                               break;                     \
+                               }                                  \
+                       } else {                               \
                                for(j=k; j>m; j--) {               \
                                        if(is_##TPE1##_nil(bp[j]))     \
-                                               continue;                  \
+                                               break;                     \
                                        SUB_WITH_CHECK(TPE1, v, TPE1, bp[j], 
TPE1, calc, GDK_##TPE1##_max, goto calc_overflow); \
                                        if ((TPE2)(ABSOLUTE(calc)) > rlimit) { \
                                                j++;                       \
                                                break;                     \
                                        }                              \
                                }                                  \
+                       }                                      \
                        *rb = j;                               \
                }                                          \
        } while(0)
@@ -65,16 +69,20 @@
                for(; k<i; k++, rb++) {                  \
                        rlimit = (TPE2) LIMIT;               \
                        v = bp[k];                           \
-                       if(is_##TPE1##_nil(v))               \
-                               j = i;                           \
-                       else                                 \
+                       if(is_##TPE1##_nil(v)) {             \
+                               for(j=k+1; j<i; j++) {           \
+                                       if(!is_##TPE1##_nil(bp[j]))  \
+                                               break;                   \
+                               }                                \
+                       } else {                             \
                                for(j=k+1; j<i; j++) {           \
                                        if(is_##TPE1##_nil(bp[j]))   \
-                                               continue;                \
+                                               break;                   \
                                        SUB_WITH_CHECK(TPE1, v, TPE1, bp[j], 
TPE1, calc, GDK_##TPE1##_max, goto calc_overflow); \
                                        if ((TPE2)(ABSOLUTE(calc)) > rlimit) \
                                                break;                   \
                                }                                \
+                       }                                    \
                        *rb = j;                             \
                }                                        \
        } while(0)
@@ -85,12 +93,15 @@
                for(; k<i; k++, rb++) {           \
                        TPE2 rlimit = (TPE2) LIMIT;   \
                        TPE1 v = bp[k];               \
-                       if(is_##TPE1##_nil(v))        \
-                               j = m;                    \
-                       else                          \
+                       if(is_##TPE1##_nil(v)) {      \
+                               for(j=k; j>m; j--) {      \
+                                       if(!is_##TPE1##_nil(bp[j])) \
+                                               break;            \
+                               }                         \
+                       } else {                      \
                                for(j=k; j>m; j--) {      \
                                        if(is_##TPE1##_nil(bp[j])) \
-                                               continue;         \
+                                               break;            \
                                        if(v != bp[j]) {      \
                                                if(rlimit == 0) { \
                                                        j++;          \
@@ -100,6 +111,7 @@
                                                v = bp[j];        \
                                        }                     \
                                }                         \
+                       }                             \
                        *rb = j;                      \
                }                                 \
        } while(0)
@@ -109,12 +121,15 @@
                for(; k<i; k++, rb++) {         \
                        TPE2 rlimit = (TPE2) LIMIT; \
                        TPE1 v = bp[k];             \
-                       if(is_##TPE1##_nil(v))      \
-                               j = i;                  \
-                       else                        \
+                       if(is_##TPE1##_nil(v)) {    \
+                               for(j=k+1; j<i; j++) {  \
+                                       if(!is_##TPE1##_nil(bp[j])) \
+                                               break;          \
+                               }                       \
+                       } else {                    \
                                for(j=k+1; j<i; j++) {  \
                                        if(is_##TPE1##_nil(bp[j])) \
-                                               continue;       \
+                                               break;           \
                                        if(v != bp[j]) {    \
                                                if(rlimit == 0) \
                                                        break;      \
@@ -122,6 +137,7 @@
                                                v = bp[j];      \
                                        }                   \
                                }                       \
+                       }                           \
                        *rb = j;                    \
                }                               \
        } while(0)
@@ -151,18 +167,22 @@
                lng m = k;                                \
                for(; k<i; k++, rb++) {                   \
                        void *v = BUNtail(bpi, (BUN) k);      \
-                       if(atomcmp(v, nil) == 0)              \
-                               j = m;                            \
-                       else                                  \
+                       if(atomcmp(v, nil) == 0) {            \
+                               for(j=k; j>m; j--) {              \
+                                       if(atomcmp(BUNtail(bpi, (BUN) j), nil) 
!= 0) \
+                                               break;                    \
+                               }                                 \
+                       } else {                              \
                                for(j=k; j>m; j--) {              \
                                        void *next = BUNtail(bpi, (BUN) j); \
                                        if(atomcmp(next, nil) == 0)   \
-                                               continue;                 \
+                                               break;                    \
                                        if(ABSOLUTE(atomcmp(v, next)) > (int) 
LIMIT) { \
                                                j++;                      \
                                                break;                    \
                                        }                             \
                                }                                 \
+                       }                                     \
                        *rb = j;                              \
                }                                         \
        } while(0)
@@ -171,16 +191,20 @@
        do {                                          \
                for(; k<i; k++, rb++) {                   \
                        void *v = BUNtail(bpi, (BUN) k);      \
-                       if(atomcmp(v, nil) == 0)              \
-                               j = i;                            \
-                       else                                  \
+                       if(atomcmp(v, nil) == 0) {            \
+                               for(j=k+1; j<i; j++) {            \
+                                       if(atomcmp(BUNtail(bpi, (BUN) j), nil) 
!= 0) \
+                                               break;                    \
+                               }                                 \
+                       } else {                              \
                                for(j=k+1; j<i; j++) {            \
                                        void *next = BUNtail(bpi, (BUN) j); \
                                        if(atomcmp(next, nil) == 0)   \
-                                               continue;                 \
+                                               break;                    \
                                        if(ABSOLUTE(atomcmp(v, next)) > (int) 
LIMIT) \
                                                break;                    \
                                }                                 \
+                       }                                     \
                        *rb = j;                              \
                }                                         \
        } while(0)
@@ -191,13 +215,16 @@
                for(; k<i; k++, rb++) {                   \
                        lng rlimit = (lng) LIMIT;             \
                        void *v = BUNtail(bpi, (BUN) k);      \
-                       if(atomcmp(v, nil) == 0)              \
-                               j = m;                            \
-                       else                                  \
+                       if(atomcmp(v, nil) == 0) {            \
+                               for(j=k; j>m; j--) {              \
+                                       if(atomcmp(BUNtail(bpi, (BUN) j), nil) 
!= 0) \
+                                               break;                    \
+                               }                                 \
+                       } else {                              \
                                for(j=k; j>m; j--) {              \
                                        void *next = BUNtail(bpi, (BUN) j); \
                                        if(atomcmp(next, nil) == 0)   \
-                                               continue;                 \
+                                               break;                    \
                                        if(atomcmp(v, next)) {        \
                                                if(rlimit == 0) {         \
                                                        j++;                  \
@@ -207,6 +234,7 @@
                                                v = next;                 \
                                        }                             \
                                }                                 \
+                       }                                     \
                        *rb = j;                              \
                }                                         \
        } while(0)
@@ -216,13 +244,16 @@
                for(; k<i; k++, rb++) {                   \
                        lng rlimit = (lng) LIMIT;             \
                        void *v = BUNtail(bpi, (BUN) k);      \
-                       if(atomcmp(v, nil) == 0)              \
-                               j = i;                            \
-                       else                                  \
+                       if(atomcmp(v, nil) == 0) {            \
+                               for(j=k+1; j<i; j++) {            \
+                                       if(atomcmp(BUNtail(bpi, (BUN) j), nil) 
!= 0) \
+                                               break;                    \
+                               }                                 \
+                       } else {                              \
                                for(j=k+1; j<i; j++) {            \
                                        void *next = BUNtail(bpi, (BUN) j); \
                                        if(atomcmp(next, nil) == 0)   \
-                                               continue;                 \
+                                               break;                    \
                                        if(atomcmp(v, next)) {        \
                                                if(rlimit == 0)           \
                                                        break;                \
@@ -230,6 +261,7 @@
                                                v = next;                 \
                                        }                             \
                                }                                 \
+                       }                                     \
                        *rb = j;                              \
                }                                         \
        } while(0)
@@ -388,7 +420,7 @@ GDKanalyticalallbounds(BAT *r, BAT *b, B
                                if (*np) {
                                        i += (np - pnp);
                                        j = k;
-                                       for (; k < i; k++, rb++)
+                                       for (; k<i; k++, rb++)
                                                *rb = j;
                                        pnp = np;
                                }
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
@@ -198,62 +198,31 @@ GDKanalyticalntile(BAT *r, BAT *b, BAT *
        return GDK_SUCCEED;
 }
 
-#define FIRST_CALC(TPE)            \
-       do {                           \
-               for (;rb < rp; rb++)       \
-                       *rb = curval;          \
-               if(is_##TPE##_nil(curval)) \
-                       has_nils = true;       \
-       } while(0)
-
-#define ANALYTICAL_FIRST_IMP(TPE)           \
-       do {                                    \
-               TPE *rp, *rb, *restrict bp, curval; \
-               rb = rp = (TPE*)Tloc(r, 0);         \
-               bp = (TPE*)Tloc(b, 0);              \
-               curval = *bp;                       \
-               if (p) {                            \
-                       pnp = np = (bit*)Tloc(p, 0);    \
-                       end = np + cnt;                 \
-                       for(; np<end; np++) {           \
-                               if (*np) {                  \
-                                       ncnt = (np - pnp);      \
-                                       rp += ncnt;             \
-                                       bp += ncnt;             \
-                                       FIRST_CALC(TPE);        \
-                                       curval = *bp;           \
-                                       pnp = np;               \
-                               }                           \
-                       }                               \
-                       ncnt = (np - pnp);              \
-                       rp += ncnt;                     \
-                       bp += ncnt;                     \
-                       FIRST_CALC(TPE);                \
-               } else {                            \
-                       rp += cnt;                      \
-                       FIRST_CALC(TPE);                \
-               }                                   \
-       } while(0)
-
-#define ANALYTICAL_FIRST_OTHERS                             \
-       do {                                                    \
-               curval = BUNtail(bpi, j);                           \
-               if (atomcmp(curval, nil) == 0)                      \
-                       has_nils = true;                                \
-               for (;j < i; j++) {                                 \
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to