sqlite3 1.5.0.rc1-x86_64-linux

data/test/test_integration_statement.rb

@@ -0,0 +1,194 @@
+require 'helper'
+
+class TC_Statement < SQLite3::TestCase
+  def setup
+    @db = SQLite3::Database.new(":memory:")
+    @db.transaction do
+      @db.execute "create table foo ( a integer primary key, b text )"
+      @db.execute "insert into foo ( b ) values ( 'foo' )"
+      @db.execute "insert into foo ( b ) values ( 'bar' )"
+      @db.execute "insert into foo ( b ) values ( 'baz' )"
+    end
+    @stmt = @db.prepare( "select * from foo where a in ( ?, :named )" )
+  end
+
+  def teardown
+    @stmt.close
+    @db.close
+  end
+
+  def test_remainder_empty
+    assert_equal "", @stmt.remainder
+  end
+
+  def test_remainder_nonempty
+    called = false
+    @db.prepare( "select * from foo;\n blah" ) do |stmt|
+      called = true
+      assert_equal "\n blah", stmt.remainder
+    end
+    assert called
+  end
+
+  def test_bind_params_empty
+    assert_nothing_raised { @stmt.bind_params }
+    assert @stmt.execute!.empty?
+  end
+
+  def test_bind_params_array
+    @stmt.bind_params 1, 2
+    assert_equal 2, @stmt.execute!.length
+  end
+
+  def test_bind_params_hash
+    @stmt.bind_params ":named" => 2
+    assert_equal 1, @stmt.execute!.length
+  end
+
+  def test_bind_params_hash_without_colon
+    @stmt.bind_params "named" => 2
+    assert_equal 1, @stmt.execute!.length
+  end
+
+  def test_bind_params_hash_as_symbol
+    @stmt.bind_params :named => 2
+    assert_equal 1, @stmt.execute!.length
+  end
+
+  def test_bind_params_mixed
+    @stmt.bind_params( 1, ":named" => 2 )
+    assert_equal 2, @stmt.execute!.length
+  end
+
+  def test_bind_param_by_index
+    @stmt.bind_params( 1, 2 )
+    assert_equal 2, @stmt.execute!.length
+  end
+
+  def test_bind_param_by_name_bad
+    assert_raise( SQLite3::Exception ) { @stmt.bind_param( "@named", 2 ) }
+  end
+
+  def test_bind_param_by_name_good
+    @stmt.bind_param( ":named", 2 )
+    assert_equal 1, @stmt.execute!.length
+  end
+
+  def test_bind_param_with_various_types
+    @db.transaction do
+      @db.execute "create table all_types ( a integer primary key, b float, c string, d integer )"
+      @db.execute "insert into all_types ( b, c, d ) values ( 1.4, 'hello', 68719476735 )"
+    end
+
+    assert_equal 1, @db.execute( "select * from all_types where b = ?", 1.4 ).length
+    assert_equal 1, @db.execute( "select * from all_types where c = ?", 'hello').length
+    assert_equal 1, @db.execute( "select * from all_types where d = ?", 68719476735).length
+  end
+
+  def test_execute_no_bind_no_block
+    assert_instance_of SQLite3::ResultSet, @stmt.execute
+  end
+
+  def test_execute_with_bind_no_block
+    assert_instance_of SQLite3::ResultSet, @stmt.execute( 1, 2 )
+  end
+
+  def test_execute_no_bind_with_block
+    called = false
+    @stmt.execute { |row| called = true }
+    assert called
+  end
+
+  def test_execute_with_bind_with_block
+    called = 0
+    @stmt.execute( 1, 2 ) { |row| called += 1 }
+    assert_equal 1, called
+  end
+
+  def test_reexecute
+    r = @stmt.execute( 1, 2 )
+    assert_equal 2, r.to_a.length
+    assert_nothing_raised { r = @stmt.execute( 1, 2 ) }
+    assert_equal 2, r.to_a.length
+  end
+
+  def test_execute_bang_no_bind_no_block
+    assert @stmt.execute!.empty?
+  end
+
+  def test_execute_bang_with_bind_no_block
+    assert_equal 2, @stmt.execute!( 1, 2 ).length
+  end
+
+  def test_execute_bang_no_bind_with_block
+    called = 0
+    @stmt.execute! { |row| called += 1 }
+    assert_equal 0, called
+  end
+
+  def test_execute_bang_with_bind_with_block
+    called = 0
+    @stmt.execute!( 1, 2 ) { |row| called += 1 }
+    assert_equal 2, called
+  end
+
+  def test_columns
+    c1 = @stmt.columns
+    c2 = @stmt.columns
+    assert_same c1, c2
+    assert_equal 2, c1.length
+  end
+
+  def test_columns_computed
+    called = false
+    @db.prepare( "select count(*) from foo" ) do |stmt|
+      called = true
+      assert_equal [ "count(*)" ], stmt.columns
+    end
+    assert called
+  end
+
+  def test_types
+    t1 = @stmt.types
+    t2 = @stmt.types
+    assert_same t1, t2
+    assert_equal 2, t1.length
+  end
+
+  def test_types_computed
+    called = false
+    @db.prepare( "select count(*) from foo" ) do |stmt|
+      called = true
+      assert_equal [ nil ], stmt.types
+    end
+    assert called
+  end
+
+  def test_close
+    stmt = @db.prepare( "select * from foo" )
+    assert !stmt.closed?
+    stmt.close
+    assert stmt.closed?
+    assert_raise( SQLite3::Exception ) { stmt.execute }
+    assert_raise( SQLite3::Exception ) { stmt.execute! }
+    assert_raise( SQLite3::Exception ) { stmt.close }
+    assert_raise( SQLite3::Exception ) { stmt.bind_params 5 }
+    assert_raise( SQLite3::Exception ) { stmt.bind_param 1, 5 }
+    assert_raise( SQLite3::Exception ) { stmt.columns }
+    assert_raise( SQLite3::Exception ) { stmt.types }
+  end
+
+  def test_committing_tx_with_statement_active
+    called = false
+    @db.prepare( "select count(*) from foo" ) do |stmt|
+      called = true
+      count = stmt.execute!.first.first.to_i
+      @db.transaction do
+        @db.execute "insert into foo ( b ) values ( 'hello' )"
+      end
+      new_count = stmt.execute!.first.first.to_i
+      assert_equal new_count, count+1
+    end
+    assert called
+  end
+end

