sqlite3 1.3.7 → 1.3.13

data/tasks/vendor_sqlite3.rake

@@ -2,17 +2,17 @@ require "rake/clean"
 require "rake/extensioncompiler"
 require "mini_portile"
 
-$recipes = {}
+CLOBBER.include("ports")
 
-$recipes[:sqlite3] = MiniPortile.new "sqlite3", BINARY_VERSION
-$recipes[:sqlite3].files << "http://sqlite.org/sqlite-autoconf-#{URL_VERSION}.tar.gz"
+directory "ports"
 
-namespace :ports do
-  directory "ports"
+def define_sqlite_task(platform, host)
+  recipe = MiniPortile.new "sqlite3", BINARY_VERSION
+  recipe.files << "http://sqlite.org#{URL_PATH}/sqlite-autoconf-#{URL_VERSION}.tar.gz"
+  recipe.host = host
 
-  desc "Install port sqlite3 #{$recipes[:sqlite3].version}"
-  task :sqlite3 => ["ports"] do |t|
-    recipe = $recipes[:sqlite3]
+  desc "Compile sqlite3 for #{platform} (#{host})"
+  task "ports:sqlite3:#{platform}" => ["ports"] do |t|
     checkpoint = "ports/.#{recipe.name}-#{recipe.version}-#{recipe.host}.installed"
 
     unless File.exist?(checkpoint)
@@ -22,30 +22,76 @@ namespace :ports do
       recipe.cook
       touch checkpoint
     end
-
-    recipe.activate
   end
+
+  recipe
 end
 
+# native sqlite3 compilation
+recipe = define_sqlite_task(RUBY_PLATFORM, RbConfig::CONFIG["host"])
+
+# force compilation of sqlite3 when working natively under MinGW
 if RUBY_PLATFORM =~ /mingw/
-  Rake::Task['compile'].prerequisites.unshift "ports:sqlite3"
+  RUBY_EXTENSION.config_options << "--with-opt-dir=#{recipe.path}"
+
+  # also prepend DevKit into compilation phase
+  Rake::Task["compile"].prerequisites.unshift "devkit", "ports:sqlite3:#{RUBY_PLATFORM}"
+  Rake::Task["native"].prerequisites.unshift "devkit", "ports:sqlite3:#{RUBY_PLATFORM}"
 end
 
+# trick to test local compilation of sqlite3
 if ENV["USE_MINI_PORTILE"] == "true"
-  Rake::Task["compile"].prerequisites.unshift "ports:sqlite3"
+  # fake recipe so we can build a directory to it
+  recipe = MiniPortile.new "sqlite3", BINARY_VERSION
+  recipe.host = RbConfig::CONFIG["host"]
+
+  RUBY_EXTENSION.config_options << "--with-opt-dir=#{recipe.path}"
+
+  # compile sqlite3 first
+  Rake::Task["compile"].prerequisites.unshift "ports:sqlite3:#{RUBY_PLATFORM}"
+end
+
+# iterate over all cross-compilation platforms and define the proper
+# sqlite3 recipe for it.
+if RUBY_EXTENSION.cross_compile
+  config_path = File.expand_path("~/.rake-compiler/config.yml")
+  if File.exist?(config_path)
+    # obtains platforms from rake-compiler's config.yml
+    config_file = YAML.load_file(config_path)
+
+    Array(RUBY_EXTENSION.cross_platform).each do |platform|
+      # obtain platform from rbconfig file
+      config_key = config_file.keys.sort.find { |key|
+        key.start_with?("rbconfig-#{platform}-")
+      }
+      rbfile = config_file[config_key]
+
+      # skip if rbconfig cannot be read
+      next unless File.exist?(rbfile)
+
+      host = IO.read(rbfile).match(/CONFIG\["CC"\] = "(.*)"/)[1].sub(/\-gcc/, '')
+      recipe = define_sqlite_task(platform, host)
+
+      RUBY_EXTENSION.cross_config_options << {
+        platform => "--with-opt-dir=#{recipe.path}"
+      }
+
+      # pre-compile sqlite3 port when cross-compiling
+      task :cross => "ports:sqlite3:#{platform}"
+    end
+  else
+    warn "rake-compiler configuration doesn't exist, but is required for ports"
+  end
 end
 
 task :cross do
   ["CC", "CXX", "LDFLAGS", "CPPFLAGS", "RUBYOPT"].each do |var|
     ENV.delete(var)
   end
