sqlite3-ruby 1.2.3-x86-mingw32 → 1.2.5-x86-mingw32

data/tasks/benchmark.rake

@@ -0,0 +1,9 @@
+desc "Run benchmarks vs. sqlite-ruby"
+task :benchmark do
+  ruby "test/bm.rb"
+end
+
+desc "Run benchmarks dl vs. native"
+task :benchmark2 do
+  ruby "test/native-vs-dl.rb"
+end

data/tasks/faq.rake

@@ -0,0 +1,9 @@
+# Generate FAQ
+desc "Generate the FAQ document"
+task :faq => ['faq/faq.html']
+
+file 'faq/faq.html' => ['faq/faq.rb', 'faq/faq.yml'] do
+  cd 'faq' do
+    ruby "faq.rb > faq.html"
+  end
+end

data/tasks/gem.rake

@@ -0,0 +1,32 @@
+require 'rubygems/package_task'
+require 'hoe'
+
+HOE = Hoe.spec 'sqlite3-ruby' do
+  self.rubyforge_name = 'sqlite-ruby'
+  self.author         = ['Jamis Buck']
+  self.email          = %w[jamis@37signals.com]
+  self.readme_file    = 'README.txt'
+  self.need_tar       = false
+  self.need_zip       = false
+
+  spec_extras[:required_ruby_version] = Gem::Requirement.new('> 1.8.5')
+
+  spec_extras[:extensions] = ["ext/sqlite3_api/extconf.rb"]
+
+  extra_dev_deps << 'mocha'
+  extra_dev_deps << ['rake-compiler', "~> 0.5.0"]
+
+  spec_extras['rdoc_options'] = proc do |rdoc_options|
+    rdoc_options << "--main=README.txt"
+  end
+
+  clean_globs.push('**/test.db')
+end
+
+file "#{HOE.spec.name}.gemspec" => ['Rakefile', 'tasks/gem.rake', 'lib/sqlite3/version.rb'] do |t|
+  puts "Generating #{t.name}"
+  File.open(t.name, 'w') { |f| f.puts HOE.spec.to_yaml }
+end
+
+desc "Generate or update the standalone gemspec file for the project"
+task :gemspec => ["#{HOE.spec.name}.gemspec"]

data/tasks/native.rake

@@ -0,0 +1,35 @@
+# use rake-compiler for building the extension
+require 'rake/extensiontask'
+
+# build sqlite3_api C extension
+Rake::ExtensionTask.new('sqlite3_api', HOE.spec) do |ext|
+  # reference to the sqlite3 library
+  sqlite3_lib = File.expand_path(File.join(File.dirname(__FILE__), '..', 'vendor', 'sqlite3'))
+
+  # define target for extension (supporting fat binaries)
+  if RUBY_PLATFORM =~ /mingw/ then
+    ruby_ver = RUBY_VERSION.match(/(\d+\.\d+)/)[1]
+    ext.lib_dir = "lib/#{ruby_ver}"
+  end
+
+  # automatically add build options to avoid need of manual input
+  if RUBY_PLATFORM =~ /mswin|mingw/ then
+    ext.config_options << "--with-sqlite3-dir=#{sqlite3_lib}"
+  else
+    ext.cross_compile = true
+    ext.cross_platform = ['i386-mswin32', 'i386-mingw32']
+    ext.cross_config_options << "--with-sqlite3-dir=#{sqlite3_lib}"
+  end
+end
+
+# C wrapper depends on swig file to be generated
+file 'ext/sqlite3_api/sqlite3_api_wrap.c' => ['ext/sqlite3_api/sqlite3_api.i'] do |t|
+  begin
+    sh "swig -ruby -o #{t.name} #{t.prerequisites.first}"
+  rescue
+    fail "could not build wrapper via swig (perhaps swig is not installed?)"
+  end
+end
+
+# ensure things are compiled prior testing
+task :test => [:compile]

data/tasks/vendor_sqlite3.rake