data/test/test_result_set.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+module SQLite3
+  class TestResultSet < SQLite3::TestCase
+    def test_each_hash
+      db = SQLite3::Database.new ':memory:'
+      db.execute "create table foo ( a integer primary key, b text )"
+      list = ('a'..'z').to_a
+      list.each do |t|
+        db.execute "insert into foo (b) values (\"#{t}\")"
+      end
+
+      rs = db.prepare('select * from foo').execute
+      rs.each_hash do |hash|
+        assert_equal list[hash['a'] - 1], hash['b']
+      end
+    end
+
+    def test_next_hash
+      db = SQLite3::Database.new ':memory:'
+      db.execute "create table foo ( a integer primary key, b text )"
+      list = ('a'..'z').to_a
+      list.each do |t|
+        db.execute "insert into foo (b) values (\"#{t}\")"
+      end
+
+      rs = db.prepare('select * from foo').execute
+      rows = []
+      while row = rs.next_hash
+        rows << row
+      end
+      rows.each do |hash|
+        assert_equal list[hash['a'] - 1], hash['b']
+      end
+    end
+  end
+end

data/test/test_sqlite3.rb

@@ -0,0 +1,25 @@
+require 'helper'
+
+module SQLite3
+  class TestSQLite3 < SQLite3::TestCase
+    def test_libversion
+      assert_not_nil SQLite3.libversion
+    end
+
+    def test_threadsafe
+      assert_not_nil SQLite3.threadsafe
+    end
+
+    def test_threadsafe?
+      if SQLite3.threadsafe > 0
+        assert SQLite3.threadsafe?
+      else
+        refute SQLite3.threadsafe?
+      end
+    end
+
+    def test_version_strings
+      assert_equal(SQLite3::VERSION, SQLite3::VersionProxy::STRING)
+    end
+  end
+end

