sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/index_caching.rb

@@ -0,0 +1,109 @@
+# frozen-string-literal: true
+#
+# The index_caching extension adds a few methods to Sequel::Database
+# that make it easy to dump information about database indexes to a file,
+# and load it from that file.  Loading index information from a
+# dumped file is faster than parsing it from the database, so this
+# can save bootup time for applications with large numbers of index.
+#
+# Basic usage in application code:
+#
+#   DB = Sequel.connect('...')
+#   DB.extension :index_caching
+#   DB.load_index_cache('/path/to/index_cache.dump')
+#
+#   # load model files
+#
+# Then, whenever database indicies are modified, write a new cached
+# file.  You can do that with <tt>bin/sequel</tt>'s -X option:
+#
+#   bin/sequel -X /path/to/index_cache.dump postgres://...
+#
+# Alternatively, if you don't want to dump the index information for
+# all tables, and you don't worry about race conditions, you can
+# choose to use the following in your application code:
+#
+#   DB = Sequel.connect('...')
+#   DB.extension :index_caching
+#   DB.load_index_cache?('/path/to/index_cache.dump')
+#
+#   # load model files
+#
+#   DB.dump_index_cache?('/path/to/index_cache.dump')
+#
+# With this method, you just have to delete the index dump file if
+# the schema is modified, and the application will recreate it for you
+# using just the tables that your models use.
+#
+# Note that it is up to the application to ensure that the dumped
+# index cache reflects the current state of the database.  Sequel
+# does no checking to ensure this, as checking would take time and the
+# purpose of this code is to take a shortcut.
+#
+# The index cache is dumped in Marshal format, since it is the fastest
+# and it handles all ruby objects used in the indexes hash.  Because of this,
+# you should not attempt to load from an untrusted file.
+#
+# Related module: Sequel::IndexCaching
+
+#
+module Sequel
+  module IndexCaching
+    # Set index cache to the empty hash.
+    def self.extended(db)
+      db.instance_variable_set(:@indexes, {})
+    end
+    
+    # Dump the index cache to the filename given in Marshal format.
+    def dump_index_cache(file)
+      File.open(file, 'wb'){|f| f.write(Marshal.dump(@indexes))}
+      nil
+    end
+
+    # Dump the index cache to the filename given unless the file
+    # already exists.
+    def dump_index_cache?(file)
+      dump_index_cache(file) unless File.exist?(file)
+    end
+
+    # Replace the index cache with the data from the given file, which
+    # should be in Marshal format.
+    def load_index_cache(file)
+      @indexes = Marshal.load(File.read(file))
+      nil
+    end
+
+    # Replace the index cache with the data from the given file if the
+    # file exists.
+    def load_index_cache?(file)
+      load_index_cache(file) if File.exist?(file)
+    end
+
+    # If no options are provided and there is cached index information for
+    # the table, return the cached information instead of querying the
+    # database.
+    def indexes(table, opts=OPTS)
+      return super unless opts.empty?
+
+      quoted_name = literal(table)
+      if v = Sequel.synchronize{@indexes[quoted_name]}
+        return v
+      end
+
+      result = super
+      Sequel.synchronize{@indexes[quoted_name] = result}
+      result
+    end
+
+    private
+
+    # Remove the index cache for the given schema name
+    def remove_cached_schema(table)
+      k = quote_schema_table(table)
+      Sequel.synchronize{@indexes.delete(k)}
+      super
+    end
+  end
+
+  Database.register_extension(:index_caching, IndexCaching)
+end

data/lib/sequel/extensions/inflector.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The inflector extension adds inflection instance methods to String, which allows the easy transformation of
 # words from singular to plural, class names to table names, modularized class
 # names to ones without, and class names to foreign keys.  It exists for 
@@ -6,6 +8,8 @@
 # To load the extension:
 #
 #   Sequel.extension :inflector
+#
+# Related module: String::Inflections
 
 class String
   # This module acts as a singleton returned/yielded by String.inflections,
@@ -91,8 +95,8 @@ class String
       (@uncountables << words).flatten!
     end
 
-    Sequel.require('default_inflections', 'model')
-    instance_eval(&Sequel::DEFAULT_INFLECTIONS_PROC)
+    require_relative '../model/default_inflections'
+    instance_exec(&Sequel::DEFAULT_INFLECTIONS_PROC)
   end
 
   # Yield the Inflections module if a block is given, and return
