Merge branch 'master' of git://github.com/quinnj/SQLite.jl

Author: quinnj

README.md

@@ -59,7 +59,7 @@ A Julia interface to the SQLite library and support for operations on DataFrames
 
   An SQL statement `sql` is prepared, executed in the context of `db`, and results, if any, are returned. The return values are a `(String[],Any[])` tuple representing `(column names, result values)`.
 
-  The values in `values` are used in parameter binding (see `bind` above). If your statement uses nameless parameters `values` must be a Vector of the values you wish to bind to your statment. If your statement uses named parameters `values` must be a Dict where the keys are of type String or Symbol. The key must match an identifier name in the statement (the name **does not** include the ':', '@' or '$' prefix). You can not use a dictionary which has Strings *and* Symbols for it's keys.
+  The values in `values` are used in parameter binding (see `bind` above). If your statement uses nameless parameters `values` must be a `Vector` of the values you wish to bind to your statment. If your statement uses named parameters `values` must be a Dict where the keys are of type `Symbol`. The key must match an identifier name in the statement (the name **does not** include the ':', '@' or '$' prefix).
 
 * `create(db::SQLiteDB,name::String,table::AbstractMatrix,
             colnames=String[],coltypes=DataType[];temp::Bool=false)`

src/SQLite.jl

@@ -4,7 +4,7 @@ export NULL, SQLiteDB, SQLiteStmt, ResultSet,
        execute, query, tables, drop, create, append
 
 type SQLiteException <: Exception
-    msg::String
+    msg::AbstractString
 end
 
 include("consts.jl")
@@ -23,15 +23,15 @@ end
 ==(a::ResultSet,b::ResultSet) = a.colnames == b.colnames && a.values == b.values
 include("show.jl")
 
-type SQLiteDB{T<:String}
+type SQLiteDB{T<:AbstractString}
     file::T
     handle::Ptr{Void}
     changes::Int
 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)
@@ -48,13 +48,13 @@ sqliteopen(file::UTF16String,handle) = sqlite3_open16(file,handle)
 sqliteerror() = throw(SQLiteException(bytestring(sqlite3_errmsg())))
 sqliteerror(db) = throw(SQLiteException(bytestring(sqlite3_errmsg(db.handle))))
 
-function SQLiteDB(file::String="";UTF16::Bool=false)
+function SQLiteDB(file::AbstractString="";UTF16::Bool=false)
     handle = [C_NULL]
     utf = UTF16 ? utf16 : utf8
     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, nargs=2)
         finalizer(db,close)
         return db
     else # error
@@ -83,7 +83,7 @@ sqliteprepare(db,sql,stmt,null) =
 sqliteprepare(db::SQLiteDB{UTF16String},sql,stmt,null) = 
     @CHECK db sqlite3_prepare16_v2(db.handle,utf16(sql),stmt,null)
 
-function SQLiteStmt{T}(db::SQLiteDB{T},sql::String)
+function SQLiteStmt{T}(db::SQLiteDB{T},sql::AbstractString)
     handle = [C_NULL]
     sqliteprepare(db,sql,handle,[C_NULL])
     stmt = SQLiteStmt(db,handle[1],convert(T,sql))
@@ -112,26 +112,26 @@ function Base.bind{V}(stmt::SQLiteStmt, values::Dict{Symbol, V})
     @assert nparams == length(values) "you must provide values for all placeholders"
     for i in 1:nparams
         name = bytestring(sqlite3_bind_parameter_name(stmt.handle, i))
-        @assert !isempty(name) "nameless parameters should be passed as a tuple"
+        @assert !isempty(name) "nameless parameters should be passed as a Vector"
         # name is returned with the ':', '@' or '$' at the start
         name = name[2:end]
         bind(stmt, i, values[symbol(name)])
     end
 end
 # Binding parameters to SQL statements
-function Base.bind(stmt::SQLiteStmt,name::String,val)
+function Base.bind(stmt::SQLiteStmt,name::AbstractString,val)
     i = sqlite3_bind_parameter_index(stmt.handle,name)
     if i == 0
         throw(SQLiteException("SQL parameter $name not found in $stmt"))
     end
     return bind(stmt,i,val)
 end
