Cleanups for 1.0 release

Author: quinnj

Project.toml

@@ -16,8 +16,8 @@ Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 [compat]
 julia = "1"
 BinaryProvider = "0.5"
-DBInterface = "1"
-Tables = "0.2"
+DBInterface = "2"
+Tables = "1"
 DecFP = "0.4"
 MariaDB_Connector_C_jll = "3"
 Parsers = "0.3"

README.md

@@ -125,11 +125,11 @@ Escape an SQL statement
 
 Deprecated - see [MySQL.Query](#mysqlquery)
 
-#### MySQL.execute!
+#### MySQL.execute
 
 ```julia
-MySQL.execute!(conn::MySQL.Connection, sql::String)
-MySQL.execute!(stmt::MySQL.Stmt, params)
+MySQL.execute(conn::MySQL.Connection, sql::String)
+MySQL.execute(stmt::MySQL.Stmt, params)
 ```
 Execute an SQL statement without returning results (useful for DDL statements, update, delete, etc.)
 
@@ -158,13 +158,13 @@ MySQL.Stmt(conn::MySQL.Connection, sql::String) => MySQL.Stmt
 ```
 A prepared SQL statement that may contain `?` parameter placeholders.
 
-A `MySQL.Stmt` may then be executed by calling `MySQL.execute!(stmt, params)` where
+A `MySQL.Stmt` may then be executed by calling `MySQL.execute(stmt, params)` where
 `params` is a vector with the values to be bound to the `?` placeholders in the
 original SQL statement. Params must be provided for every `?` and will be matched in the same order they
 appeared in the original SQL statement.
 
 Alternately, a source implementing the Tables.jl interface can be streamed by executing
-`MySQL.execute!(itr, stmt)`. Each row must have a value for each param.
+`MySQL.execute(itr, stmt)`. Each row must have a value for each param.
 
 #### MySQL.Query
 
@@ -196,7 +196,7 @@ num_foo = foo[1,1]
 my_stmt = MySQL.Stmt(conn, """INSERT INTO my_second_table ('foo_id','foo_name') VALUES (?,?);""")
 
 for i = 1:num_foo
-  MySQL.execute!(my_stmt, [i, "foo_$i"])
+  MySQL.execute(my_stmt, [i, "foo_$i"])
 end
 
 MySQL.disconnect(conn)

docs/src/index.md

@@ -8,7 +8,7 @@
 DBInterface.connect
 DBInterface.close!
 MySQL.escape
-DBInterface.execute!
+DBInterface.execute
 DBInterface.prepare
 DBInterface.lastrowid
 ```

src/execute.jl

@@ -10,7 +10,7 @@ mutable struct TextCursor{buffered} <: DBInterface.Cursor
     lookup::Dict{Symbol, Int}
 end
 
-struct TextRow{buffered} <: AbstractVector{Any}
+struct TextRow{buffered} <: Tables.AbstractRow
     cursor::TextCursor{buffered}
     row::Ptr{Ptr{UInt8}}
     lengths::Vector{Culong}
@@ -20,9 +20,7 @@ getcursor(r::TextRow) = getfield(r, :cursor)
 getrow(r::TextRow) = getfield(r, :row)
 getlengths(r::TextRow) = getfield(r, :lengths)
 
-Base.size(r::TextRow) = (getcursor(r).nfields,)
-Base.IndexStyle(::Type{<:TextRow}) = Base.IndexLinear()
-Base.propertynames(r::TextRow) = getcursor(r).names
+Tables.columnnames(r::TextRow) = getcursor(r).names
 
 cast(::Type{Union{Missing, T}}, ptr, len) where {T} = ptr == C_NULL ? missing : cast(T, ptr, len)
 
@@ -67,16 +65,14 @@ function cast(::Type{DateTime}, ptr, len)
     casterror(DateTime, ptr, len)
 end
 
-function Base.getindex(r::TextRow, i::Int)
-    return cast(getcursor(r).types[i], unsafe_load(getrow(r), i), getlengths(r)[i])
+function Tables.getcolumn(r::TextRow, ::Type{T}, i::Int, nm::Symbol) where {T}
+    return cast(T, unsafe_load(getrow(r), i), getlengths(r)[i])
 end
 
-Base.getindex(r::TextRow, nm::Symbol) = getindex(r, getcursor(r).lookup[nm])
-Base.getproperty(r::TextRow, nm::Symbol) = getindex(r, getcursor(r).lookup[nm])
+Tables.getcolumn(r::TextRow, i::Int) = Tables.getcolumn(r, getcursor(r).types[i], i, getcursor(r).names[i])
+Tables.getcolumn(r::TextRow, nm::Symbol) = Tables.getcolumn(r, getcursor(r).lookup[nm])
 
-Tables.istable(::Type{<:TextCursor}) = true
-Tables.rowaccess(::Type{<:TextCursor}) = true
-Tables.rows(q::TextCursor) = q
+Tables.isrowtable(::Type{<:TextCursor}) = true
 Tables.schema(c::TextCursor) = Tables.Schema(c.names, c.types)
 
 Base.eltype(c::TextCursor) = TextRow
@@ -107,7 +103,14 @@ function DBInterface.lastrowid(c::TextCursor)
 end
 
 """
-    DBInterface.execute!(conn::MySQL.Connection, sql) => MySQL.TextCursor
+    DBInterface.close!(cursor)
+
+Close a cursor. No more results will be available.
+"""
+DBInterface.close!(c::TextCursor) = clear!(c.conn)
+
+"""
+    DBInterface.execute(conn::MySQL.Connection, sql) => MySQL.TextCursor
 
 Execute the SQL `sql` statement with the database connection `conn`. Parameter binding is
 only supported via prepared statements, see `?DBInterface.prepare(conn, sql)`.
@@ -117,8 +120,9 @@ Specifying `mysql_store_result=false` will avoid buffering the full resultset to
 the query, which has memory use advantages, though ties up the database server since resultset rows must be
 fetched one at a time.
 """
-function DBInterface.execute!(conn::Connection, sql::AbstractString, args...; mysql_store_result::Bool=true, kw...)
+function DBInterface.execute(conn::Connection, sql::AbstractString, params=(); mysql_store_result::Bool=true)
     checkconn(conn)
+    params != () && error("`DBInterface.execute(conn, sql)` does not support parameter binding; see `?DBInterface.prepare(conn, sql)`")
     clear!(conn)
     API.query(conn.mysql, sql)
 

src/prepare.jl

@@ -33,7 +33,7 @@ DBInterface.close!(stmt::Statement) = finalize(stmt.stmt)
     DBInterface.prepare(conn::MySQL.Connection, sql) => MySQL.Statement
 
 Send a `sql` SQL string to the database to be prepared, returning a `MySQL.Statement` object
-that can be passed to `DBInterface.execute!(stmt, args...)` to be repeatedly executed,
+that can be passed to `DBInterface.execute(stmt, args...)` to be repeatedly executed,
 optionally passing `args` for parameters to be bound on each execution.
 
 Note that `DBInterface.close!(stmt)` should be called once statement executions are finished. Apart from
@@ -80,27 +80,23 @@ struct Cursor{buffered} <: DBInterface.Cursor
     rows::Int
 end
 
-struct Row <: AbstractVector{Any}
+struct Row <: Tables.AbstractRow
     cursor::Cursor
 end
 
 getcursor(r::Row) = getfield(r, :cursor)
 
-Base.size(r::Row) = (getcursor(r).nfields,)
-Base.IndexStyle(::Type{<:Row}) = Base.IndexLinear()
-Base.propertynames(r::Row) = getcursor(r).names
+Tables.columnnames(r::Row) = getcursor(r).names
 
-function Base.getindex(r::Row, i::Int)
+function Tables.getcolumn(r::Row, ::Type{T}, i::Int, nm::Symbol) where {T}
     cursor = getcursor(r)
-    return getvalue(cursor.stmt, cursor.valuehelpers[i], cursor.values, i, cursor.types[i])
+    return getvalue(cursor.stmt, cursor.valuehelpers[i], cursor.values, i, T)
 end
 
-Base.getindex(r::Row, nm::Symbol) = getindex(r, getcursor(r).lookup[nm])
-Base.getproperty(r::Row, nm::Symbol) = getindex(r, getcursor(r).lookup[nm])
+Tables.getcolumn(r::Row, i::Int) = Tables.getcolumn(r, getcursor(r).types[i], i, getcursor(r).names[i])
+Tables.getcolumn(r::Row, nm::Symbol) = Tables.getcolumn(r, getcursor(r).lookup[nm])
 
-Tables.istable(::Type{<:Cursor}) = true
-Tables.rowaccess(::Type{<:Cursor}) = true
-Tables.rows(q::Cursor) = q
+Tables.isrowtable(::Type{<:Cursor}) = true
 Tables.schema(c::Cursor) = Tables.Schema(c.names, c.types)
 
 Base.eltype(c::Cursor) = Row
@@ -126,27 +122,32 @@ function DBInterface.lastrowid(c::Cursor)
     return API.insertid(c.stmt)
 end
 
-@noinline kwcheck(kw) = !isempty(kw) && throw(MySQLInterfaceError("named parameters not supported by mysql; parameters must be provided in order by position; e.g. `DBInterface.execute!(stmt, param1, param2)`"))
+"""
+    DBInterface.close!(cursor)
+
+Close a cursor. No more results will be available.
+"""
+DBInterface.close!(c::Cursor) = clear!(c.conn)
+
 @noinline paramcheck(stmt, args) = length(args) == stmt.nparams || throw(MySQLInterfaceError("stmt requires $(stmt.nparams) params, only $(length(args)) provided"))
 
 """
-    DBInterface.execute!(stmt, args...; mysql_store_result=true) => MySQL.Cursor
+    DBInterface.execute(stmt, params; mysql_store_result=true) => MySQL.Cursor
 
-Execute a prepared statement, optionally passing `args` to be bound as parameters (like `?` in the sql).
+Execute a prepared statement, optionally passing `params` to be bound as parameters (like `?` in the sql).
 Returns a `Cursor` object, which iterates resultset rows and satisfies the `Tables.jl` interface, meaning
 results can be sent to any valid sink function (`DataFrame(cursor)`, `CSV.write("results.csv", cursor)`, etc.).
 Specifying `mysql_store_result=false` will avoid buffering the full resultset to the client after executing
 the query, which has memory use advantages, though ties up the database server since resultset rows must be
 fetched one at a time.
 """
-function DBInterface.execute!(stmt::Statement, args...; mysql_store_result::Bool=true, kw...)
+function DBInterface.execute(stmt::Statement, params=(); mysql_store_result::Bool=true)
     checkstmt(stmt)
-    kwcheck(kw)
-    paramcheck(stmt, args)
+    paramcheck(stmt, params)
     clear!(stmt.conn)
-    if length(args) > 0
+    if length(params) > 0
         foreach(1:stmt.nparams) do i
-            bind!(stmt.bindhelpers[i], stmt.binds, i, args[i])
+            bind!(stmt.bindhelpers[i], stmt.binds, i, params[i])
         end
         API.bindparam(stmt.stmt, stmt.binds)
     end

test/runtests.jl

@@ -6,10 +6,10 @@ DBInterface.close!(conn)
 # load host/user + options from file
 conn = DBInterface.connect(MySQL.Connection, "", "", ""; option_file="my.ini")
 
-DBInterface.execute!(conn, "DROP DATABASE if exists mysqltest")
-DBInterface.execute!(conn, "CREATE DATABASE mysqltest")
-DBInterface.execute!(conn, "use mysqltest")
-DBInterface.execute!(conn, """CREATE TABLE Employee
+DBInterface.execute(conn, "DROP DATABASE if exists mysqltest")
+DBInterface.execute(conn, "CREATE DATABASE mysqltest")
+DBInterface.execute(conn, "use mysqltest")
+DBInterface.execute(conn, """CREATE TABLE Employee
                  (
                      ID INT NOT NULL AUTO_INCREMENT,
                      OfficeNo TINYINT,
@@ -30,7 +30,7 @@ DBInterface.execute!(conn, """CREATE TABLE Employee
                      PRIMARY KEY (ID)
                  );""")
 
-DBInterface.execute!(conn, """INSERT INTO Employee (OfficeNo, DeptNo, EmpNo, Wage, Salary, Rate, LunchTime, JoinDate, LastLogin, LastLogin2, Initial, Name, Photo, JobType, Senior)
+DBInterface.execute(conn, """INSERT INTO Employee (OfficeNo, DeptNo, EmpNo, Wage, Salary, Rate, LunchTime, JoinDate, LastLogin, LastLogin2, Initial, Name, Photo, JobType, Senior)
                  VALUES
                  (1, 2, 1301, 3.14, 10000.50, 1.001, '12:00:00', '2015-8-3', '2015-9-5 12:31:30', '2015-9-5 12:31:30', 'A', 'John', 'abc', 'HR', b'1'),
                  (1, 2, 1422, 3.14, 20000.25, 2.002, '13:00:00', '2015-8-4', '2015-10-12 13:12:14', '2015-10-12 13:12:14', 'B', 'Tom', 'def', 'HR', b'1'),
@@ -57,7 +57,7 @@ expected = (
   Senior     = Union{Missing, MySQL.API.Bit}[MySQL.API.Bit(1), MySQL.API.Bit(1), MySQL.API.Bit(0), MySQL.API.Bit(1)],
 )
 
-cursor = DBInterface.execute!(conn, "select * from Employee")
+cursor = DBInterface.execute(conn, "select * from Employee")
 @test DBInterface.lastrowid(cursor) == 1
 @test eltype(cursor) == MySQL.TextRow
 @test Tables.istable(cursor)
@@ -75,14 +75,14 @@ for (i, prop) in enumerate(propertynames(row))
     @test getproperty(row, prop) == row[prop] == row[i] == expected[prop][1]
 end
 
-res = DBInterface.execute!(conn, "select * from Employee") |> columntable
+res = DBInterface.execute(conn, "select * from Employee") |> columntable
 @test length(res) == 16
 @test length(res[1]) == 4
 @test res == expected
 
 # as a prepared statement
 stmt = DBInterface.prepare(conn, "select * from Employee")
-cursor = DBInterface.execute!(stmt)
+cursor = DBInterface.execute(stmt)
 @test DBInterface.lastrowid(cursor) == 1
 @test eltype(cursor) == MySQL.Row
 @test Tables.istable(cursor)
@@ -100,15 +100,15 @@ for (i, prop) in enumerate(propertynames(row))
     @test getproperty(row, prop) == row[prop] == row[i] == expected[prop][1]
 end
 
-res = DBInterface.execute!(stmt) |> columntable
+res = DBInterface.execute(stmt) |> columntable
 @test length(res) == 16
 @test length(res[1]) == 4
 @test res == expected
 
 @test DBInterface.close!(stmt) === nothing
 
 # insert null row
-DBInterface.execute!(conn, "INSERT INTO Employee () VALUES ();")
+DBInterface.execute(conn, "INSERT INTO Employee () VALUES ();")
 for i = 1:length(expected)
     if i == 1
         push!(expected[i], 5)
@@ -118,7 +118,7 @@ for i = 1:length(expected)
     end
 end
 
-res = DBInterface.execute!(conn, "select * from Employee") |> columntable
+res = DBInterface.execute(conn, "select * from Employee") |> columntable
 @test length(res) == 16
 @test length(res[1]) == 5
 for i = 1:length(expected)
@@ -128,7 +128,7 @@ for i = 1:length(expected)
 end
 
 stmt = DBInterface.prepare(conn, "select * from Employee")
-res = DBInterface.execute!(stmt) |> columntable
+res = DBInterface.execute(stmt) |> columntable
 DBInterface.close!(stmt)
 @test length(res) == 16
 @test length(res[1]) == 5
@@ -139,7 +139,7 @@ for i = 1:length(expected)
 end
 
 # now test insert/parameter binding
-DBInterface.execute!(conn, "DELETE FROM Employee")
+DBInterface.execute(conn, "DELETE FROM Employee")
 for i = 1:length(expected)
     if i != 11
         pop!(expected[i])
@@ -150,10 +150,10 @@ stmt = DBInterface.prepare(conn,
     "INSERT INTO Employee (OfficeNo, DeptNo, EmpNo, Wage, Salary, Rate, LunchTime, JoinDate, LastLogin, LastLogin2, Initial, Name, Photo, JobType, Senior)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
 
-DBInterface.executemany!(stmt, Base.structdiff(expected, NamedTuple{(:ID,)})...)
+DBInterface.executemany(stmt, Base.structdiff(expected, NamedTuple{(:ID,)}))
 
 stmt2 = DBInterface.prepare(conn, "select * from Employee")
-res = DBInterface.execute!(stmt2) |> columntable
+res = DBInterface.execute(stmt2) |> columntable
 DBInterface.close!(stmt2)
 @test length(res) == 16
 @test length(res[1]) == 4
@@ -163,11 +163,11 @@ for i = 1:length(expected)
     end
 end
 
-DBInterface.execute!(stmt, missing, missing, missing, missing, missing, missing, missing, missing, missing, DateTime("2015-09-05T12:31:30"), missing, missing, missing, missing, missing)
+DBInterface.execute(stmt, [missing, missing, missing, missing, missing, missing, missing, missing, missing, DateTime("2015-09-05T12:31:30"), missing, missing, missing, missing, missing])
 DBInterface.close!(stmt)
 
 stmt = DBInterface.prepare(conn, "select * from Employee")
-res = DBInterface.execute!(stmt) |> columntable
+res = DBInterface.execute(stmt) |> columntable
 DBInterface.close!(stmt)
 for i = 1:length(expected)
     if i != 11 && i != 1
@@ -176,20 +176,20 @@ for i = 1:length(expected)
 end
 
 # mysql_use_result
-res = DBInterface.execute!(conn, "select DeptNo, OfficeNo from Employee"; mysql_store_result=false) |> columntable
+res = DBInterface.execute(conn, "select DeptNo, OfficeNo from Employee"; mysql_store_result=false) |> columntable
 @test length(res) == 2
 @test length(res[1]) == 5
 @test isequal(res.OfficeNo, [1, 1, 1, 1, missing])
 
 stmt = DBInterface.prepare(conn, "select DeptNo, OfficeNo from Employee")
-res = DBInterface.execute!(stmt; mysql_store_result=false) |> columntable
+res = DBInterface.execute(stmt; mysql_store_result=false) |> columntable
 DBInterface.close!(stmt)
 @test length(res) == 2
 @test length(res[1]) == 5
 @test isequal(res.OfficeNo, [1, 1, 1, 1, missing])
 
 stmt = DBInterface.prepare(conn, "select DeptNo, OfficeNo from Employee where OfficeNo = ?")
-res = DBInterface.execute!(stmt, 1; mysql_store_result=false) |> columntable
+res = DBInterface.execute(stmt, 1; mysql_store_result=false) |> columntable
 DBInterface.close!(stmt)
 @test length(res) == 2
 @test length(res[1]) == 4