sqlite3 1.3.13 → 1.4.2

data/ext/sqlite3/statement.c

@@ -43,11 +43,9 @@ static VALUE initialize(VALUE self, VALUE db, VALUE sql)
   if(!db_ctx->db)
     rb_raise(rb_eArgError, "prepare called on a closed database");
 
-#ifdef HAVE_RUBY_ENCODING_H
   if(!UTF8_P(sql)) {
     sql               = rb_str_export_to_enc(sql, rb_utf8_encoding());
   }
-#endif
 
 #ifdef HAVE_SQLITE3_PREPARE_V2
   status = sqlite3_prepare_v2(
@@ -110,9 +108,7 @@ static VALUE step(VALUE self)
   sqlite3_stmt *stmt;
   int value, length;
   VALUE list;
-#ifdef HAVE_RUBY_ENCODING_H
   rb_encoding * internal_encoding;
-#endif
 
   Data_Get_Struct(self, sqlite3StmtRuby, ctx);
 
@@ -120,17 +116,24 @@ static VALUE step(VALUE self)
 
   if(ctx->done_p) return Qnil;
 
-#ifdef HAVE_RUBY_ENCODING_H
   {
       VALUE db          = rb_iv_get(self, "@connection");
       rb_funcall(db, rb_intern("encoding"), 0);
       internal_encoding = rb_default_internal_encoding();
   }
-#endif
 
   stmt = ctx->st;
 
   value = sqlite3_step(stmt);
+  if (rb_errinfo() != Qnil) {
+    /* some user defined function was invoked as a callback during step and
+     * it raised an exception that has been suppressed until step returns.
+     * Now re-raise it. */
+    VALUE exception = rb_errinfo();
+    rb_set_errinfo(Qnil);
+    rb_exc_raise(exception);
+  }
+
   length = sqlite3_column_count(stmt);
   list = rb_ary_new2((long)length);
 
@@ -148,21 +151,19 @@ static VALUE step(VALUE self)
               break;
             case SQLITE_TEXT:
               {
-                VALUE str = rb_tainted_str_new(
+                VALUE str = rb_str_new(
                     (const char *)sqlite3_column_text(stmt, i),
                     (long)sqlite3_column_bytes(stmt, i)
                 );
-#ifdef HAVE_RUBY_ENCODING_H
                 rb_enc_associate_index(str, rb_utf8_encindex());
                 if(internal_encoding)
                   str = rb_str_export_to_enc(str, internal_encoding);
-#endif
                 rb_ary_push(list, str);
               }
               break;
             case SQLITE_BLOB:
               {
-                VALUE str = rb_tainted_str_new(
+                VALUE str = rb_str_new(
                     (const char *)sqlite3_column_blob(stmt, i),
                     (long)sqlite3_column_bytes(stmt, i)
                 );
@@ -225,9 +226,7 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
   switch(TYPE(value)) {
     case T_STRING:
       if(CLASS_OF(value) == cSqlite3Blob
-#ifdef HAVE_RUBY_ENCODING_H
               || rb_enc_get_index(value) == rb_ascii8bit_encindex()
-#endif
         ) {
         status = sqlite3_bind_blob(
             ctx->st,
@@ -239,7 +238,6 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
       } else {
 
 
-#ifdef HAVE_RUBY_ENCODING_H
         if (UTF16_LE_P(value) || UTF16_BE_P(value)) {
           status = sqlite3_bind_text16(
               ctx->st,
@@ -252,7 +250,6 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
           if (!UTF8_P(value) || !USASCII_P(value)) {
               value = rb_str_encode(value, rb_enc_from_encoding(rb_utf8_encoding()), 0, Qnil);
           }
-#endif
         status = sqlite3_bind_text(
             ctx->st,
             index,
@@ -260,9 +257,7 @@ static VALUE bind_param(VALUE self, VALUE key, VALUE value)
             (int)RSTRING_LEN(value),
             SQLITE_TRANSIENT
             );
-#ifdef HAVE_RUBY_ENCODING_H
         }
-#endif
       }
       break;
     case T_BIGNUM: {
@@ -316,7 +311,7 @@ static VALUE reset_bang(VALUE self)
  * Resets the statement. This is typically done internally, though it might
  * occassionally be necessary to manually reset the statement.
  */
-static VALUE clear_bindings(VALUE self)
+static VALUE clear_bindings_bang(VALUE self)
 {
   sqlite3StmtRubyPtr ctx;
 
@@ -433,7 +428,7 @@ void init_sqlite3_statement()
   rb_define_method(cSqlite3Statement, "closed?", closed_p, 0);
   rb_define_method(cSqlite3Statement, "bind_param", bind_param, 2);
   rb_define_method(cSqlite3Statement, "reset!", reset_bang, 0);
-  rb_define_method(cSqlite3Statement, "clear_bindings!", clear_bindings, 0);
+  rb_define_method(cSqlite3Statement, "clear_bindings!", clear_bindings_bang, 0);
   rb_define_method(cSqlite3Statement, "step", step, 0);
   rb_define_method(cSqlite3Statement, "done?", done_p, 0);
   rb_define_method(cSqlite3Statement, "column_count", column_count, 0);

data/lib/sqlite3/constants.rb

@@ -6,6 +6,7 @@ module SQLite3 ; module Constants
     UTF16BE = 3
     UTF16   = 4
     ANY     = 5
+    DETERMINISTIC = 0x800
   end
 
   module ColumnType

data/lib/sqlite3/database.rb

@@ -54,12 +54,68 @@ 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
+
+      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
+      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 +192,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 +235,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 statments.
     def execute_batch( sql, bind_vars = [], *args )
       # FIXME: remove this stuff later
       unless [Array, Hash].include?(bind_vars.class)
@@ -234,6 +282,30 @@ 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 statments.
+    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:
     #
@@ -287,7 +359,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 +392,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 +440,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 +536,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 compatiblity 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 varibales 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 compatiblity shim
+      proxy = Class.new do
+        @template = aggregator
+        @name = name
 
-        def instance
-          @instance ||= @klass.new
+        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 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 +631,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 +712,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

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,12 +1,12 @@
 module SQLite3
 
-  VERSION = '1.3.13'
+  VERSION = '1.4.2'
 
   module VersionProxy
 
     MAJOR = 1
-    MINOR = 3
-    TINY  = 13
+    MINOR = 4
+    TINY  = 2
     BUILD = nil
 
     STRING = [ MAJOR, MINOR, TINY, BUILD ].compact.join( "." )

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