sequel 5.15.0 → 5.16.0

data/lib/sequel/dataset/sql.rb

@@ -717,8 +717,19 @@ module Sequel
 
     # Append literalization of subscripts (SQL array accesses) to SQL string.
     def subscript_sql_append(sql, s)
+      case s.expression
+      when Symbol, SQL::Subscript, SQL::Identifier, SQL::QualifiedIdentifier
+        # nothing
+      else
+        wrap_expression = true
+        sql << '('
+      end
       literal_append(sql, s.expression)
-      sql << '['
+      if wrap_expression
+        sql << ')['
+      else
+        sql << '['
+      end
       sub = s.sub
       if sub.length == 1 && (range = sub.first).is_a?(Range)
         literal_append(sql, range.begin)

data/lib/sequel/extensions/migration.rb

@@ -389,7 +389,8 @@ module Sequel
     #             using the :table and :column options.
     # :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).
+    # :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: 
@@ -405,6 +406,7 @@ module Sequel
     # 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('_', 2).first.to_i > 20000101
@@ -519,7 +521,6 @@ module Sequel
       raise(Error, "No current version available") unless current
 
       latest_version = latest_migration_version
-
       @target = if opts[:target]
         opts[:target]
       elsif opts[:relative]
@@ -528,7 +529,7 @@ module Sequel
         latest_version
       end
 
-      raise(Error, "No target version available, probably because no migration files found or filenames don't follow the migration filename convention") unless target
+      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

data/lib/sequel/model/associations.rb

@@ -2597,13 +2597,25 @@ module Sequel
         # Set the given object as the associated object for the given *_to_one association reflection
         def _set_associated_object(opts, o)
           a = associations[opts[:name]]
-          return if a && a == o && !set_associated_object_if_same?
+          reciprocal = opts.reciprocal
+          if set_associated_object_if_same?
+            if reciprocal
+              remove_reciprocal = a && (a != o || a.associations[reciprocal] != self)
+              add_reciprocal = o && o.associations[reciprocal] != self
+            end
+          else
+            return if a && a == o
+            if reciprocal
+              remove_reciprocal = a
+              add_reciprocal = o
+            end
+          end
           run_association_callbacks(opts, :before_set, o)
-          remove_reciprocal_object(opts, a) if a
+          remove_reciprocal_object(opts, a) if remove_reciprocal
           # Allow calling private _setter method
           send(opts[:_setter_method], o)
           associations[opts[:name]] = o
-          add_reciprocal_object(opts, o) if o
+          add_reciprocal_object(opts, o) if add_reciprocal
           run_association_callbacks(opts, :after_set, o)
           o
         end

data/lib/sequel/model/base.rb

@@ -765,9 +765,11 @@ module Sequel
 
       # Create a column accessor for a column with a method name that is hard to use in ruby code.
       def def_bad_column_accessor(column)
+        im = instance_methods
         overridable_methods_module.module_eval do
-          define_method(column){self[column]}
-          define_method("#{column}="){|v| self[column] = v}
+          meth = :"#{column}="
+          define_method(column){self[column]} unless im.include?(column)
+          define_method(meth){|v| self[column] = v} unless im.include?(meth)
         end
       end
   
@@ -779,7 +781,7 @@ module Sequel
         bad_columns.each{|x| def_bad_column_accessor(x)}
         im = instance_methods
         columns.each do |column|
-          meth = "#{column}="
+          meth = :"#{column}="
           overridable_methods_module.module_eval("def #{column}; self[:#{column}] end", __FILE__, __LINE__) unless im.include?(column)
           overridable_methods_module.module_eval("def #{meth}(v); self[:#{column}] = v end", __FILE__, __LINE__) unless im.include?(meth)
         end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -98,7 +98,7 @@ module Sequel
     #
     #   a = Executive.first
     #   a.values # {:id=>1, name=>'S', :kind=>'Executive', :num_staff=>4, :num_managers=>2}
-    #   
+    #
     # Note that when loading from a subclass, because the subclass dataset uses a subquery
     # that by default uses the same alias at the primary table, any qualified identifiers
     # should reference the subquery alias (and qualified identifiers should not be needed
@@ -281,14 +281,14 @@ module Sequel
           columns = nil
           if (n = subclass.name) && !n.empty?
             if table = cti_table_map[n.to_sym]
-              columns = db.from(table).columns
+              columns = db.schema(table).map(&:first)
             else
