Changeset: 4312192ab215 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=4312192ab215
Modified Files:
        gdk/gdk_analytic_bounds.c
        sql/server/rel_select.c
Branch: window-tunning
Log Message:

Pass diff function output into group frame so it will get right results for 
call with more than one ordering column


diffs (truncated from 480 to 300 lines):

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
@@ -34,6 +34,73 @@
                }                                                       \
        } while (0)
 
+#define ANALYTICAL_WINDOW_BOUNDS_BRANCHES_ROWS(IMP, LIMIT)             \
+       do {                                                            \
+               if (p) {                                                \
+                       np = (bit*)Tloc(p, 0);                  \
+                       for (; i < cnt; i++) {                  \
+                               if (np[i])                      \
+                                       
ANALYTICAL_WINDOW_BOUNDS_ROWS##IMP(LIMIT); \
+                       }                                               \
+                       i = cnt;                                \
+                       ANALYTICAL_WINDOW_BOUNDS_ROWS##IMP(LIMIT);      \
+               } else {                                                \
+                       i = cnt;                                        \
+                       ANALYTICAL_WINDOW_BOUNDS_ROWS##IMP(LIMIT);      \
+               }                                                       \
+       } while (0)
+
+#define ANALYTICAL_WINDOW_BOUNDS_GROUPS_PRECEDING(LIMIT) \
+       do {                                                            \
+               lng m = k - 1;                                          \
+               for (; k < i; k++) {            \
+                       lng rlimit = LIMIT;             \
+                       for (j = k; ; j--) {            \
+                               if (j == m) {           \
+                                       j++; \
+                                       break;          \
+                               } \
+                               if (bp[j]) {            \
+                                       if (rlimit == 0)                \
+                                               break;          \
+                                       rlimit--;               \
+                               }                               \
+                       }                               \
+                       rb[k] =j;               \
+               }                                       \
+       } while (0)
+
+#define ANALYTICAL_WINDOW_BOUNDS_GROUPS_FOLLOWING(LIMIT) \
+       do {                                                            \
+               for (; k < i; k++) {            \
+                       lng rlimit = LIMIT;             \
+                       for (j = k + 1; j < i; j++) {   \
+                               if (bp[j]) {            \
+                                       if (rlimit == 0)                \
+                                               break;          \
+                                       rlimit--;               \
+                               }               \
+                       }               \
+                       rb[k] = j;              \
+               }               \
+       } while (0)
+
+#define ANALYTICAL_WINDOW_BOUNDS_BRANCHES_GROUPS(IMP, LIMIT)           \
+       do {                                                            \
+               if (p) {                                                \
+                       np = (bit*)Tloc(p, 0);                  \
+                       for (; i < cnt; i++) {                  \
+                               if (np[i])                      \
+                                       
ANALYTICAL_WINDOW_BOUNDS_GROUPS##IMP(LIMIT); \
+                       }                                               \
+                       i = cnt;                                \
+                       ANALYTICAL_WINDOW_BOUNDS_GROUPS##IMP(LIMIT);    \
+               } else {                                                \
+                       i = cnt;                                        \
+                       ANALYTICAL_WINDOW_BOUNDS_GROUPS##IMP(LIMIT);    \
+               }                                                       \
+       } while (0)
+
 #define ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_PRECEDING(TPE1, LIMIT, TPE2) \
        do {                                                            \
                lng m = k - 1;                                          \
@@ -117,97 +184,6 @@
                }                                                       \
        } while (0)
 
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_PRECEDING(TPE1, LIMIT, TPE2) \
-       do {                                                            \
-               lng m = k - 1;                                          \
-               if (b->tnonil) {                                        \
-                       for (; k < i; k++) {                    \
-                               TPE2 rlimit = LIMIT;                    \
-                               TPE1 v = bp[k];                         \
-                               for (j = k; ; j--) {                    \
-                                       if (j == m)                     \
-                                               break;                  \
-                               if (v != bp[j]) {                       \
-                                               if (rlimit == 0)        \
-                                                       break;          \
-                                               rlimit--;               \
-                                               v = bp[j];              \
-                                       }                               \
-                               }                                       \
-                               rb[k] = ++j;                            \
-                       }                                               \
-               } else {                                                \
-                       for (; k < i; k++) {                    \
-                               TPE2 rlimit = LIMIT;                    \
-                               TPE1 v = bp[k];                         \
-                               if (is_##TPE1##_nil(v)) {               \
-                                       for (j = k; ; j--) {            \
-                                               if (j == m)             \
-                                                       break;          \
-                                               if (!is_##TPE1##_nil(bp[j])) \
-                                                       break;          \
-                                       }                               \
-                               } else {                                \
-                                       for (j = k; ; j--) {            \
-                                               if (j == m)             \
-                                                       break;          \
-                                               if (is_##TPE1##_nil(bp[j])) \
-                                                       break;          \
-                                               if (v != bp[j]) {       \
-                                                       if (rlimit == 0) \
-                                                               break;  \
-                                                       rlimit--;       \
-                                                       v = bp[j];      \
-                                               }                       \
-                                       }                               \
-                               }                                       \
-                               rb[k] = ++j;                    \
-                       }                                               \
-               }                                                       \
-       } while (0)
-
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_FOLLOWING(TPE1, LIMIT, TPE2) \
-       do {                                                            \
-               if (b->tnonil) {                                        \
-                       for (; k < i; k++) {                    \
-                               TPE2 rlimit = LIMIT;                    \
-                               TPE1 v = bp[k];                         \
-                               for (j = k + 1; j < i; j++) {           \
-                                       if (v != bp[j]) {               \
-                                               if (rlimit == 0)        \
-                                                       break;          \
-                                               rlimit--;               \
-                                               v = bp[j];              \
-                                       }                               \
-                               }                                       \
-                               rb[k] = j;                              \
-                       }                                               \
-               } else {                                                \
-                       for (; k < i; k++) {                    \
-                               TPE2 rlimit = LIMIT;                    \
-                               TPE1 v = bp[k];                         \
-                               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])) \
-                                                       break;          \
-                                               if (v != bp[j]) {       \
-                                                       if (rlimit == 0) \
-                                                               break;  \
-                                                       rlimit--;       \
-                                                       v = bp[j];      \
-                                               }                       \
-                                       }                               \
-                               }                                       \
-                               rb[k] = j;                              \
-                       }                                               \
-               }                                                       \
-       } while (0)
-
 #define ANALYTICAL_WINDOW_BOUNDS_CALC_FIXED(TPE1, IMP, LIMIT, TPE2)    \
        do {                                                            \
                TPE1 *restrict bp = (TPE1*)Tloc(b, 0);                  \
@@ -301,119 +277,6 @@
                }                                                       \
        } while (0)
 