@@ -0,0 +1,104 @@
+require 'rake/clean'
+require 'rake/extensioncompiler'
+
+# download sqlite3 library and headers
+
+# only on Windows or cross platform compilation
+def dlltool(dllname, deffile, libfile)
+  # define if we are using GCC or not
+  if Rake::ExtensionCompiler.mingw_gcc_executable then
+    dir = File.dirname(Rake::ExtensionCompiler.mingw_gcc_executable)
+    tool = case RUBY_PLATFORM
+      when /mingw/
+        File.join(dir, 'dlltool.exe')
+      when /linux|darwin/
+        File.join(dir, "#{Rake::ExtensionCompiler.mingw_host}-dlltool")
+    end
+    return "#{tool} --dllname #{dllname} --def #{deffile} --output-lib #{libfile}"
+  else
+    if RUBY_PLATFORM =~ /mswin/ then
+      tool = 'lib.exe'
+    else
+      fail "Unsupported platform for cross-compilation (please, contribute some patches)."
+    end
+    return "#{tool} /DEF:#{deffile} /OUT:#{libfile}"
+  end
+end
+
+version = '3_6_16'
+
+# required folder structure for --with-sqlite3-dir (include + lib)
+directory "vendor/sqlite3/lib"
+directory "vendor/sqlite3/include"
+
+# download amalgamation version (for include files)
+file "vendor/sqlite-amalgamation-#{version}.zip" => ['vendor'] do |t|
+  url = "http://www.sqlite.org/#{File.basename(t.name)}"
+  when_writing "downloading #{t.name}" do
+    cd File.dirname(t.name) do
+      system "wget -c #{url} || curl -C - -O #{url}"
+    end
+  end
+end
+
+# download dll binaries
+file "vendor/sqlitedll-#{version}.zip" => ['vendor'] do |t|
+  url = "http://www.sqlite.org/#{File.basename(t.name)}"
+  when_writing "downloading #{t.name}" do
+    cd File.dirname(t.name) do
+      system "wget -c #{url} || curl -C - -O #{url}"
+    end
+  end
+end
+
+# extract header files into include folder
+file "vendor/sqlite3/include/sqlite3.h" => ['vendor/sqlite3/include', "vendor/sqlite-amalgamation-#{version}.zip"] do |t|
+  full_file = File.expand_path(t.prerequisites.last)
+  when_writing "creating #{t.name}" do
+    cd File.dirname(t.name) do
+      sh "unzip #{full_file}"
+      # update file timestamp to avoid Rake perform this extraction again.
+      touch File.basename(t.name)
+    end
+  end
+end
+
+# extract dll files into lib folder
+file "vendor/sqlite3/lib/sqlite3.dll" => ['vendor/sqlite3/lib', "vendor/sqlitedll-#{version}.zip"] do |t|
+  full_file = File.expand_path(t.prerequisites.last)
+  when_writing "creating #{t.name}" do
+    cd File.dirname(t.name) do
+      sh "unzip #{full_file}"
+      # update file timestamp to avoid Rake perform this extraction again.
+      touch File.basename(t.name)
+    end
+  end
+end
+
+# generate import library from definition and dll file
+file "vendor/sqlite3/lib/sqlite3.lib" => ["vendor/sqlite3/lib/sqlite3.dll"] do |t|
+  libfile = t.name
+  dllname = libfile.ext('dll')
+  deffile = libfile.ext('def')
+
+  when_writing "creating #{t.name}" do
+    sh dlltool(dllname, deffile, libfile)
+  end
+end
+
+# clean and clobber actions
+# All the uncompressed files must be removed at clean
+ CLEAN.include('vendor/sqlite3')
+
+# clobber vendored packages
+CLOBBER.include('vendor')
+
+# vendor:sqlite3
+task 'vendor:sqlite3' => ["vendor/sqlite3/lib/sqlite3.lib", "vendor/sqlite3/include/sqlite3.h"]
+
+# hook into cross compilation vendored sqlite3 dependency
+if RUBY_PLATFORM =~ /mingw|mswin/ then
+  Rake::Task['compile'].prerequisites.unshift 'vendor:sqlite3'
+else
+  Rake::Task['cross'].prerequisites.unshift 'vendor:sqlite3'
+end

data/test/{mocks.rb → helper.rb}

@@ -1,6 +1,12 @@
+# add lib folder to the path
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'sqlite3'
+
 require 'rubygems'
-gem 'mocha'
+require 'test/unit'
 
+# define mocks to be used
 require 'mocha'
 
 class Driver < Mocha::Mock
@@ -43,3 +49,19 @@ class Statement < Mocha::Mock
     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/{tc_database.rb → test_database.rb}

@@ -1,9 +1,4 @@
-$:.unshift "../lib"
-
-require 'sqlite3/database'
-require 'test/unit'
-
-require 'mocks'
+require File.join(File.dirname(__FILE__), 'helper')
 
 class TC_Database_Init < Test::Unit::TestCase
   def test_new
@@ -16,6 +11,18 @@ class TC_Database_Init < Test::Unit::TestCase
     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
@@ -27,6 +34,18 @@ class TC_Database_Init < Test::Unit::TestCase
     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 )

data/test/{tc_errors.rb → test_errors.rb}

@@ -1,8 +1,4 @@
-$:.unshift "../lib"
-
-require 'sqlite3/errors'
-require 'test/unit'
-require 'mocha'
+require File.join(File.dirname(__FILE__), 'helper')
 
 class TC_Errors < Test::Unit::TestCase
   (1..26).each do |code|

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