data/test/test_statement.rb

@@ -0,0 +1,263 @@
+require 'helper'
+
+module SQLite3
+  class TestStatement < SQLite3::TestCase
+    def setup
+      @db   = SQLite3::Database.new(':memory:')
+      @stmt = SQLite3::Statement.new(@db, "select 'foo'")
+    end
+
+    def test_double_close_does_not_segv
+      @db.execute 'CREATE TABLE "things" ("number" float NOT NULL)'
+
+      stmt = @db.prepare 'INSERT INTO things (number) VALUES (?)'
+      assert_raises(SQLite3::ConstraintException) { stmt.execute(nil) }
+
+      stmt.close
+
+      assert_raises(SQLite3::Exception) { stmt.close }
+    end
+
+    def test_raises_type_error
+      assert_raises(TypeError) do
+        SQLite3::Statement.new( @db, nil )
+      end
+    end
+
+    def test_insert_duplicate_records
+      @db.execute 'CREATE TABLE "things" ("name" varchar(20) CONSTRAINT "index_things_on_name" UNIQUE)'
+      stmt = @db.prepare("INSERT INTO things(name) VALUES(?)")
+      stmt.execute('ruby')
+
+      exception = assert_raises(SQLite3::ConstraintException) { stmt.execute('ruby') }
+      # SQLite 3.8.2 returns new error message:
+      #   UNIQUE constraint failed: *table_name*.*column_name*
+      # Older versions of SQLite return:
+      #   column *column_name* is not unique
+      assert_match(/(column(s)? .* (is|are) not unique|UNIQUE constraint failed: .*)/, exception.message)
+    end
+
+    ###
+    # This method may not exist depending on how sqlite3 was compiled
+    def test_database_name
+      @db.execute('create table foo(text BLOB)')
+      @db.execute('insert into foo(text) values (?)',SQLite3::Blob.new('hello'))
+      stmt = @db.prepare('select text from foo')
+      if stmt.respond_to?(:database_name)
+        assert_equal 'main', stmt.database_name(0)
+      end
+    end
+
+    def test_prepare_blob
+      @db.execute('create table foo(text BLOB)')
+      stmt = @db.prepare('insert into foo(text) values (?)')
+      stmt.bind_param(1, SQLite3::Blob.new('hello'))
+      stmt.step
+      stmt.close
+    end
+
+    def test_select_blob
+      @db.execute('create table foo(text BLOB)')
+      @db.execute('insert into foo(text) values (?)',SQLite3::Blob.new('hello'))
+      assert_equal 'hello', @db.execute('select * from foo').first.first
+    end
+
+    def test_new
+      assert @stmt
+    end
+
+    def test_new_closed_handle
+      @db = SQLite3::Database.new(':memory:')
+      @db.close
+      assert_raises(ArgumentError) do
+        SQLite3::Statement.new(@db, 'select "foo"')
+      end
+    end
+
+    def test_new_with_remainder
+      stmt = SQLite3::Statement.new(@db, "select 'foo';bar")
+      assert_equal 'bar', stmt.remainder
+    end
+
+    def test_empty_remainder
+      assert_equal '', @stmt.remainder
+    end
+
+    def test_close
+      @stmt.close
+      assert @stmt.closed?
+    end
+
+    def test_double_close
+      @stmt.close
+      assert_raises(SQLite3::Exception) do
+        @stmt.close
+      end
+    end
+
+    def test_bind_param_string
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, "hello")
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_bind_param_int
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 10)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [10], result
+    end
+
+    def test_bind_nil
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, nil)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [nil], result
+    end
+
+    def test_bind_blob
+      @db.execute('create table foo(text BLOB)')
+      stmt = SQLite3::Statement.new(@db, 'insert into foo(text) values (?)')
+      stmt.bind_param(1, SQLite3::Blob.new('hello'))
+      stmt.execute
+      row = @db.execute('select * from foo')
+
+      assert_equal ['hello'], row.first
+      assert_equal ['blob'], row.first.types
+    end
+
+    def test_bind_64
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 2 ** 31)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [2 ** 31], result
+    end
+
+    def test_bind_double
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 2.2)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [2.2], result
+    end
+
+    def test_named_bind
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param(':foo', 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_no_colon
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param('foo', 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_symbol
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param(:foo, 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_not_found
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      assert_raises(SQLite3::Exception) do
+        stmt.bind_param('bar', 'hello')
+      end
+    end
+
+    def test_each
+      r = nil
+      @stmt.each do |row|
+        r = row
+      end
+      assert_equal(['foo'], r)
+    end
+
+    def test_reset!
+      r = []
+      @stmt.each { |row| r << row }
+      @stmt.reset!
+      @stmt.each { |row| r << row }
+      assert_equal [['foo'], ['foo']], r
+    end
+
+    def test_step
+      r = @stmt.step
+      assert_equal ['foo'], r
+    end
+
+    def test_step_twice
+      assert_not_nil @stmt.step
+      assert !@stmt.done?
+      assert_nil @stmt.step
+      assert @stmt.done?
+
+      @stmt.reset!
+      assert !@stmt.done?
+    end
+
+    def test_step_never_moves_past_done
+      10.times { @stmt.step }
+      @stmt.done?
+    end
+
+    def test_column_count
+      assert_equal 1, @stmt.column_count
+    end
+
+    def test_column_name
+      assert_equal "'foo'", @stmt.column_name(0)
+      assert_nil @stmt.column_name(10)
+    end
+
+    def test_bind_parameter_count
+      stmt = SQLite3::Statement.new(@db, "select ?, ?, ?")
+      assert_equal 3, stmt.bind_parameter_count
+    end
+
+    def test_execute_with_varargs
+      stmt = @db.prepare('select ?, ?')
+      assert_equal [[nil, nil]], stmt.execute(nil, nil).to_a
+    end
+
+    def test_execute_with_hash
+      stmt = @db.prepare('select :n, :h')
+      assert_equal [[10, nil]], stmt.execute('n' => 10, 'h' => nil).to_a
+    end
+
+    def test_with_error
+      @db.execute('CREATE TABLE "employees" ("name" varchar(20) NOT NULL CONSTRAINT "index_employees_on_name" UNIQUE)')
+      stmt = @db.prepare("INSERT INTO Employees(name) VALUES(?)")
+      stmt.execute('employee-1')
+      stmt.execute('employee-1') rescue SQLite3::ConstraintException
+      stmt.reset!
+      assert stmt.execute('employee-2')
+    end
+
+    def test_clear_bindings!
+      stmt = @db.prepare('select ?, ?')
+      stmt.bind_param 1, "foo"
+      stmt.bind_param 2, "bar"
+
+      # We can't fetch bound parameters back out of sqlite3, so just call
+      # the clear_bindings! method and assert that nil is returned
+      stmt.clear_bindings!
+
+      while x = stmt.step
+        assert_equal [nil, nil], x
+      end
+    end
+  end
+end

data/test/test_statement_execute.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+module SQLite3
+  class TestStatementExecute < SQLite3::TestCase
+    def setup
+      @db   = SQLite3::Database.new(':memory:')
+      @db.execute_batch(
+        "CREATE TABLE items (id integer PRIMARY KEY, number integer)")
+    end
+
+    def test_execute_insert
+      ps = @db.prepare("INSERT INTO items (number) VALUES (:n)")
+      ps.execute('n'=>10)
+      assert_equal 1, @db.get_first_value("SELECT count(*) FROM items")
+      ps.close
+    end
+
+    def test_execute_update
+      @db.execute("INSERT INTO items (number) VALUES (?)", [10])
+
+      ps = @db.prepare("UPDATE items SET number = :new WHERE number = :old")
+      ps.execute('old'=>10, 'new'=>20)
+      assert_equal 20, @db.get_first_value("SELECT number FROM items")
+      ps.close
+    end
+
+    def test_execute_delete
+      @db.execute("INSERT INTO items (number) VALUES (?)", [20])
+      ps = @db.prepare("DELETE FROM items WHERE number = :n")
+      ps.execute('n' => 20)
+      assert_equal 0, @db.get_first_value("SELECT count(*) FROM items")
+      ps.close
+    end
+  end
+end