MonetDB: pythonudf - Revert some code accidently checked in.

[Mark Raasveldt]

Changeset: f687a7a4c6fb for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=f687a7a4c6fb
Modified Files:
        sql/backends/monet5/UDF/80_udf.sql
        sql/backends/monet5/UDF/udf.c
        sql/backends/monet5/UDF/udf.h
        sql/backends/monet5/UDF/udf.mal
Branch: pythonudf
Log Message:

Revert some code accidently checked in.


diffs (165 lines):

diff --git a/sql/backends/monet5/UDF/80_udf.sql 
b/sql/backends/monet5/UDF/80_udf.sql
--- a/sql/backends/monet5/UDF/80_udf.sql
+++ b/sql/backends/monet5/UDF/80_udf.sql
@@ -8,8 +8,8 @@
 
 
 -- Reverse a string
-create function reverse(src integer)
-returns double external name udf.reverse;
+create function reverse(src string)
+returns string external name udf.reverse;
 
 
 -- fuse two (1-byte) tinyint values into one (2-byte) smallint value
diff --git a/sql/backends/monet5/UDF/udf.c b/sql/backends/monet5/UDF/udf.c
--- a/sql/backends/monet5/UDF/udf.c
+++ b/sql/backends/monet5/UDF/udf.c
@@ -15,16 +15,46 @@
 /* actual implementation */
 /* all non-exported functions must be declared static */
 static char *
-UDFreverse_(dbl *ret, const int src)
+UDFreverse_(char **ret, const char *src)
 {
-       *ret = sqrt(src);
+       size_t len = 0;
+       char *dst = NULL;
+
+       /* assert calling sanity */
+       assert(ret != NULL);
+
+       /* handle NULL pointer and NULL value */
+       if (src == NULL || strcmp(src, str_nil) == 0) {
+               *ret = GDKstrdup(str_nil);
+               if (*ret == NULL)
+                       throw(MAL, "udf.reverse",
+                             "failed to create copy of str_nil");
+
+               return MAL_SUCCEED;
+       }
+
+       /* allocate result string */
+       len = strlen(src);
+       *ret = dst = GDKmalloc(len + 1);
+       if (dst == NULL)
+               throw(MAL, "udf.reverse",
+                     "failed to allocate string of length " SZFMT, len + 1);
+
+       /* copy characters from src to dst in reverse order */
+       dst[len] = 0;
+       while (len > 0)
+               *dst++ = src[--len];
+
        return MAL_SUCCEED;
 }
 
 /* MAL wrapper */
 char *
-UDFreverse(dbl *ret, const int *arg)
+UDFreverse(char **ret, const char **arg)
 {
+       /* assert calling sanity */
+       assert(ret != NULL && arg != NULL);
+
        return UDFreverse_ ( ret, *arg );
 }
 
@@ -39,7 +69,9 @@ UDFreverse(dbl *ret, const int *arg)
 static char *
 UDFBATreverse_(BAT **ret, BAT *src)
 {
+       BATiter li;
        BAT *bn = NULL;
+       BUN p = 0, q = 0;
 
        /* assert calling sanity */
        assert(ret != NULL);
@@ -49,28 +81,44 @@ UDFBATreverse_(BAT **ret, BAT *src)
                throw(MAL, "batudf.reverse", RUNTIME_OBJECT_MISSING);
 
        /* check tail type */
-       if (src->ttype != TYPE_int) {
+       if (src->ttype != TYPE_str) {
                throw(MAL, "batudf.reverse",
-                     "tail-type of input BAT must be TYPE_int");
+                     "tail-type of input BAT must be TYPE_str");
        }
 
        /* allocate void-headed result BAT */
-       bn = BATnew(TYPE_void, TYPE_dbl, BATcount(src), TRANSIENT);
+       bn = BATnew(TYPE_void, TYPE_str, BATcount(src), TRANSIENT);
        if (bn == NULL) {
                throw(MAL, "batudf.reverse", MAL_MALLOC_FAIL);
        }
        BATseqbase(bn, src->hseqbase);
 
-       {
-               size_t i;
-               int *ptr = (int*) src->T->heap.base;
-               dbl *res = (dbl*) bn->T->heap.base;
+       /* create BAT iterator */
+       li = bat_iterator(src);
 
-               for(i = 0; i < BATcount(src); i++) {
-                       res[i] = sqrt(ptr[i]);
+       /* the core of the algorithm, expensive due to malloc/frees */
+       BATloop(src, p, q) {
+               char *tr = NULL, *err = NULL;
+
+               const char *t = (const char *) BUNtail(li, p);
+
+               /* revert tail value */
+               err = UDFreverse_(&tr, t);
+               if (err != MAL_SUCCEED) {
+                       /* error -> bail out */
+                       BBPunfix(bn->batCacheid);
+                       return err;
                }
+
+               /* assert logical sanity */
+               assert(tr != NULL);
+
+               /* append reversed tail in result BAT */
+               BUNappend(bn, tr, FALSE);
+
+               /* free memory allocated in UDFreverse_() */
+               GDKfree(tr);
        }
-       BATsetcount(bn, BATcount(src));
 
        *ret = bn;
 
diff --git a/sql/backends/monet5/UDF/udf.h b/sql/backends/monet5/UDF/udf.h
--- a/sql/backends/monet5/UDF/udf.h
+++ b/sql/backends/monet5/UDF/udf.h
@@ -29,7 +29,7 @@
 
 /* export MAL wrapper functions */
 
-udf_export char * UDFreverse(dbl *ret, const int *arg);
+udf_export char * UDFreverse(char **ret, const char **arg);
 udf_export char * UDFBATreverse(bat *ret, const bat *arg);
 
 /* using C macro for convenient type-expansion */
diff --git a/sql/backends/monet5/UDF/udf.mal b/sql/backends/monet5/UDF/udf.mal
--- a/sql/backends/monet5/UDF/udf.mal
+++ b/sql/backends/monet5/UDF/udf.mal
@@ -7,7 +7,7 @@
 # scalar MAL signatures
 module udf;
 
-command reverse(ra1:int):dbl
+command reverse(ra1:str):str
 address UDFreverse
 comment "Reverse a string";
 
@@ -15,7 +15,7 @@ comment "Reverse a string";
 # BAT MAL signatures
 module batudf;
 
-command reverse(b:bat[:int]):bat[:dbl]
+command reverse(b:bat[:str]):bat[:str]
 address UDFBATreverse
 comment "Reverse a BAT of strings";
 
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list