-#define ANALYTICAL_WINDOW_BOUNDS_VARSIZED_GROUPS_PRECEDING(LIMIT, TPE) \
-       do {                                                            \
-               lng m = k - 1;                                          \
-               if (b->tnonil) {                                        \
-                       for (; k < i; k++) {                    \
-                               TPE rlimit = LIMIT;                     \
-                               void *v = BUNtail(bpi, (BUN) k);        \
-                               for (j = k; ; j--) {                    \
-                                       void *next;                     \
-                                       if (j == m)                     \
-                                               break;                  \
-                                       next = BUNtail(bpi, (BUN) j);   \
-                                       if (atomcmp(v, next)) {         \
-                                               if (rlimit == 0)        \
-                                                       break;          \
-                                               rlimit--;               \
-                                               v = next;               \
-                                       }                               \
-                               }                                       \
-                               rb[k] = ++j;                            \
-                       }                                               \
-               } else {                                                \
-                       for (; k < i; k++) {                    \
-                               TPE rlimit = LIMIT;                     \
-                               void *v = BUNtail(bpi, (BUN) k);        \
-                               if (atomcmp(v, nil) == 0) {             \
-                                       for (j = k; ; j--) {            \
-                                               if (j == m)             \
-                                                       break;          \
-                                               if (atomcmp(BUNtail(bpi, (BUN) 
j), nil) != 0) \
-                                                       break;          \
-                                       }                               \
-                               } else {                                \
-                                       for (j = k; ; j--) {            \
-                                               void *next;             \
-                                               if (j == m)             \
-                                                       break;          \
-                                               next = BUNtail(bpi, (BUN) j); \
-                                               if (atomcmp(next, nil) == 0) \
-                                                       break;          \
-                                               if (atomcmp(v, next)) { \
-                                                       if (rlimit == 0) \
-                                                               break;  \
-                                                       rlimit--;       \
-                                                       v = next;       \
-                                               }                       \
-                                       }                               \
-                               }                                       \
-                               rb[k] = ++j;                                    
\
-                       }                                               \
-               }                                                       \
-       } while (0)
-
-#define ANALYTICAL_WINDOW_BOUNDS_VARSIZED_GROUPS_FOLLOWING(LIMIT, TPE) \
-       do {                                                            \
-               if (b->tnonil) {                                        \
-                       for (; k < i; k++) {                    \
-                               TPE rlimit = LIMIT;                     \
-                               void *v = BUNtail(bpi, (BUN) k);        \
-                               for (j = k + 1; j < i; j++) {           \
-                                       void *next = BUNtail(bpi, (BUN) j); \
-                                       if (atomcmp(v, next)) {         \
-                                               if (rlimit == 0)        \
-                                                       break;          \
-                                               rlimit--;               \
-                                               v = next;               \
-                                       }                               \
-                               }                                       \
-                               rb[k] = j;                              \
-                       }                                               \
-               } else {                                                \
-                       for (; k < i; k++) {                    \
-                               TPE rlimit = LIMIT;                     \
-                               void *v = BUNtail(bpi, (BUN) k);        \
-                               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) \
-                                                       break;          \
-                                               if (atomcmp(v, next)) { \
-                                                       if (rlimit == 0) \
-                                                               break;  \
-                                                       rlimit--;       \
-                                                       v = next;       \
-                                               }                       \
-                                       }                               \
-                               }                                       \
-                               rb[k] = j;                              \
-                       }                                               \
-               }                                                       \
-       } while (0)
-
-#define ANALYTICAL_WINDOW_BOUNDS_BRANCHES_ROWS(IMP, LIMIT)             \
-       do {                                                            \
-               if (p) {                                                \
-                       np = (bit*)Tloc(p, 0);                  \
-                       for (; i < cnt; i++) {                  \
-                               if (np[i])                      \
-                                       
ANALYTICAL_WINDOW_BOUNDS_ROWS##IMP(LIMIT); \
-                       }                                               \
-                       i = cnt;                                \
-                       ANALYTICAL_WINDOW_BOUNDS_ROWS##IMP(LIMIT);      \
-               } else {                                                \
-                       i = cnt;                                        \
-                       ANALYTICAL_WINDOW_BOUNDS_ROWS##IMP(LIMIT);      \
-               }                                                       \
-       } while (0)
-
 #define ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_NUM(IMP, LIMIT, CAST)  \
        do {                                                            \
                switch (tp1) {                                          \
@@ -513,48 +376,6 @@
        } while (0)
 #endif
 
-#ifdef HAVE_HGE
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to