Changeset: f38d101c7f41 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=f38d101c7f41
Added Files:
        sql/backends/monet5/generator/Tests/crash.Bug-3609.sql
        sql/backends/monet5/generator/Tests/crash.Bug-3609.stable.err
        sql/backends/monet5/generator/Tests/crash.Bug-3609.stable.out
        sql/test/BugTracker-2014/Tests/querylog.Bug-3607.sql
        sql/test/BugTracker-2014/Tests/querylog.Bug-3607.stable.err
        sql/test/BugTracker-2014/Tests/querylog.Bug-3607.stable.out
Modified Files:
        gdk/gdk_firstn.c
        gdk/gdk_imprints.c
        gdk/gdk_select.c
        monetdb5/mal/mal_interpreter.h
        monetdb5/modules/mal/Tests/pqueue3.stable.out
        monetdb5/modules/mal/clients.c
        monetdb5/modules/mal/querylog.c
        monetdb5/optimizer/opt_generator.c
        monetdb5/optimizer/opt_querylog.c
        monetdb5/tests/gdkTests/Tests/firstn.stable.out
        sql/backends/monet5/datacell/datacell.c
        sql/backends/monet5/datacell/opt_datacell.c
        sql/backends/monet5/datacell/opt_datacell.h
        sql/backends/monet5/generator/Tests/All
        sql/backends/monet5/sql_gencode.c
        sql/benchmarks/tpch/Tests/13-explain.stable.out.32bit
        sql/benchmarks/tpch/Tests/16-explain.stable.out.32bit
        sql/benchmarks/tpch/Tests/20-explain.stable.out.32bit
        sql/benchmarks/tpch/Tests/21-explain.stable.out.32bit
        
sql/test/BugTracker-2010/Tests/group-by_ordered_column.Bug-2564.stable.out.32bit
        sql/test/BugTracker-2014/Tests/All
        sql/test/BugTracker/Tests/jdbc_no_debug.SF-1739356.stable.out.32bit
Branch: default
Log Message:

Merge with Oct2014 branch, not deleting Node.JS connector.


diffs (truncated from 1077 to 300 lines):

diff --git a/gdk/gdk_firstn.c b/gdk/gdk_firstn.c
--- a/gdk/gdk_firstn.c
+++ b/gdk/gdk_firstn.c
@@ -70,9 +70,9 @@
  * root of the heap with a new value if appropriate (if the new value
  * is among the first-N seen so far).  The siftup macro then restores
  * the heap property. */
-#define siftup(OPER, START, SWAP)                                              
\
+#define siftup(OPER, START, SWAP)                                      \
        do {                                                            \
-           pos = (START);                                              \
+               pos = (START);                                          \
                childpos = (pos << 1) + 1;                              \
                while (childpos < n) {                                  \
                        /* find most extreme child */                   \
@@ -80,19 +80,19 @@
                            !(OPER(childpos + 1, childpos)))            \
                                childpos++;                             \
                        /* compare parent with most extreme child */    \
-                       if (OPER(pos, childpos)) {              \
-                               /* exchange parent with child and */    \
-                               /* sift child further */                \
-                               SWAP(pos, childpos);                    \
-                               pos = childpos;                         \
-                               childpos = (pos << 1) + 1;              \
-                               continue;                               \
+                       if (!OPER(pos, childpos)) {                     \
+                               /* already correctly ordered */         \
+                               break;                                  \
                        }                                               \
-                       break;                                          \
+                       /* exchange parent with child and sift child */ \
+                       /* further */                                   \
+                       SWAP(pos, childpos);                            \
+                       pos = childpos;                                 \
+                       childpos = (pos << 1) + 1;                      \
                }                                                       \
        } while (0)
 