@@ -147,7 +151,7 @@ class String
   # Example
   #   "puni_puni".dasherize #=> "puni-puni"
   def dasherize
-    gsub(/_/, '-')
+    gsub('_', '-')
   end
 
   # Removes the module part from the expression in the string
@@ -177,7 +181,7 @@ class String
   #   "employee_salary" #=> "Employee salary"
   #   "author_id" #=> "Author"
   def humanize
-    gsub(/_id$/, "").gsub(/_/, " ").capitalize
+    gsub(/_id$/, "").gsub('_', " ").capitalize
   end
 
   # Returns the plural form of the word in the string.

data/lib/sequel/extensions/integer64.rb

@@ -0,0 +1,32 @@
+# frozen-string-literal: true
+#
+# The integer64 extension changes the default type used for Integer
+# to be the same type as used for :Bignum.  In general, this means that
+# instead of Integer resulting in a 32-bit database integer type, it will
+# result in a 64-bit database integer type.  This affects the default
+# type used for primary_key and foreign_key when using the schema
+# modification methods.
+#
+# Note that it doesn't make sense to use this extension on SQLite, since
+# the integer type will automatically handle 64-bit integers, and it treats
+# the integer type specially when the column is also the primary key.
+# 
+# To load the extension into the database:
+#
+#   DB.extension :integer64
+#
+# Related module: Sequel::Integer64
+
+#
+module Sequel
+  module Integer64
+    private
+
+    # Use same type as used for :Bignum by default for generic integer value.
+    def type_literal_generic_integer(column)
+      type_literal_generic_bignum_symbol(column)
+    end
+  end
+
+  Database.register_extension(:integer64, Integer64)
+end

data/lib/sequel/extensions/looser_typecasting.rb

@@ -1,18 +1,24 @@
+# frozen-string-literal: true
+#
 # The LooserTypecasting extension loosens the default database typecasting
 # for the following types:
 #
 # :float :: use to_f instead of Float()
 # :integer :: use to_i instead of Integer()
-# :decimal :: don't check string conversion with Float()
+# :decimal :: use 0.0 for unsupported strings
 # :string :: silently allow hash and array conversion to string
 #
 # To load the extension into the database:
 #
 #   DB.extension :looser_typecasting
+#
+# Related module: Sequel::LooserTypecasting
 
 #
 module Sequel
   module LooserTypecasting
+    private
+
     # Typecast the value to a Float using to_f instead of Kernel.Float
     def typecast_value_float(value)
       value.to_f
@@ -23,19 +29,23 @@ module Sequel
       value.to_i
     end
 
-    # Typecast the value to an Integer using to_i instead of Kernel.Integer
+    # Typecast the value to an String using to_s instead of Kernel.String
     def typecast_value_string(value)
       value.to_s
     end
 
-    # Typecast the value to a BigDecimal, without checking if strings
-    # have a valid format.
-    def typecast_value_decimal(value)
-      if value.is_a?(String)
-        BigDecimal.new(value)
-      else
-        super
+    if RUBY_VERSION >= '2.4'
+      def _typecast_value_string_to_decimal(value)
+        BigDecimal(value)
+      rescue
+        BigDecimal('0.0')
+      end
+    else
+      # :nocov:
+      def _typecast_value_string_to_decimal(value)
+        BigDecimal(value)
       end
+      # :nocov:
     end
   end
 

data/lib/sequel/extensions/migration.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # Adds the Sequel::Migration and Sequel::Migrator classes, which allow
 # the user to easily group schema changes and migrate the database
 # to a newer version or revert to a previous version.
@@ -5,6 +7,10 @@
 # To load the extension:
 #
 #   Sequel.extension :migration
+#
+# Related modules: Sequel::Migration, Sequel::SimpleMigration,
+# Sequel::MigrationDSL, Sequel::MigrationReverser, Sequel::MigrationAlterTableReverser,
+# Sequel::Migrator, Sequel::IntegerMigrator, Sequel::TimestampMigrator
 
 #
 module Sequel
