Merge branch 'quinnj-jq/scalarfuncs'

Author: Sean1708

src/SQLite.jl

@@ -31,7 +31,7 @@ end
 SQLiteDB(file,handle) = SQLiteDB(file,handle,0)
 
 include("UDF.jl")
-export registerfunc, sqlreturn, @scalarfunc, @sr_str
+export @sr_str, @register, register
 
 
 function changes(db::SQLiteDB)
@@ -54,7 +54,7 @@ function SQLiteDB(file::AbstractString="";UTF16::Bool=false)
     file = isempty(file) ? file : expanduser(file)
     if @OK sqliteopen(utf(file),handle)
         db = SQLiteDB(utf(file),handle[1])
-        registerfunc(db, 2, regexp)
+        register(db, regexp, 2)
         finalizer(db,close)
         return db
     else # error

src/UDF.jl

@@ -1,42 +1,3 @@
-# scalar functions
-function registerfunc(db::SQLiteDB, nargs::Integer, func::Function, isdeterm::Bool=true; name="")
-    @assert nargs <= 127 "only varargs functions can have more than 127 arguments"
-    # assume any negative number means a varargs function
-    nargs < -1 && (nargs = -1)
-
-    name = isempty(name) ? string(func) : name::AbstractString
-    @assert sizeof(name) <= 255 "size of function name must be <= 255"
-
-    cfunc = cfunction(func, Nothing, (Ptr{Void}, Cint, Ptr{Ptr{Void}}))
-
-    # TODO: allow the other encodings
-    enc = SQLITE_UTF8
-    enc = isdeterm ? enc | SQLITE_DETERMINISTIC : enc
-
-    @CHECK db sqlite3_create_function_v2(
-        db.handle, name, nargs, enc, C_NULL, cfunc, C_NULL, C_NULL, C_NULL
-    )
-end
-
-# aggregate functions
-function registerfunc(db::SQLiteDB, nargs::Integer, step::Function, final::Function, isdeterm::Bool=true; name="")
-    @assert nargs <= 127 "only varargs functions can have more than 127 arguments"
-    # assume any negative number means a varargs function
-    nargs < -1 && (nargs = -1)
-
-    name = isempty(name) ? string(step) : name::AbstractString
-    cstep = cfunction(step, Nothing, (Ptr{Void}, Cint, Ptr{Ptr{Void}}))
-    cfinal = cfunction(final, Nothing, (Ptr{Void}, Cint, Ptr{Ptr{Void}}))
-
-    # TODO: allow the other encodings
-    enc = SQLITE_UTF8
-    enc = isdeterm ? enc | SQLITE_DETERMINISTIC : enc
-
-    @CHECK db sqlite3_create_function_v2(
-        db.handle, name, nargs, enc, C_NULL, C_NULL, cstep, cfinal, C_NULL
-    )
-end
-
 function sqlvalue(values, i)
     temp_val_ptr = unsafe_load(values, i)
     valuetype = sqlite3_value_type(temp_val_ptr)
@@ -76,30 +37,55 @@ sqlreturn(context, val::Bool) = sqlreturn(context, int(val))
 sqludferror(context, msg::AbstractString)      = sqlite3_result_error(context, msg)
 sqludferror(context, msg::UTF16String) = sqlite3_result_error16(context, msg)
 
-function funcname(expr)
-    if length(expr) == 2
-        func = expr[2]
-        name = expr[1]
-    else
-        func = expr[1]
-        name = func.args[1].args[1]
-    end
-    name, func
-end
-
-macro scalarfunc(args...)
-    name, func = funcname(args)
+# Internal method for generating an SQLite scalar function from
+# a Julia function name
+function scalarfunc(func,fsym=symbol(string(func)))
+    # check if name defined in Base so we don't clobber Base methods
+    nm = isdefined(Base,fsym) ? :(Base.$fsym) : fsym
     return quote
-        function $(esc(name))(context::Ptr{Void}, nargs::Cint, values::Ptr{Ptr{Void}})
-            args = [sqlvalue(values, i) for i in 1:nargs]
+        #nm needs to be a symbol or expr, i.e. :sin or :(Base.sin)
+        function $(nm)(context::Ptr{Void}, nargs::Cint, values::Ptr{Ptr{Void}})
+            args = [SQLite.sqlvalue(values, i) for i in 1:nargs]
             ret = $(func)(args...)
