sqlite3 1.3.5 → 1.3.13

data/lib/sqlite3/resultset.rb

@@ -5,28 +5,66 @@ module SQLite3
 
   # The ResultSet object encapsulates the enumerability of a query's output.
   # It is a simple cursor over the data that the query returns. It will
-  # very rarely (if ever) be instantiated directly. Instead, client's should
+  # very rarely (if ever) be instantiated directly. Instead, clients should
   # obtain a ResultSet instance via Statement#execute.
   class ResultSet
     include Enumerable
 
-    # The class of which we return an object in case we want an Array as
-    # result. (ArrayFields is installed.)
-    class ArrayWithTypes < Array
+    class ArrayWithTypes < Array # :nodoc:
       attr_accessor :types
     end
 
-    # The class of which we return an object in case we want an Array as
-    # result. (ArrayFields is not installed.)
-    class ArrayWithTypesAndFields < Array
-      attr_accessor :types
-      attr_accessor :fields
+    class ArrayWithTypesAndFields < Array # :nodoc:
+      attr_writer :types
+      attr_writer :fields
+
+      def types
+        warn(<<-eowarn) if $VERBOSE
+#{caller[0]} is calling #{self.class}#types.  This method will be removed in
+sqlite3 version 2.0.0, please call the `types` method on the SQLite3::ResultSet
+object that created this object
+        eowarn
+        @types
+      end
+
+      def fields
+        warn(<<-eowarn) if $VERBOSE
+#{caller[0]} is calling #{self.class}#fields.  This method will be removed in
+sqlite3 version 2.0.0, please call the `columns` method on the SQLite3::ResultSet
+object that created this object
+        eowarn
+        @fields
+      end
     end
 
     # The class of which we return an object in case we want a Hash as
     # result.
-    class HashWithTypes < Hash
-      attr_accessor :types
+    class HashWithTypesAndFields < Hash # :nodoc:
+      attr_writer :types
+      attr_writer :fields
+
+      def types
+        warn(<<-eowarn) if $VERBOSE
+#{caller[0]} is calling #{self.class}#types.  This method will be removed in
+sqlite3 version 2.0.0, please call the `types` method on the SQLite3::ResultSet
+object that created this object
+        eowarn
+        @types
+      end
+
+      def fields
+        warn(<<-eowarn) if $VERBOSE
+#{caller[0]} is calling #{self.class}#fields.  This method will be removed in
+sqlite3 version 2.0.0, please call the `columns` method on the SQLite3::ResultSet
+object that created this object
+        eowarn
+        @fields
+      end
+
+      def [] key
+        key = fields[key] if key.is_a? Numeric
+        super key
+      end
     end
 
     # Create a new ResultSet attached to the given database, using the
@@ -63,6 +101,10 @@ module SQLite3
     # For hashes, the column names are the keys of the hash, and the column
     # types are accessible via the +types+ property.
     def next
+      if @db.results_as_hash
+        return next_hash
+      end
+
       row = @stmt.step
       return nil if @stmt.done?
 
@@ -72,33 +114,39 @@ module SQLite3
         end
       end
 
-      if @db.results_as_hash
-        new_row = HashWithTypes[*@stmt.columns.zip(row).flatten]
-        row.each_with_index { |value,idx|
-          new_row[idx] = value
-        }
-        row = new_row
+      if row.respond_to?(:fields)
+        # FIXME: this can only happen if the translator returns something
+        # that responds to `fields`.  Since we're removing the translator
+        # in 2.0, we can remove this branch in 2.0.
+        row = ArrayWithTypes.new(row)
       else
-        if row.respond_to?(:fields)
-          row = ArrayWithTypes.new(row)
-        else
-          row = ArrayWithTypesAndFields.new(row)
-        end
-        row.fields = @stmt.columns
+        # FIXME: the `fields` and `types` methods are deprecated on this
+        # object for version 2.0, so we can safely remove this branch
+        # as well.
+        row = ArrayWithTypesAndFields.new(row)
       end
 