@@ -35,7 +41,7 @@ module Sequel
     # direction.
     def self.apply(db, direction)
       raise(ArgumentError, "Invalid migration direction specified (#{direction.inspect})") unless [:up, :down].include?(direction)
-      new(db).send(direction)
+      new(db).public_send(direction)
     end
 
     # Returns the list of Migration descendants.
@@ -59,8 +65,10 @@ module Sequel
     
     # Intercepts method calls intended for the database and sends them along.
     def method_missing(method_sym, *args, &block)
+      # Allow calling private methods for backwards compatibility
       @db.send(method_sym, *args, &block)
     end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
     # This object responds to all methods the database responds to.
     def respond_to_missing?(meth, include_private)
@@ -93,29 +101,29 @@ module Sequel
     end
 
     # Apply the appropriate block on the +Database+
-    # instance using instance_eval.
+    # instance using instance_exec.
     def apply(db, direction)
       raise(ArgumentError, "Invalid migration direction specified (#{direction.inspect})") unless [:up, :down].include?(direction)
-      if prok = send(direction)
-        db.instance_eval(&prok)
+      if prok = public_send(direction)
+        db.instance_exec(&prok)
       end
     end
   end
 
   # Internal class used by the Sequel.migration DSL, part of the +migration+ extension.
   class MigrationDSL < BasicObject
-    # The underlying Migration instance
+    # The underlying SimpleMigration instance
     attr_reader :migration
 
     def self.create(&block)
       new(&block).migration
     end
 
-    # Create a new migration class, and instance_eval the block.
+    # Create a new migration class, and instance_exec the block.
     def initialize(&block)
       @migration = SimpleMigration.new
       Migration.descendants << migration
-      instance_eval(&block)
+      instance_exec(&block)
     end
 
     # Defines the migration's down action.
@@ -144,7 +152,7 @@ module Sequel
     # the block.
     #
     # There are no guarantees that this will work perfectly
-    # in all cases, but it should work for most common cases.
+    # in all cases, but it works for some simple cases.
     def change(&block)
       migration.up = block
       migration.down = MigrationReverser.new.reverse(&block)
@@ -164,22 +172,19 @@ module Sequel
     # the given block.
     def reverse(&block)
       begin
-        instance_eval(&block)
+        instance_exec(&block)
       rescue
         just_raise = true
       end
       if just_raise
-        Proc.new{raise Sequel::Error, 'irreversible migration method used, you may need to write your own down method'}
+        Proc.new{raise Sequel::Error, "irreversible migration method used in #{block.source_location.first}, you may need to write your own down method"}
       else
         actions = @actions.reverse
         Proc.new do
           actions.each do |a|
-            if a.last.is_a?(Proc)
-              pr = a.pop
-              send(*a, &pr)
-            else
-              send(*a)
-            end
+            pr = a.last.is_a?(Proc) ? a.pop : nil
+            # Allow calling private methods as the reversing methods are private
+            send(*a, &pr)
           end
         end
       end
@@ -227,8 +232,9 @@ module Sequel
     end
 
     def reverse(&block)
-      instance_eval(&block)
+      instance_exec(&block)
       actions = @actions.reverse
+      # Allow calling private methods as the reversing methods are private
       Proc.new{actions.each{|a| send(*a)}}
     end
 
@@ -239,7 +245,9 @@ module Sequel
     end
 
     def add_constraint(*args)
-      @actions << [:drop_constraint, args.first]
+      name = args.first
+      name = name.is_a?(Hash) ? name[:name] : name
+      @actions << [:drop_constraint, name]
     end
 
     def add_foreign_key(key, table, *args)
@@ -322,30 +330,32 @@ module Sequel
   # schema_migrations for timestamped migrations). in the database to keep track
   # of the current migration version. If no migration version is stored in the
   # database, the version is considered to be 0. If no target version is 
-  # specified, the database is migrated to the latest version available in the
+  # specified, or the target version specified is greater than the latest
+  # version available, the database is migrated to the latest version available in the
   # migration directory.
   #
   # For example, to migrate the database to the latest version:
   #
-  #   Sequel::Migrator.apply(DB, '.')
+  #   Sequel::Migrator.run(DB, '.')
   #
   # For example, to migrate the database all the way down:
   #
-  #   Sequel::Migrator.apply(DB, '.', 0)
+  #   Sequel::Migrator.run(DB, '.', target: 0)
   #
   # For example, to migrate the database to version 4:
   #