-            sqlreturn(context, ret)
+            SQLite.sqlreturn(context, ret)
             nothing
         end
     end
 end
+function scalarfunc(expr::Expr)
+    f = eval(expr)
+    return scalarfunc(f)
+end
+# User-facing macro for convenience in registering a simple function
+# with no configurations needed
+macro register(db, func)
+    :(register($(esc(db)), $(esc(func))))
+end
+# User-facing method with keyword arguments for registering a function
+# to be used within SQLite
+function register(db::SQLiteDB, func::Function; nargs::Int=-1, isdeterm::Bool=true, name::String=string(func))
+    register(db, func, nargs, isdeterm, name)
+end
+# User-facing method for registering a Julia function to be used within SQLite
+function register(db::SQLiteDB, func::Function, nargs::Int=-1, isdeterm::Bool=true, name::String=string(func))
+    @assert nargs <= 127 "use -1 if > 127 arguments are needed"
+    # assume any negative number means a varargs function
+    nargs < -1 && (nargs = -1)
+    @assert sizeof(name) <= 255 "size of function name must be <= 255"
+
+    f = eval(scalarfunc(func,symbol(name)))
+
+    cfunc = cfunction(f, Nothing, (Ptr{Void}, Cint, Ptr{Ptr{Void}}))
+    # TODO: allow the other encodings
+    enc = SQLITE_UTF8
+    enc = isdeterm ? enc | SQLITE_DETERMINISTIC : enc
+
+    @CHECK db sqlite3_create_function_v2(
+        db.handle, name, nargs, enc, C_NULL, cfunc, C_NULL, C_NULL, C_NULL
+    )    
+end
 
 # annotate types because the MethodError makes more sense that way
-@scalarfunc regexp(r::AbstractString, s::AbstractString) = ismatch(Regex(r), s)
+regexp(r::String, s::String) = ismatch(Regex(r), s)
 # macro for preserving the special characters in a string
 macro sr_str(s) s end

test/runtests.jl

@@ -130,25 +130,37 @@ end
 r = query(db, sr"SELECT LastName FROM Employee WHERE BirthDate REGEXP '^\d{4}-08'")
 @test r.values[1][1] == "Peacock"
 
-@scalarfunc function triple(x)
-    x * 3
-end
-@test_throws ErrorException registerfunc(db, 186, triple)
-registerfunc(db, 1, triple)
+triple(x) = x * 3
+@test_throws ErrorException SQLite.register(db, triple, 186)
+SQLite.register(db, triple, 1)
 r = query(db, "SELECT triple(Total) FROM Invoice ORDER BY InvoiceId LIMIT 5")
 s = query(db, "SELECT Total FROM Invoice ORDER BY InvoiceId LIMIT 5")
 for (i, j) in zip(r.values[1], s.values[1])
     @test_approx_eq i j*3
 end
 
-@scalarfunc mult (*)
-registerfunc(db, -1, mult)
+SQLite.@register db function add4(q)
+    q+4
+end
+r = query(db, "SELECT add4(AlbumId) FROM Album")
+s = query(db, "SELECT AlbumId FROM Album")
+@test r[1] == s[1]+4
+
+SQLite.@register db mult(args...) = *(args...)
 r = query(db, "SELECT Milliseconds, Bytes FROM Track")
 s = query(db, "SELECT mult(Milliseconds, Bytes) FROM Track")
 @test r[1].*r[2] == s[1]
 t = query(db, "SELECT mult(Milliseconds, Bytes, 3, 4) FROM Track")
 @test r[1].*r[2]*3*4 == t[1]
 
+SQLite.@register db sin
+u = query(db, "select sin(milliseconds) from track limit 5")
+@test all(-1 .< u[1] .< 1)
+
+SQLite.register(db, hypot; nargs=2, name="hypotenuse")
+v = query(db, "select hypotenuse(Milliseconds,bytes) from track limit 5")
+@test [int(i) for i in v[1]] == [11175621,5521062,3997652,4339106,6301714]
+
 @test size(tables(db)) == (11,1)
 
 close(db)