-#define heapify(OPER, SWAP)                                    \
+#define heapify(OPER, SWAP)                            \
        do {                                            \
                for (i = n / 2; i > 0; i--)             \
                        siftup(OPER, i - 1, SWAP);      \
@@ -212,12 +212,28 @@ BATfirstn_unique(BAT *b, BAT *s, BUN n, 
                /* note, this takes care of types oid and wrd */
                tpe = ATOMstorage(tpe);
        }
+       /* if the input happens to be almost sorted in ascending order
+        * (likely a common use case), it is more efficient to start
+        * off with the first n elements when doing a firstn-ascending
+        * and to start off with the last n elements when doing a
+        * firstn-descending so that most values that we look at after
+        * this will be skipped. */
        if (cand) {
-               for (i = 0; i < n; i++)
-                       oids[i] = *cand++;
+               if (asc) {
+                       for (i = 0; i < n; i++)
+                               oids[i] = *cand++;
+               } else {
+                       for (i = 0; i < n; i++)
+                               oids[i] = *--candend;
+               }
        } else {
-               for (i = 0; i < n; i++)
-                       oids[i] = start++ + b->hseqbase;
+               if (asc) {
+                       for (i = 0; i < n; i++)
+                               oids[i] = start++ + b->hseqbase;
+               } else {
+                       for (i = 0; i < n; i++)
+                               oids[i] = --end + b->hseqbase;
+               }
        }
        if (asc) {
                switch (tpe) {
diff --git a/gdk/gdk_imprints.c b/gdk/gdk_imprints.c
--- a/gdk/gdk_imprints.c
+++ b/gdk/gdk_imprints.c
@@ -453,22 +453,13 @@ do {                                                      
                \
                }                                                       \
                GETBIN##B(bin,col[i]);                                  \
                mask = IMPSsetBit(B,mask,bin);                          \
-               if (!cnt_bins[bin]++) {                                 \
-                       min_bins[bin] = max_bins[bin] = i;              \
-               } else {                                                \
-                       /* nil value can not be min */                  \
-                       if ((bin == 0) && (col[i] != nil)) {            \
-                               /* in case the first value was nil and 
min_bin[0] \
-                                * has been initialized with it */      \
-                               if (col[min_bins[0]] == nil) {          \
-                                       min_bins[0] = i;                \
-                               } else if (col[i] < col[min_bins[0]]) { \
-                                       min_bins[0] = i;                \
-                               }                                       \
-                       } else  {                                       \
-                               if (col[i] < col[min_bins[bin]]) min_bins[bin] 
= i; \
+               if (col[i] != nil) { /* do not count nils */                    
\
+                       if (!cnt_bins[bin]++) {                                 
\
+                               min_bins[bin] = max_bins[bin] = i;              
\
+                       } else {                                                
                                                \
+                               if (col[i] < col[min_bins[bin]]) min_bins[bin] 
= i;     \
+                               if (col[i] > col[max_bins[bin]]) max_bins[bin] 
= i;     \
                        }                                               \
-                       if (col[i] > col[max_bins[bin]]) max_bins[bin] = i; \
                }                                                       \
        }                                                               \
        /* one last left */                                             \
@@ -573,7 +564,7 @@ BATimprints(BAT *b)
 {
        BAT *o = NULL;
        Imprints *imprints;
-       lng t0 =0,t1=0;
+       lng t0 = 0, t1 = 0;
 
        assert(BAThdense(b));   /* assert void head */
 
@@ -656,7 +647,7 @@ BATimprints(BAT *b)
                        struct stat st;
                        if (read(fd, hdata, sizeof(hdata)) == sizeof(hdata) &&
                            hdata[0] & ((size_t) 1 << 16) &&
-                           ((hdata[0] & 0xFF00) >> 8) == 1 && /* version 1 */
+                           ((hdata[0] & 0xFF00) >> 8) == 2 && /* version 2 */
                            hdata[3] == (size_t) BATcount(b) &&
                            fstat(fd, &st) == 0 &&
                            st.st_size >= (off_t) (imprints->imprints->size =
@@ -824,7 +815,7 @@ BATimprints(BAT *b)
                        /* add version number */
                        ((size_t *) imprints->imprints->base)[0] |= (size_t) 1 
<< 8;
                        /* sync-on-disk checked bit */
-                       ((size_t *) imprints->imprints->base)[0] |= (size_t) 1 
<< 16;
+                       ((size_t *) imprints->imprints->base)[0] |= (size_t) 2 
<< 16;
                        if (write(fd, imprints->imprints->base, sizeof(size_t)) 
< 0)
                                perror("write imprints");
 #if defined(NATIVE_WIN32)
diff --git a/gdk/gdk_select.c b/gdk/gdk_select.c
--- a/gdk/gdk_select.c
+++ b/gdk/gdk_select.c
@@ -341,6 +341,28 @@ do {                                                       
                \
        }                                                               \
 } while (0)
 
+#define checkMINMAX(B)                                                         
                                        \
+do {                                                                           
                                                        \
+       int ii;                                                                 
                                                        \
+       BUN *imp_cnt = (BUN *) (((oid *)imprints->stats)+128);                  
        \
+       imp_min = imp_max = nil;                                                
                                        \
+       for (ii = 0; ii < B; ii++) {                                            
                                \
+               if ((imp_min == nil) && (imp_cnt[ii])) {                        
                        \
+                       imp_min = src[((oid *)imprints->stats)[ii]];            
                \
+               }                                                               
                                                                \
+               if ((imp_max == nil) && (imp_cnt[B-1-ii])) {                    
                \
+                       imp_max = src[(((oid *)imprints->stats)+64)[B-1-ii]];   
        \
+               }                                                               
                                                                \
+       }                                                                       
                                                                \
+       assert((imp_min != nil) && (imp_max != nil));                           
                \
+       if (!s && !VIEWtparent(b)) { /* no candidate list and no views*/        
\
+               if ((vl > imp_max || vh < imp_min) ||                           
                        \
+                       (anti && (vl < imp_min && vh > imp_max))) {             
                        \
+               return 0;                                                       
                                                        \
+               }                                                               
                                                                \
+       }                                                                       
                                                                \
+} while (0)                                                                    
                                                        \
+
 /* choose number of bits */
 #define bitswitch(CAND,TEST)                                           \
 do {                                                                   \
@@ -352,10 +374,10 @@ do {                                                      
                \
                          s && BATtdense(s) ? "(dense)" : "",           \
                          anti, #TEST);                                 \
        switch (imprints->bits) {                                       \
-       case 8:  impsmask(CAND,TEST,8); break;                          \
-       case 16: impsmask(CAND,TEST,16); break;                         \
-       case 32: impsmask(CAND,TEST,32); break;                         \
-       case 64: impsmask(CAND,TEST,64); break;                         \
+       case 8:  checkMINMAX(8); impsmask(CAND,TEST,8); break;                  
        \
+       case 16: checkMINMAX(16); impsmask(CAND,TEST,16); break;                
                \
+       case 32: checkMINMAX(32); impsmask(CAND,TEST,32); break;                
                \
+       case 64: checkMINMAX(64); impsmask(CAND,TEST,64); break;                
                \
        default: assert(0); break;                                      \
        }                                                               \
 } while (0)
@@ -462,11 +484,13 @@ NAME##_##TYPE (BAT *b, BAT *s, BAT *bn, 
 {                                                                      \
        TYPE vl = *(const TYPE *) tl;                                   \
        TYPE vh = *(const TYPE *) th;                                   \
-       TYPE v;                                                         \
-       TYPE nil = TYPE##_nil;                                          \
+       TYPE imp_min;                                                           
        \
+       TYPE imp_max;                                                           
        \
+       TYPE v;                                                                 
                \
+       TYPE nil = TYPE##_nil;                                                  
\
        TYPE minval = MINVALUE##TYPE;                                   \
        TYPE maxval = MAXVALUE##TYPE;                                   \
-       const TYPE *src = (const TYPE *) Tloc(b, 0);                    \
+       const TYPE *src = (const TYPE *) Tloc(b, 0);    \
        oid o;                                                          \
        BUN w, p = r;                                                   \
        BUN pr_off = 0;                                                 \
diff --git a/monetdb5/mal/mal_interpreter.h b/monetdb5/mal/mal_interpreter.h
--- a/monetdb5/mal/mal_interpreter.h
+++ b/monetdb5/mal/mal_interpreter.h
@@ -98,11 +98,11 @@ mal_export ptr getArgReference(MalStkPtr
                assert(v->vtype == TYPE_bte);                           \
                &v->val.btval;                                                  
        \
        })
-#define getArgReference_oid(s, pci, k)                         \
-       ({                                                                      
                        \
-               ValRecord *v = &(s)->stk[(pci)->argv[k]];       \
-               assert(v->vtype == TYPE_oid);                           \
-               &v->val.oval;                                                   
        \
+#define getArgReference_oid(s, pci, k)                                         
        \
+       ({                                                                      
                                                \
+               ValRecord *v = &(s)->stk[(pci)->argv[k]];                       
        \
+               assert(v->vtype == TYPE_oid || v->vtype == TYPE_void);  \
+               &v->val.oval;                                                   
                                \
        })
 #define getArgReference_ptr(s, pci, k)                         \
        ({                                                                      
                        \
diff --git a/monetdb5/modules/mal/Tests/pqueue3.stable.out 
b/monetdb5/modules/mal/Tests/pqueue3.stable.out
--- a/monetdb5/modules/mal/Tests/pqueue3.stable.out
+++ b/monetdb5/modules/mal/Tests/pqueue3.stable.out
@@ -148,13 +148,13 @@ end main;
 # h    t  # name
 # void oid  # type
 #--------------------------#
-[ 0@0, 2@0  ]
+[ 0@0, 6@0  ]
 #--------------------------#
 # h    t  # name
 # void oid  # type
 #--------------------------#
 [ 0@0, 2@0  ]
-[ 1@0, 3@0  ]
+[ 1@0, 6@0  ]
 #--------------------------#
 # h    t  # name
 # void oid  # type
diff --git a/monetdb5/modules/mal/clients.c b/monetdb5/modules/mal/clients.c
--- a/monetdb5/modules/mal/clients.c
+++ b/monetdb5/modules/mal/clients.c
@@ -586,12 +586,12 @@ str
 CLTsessions(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
 {
        BAT *user = NULL, *login = NULL, *stimeout = NULL, *qtimeout = NULL, 
*last= NULL, *active= NULL;
-       int *userId = getArgReference_int(stk,pci,0);
-       int *loginId = getArgReference_int(stk,pci,1);
-       int *stimeoutId = getArgReference_int(stk,pci,2);
-       int *lastId = getArgReference_int(stk,pci,3);
-       int *qtimeoutId = getArgReference_int(stk,pci,4);
-       int *activeId = getArgReference_int(stk,pci,5);
+       bat *userId = getArgReference_bat(stk,pci,0);
+       bat *loginId = getArgReference_bat(stk,pci,1);
+       bat *stimeoutId = getArgReference_bat(stk,pci,2);
+       bat *lastId = getArgReference_bat(stk,pci,3);
+       bat *qtimeoutId = getArgReference_bat(stk,pci,4);
+       bat *activeId = getArgReference_bat(stk,pci,5);
     Client c;
        char usrname[256]= {"monetdb"};
        timestamp ts, ret;
diff --git a/monetdb5/modules/mal/querylog.c b/monetdb5/modules/mal/querylog.c
--- a/monetdb5/modules/mal/querylog.c
+++ b/monetdb5/modules/mal/querylog.c
@@ -36,6 +36,7 @@
 
 #include "monetdb_config.h"
 #include "querylog.h"
+#include "mtime.h"
 
 /* (c) M.L. Kersten
  * The query logger facility is hardwired to avoid interference 
@@ -188,15 +189,15 @@ static void
 {
        QLOG_cat_id = QLOGcreate("cat","id",TYPE_oid);
        QLOG_cat_user = QLOGcreate("cat","user",TYPE_str);
-       QLOG_cat_defined = QLOGcreate("cat","defined",TYPE_lng);
+       QLOG_cat_defined = QLOGcreate("cat","defined",TYPE_timestamp);
        QLOG_cat_query = QLOGcreate("cat","query",TYPE_str);
        QLOG_cat_pipe = QLOGcreate("cat","pipe",TYPE_str);
        QLOG_cat_mal = QLOGcreate("cat","mal",TYPE_int);
        QLOG_cat_optimize = QLOGcreate("cat","optimize",TYPE_lng);
        
        QLOG_calls_id = QLOGcreate("calls","id",TYPE_oid);
-       QLOG_calls_start = QLOGcreate("calls","start",TYPE_lng);
-       QLOG_calls_stop = QLOGcreate("calls","stop",TYPE_lng);
+       QLOG_calls_start = QLOGcreate("calls","start",TYPE_timestamp);
+       QLOG_calls_stop = QLOGcreate("calls","stop",TYPE_timestamp);
        QLOG_calls_arguments = QLOGcreate("calls","arguments",TYPE_str);
        QLOG_calls_tuples = QLOGcreate("calls","tuples",TYPE_wrd);
        QLOG_calls_exec = QLOGcreate("calls","exec",TYPE_lng);
@@ -298,7 +299,7 @@ QLOGdefine(Client cntxt, MalBlkPtr mb, M
        str *q = getArgReference_str(stk,pci,1);
        str *pipe = getArgReference_str(stk,pci,2);
        str  *usr = getArgReference_str(stk,pci,3);
-       lng *tick = getArgReference_lng(stk,pci,4);
+       timestamp *tick = getArgReference_TYPE(stk,pci,4,timestamp);
        oid o;
 
        (void) cntxt;
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to