-  #   Sequel::Migrator.apply(DB, '.', 4)
+  #   Sequel::Migrator.run(DB, '.', target: 4)
   #
   # To migrate the database from version 1 to version 5:
   #
-  #   Sequel::Migrator.apply(DB, '.', 5, 1)
+  #   Sequel::Migrator.run(DB, '.', target: 5, current: 1)
   #
   # Part of the +migration+ extension.
   class Migrator
     MIGRATION_FILE_PATTERN = /\A(\d+)_.+\.rb\z/i.freeze
-    MIGRATION_SPLITTER = '_'.freeze
-    MINIMUM_TIMESTAMP = 20000101
+
+    # Mutex used around migration file loading
+    MUTEX = Mutex.new
 
     # Exception class raised when there is an error with the migrator's
     # file structure, database, or arguments.
@@ -379,26 +389,29 @@ module Sequel
     # :column :: The column in the :table argument storing the migration version (default: :version).
     # :current :: The current version of the database.  If not given, it is retrieved from the database
     #             using the :table and :column options.
-    # :table :: The table containing the schema version (default: :schema_info).
+    # :relative :: Run the given number of migrations, with a positive number being migrations to migrate
+    #              up, and a negative number being migrations to migrate down (IntegerMigrator only).
+    # :table :: The table containing the schema version (default: :schema_info for integer migrations and
+    #           :schema_migrations for timestamped migrations).
     # :target :: The target version to which to migrate.  If not given, migrates to the maximum version.
     #
     # Examples: 
     #   Sequel::Migrator.run(DB, "migrations")
-    #   Sequel::Migrator.run(DB, "migrations", :target=>15, :current=>10)
-    #   Sequel::Migrator.run(DB, "app1/migrations", :column=> :app2_version)
-    #   Sequel::Migrator.run(DB, "app2/migrations", :column => :app2_version, :table=>:schema_info2)
+    #   Sequel::Migrator.run(DB, "migrations", target: 15, current: 10)
+    #   Sequel::Migrator.run(DB, "app1/migrations", column: :app2_version)
+    #   Sequel::Migrator.run(DB, "app2/migrations", column: :app2_version, table: :schema_info2)
     def self.run(db, directory, opts=OPTS)
       migrator_class(directory).new(db, directory, opts).run
     end
 
     # Choose the Migrator subclass to use.  Uses the TimestampMigrator
-    # if the version number appears to be a unix time integer for a year
-    # after 2005, otherwise uses the IntegerMigrator.
+    # if the version number is greater than 20000101, otherwise uses the IntegerMigrator.
     def self.migrator_class(directory)
       if self.equal?(Migrator)
+        raise(Error, "Must supply a valid migration path") unless File.directory?(directory)
         Dir.new(directory).each do |file|
           next unless MIGRATION_FILE_PATTERN.match(file)
-          return TimestampMigrator if file.split(MIGRATION_SPLITTER, 2).first.to_i > MINIMUM_TIMESTAMP
+          return TimestampMigrator if file.split('_', 2).first.to_i > 20000101
         end
         IntegerMigrator
       else
@@ -438,9 +451,9 @@ module Sequel
       @directory = directory
       @allow_missing_migration_files = opts[:allow_missing_migration_files]
       @files = get_migration_files
-      schema, table = @db.send(:schema_and_table, opts[:table]  || self.class.const_get(:DEFAULT_SCHEMA_TABLE))
+      schema, table = @db.send(:schema_and_table, opts[:table] || default_schema_table)
       @table = schema ? Sequel::SQL::QualifiedIdentifier.new(schema, table) : table
-      @column = opts[:column] || self.class.const_get(:DEFAULT_SCHEMA_COLUMN)
+      @column = opts[:column] || default_schema_column
       @ds = schema_dataset
       @use_transactions = opts[:use_transactions]
     end
@@ -467,19 +480,24 @@ module Sequel
       end
     end
 
