sqlite3 1.3.13 → 1.4.0

data/lib/sqlite3/errors.rb

@@ -2,17 +2,8 @@ require 'sqlite3/constants'
 
 module SQLite3
   class Exception < ::StandardError
-    @code = 0
-
-    # The numeric error code that this exception represents.
-    def self.code
-      @code
-    end
-
     # A convenience for accessing the error code for this exception.
-    def code
-      self.class.code
-    end
+    attr_reader :code
   end
 
   class SQLException < Exception; end

data/lib/sqlite3/pragmas.rb

@@ -19,19 +19,19 @@ module SQLite3
     # integer that represents truth.
     def set_boolean_pragma( name, mode )
       case mode
-        when String
+      when String
           case mode.downcase
-            when "on", "yes", "true", "y", "t"; mode = "'ON'"
-            when "off", "no", "false", "n", "f"; mode = "'OFF'"
-            else
+          when "on", "yes", "true", "y", "t"; mode = "'ON'"
+          when "off", "no", "false", "n", "f"; mode = "'OFF'"
+          else
               raise Exception,
                 "unrecognized pragma parameter #{mode.inspect}"
           end
-        when true, 1
+      when true, 1
           mode = "ON"
-        when false, 0, nil
+      when false, 0, nil
           mode = "OFF"
-        else
+      else
           raise Exception,
             "unrecognized pragma parameter #{mode.inspect}"
       end

data/lib/sqlite3/resultset.rb

@@ -108,11 +108,7 @@ object that created this object
       row = @stmt.step
       return nil if @stmt.done?
 
-      if @db.type_translation
-        row = @stmt.types.zip(row).map do |type, value|
-          @db.translator.translate( type, value )
-        end
-      end
+      row = @db.translate_from_db @stmt.types, row
 
       if row.respond_to?(:fields)
         # FIXME: this can only happen if the translator returns something
@@ -176,11 +172,7 @@ object that created this object
 
       # FIXME: type translation is deprecated, so this can be removed
       # in 2.0
-      if @db.type_translation
-        row = @stmt.types.zip(row).map do |type, value|
-          @db.translator.translate( type, value )
-        end
-      end
+      row = @db.translate_from_db @stmt.types, row
 
       # FIXME: this can be switched to a regular hash in 2.0
       row = HashWithTypesAndFields[*@stmt.columns.zip(row).flatten]

data/lib/sqlite3/version.rb

@@ -1,6 +1,6 @@
 module SQLite3
 
-  VERSION = '1.3.13'
+  VERSION = '1.4.0'
 
   module VersionProxy
 

data/{tasks → rakelib}/gem.rake

@@ -6,14 +6,14 @@ rescue LoadError
   require 'hoe'
 end
 
-Hoe.plugin :debugging, :doofus, :git, :minitest, :bundler
+Hoe.plugin :debugging, :doofus, :git, :minitest, :bundler, :gemspec
 
 HOE = Hoe.spec 'sqlite3' do
   developer           'Jamis Buck', 'jamis@37signals.com'
   developer           'Luis Lavena', 'luislavena@gmail.com'
   developer           'Aaron Patterson', 'aaron@tenderlovemaking.com'
 
-  license             "BSD-3"
+  license             "BSD-3-Clause"
 
   self.readme_file   = 'README.rdoc'
   self.history_file  = 'CHANGELOG.rdoc'
@@ -23,12 +23,14 @@ HOE = Hoe.spec 'sqlite3' do
   require_rubygems_version ">= 1.3.5"
 
   spec_extras[:extensions] = ["ext/sqlite3/extconf.rb"]
+  spec_extras[:metadata] = {'msys2_mingw_dependencies' => 'sqlite3'}
 
-  extra_dev_deps << ['rake-compiler', "~> 0.9.3"]
-  extra_dev_deps << ['rake-compiler-dock', "~> 0.5.2"]
+  extra_dev_deps << ['rake-compiler', "~> 1.0"]
+  extra_dev_deps << ['rake-compiler-dock', "~> 0.6.0"]
   extra_dev_deps << ["mini_portile", "~> 0.6.2"]
   extra_dev_deps << ["minitest", "~> 5.0"]
   extra_dev_deps << ["hoe-bundler", "~> 1.0"]
+  extra_dev_deps << ["hoe-gemspec", "~> 1.0"]
 
   clean_globs.push('**/test.db')
 end

data/{tasks → rakelib}/native.rake

@@ -40,6 +40,10 @@ RUBY_EXTENSION = Rake::ExtensionTask.new('sqlite3_native', HOE.spec) do |ext|
       Rake::ExtensionCompiler.mingw_host
       ext.cross_compile = true
       ext.cross_platform = ['i386-mswin32-60', 'i386-mingw32', 'x64-mingw32']
+      ext.cross_compiling do |spec|
+        # The fat binary gem doesn't depend on the sqlite3 package, since it bundles the library.
+        spec.metadata.delete('msys2_mingw_dependencies')
+      end
     rescue RuntimeError
       # noop
     end

data/test/test_database.rb

@@ -12,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
@@ -45,6 +45,24 @@ module SQLite3
       tf.unlink 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)'
@@ -66,15 +84,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
@@ -101,6 +121,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
@@ -181,7 +254,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
@@ -189,7 +262,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
 
@@ -384,7 +457,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

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" ] )