Changeset: 29cd71b32422 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=29cd71b32422
Removed Files:
        monetdb5/modules/atoms/mtime.h
        monetdb5/modules/atoms/mtime_analytic.c
Modified Files:
        gdk/gdk_analytic_bounds.c
        monetdb5/modules/atoms/CMakeLists.txt
        monetdb5/modules/atoms/mtime.c
        sql/backends/monet5/sql_rank.c
        sql/test/analytics/Tests/analytics07.stable.err
        tools/monetdbe/monetdbe.c
Branch: window-tunning
Log Message:

Moved bounds calculation into the GDK as the time types have moved there. This 
cleans up the codebase for the binary search optimization I plan to make soon


diffs (truncated from 573 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
@@ -9,6 +9,7 @@
 #include "monetdb_config.h"
 #include "gdk.h"
 #include "gdk_analytic.h"
+#include "gdk_time.h"
 #include "gdk_calc_private.h"
 
 #define ANALYTICAL_DIFF_IMP(TPE)                               \
@@ -516,6 +517,150 @@ GDKanalyticaldiff(BAT *r, BAT *b, BAT *p
        } while (0)
 #endif
 
+#define date_sub_month(D,M)                    date_add_month(D,-(M))
+#define timestamp_sub_month(T,M)       timestamp_add_month(T,-(M))
+
+#define daytime_add_msec(D,M)          daytime_add_usec(D, 1000*(M))
+#define daytime_sub_msec(D,M)          daytime_add_usec(D, -1000*(M))
+#define date_add_msec(D,M)                     date_add_day(D,(int) 
((M)/(24*60*60*1000)))
+#define date_sub_msec(D,M)                     date_add_day(D,(int) 
(-(M)/(24*60*60*1000)))
+#define timestamp_add_msec(T,M)                timestamp_add_usec(T, (M)*1000)
+#define timestamp_sub_msec(T,M)                timestamp_add_usec(T, -(M)*1000)
+
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_MTIME_PRECEDING(TPE1, LIMIT, 
TPE2, SUB, ADD) \
+       do {                                                                    
                                                        \
+               lng m = k - 1;                                                  
                                                \
+               TPE1 v, vmin, vmax;                                             
                                                \
+               if (b->tnonil) {                                                
                                                \
+                       for (; k < i; k++) {                                    
                                \
+                               TPE2 rlimit = LIMIT;    \
+                               if (is_##TPE1##_nil(rlimit) || rlimit < 0)      
\
+                                       goto invalid_bound;     \
+                               v = bp[k];                                      
                                                        \
+                               vmin = SUB(v, rlimit);                          
                                        \
+                               vmax = ADD(v, rlimit);                          
                                        \
+                               for (j=k; ; j--) {                              
                                                \
+                                       if (j == m)                             
                                                        \
+                                               break;                          
                                                        \
+                                       if ((!is_##TPE1##_nil(vmin) && bp[j] < 
vmin) ||         \
+                                               (!is_##TPE1##_nil(vmax) && 
bp[j] > vmax))               \
+                                               break;                          
                                                        \
+                               }                                               
                                                                \
+                               j++;                                            
                                                        \
+                               rb[k] = j;                                      
                                                        \
+                       }                                                       
                                                                \
+               } else {                                                        
                                                        \
+                       for (; k < i; k++) {                                    
                                \
+                               TPE2 rlimit = LIMIT;    \
+                               if (is_##TPE1##_nil(rlimit) || rlimit < 0)      
\
+                                       goto invalid_bound;     \
+                               v = bp[k];                                      
                                                        \
+                               if (is_##TPE1##_nil(v)) {                       
                                        \
+                                       for (j=k; ; j--) {                      
                                                \
+                                               if (!is_##TPE1##_nil(bp[j]))    
                                \
+                                                       break;                  
                                                        \
+                                       }                                       
                                                                \
+                               } else {                                        
                                                        \
+                                       vmin = SUB(v, rlimit);                  
                                        \
+                                       vmax = ADD(v, rlimit);                  
                                        \
+                                       for (j=k; ; j--) {                      
                                                \
+                                               if (j == m)                     
                                                        \
+                                                       break;                  
                                                        \
+                                               if (is_##TPE1##_nil(bp[j]))     
                                        \
+                                                       break;                  
                                                        \
+                                               if ((!is_##TPE1##_nil(vmin) && 
bp[j] < vmin) || \
+                                                       (!is_##TPE1##_nil(vmax) 
&& bp[j] > vmax))       \
+                                                       break;                  
                                                        \
+                                       }                                       
                                                                \
+                               }                                               
                                                                \
+                               j++;                                            
                                                        \
+                               rb[k] = j;                                      
                                                        \
+                       }                                                       
                                                                \
+               } \
+       } while(0)
+
+#define ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_MTIME_FOLLOWING(TPE1, LIMIT, 
TPE2, SUB, ADD) \
+       do {                                                                    
                                                        \
+               TPE1 v, vmin, vmax;                                             
                                                \
+               if (b->tnonil) {                                                
                                                \
+                       for (; k < i; k++) {                                    
                                \
+                               TPE2 rlimit = LIMIT;    \
+                               if (is_##TPE1##_nil(rlimit) || rlimit < 0)      
\
+                                       goto invalid_bound;     \
+                               v = bp[k];                                      
                                                        \
+                               vmin = SUB(v, rlimit);                          
                                        \
+                               vmax = ADD(v, rlimit);                          
                                        \
+                               for (j=k+1; j<i; j++) {                         
                                        \
+                                       if ((!is_##TPE1##_nil(vmin) && bp[j] < 
vmin) ||         \
+                                               (!is_##TPE1##_nil(vmax) && 
bp[j] > vmax))               \
+                                               break;                          
                                                        \
+                               }                                               
                                                                \
+                               rb[k] = j;                                      
                                                        \
+                       }                                                       
                                                                \
+               } else {                                                        
                                                        \
+                       for (; k < i; k++) {                                    
                                \
+                               TPE2 rlimit = LIMIT;    \
+                               if (is_##TPE1##_nil(rlimit) || rlimit < 0)      
\
+                                       goto invalid_bound;     \
+                               v = bp[k];                                      
                                                        \
+                               if (is_##TPE1##_nil(v)) {                       
                                        \
+                                       for (j=k+1; j<i; j++) {                 
                                        \
+                                               if (!is_##TPE1##_nil(bp[j]))    
                                \
+                                                       break;                  
                                                        \
+                                       }                                       
                                                                \
+                               } else {                                        
                                                        \
+                                       vmin = SUB(v, rlimit);                  
                                        \
+                                       vmax = ADD(v, rlimit);                  
                                        \
+                                       for (j=k+1; j<i; j++) {                 
                                        \
+                                               if (is_##TPE1##_nil(bp[j]))     
                                        \
+                                                       break;                  
                                                        \
+                                               if ((!is_##TPE1##_nil(vmin) && 
bp[j] < vmin) || \
+                                                       (!is_##TPE1##_nil(vmax) 
&& bp[j] > vmax))       \
+                                                       break;                  
                                                        \
+                                       }                                       
                                                                \
+                               }                                               
                                                                \
+                               rb[k] = j;                                      
                                                        \
+                       }                                                       
                                                                \
+               } \
+       } while(0)
+
+#define ANALYTICAL_WINDOW_BOUNDS_CALC_FIXED_MTIME(TPE1, IMP, LIMIT, TPE2, SUB, 
ADD) \
+       do { \
+               TPE1 *restrict bp = (TPE1*)Tloc(b, 0); \
+               if (p) {                                                \
+                       for (; i < cnt; i++) {                  \
+                               if (np[i])                      \
+                                       IMP(TPE1, LIMIT, TPE2, SUB, ADD); \
+                       }                                               \
+               }               \
+               i = cnt;                                        \
+               IMP(TPE1, LIMIT, TPE2, SUB, ADD); \
+       } while(0)
+
+#define ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_MTIME_MONTH_INTERVAL(IMP, 
LIMIT) \
+       do { \
+               if (tp1 == TYPE_date) { \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_FIXED_MTIME(date, 
ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_MTIME##IMP, LIMIT, int, date_sub_month, 
date_add_month); \
+               } else if (tp1 == TYPE_timestamp) { \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_FIXED_MTIME(timestamp, 
ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_MTIME##IMP, LIMIT, int, 
timestamp_sub_month, timestamp_add_month); \
+               } else { \
+                       goto type_not_supported; \
+               } \
+       } while(0)
+
+#define ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_MTIME_SEC_INTERVAL(IMP, LIMIT) 
\
+       do { \
+               if (tp1 == TYPE_daytime) { \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_FIXED_MTIME(daytime, 
ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_MTIME##IMP, LIMIT, lng, daytime_sub_msec, 
daytime_add_msec); \
+               } else if (tp1 == TYPE_date) { \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_FIXED_MTIME(date, 
ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_MTIME##IMP, LIMIT, lng, date_sub_msec, 
date_add_msec); \
+               } else if (tp1 == TYPE_timestamp) { \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_FIXED_MTIME(timestamp, 
ANALYTICAL_WINDOW_BOUNDS_FIXED_RANGE_MTIME##IMP, LIMIT, lng, 
timestamp_sub_msec, timestamp_add_msec); \
+               } else { \
+                       goto type_not_supported; \
+               } \
+       } while(0)
+
 static gdk_return
 GDKanalyticalallbounds(BAT *r, BAT *b, BAT *p, bool preceding)
 {
@@ -702,7 +847,13 @@ GDKanalyticalrangebounds(BAT *r, BAT *b,
                }
                case TYPE_int:{
                        int *restrict limit = (int *) Tloc(l, 0);
-                       if (preceding) {
+                       if (tp1 == TYPE_daytime || tp1 == TYPE_date || tp1 == 
TYPE_timestamp) {
+                               if (preceding) {
+                                       
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_MTIME_MONTH_INTERVAL(_PRECEDING, 
limit[k]);
+                               } else {
+                                       
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_MTIME_MONTH_INTERVAL(_FOLLOWING, 
limit[k]);
+                               }
+                       } else if (preceding) {
                                
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_NUM(_PRECEDING, limit[k], int);
                        } else {
                                
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_NUM(_FOLLOWING, limit[k], int);
@@ -711,7 +862,13 @@ GDKanalyticalrangebounds(BAT *r, BAT *b,
                }
                case TYPE_lng:{
                        lng *restrict limit = (lng *) Tloc(l, 0);
-                       if (preceding) {
+                       if (tp1 == TYPE_daytime || tp1 == TYPE_date || tp1 == 
TYPE_timestamp) {
+                               if (preceding) {
+                                       
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_MTIME_SEC_INTERVAL(_PRECEDING, 
limit[k]);
+                               } else {
+                                       
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_MTIME_SEC_INTERVAL(_FOLLOWING, 
limit[k]);
+                               }
+                       } else if (preceding) {
                                
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_NUM(_PRECEDING, limit[k], lng);
                        } else {
                                
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_NUM(_FOLLOWING, limit[k], lng);
@@ -795,6 +952,20 @@ GDKanalyticalrangebounds(BAT *r, BAT *b,
                        }
                        if (is_lng_nil(limit) || limit < 0) {
                                goto invalid_bound;
+                       } else if (tp1 == TYPE_daytime || tp1 == TYPE_date || 
tp1 == TYPE_timestamp) {
+                               if (tp2 == TYPE_int) {
+                                       if (preceding) {
+                                               
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_MTIME_MONTH_INTERVAL(_PRECEDING, limit);
+                                       } else {
+                                               
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_MTIME_MONTH_INTERVAL(_FOLLOWING, limit);
+                                       }
+                               } else {
+                                       if (preceding) {
+                                               
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_MTIME_SEC_INTERVAL(_PRECEDING, limit);
+                                       } else {
+                                               
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_MTIME_SEC_INTERVAL(_FOLLOWING, limit);
+                                       }
+                               }
                        } else if (preceding) {
                                
ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_NUM(_PRECEDING, limit, lng);
                        } else {
diff --git a/monetdb5/modules/atoms/CMakeLists.txt 
b/monetdb5/modules/atoms/CMakeLists.txt
--- a/monetdb5/modules/atoms/CMakeLists.txt
+++ b/monetdb5/modules/atoms/CMakeLists.txt
@@ -19,13 +19,10 @@ target_sources(atoms
   uuid.c uuid.h
   json.c
   mtime.c
-  mtime_analytic.c
   inet.c
   identifier.c
   xml.c xml.h
-  batxml.c
-  PUBLIC
-  ${CMAKE_CURRENT_SOURCE_DIR}/mtime.h)
+  batxml.c)
 
 target_include_directories(atoms
   PRIVATE
@@ -50,5 +47,4 @@ target_compile_definitions(atoms
 
 set_target_properties(atoms
   PROPERTIES
-  POSITION_INDEPENDENT_CODE ON
-  PUBLIC_HEADER ${CMAKE_CURRENT_SOURCE_DIR}/mtime.h)
+  POSITION_INDEPENDENT_CODE ON)
diff --git a/monetdb5/modules/atoms/mtime.c b/monetdb5/modules/atoms/mtime.c
--- a/monetdb5/modules/atoms/mtime.c
+++ b/monetdb5/modules/atoms/mtime.c
@@ -31,7 +31,6 @@
 #include "monetdb_config.h"
 #include "gdk.h"
 #include "gdk_time.h"
-#include "mtime.h"
 #include "mal_client.h"
 #include "mal_interpreter.h"
 #include "mal_exception.h"
diff --git a/monetdb5/modules/atoms/mtime.h b/monetdb5/modules/atoms/mtime.h
deleted file mode 100644
--- a/monetdb5/modules/atoms/mtime.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0.  If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright 1997 - July 2008 CWI, August 2008 - 2020 MonetDB B.V.
- */
-
-#ifndef _MONETTIME_H_
-#define _MONETTIME_H_
-
-#include "mal.h"
-
-mal_export str MTIMEanalyticalrangebounds(BAT *r, BAT *b, BAT *p, BAT *l,
-                                                                               
  const void* restrict bound,
-                                                                               
  int tp1, int tp2, bool preceding,
-                                                                               
  lng first_half);
-
-#endif /* _MONETTIME_H_ */
diff --git a/monetdb5/modules/atoms/mtime_analytic.c 
b/monetdb5/modules/atoms/mtime_analytic.c
deleted file mode 100644
--- a/monetdb5/modules/atoms/mtime_analytic.c
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0.  If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright 1997 - July 2008 CWI, August 2008 - 2020 MonetDB B.V.
- */
-
-/*
- * @t Temporal analytic module
- * @a Pedro Ferreira
- * @v 1.0
- *
- * Ranges calculation for temporal types for SQL windowing functions.
- */
-
-#include "monetdb_config.h"
-#include "mal_exception.h"
-#include "gdk_time.h"
-#include "mtime.h"
-
-#define date_sub_month(D,M)                    date_add_month(D,-(M))
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to