-    # Remove all migration classes.  Done by the migrator to ensure that
-    # the correct migration classes are picked up.
-    def remove_migration_classes
-      # Remove class definitions
-      Migration.descendants.each do |c|
-        Object.send(:remove_const, c.to_s) rescue nil
+    # Load the migration file, raising an exception if the file does not define
+    # a single migration.
+    def load_migration_file(file)
+      MUTEX.synchronize do
+        n = Migration.descendants.length
+        load(file)
+        raise Error, "Migration file #{file.inspect} not containing a single migration detected" unless n + 1 == Migration.descendants.length
+        c = Migration.descendants.pop
+        if c.is_a?(Class) && !c.name.to_s.empty? && Object.const_defined?(c.name)
+          Object.send(:remove_const, c.name)
+        end
+        c
       end
-      Migration.descendants.clear # remove any defined migration classes
     end
 
     # Return the integer migration version based on the filename.
     def migration_version_from_file(filename)
-      filename.split(MIGRATION_SPLITTER, 2).first.to_i
+      filename.split('_', 2).first.to_i
     end
   end
 
@@ -487,9 +505,6 @@ module Sequel
   # version number starting with 1, where missing or duplicate migration file
   # versions are not allowed.  Part of the +migration+ extension.
   class IntegerMigrator < Migrator
-    DEFAULT_SCHEMA_COLUMN = :version
-    DEFAULT_SCHEMA_TABLE = :schema_info
-
     Error = Migrator::Error
 
     # The current version for this migrator
@@ -504,13 +519,31 @@ module Sequel
     # Set up all state for the migrator instance
     def initialize(db, directory, opts=OPTS)
       super
-      @target = opts[:target] || latest_migration_version
       @current = opts[:current] || current_migration_version
 
-      raise(Error, "No current version available") unless current
-      raise(Error, "No target version available, probably because no migration files found or filenames don't follow the migration filename convention") unless target
+      latest_version = latest_migration_version
+      @target = if opts[:target]
+        opts[:target]
+      elsif opts[:relative]
+        @current + opts[:relative]
+      else
+        latest_version
+      end
+
+      raise(Error, "No target and/or latest version available, probably because no migration files found or filenames don't follow the migration filename convention") unless target && latest_version
+
+      if @target > latest_version
+        @target = latest_version
+      elsif @target < 0
+        @target = 0
+      end
 
       @direction = current < target ? :up : :down
+
+      if @direction == :down && @current >= @files.length
+        raise Migrator::Error, "Missing migration version(s) needed to migrate down to target version (current: #{current}, target: #{target})"
+      end
+
       @migrations = get_migrations
     end
 
@@ -522,13 +555,13 @@ module Sequel
     # Apply all migrations on the database
     def run
       migrations.zip(version_numbers).each do |m, v|
-        t = Time.now
+        timer = Sequel.start_timer
         db.log_info("Begin applying migration version #{v}, direction: #{direction}")
         checked_transaction(m) do
           m.apply(db, direction)
           set_migration_version(up? ? v : v-1)
         end
