Changeset: f47272b81e66 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=f47272b81e66
Modified Files:
        clients/Tests/MAL-signatures_all.stable.out
        clients/Tests/MAL-signatures_fits_geom.stable.out
        clients/Tests/MAL-signatures_geom.stable.out
        clients/Tests/MAL-signatures_none.stable.out
        clients/Tests/exports.stable.out
        monetdb5/modules/kernel/mmath.c
        monetdb5/modules/kernel/mmath.h
        monetdb5/modules/kernel/mmath.mal
        monetdb5/modules/mal/manifold.c
        monetdb5/tests/gdkTests/Tests/void.mal
        sql/backends/monet5/UDF/Tests/udf-fuse.stable.out
        sql/backends/monet5/UDF/Tests/udf-reverse.stable.out
        sql/jdbc/tests/Tests/Test_Dobjects_bam.stable.out
        sql/test/BugTracker-2014/Tests/nil_2dec_lng.Bug-3592.stable.out
Branch: default
Log Message:

Merge with Oct2014 branch.


diffs (truncated from 443 to 300 lines):

diff --git a/clients/Tests/MAL-signatures_all.stable.out 
b/clients/Tests/MAL-signatures_all.stable.out
--- a/clients/Tests/MAL-signatures_all.stable.out
+++ b/clients/Tests/MAL-signatures_all.stable.out
@@ -40184,7 +40184,7 @@ comment The pow(x,y) function  returns t
 command mmath.pow(x:flt,y:flt):flt 
 address MATHbinary_POWflt;
 command mmath.rand{unsafe}(v:int):int 
-address MATHrandintseed;
+address MATHrandintarg;
 comment return a random number
 
 command mmath.rand{unsafe}():int 
diff --git a/clients/Tests/MAL-signatures_fits_geom.stable.out 
b/clients/Tests/MAL-signatures_fits_geom.stable.out
--- a/clients/Tests/MAL-signatures_fits_geom.stable.out
+++ b/clients/Tests/MAL-signatures_fits_geom.stable.out
@@ -40101,7 +40101,7 @@ comment The pow(x,y) function  returns t
 command mmath.pow(x:flt,y:flt):flt 
 address MATHbinary_POWflt;
 command mmath.rand{unsafe}(v:int):int 
-address MATHrandintseed;
+address MATHrandintarg;
 comment return a random number
 
 command mmath.rand{unsafe}():int 
diff --git a/clients/Tests/MAL-signatures_geom.stable.out 
b/clients/Tests/MAL-signatures_geom.stable.out
--- a/clients/Tests/MAL-signatures_geom.stable.out
+++ b/clients/Tests/MAL-signatures_geom.stable.out
@@ -40077,7 +40077,7 @@ comment The pow(x,y) function  returns t
 command mmath.pow(x:flt,y:flt):flt 
 address MATHbinary_POWflt;
 command mmath.rand{unsafe}(v:int):int 
-address MATHrandintseed;
+address MATHrandintarg;
 comment return a random number
 
 command mmath.rand{unsafe}():int 
diff --git a/clients/Tests/MAL-signatures_none.stable.out 
b/clients/Tests/MAL-signatures_none.stable.out
--- a/clients/Tests/MAL-signatures_none.stable.out
+++ b/clients/Tests/MAL-signatures_none.stable.out
@@ -39890,7 +39890,7 @@ comment The pow(x,y) function  returns t
 command mmath.pow(x:flt,y:flt):flt 
 address MATHbinary_POWflt;
 command mmath.rand{unsafe}(v:int):int 
-address MATHrandintseed;
+address MATHrandintarg;
 comment return a random number
 
 command mmath.rand{unsafe}():int 
diff --git a/clients/Tests/exports.stable.out b/clients/Tests/exports.stable.out
--- a/clients/Tests/exports.stable.out
+++ b/clients/Tests/exports.stable.out
@@ -1502,7 +1502,7 @@ str MATHbinary_ROUNDdbl(dbl *res, const 
 str MATHbinary_ROUNDflt(flt *res, const flt *a, const int *b);
 str MATHpi(dbl *pi);
 str MATHrandint(int *res);
-str MATHrandintseed(int *res, const int *seed);
+str MATHrandintarg(int *res, const int *dummy);
 str MATHsqlrandint(int *res, const int *seed);
 str MATHsrandint(void *ret, const int *seed);
 str MATHunary_ACOSdbl(dbl *res, const dbl *a);
diff --git a/monetdb5/modules/kernel/mmath.c b/monetdb5/modules/kernel/mmath.c
--- a/monetdb5/modules/kernel/mmath.c
+++ b/monetdb5/modules/kernel/mmath.c
@@ -291,10 +291,10 @@ MATHrandint(int *res)
 }
 
 str