+      row.fields = @stmt.columns
       row.types = @stmt.types
       row
     end
 
     # Required by the Enumerable mixin. Provides an internal iterator over the
     # rows of the result set.
-    def each( &block )
+    def each
       while node = self.next
         yield node
       end
     end
 
+    # Provides an internal iterator over the rows of the result set where
+    # each row is yielded as a hash.
+    def each_hash
+      while node = next_hash
+        yield node
+      end
+    end
+
     # Closes the statement that spawned this result set.
     # <em>Use with caution!</em> Closing a result set will automatically
     # close any other result sets that were spawned from the same statement.
@@ -121,6 +169,27 @@ module SQLite3
       @stmt.columns
     end
 
-  end
+    # Return the next row as a hash
+    def next_hash
+      row = @stmt.step
+      return nil if @stmt.done?
+
+      # 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
+
+      # FIXME: this can be switched to a regular hash in 2.0
+      row = HashWithTypesAndFields[*@stmt.columns.zip(row).flatten]
 
+      # FIXME: these methods are deprecated for version 2.0, so we can remove
+      # this code in 2.0
+      row.fields = @stmt.columns
+      row.types = @stmt.types
+      row
+    end
+  end
 end

data/lib/sqlite3/statement.rb

@@ -120,23 +120,6 @@ module SQLite3
       @types
     end
 
-    # A convenience method for obtaining the metadata about the query. Note
-    # that this will actually execute the SQL, which means it can be a
-    # (potentially) expensive operation.
-    def get_metadata
-      @columns = []
-      @types = []
-
-      column_count.times do |column|
-        @columns << column_name(column)
-        @types << column_decltype(column)
-      end
-
-      @columns.freeze
-      @types.freeze
-    end
-    private :get_metadata
-
     # Performs a sanity check to ensure that the statement is not
     # closed. If it is, an exception is raised.
     def must_be_open! # :nodoc:
@@ -144,5 +127,18 @@ module SQLite3
         raise SQLite3::Exception, "cannot use a closed statement"
       end
     end
+
+    private
+    # A convenience method for obtaining the metadata about the query. Note
+    # that this will actually execute the SQL, which means it can be a
+    # (potentially) expensive operation.
+    def get_metadata
+      @columns = Array.new(column_count) do |column|
+        column_name column
+      end
+      @types = Array.new(column_count) do |column|
+        column_decltype column
+      end
+    end
   end
 end

data/lib/sqlite3/version.rb

@@ -1,12 +1,12 @@
 module SQLite3
 
-  VERSION = '1.3.5'
+  VERSION = '1.3.13'
 
   module VersionProxy
 
     MAJOR = 1
     MINOR = 3
-    TINY  = 4
+    TINY  = 13
     BUILD = nil
 
     STRING = [ MAJOR, MINOR, TINY, BUILD ].compact.join( "." )

data/setup.rb

@@ -102,7 +102,7 @@ end
 
 class ConfigTable
 
-  c = ::Config::CONFIG
+  c = ::RbConfig::CONFIG
 
   rubypath = c['bindir'] + '/' + c['ruby_install_name']
 
@@ -1219,7 +1219,7 @@ class Installer
         raise InstallError, "no ruby extention exists: 'ruby #{$0} setup' first"
   end
 
