Merge pull request #103 from felipenoris/fn/fixv4

fixes #102 and #104

Author: quinnj

src/SQLite.jl

@@ -21,16 +21,16 @@ show(io::IO,::NullType) = print(io,"#NULL")
 # Normal constructor from filename
 sqliteopen(file,handle) = sqlite3_open(file,handle)
 sqliteopen(file::UTF16String,handle) = sqlite3_open16(file,handle)
-sqliteerror() = throw(SQLiteException(bytestring(sqlite3_errmsg())))
-sqliteerror(db) = throw(SQLiteException(bytestring(sqlite3_errmsg(db.handle))))
+sqliteerror() = throw(SQLiteException(Compat.bytestring(sqlite3_errmsg())))
+sqliteerror(db) = throw(SQLiteException(Compat.bytestring(sqlite3_errmsg(db.handle))))
 
 "represents an SQLite database, either backed by an on-disk file or in-memory"
 type DB
-    file::@compat(String)
+    file::Compat.UTF8String
     handle::Ptr{Void}
     changes::Int
 
-    function DB(f::@compat(String))
+    function DB(f::Compat.UTF8String)
         handle = Ref{Ptr{Void}}()
         f = isempty(f) ? f : expanduser(f)
         if @OK sqliteopen(f,handle)
@@ -45,9 +45,9 @@ type DB
     end
 end
 "`SQLite.DB(file::AbstractString)` opens or creates an SQLite database with `file`"
-DB(f::AbstractString) = DB(f)
+DB(f::AbstractString) = DB(Compat.UTF8String(f))
 "`SQLite.DB()` creates an in-memory SQLite database"
-DB() = DB(":memory:")
+DB() = DB(Compat.UTF8String(":memory:"))
 
 function _close(db::DB)
     sqlite3_close_v2(db.handle)
@@ -105,7 +105,7 @@ function bind!{V}(stmt::Stmt, 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))
+        name = Compat.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]
@@ -115,7 +115,7 @@ end
 # Binding parameters to SQL statements
 "bind `val` to the named parameter `name`"
 function bind!(stmt::Stmt,name::AbstractString,val)
-    i = sqlite3_bind_parameter_index(stmt.handle,name)
+    i::Int = sqlite3_bind_parameter_index(stmt.handle,name)
     if i == 0
         throw(SQLiteException("SQL parameter $name not found in $stmt"))
     end
