Fix data type conversion in user-defined functions

Author: ShapovalovKL

src/api.coffee

@@ -459,7 +459,7 @@ class Database
                 value_ptr = getValue(argv+(4*i), 'i32')
                 value_type = sqlite3_value_type(value_ptr)
                 data_func = switch
-                    when value_type == 1 then sqlite3_value_int
+                    when value_type == 1 then sqlite3_value_double
                     when value_type == 2 then sqlite3_value_double
                     when value_type == 3 then sqlite3_value_text
                     when value_type == 4 then (ptr) ->
@@ -474,15 +474,26 @@ class Database
                 args.push arg
 
             # Invoke the user defined function with arguments from SQLite
-            result = func.apply(null, args)
-
-            # Return the result of the user defined function to SQLite
-            if not result
-                sqlite3_result_null cx
-            else
-                switch typeof(result)
-                    when 'number' then sqlite3_result_double(cx, result)
-                    when 'string' then sqlite3_result_text(cx, result, -1, -1)
+            try
+              result = func.apply(null, args)
+            catch error
+              sqlite3_result_error(cx,error,-1)
+              return
+
+            # Return the result of the user defined function to SQLite            
+            switch typeof(result)
+                when 'boolean' then sqlite3_result_int(cx,if result then 1 else 0)
+                when 'number' then sqlite3_result_double(cx, result)
+                when 'string' then sqlite3_result_text(cx, result, -1, -1)
+                when 'object'
+                  if result is null then sqlite3_result_null cx
+                  else if result.length?
+                    blobptr = allocate result, 'i8', ALLOC_NORMAL
+                    sqlite3_result_blob(cx, blobptr,result.length, -1)
+                    _free blobptr
+                  else sqlite3_result_error(cx,"Wrong API use : tried to return a value of an unknown type (#{result}).",-1)
+                else sqlite3_result_null cx
+            return
         if(name of @functions)
           removeFunction(@functions[name])
           delete @functions[name]

src/exported_functions.json

@@ -34,5 +34,9 @@
 "_sqlite3_result_double",
 "_sqlite3_result_null",
 "_sqlite3_result_text",
+"_sqlite3_result_blob",
+"_sqlite3_result_int",
+"_sqlite3_result_int64",
+"_sqlite3_result_error",
 "_RegisterExtensionFunctions"
 ]

src/exports.coffee

@@ -53,6 +53,10 @@ sqlite3_value_double = Module['cwrap'] 'sqlite3_value_double', 'number', ['numbe
 sqlite3_result_double = Module['cwrap'] 'sqlite3_result_double', '', ['number', 'number']
 sqlite3_result_null = Module['cwrap'] 'sqlite3_result_null', '', ['number']
 sqlite3_result_text = Module['cwrap'] 'sqlite3_result_text', '', ['number', 'string', 'number', 'number']
+sqlite3_result_blob = Module['cwrap'] 'sqlite3_result_blob', '', ['number', 'number', 'number', 'number']
+sqlite3_result_int = Module['cwrap'] 'sqlite3_result_int', '', ['number','number']
+sqlite3_result_int64 = Module['cwrap'] 'sqlite3_result_int64', '', ['number', 'number']
+sqlite3_result_error = Module['cwrap'] 'sqlite3_result_error', '', ['number', 'string', 'number']
 RegisterExtensionFunctions = Module['cwrap'] 'RegisterExtensionFunctions', 'number', ['number']
 
 # Export the API

test/test_functions.js

@@ -50,6 +50,87 @@ exports.test = function(SQL, assert){
   db.create_function("addOne", function (x) { return x + 1;} );
   result = db.exec("SELECT addOne(1);");
   assert.equal(result[0]["values"][0][0], 2, "Accepts anonymous functions");
+ 
+  // Test api support of different sqlite types and special values
+  db.create_function("identityFunction", function (x) { return x;} );
+  var verbose=false;
+  function canHandle(testData)
+  {
+    let result={};
+    let ok=true;
+    let sql_value=("sql_value" in testData)?testData.sql_value:(""+testData.value);
+    function simpleEqual(a, b) {return a===b;}
+    let value_equal=("equal" in testData)?testData.equal:simpleEqual;
+    db.create_function("CheckTestValue", function (x) {return value_equal(testData.value,x)?12345:5678;});
+    db.create_function("GetTestValue", function () {return testData.value; });  
+    // Check sqlite to js value conversion
+    result = db.exec("SELECT CheckTestValue("+sql_value+")==12345"); 
+    if(result[0]["values"][0][0]!=1)
+    {
+      if(verbose)
+        assert.ok(false, "Can accept "+testData.info);
+      ok=false;
+    }
+    // Check js to sqlite value conversion
+    result = db.exec("SELECT GetTestValue()");
+    if(!value_equal(result[0]["values"][0][0],testData.value))
+    {
+      if(verbose)
+        assert.ok(false, "Can return "+testData.info);
+      ok=false;
+    } 
+    // Check sqlite to sqlite value conversion (identityFunction(x)==x)
+    if(sql_value!=="null")
+    {
+      result = db.exec("SELECT identityFunction("+sql_value+")="+sql_value); 
+    }else
+    {
+      result = db.exec("SELECT identityFunction("+sql_value+") is null"); 
+    }
+    if(result[0]["values"][0][0]!=1)
+    {
+      if(verbose)
+        assert.ok(false, "Can pass "+testData.info);
+      ok=false;
+    } 
+    return ok;
+  }
+  
+  function numberEqual(a, b) {
+      return (+a)===(+b);
+  }
+  
+  function blobEqual(a, b) {
+      if(((typeof a)!="object")||(!a)||((typeof b)!="object")||(!b)) return false;
+      if (a.byteLength !== b.byteLength) return false;
+      return a.every((val, i) => val === b[i]);
+  }
+  
+  [
+    {info:"null",value:null}, // sqlite special value null
+    {info:"false",value:false,sql_value:"0",equal:numberEqual}, // sqlite special value (==false)
+    {info:"true", value:true,sql_value:"1",equal:numberEqual}, // sqlite special value (==true)
+    {info:"integer 0",value:0}, // sqlite special value (==false)
+    {info:"integer 1",value:1}, // sqlite special value (==true)
+    {info:"integer -1",value:-1},
+    {info:"long integer 5e+9",value:5000000000}, // int64
+    {info:"long integer -5e+9",value:-5000000000}, // negative int64
+    {info:"double",value:0.5},
+    {info:"string",value:"Test",sql_value:"'Test'"},
+    {info:"empty string",value:"",sql_value:"''"},
+    {info:"unicode string",value:"\uC7B8",sql_value:"CAST(x'EC9EB8' AS TEXT)"}, // unicode-hex: C7B8 utf8-hex: EC9EB8
+    {info:"blob",value:new Uint8Array([0xC7,0xB8]),sql_value:"x'C7B8'",equal:blobEqual},
+    {info:"empty blob",value:new Uint8Array([]),sql_value:"x''",equal:blobEqual}
+  ].forEach(function(testData)
+  {
+    assert.ok(canHandle(testData),"Can handle "+testData.info);
+  });
+   
+  db.create_function("throwFunction", function () { throw "internal exception"; return 5;} );    
+  assert.throws(function(){db.exec("SELECT throwFunction()");},/internal exception/, "Can handle internal exceptions");
+  
+  db.create_function("customeObjectFunction", function () { return {test:123};} );    
+  assert.throws(function(){db.exec("SELECT customeObjectFunction()");},/Wrong API use/, "Reports wrong API use");
 
   db.close();
 };