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

data/lib/sqlite3/database.rb

@@ -54,12 +54,73 @@ module SQLite3
     # as hashes or not. By default, rows are returned as arrays.
     attr_accessor :results_as_hash
 
+    # call-seq: SQLite3::Database.new(file, options = {})
+    #
+    # Create a new Database object that opens the given file. If utf16
+    # is +true+, the filename is interpreted as a UTF-16 encoded string.
+    #
+    # By default, the new database will return result rows as arrays
+    # (#results_as_hash) and has type translation disabled (#type_translation=).
+
+    def initialize file, options = {}, zvfs = nil
+      mode = Constants::Open::READWRITE | Constants::Open::CREATE
+
+      file = file.to_path if file.respond_to? :to_path
+      if file.encoding == ::Encoding::UTF_16LE || file.encoding == ::Encoding::UTF_16BE || options[:utf16]
+        open16 file
+      else
+        # The three primary flag values for sqlite3_open_v2 are:
+        # SQLITE_OPEN_READONLY
+        # SQLITE_OPEN_READWRITE
+        # SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE -- always used for sqlite3_open and sqlite3_open16
+        mode = Constants::Open::READONLY if options[:readonly]
+
+        if options[:readwrite]
+          raise "conflicting options: readonly and readwrite" if options[:readonly]
+          mode = Constants::Open::READWRITE
+        end
+
+        if options[:flags]
+          if options[:readonly] || options[:readwrite]
+            raise "conflicting options: flags with readonly and/or readwrite"
+          end
+          mode = options[:flags]
+        end
+
+        open_v2 file.encode("utf-8"), mode, zvfs
+
+        if options[:strict]
+          disable_quirk_mode
+        end
+      end
+
+      @tracefunc        = nil
+      @authorizer       = nil
+      @encoding         = nil
+      @busy_handler     = nil
+      @collations       = {}
+      @functions        = {}
+      @results_as_hash  = options[:results_as_hash]
+      @type_translation = options[:type_translation]
+      @type_translator  = make_type_translator @type_translation
+      @readonly         = mode & Constants::Open::READONLY != 0
+
+      if block_given?
+        begin
+          yield self
+        ensure
+          close
+        end
+      end
+    end
+
     def type_translation= value # :nodoc:
       warn(<<-eowarn) if $VERBOSE
 #{caller[0]} is calling SQLite3::Database#type_translation=
 SQLite3::Database#type_translation= is deprecated and will be removed
 in version 2.0.0.
       eowarn
+      @type_translator  = make_type_translator value
       @type_translation = value
     end
     attr_reader :type_translation # :nodoc:
@@ -136,25 +197,14 @@ Support for bind parameters as *args will be removed in 2.0.0.
 
       prepare( sql ) do |stmt|
         stmt.bind_params(bind_vars)
-        columns = stmt.columns
-        stmt    = ResultSet.new(self, stmt).to_a if type_translation
+        stmt    = ResultSet.new self, stmt
 
         if block_given?
           stmt.each do |row|
-            if @results_as_hash
-              yield type_translation ? row : ordered_map_for(columns, row)
-            else
-              yield row
-            end
+            yield row
           end
         else
-          if @results_as_hash
-            stmt.map { |row|
-              type_translation ? row : ordered_map_for(columns, row)
-            }
-          else
-            stmt.to_a
-          end
+          stmt.to_a
         end
       end
     end
@@ -190,6 +240,9 @@ Support for bind parameters as *args will be removed in 2.0.0.
     #
     # This always returns +nil+, making it unsuitable for queries that return
     # rows.
+    #
+    # See also #execute_batch2 for additional ways of
+    # executing statements.
     def execute_batch( sql, bind_vars = [], *args )
       # FIXME: remove this stuff later
       unless [Array, Hash].include?(bind_vars.class)
@@ -234,8 +287,32 @@ Support for this behavior will be removed in version 2.0.0.
       nil
     end
 
+    # Executes all SQL statements in the given string. By contrast, the other
+    # means of executing queries will only execute the first statement in the
+    # string, ignoring all subsequent statements. This will execute each one
+    # in turn. Bind parameters cannot be passed to #execute_batch2.
+    #
+    # If a query is made, all values will be returned as strings.
+    # If no query is made, an empty array will be returned.
+    #
+    # Because all values except for 'NULL' are returned as strings,
+    # a block can be passed to parse the values accordingly.
+    #
+    # See also #execute_batch for additional ways of
+    # executing statements.
+    def execute_batch2(sql, &block)
+      if block_given?
+        result = exec_batch(sql, @results_as_hash)
+        result.map do |val|
+          yield val
+        end
+      else
+        exec_batch(sql, @results_as_hash)
+      end
+    end
+
     # This is a convenience method for creating a statement, binding
-    # paramters to it, and calling execute:
+    # parameters to it, and calling execute:
     #
     #   result = db.query( "select * from foo where a=?", [5])
     #   # is the same as