-  host = ENV.fetch("HOST", Rake::ExtensionCompiler.mingw_host)
-  $recipes.each do |_, recipe|
-    recipe.host = host
-  end
-
-  # hook compile task with dependencies
-  Rake::Task["compile"].prerequisites.unshift "ports:sqlite3"
 end
 
-CLOBBER.include("ports")
+desc "Build windows binary gems per rake-compiler-dock."
+task "gem:windows" do
+  require "rake_compiler_dock"
+  RakeCompilerDock.sh "bundle && rake cross native gem MAKE='nice make -j`nproc`'"
+end

data/test/helper.rb

@@ -1,14 +1,18 @@
 require 'sqlite3'
-require 'test/unit'
+require 'minitest/autorun'
 
 unless RUBY_VERSION >= "1.9"
   require 'iconv'
 end
 
 module SQLite3
-  class TestCase < Test::Unit::TestCase
-    unless RUBY_VERSION >= '1.9'
-      undef :default_test
+  class TestCase < Minitest::Test
+    alias :assert_not_equal :refute_equal
+    alias :assert_not_nil   :refute_nil
+    alias :assert_raise     :assert_raises
+
+    def assert_nothing_raised
+      yield
     end
   end
 end

data/test/test_database.rb

@@ -1,4 +1,6 @@
 require 'helper'
+require 'tempfile'
+require 'pathname'
 
 module SQLite3
   class TestDatabase < SQLite3::TestCase
@@ -6,12 +8,43 @@ module SQLite3
 
     def setup
       @db = SQLite3::Database.new(':memory:')
+      super
     end
 
     def test_segv
       assert_raises(TypeError) { SQLite3::Database.new 1 }
     end
 
+    def test_db_filename
+      tf = nil
+      assert_equal '', @db.filename('main')
+      tf = Tempfile.new 'thing'
+      @db = SQLite3::Database.new tf.path
+      assert_equal File.expand_path(tf.path), File.expand_path(@db.filename('main'))
+    ensure
+      tf.unlink if tf
+    end
+
+    def test_filename
+      tf = nil
+      assert_equal '', @db.filename
+      tf = Tempfile.new 'thing'
+      @db = SQLite3::Database.new tf.path
+      assert_equal File.expand_path(tf.path), File.expand_path(@db.filename)
+    ensure
+      tf.unlink if tf
+    end
+
+    def test_filename_with_attachment
+      tf = nil
+      assert_equal '', @db.filename
+      tf = Tempfile.new 'thing'
+      @db.execute "ATTACH DATABASE '#{tf.path}' AS 'testing'"
+      assert_equal File.expand_path(tf.path), File.expand_path(@db.filename('testing'))
+    ensure
+      tf.unlink if tf
+    end
+
     def test_bignum
       num = 4907021672125087844
       db.execute 'CREATE TABLE "employees" ("token" integer(8), "name" varchar(20) NOT NULL)'
@@ -22,9 +55,9 @@ module SQLite3
 
     def test_blob
       @db.execute("CREATE TABLE blobs ( id INTEGER, hash BLOB(10) )")
-      str = "\0foo"
-      @db.execute("INSERT INTO blobs VALUES (0, ?)", [str])
-      assert_equal [[0, str]], @db.execute("SELECT * FROM blobs")
+      blob = Blob.new("foo\0bar")
+      @db.execute("INSERT INTO blobs VALUES (0, ?)", [blob])
+      assert_equal [[0, blob, blob.length, blob.length*2]], @db.execute("SELECT id, hash, length(hash), length(hex(hash)) FROM blobs")
     end
 
     def test_get_first_row
@@ -60,6 +93,14 @@ module SQLite3
       assert_equal [[30]], @db.execute("select number from items")
     end
 
+    def test_batch_last_comment_is_processed
+      # FIXME: nil as a successful return value is kinda dumb
+      assert_nil @db.execute_batch <<-eosql
+        CREATE TABLE items (id integer PRIMARY KEY AUTOINCREMENT);
+        -- omg
+      eosql
+    end
+
     def test_new
       db = SQLite3::Database.new(':memory:')
       assert db
@@ -101,12 +142,33 @@ module SQLite3
       assert thing.closed?
     end
 