-Base.bind(stmt::SQLiteStmt,i::Int,val::FloatingPoint) = @CHECK stmt.db sqlite3_bind_double(stmt.handle,i,float64(val))
-Base.bind(stmt::SQLiteStmt,i::Int,val::Int32)         = @CHECK stmt.db sqlite3_bind_int(stmt.handle,i,val)
-Base.bind(stmt::SQLiteStmt,i::Int,val::Int64)         = @CHECK stmt.db sqlite3_bind_int64(stmt.handle,i,val)
-Base.bind(stmt::SQLiteStmt,i::Int,val::NullType)      = @CHECK stmt.db sqlite3_bind_null(stmt.handle,i)
-Base.bind(stmt::SQLiteStmt,i::Int,val::String)        = @CHECK stmt.db sqlite3_bind_text(stmt.handle,i,val)
-Base.bind(stmt::SQLiteStmt,i::Int,val::UTF16String)   = @CHECK stmt.db sqlite3_bind_text16(stmt.handle,i,val)
+Base.bind(stmt::SQLiteStmt,i::Int,val::FloatingPoint)  = @CHECK stmt.db sqlite3_bind_double(stmt.handle,i,float64(val))
+Base.bind(stmt::SQLiteStmt,i::Int,val::Int32)          = @CHECK stmt.db sqlite3_bind_int(stmt.handle,i,val)
+Base.bind(stmt::SQLiteStmt,i::Int,val::Int64)          = @CHECK stmt.db sqlite3_bind_int64(stmt.handle,i,val)
+Base.bind(stmt::SQLiteStmt,i::Int,val::NullType)       = @CHECK stmt.db sqlite3_bind_null(stmt.handle,i)
+Base.bind(stmt::SQLiteStmt,i::Int,val::AbstractString) = @CHECK stmt.db sqlite3_bind_text(stmt.handle,i,val)
+Base.bind(stmt::SQLiteStmt,i::Int,val::UTF16String)    = @CHECK stmt.db sqlite3_bind_text16(stmt.handle,i,val)
 # Fallback is BLOB and defaults to serializing the julia value
 function sqlserialize(x)
     t = IOBuffer()
@@ -153,23 +153,23 @@ function execute(stmt::SQLiteStmt)
     end
     return r
 end
-function execute(db::SQLiteDB,sql::String)
+function execute(db::SQLiteDB,sql::AbstractString)
     stmt = SQLiteStmt(db,sql)
     execute(stmt)
     return changes(db)
 end
 
 sqldeserialize(r) = deserialize(IOBuffer(r))
 
-function query(db::SQLiteDB,sql::String, values=[])
+function query(db::SQLiteDB,sql::AbstractString, values=[])
     stmt = SQLiteStmt(db,sql)
     bind(stmt, values)
     status = execute(stmt)
     ncols = sqlite3_column_count(stmt.handle)
     if status == SQLITE_DONE || ncols == 0
         return changes(db)
     end
-    colnames = Array(String,ncols)
+    colnames = Array(AbstractString,ncols)
     results = Array(Any,ncols)
     for i = 1:ncols
         colnames[i] = bytestring(sqlite3_column_name(stmt.handle,i-1))
@@ -220,7 +220,7 @@ function transaction(db, mode="DEFERRED")
 
      If mode is one of "", "DEFERRED", "IMMEDIATE" or "EXCLUSIVE" then a
      transaction of that (or the default) type is started. Otherwise a savepoint
-     is created whose name is mode converted to String.
+     is created whose name is mode converted to AbstractString.
     =#
     if uppercase(mode) in ["", "DEFERRED", "IMMEDIATE", "EXCLUSIVE"]
         execute(db, "BEGIN $(mode) TRANSACTION;")
@@ -257,15 +257,15 @@ commit(db, name) = execute(db, "RELEASE SAVEPOINT $(name);")
 rollback(db) = execute(db, "ROLLBACK TRANSACTION;")
 rollback(db, name) = execute(db, "ROLLBACK TRANSACTION TO SAVEPOINT $(name);")
 
-function drop(db::SQLiteDB,table::String)
+function drop(db::SQLiteDB,table::AbstractString)
     transaction(db) do
         execute(db,"drop table $table")
     end
     execute(db,"vacuum")
     return changes(db)
 end
 