-              table = if cti_qualify_tables && (schema = dataset.schema_and_table(table_name).first)
+              table = if cti_qualify_tables && (schema = dataset.schema_and_table(cti_table_name).first)
                 SQL::QualifiedIdentifier.new(schema, subclass.implicit_table_name)
               else
                 subclass.implicit_table_name
               end
-              columns = check_non_connection_error(false){db.from(table).columns}
+              columns = check_non_connection_error(false){db.schema(table) && db.schema(table).map(&:first)}
               table = nil if !columns || columns.empty?
             end
           end
@@ -301,6 +301,7 @@ module Sequel
             if cti_tables.length == 1
               ds = ds.select(*self.columns.map{|cc| Sequel.qualify(cti_table_name, Sequel.identifier(cc))})
             end
+            ds.send(:columns=, self.columns)
             cols = (columns - [pk]) - cti_ignore_subclass_columns
             dup_cols = cols & ds.columns
             unless dup_cols.empty?
@@ -310,6 +311,7 @@ module Sequel
             @sti_dataset = ds = ds.join(table, pk=>pk).select_append(*sel_app)
 
             ds = ds.from_self(:alias=>@cti_alias)
+            ds.send(:columns=, self.columns + cols)
 
             set_dataset(ds)
             set_columns(self.columns)

data/lib/sequel/plugins/nested_attributes.rb

@@ -191,7 +191,10 @@ module Sequel
             if reflection[:type] == :many_to_one 
               before_save_hook{public_send(reflection[:setter_method], obj.save(:validate=>false))}
             else
-              after_save_hook{public_send(reflection[:setter_method], obj)}
+              after_save_hook do
+                obj.skip_validation_on_next_save!
+                public_send(reflection[:setter_method], obj)
+              end
             end
           end
           add_reciprocal_object(reflection, obj)

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 15
+  MINOR = 16
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

data/spec/bin_spec.rb

@@ -99,6 +99,13 @@ END
     DB2.foreign_key_list(:b).must_equal [{:columns=>[:a], :table=>:a, :key=>nil, :on_update=>:no_action, :on_delete=>:no_action}]
   end
 
+  it "-C should convert integer to bigint when copying from SQLite to other databases" do
+    DB.create_table(:a) do
+      Integer :id
+    end
+    bin(:args=>'-EC', :post=>"mock://postgres").must_include 'CREATE TABLE "a" ("id" bigint)'
+  end
+
   it "-d and -D should dump generic and specific migrations" do
     DB.create_table(:a) do
       primary_key :a

data/spec/core/database_spec.rb

@@ -1072,6 +1072,22 @@ DatabaseTransactionSpecs = shared_description do
     proc{@db.transaction(:prepare=>'XYZ'){@db.after_rollback{@db.execute('foo')}}}.must_raise(Sequel::Error)
     @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
   end
+
+  it "should have rollback_on_exit cause the transaction to rollback on exit" do
+    @db.transaction{@db.rollback_on_exit}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
+    catch(:foo){@db.transaction{@db.rollback_on_exit; throw :foo}}
+    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
+    lambda{@db.transaction{@db.rollback_on_exit; return true}}.call
+    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
+  end
+
+  it "should have rollback_on_exit with :cancel option will cause the transaction to commit on exit" do
+    @db.transaction{@db.rollback_on_exit(:cancel=>true)}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'COMMIT']
+    @db.transaction{@db.rollback_on_exit; @db.rollback_on_exit(:cancel=>true)}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'COMMIT']
+  end
 end
 
 describe "Database#transaction with savepoint support" do
@@ -1154,6 +1170,87 @@ describe "Database#transaction with savepoint support" do
     @db.transaction(:savepoint=>:only){}
     @db.sqls.must_equal []
   end