@@ -131,7 +131,7 @@ bind!(stmt::Stmt,i::Int,val::PointerString{UInt16})  = (sqlite3_bind_text16(stmt
 bind!(stmt::Stmt,i::Int,val::UTF16String)    = (sqlite3_bind_text16(stmt.handle,i,val); return nothing)
 function bind!(stmt::Stmt,i::Int,val::PointerString{UInt32})
     A = UTF32String(pointer_to_array(val.ptr, val.len+1, false))
-    return bind!(stmt, i, convert(@compat(String),A))
+    return bind!(stmt, i, convert(Compat.UTF8String,A))
 end
 # 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}
@@ -310,7 +310,7 @@ end
 type Sink <: Data.Sink # <: IO
     schema::Data.Schema
     db::DB
-    tablename::@compat(String)
+    tablename::Compat.UTF8String
     stmt::Stmt
 end
 

src/Source.jl

@@ -19,10 +19,10 @@ function Source(db::DB, sql::AbstractString, values=[]; rows::Int=0, stricttypes
     bind!(stmt, values)
     status = SQLite.execute!(stmt)
     cols = SQLite.sqlite3_column_count(stmt.handle)
-    header = Array(@compat(String),cols)
+    header = Array(Compat.UTF8String,cols)
     types = Array(DataType,cols)
     for i = 1:cols
-        header[i] = bytestring(SQLite.sqlite3_column_name(stmt.handle,i))
+        header[i] = Compat.bytestring(SQLite.sqlite3_column_name(stmt.handle,i))
         # do better column type inference; query what the column was created for?
         types[i] = stricttypes ? SQLite.juliatype(stmt.handle,i) : Any
     end
@@ -41,13 +41,13 @@ function juliatype(handle,col)
         return juliatype(x)
     end
 end
-juliatype(x) = x == SQLITE_INTEGER ? Int : x == SQLITE_FLOAT ? Float64 : x == SQLITE_TEXT ? @compat(String) : Any
+juliatype(x) = x == SQLITE_INTEGER ? Int : x == SQLITE_FLOAT ? Float64 : x == SQLITE_TEXT ? Compat.UTF8String : Any
 
 sqlitevalue{T<:Union{Signed,Unsigned}}(::Type{T},handle,col) = convert(T, sqlite3_column_int64(handle,col))
 const FLOAT_TYPES = Union{Float16,Float32,Float64} # exclude BigFloat
 sqlitevalue{T<:FLOAT_TYPES}(::Type{T},handle,col) = convert(T, sqlite3_column_double(handle,col))
 #TODO: test returning a PointerString instead of calling `bytestring`
-sqlitevalue{T<:AbstractString}(::Type{T},handle,col) = convert(T,bytestring(sqlite3_column_text(handle,col)))
+sqlitevalue{T<:AbstractString}(::Type{T},handle,col) = convert(T,Compat.bytestring(sqlite3_column_text(handle,col)))
 function sqlitevalue{T}(::Type{T},handle,col)
     blob = convert(Ptr{UInt8},SQLite.sqlite3_column_blob(handle,col))
     b = SQLite.sqlite3_column_bytes(handle,col)

src/UDF.jl

@@ -3,7 +3,7 @@ function sqlvalue(values, i)
     valuetype = sqlite3_value_type(temp_val_ptr)
 
     if valuetype == SQLITE_INTEGER
-        if WORD_SIZE == 64
+        if Sys.WORD_SIZE == 64
             return sqlite3_value_int64(temp_val_ptr)
         else
             return sqlite3_value_int(temp_val_ptr)
@@ -12,7 +12,7 @@ function sqlvalue(values, i)
         return sqlite3_value_double(temp_val_ptr)
     elseif valuetype == SQLITE_TEXT
         # TODO: have a way to return UTF16
-        return bytestring(sqlite3_value_text(temp_val_ptr))
+        return Compat.bytestring(sqlite3_value_text(temp_val_ptr))
     elseif valuetype == SQLITE_BLOB
         nbytes = sqlite3_value_bytes(temp_val_ptr)
         blob = sqlite3_value_blob(temp_val_ptr)

src/old_ui.jl

@@ -89,7 +89,7 @@ function bind{V}(stmt, 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))
+        name = Compat.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]
@@ -143,7 +143,7 @@ function query(db::SQLiteDB,sql::AbstractString, values=[])
     colnames = Array(AbstractString,ncols)
     results = Array(Any,ncols)
     for i = 1:ncols
-        colnames[i] = bytestring(sqlite3_column_name(stmt.handle,i))
+        colnames[i] = Compat.bytestring(sqlite3_column_name(stmt.handle,i))
         results[i] = Any[]
     end
     while status == SQLITE_ROW
@@ -155,7 +155,7 @@ function query(db::SQLiteDB,sql::AbstractString, values=[])
                 r = sqlite3_column_double(stmt.handle,i)
             elseif t == SQLITE_TEXT
                 #TODO: have a way to return text16?
-                r = bytestring( sqlite3_column_text(stmt.handle,i) )
+                r = Compat.bytestring( sqlite3_column_text(stmt.handle,i) )
             elseif t == SQLITE_BLOB
                 blob = sqlite3_column_blob(stmt.handle,i)
                 b = sqlite3_column_bytes(stmt.handle,i)

src/show.jl

@@ -14,7 +14,7 @@
 #' summary(DataFrame(A = 1:10))
 function Base.summary(adf::ResultSet) # -> UTF8String
     nrows, ncols = size(adf)
-    return utf8(@sprintf "%dx%d %s" nrows ncols typeof(adf))
+    return Compat.utf8(@sprintf "%dx%d %s" nrows ncols typeof(adf))
 end
 
 #' @description

test/runtests.jl

@@ -25,7 +25,7 @@ results = SQLite.query(db,"SELECT * FROM Employee;")
 @test length(results.data) == 15
 @test size(results) == (8,15)
 @test typeof(results[1,1]) == Nullable{Int}
-@test typeof(results[1,2]) == Nullable{@compat(String)}
+@test typeof(results[1,2]) == Nullable{Compat.UTF8String}
 @test isnull(results[1,5])
 
 SQLite.query(db,"SELECT * FROM Album;")
@@ -277,10 +277,10 @@ dt = Data.stream!(source3,Data.Table)
 
 #Make sure we handle undefined values
 db = SQLite.DB() #In case the order of tests is changed
-arr = Array(@compat(String),2) 
+arr = Array(Compat.UTF8String,2) 
 arr[1] = "1" #Now an array with the second value undefined
 nv = NullableArrays.NullableArray(arr, [false, true])
-schema = DataStreams.Data.Schema(["nv"], [@compat(String)],2)
+schema = DataStreams.Data.Schema(["nv"], [Compat.UTF8String],2)
 d = NullableArrays.NullableVector[nv]
 dt = DataStreams.Data.Table(schema, d,0)
 SQLite.drop!(db, "temp", ifexists=true)
@@ -294,10 +294,10 @@ dt2 = SQLite.query(db, "Select * from temp")
 #Test removeduplicates!
 db = SQLite.DB() #In case the order of tests is changed
 ints = Int64[1,1,2,2,3]
-strs = @compat(String)["A", "A", "B", "C", "C"]
+strs = Compat.UTF8String["A", "A", "B", "C", "C"]
 nvInts = NullableArrays.NullableArray(ints)
 nvStrs = NullableArrays.NullableArray(strs)
-schema = DataStreams.Data.Schema(["ints", "strs"], [Int64, @compat(String)],5)
+schema = DataStreams.Data.Schema(["ints", "strs"], [Int64, Compat.UTF8String],5)
 d = NullableArrays.NullableVector[nvInts, nvStrs]
 dt = DataStreams.Data.Table(schema, d,0)
 SQLite.drop!(db, "temp", ifexists=true)
@@ -311,3 +311,9 @@ dt3 = SQLite.query(db, "Select * from temp")
 @test get(dt3[2,2]) == "B"
 @test get(dt3[3,1]) == 2
 @test get(dt3[3,2]) == "C"
+
+# issue #104
+db = SQLite.DB() #In case the order of tests is changed
+SQLite.execute!(db, "CREATE TABLE IF NOT EXISTS tbl(a  INTEGER);")
+stmt = SQLite.Stmt(db, "INSERT INTO tbl (a) VALUES (@a);")
+SQLite.bind!(stmt, "@a", 1)