Changeset: 058cc058ecd4 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=058cc058ecd4
Modified Files:
        gdk/gdk_analytic_bounds.c
        gdk/gdk_analytic_func.c
        monetdb5/modules/atoms/mtime_analytic.c
        sql/backends/monet5/sql.mal
        sql/server/rel_exp.c
        sql/server/rel_optimizer.c
        sql/server/sql_scan.c
        sql/test/BugTracker-2013/Tests/pivot.Bug-3339.stable.err
        
sql/test/BugTracker-2016/Tests/CREATE_INDEX_breaks_table_queries.Bug-4053.stable.out
        sql/test/BugTracker/Tests/bug_in_selection.SF-1892413.stable.err
        sql/test/BugTracker/Tests/bug_in_selection.SF-1892413.stable.out
        sql/test/Tests/keys.sql
        sql/test/Tests/keys.stable.out
        sql/test/copy/Tests/nonutf8.stable.err
        sql/test/miscellaneous/Tests/All
        sql/test/miscellaneous/Tests/view-mul-digits.stable.out
        sql/test/subquery/Tests/correlated.stable.err
        testing/malcheck.py
Branch: default
Log Message:

Merge with Nov2019


diffs (truncated from 1171 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
@@ -39,76 +39,144 @@
                lng m = k - 1;                                          \
                TPE1 v, calc;                                           \
                TPE2 rlimit;                                            \
-               for (; k < i; k++, rb++) {                              \
-                       rlimit = (TPE2) LIMIT;                          \
-                       v = bp[k];                                      \
-                       if (is_##TPE1##_nil(v)) {                       \
+               if (b->tnonil) {                                \
+                       for (; k < i; k++, rb++) {      \
+                               rlimit = (TPE2) LIMIT;  \
+                               v = bp[k];      \
                                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;                  \
                                        SUB_WITH_CHECK(v, bp[j], TPE1, calc, 
GDK_##TPE1##_max, goto calc_overflow); \
                                        if ((TPE2)(ABSOLUTE(calc)) > rlimit) \
                                                break;                  \
                                }                                       \
-                       }                                               \
-                       j++;                                            \
-                       *rb = j;                                        \
-               }                                                       \
+                               j++;                                            
\
+                               *rb = j;                                        
\
+                       }                                                       
\
+               } else { \
+                       for (; k < i; k++, rb++) {                              
\
+                               rlimit = (TPE2) LIMIT;                          
\
+                               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;                  
\
+                                               SUB_WITH_CHECK(v, bp[j], TPE1, 
calc, GDK_##TPE1##_max, goto calc_overflow); \
+                                               if ((TPE2)(ABSOLUTE(calc)) > 
rlimit) \
+                                                       break;                  
\
+                                       }                                       
\
+                               }                                               
\
+                               j++;                                            
\
+                               *rb = j;                                        
\
+                       }                                                       
\
+               } \
        } while (0)
 
 #define ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_FOLLOWING(TPE1, LIMIT, TPE2) \
        do {                                                            \
                TPE1 v, calc;                                           \
                TPE2 rlimit;                                            \
-               for (; k < i; k++, rb++) {                              \
-                       rlimit = (TPE2) LIMIT;                          \
-                       v = bp[k];                                      \
-                       if (is_##TPE1##_nil(v)) {                       \
-                               for (j =k + 1; j < i; j++) {            \
-                                       if (!is_##TPE1##_nil(bp[j]))    \
-                                               break;                  \
-                               }                                       \
-                       } else {                                        \
+               if (b->tnonil) {                                \
+                       for (; k < i; k++, rb++) {                              
\
+                               rlimit = (TPE2) LIMIT;                          
\
+                               v = bp[k];                                      
\
                                for (j = k + 1; j < i; j++) {           \
-                                       if (is_##TPE1##_nil(bp[j]))     \
-                                               break;                  \
                                        SUB_WITH_CHECK(v, bp[j], TPE1, calc, 
GDK_##TPE1##_max, goto calc_overflow); \
                                        if ((TPE2)(ABSOLUTE(calc)) > rlimit) \
                                                break;                  \
                                }                                       \
-                       }                                               \
-                       *rb = j;                                        \
-               }                                                       \
+                               *rb = j;                                        
\
+                       }                                                       
\
+               } else { \
+                       for (; k < i; k++, rb++) {                              
\
+                               rlimit = (TPE2) LIMIT;                          
\
+                               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;                  
\
+                                               SUB_WITH_CHECK(v, bp[j], TPE1, 
calc, GDK_##TPE1##_max, goto calc_overflow); \
+                                               if ((TPE2)(ABSOLUTE(calc)) > 
rlimit) \
+                                                       break;                  
\
+                                       }                                       
\
+                               }                                               
\
+                               *rb = j;                                        
\
+                       }                                                       
\
+               } \
        } while (0)
 
 #define ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_PRECEDING(TPE1, LIMIT, TPE2) \
        do {                                                            \
                lng m = k - 1;                                          \
-               for (; k < i; k++, rb++) {                              \
-                       TPE2 rlimit = LIMIT;                    \
-                       TPE1 v = bp[k];                                 \
-                       if (is_##TPE1##_nil(v)) {                       \
+               if (b->tnonil) { \
+                       for (; k < i; k++, rb++) {                              
\
+                               TPE2 rlimit = LIMIT;                    \
+                               TPE1 v = bp[k];                                 
\
                                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];              \
+                                       }                               \
                                }                                       \
-                       } else {                                        \
-                               for (j = k; ; j--) {                    \
-                                       if (j == m)                     \
-                                               break;                  \
-                                       if (is_##TPE1##_nil(bp[j]))     \
-                                               break;                  \
+                               j++;                                            
\
+                               *rb = j;                                        
\
+                       }                                                       
\
+               } else { \
+                       for (; k < i; k++, rb++) {                              
\
+                               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];              
\
+                                               }                               
\
+                                       }                                       
\
+                               }                                               
\
+                               j++;                                            
\
+                               *rb = j;                                        
\
+                       }                                                       
\
+               } \
+       } while (0)
+
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_FOLLOWING(TPE1, LIMIT, TPE2) \
+       do {                                                            \
+               if (b->tnonil) { \
+                       for (; k < i; k++, rb++) {                              
\
+                               TPE2 rlimit = LIMIT;                    \
+                               TPE1 v = bp[k];                                 
\
+                               for (j = k + 1; j < i; j++) {           \
                                        if (v != bp[j]) {               \
                                                if (rlimit == 0)        \
                                                        break;          \
@@ -116,36 +184,32 @@
                                                v = bp[j];              \
                                        }                               \
                                }                                       \
-                       }                                               \
-                       j++;                                            \
-                       *rb = j;                                        \
-               }                                                       \
-       } while (0)
-
-#define ANALYTICAL_WINDOW_BOUNDS_FIXED_GROUPS_FOLLOWING(TPE1, LIMIT, TPE2) \
-       do {                                                            \
-               for (; k < i; k++, rb++) {                              \
-                       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 = j;                                        \
-               }                                                       \
+                               *rb = j;                                        
\
+                       }       \
+               } else { \
+                       for (; k < i; k++, rb++) {                      \
+                               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 = j;                                        
\
+                       }                                                       
\
+               } \
        } while (0)
 
 #define ANALYTICAL_WINDOW_BOUNDS_CALC_FIXED(TPE1, IMP, LIMIT, TPE2)    \