-MATHrandintseed(int *res, const int *seed)
+MATHrandintarg(int *res, const int *dummy)
 {
+       (void) dummy;
        /* coverity[dont_call] */
-       srand(*seed);
        *res = rand();
        return MAL_SUCCEED;
 }
diff --git a/monetdb5/modules/kernel/mmath.h b/monetdb5/modules/kernel/mmath.h
--- a/monetdb5/modules/kernel/mmath.h
+++ b/monetdb5/modules/kernel/mmath.h
@@ -88,7 +88,7 @@ mmath_export str MATHunary_ISNAN(bit *re
 mmath_export str MATHunary_ISINF(int *res, const dbl *a);
 mmath_export str MATHunary_FINITE(bit *res, const dbl *a);
 mmath_export str MATHrandint(int *res);
-mmath_export str MATHrandintseed(int *res, const int *seed);
+mmath_export str MATHrandintarg(int *res, const int *dummy);
 mmath_export str MATHsrandint(void *ret, const int *seed);
 mmath_export str MATHsqlrandint(int *res, const int *seed);
 mmath_export str MATHpi(dbl *pi);
diff --git a/monetdb5/modules/kernel/mmath.mal 
b/monetdb5/modules/kernel/mmath.mal
--- a/monetdb5/modules/kernel/mmath.mal
+++ b/monetdb5/modules/kernel/mmath.mal
@@ -200,7 +200,7 @@ address MATHrandint
 comment "return a random number";
 
 command rand{unsafe} (v:int) :int 
-address MATHrandintseed
+address MATHrandintarg
 comment "return a random number";
 
 command srand(seed:int) :void 
diff --git a/monetdb5/modules/mal/manifold.c b/monetdb5/modules/mal/manifold.c
--- a/monetdb5/modules/mal/manifold.c
+++ b/monetdb5/modules/mal/manifold.c
@@ -66,75 +66,84 @@ typedef struct{
 
 // Loop through the first BAT
 // keep the last error message received
-#define ManifoldLoop(Type, ...) {                      \
-       Type *v = (Type*) mut->args[0].first;           \
-       oid oo, olimit = mut->args[mut->fvar].cnt; \
-       for( oo= 0; oo < olimit; oo++){\
-               msg = (*mut->pci->fcn)(v, __VA_ARGS__); \
-               if (msg) break;                         \
-               for( i = mut->fvar; i<= mut->lvar; i++) {       \
-                       if(ATOMstorage(mut->args[i].type == TYPE_void) ){       
\
-                               args[i] = (void*)  &mut->args[i].o;      \
-                               mut->args[i].o++;               \
-                       } else if(ATOMstorage(mut->args[i].type) < TYPE_str ) { 
\
-                               args[i] += mut->args[i].size;   \
-                       } else if (ATOMvarsized(mut->args[i].type)) { \
-                               mut->args[i].o++;               \
-                               mut->args[i].s = (str *) 
BUNtail(mut->args[i].bi, mut->args[i].o); \
-                               args[i] = (void*)  &mut->args[i].s;      \
-                       } else { \
-                               mut->args[i].o++;               \
-                               mut->args[i].s = (str *) Tloc(mut->args[i].b, 
mut->args[i].o); \
-                               args[i] = (void*)  &mut->args[i].s;      \
-                       }                               \
-               }                                       \
-               v++;                                    \
-       }                                               \
-}
+#define ManifoldLoop(Type, ...)                                                
                                        \
+       do {                                                                    
                                                        \
+               Type *v = (Type*) mut->args[0].first;                           
                        \
+               oid oo, olimit = mut->args[mut->fvar].cnt;                      
                        \
+               for( oo= 0; oo < olimit; oo++){                                 
                                \
+                       msg = (*mut->pci->fcn)(v, __VA_ARGS__);                 
                        \
+                       if (msg) break;                                         
                                                \
+                       for( i = mut->fvar; i<= mut->lvar; i++) {               
                        \
+                               if(ATOMstorage(mut->args[i].type == TYPE_void) 
){               \
+                                       args[i] = (void*)  &mut->args[i].o;     
                                \
+                                       mut->args[i].o++;                       
                                                \
+                               } else if(mut->args[i].size == 0) {             
                                \
+                                       ;                                       
                                                                \
+                               } else if(ATOMstorage(mut->args[i].type) < 
TYPE_str ) { \
+                                       args[i] += mut->args[i].size;           
                                \
+                               } else if (ATOMvarsized(mut->args[i].type)) {   
                \
+                                       mut->args[i].o++;                       
                                                \
+                                       mut->args[i].s = (str *) 
BUNtail(mut->args[i].bi, mut->args[i].o); \
+                                       args[i] = (void*)  &mut->args[i].s;     
                                \
+                               } else {                                        
                                                        \
+                                       mut->args[i].o++;                       
                                                \
+                                       mut->args[i].s = (str *) 
Tloc(mut->args[i].b, mut->args[i].o); \
+                                       args[i] = (void*)  &mut->args[i].s;     
                                \
+                               }                                               
                                                                \
+                       }                                                       
                                                                \
+                       v++;                                                    
                                                        \
+               }                                                               
                                                                \
+       } while (0)
 
 // The target BAT tail type determines the result variable
 #ifdef HAVE_HGE
-#define Manifoldbody_hge(...) \
+#define Manifoldbody_hge(...)                                  \
        case TYPE_hge: ManifoldLoop(hge,__VA_ARGS__); break
 #else
 #define Manifoldbody_hge(...)
 #endif
-#define Manifoldbody(...) \
-switch(ATOMstorage(mut->args[0].b->T->type)){\
-case TYPE_bte: ManifoldLoop(bte,__VA_ARGS__); break;\
-case TYPE_sht: ManifoldLoop(sht,__VA_ARGS__); break;\
-case TYPE_int: ManifoldLoop(int,__VA_ARGS__); break;\
-case TYPE_lng: ManifoldLoop(lng,__VA_ARGS__); break;\
-Manifoldbody_hge(__VA_ARGS__);                      \
-case TYPE_oid: ManifoldLoop(oid,__VA_ARGS__); break;\
-case TYPE_flt: ManifoldLoop(flt,__VA_ARGS__); break;\
-case TYPE_dbl: ManifoldLoop(dbl,__VA_ARGS__); break;\
-case TYPE_str: \
-default:\
-{   oid oo, olimit = mut->args[mut->fvar].cnt; \
-       for( oo= 0; oo < olimit; oo++){\
-               msg = (*mut->pci->fcn)(&y, __VA_ARGS__);        \
-               if (msg)                                        \
-                       break;                                  \
-               bunfastapp(mut->args[0].b, (void*) y);  \
-               for( i = mut->fvar; i<= mut->lvar; i++) {       \
-                       if(ATOMstorage(mut->args[i].type == TYPE_void) ){       
\
-                               args[i] = (void*)  &mut->args[i].o;      \
-                               mut->args[i].o++;               \
-                       } else if(ATOMstorage(mut->args[i].type) < TYPE_str){   
\
-                               args[i] += mut->args[i].size;   \
-                       } else if(ATOMvarsized(mut->args[i].type)){     \
-                               mut->args[i].o++;               \
-                               mut->args[i].s = (str*) 
BUNtail(mut->args[i].bi, mut->args[i].o);\
-                               args[i] =  (void*) & mut->args[i].s;    \
-                       } else {                                \
-                               mut->args[i].o++;               \
-                               mut->args[i].s = (str*) Tloc(mut->args[i].b, 
mut->args[i].o);\
-                               args[i] =  (void*) & mut->args[i].s;    \
-                       }                                       \
-               }                                               \
-       }                                                       \
-} }
+#define Manifoldbody(...)                                                      
                                        \
+       do {                                                                    
                                                        \
+               switch(ATOMstorage(mut->args[0].b->T->type)){                   
                \
+               case TYPE_bte: ManifoldLoop(bte,__VA_ARGS__); break;            
        \
+               case TYPE_sht: ManifoldLoop(sht,__VA_ARGS__); break;            
        \
+               case TYPE_int: ManifoldLoop(int,__VA_ARGS__); break;            
        \
+               case TYPE_lng: ManifoldLoop(lng,__VA_ARGS__); break;            
        \
+               Manifoldbody_hge(__VA_ARGS__);                                  
                                \
+               case TYPE_oid: ManifoldLoop(oid,__VA_ARGS__); break;            
        \
+               case TYPE_flt: ManifoldLoop(flt,__VA_ARGS__); break;            
        \
+               case TYPE_dbl: ManifoldLoop(dbl,__VA_ARGS__); break;            
        \
+               case TYPE_str:                                                  
                                                \
+               default: {                                                      
                                                        \
+                       oid oo, olimit = mut->args[mut->fvar].cnt;              
                        \
+                       for( oo= 0; oo < olimit; oo++){                         
                                \
+                               msg = (*mut->pci->fcn)(&y, __VA_ARGS__);        
                        \
+                               if (msg)                                        
                                                        \
+                                       break;                                  
                                                        \
+                               bunfastapp(mut->args[0].b, (void*) y);          
                        \
+                               for( i = mut->fvar; i<= mut->lvar; i++) {       
                        \
+                                       if(ATOMstorage(mut->args[i].type == 
TYPE_void) ){       \
+                                               args[i] = (void*)  
&mut->args[i].o;                             \
+                                               mut->args[i].o++;               
                                                \
+                                       } else if(mut->args[i].size == 0) {     
                                \
+                                               ;                               
                                                                \
+                                       } else if 
(ATOMstorage(mut->args[i].type) < TYPE_str){ \
+                                               args[i] += mut->args[i].size;   
                                \
+                                       } else 
if(ATOMvarsized(mut->args[i].type)){                     \
+                                               mut->args[i].o++;               
                                                \
+                                               mut->args[i].s = (str*) 
BUNtail(mut->args[i].bi, mut->args[i].o); \
+                                               args[i] =  (void*) & 
mut->args[i].s;                    \
+                                       } else {                                
                                                        \
+                                               mut->args[i].o++;               
                                                \
+                                               mut->args[i].s = (str*) 
Tloc(mut->args[i].b, mut->args[i].o); \
+                                               args[i] =  (void*) & 
mut->args[i].s;                    \
+                                       }                                       
                                                                \
+                               }                                               
                                                                \
+                       }                                                       
                                                                \
+                       break;                                                  
                                                        \
+               }                                                               
                                                                \
+               }                                                               
                                                                \
+       } while (0)
 
 // single argument is preparatory step for GDK_mapreduce
 // Only the last error message is returned, the value of
@@ -208,17 +217,7 @@ MANIFOLDtypecheck(Client cntxt, MalBlkPt
                getVarConstant(mb,getArg(pci,pci->retc+1)).val.sval);
 
        // Prepare the single result variable
-       tpe = TYPE_any;
-       for( i = pci->retc+2; i < pci->argc; i++)
-               if ( isaBatType(getArgType(mb,pci,i)) ){
-                       tpe =getColumnType(getArgType(mb,pci,i));
-                       break;
-               }
-       if( tpe == TYPE_any ){
-               freeMalBlk(nmb);
-               return NULL;
-       }
-       
+       tpe =getColumnType(getArgType(mb,pci,0));
        k= getArg(q,0);
        setVarType(nmb,k,tpe);
        setVarFixed(nmb,k);
@@ -315,6 +314,7 @@ MANIFOLDevaluate(Client cntxt, MalBlkPtr
                        mat[i].q = BUNlast(mat[i].b);
                } else {
                        mat[i].last = mat[i].first = (void *) 
getArgReference(stk,pci,i);
+                       mat[i].type = getArgType(mb, pci, i);
                }
        }
 