+    def test_block_closes_self_even_raised
+      thing = nil
+      begin
+        SQLite3::Database.new(':memory:') do |db|
+          thing = db
+          raise
+        end
+      rescue
+      end
+      assert thing.closed?
+    end
+
     def test_prepare
       db = SQLite3::Database.new(':memory:')
       stmt = db.prepare('select "hello world"')
       assert_instance_of(SQLite3::Statement, stmt)
     end
 
+    def test_block_prepare_does_not_double_close
+      db = SQLite3::Database.new(':memory:')
+      r = db.prepare('select "hello world"') do |stmt|
+        stmt.close
+        :foo
+      end
+      assert_equal :foo, r
+    end
+
     def test_total_changes
       db = SQLite3::Database.new(':memory:')
       db.execute("create table foo ( a integer primary key, b text )")
@@ -227,18 +289,47 @@ module SQLite3
       assert_equal [2.2, 'foo', nil], called_with
     end
 
+    def test_call_func_blob
+      called_with = nil
+      @db.define_function("hello") do |a, b|
+        called_with = [a, b, a.length]
+        nil
+      end
+      blob = Blob.new("a\0fine\0kettle\0of\0fish")
+      @db.execute("select hello(?, length(?))", [blob, blob])
+      assert_equal [blob, blob.length, 21], called_with
+    end
+
     def test_function_return
       @db.define_function("hello") { |a| 10 }
       assert_equal [10], @db.execute("select hello('world')").first
     end
 
     def test_function_return_types
-      [10, 2.2, nil, "foo"].each do |thing|
+      [10, 2.2, nil, "foo", Blob.new("foo\0bar")].each do |thing|
         @db.define_function("hello") { |a| thing }
         assert_equal [thing], @db.execute("select hello('world')").first
       end
     end
 
+    def test_function_gc_segfault
+      @db.create_function("bug", -1) { |func, *values| func.result = values.join }
+      # With a lot of data and a lot of threads, try to induce a GC segfault.
+      params = Array.new(127, "?" * 28000)
+      proc = Proc.new {
+        db.execute("select bug(#{Array.new(params.length, "?").join(",")})", params)
+      }
+      m = Mutex.new
+      30.times.map { Thread.new { m.synchronize { proc.call } } }.each(&:join)
+    end
+
+    def test_function_return_type_round_trip
+      [10, 2.2, nil, "foo", Blob.new("foo\0bar")].each do |thing|
+        @db.define_function("hello") { |a| a }
+        assert_equal [thing], @db.execute("select hello(hello(?))", [thing]).first
+      end
+    end
+
     def test_define_function_closed
       @db.close
       assert_raise(SQLite3::Exception) do

data/test/test_database_readonly.rb

@@ -3,7 +3,7 @@ require 'helper'
 module SQLite3
   class TestDatabaseReadonly < SQLite3::TestCase
     def setup
-      File.unlink 'test-readonly.db' if File.exists?('test-readonly.db')
+      File.unlink 'test-readonly.db' if File.exist?('test-readonly.db')
       @db = SQLite3::Database.new('test-readonly.db')
       @db.execute("CREATE TABLE foos (id integer)")
       @db.close
@@ -11,7 +11,7 @@ module SQLite3
 
     def teardown
       @db.close unless @db.closed?
-      File.unlink 'test-readonly.db'
+      File.unlink 'test-readonly.db' if File.exist?('test-readonly.db')
     end
 
     def test_open_readonly_database
@@ -19,6 +19,13 @@ module SQLite3
       assert @db.readonly?
     end
 
+    def test_open_readonly_not_exists_database
+      File.unlink 'test-readonly.db'
+      assert_raise(SQLite3::CantOpenException) do
+        @db = SQLite3::Database.new('test-readonly.db', :readonly => true)
+      end
+    end
+
     def test_insert_readonly_database
       @db = SQLite3::Database.new('test-readonly.db', :readonly => true)
       assert_raise(SQLite3::ReadOnlyException) do

data/test/test_encoding.rb

@@ -11,6 +11,40 @@ module SQLite3
       @db.execute(@create);
     end
 