@@ -287,7 +364,11 @@ Support for this will be removed in version 2.0.0.
     #
     # See also #get_first_row.
     def get_first_value( sql, *bind_vars )
-      execute( sql, *bind_vars ) { |row| return row[0] }
+      query( sql, bind_vars ) do |rs|
+        if (row = rs.next)
+          return @results_as_hash ? row[rs.columns[0]] : row[0]
+        end
+      end
       nil
     end
 
@@ -316,8 +397,8 @@ Support for this will be removed in version 2.0.0.
     #   end
     #
     #   puts db.get_first_value( "select maim(name) from table" )
-    def create_function name, arity, text_rep=Constants::TextRep::ANY, &block
-      define_function(name) do |*args|
+    def create_function name, arity, text_rep=Constants::TextRep::UTF8, &block
+      define_function_with_flags(name, text_rep) do |*args|
         fp = FunctionProxy.new
         block.call(fp, *args)
         fp.result
@@ -364,42 +445,52 @@ Support for this will be removed in version 2.0.0.
     def create_aggregate( name, arity, step=nil, finalize=nil,
       text_rep=Constants::TextRep::ANY, &block )
 
-      factory = Class.new do
+      proxy = Class.new do
         def self.step( &block )
-          define_method(:step, &block)
+          define_method(:step_with_ctx, &block)
         end
 
         def self.finalize( &block )
-          define_method(:finalize, &block)
+          define_method(:finalize_with_ctx, &block)
         end
       end
 
       if block_given?
-        factory.instance_eval(&block)
+        proxy.instance_eval(&block)
       else
-        factory.class_eval do
-          define_method(:step, step)
-          define_method(:finalize, finalize)
+        proxy.class_eval do
+          define_method(:step_with_ctx, step)
+          define_method(:finalize_with_ctx, finalize)
         end
       end
 
-      proxy = factory.new
-      proxy.extend(Module.new {
-        attr_accessor :ctx
+      proxy.class_eval do
+        # class instance variables
+        @name = name
+        @arity = arity
+
+        def self.name
+          @name
+        end
+
+        def self.arity
+          @arity
+        end
+
+        def initialize
+          @ctx = FunctionProxy.new
+        end
 
         def step( *args )
-          super(@ctx, *args)
+          step_with_ctx(@ctx, *args)
         end
 
         def finalize
-          super(@ctx)
-          result = @ctx.result
-          @ctx = FunctionProxy.new
-          result
+          finalize_with_ctx(@ctx)
+          @ctx.result
         end
-      })
-      proxy.ctx = FunctionProxy.new
-      define_aggregator(name, proxy)
+      end
+      define_aggregator2(proxy, name)
     end
 
     # This is another approach to creating an aggregate function (see
@@ -450,29 +541,75 @@ Support for this will be removed in version 2.0.0.
     #   db.create_aggregate_handler( LengthsAggregateHandler )
     #   puts db.get_first_value( "select lengths(name) from A" )
     def create_aggregate_handler( handler )
-      proxy = Class.new do
-        def initialize klass
-          @klass = klass
-          @fp    = FunctionProxy.new
+      # This is a compatibility shim so the (basically pointless) FunctionProxy
+      # "ctx" object is passed as first argument to both step() and finalize().
+      # Now its up to the library user whether he prefers to store his
+      # temporaries as instance variables or fields in the FunctionProxy.
+      # The library user still must set the result value with
+      # FunctionProxy.result= as there is no backwards compatible way to
+      # change this.
+      proxy = Class.new(handler) do
+        def initialize
+          super
+          @fp = FunctionProxy.new
         end
 
         def step( *args )
-          instance.step(@fp, *args)
+          super(@fp, *args)
         end
 
         def finalize
-          instance.finalize @fp
-          @instance = nil
+          super(@fp)
           @fp.result
         end
+      end
+      define_aggregator2(proxy, proxy.name)
+      self
+    end
 
-        private
+    # Define an aggregate function named +name+ using a object template
+    # object +aggregator+. +aggregator+ must respond to +step+ and +finalize+.
+    # +step+ will be called with row information and +finalize+ must return the
+    # return value for the aggregator function.
+    #
+    # _API Change:_ +aggregator+ must also implement +clone+. The provided
+    # +aggregator+ object will serve as template that is cloned to provide the
+    # individual instances of the aggregate function. Regular ruby objects
+    # already provide a suitable +clone+.
+    # The functions arity is the arity of the +step+ method.
+    def define_aggregator( name, aggregator )
+      # Previously, this has been implemented in C. Now this is just yet
+      # another compatibility shim
+      proxy = Class.new do
+        @template = aggregator
+        @name = name
+
+        def self.template
+          @template
+        end
+
+        def self.name
+          @name
+        end
+
+        def self.arity
+          # this is what sqlite3_obj_method_arity did before
+          @template.method(:step).arity
+        end
+
+        def initialize
+          @klass = self.class.template.clone
+        end
 