+
+  it "should have rollback_on_exit with :savepoint option inside transaction cause the transaction to rollback on exit" do
+    @db.transaction{@db.rollback_on_exit(:savepoint=>true)}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
+    catch(:foo){@db.transaction{@db.rollback_on_exit(:savepoint=>true); throw :foo}}
+    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
+    lambda{@db.transaction{@db.rollback_on_exit(:savepoint=>true); return true}}.call
+    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
+  end
+
+  it "should have rollback_on_exit with :savepoint option inside savepoint cause the savepoint to rollback on exit" do
+    @db.transaction{@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true)}}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'COMMIT']
+    catch(:foo){@db.transaction{@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true); throw :foo}}}
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'COMMIT']
+    lambda{@db.transaction{@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true); return true}}}.call
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'COMMIT']
+  end
+
+  it "should have rollback_on_exit with :savepoint option inside nested savepoint cause the current savepoint to rollback on exit" do
+    @db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true)}}}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+    catch(:foo){@db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true); throw :foo}}}}
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+    lambda{@db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true); return true}}}}.call
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+  end
+
+  it "should have rollback_on_exit with :savepoint=>1 option inside nested savepoint cause the current savepoint to rollback on exit" do
+    @db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>1)}}}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+    catch(:foo){@db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>1); throw :foo}}}}
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+    lambda{@db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>1); return true}}}}.call
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+  end
+
+  it "should have rollback_on_exit with :savepoint=>2 option inside nested savepoint cause the current and next savepoint to rollback on exit" do
+    @db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>2)}}}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'ROLLBACK TO SAVEPOINT autopoint_1', 'COMMIT']
+    catch(:foo){@db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>2); throw :foo}}}}
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'ROLLBACK TO SAVEPOINT autopoint_1', 'COMMIT']
+    lambda{@db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>2); return true}}}}.call
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'ROLLBACK TO SAVEPOINT autopoint_1', 'COMMIT']
+  end
+
+  it "should have rollback_on_exit with :savepoint=>3 option inside nested savepoint cause the three enclosing savepoints/transaction to rollback on exit" do
+    @db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>3)}}}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
+    catch(:foo){@db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>3); throw :foo}}}}
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
+    lambda{@db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>3); return true}}}}.call
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
+  end
+
+  it "should have rollback_on_exit with :savepoint and :cancel option will cause the transaction to commit on exit" do
+    @db.transaction{@db.rollback_on_exit(:savepoint=>true, :cancel=>true)}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'COMMIT']
+    @db.transaction{@db.rollback_on_exit(:savepoint=>true); @db.rollback_on_exit(:savepoint=>true, :cancel=>true)}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'COMMIT']
+  end
+
+  it "should have rollback_on_exit with :savepoint option called at different levels work correctly" do
+    @db.transaction{@db.rollback_on_exit(:savepoint=>true); @db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true)}}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
+
+    @db.transaction{@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true); @db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true)}}}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'SAVEPOINT autopoint_2','ROLLBACK TO SAVEPOINT autopoint_2', 'ROLLBACK TO SAVEPOINT autopoint_1', 'COMMIT']
+
+    @db.transaction{@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true); @db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true, :cancel=>true)}}}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'SAVEPOINT autopoint_2','RELEASE SAVEPOINT autopoint_2', 'ROLLBACK TO SAVEPOINT autopoint_1', 'COMMIT']
+
+    @db.transaction{@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true); @db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>2, :cancel=>true)}}}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'SAVEPOINT autopoint_2','RELEASE SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+
+    @db.transaction{@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true); @db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>3, :cancel=>true)}}}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'SAVEPOINT autopoint_2','RELEASE SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+
+    @db.transaction{@db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>true); @db.transaction(:savepoint=>true){@db.rollback_on_exit(:savepoint=>4, :cancel=>true)}}}.must_be_nil
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'SAVEPOINT autopoint_2','RELEASE SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+  end
 end
   
 describe "Database#transaction without savepoint support" do
@@ -1167,7 +1264,7 @@ describe "Database#transaction without savepoint support" do
     @db.sqls.must_equal ['BEGIN', 'COMMIT']
   end
 
-  it "should automatically use a savepoint if :rollback=>:always given inside a transaction" do
+  it "should not automatically use a savepoint if :rollback=>:always given inside a transaction" do
     proc do
       @db.transaction do
         @db.transaction(:rollback=>:always) do

data/spec/core/expression_filters_spec.rb

@@ -1271,7 +1271,7 @@ describe "Sequel::SQL::Wrapper" do
     @ds.literal(s**1).must_equal "power(foo, 1)"
     @ds.literal(s & true).must_equal "(foo AND 't')"
     @ds.literal(s < 1).must_equal "(foo < 1)"
-    @ds.literal(s.sql_subscript(1)).must_equal "foo[1]"
+    @ds.literal(s.sql_subscript(1)).must_equal "(foo)[1]"
     @ds.literal(s.like('a')).must_equal "(foo LIKE 'a' ESCAPE '\\')"
     @ds.literal(s.as(:a)).must_equal "foo AS a"
     @ds.literal(s.cast(Integer)).must_equal "CAST(foo AS integer)"
