sqlite3 1.3.12-x64-mingw32 → 1.5.0.rc2-x64-mingw32

data/test/test_database.rb

@@ -1,5 +1,6 @@
 require 'helper'
 require 'tempfile'
+require 'pathname'
 
 module SQLite3
   class TestDatabase < SQLite3::TestCase
@@ -11,7 +12,7 @@ module SQLite3
     end
 
     def test_segv
-      assert_raises(TypeError) { SQLite3::Database.new 1 }
+      assert_raises { SQLite3::Database.new 1 }
     end
 
     def test_db_filename
@@ -19,7 +20,7 @@ module SQLite3
       assert_equal '', @db.filename('main')
       tf = Tempfile.new 'thing'
       @db = SQLite3::Database.new tf.path
-      assert_equal tf.path, @db.filename('main')
+      assert_equal File.realdirpath(tf.path), File.realdirpath(@db.filename('main'))
     ensure
       tf.unlink if tf
     end
@@ -29,7 +30,7 @@ module SQLite3
       assert_equal '', @db.filename
       tf = Tempfile.new 'thing'
       @db = SQLite3::Database.new tf.path
-      assert_equal tf.path, @db.filename
+      assert_equal File.realdirpath(tf.path), File.realdirpath(@db.filename)
     ensure
       tf.unlink if tf
     end
@@ -39,11 +40,41 @@ module SQLite3
       assert_equal '', @db.filename
       tf = Tempfile.new 'thing'
       @db.execute "ATTACH DATABASE '#{tf.path}' AS 'testing'"
-      assert_equal tf.path, @db.filename('testing')
+
+      assert_equal File.realdirpath(tf.path), File.realdirpath(@db.filename('testing'))
     ensure
       tf.unlink if tf
     end
 
+
+    def test_filename_to_path
+      tf = Tempfile.new 'thing'
+      pn = Pathname tf.path
+      db = SQLite3::Database.new pn
+      assert_equal pn.realdirpath.to_s, File.realdirpath(db.filename)
+    ensure
+      tf.close! if tf
+    end
+
+
+    def test_error_code
+      begin
+        db.execute 'SELECT'
+      rescue SQLite3::SQLException => e
+      end
+      assert_equal 1, e.code
+    end
+
+    def test_extended_error_code
+      db.extended_result_codes = true
+      db.execute 'CREATE TABLE "employees" ("token" integer NOT NULL)'
+      begin
+        db.execute 'INSERT INTO employees (token) VALUES (NULL)'
+      rescue SQLite3::ConstraintException => e
+      end
+      assert_equal 1299, e.code
+    end
+
     def test_bignum
       num = 4907021672125087844
       db.execute 'CREATE TABLE "employees" ("token" integer(8), "name" varchar(20) NOT NULL)'
@@ -65,15 +96,17 @@ module SQLite3
 
     def test_get_first_row_with_type_translation_and_hash_results
       @db.results_as_hash = true
-      assert_equal({0=>1, "1"=>1}, @db.get_first_row('SELECT 1'))
+      @db.type_translation = true
+      assert_equal({"1"=>1}, @db.get_first_row('SELECT 1'))
     end
 
     def test_execute_with_type_translation_and_hash
       @db.results_as_hash = true
+      @db.type_translation = true
       rows = []
       @db.execute('SELECT 1') { |row| rows << row }
 
-      assert_equal({0=>1, "1"=>1}, rows.first)
+      assert_equal({"1"=>1}, rows.first)
     end
 
     def test_encoding
@@ -100,6 +133,59 @@ module SQLite3
       eosql
     end
 