-  DLEXT = /\.#{ ::Config::CONFIG['DLEXT'] }\z/
+  DLEXT = /\.#{ ::RbConfig::CONFIG['DLEXT'] }\z/
 
   def _ruby_extentions(dir)
     Dir.open(dir) {|d|

data/tasks/gem.rake

@@ -6,23 +6,29 @@ rescue LoadError
   require 'hoe'
 end
 
-Hoe.plugin :debugging, :doofus, :git
+Hoe.plugin :debugging, :doofus, :git, :minitest, :bundler
 
 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"
+
   self.readme_file   = 'README.rdoc'
   self.history_file  = 'CHANGELOG.rdoc'
   self.extra_rdoc_files  = FileList['*.rdoc', 'ext/**/*.c']
 
-  spec_extras[:required_ruby_version]     = Gem::Requirement.new('>= 1.8.7')
-  spec_extras[:required_rubygems_version] = '>= 1.3.5'
-  spec_extras[:extensions]                = ["ext/sqlite3/extconf.rb"]
+  require_ruby_version ">= 1.8.7"
+  require_rubygems_version ">= 1.3.5"
+
+  spec_extras[:extensions] = ["ext/sqlite3/extconf.rb"]
 
-  extra_dev_deps << ['rake-compiler', "~> 0.7.0"]
-  extra_dev_deps << ["mini_portile", "~> 0.2.2"]
+  extra_dev_deps << ['rake-compiler', "~> 0.9.3"]
+  extra_dev_deps << ['rake-compiler-dock', "~> 0.5.2"]
+  extra_dev_deps << ["mini_portile", "~> 0.6.2"]
+  extra_dev_deps << ["minitest", "~> 5.0"]
+  extra_dev_deps << ["hoe-bundler", "~> 1.0"]
 
   clean_globs.push('**/test.db')
 end

data/tasks/native.rake

@@ -1,14 +1,24 @@
 # use rake-compiler for building the extension
 require 'rake/extensiontask'
+require 'rake/extensioncompiler'
 
 # NOTE: version used by cross compilation of Windows native extension
 # It do not affect compilation under other operating systems
 # The version indicated is the minimum DLL suggested for correct functionality
-BINARY_VERSION = "3.7.9"
-URL_VERSION    = "3070900"
+BINARY_VERSION = "3.8.11.1"
+URL_VERSION    = "3081101"
+URL_PATH       = "/2015"
+
+task :devkit do
+  begin
+    require "devkit"
+  rescue LoadError => e
+    abort "Failed to activate RubyInstaller's DevKit required for compilation."
+  end
+end
 
 # build sqlite3_native C extension
-Rake::ExtensionTask.new('sqlite3_native', HOE.spec) do |ext|
+RUBY_EXTENSION = Rake::ExtensionTask.new('sqlite3_native', HOE.spec) do |ext|
   # where to locate the extension
   ext.ext_dir = 'ext/sqlite3'
 
@@ -23,11 +33,16 @@ Rake::ExtensionTask.new('sqlite3_native', HOE.spec) do |ext|
     # define target for extension (supporting fat binaries)
     RUBY_VERSION =~ /(\d+\.\d+)/
     ext.lib_dir = "lib/sqlite3/#{$1}"
-    ext.config_options << "--enable-local"
   else
-    ext.cross_compile = true
-    ext.cross_platform = ['i386-mswin32-60', 'i386-mingw32']
-    ext.cross_config_options << "--enable-local"
+
+    # detect cross-compiler available
+    begin
+      Rake::ExtensionCompiler.mingw_host
+      ext.cross_compile = true
+      ext.cross_platform = ['i386-mswin32-60', 'i386-mingw32', 'x64-mingw32']
+    rescue RuntimeError
+      # noop
+    end
   end
 end
 

data/tasks/vendor_sqlite3.rake

@@ -2,47 +2,96 @@ 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)
       cflags = "-O2 -DSQLITE_ENABLE_COLUMN_METADATA"
-      cflags << " -fPIC" if recipe.host.include?("x86_64")
+      cflags << " -fPIC" if recipe.host && recipe.host.include?("x86_64")
       recipe.configure_options << "CFLAGS='#{cflags}'"
       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
 
-task :cross do
-  host = ENV.fetch("HOST", Rake::ExtensionCompiler.mingw_host)
-  $recipes.each do |_, recipe|
-    recipe.host = host
+# 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
 
-  # hook compile task with dependencies
-  Rake::Task["compile"].prerequisites.unshift "ports:sqlite3"
+task :cross do
+  ["CC", "CXX", "LDFLAGS", "CPPFLAGS", "RUBYOPT"].each do |var|
+    ENV.delete(var)
+  end
 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