-        db.log_info("Finished applying migration version #{v}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
+        db.log_info("Finished applying migration version #{v}, direction: #{direction}, took #{sprintf('%0.6f', Sequel.elapsed_seconds_since(timer))} seconds")
       end
       
       target
@@ -542,6 +575,16 @@ module Sequel
       ds.get(column) || 0
     end
 
+    # The default column storing schema version.
+    def default_schema_column
+      :version
+    end
+
+    # The default table storing schema version.
+    def default_schema_table
+      :schema_info
+    end
+
     # Returns any found migration files in the supplied directory.
     def get_migration_files
       files = []
@@ -561,13 +604,7 @@ module Sequel
     # Returns a list of migration classes filtered for the migration range and
     # ordered according to the migration direction.
     def get_migrations
-      remove_migration_classes
-
-      # load migration files
-      version_numbers.each{|n| load(files[n])}
-      
-      # get migration classes
-      Migration.descendants
+      version_numbers.map{|n| load_migration_file(files[n])}
     end
     
     # Returns the latest version available in the specified directory.
@@ -590,7 +627,7 @@ module Sequel
       ds
     end
     
-    # Sets the current migration  version stored in the database.
+    # Sets the current migration version stored in the database.
     def set_migration_version(version)
       ds.update(column=>version)
     end
@@ -604,25 +641,24 @@ module Sequel
     # so that each number in the array is the migration version
     # that will be in affect after the migration is run.
     def version_numbers
-      versions = files.
-        compact.
-        map{|f| migration_version_from_file(File.basename(f))}.
-        select{|v| up? ? (v > current && v <= target) : (v <= current && v > target)}.
-        sort
-      versions.reverse! unless up?
-      versions
+      @version_numbers ||= begin
+        versions = files.
+          compact.
+          map{|f| migration_version_from_file(File.basename(f))}.
+          select{|v| up? ? (v > current && v <= target) : (v <= current && v > target)}.
+          sort
+        versions.reverse! unless up?
+        versions
+      end
     end
   end
 
-  # The migrator used if any migration file version appears to be a timestamp.
+  # The migrator used if any migration file version is greater than 20000101.
   # Stores filenames of migration files, and can figure out which migrations
   # have not been applied and apply them, even if earlier migrations are added
   # after later migrations.  If you plan to do that, the responsibility is on
   # you to make sure the migrations don't conflict. Part of the +migration+ extension.
   class TimestampMigrator < Migrator
-    DEFAULT_SCHEMA_COLUMN = :filename
-    DEFAULT_SCHEMA_TABLE = :schema_migrations
-    
     Error = Migrator::Error
 
     # Array of strings of applied migration filenames
@@ -653,7 +689,7 @@ module Sequel
         checked_transaction(m) do
           m.apply(db, direction)
           fi = f.downcase
-          direction == :up ? ds.insert(column=>fi) : ds.filter(column=>fi).delete
+          direction == :up ? ds.insert(column=>fi) : ds.where(column=>fi).delete
         end
         db.log_info("Finished applying migration #{f}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
       end
@@ -665,7 +701,7 @@ module Sequel
     # Convert the schema_info table to the new schema_migrations table format,
     # using the version of the schema_info table and the current migration files.
     def convert_from_schema_info
-      v = db[IntegerMigrator::DEFAULT_SCHEMA_TABLE].get(IntegerMigrator::DEFAULT_SCHEMA_COLUMN)
+      v = db[:schema_info].get(:version)
       ds = db.from(table)
       files.each do |path|
         f = File.basename(path)
@@ -675,6 +711,16 @@ module Sequel
       end
     end
 
+    # The default column storing migration filenames.
+    def default_schema_column
+      :filename
+    end
+
+    # The default table storing migration filenames.
+    def default_schema_table
+      :schema_migrations
+    end
+
     # Returns filenames of all applied migrations
     def get_applied_migrations
       am = ds.select_order_map(column)
@@ -695,26 +741,21 @@ module Sequel
     
     # Returns tuples of migration, filename, and direction
     def get_migration_tuples
-      remove_migration_classes
       up_mts = []
       down_mts = []
-      ms = Migration.descendants
       files.each do |path|
         f = File.basename(path)
         fi = f.downcase
         if target
           if migration_version_from_file(f) > target
             if applied_migrations.include?(fi)
-              load(path)
-              down_mts << [ms.last, f, :down]
+              down_mts << [load_migration_file(path), f, :down]
             end
           elsif !applied_migrations.include?(fi)
-            load(path)
-            up_mts << [ms.last, f, :up]
+            up_mts << [load_migration_file(path), f, :up]
           end
         elsif !applied_migrations.include?(fi)
-          load(path)
-          up_mts << [ms.last, f, :up]
+          up_mts << [load_migration_file(path), f, :up]
         end
       end
       up_mts + down_mts.reverse
@@ -726,7 +767,18 @@ module Sequel
       c = column
       ds = db.from(table)
       if !db.table_exists?(table)
-        db.create_table(table){String c, :primary_key=>true}
+        begin
+          db.create_table(table){String c, :primary_key=>true}
+        rescue Sequel::DatabaseError => e
+          if db.database_type == :mysql && e.message =~ /max key length/
+            # Handle case where MySQL is used with utf8mb4 charset default, which
+            # only allows a maximum length of about 190 characters for string
+            # primary keys due to InnoDB limitations.
+            db.create_table(table){String c, :primary_key=>true, :size=>190}
+          else
+            raise e
+          end
+        end
         if db.table_exists?(:schema_info) and vha = db[:schema_info].all and vha.length == 1 and
            vha.first.keys == [:version] and vha.first.values.first.is_a?(Integer)
           convert_from_schema_info