sqlite3 1.7.1 → 2.0.2

data/test/test_integration_statement.rb

@@ -1,194 +0,0 @@
-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.5, 'hello', 68719476735 )"
-    end
-
-    assert_equal 1, @db.execute( "select * from all_types where b = ?", 1.5 ).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_pragmas.rb

@@ -1,22 +0,0 @@
-require 'helper'
-
-module SQLite3
-  class TestPragmas < SQLite3::TestCase
-    def setup
-      super
-      @db = SQLite3::Database.new(":memory:")
-    end
-
-    def test_get_boolean_pragma
-      refute(@db.get_boolean_pragma("read_uncommitted"))
-    end
-
-    def test_set_boolean_pragma
-      @db.set_boolean_pragma("read_uncommitted", 1)
-
-      assert(@db.get_boolean_pragma("read_uncommitted"))
-    ensure
-      @db.set_boolean_pragma("read_uncommitted", 0)
-    end
-  end
-end

data/test/test_result_set.rb

@@ -1,47 +0,0 @@
-require 'helper'
-
-module SQLite3
-  class TestResultSet < SQLite3::TestCase
-    def setup
-      @db = SQLite3::Database.new ':memory:'
-      super
-    end
-
-    def teardown
-      super
-      @db.close
-    end
-
-    def test_each_hash
-      @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
-      rs.close
-    end
-
-    def test_next_hash
-      @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
-      rs.close
-    end
-  end
-end

data/test/test_sqlite3.rb

@@ -1,30 +0,0 @@
-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
-      skip if SQLite3::VERSION.include?("test") # see set-version-to-timestamp rake task
-      assert_equal(SQLite3::VERSION, SQLite3::VersionProxy::STRING)
-    end
-
-    def test_compiled_version_and_loaded_version
-      assert_equal(SQLite3::SQLITE_VERSION, SQLite3::SQLITE_LOADED_VERSION)
-    end
-  end
-end

data/test/test_statement.rb

@@ -1,290 +0,0 @@
-require 'helper'
-
-module SQLite3
-  class TestStatement < SQLite3::TestCase
-    def setup
-      @db   = SQLite3::Database.new(':memory:')
-      @stmt = SQLite3::Statement.new(@db, "select 'foo'")
-    end
-
-    def teardown
-      @stmt.close if !@stmt.closed?
-      @db.close
-    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)
-
-      stmt.close
-    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
-      stmt.close
-    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
-      stmt.close
-    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
-      stmt.close
-    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
-      stmt.close
-    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
-      stmt.close
-    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')
-      stmt.close
-
-      assert_equal ['hello'], row.first
-      capture_io do # hush deprecation warning
-        assert_equal ['blob'], row.first.types
-      end
-    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
-      stmt.close
-    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
-      stmt.close
-    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
-      stmt.close
-    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
-      stmt.close
-    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
-      stmt.close
-    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
-      stmt.close
-    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
-      stmt.close
-    end
-
-    def test_execute_with_varargs
-      stmt = @db.prepare('select ?, ?')
-      assert_equal [[nil, nil]], stmt.execute(nil, nil).to_a
-      stmt.close
-    end
-
-    def test_execute_with_hash
-      stmt = @db.prepare('select :n, :h')
-      assert_equal [[10, nil]], stmt.execute('n' => 10, 'h' => nil).to_a
-      stmt.close
-    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')
-      stmt.close
-    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
-
-      stmt.close
-    end
-  end
-end

data/test/test_statement_execute.rb

@@ -1,39 +0,0 @@
-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 teardown
-      @db.close
-    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