@@ -1302,6 +1302,18 @@ describe Sequel::SQL::Subscript do
     s = @s[2]
     @ds.literal(s).must_equal 'a[1][2]'
   end
+
+  it "should not wrap identifiers in parentheses" do
+    @ds.literal(Sequel::SQL::Subscript.new(:a, [1])).must_equal 'a[1]'
+    @ds.literal(Sequel::SQL::Subscript.new(Sequel[:a], [1])).must_equal 'a[1]'
+    @ds.literal(Sequel::SQL::Subscript.new(Sequel[:a][:b], [1])).must_equal 'a.b[1]'
+  end
+
+  it "should wrap other expression types in parentheses" do
+    @ds.literal(Sequel::SQL::Subscript.new(Sequel.function('a'), [1])).must_equal '(a())[1]'
+    @ds.literal(Sequel::SQL::Subscript.new(Sequel.lit('a'), [1])).must_equal '(a)[1]'
+    @ds.literal(Sequel::SQL::Subscript.new(Sequel.lit('a(?)', 2), [1])).must_equal '(a(2))[1]'
+  end
 end
 
 describe Sequel::SQL::CaseExpression, "#with_merged_expression" do

data/spec/extensions/class_table_inheritance_spec.rb

@@ -574,6 +574,7 @@ describe "class_table_inheritance plugin with dataset defined with QualifiedIden
       {Sequel[:hr][:employees]=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string}], [:kind, {:type=>:string}]],
        Sequel[:hr][:managers]=>[[:id, {:type=>:integer}]],
        Sequel[:hr][:staff]=>[[:id, {:type=>:integer}], [:manager_id, {:type=>:integer}]],
+       Sequel[:hr][:executives]=>[[:id, {:type=>:integer}], [:num_managers, {:type=>:integer}]],
       }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
     end
     @db.extend_datasets do
@@ -583,12 +584,13 @@ describe "class_table_inheritance plugin with dataset defined with QualifiedIden
          [Sequel[:hr][:staff]]=>[:id, :manager_id],
          [Sequel[:hr][:employees], Sequel[:hr][:managers]]=>[:id, :name, :kind],
          [Sequel[:hr][:employees], Sequel[:hr][:staff]]=>[:id, :name, :kind, :manager_id],
+         [Sequel[:hr][:employees], Sequel[:hr][:managers], Sequel[:hr][:executives]]=>[:id, :name, :kind, :manager_id, :num_managers],
         }[opts[:from] + (opts[:join] || []).map{|x| x.table}]
       end
     end
   end
   after do
-    [:Manager, :Staff, :Employee].each{|s| Object.send(:remove_const, s) if Object.const_defined?(s)}
+    [:Manager, :Staff, :Employee, :Executive].each{|s| Object.send(:remove_const, s) if Object.const_defined?(s)}
   end
 
   describe "with table_map used to qualify subclasses" do
@@ -675,10 +677,52 @@ describe "class_table_inheritance plugin with dataset defined with QualifiedIden
       class ::Staff < ::Employee
         many_to_one :manager
       end
+      class ::Executive < ::Manager
+      end
 
       Employee.dataset.sql.must_equal 'SELECT * FROM hr.employees'
       Manager.dataset.sql.must_equal 'SELECT * FROM (SELECT hr.employees.id, hr.employees.name, hr.employees.kind FROM hr.employees INNER JOIN hr.managers ON (hr.managers.id = hr.employees.id)) AS employees'
       Staff.dataset.sql.must_equal 'SELECT * FROM (SELECT hr.employees.id, hr.employees.name, hr.employees.kind, hr.staff.manager_id FROM hr.employees INNER JOIN hr.staff ON (hr.staff.id = hr.employees.id)) AS employees'
+      Executive.dataset.sql.must_equal 'SELECT * FROM (SELECT hr.employees.id, hr.employees.name, hr.employees.kind, hr.executives.num_managers FROM hr.employees INNER JOIN hr.managers ON (hr.managers.id = hr.employees.id) INNER JOIN hr.executives ON (hr.executives.id = hr.managers.id)) AS employees'
+    end
+  end
+end
+
+describe "class_table_inheritance plugin with schema_caching extension" do
+  before do
+    @db = Sequel.mock(:autoid=>proc{|sql| 1})
+    def @db.supports_schema_parsing?() true end
+    def @db.schema(table, opts={})
+      {:employees=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string}], [:kind, {:type=>:string}]],
+       :managers=>[[:id, {:type=>:integer}], [:num_staff, {:type=>:integer}] ],
+       :executives=>[[:id, {:type=>:integer}], [:num_managers, {:type=>:integer}]],
+       }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
     end
   end