diff --git a/monetdb5/tests/gdkTests/Tests/void.mal 
b/monetdb5/tests/gdkTests/Tests/void.mal
--- a/monetdb5/tests/gdkTests/Tests/void.mal
+++ b/monetdb5/tests/gdkTests/Tests/void.mal
@@ -114,12 +114,14 @@ vj:= algebra.join(vr,t1);
 io.print(vj);
 
 v3 := algebra.select(t1,2, nil:int);
-(i,j):= bat.info(v3); ir:= bat.reverse(i); z2:= algebra.find(ir,"hseqbase"); 
z22:= algebra.fetch(j,z2); io.print(z22);
+(i,j):= bat.info(v3); ir:= bat.reverse(i); z2:= algebra.find(ir,"hseqbase");
+z22:= algebra.fetch(j,z2); io.print(z22);
 z2:= algebra.find(ir,"hdense"); z22:= algebra.fetch(j,z2); io.print(z22);
 bat.setWriteMode(v3);
 v3r:= bat.reverse(v3);
 z4:= bat.delete(v3r,2);
-(i,j):= bat.info(z4); ir:= bat.reverse(i); z2:= algebra.find(ir,"hseqbase"); 
z22:= algebra.fetch(j,z2); io.print(z22);
+(i,j):= bat.info(v3); ir:= bat.reverse(i); z2:= algebra.find(ir,"hseqbase");
+z22:= algebra.fetch(j,z2); io.print(z22);
 z2:= algebra.find(ir,"hdense"); z22:= algebra.fetch(j,z2); io.print(z22);
 
 x := bat.new(:oid,:oid);
diff --git a/sql/backends/monet5/UDF/Tests/udf-fuse.stable.out 
b/sql/backends/monet5/UDF/Tests/udf-fuse.stable.out
--- a/sql/backends/monet5/UDF/Tests/udf-fuse.stable.out
+++ b/sql/backends/monet5/UDF/Tests/udf-fuse.stable.out
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to