-        def instance
-          @instance ||= @klass.new
+        def step(*args)
+          @klass.step(*args)
+        end
+
+        def finalize
+          @klass.finalize
         end
       end
-      define_aggregator(handler.name, proxy.new(handler))
+      define_aggregator2(proxy, name)
       self
     end
 
@@ -499,7 +636,7 @@ Support for this will be removed in version 2.0.0.
         abort = false
         begin
           yield self
-        rescue ::Object
+        rescue
           abort = true
           raise
         ensure
@@ -580,12 +717,25 @@ Support for this will be removed in version 2.0.0.
       end
     end
 
+    # Translates a +row+ of data from the database with the given +types+
+    def translate_from_db types, row
+      @type_translator.call types, row
+    end
+
     private
 
-    def ordered_map_for columns, row
-      h = Hash[*columns.zip(row).flatten]
-      row.each_with_index { |r, i| h[i] = r }
-      h
+    NULL_TRANSLATOR = lambda { |_, row| row }
+
+    def make_type_translator should_translate
+      if should_translate
+        lambda { |types, row|
+          types.zip(row).map do |type, value|
+            translator.translate( type, value )
+          end
+        }
+      else
+        NULL_TRANSLATOR
+      end
     end
   end
 end

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
@@ -42,11 +42,11 @@ module SQLite3
     # Requests the given pragma (and parameters), and if the block is given,
     # each row of the result set will be yielded to it. Otherwise, the results
     # are returned as an array.
-    def get_query_pragma( name, *parms, &block ) # :yields: row
-      if parms.empty?
+    def get_query_pragma( name, *params, &block ) # :yields: row
+      if params.empty?
         execute( "PRAGMA #{name}", &block )
       else
-        args = "'" + parms.join("','") + "'"
+        args = "'" + params.join("','") + "'"
         execute( "PRAGMA #{name}( #{args} )", &block )
       end
     end
@@ -101,15 +101,6 @@ module SQLite3
     # The list of valid WAL checkpoints.
     WAL_CHECKPOINTS = [ [ 'passive' ], [ 'full' ], [ 'restart' ], [ 'truncate' ] ]
 
-    # Does an integrity check on the database. If the check fails, a
-    # SQLite3::Exception will be raised. Otherwise it
-    # returns silently.
-    def integrity_check
-      execute( "PRAGMA integrity_check" ) do |row|
-        raise Exception, row[0] if row[0] != "ok"
-      end
-    end
-
     def application_id
       get_int_pragma "application_id"
     end
@@ -552,6 +543,13 @@ module SQLite3
 
         tweak_default(new_row) if needs_tweak_default
 
+        # Ensure the type value is downcased.  On Mac and Windows
+        # platforms this value is now being returned as all upper
+        # case.
+        if new_row['type']
+          new_row['type'] = new_row['type'].downcase
+        end
+
         if block_given?
           yield new_row
         else

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/statement.rb

@@ -137,7 +137,8 @@ module SQLite3
         column_name column
       end
       @types = Array.new(column_count) do |column|
-        column_decltype column
+        val = column_decltype(column)
+        val.nil? ? nil : val.downcase
       end
     end
   end

data/lib/sqlite3/translator.rb

@@ -43,7 +43,7 @@ Built in translators are deprecated and will be removed in version 2.0.0
     end
 
     # Translate the given string value to a value of the given type. In the
-    # absense of an installed translator block for the given type, the value
+    # absence of an installed translator block for the given type, the value
     # itself is always returned. Further, +nil+ values are never translated,
     # and are always passed straight through regardless of the type parameter.
     def translate( type, value )

data/lib/sqlite3/version.rb

@@ -1,13 +1,13 @@
 module SQLite3
 
-  VERSION = '1.3.12'
+  VERSION = "1.5.0.rc2"
 
   module VersionProxy
 
     MAJOR = 1
-    MINOR = 3
-    TINY  = 12
-    BUILD = nil
+    MINOR = 5
+    TINY  = 0
+    BUILD = "rc2"
 
     STRING = [ MAJOR, MINOR, TINY, BUILD ].compact.join( "." )
     #:beta-tag:

data/test/helper.rb

@@ -1,6 +1,15 @@
 require 'sqlite3'
 require 'minitest/autorun'
 
+if ENV['GITHUB_ACTIONS'] == 'true' || ENV['CI']
+  $VERBOSE = nil
+end
+
+puts "info: sqlite3-ruby version: #{SQLite3::VERSION}/#{SQLite3::VersionProxy::STRING}"
+puts "info: sqlite3 version: #{SQLite3::SQLITE_VERSION}/#{SQLite3::SQLITE_LOADED_VERSION}"
+puts "info: sqlcipher?: #{SQLite3.sqlcipher?}"
+puts "info: threadsafe?: #{SQLite3.threadsafe?}"
+
 unless RUBY_VERSION >= "1.9"
   require 'iconv'
 end