+  after do
+    [:Executive, :Manager, :Employee, :Staff].each{|s| Object.send(:remove_const, s) if Object.const_defined?(s)}
+  end
+
+  it "should not query for columns if the schema cache is present and a table_map is given" do
+    class ::Employee < Sequel::Model(@db)
+      plugin :class_table_inheritance, :table_map=>{:Staff=>:employees, :Manager=>:managers, :Executive=>:executives}
+    end
+    class ::Staff < Employee; end
+    class ::Manager < Employee; end
+    class ::Executive < Manager; end
+    Employee.columns.must_equal [:id, :name, :kind]
+    Staff.columns.must_equal [:id, :name, :kind]
+    Manager.columns.must_equal [:id, :name, :kind, :num_staff]
+    Executive.columns.must_equal [:id, :name, :kind, :num_staff, :num_managers]
+    @db.sqls.must_equal []
+  end
+
+  it "should not query for columns if the schema cache is present and no table_map is given" do
+    class ::Employee < Sequel::Model(@db)
+      plugin :class_table_inheritance
+    end
+    class ::Manager < Employee; end
+    class ::Executive < Manager; end
+    @db.sqls.must_equal []
+  end
 end

data/spec/extensions/migration_spec.rb

@@ -237,6 +237,11 @@ describe "Sequel::Migrator.migrator_class" do
     Sequel::IntegerMigrator.migrator_class("spec/files/timestamped_migrations").must_equal Sequel::IntegerMigrator
     Sequel::TimestampMigrator.migrator_class("spec/files/integer_migrations").must_equal Sequel::TimestampMigrator
   end
+
+  it "should raise an error if the migration folder does not exist" do
+    proc{Sequel::Migrator.apply(@db, "spec/files/nonexistant_migration_path")}.must_raise(Sequel::Migrator::Error)
+  end
+  
 end
 
 describe "Sequel::IntegerMigrator" do
@@ -283,19 +288,19 @@ describe "Sequel::IntegerMigrator" do
   after do
     Object.send(:remove_const, "CreateSessions") if Object.const_defined?("CreateSessions")
   end
-  
-  it "should raise and error if there is a missing integer migration version" do
+
+  it "should raise an error if there is a missing integer migration version" do
     proc{Sequel::Migrator.apply(@db, "spec/files/missing_integer_migrations")}.must_raise(Sequel::Migrator::Error)
   end
   
-  it "should not raise and error if there is a missing integer migration version and allow_missing_migration_files is true" do
+  it "should not raise an error if there is a missing integer migration version and allow_missing_migration_files is true" do
     Sequel::Migrator.run(@db, "spec/files/missing_integer_migrations", :allow_missing_migration_files => true)
     @db.sqls.last.must_equal "UPDATE schema_info SET version = 3"
     Sequel::Migrator.run(@db, "spec/files/missing_integer_migrations", :allow_missing_migration_files => true, :target=>0)
     @db.sqls.last.must_equal "UPDATE schema_info SET version = 0"
   end
 
-  it "should raise and error if there is a duplicate integer migration version" do
+  it "should raise an error if there is a duplicate integer migration version" do
     proc{Sequel::Migrator.apply(@db, "spec/files/duplicate_integer_migrations")}.must_raise(Sequel::Migrator::Error)
   end
 
@@ -307,6 +312,12 @@ describe "Sequel::IntegerMigrator" do
     proc{Sequel::Migrator.apply(@db, "spec/files/double_migration")}.must_raise(Sequel::Migrator::Error)
   end
 
+  it "should raise an error if the most recent migration can't be detected" do
+    # Have to specify a target version, otherwise an earlier check (inability
+    # to detect the target) would raise an error, falsely matching the check.
+    proc{Sequel::Migrator.apply(@db, "spec/files/empty_migration_folder", 2)}.must_raise(Sequel::Migrator::Error)
+  end
+
   it "should add a column name if it doesn't already exist in the schema_info table" do
     @db.create_table(:schema_info){Integer :v}
     def @db.alter_table(*); end