Merge branch 'master' into quinnj-jq/scalarfuncs

Sean1708 · Sean1708 · commit 0e420d3a0e47 · 2014-11-05T15:35:06.000Z
Conflicts:
	src/UDF.jl
diff --git a/README.md b/README.md
@@ -55,10 +55,12 @@ A Julia interface to the SQLite library and support for operations on DataFrames
 
   Used to execute prepared `SQLiteStmt`. The 2nd method is a convenience method to pass in an SQL statement as a string which gets prepared and executed in one call. This method does not check for or return any results, hence it is only useful for database manipulation methods (i.e. ALTER, CREATE, UPDATE, DROP). To return results, see `query` below. Also consider the `create`, `drop`, and `append` methods for manipulation statements as further SQLite performance tricks are incorporated automatically.
 
-* `query(db::SQLiteDB, sql::String)`
+* `query(db::SQLiteDB, sql::String, values=[])`
   
   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 `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)`
 
diff --git a/src/SQLite.jl b/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,7 +23,7 @@ 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
@@ -48,7 +48,7 @@ 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)
@@ -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))
@@ -98,20 +98,40 @@ function Base.close(stmt::SQLiteStmt)
     return
 end
 
+# bind a row to nameless parameters
+function Base.bind(stmt::SQLiteStmt, values::Vector)
+    nparams = sqlite3_bind_parameter_count(stmt.handle)
+    @assert nparams == length(values) "you must provide values for all placeholders"
+    for i in 1:nparams
+        @inbounds bind(stmt, i, values[i])
+    end
+end
+# bind a row to named parameters
+function Base.bind{V}(stmt::SQLiteStmt, values::Dict{Symbol, V})
+    nparams = sqlite3_bind_parameter_count(stmt.handle)
+    @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 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()
@@ -133,22 +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)
+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))
@@ -199,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;")
@@ -236,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
@@ -253,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
@@ -284,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)")
@@ -293,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
@@ -312,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
diff --git a/src/UDF.jl b/src/UDF.jl
@@ -24,17 +24,17 @@ 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::AbstractString)      = sqlite3_result_error(context, msg)
 sqludferror(context, msg::UTF16String) = sqlite3_result_error16(context, msg)
 
 # Internal method for generating an SQLite scalar function from
diff --git a/src/api.jl b/src/api.jl
@@ -9,7 +9,7 @@ function sqlite3_errmsg(db::Ptr{Void})
         Ptr{Uint8}, (Ptr{Void},),
         db)
 end
-function sqlite3_open(file::String,handle::Array{Ptr{Void},1})
+function sqlite3_open(file::AbstractString,handle::Array{Ptr{Void},1})
     return ccall( (:sqlite3_open, sqlite3_lib),
         Cint, (Ptr{Uint8},Ptr{Void}),
         file,handle)
@@ -31,13 +31,13 @@ function sqlite3_next_stmt(db::Ptr{Void},stmt::Ptr{Void})
         Ptr{Void}, (Ptr{Void},Ptr{Void}),
         db, stmt)
 end
-function sqlite3_prepare_v2(handle::Ptr{Void},query::String,stmt::Array{Ptr{Void},1},unused::Array{Ptr{Void},1})
+function sqlite3_prepare_v2(handle::Ptr{Void},query::AbstractString,stmt::Array{Ptr{Void},1},unused::Array{Ptr{Void},1})
     @NULLCHECK handle
     return ccall( (:sqlite3_prepare_v2, sqlite3_lib),
         Cint, (Ptr{Void},Ptr{Uint8},Cint,Ptr{Void},Ptr{Void}),
             handle,query,sizeof(query),stmt,unused)
 end
-function sqlite3_prepare16_v2(handle::Ptr{Void},query::String,stmt::Array{Ptr{Void},1},unused::Array{Ptr{Void},1})
+function sqlite3_prepare16_v2(handle::Ptr{Void},query::AbstractString,stmt::Array{Ptr{Void},1},unused::Array{Ptr{Void},1})
     @NULLCHECK handle
     return ccall( (:sqlite3_prepare16_v2, sqlite3_lib),
         Cint, (Ptr{Void},Ptr{Uint16},Cint,Ptr{Void},Ptr{Void}),
@@ -49,8 +49,23 @@ function sqlite3_finalize(stmt::Ptr{Void})
         Cint, (Ptr{Void},),
         stmt)
 end
+
+# SQLITE_API int sqlite3_bind_paramter_count(sqlite3_stmt*)
+function sqlite3_bind_parameter_count(stmt::Ptr{Void})
+    @NULLCHECK stmt
+    return ccall( (:sqlite3_bind_parameter_count, sqlite3_lib),
+        Cint, (Ptr{Void},),
+        stmt)
+end
+#SQLITE_API const char* sqlite3_bind_parameter_name(sqlite3_stmt*, int)
+function sqlite3_bind_parameter_name(stmt::Ptr{Void}, col::Int)
+    @NULLCHECK stmt
+    return ccall( (:sqlite3_bind_parameter_name, sqlite3_lib),
+        Ptr{Uint8}, (Ptr{Void}, Cint),
+        stmt, col)
+end
 # SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
-function sqlite3_bind_parameter_index(stmt::Ptr{Void},value::String)
+function sqlite3_bind_parameter_index(stmt::Ptr{Void},value::AbstractString)
     @NULLCHECK stmt
     return ccall( (:sqlite3_bind_parameter_index, sqlite3_lib),
         Cint, (Ptr{Void},Ptr{Uint8}),
@@ -85,7 +100,7 @@ function sqlite3_bind_null(stmt::Ptr{Void},col::Int)
         stmt,col)
 end
 # SQLITE_API int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