-function dropindex(db::SQLiteDB,index::String)
+function dropindex(db::SQLiteDB,index::AbstractString)
     transaction(db) do
         execute(db,"drop index $index")
     end
@@ -274,12 +274,12 @@ end
 
 gettype{T<:Integer}(::Type{T}) = " INT"
 gettype{T<:Real}(::Type{T}) = " REAL"
-gettype{T<:String}(::Type{T}) = " TEXT"
+gettype{T<:AbstractString}(::Type{T}) = " TEXT"
 gettype(::Type) = " BLOB"
 gettype(::Type{NullType}) = " NULL"
 
-function create(db::SQLiteDB,name::String,table,
-            colnames=String[],coltypes=DataType[];temp::Bool=false)
+function create(db::SQLiteDB,name::AbstractString,table,
+            colnames=AbstractString[],coltypes=DataType[];temp::Bool=false)
     N, M = size(table)
     colnames = isempty(colnames) ? ["x$i" for i=1:M] : colnames
     coltypes = isempty(coltypes) ? [typeof(table[1,i]) for i=1:M] : coltypes
@@ -305,7 +305,7 @@ function create(db::SQLiteDB,name::String,table,
     return changes(db)
 end
 
-function createindex(db::SQLiteDB,table::String,index::String,cols;unique::Bool=true)
+function createindex(db::SQLiteDB,table::AbstractString,index::AbstractString,cols;unique::Bool=true)
     u = unique ? "unique" : ""
     transaction(db) do
         execute(db,"create $u index $index on $table ($cols)")
@@ -314,7 +314,7 @@ function createindex(db::SQLiteDB,table::String,index::String,cols;unique::Bool=
     return changes(db)
 end
 
-function append(db::SQLiteDB,name::String,table)
+function append(db::SQLiteDB,name::AbstractString,table)
     N, M = size(table)
     transaction(db) do
         # insert statements
@@ -333,7 +333,7 @@ function append(db::SQLiteDB,name::String,table)
     return return changes(db)
 end
 
-function deleteduplicates(db,table::String,cols::String)
+function deleteduplicates(db,table::AbstractString,cols::AbstractString)
     transaction(db) do
         execute(db,"delete from $table where rowid not in (select max(rowid) from $table group by $cols);")
     end

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::String
-    @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::String
-    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)
@@ -63,43 +24,60 @@ function sqlvalue(values, i)
     end
 end
 
-sqlreturn(context, ::NullType)        = sqlite3_result_null(context)
-sqlreturn(context, val::Int32)        = sqlite3_result_int(context, val)
-sqlreturn(context, val::Int64)        = sqlite3_result_int64(context, val)
-sqlreturn(context, val::Float64)      = sqlite3_result_double(context, val)
-sqlreturn(context, val::String)       = sqlite3_result_text(context, val)
-sqlreturn(context, val::UTF16String)  = sqlite3_result_text16(context, val)
-sqlreturn(context, val)               = sqlite3_result_blob(context, sqlserialize(val))
+sqlreturn(context, ::NullType)          = sqlite3_result_null(context)
+sqlreturn(context, val::Int32)          = sqlite3_result_int(context, val)
+sqlreturn(context, val::Int64)          = sqlite3_result_int64(context, val)
+sqlreturn(context, val::Float64)        = sqlite3_result_double(context, val)
+sqlreturn(context, val::UTF16String)    = sqlite3_result_text16(context, val)
+sqlreturn(context, val::AbstractString) = sqlite3_result_text(context, val)
+sqlreturn(context, val)                 = sqlite3_result_blob(context, sqlserialize(val))
 
 sqlreturn(context, val::Bool) = sqlreturn(context, int(val))
 
-sqludferror(context, msg::String)      = 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 for registering a Julia function to be used within SQLite
+function register(db::SQLiteDB, func::Function; nargs::Int=-1, name::AbstractString=string(func), isdeterm::Bool=true)
+    @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::String, s::String) = ismatch(Regex(r), s)
+regexp(r::AbstractString, s::AbstractString) = ismatch(Regex(r), s)
 # macro for preserving the special characters in a string
 macro sr_str(s) s end