Merge pull request #68 from simonbyrne/fix04

get working on 0.4

Author: quinnj

README.md

@@ -54,7 +54,7 @@ A Julia interface to the SQLite library and support for operations on DataFrames
 * `execute(stmt::SQLiteStmt)`
   `execute(db::SQLiteDB, sql::String)`
 
-  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.
+  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`, `droptable`, and `append` methods for manipulation statements as further SQLite performance tricks are incorporated automatically.
 
 * `query(db::SQLiteDB, sql::String, values=[])`
 
@@ -73,9 +73,9 @@ A Julia interface to the SQLite library and support for operations on DataFrames
 
   Takes the values in `table` and appends (by repeated inserts) to the SQLite table `name`. No column checking is done to ensure correct types, so care should be taken as SQLite is "typeless" in that it allows items of any type to be stored in columns. Transaction handling is automatic as well as performance enhancements.
 
-* `drop(db::SQLiteDB,table::String)`
+* `droptable(db::SQLiteDB,table::String)`
 
-  `drop` is pretty self-explanatory. It's really just a convenience wrapper around `query` to execute a DROP TABLE command, while also calling "VACUUM" to clean out freed memory from the database.
+  `droptable` is pretty self-explanatory. It's really just a convenience wrapper around `query` to execute a DROP TABLE command, while also calling "VACUUM" to clean out freed memory from the database.
 
 * `register(db::SQLiteDB, func::Function; nargs::Int=-1, name::AbstractString=string(func), isdeterm::Bool=true)`
 * `register(db::SQLiteDB, init, step::Function, final::Function=identity; nargs::Int=-1, name::AbstractString=string(final), isdeterm::Bool=true)`

REQUIRE

@@ -1,4 +1,5 @@
 julia 0.3-
 BinDeps
+Compat
 @osx Homebrew
 @windows WinRPM

src/SQLite.jl

@@ -1,18 +1,12 @@
 module SQLite
 
+using Compat
+
 export NULL, SQLiteDB, SQLiteStmt, ResultSet,
-       execute, query, tables, indices, columns, drop, dropindex,
+       execute, query, tables, indices, columns, droptable, dropindex,
        create, createindex, append, deleteduplicates
 
-if VERSION < v"0.4.0-dev"
-    const AbstractString = String
-    const UInt8 = Uint8
-    const UInt16 = Uint16
-    const UInt32 = Uint32
-    const UInt64 = Uint64
-    const UInt128 = Uint128
-    const UInt = Uint
-end
+import Base: ==, show, convert, bind, close
 
 type SQLiteException <: Exception
     msg::AbstractString
@@ -24,7 +18,7 @@ include("api.jl")
 # Custom NULL type
 immutable NullType end
 const NULL = NullType()
-Base.show(io::IO,::NullType) = print(io,"NULL")
+show(io::IO,::NullType) = print(io,"NULL")
 
 # internal wrapper type to, in-effect, mark something which has been serialized
 immutable Serialization
@@ -37,7 +31,7 @@ type ResultSet
 end
 ==(a::ResultSet,b::ResultSet) = a.colnames == b.colnames && a.values == b.values
 include("show.jl")
-Base.convert(::Type{Matrix},a::ResultSet) = [a[i,j] for i=1:size(a,1), j=1:size(a,2)]
+convert(::Type{Matrix},a::ResultSet) = [a[i,j] for i=1:size(a,1), j=1:size(a,2)]
 
 type SQLiteDB{T<:AbstractString}
     file::T
@@ -79,7 +73,7 @@ function SQLiteDB(file::AbstractString="";UTF16::Bool=false)
     end
 end
 
-function Base.close{T}(db::SQLiteDB{T})
+function close{T}(db::SQLiteDB{T})
     db.handle == C_NULL && return
     # ensure SQLiteStmts are finalised
     gc()
@@ -107,23 +101,23 @@ function SQLiteStmt{T}(db::SQLiteDB{T},sql::AbstractString)
     return stmt
 end
 
-function Base.close(stmt::SQLiteStmt)
+function close(stmt::SQLiteStmt)
     stmt.handle == C_NULL && return
     @CHECK stmt.db sqlite3_finalize(stmt.handle)
     stmt.handle = C_NULL
     return
 end
 
 # bind a row to nameless parameters
-function Base.bind(stmt::SQLiteStmt, values::Vector)
+function 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})
+function 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
@@ -135,22 +129,22 @@ function Base.bind{V}(stmt::SQLiteStmt, values::Dict{Symbol, V})
     end
 end
 # Binding parameters to SQL statements
-function Base.bind(stmt::SQLiteStmt,name::AbstractString,val)
+function 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::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)
+bind(stmt::SQLiteStmt,i::Int,val::FloatingPoint)  = @CHECK stmt.db sqlite3_bind_double(stmt.handle,i,@compat Float64(val))
+bind(stmt::SQLiteStmt,i::Int,val::Int32)          = @CHECK stmt.db sqlite3_bind_int(stmt.handle,i,val)
+bind(stmt::SQLiteStmt,i::Int,val::Int64)          = @CHECK stmt.db sqlite3_bind_int64(stmt.handle,i,val)
+bind(stmt::SQLiteStmt,i::Int,val::NullType)       = @CHECK stmt.db sqlite3_bind_null(stmt.handle,i)
+bind(stmt::SQLiteStmt,i::Int,val::AbstractString) = @CHECK stmt.db sqlite3_bind_text(stmt.handle,i,val)
+bind(stmt::SQLiteStmt,i::Int,val::UTF16String)    = @CHECK stmt.db sqlite3_bind_text16(stmt.handle,i,val)
 # We may want to track the new ByteVec type proposed at https://github.com/JuliaLang/julia/pull/8964
 # as the "official" bytes type instead of Vector{UInt8}
-Base.bind(stmt::SQLiteStmt,i::Int,val::Vector{UInt8})  = @CHECK stmt.db sqlite3_bind_blob(stmt.handle,i,val)
+bind(stmt::SQLiteStmt,i::Int,val::Vector{UInt8})  = @CHECK stmt.db sqlite3_bind_blob(stmt.handle,i,val)
 # Fallback is BLOB and defaults to serializing the julia value
 function sqlserialize(x)
     t = IOBuffer()
@@ -161,7 +155,7 @@ function sqlserialize(x)
     serialize(t,s)
     return takebuf_array(t)
 end
-Base.bind(stmt::SQLiteStmt,i::Int,val) = bind(stmt,i,sqlserialize(val))
+bind(stmt::SQLiteStmt,i::Int,val) = bind(stmt,i,sqlserialize(val))
 #TODO:
  #int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
  #int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
@@ -293,7 +287,7 @@ 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::AbstractString;ifexists::Bool=false)
+function droptable(db::SQLiteDB,table::AbstractString;ifexists::Bool=false)
     exists = ifexists ? "if exists" : ""
     transaction(db) do
         execute(db,"drop table $exists $table")
@@ -384,4 +378,4 @@ function deleteduplicates(db,table::AbstractString,cols::AbstractString)
     return changes(db)
 end
 
-end #SQLite module
+end #SQLite module

src/UDF.jl

@@ -32,7 +32,7 @@ sqlreturn(context, val::UTF16String)    = sqlite3_result_text16(context, val)
 sqlreturn(context, val::AbstractString) = sqlite3_result_text(context, val)
 sqlreturn(context, val::Vector{UInt8})  = sqlite3_result_blob(context, val)
 
-sqlreturn(context, val::Bool) = sqlreturn(context, int(val))
+sqlreturn(context, val::Bool) = sqlreturn(context, @compat Int(val))
 sqlreturn(context, val) = sqlreturn(context, sqlserialize(val))
 
 # Internal method for generating an SQLite scalar function from
@@ -88,7 +88,7 @@ function stepfunc(init, func, fsym=symbol(string(func)*"_step"))
                 acval = $(init)
                 valsize = 256
                 # avoid the garbage collector using malloc
-                valptr = convert(Ptr{UInt8}, c_malloc(valsize))
+                valptr = convert(Ptr{UInt8}, Libc.malloc(valsize))
                 valptr == C_NULL && throw(SQLiteException("memory error"))
             else
                 # size of serialized value is first sizeof(Int) bytes
@@ -107,16 +107,16 @@ function stepfunc(init, func, fsym=symbol(string(func)*"_step"))
             try
                 funcret = sqlserialize($(func)(acval, args...))
             catch
-                c_free(valptr)
+                Libc.free(valptr)
                 rethrow()
             end
 
             newsize = sizeof(funcret)
             if newsize > valsize
                 # TODO: increase this in a cleverer way?
-                tmp = convert(Ptr{UInt8}, c_realloc(valptr, newsize))
+                tmp = convert(Ptr{UInt8}, Libc.realloc(valptr, newsize))
                 if tmp == C_NULL
-                    c_free(valptr)
+                    Libc.free(valptr)
                     throw(SQLiteException("memory error"))
                 else
                     valptr = tmp
@@ -171,7 +171,7 @@ function finalfunc(init, func, fsym=symbol(string(func)*"_final"))
                 try
                     ret = $(func)(acval)
                 finally
-                    c_free(valptr)
+                    Libc.free(valptr)
                 end
                 sqlreturn(context, ret)
             end

src/show.jl

@@ -39,10 +39,10 @@ begin
         return position(io)
     end
     ourstrwidth(x::AbstractString) = strwidth(x) + 2 # -> Int
-    ourstrwidth(s::Symbol) = int(ccall(:u8_strwidth,
+    ourstrwidth(s::Symbol) = @compat Int(ccall(:u8_strwidth,
                                        Csize_t,
                                        (Ptr{Uint8}, ),
-                                       convert(Ptr{Uint8}, s)))
+                                       string(s)))
 end
 
 #' @description

test/runtests.jl

@@ -1,15 +1,6 @@
-using Base.Test, SQLite
-
-if VERSION < v"0.4.0-dev"
-    const AbstractString = String
-    const UInt8 = Uint8
-    const UInt16 = Uint16
-    const UInt32 = Uint32
-    const UInt64 = Uint64
-    const UInt128 = Uint128
-    const UInt = Uint
-    typealias AssertionError ErrorException
-end
+using Base.Test, SQLite, Compat
+
+import Base: +, ==
 
 a = SQLiteDB()
 b = SQLiteDB(UTF16=true)
@@ -80,15 +71,15 @@ r = query(db,"select * from temp")
 @test all(r.values[1] .== 0.0)
 @test all([typeof(i) for i in r.values[1]] .== Float64)
 @test r.colnames == ["col1","col2","col3","col4","col5"]
-@test drop(db,"temp") == EMPTY_RESULTSET
+@test droptable(db,"temp") == EMPTY_RESULTSET
 
 create(db,"temp",zeros(5,5))
 r = query(db,"select * from temp")
 @test size(r) == (5,5)
 @test all(r.values[1] .== 0.0)
 @test all([typeof(i) for i in r.values[1]] .== Float64)
 @test r.colnames == ["x1","x2","x3","x4","x5"]
-@test drop(db,"temp") == EMPTY_RESULTSET
+@test droptable(db,"temp") == EMPTY_RESULTSET
 
 create(db,"temp",zeros(Int,5,5))
 r = query(db,"select * from temp")
@@ -102,7 +93,7 @@ r = query(db,"select * from temp")
 @test r.values[1] == Any[0,0,0,0,0,1,1,1,1,1]
 @test typeof(r[1,1]) == Int64
 @test r.colnames == ["x1","x2","x3","x4","x5"]
-@test drop(db,"temp") == EMPTY_RESULTSET
+@test droptable(db,"temp") == EMPTY_RESULTSET
 
 if VERSION > v"0.4.0-"
     rng = Date(2013):Date(2013,1,5)
@@ -112,7 +103,7 @@ if VERSION > v"0.4.0-"
     @test all(r[:,1] .== rng)
     @test all([typeof(i) for i in r.values[1]] .== Date)
     @test r.colnames == ["x1","x2","x3","x4","x5"]
-    @test drop(db,"temp") == EMPTY_RESULTSET
+    @test droptable(db,"temp") == EMPTY_RESULTSET
 end
 
 query(db,"CREATE TABLE temp AS SELECT * FROM Album")
@@ -123,11 +114,11 @@ r = query(db, "SELECT * FROM temp WHERE Title LIKE ?", ["%time%"])
 query(db, "INSERT INTO temp VALUES (?1, ?3, ?2)", [0,0,"Test Album"])
 r = query(db, "SELECT * FROM temp WHERE AlbumId = 0")
 @test r == ResultSet(Any["AlbumId", "Title", "ArtistId"], Any[Any[0], Any["Test Album"], Any[0]])
-drop(db, "temp")
+droptable(db, "temp")
 
 binddb = SQLiteDB()
 query(binddb, "CREATE TABLE temp (n NULL, i6 INT, f REAL, s TEXT, a BLOB)")
-query(binddb, "INSERT INTO temp VALUES (?1, ?2, ?3, ?4, ?5)", Any[NULL, int64(6), 6.4, "some text", b"bytearray"])
+query(binddb, "INSERT INTO temp VALUES (?1, ?2, ?3, ?4, ?5)", Any[NULL, convert(Int64,6), 6.4, "some text", b"bytearray"])
 r = query(binddb, "SELECT * FROM temp")
 for (v, t) in zip(r.values, [SQLite.NullType, Int64, Float64, AbstractString, Vector{UInt8}])
     @test isa(v[1], t)
@@ -163,7 +154,7 @@ if VERSION > v"0.4.0-"
     query(db, "INSERT INTO temp VALUES (@lid, :title, \$rid)", Dict(:rid => 0, :lid => 0, :title => "Test Album"))
     r = query(db, "SELECT * FROM temp WHERE AlbumId = 0")
     @test r == ResultSet(Any["AlbumId", "Title", "ArtistId"], Any[Any[0], Any["Test Album"], Any[0]])
-    drop(db, "temp")
+    droptable(db, "temp")
 end
 
 r = query(db, sr"SELECT LastName FROM Employee WHERE BirthDate REGEXP '^\d{4}-08'")
@@ -198,7 +189,7 @@ u = query(db, "select sin(milliseconds) from track limit 5")
 
 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 [@compat round(Int,i) for i in v[1]] == [11175621,5521062,3997652,4339106,6301714]
 
 SQLite.@register db str2arr(s) = convert(Array{UInt8}, s)
 r = query(db, "SELECT str2arr(LastName) FROM Employee LIMIT 2")
@@ -242,7 +233,7 @@ sumpoint(p::Point3D, x, y, z) = p + Point3D(x, y, z)
 register(db, Point3D(0, 0, 0), sumpoint)
 r = query(db, "SELECT sumpoint(x, y, z) FROM points")
 @test r[1][1] == Point3D(12, 15, 18)
-drop(db, "points")
+droptable(db, "points")
 
 db2 = SQLiteDB()
 query(db2, "CREATE TABLE tab1 (r REAL, s INT)")
@@ -252,11 +243,11 @@ query(db2, "CREATE TABLE tab1 (r REAL, s INT)")
 create(db2, "tab1", [2.1 3; 3.4 8], ifnotexists=true)
 create(db2, "tab2", [2.1 3; 3.4 8])
 
-@test_throws SQLite.SQLiteException drop(db2, "nonexistant")
+@test_throws SQLite.SQLiteException droptable(db2, "nonexistant")
 # should not throw anything
-drop(db2, "nonexistant", ifexists=true)
+droptable(db2, "nonexistant", ifexists=true)
 # should drop "tab2"
-drop(db2, "tab2", ifexists=true)
+droptable(db2, "tab2", ifexists=true)
 @test !in("tab2", tables(db2)[1])
 
 close(db2)