+    def test_execute_batch2
+      @db.results_as_hash = true
+      return_value = @db.execute_batch2 <<-eosql
+        CREATE TABLE items (id integer PRIMARY KEY AUTOINCREMENT, name string);
+        INSERT INTO items (name) VALUES ("foo");
+        INSERT INTO items (name) VALUES ("bar");
+        SELECT * FROM items;
+        eosql
+      assert_equal return_value, [{"id"=>"1","name"=>"foo"}, {"id"=>"2", "name"=>"bar"}]
+
+      return_value = @db.execute_batch2('SELECT * FROM items;') do |result|
+        result["id"] = result["id"].to_i
+        result
+      end
+      assert_equal return_value, [{"id"=>1,"name"=>"foo"}, {"id"=>2, "name"=>"bar"}]
+
+      return_value = @db.execute_batch2('INSERT INTO items (name) VALUES ("oof")')
+      assert_equal return_value, []
+
+      return_value = @db.execute_batch2(
+       'CREATE TABLE employees (id integer PRIMARY KEY AUTOINCREMENT, name string, age integer(3));
+        INSERT INTO employees (age) VALUES (30);
+        INSERT INTO employees (age) VALUES (40);
+        INSERT INTO employees (age) VALUES (20);
+        SELECT age FROM employees;') do |result|
+          result["age"] = result["age"].to_i
+          result
+        end
+      assert_equal return_value, [{"age"=>30}, {"age"=>40}, {"age"=>20}]
+
+      return_value = @db.execute_batch2('SELECT name FROM employees');
+      assert_equal return_value, [{"name"=>nil}, {"name"=>nil}, {"name"=>nil}]
+
+      @db.results_as_hash = false
+      return_value = @db.execute_batch2(
+        'CREATE TABLE managers (id integer PRIMARY KEY AUTOINCREMENT, age integer(3));
+        INSERT INTO managers (age) VALUES (50);
+        INSERT INTO managers (age) VALUES (60);
+        SELECT id, age from managers;') do |result|
+          result = result.map do |res|
+            res.to_i
+          end
+          result
+        end
+      assert_equal return_value, [[1, 50], [2, 60]]
+
+      assert_raises (RuntimeError) do
+        # "names" is not a valid column
+        @db.execute_batch2 'INSERT INTO items (names) VALUES ("bazz")'
+      end
+
+    end
+
     def test_new
       db = SQLite3::Database.new(':memory:')
       assert db
@@ -180,7 +266,7 @@ module SQLite3
       db.execute("create table foo ( a integer primary key, b text )")
       db.execute("insert into foo (b) values ('hello')")
       rows = db.execute("select * from foo")
-      assert_equal [{0=>1, "a"=>1, "b"=>"hello", 1=>"hello"}], rows
+      assert_equal [{"a"=>1, "b"=>"hello"}], rows
     end
 
     def test_execute_yields_hash
@@ -188,7 +274,7 @@ module SQLite3
       db.execute("create table foo ( a integer primary key, b text )")
       db.execute("insert into foo (b) values ('hello')")
       db.execute("select * from foo") do |row|
-        assert_equal({0=>1, "a"=>1, "b"=>"hello", 1=>"hello"}, row)
+        assert_equal({"a"=>1, "b"=>"hello"}, row)
       end
     end
 
@@ -275,7 +361,10 @@ module SQLite3
         nil
       end
       @db.execute("select hello(2.2, 'foo', NULL)")
-      assert_equal [2.2, 'foo', nil], called_with
+
+      assert_in_delta(2.2, called_with[0], 0.0001)
+      assert_equal("foo", called_with[1])
+      assert_nil(called_with[2])
     end
 
     def test_define_varargs
@@ -285,7 +374,10 @@ module SQLite3
         nil
       end
       @db.execute("select hello(2.2, 'foo', NULL)")
-      assert_equal [2.2, 'foo', nil], called_with
+
+      assert_in_delta(2.2, called_with[0], 0.0001)
+      assert_equal("foo", called_with[1])
+      assert_nil(called_with[2])
     end
 
     def test_call_func_blob
@@ -383,7 +475,7 @@ module SQLite3
         def call action, a, b, c, d; nil end
       }.new
       stmt = @db.prepare("select 'fooooo'")
-      assert_equal nil, stmt.step
+      assert_nil stmt.step
     end
 
     def test_authorizer_fail
@@ -425,5 +517,29 @@ module SQLite3
     def test_execute_with_named_bind_params
       assert_equal [['foo']], @db.execute("select :n", {'n' => 'foo'})
     end
+
+    def test_strict_mode
+      unless Gem::Requirement.new(">= 3.29.0").satisfied_by?(Gem::Version.new(SQLite3::SQLITE_VERSION))
+        skip("strict mode feature not available in #{SQLite3::SQLITE_VERSION}")
+      end
+
+      db = SQLite3::Database.new(':memory:')
+      db.execute('create table numbers (val int);')
+      db.execute('create index index_numbers_nope ON numbers ("nope");') # nothing raised
+
+      db = SQLite3::Database.new(':memory:', :strict => true)
+      db.execute('create table numbers (val int);')
+      error = assert_raises SQLite3::SQLException do
+        db.execute('create index index_numbers_nope ON numbers ("nope");')
+      end
+      assert_includes error.message, "no such column: nope"
+    end
+
+    def test_load_extension_with_nonstring_argument
+      db = SQLite3::Database.new(':memory:')
+      skip("extensions are not enabled") unless db.respond_to?(:load_extension)
+      assert_raises(TypeError) { db.load_extension(1) }
+      assert_raises(TypeError) { db.load_extension(Pathname.new("foo.so")) }
+    end
   end
 end

data/test/test_database_flags.rb

@@ -0,0 +1,95 @@
+require 'helper'
+
+module SQLite3
+  class TestDatabaseFlags < SQLite3::TestCase
+    def setup
+      File.unlink 'test-flags.db' if File.exist?('test-flags.db')
+      @db = SQLite3::Database.new('test-flags.db')
+      @db.execute("CREATE TABLE foos (id integer)")
+      @db.close
+    end
+
+    def teardown
+      @db.close unless @db.closed?
+      File.unlink 'test-flags.db' if File.exist?('test-flags.db')
+    end
+
+    def test_open_database_flags_constants
+      defined_to_date = [:READONLY, :READWRITE, :CREATE, :DELETEONCLOSE,
+                         :EXCLUSIVE, :MAIN_DB, :TEMP_DB, :TRANSIENT_DB,
+                         :MAIN_JOURNAL, :TEMP_JOURNAL, :SUBJOURNAL,
+                         :MASTER_JOURNAL, :NOMUTEX, :FULLMUTEX]
+      if SQLite3::SQLITE_VERSION_NUMBER > 3007002
+        defined_to_date += [:AUTOPROXY, :SHAREDCACHE, :PRIVATECACHE, :WAL]
+      end
+      if SQLite3::SQLITE_VERSION_NUMBER > 3007007
+        defined_to_date += [:URI]
+      end
+      if SQLite3::SQLITE_VERSION_NUMBER > 3007013
+        defined_to_date += [:MEMORY]
+      end
+      assert defined_to_date.sort == SQLite3::Constants::Open.constants.sort
+    end
+
+    def test_open_database_flags_conflicts_with_readonly
+      assert_raise(RuntimeError) do
+        @db = SQLite3::Database.new('test-flags.db', :flags => 2, :readonly => true)
+      end
+    end
+
+    def test_open_database_flags_conflicts_with_readwrite
+      assert_raise(RuntimeError) do
+        @db = SQLite3::Database.new('test-flags.db', :flags => 2, :readwrite => true)
+      end
+    end
+
+    def test_open_database_readonly_flags
+      @db = SQLite3::Database.new('test-flags.db', :flags => SQLite3::Constants::Open::READONLY)
+      assert @db.readonly?
+    end
+
+    def test_open_database_readwrite_flags
+      @db = SQLite3::Database.new('test-flags.db', :flags => SQLite3::Constants::Open::READWRITE)
+      assert !@db.readonly?
+    end
+
+    def test_open_database_readonly_flags_cant_open
+      File.unlink 'test-flags.db'
+      assert_raise(SQLite3::CantOpenException) do
+        @db = SQLite3::Database.new('test-flags.db', :flags => SQLite3::Constants::Open::READONLY)
+      end
+    end
+
+    def test_open_database_readwrite_flags_cant_open
+      File.unlink 'test-flags.db'
+      assert_raise(SQLite3::CantOpenException) do
+        @db = SQLite3::Database.new('test-flags.db', :flags => SQLite3::Constants::Open::READWRITE)
+      end
+    end
+
+    def test_open_database_misuse_flags
+      assert_raise(SQLite3::MisuseException) do
+        flags = SQLite3::Constants::Open::READONLY | SQLite3::Constants::Open::READWRITE # <== incompatible flags
+        @db = SQLite3::Database.new('test-flags.db', :flags => flags)
+      end
+    end
+
+    def test_open_database_create_flags
+      File.unlink 'test-flags.db'
+      flags = SQLite3::Constants::Open::READWRITE | SQLite3::Constants::Open::CREATE
+      @db = SQLite3::Database.new('test-flags.db', :flags => flags) do |db|
+        db.execute("CREATE TABLE foos (id integer)")
+        db.execute("INSERT INTO foos (id) VALUES (12)")
+      end
+      assert File.exist?('test-flags.db')
+    end
+
+    def test_open_database_exotic_flags
+      flags = SQLite3::Constants::Open::READWRITE | SQLite3::Constants::Open::CREATE
+      exotic_flags = SQLite3::Constants::Open::NOMUTEX | SQLite3::Constants::Open::TEMP_DB
+      @db = SQLite3::Database.new('test-flags.db', :flags => flags | exotic_flags)
+      @db.execute("INSERT INTO foos (id) VALUES (12)")
+      assert @db.changes == 1
+    end
+  end
+end

data/test/test_database_readwrite.rb

@@ -0,0 +1,41 @@
+require 'helper'
+
+module SQLite3
+  class TestDatabaseReadwrite < SQLite3::TestCase
+    def setup
+      File.unlink 'test-readwrite.db' if File.exist?('test-readwrite.db')
+      @db = SQLite3::Database.new('test-readwrite.db')
+      @db.execute("CREATE TABLE foos (id integer)")
+      @db.close
+    end
+
+    def teardown
+      @db.close unless @db.closed?
+      File.unlink 'test-readwrite.db' if File.exist?('test-readwrite.db')
+    end
+
+    def test_open_readwrite_database
+      @db = SQLite3::Database.new('test-readwrite.db', :readwrite => true)
+      assert !@db.readonly?
+    end
+
+    def test_open_readwrite_readonly_database
+      assert_raise(RuntimeError) do
+        @db = SQLite3::Database.new('test-readwrite.db', :readwrite => true, :readonly => true)
+      end
+    end
+
+    def test_open_readwrite_not_exists_database
+      File.unlink 'test-readwrite.db'
+      assert_raise(SQLite3::CantOpenException) do
+        @db = SQLite3::Database.new('test-readwrite.db', :readonly => true)
+      end
+    end
+
+    def test_insert_readwrite_database
+      @db = SQLite3::Database.new('test-readwrite.db', :readwrite => true)
+      @db.execute("INSERT INTO foos (id) VALUES (12)")
+      assert @db.changes == 1
+    end
+  end
+end

data/test/test_integration.rb

@@ -359,21 +359,33 @@ class TC_Database_Integration < SQLite3::TestCase
   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
+    @db.results_as_hash = true
+    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
+    @db.results_as_hash = true
+    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
+    @db.results_as_hash = true
+    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
+    @db.results_as_hash = true
+    result = @db.get_first_value( "select b, a from foo where a=?", 1 )
+    assert_equal "foo", result
   end
 
   def test_last_insert_row_id
@@ -487,87 +499,6 @@ class TC_Database_Integration < SQLite3::TestCase
     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
-
-    # 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
-    @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
-
-  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
-    end
-
-    @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
-
   def test_bind_array_parameter
     result = @db.get_first_value( "select b from foo where a=? and b=?",
       [ 1, "foo" ] )