-function sqlite3_bind_text(stmt::Ptr{Void},col::Int,value::String)
+function sqlite3_bind_text(stmt::Ptr{Void},col::Int,value::AbstractString)
     @NULLCHECK stmt
     return ccall( (:sqlite3_bind_text, sqlite3_lib),
         Cint, (Ptr{Void},Cint,Ptr{Uint8},Cint,Ptr{Void}),
@@ -108,8 +123,6 @@ end
 # SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
 # SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
 
-# SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);
-# SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
 # SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);
 
 function sqlite3_step(stmt::Ptr{Void})
@@ -238,7 +251,7 @@ function sqlite3_result_double(context::Ptr{Void},value::Float64)
         context,value)
 end
 # SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int)
-function sqlite3_result_error(context::Ptr{Void},msg::String)
+function sqlite3_result_error(context::Ptr{Void},msg::AbstractString)
     return ccall( (:sqlite3_result_error, sqlite3_lib),
         Void, (Ptr{Void},Ptr{Uint8},Cint),
         context,value,sizeof(msg)+1)
@@ -268,7 +281,7 @@ function sqlite3_result_null(context::Ptr{Void})
         context)
 end
 # SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int n, void(*)(void*));
-function sqlite3_result_text(context::Ptr{Void},value::String)
+function sqlite3_result_text(context::Ptr{Void},value::AbstractString)
     return ccall( (:sqlite3_result_text, sqlite3_lib),
         Void, (Ptr{Void},Ptr{Uint8},Cint,Ptr{Void}),
         context,value,sizeof(value)+1,SQLITE_TRANSIENT)
@@ -292,7 +305,7 @@ end
 # SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int)
 
 
-function sqlite3_create_function_v2(db::Ptr{Void},name::String,nargs::Integer,
+function sqlite3_create_function_v2(db::Ptr{Void},name::AbstractString,nargs::Integer,
                                     enc::Integer,data::Ptr{Void},func::Ptr{Void},
                                     step::Ptr{Void},final::Ptr{Void},
                                     destructor::Ptr{Void})
@@ -390,7 +403,7 @@ function sqlite3_os_end()
         Cint, (),
         )
 end
-function sqlite3_free_table(result::Array{String,1})
+function sqlite3_free_table(result::Array{AbstractString,1})
     return ccall( (:sqlite3_free_table, sqlite_lib),
         Void, (Ptr{Ptr{Void}},),
         result)
@@ -441,18 +454,18 @@ end
 # SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
 
 # Not directly used
-function sqlite3_open_v2(file::String,handle::Array{Ptr{Void},1},flags::Cint,vfs::String)
+function sqlite3_open_v2(file::AbstractString,handle::Array{Ptr{Void},1},flags::Cint,vfs::AbstractString)
     return ccall( (:sqlite3_open_v2, sqlite3_lib),
             Cint, (Ptr{Uint8},Ptr{Void},Cint,Ptr{Uint8}),
             file,handle,flags,vfs)
 end
-function sqlite3_prepare(handle::Ptr{Void},query::String,stmt::Array{Ptr{Void},1},unused::Array{Ptr{Void},1})
+function sqlite3_prepare(handle::Ptr{Void},query::AbstractString,stmt::Array{Ptr{Void},1},unused::Array{Ptr{Void},1})
     @NULLCHECK handle
     return ccall( (:sqlite3_prepare, sqlite3_lib),
         Cint, (Ptr{Void},Ptr{Uint8},Cint,Ptr{Void},Ptr{Void}),
             handle,query,sizeof(query),stmt,unused)
 end
-function sqlite3_prepare16(handle::Ptr{Void},query::String,stmt::Array{Ptr{Void},1},unused::Array{Ptr{Void},1})
+function sqlite3_prepare16(handle::Ptr{Void},query::AbstractString,stmt::Array{Ptr{Void},1},unused::Array{Ptr{Void},1})
     @NULLCHECK handle
     return ccall( (:sqlite3_prepare16, sqlite3_lib),
         Cint, (Ptr{Void},Ptr{Uint8},Cint,Ptr{Void},Ptr{Void}),
diff --git a/src/show.jl b/src/show.jl
@@ -38,7 +38,7 @@ begin
         ourshowcompact(io, x)
         return position(io)
     end
-    ourstrwidth(x::String) = strwidth(x) + 2 # -> Int
+    ourstrwidth(x::AbstractString) = strwidth(x) + 2 # -> Int
     ourstrwidth(s::Symbol) = int(ccall(:u8_strwidth,
                                        Csize_t,
                                        (Ptr{Uint8}, ),
@@ -61,7 +61,7 @@ end
 #' ourshowcompact(STDOUT, "abc")
 #' ourshowcompact(STDOUT, 10000)
 ourshowcompact(io::IO, x::Any) = showcompact(io, x) # -> Nothing
-ourshowcompact(io::IO, x::String) = showcompact(io, x) # -> Nothing
+ourshowcompact(io::IO, x::AbstractString) = showcompact(io, x) # -> Nothing
 ourshowcompact(io::IO, x::Symbol) = print(io, x) # -> Nothing
 
 #' @description
@@ -83,7 +83,7 @@ ourshowcompact(io::IO, x::Symbol) = print(io, x) # -> Nothing
 #'        chunk of the AbstractDataFrame that would be rendered to IO. Can
 #'        be empty if the AbstractDataFrame would be printed without any
 #'        ellipses.
-#' @param rowlabel::String The label that will be used when rendered the
+#' @param rowlabel::AbstractString The label that will be used when rendered the
 #'        numeric ID's of each row. Typically, this will be set to "Row".
 #'
 #' @returns widths::Vector{Int} The maximum string widths required to render
diff --git a/test/runtests.jl b/test/runtests.jl