+    def test_select_encoding_on_utf_16
+      str = "foo"
+      utf16 = ([1].pack("I") == [1].pack("N")) ? "UTF-16BE" : "UTF-16LE"
+      db = SQLite3::Database.new(':memory:'.encode(utf16))
+      db.execute @create
+      db.execute "insert into ex (id, data) values (1, \"#{str}\")"
+
+      stmt = db.prepare 'select * from ex where data = ?'
+      ['US-ASCII', utf16, 'EUC-JP', 'UTF-8'].each do |enc|
+        stmt.bind_param 1, str.encode(enc)
+        assert_equal 1, stmt.to_a.length
+        stmt.reset!
+      end
+    end
+
+    def test_insert_encoding
+      str = "foo"
+      utf16 = ([1].pack("I") == [1].pack("N")) ? "UTF-16BE" : "UTF-16LE"
+      db = SQLite3::Database.new(':memory:'.encode(utf16))
+      db.execute @create
+      stmt = db.prepare @insert
+
+      ['US-ASCII', utf16, 'EUC-JP', 'UTF-8'].each_with_index do |enc,i|
+        stmt.bind_param 1, i
+        stmt.bind_param 2, str.encode(enc)
+        stmt.to_a
+        stmt.reset!
+      end
+
+      db.execute('select data from ex').flatten.each do |s|
+        assert_equal str, s
+      end
+    end
+
     def test_default_internal_is_honored
       warn_before = $-w
       $-w = false

data/test/test_integration.rb

@@ -21,12 +21,14 @@ class TC_Database_Integration < SQLite3::TestCase
 
   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' )"
+      @db.execute "create table defaults_test ( a string default NULL, b string default 'Hello', c string default '--- []\n' )"
       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])
+      assert_equal({"name" => "c", "type" => "string", "dflt_value" => "--- []\n", "notnull" => 0, "cid" => 2, "pk" => 0},
+        data[2])
     end
   end
 
@@ -236,7 +238,7 @@ class TC_Database_Integration < SQLite3::TestCase
 
   def test_execute2_with_block_with_bind_with_match
     called = 0
-    @db.execute2( "select * from foo where a = ?", 1 ) do |row|
+    @db.execute2( "select * from foo where a = ?", 1 ) do
       called += 1
     end
     assert_equal 2, called
@@ -497,6 +499,10 @@ class TC_Database_Integration < SQLite3::TestCase
 
     value = @db.get_first_value( "select accumulate(a) from foo" )
     assert_equal 6, value
+
+    # calling #get_first_value twice don't add up to the latest result
+    value = @db.get_first_value( "select accumulate(a) from foo" )
+    assert_equal 6, value
   end
 
   def test_create_aggregate_with_block
@@ -528,21 +534,36 @@ class TC_Database_Integration < SQLite3::TestCase
     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
+  class AggregateHandler
+    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
+
+  def test_aggregate_initialized_twice
+    initialized = 0
+    handler = Class.new(AggregateHandler) do
+      define_method(:initialize) do
+        initialized += 1
+        super()
       end
-      def finalize(ctx); ctx.result = ctx[:buffer]; end
     end
 
-    @db.create_aggregate_handler( handler )
+    @db.create_aggregate_handler handler
+    @db.get_first_value( "select multiply(a) from foo" )
+    @db.get_first_value( "select multiply(a) from foo" )
+    assert_equal 2, initialized
+  end
+
+  def test_create_aggregate_handler
+    @db.create_aggregate_handler AggregateHandler
     value = @db.get_first_value( "select multiply(a) from foo" )
     assert_equal 6, value
   end

data/test/test_integration_pending.rb

@@ -69,7 +69,7 @@ class TC_Integration_Pending < SQLite3::TestCase
     end
     sleep 1
 
-    @db.busy_handler do |count|
+    @db.busy_handler do
       handler_call_count += 1
       false
     end

data/test/test_sqlite3.rb

@@ -5,5 +5,17 @@ module SQLite3
     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
   end
 end

data/test/test_statement.rb

@@ -24,6 +24,19 @@ module SQLite3
       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
@@ -227,9 +240,7 @@ module SQLite3
       stmt.execute('employee-1')
       stmt.execute('employee-1') rescue SQLite3::ConstraintException
       stmt.reset!
-      assert_nothing_raised(SQLite3::ConstraintException) {
-        stmt.execute('employee-2')
-      }
+      assert stmt.execute('employee-2')
     end
 
     def test_clear_bindings