@@ -171,75 +235,94 @@
 #define ANALYTICAL_WINDOW_BOUNDS_VARSIZED_RANGE_PRECEDING(LIMIT, TPE)  \
        do {                                                            \
                lng m = k - 1;                                          \
-               for (; k < i; k++, rb++) {                              \
-                       void *v = BUNtail(bpi, (BUN) k);                \
-                       if (atomcmp(v, nil) == 0) {                     \
-                               for (j = k; ; j--) {                    \
+               if (b->tnonil) { \
+                       for (; k < i; k++, rb++) {                      \
+                               void *v = BUNtail(bpi, (BUN) k);        \
+                               for (j = k; ; j--) {            \
+                                       void *next;                     \
                                        if (j == m)                     \
                                                break;                  \
-                                       if (atomcmp(BUNtail(bpi, (BUN) j), nil) 
!= 0) \
+                                       next = BUNtail(bpi, (BUN) j);   \
+                                       if (ABSOLUTE((TPE) atomcmp(v, next)) > 
(TPE) LIMIT) \
+                                               break;                  \
+                               }               \
+                               j++;    \
+                               *rb = j;        \
+                       }       \
+               } else { \
+                       for (; k < i; k++, rb++) {                              
\
+                               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 (ABSOLUTE((TPE) atomcmp(v, 
next)) > (TPE) LIMIT) \
+                                                       break;                  
\
+                                       }                                       
\
+                               }                                               
\
+                               j++;                                            
\
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to