sqlite3-ruby 1.2.5-x86-mswin32

data/test/helper.rb

@@ -0,0 +1,67 @@
+# add lib folder to the path
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'sqlite3'
+
+require 'rubygems'
+require 'test/unit'
+
+# define mocks to be used
+require 'mocha'
+
+class Driver < Mocha::Mock
+  def initialize
+    super
+    stubs( :open ).returns([0, 'cookie'])
+    stubs( :close ).returns(0)
+    stubs( :complete? ).returns(0)
+    stubs( :errmsg ).returns('')
+    stubs( :errcode ).returns(0)
+    stubs( :trace ).returns(nil)
+    stubs( :set_authorizer ).returns(0)
+    stubs( :prepare ).returns([0, 'stmt', 'remainder'])
+    stubs( :finalize ).returns(0)
+    stubs( :changes ).returns(14)
+    stubs( :total_changes ).returns(28)
+    stubs( :interrupt ).returns(0)
+  end
+end
+
+class MockResultSet < Mocha::Mock
+  def initialize
+    super
+    stubs( :each ).yields(['foo'])
+    stubs( :columns ).returns(['name'])
+  end
+end
+
+class Statement < Mocha::Mock
+  attr_reader :handle
+  attr_reader :sql
+  attr_reader :last_result
+
+  def initialize( handle, sql )
+    super()
+    @handle = handle
+    @sql = sql
+    stubs( :close ).returns(0)
+    stubs( :remainder ).returns('')
+    stubs( :execute ).returns(MockResultSet.new)
+  end
+end
+
+# UTF conversion extensions
+class String
+  def to_utf16(terminate=false)
+    self.split(//).map { |c| c[0] }.pack("v*") +
+      (terminate ? "\0\0" : "")
+  end
+
+  def from_utf16
+    result = ""
+    length.times do |i|
+      result << self[i,1] if i % 2 == 0 && self[i] != 0
+    end
+    result
+  end
+end

data/test/native-vs-dl.rb

@@ -0,0 +1,126 @@
+$:.unshift "../lib", "../ext/sqlite3_api"
+
+require 'sqlite3'
+
+require 'benchmark'
+
+N = 1000
+
+$VERBOSE=nil
+
+puts "database creation..."
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    N.times do
+      File.delete "test.db" rescue nil
+      SQLite3::Database.open( "test.db", :driver => "DL" ).close
+    end
+  end
+  x.report('native') do
+    N.times do
+      File.delete "test.db" rescue nil
+      SQLite3::Database.open( "test.db", :driver => "Native" ).close
+    end
+  end
+end
+File.delete "test.db" rescue nil
+
+SQLite3::Database.open( "test.db" ).close
+
+puts
+puts "database open..."
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    N.times do
+      SQLite3::Database.open( "test.db", :driver => "DL" ).close
+    end
+  end
+  x.report('native') do
+    N.times do
+      SQLite3::Database.open( "test.db", :driver => "Native" ).close
+    end
+  end
+end
+File.delete "test.db" rescue nil
+
+dl = SQLite3::Database.open( "test-dl.db", :driver => "DL" )
+native = SQLite3::Database.open( "test-native.db", :driver => "Native" )
+
+dl.execute "create table foo (a,b)"
+native.execute "create table foo (a,b)"
+
+puts
+puts "insertions"
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    dl.transaction do
+      N.times do |i|
+        dl.execute "insert into foo values (#{i}, #{i+1})"
+      end
+    end
+  end
+  x.report('native') do
+    native.transaction do
+      N.times do |i|
+        native.execute "insert into foo values (#{i}, #{i+1})"
+      end
+    end
+  end
+end
+
+puts
+puts "insertions using prepared statement"
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    dl.transaction do
+      dl.prepare "insert into foo values (?,?)" do |stmt|
+        N.times { |i| stmt.execute i, i+1 }
+      end
+    end
+  end
+  x.report('native') do
+    native.transaction do
+      native.prepare( "insert into foo values (?,?)" ) do |stmt|
+        N.times { |i| stmt.execute i, i+1 }
+      end
+    end
+  end
+end
+
+dl.close
+native.close
+File.delete "test-dl.db" rescue nil
+File.delete "test-native.db" rescue nil
+
+dl = SQLite3::Database.open( "test-dl.db", :driver => "DL" )
+native = SQLite3::Database.open( "test-native.db", :driver => "Native" )
+
+dl.execute "create table foo (a,b)"
+dl.execute "insert into foo values (1,2)"
+dl.execute "insert into foo values (3,4)"
+dl.execute "insert into foo values (5,6)"
+
+native.execute "create table foo (a,b)"
+native.execute "insert into foo values (1,2)"
+native.execute "insert into foo values (3,4)"
+native.execute "insert into foo values (5,6)"
+
+puts
+puts "queries"
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    N.times do
+      dl.execute "select * from foo"
+    end
+  end
+  x.report('native') do
+    N.times do
+      native.execute "select * from foo"
+    end
+  end
+end
+
+dl.close
+native.close
+File.delete "test-dl.db" rescue nil
+File.delete "test-native.db" rescue nil

data/test/test_database.rb

@@ -0,0 +1,217 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TC_Database_Init < Test::Unit::TestCase
+  def test_new
+    # any_instance fails here...
+    driver = Driver.new
+    driver.expects(:open).once.with('foo.db', false).returns([0, 'cookie'])
+    Driver.stubs(:new).returns(driver)
+    db = SQLite3::Database.new( 'foo.db', :driver => Driver )
+    assert !db.closed?
+    assert !db.results_as_hash
+    assert !db.type_translation
+  end
+  
+  def test_new_with_block
+    driver = Driver.new
+    driver.expects(:open).once.with('foo.db', false).returns([0, 'cookie'])
+    Driver.stubs(:new).returns(driver)
+    returned_db = SQLite3::Database.new( "foo.db", :driver => Driver ) do |db|
+      assert !db.closed?
+      assert !db.results_as_hash
+      assert !db.type_translation
+    end
+    assert returned_db.closed?
+  end
+
+  def test_open
+    driver = Driver.new
+    driver.expects(:open).once.with('foo.db', false).returns([0, 'cookie'])
+    Driver.stubs(:new).returns(driver)
+    db = SQLite3::Database.open( "foo.db", :driver => Driver )
+    assert !db.closed?
+    assert !db.results_as_hash
+    assert !db.type_translation
+  end
+  
+  def test_open_with_block
+    driver = Driver.new
+    driver.expects(:open).once.with('foo.db', false).returns([0, 'cookie'])
+    Driver.stubs(:new).returns(driver)
+    returned_db = SQLite3::Database.open( "foo.db", :driver => Driver ) do |db|
+      assert !db.closed?
+      assert !db.results_as_hash
+      assert !db.type_translation
+    end
+    assert returned_db.closed?
+  end
+  
+  def test_with_type_translation
+    db = SQLite3::Database.open( "foo.db", :driver => Driver,
+      :type_translation => true )
+    assert db.type_translation
+  end
+  
+  def test_with_results_as_hash
+    db = SQLite3::Database.open( "foo.db", :driver => Driver,
+      :results_as_hash => true )
+    assert db.results_as_hash
+  end
+  
+  def test_with_type_translation_and_results_as_hash
+    db = SQLite3::Database.open( "foo.db", :driver => Driver,
+      :results_as_hash => true,
+      :type_translation => true )
+    assert db.results_as_hash
+    assert db.type_translation
+  end
+end
+
+class TC_Database < Test::Unit::TestCase
+  def setup
+    @db = SQLite3::Database.open( "foo.db",
+      :driver => Driver, :statement_factory => Statement )
+  end
+
+  def test_quote
+    assert_equal "''one''two''three''", SQLite3::Database.quote(
+      "'one'two'three'" )
+  end
+
+  def test_complete
+    Driver.any_instance.expects(:complete?)
+    @db.complete? "foo"
+  end
+
+  def test_errmsg
+    Driver.any_instance.expects(:errmsg)
+    @db.errmsg
+  end
+
+  def test_errcode
+    Driver.any_instance.expects(:errcode)
+    @db.errcode
+  end
+
+  def test_translator
+    translator = @db.translator
+    assert_instance_of SQLite3::Translator, translator
+  end
+
+  def test_close
+    Driver.any_instance.expects(:close).returns(0)
+    @db.close
+    assert @db.closed?
+    Driver.any_instance.expects(:close).never
+    @db.close
+  end
+
+  def test_trace
+    Driver.any_instance.expects(:trace).with('cookie', 15)
+    @db.trace( 15 ) { "foo" }
+    # assert_equal 1, driver.mock_blocks[:trace].length
+  end
+
+  def test_authorizer
+    Driver.any_instance.expects(:set_authorizer).with('cookie', 15).returns(0)
+    @db.authorizer( 15 ) { "foo" }
+    # assert_equal 1, driver.mock_blocks[:set_authorizer].length
+  end
+
+  def test_prepare_no_block
+    Statement.any_instance.expects(:close).never
+    assert_nothing_raised { @db.prepare( "foo" ) }
+  end
+
+  def test_prepare_with_block
+    called = false
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:close).once
+    Statement.stubs(:new).returns(statement)
+    @db.prepare( "foo" ) { |stmt| called = true }
+    assert called
+  end
+
+  def test_execute_no_block
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new)
+    Statement.stubs(:new).returns(statement)
+    MockResultSet.any_instance.stubs(:inject).returns([['foo']])
+    result = @db.execute( "foo", "bar", "baz" )
+    assert_equal [["foo"]], result
+  end
+
+  def test_execute_with_block
+    called = false
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new)
+    Statement.stubs(:new).returns(statement)
+    @db.execute( "foo", "bar", "baz" ) do |row|
+      called = true
+      assert_equal ["foo"], row
+    end
+
+    assert called
+  end
+
+  def test_execute2_no_block
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new)
+    Statement.stubs(:new).returns(statement)
+    MockResultSet.any_instance.stubs(:inject).returns([['name'], ['foo']])
+    result = @db.execute2( "foo", "bar", "baz" )
+    assert_equal [["name"],["foo"]], result
+  end
+
+  def test_execute2_with_block
+    called = false
+    parts = [ ["name"],["foo"] ]
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new)
+    Statement.stubs(:new).returns(statement)
+    @db.execute2( "foo", "bar", "baz" ) do |row|
+      called = true
+      assert_equal parts.shift, row
+    end
+
+    assert called
+  end
+
+  def test_execute_batch
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new)
+    Statement.stubs(:new).returns(statement)
+    @db.execute_batch( "foo", "bar", "baz" )
+  end
+
+  def test_get_first_row
+    result = @db.get_first_row( "foo", "bar", "baz" )
+    assert_equal ["foo"], result
+  end
+
+  def test_get_first_value
+    result = @db.get_first_value( "foo", "bar", "baz" )
+    assert_equal "foo", result
+  end
+
+  def test_changes
+    Driver.any_instance.expects(:changes).returns(14)
+    assert_equal 14, @db.changes
+  end
+
+  def test_total_changes
+    Driver.any_instance.expects(:total_changes).returns(28)
+    assert_equal 28, @db.total_changes
+  end
+
+  def test_interrupt
+    Driver.any_instance.expects(:interrupt)
+    @db.interrupt
+  end
+end

data/test/test_errors.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TC_Errors < Test::Unit::TestCase
+  (1..26).each do |code|
+    define_method( "test_error_code_%02d" % code ) do
+      db = stub('database', :errmsg => 'message')
+      begin
+        SQLite3::Error.check( code, db )
+      rescue SQLite3::Exception => e
+        assert_instance_of SQLite3::EXCEPTIONS[code], e
+        assert_equal code, e.code
+        assert_equal code, e.class.code
+        assert_equal "message", e.message
+      end
+    end
+  end
+end

data/test/test_integration.rb

@@ -0,0 +1,542 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TC_Database_Integration < Test::Unit::TestCase
+  def setup
+    @db = SQLite3::Database.new( "test.db" )
+    @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
+  end
+
+  def teardown
+    @db.close
+    File.delete( "test.db" )
+  end
+
+  def test_table_info_with_type_translation_active
+    @db.type_translation = true
+    assert_nothing_raised { @db.table_info("foo") }
+  end
+
+  def test_table_info_with_defaults_for_version_3_3_8_and_higher
+    @db.transaction do
+      @db.execute "create table defaults_test ( a string default NULL, b string default 'Hello' )"
+      data = @db.table_info( "defaults_test" )
+      assert_equal({"name" => "a", "type" => "string", "dflt_value" => nil, "notnull" => "0", "cid" => "0", "pk" => "0"},
+        data[0])
+      assert_equal({"name" => "b", "type" => "string", "dflt_value" => "Hello", "notnull" => "0", "cid" => "1", "pk" => "0"},
+        data[1])
+    end
+  end
+
+  def test_table_info_without_defaults_for_version_3_3_8_and_higher
+    @db.transaction do
+      @db.execute "create table no_defaults_test ( a integer default 1, b integer )"
+      data = @db.table_info( "no_defaults_test" )
+      assert_equal({"name" => "a", "type" => "integer", "dflt_value" => "1", "notnull" => "0", "cid" => "0", "pk" => "0"},
+        data[0])
+      assert_equal({"name" => "b", "type" => "integer", "dflt_value" => nil, "notnull" => "0", "cid" => "1", "pk" => "0"},
+        data[1])
+    end
+  end
+
+  def test_complete_fail
+    assert !@db.complete?( "select * from foo" )
+  end
+  def test_complete_success
+    assert @db.complete?( "select * from foo;" )
+  end
+
+  def test_complete_fail_utf16
+    assert !@db.complete?( "select * from foo".to_utf16(false), true )
+  end
+
+  def test_complete_success_utf16
+    assert @db.complete?( "select * from foo;".to_utf16(true), true )
+  end
+
+  def test_errmsg
+    assert_equal "not an error", @db.errmsg
+  end
+
+  def test_errmsg_utf16
+    assert_equal "not an error".to_utf16, @db.errmsg(true)
+  end
+
+  def test_errcode
+    assert_equal 0, @db.errcode
+  end
+
+  def test_trace
+    result = nil
+    @db.trace( "data" ) { |data,sql| result = [ data, sql ]; 0 }
+    @db.execute "select * from foo"
+    assert_equal ["data","select * from foo"], result
+  end
+
+  def test_authorizer_okay
+    @db.authorizer( "data" ) { |data,type,a,b,c,d| 0 }
+    rows = @db.execute "select * from foo"
+    assert_equal 3, rows.length
+  end
+
+  def test_authorizer_error
+    @db.authorizer( "data" ) { |data,type,a,b,c,d| 1 }
+    assert_raise( SQLite3::AuthorizationException ) do
+      @db.execute "select * from foo"
+    end
+  end
+
+  def test_authorizer_silent
+    @db.authorizer( "data" ) { |data,type,a,b,c,d| 2 }
+    rows = @db.execute "select * from foo"
+    assert rows.empty?
+  end
+
+  def test_prepare_invalid_syntax
+    assert_raise( SQLite3::SQLException ) do
+      @db.prepare "select from foo"
+    end
+  end
+
+  def test_prepare_invalid_column
+    assert_raise( SQLite3::SQLException ) do
+      @db.prepare "select k from foo"
+    end
+  end
+
+  def test_prepare_invalid_table
+    assert_raise( SQLite3::SQLException ) do
+      @db.prepare "select * from barf"
+    end
+  end
+
+  def test_prepare_no_block
+    stmt = @db.prepare "select * from foo"
+    assert stmt.respond_to?(:execute)
+    stmt.close
+  end
+
+  def test_prepare_with_block
+    called = false
+    @db.prepare "select * from foo" do |stmt|
+      called = true
+      assert stmt.respond_to?(:execute)
+    end
+    assert called
+  end
+
+  def test_execute_no_block_no_bind_no_match
+    rows = @db.execute( "select * from foo where a > 100" )
+    assert rows.empty?
+  end
+
+  def test_execute_with_block_no_bind_no_match
+    called = false
+    @db.execute( "select * from foo where a > 100" ) do |row|
+      called = true
+    end
+    assert !called
+  end
+
+  def test_execute_no_block_with_bind_no_match
+    rows = @db.execute( "select * from foo where a > ?", 100 )
+    assert rows.empty?
+  end
+
+  def test_execute_with_block_with_bind_no_match
+    called = false
+    @db.execute( "select * from foo where a > ?", 100 ) do |row|
+      called = true
+    end
+    assert !called
+  end
+
+  def test_execute_no_block_no_bind_with_match
+    rows = @db.execute( "select * from foo where a = 1" )
+    assert_equal 1, rows.length
+  end
+
+  def test_execute_with_block_no_bind_with_match
+    called = 0
+    @db.execute( "select * from foo where a = 1" ) do |row|
+      called += 1
+    end
+    assert_equal 1, called
+  end
+
+  def test_execute_no_block_with_bind_with_match
+    rows = @db.execute( "select * from foo where a = ?", 1 )
+    assert_equal 1, rows.length
+  end
+
+  def test_execute_with_block_with_bind_with_match
+    called = 0
+    @db.execute( "select * from foo where a = ?", 1 ) do |row|
+      called += 1
+    end
+    assert_equal 1, called
+  end
+
+  def test_execute2_no_block_no_bind_no_match
+    columns, *rows = @db.execute2( "select * from foo where a > 100" )
+    assert rows.empty?
+    assert [ "a", "b" ], columns
+  end
+
+  def test_execute2_with_block_no_bind_no_match
+    called = 0
+    @db.execute2( "select * from foo where a > 100" ) do |row|
+      assert [ "a", "b" ], row unless called == 0
+      called += 1
+    end
+    assert_equal 1, called
+  end
+
+  def test_execute2_no_block_with_bind_no_match
+    columns, *rows = @db.execute2( "select * from foo where a > ?", 100 )
+    assert rows.empty?
+    assert [ "a", "b" ], columns
+  end
+
+  def test_execute2_with_block_with_bind_no_match
+    called = 0
+    @db.execute2( "select * from foo where a > ?", 100 ) do |row|
+      assert [ "a", "b" ], row unless called == 0
+      called += 1
+    end
+    assert_equal 1, called
+  end
+
+  def test_execute2_no_block_no_bind_with_match
+    columns, *rows = @db.execute2( "select * from foo where a = 1" )
+    assert_equal 1, rows.length
+    assert [ "a", "b" ], columns
+  end
+
+  def test_execute2_with_block_no_bind_with_match
+    called = 0
+    @db.execute2( "select * from foo where a = 1" ) do |row|
+      assert [ "a", "b" ], row unless called == 0
+      called += 1
+    end
+    assert_equal 2, called
+  end
+
+  def test_execute2_no_block_with_bind_with_match
+    columns, *rows = @db.execute2( "select * from foo where a = ?", 1 )
+    assert_equal 1, rows.length
+    assert [ "a", "b" ], columns
+  end
+
+  def test_execute2_with_block_with_bind_with_match
+    called = 0
+    @db.execute2( "select * from foo where a = ?", 1 ) do |row|
+      called += 1
+    end
+    assert_equal 2, called
+  end
+
+  def test_execute_batch_empty
+    assert_nothing_raised { @db.execute_batch "" }
+  end
+
+  def test_execute_batch_no_bind
+    @db.transaction do
+      @db.execute_batch <<-SQL
+        create table bar ( a, b, c );
+        insert into bar values ( 'one', 2, 'three' );
+        insert into bar values ( 'four', 5, 'six' );
+        insert into bar values ( 'seven', 8, 'nine' );
+      SQL
+    end
+    rows = @db.execute( "select * from bar" )
+    assert_equal 3, rows.length
+  end
+
+  def test_execute_batch_with_bind
+    @db.execute_batch( <<-SQL, 1 )
+      create table bar ( a, b, c );
+      insert into bar values ( 'one', 2, ? );
+      insert into bar values ( 'four', 5, ? );
+      insert into bar values ( 'seven', 8, ? );
+    SQL
+    rows = @db.execute( "select * from bar" ).map { |a,b,c| c }
+    assert_equal %w{1 1 1}, rows
+  end
+
+  def test_query_no_block_no_bind_no_match
+    result = @db.query( "select * from foo where a > 100" )
+    assert_nil result.next
+    result.close
+  end
+
+  def test_query_with_block_no_bind_no_match
+    r = nil
+    @db.query( "select * from foo where a > 100" ) do |result|
+      assert_nil result.next
+      r = result
+    end
+    assert r.closed?
+  end
+
+  def test_query_no_block_with_bind_no_match
+    result = @db.query( "select * from foo where a > ?", 100 )
+    assert_nil result.next
+    result.close
+  end
+
+  def test_query_with_block_with_bind_no_match
+    r = nil
+    @db.query( "select * from foo where a > ?", 100 ) do |result|
+      assert_nil result.next
+      r = result
+    end
+    assert r.closed?
+  end
+
+  def test_query_no_block_no_bind_with_match
+    result = @db.query( "select * from foo where a = 1" )
+    assert_not_nil result.next
+    assert_nil result.next
+    result.close
+  end
+
+  def test_query_with_block_no_bind_with_match
+    r = nil
+    @db.query( "select * from foo where a = 1" ) do |result|
+      assert_not_nil result.next
+      assert_nil result.next
+      r = result
+    end
+    assert r.closed?
+  end
+
+  def test_query_no_block_with_bind_with_match
+    result = @db.query( "select * from foo where a = ?", 1 )
+    assert_not_nil result.next
+    assert_nil result.next
+    result.close
+  end
+
+  def test_query_with_block_with_bind_with_match
+    r = nil
+    @db.query( "select * from foo where a = ?", 1 ) do |result|
+      assert_not_nil result.next
+      assert_nil result.next
+      r = result
+    end
+    assert r.closed?
+  end
+
+  def test_get_first_row_no_bind_no_match
+    result = @db.get_first_row( "select * from foo where a=100" )
+    assert_nil result
+  end
+
+  def test_get_first_row_no_bind_with_match
+    result = @db.get_first_row( "select * from foo where a=1" )
+    assert_equal [ "1", "foo" ], result
+  end
+
+  def test_get_first_row_with_bind_no_match
+    result = @db.get_first_row( "select * from foo where a=?", 100 )
+    assert_nil result
+  end
+
+  def test_get_first_row_with_bind_with_match
+    result = @db.get_first_row( "select * from foo where a=?", 1 )
+    assert_equal [ "1", "foo" ], result
+  end
+
+  def test_get_first_value_no_bind_no_match
+    result = @db.get_first_value( "select b, a from foo where a=100" )
+    assert_nil result
+  end
+
+  def test_get_first_value_no_bind_with_match
+    result = @db.get_first_value( "select b, a from foo where a=1" )
+    assert_equal "foo", result
+  end
+
+  def test_get_first_value_with_bind_no_match
+    result = @db.get_first_value( "select b, a from foo where a=?", 100 )
+    assert_nil result
+  end
+
+  def test_get_first_value_with_bind_with_match
+    result = @db.get_first_value( "select b, a from foo where a=?", 1 )
+    assert_equal "foo", result
+  end
+
+  def test_last_insert_row_id
+    @db.execute "insert into foo ( b ) values ( 'test' )"
+    assert_equal 4, @db.last_insert_row_id
+    @db.execute "insert into foo ( b ) values ( 'again' )"
+    assert_equal 5, @db.last_insert_row_id
+  end
+
+  def test_changes
+    @db.execute "insert into foo ( b ) values ( 'test' )"
+    assert_equal 1, @db.changes
+    @db.execute "delete from foo where 1=1"
+    assert_equal 4, @db.changes
+  end
+
+  def test_total_changes
+    assert_equal 3, @db.total_changes
+    @db.execute "insert into foo ( b ) values ( 'test' )"
+    @db.execute "delete from foo where 1=1"
+    assert_equal 8, @db.total_changes
+  end
+
+  def test_transaction_nest
+    assert_raise( SQLite3::SQLException ) do
+      @db.transaction do
+        @db.transaction do
+        end
+      end
+    end
+  end
+
+  def test_transaction_rollback
+    @db.transaction
+    @db.execute_batch <<-SQL
+      insert into foo (b) values ( 'test1' );
+      insert into foo (b) values ( 'test2' );
+      insert into foo (b) values ( 'test3' );
+      insert into foo (b) values ( 'test4' );
+    SQL
+    assert_equal 7, @db.get_first_value("select count(*) from foo").to_i
+    @db.rollback
+    assert_equal 3, @db.get_first_value("select count(*) from foo").to_i
+  end
+
+  def test_transaction_commit
+    @db.transaction
+    @db.execute_batch <<-SQL
+      insert into foo (b) values ( 'test1' );
+      insert into foo (b) values ( 'test2' );
+      insert into foo (b) values ( 'test3' );
+      insert into foo (b) values ( 'test4' );
+    SQL
+    assert_equal 7, @db.get_first_value("select count(*) from foo").to_i
+    @db.commit
+    assert_equal 7, @db.get_first_value("select count(*) from foo").to_i
+  end
+
+  def test_transaction_rollback_in_block
+    assert_raise( SQLite3::SQLException ) do
+      @db.transaction do
+        @db.rollback
+      end
+    end
+  end
+
+  def test_transaction_commit_in_block
+    assert_raise( SQLite3::SQLException ) do
+      @db.transaction do
+        @db.commit
+      end
+    end
+  end
+
+  def test_transaction_active
+    assert !@db.transaction_active?
+    @db.transaction
+    assert @db.transaction_active?
+    @db.commit
+    assert !@db.transaction_active?
+  end
+
+  def test_interrupt
+    @db.create_function( "abort", 1 ) do |func,x|
+      @db.interrupt
+      func.result = x
+    end
+
+    assert_raise( SQLite3::SQLException ) do
+      @db.execute "select abort(a) from foo"
+    end
+  end
+
+  def test_create_function
+    @db.create_function( "munge", 1 ) do |func,x|
+      func.result = ">>>#{x}<<<"
+    end
+
+    value = @db.get_first_value( "select munge(b) from foo where a=1" )
+    assert_match( />>>.*<<</, value )
+  end
+
+  def test_create_aggregate_without_block
+    step = proc do |ctx,a|
+      ctx[:sum] ||= 0
+      ctx[:sum] += a.to_i
+    end
+
+    final = proc { |ctx| ctx.result = ctx[:sum] }
+
+    @db.create_aggregate( "accumulate", 1, step, final )
+
+    value = @db.get_first_value( "select accumulate(a) from foo" )
+    assert_equal "6", value
+  end
+
+  def test_create_aggregate_with_block
+    @db.create_aggregate( "accumulate", 1 ) do
+      step do |ctx,a|
+        ctx[:sum] ||= 0
+        ctx[:sum] += a.to_i
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] }
+    end
+
+    value = @db.get_first_value( "select accumulate(a) from foo" )
+    assert_equal "6", value
+  end
+
+  def test_create_aggregate_with_no_data
+    @db.create_aggregate( "accumulate", 1 ) do
+      step do |ctx,a|
+        ctx[:sum] ||= 0
+        ctx[:sum] += a.to_i
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] || 0 }
+    end
+
+    value = @db.get_first_value(
+      "select accumulate(a) from foo where a = 100" )
+    assert_equal "0", value
+  end
+
+  def test_create_aggregate_handler
+    handler = Class.new do
+      class << self
+        def arity; 1; end
+        def text_rep; SQLite3::Constants::TextRep::ANY; end
+        def name; "multiply"; end
+      end
+      def step(ctx, a)
+        ctx[:buffer] ||= 1
+        ctx[:buffer] *= a.to_i
+      end
+      def finalize(ctx); ctx.result = ctx[:buffer]; end
+    end
+
+    @db.create_aggregate_handler( handler )
+    value = @db.get_first_value( "select multiply(a) from foo" )
+    assert_equal "6", value
+  end
+
+  def test_bind_array_parameter
+    result = @db.get_first_value( "select b from foo where a=? and b=?",
+      [ 1, "foo" ] )
+    assert_equal "foo", result
+  end
+end