sequel 5.19.0 → 5.20.0

data/lib/sequel/plugins/subset_conditions.rb

@@ -26,8 +26,8 @@ module Sequel
     #   Album.where(Album.published_conditions | {ready: true}).sql
     #   # SELECT * FROM albums WHERE ((published IS TRUE) OR (ready IS TRUE))
     module SubsetConditions
-      def self.apply(mod, &block)
-        mod.instance_exec do
+      def self.apply(model, &block)
+        model.instance_exec do
           @dataset_module_class = Class.new(@dataset_module_class) do
             include DatasetModuleMethods
           end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -188,13 +188,17 @@ module Sequel
         #                   Sequel will attempt to insert a NULL value into the database, instead of using the
         #                   database's default.
         # :allow_nil :: Whether to skip the validation if the value is nil.
-        # :if :: A symbol (indicating an instance_method) or proc (which is instance_execed)
+        # :if :: A symbol (indicating an instance_method) or proc (which is used to define an instance method)
         #        skipping this validation if it returns nil or false.
         # :tag :: The tag to use for this validation.
         def validates_each(*atts, &block)
           opts = extract_options!(atts)
           blank_meth = db.method(:blank_object?).to_proc
           blk = if (i = opts[:if]) || (am = opts[:allow_missing]) || (an = opts[:allow_nil]) || (ab = opts[:allow_blank])
+            if i.is_a?(Proc)
+              i = Plugins.def_sequel_method(self, "validation_class_methods_if", 0, &i)
+            end
+
             proc do |o,a,v|
               next if i && !validation_if_proc(o, i)
               next if an && Array(v).all?(&:nil?)
@@ -434,8 +438,6 @@ module Sequel
           case i
           when Symbol
             o.get_column_value(i)
-          when Proc
-            o.instance_exec(&i)
           else
             raise(::Sequel::Error, "invalid value for :if validation option")
           end

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 = 19
+  MINOR = 20
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

data/spec/adapters/postgres_spec.rb

@@ -104,6 +104,24 @@ describe "PostgreSQL", '#create_table' do
     @db.check_constraints(:tmp_dolls).must_equal(:ic=>{:definition=>"CHECK ((i > 2))", :columns=>[:i]}, :jc=>{:definition=>"CHECK ((j > 2))", :columns=>[:j]}, :ijc=>{:definition=>"CHECK (((i - j) > 2))", :columns=>[:i, :j]})
   end
 
+  it "should have #check_constraints return check constraints where columns are unknown" do
+    begin
+      @db.create_table(:tmp_dolls) do
+        Integer :i
+        Integer :j
+      end
+      @db.run "CREATE OR REPLACE FUNCTION valid_tmp_dolls(t1 tmp_dolls) RETURNS boolean AS 'SELECT false' LANGUAGE SQL;"
+      @db.alter_table(:tmp_dolls) do
+        add_constraint(:valid_tmp_dolls, Sequel.function(:valid_tmp_dolls, :tmp_dolls))
+      end
+
+      @db.check_constraints(:tmp_dolls).must_equal(:valid_tmp_dolls=>{:definition=>"CHECK (valid_tmp_dolls(tmp_dolls.*))", :columns=>[]})
+    ensure
+      @db.run "ALTER TABLE tmp_dolls DROP CONSTRAINT IF EXISTS valid_tmp_dolls"
+      @db.run "DROP FUNCTION IF EXISTS valid_tmp_dolls(tmp_dolls)"
+    end
+  end if DB.server_version >= 90000
+
   it "should not allow to pass both :temp and :unlogged" do
     proc do
       @db.create_table(:temp_unlogged_dolls, :temp => true, :unlogged => true){text :name}
@@ -3988,6 +4006,10 @@ describe "pg_auto_constraint_validations plugin" do
       constraint :valid_i, Sequel[:i] < 10
       constraint(:valid_i_id, Sequel[:i] + Sequel[:id] < 20)
     end
+    @db.run "CREATE OR REPLACE FUNCTION valid_test1(t1 test1) RETURNS boolean AS 'SELECT t1.i != -100' LANGUAGE SQL;"
+    @db.alter_table(:test1) do
+      add_constraint(:valid_test1, Sequel.function(:valid_test1, :test1))
+    end
     @db.create_table!(:test2) do
       Integer :test2_id, :primary_key=>true
       foreign_key :test1_id, :test1
@@ -4008,6 +4030,8 @@ describe "pg_auto_constraint_validations plugin" do
     @c2.insert(:test2_id=>3, :test1_id=>1)
   end
   after(:all) do
+    @db.run "ALTER TABLE test1 DROP CONSTRAINT IF EXISTS valid_test1"
+    @db.run "DROP FUNCTION IF EXISTS valid_test1(test1)"
     @db.drop_table?(:test2, :test1)
   end
 
@@ -4017,6 +4041,14 @@ describe "pg_auto_constraint_validations plugin" do
     o.errors.must_equal(:i=>['is invalid'])
   end
 
+  it "should handle check constraint failures where the columns are unknown, if columns are explicitly specified" do
+    o = @c1.new(:id=>5, :i=>-100)
+    proc{o.save}.must_raise Sequel::CheckConstraintViolation
+    @c1.pg_auto_constraint_validation_override(:valid_test1, :i, "should not be -100")
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['should not be -100'])
+  end
+
   it "should handle check constraint failures as validation errors when updating" do
     o = @c1.new(:id=>5, :i=>3)
     o.save

data/spec/core/database_spec.rb

@@ -1140,15 +1140,86 @@ describe "Database#transaction with savepoint support" do
   end
 
   it "should support after_rollback inside savepoints" do
-    @db.transaction do
+    @db.transaction(:rollback=>:always) do
       @db.after_rollback{@db.execute('foo')}
       @db.transaction(:savepoint=>true){@db.after_rollback{@db.execute('bar')}}
       @db.after_rollback{@db.execute('baz')}
-      raise Sequel::Rollback
     end
     @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'RELEASE SAVEPOINT autopoint_1', 'ROLLBACK', 'foo', 'bar', 'baz']
   end
 
+  it "should run after_commit if savepoint rolled back" do
+    @db.transaction do
+      @db.after_commit{@db.execute('foo')}
+      @db.transaction(:savepoint=>true, :rollback=>:always){@db.after_commit{@db.execute('bar')}}
+    end
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'ROLLBACK TO SAVEPOINT autopoint_1', 'COMMIT', 'foo', 'bar']
+  end
+
+  it "should not run after_commit if savepoint rolled back and :savepoint option used" do
+    @db.transaction do
+      @db.after_commit{@db.execute('foo')}
+      @db.transaction(:savepoint=>true, :rollback=>:always){@db.after_commit(:savepoint=>true){@db.execute('bar')}}
+    end
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'ROLLBACK TO SAVEPOINT autopoint_1', 'COMMIT', 'foo']
+  end
+
+  it "should not run after_commit if higher-level savepoint rolled back and :savepoint option used" do
+    @db.transaction do
+      @db.after_commit{@db.execute('foo')}
+      @db.transaction(:savepoint=>true, :rollback=>:always){@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){@db.execute('bar')}}}
+    end
+    @db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "SAVEPOINT autopoint_2", "RELEASE SAVEPOINT autopoint_2", "ROLLBACK TO SAVEPOINT autopoint_1", "COMMIT", "foo"]
+  end
+
+  it "should not run after_commit if transaction rolled back and :savepoint option used" do
+    @db.transaction(:rollback=>:always) do
+      @db.after_commit{@db.execute('foo')}
+      @db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){@db.execute('bar')}}}
+    end
+    @db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "SAVEPOINT autopoint_2", "RELEASE SAVEPOINT autopoint_2", "RELEASE SAVEPOINT autopoint_1", "ROLLBACK"]
+  end
+
+  it "should run after_rollback if savepoint rolls back" do
+    @db.transaction(:rollback=>:always) do
+      @db.after_rollback{@db.execute('foo')}
+      @db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback{@db.execute('bar')}}
+      @db.after_rollback{@db.execute('baz')}
+    end
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK', 'foo', 'bar', 'baz']
+  end
+
+  it "should run after_rollback when savepoint rolls back if :savepoint option used" do
+    @db.transaction(:rollback=>:always) do
+      @db.after_rollback{@db.execute('foo')}
+      @db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback(:savepoint=>true){@db.execute('bar')}}
+      @db.after_rollback{@db.execute('baz')}
+    end
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'ROLLBACK TO SAVEPOINT autopoint_1', 'bar', 'ROLLBACK', 'foo', 'baz']
+  end
+
+  it "should run after_rollback if savepoint rolled back and :savepoint option used, even if transaction commits" do
+    @db.transaction do
+      @db.after_commit{@db.execute('foo')}
+      @db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback(:savepoint=>true){@db.execute('bar')}}
+    end
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'ROLLBACK TO SAVEPOINT autopoint_1', 'bar', 'COMMIT', 'foo']
+  end
+
+  it "should run after_rollback if higher-level savepoint rolled back and :savepoint option used" do
+    @db.transaction do
+      @db.transaction(:savepoint=>true, :rollback=>:always){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){@db.execute('bar')}}}
+    end
+    @db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "SAVEPOINT autopoint_2", "RELEASE SAVEPOINT autopoint_2", "ROLLBACK TO SAVEPOINT autopoint_1", "bar", "COMMIT"]
+  end
+
+  it "should run after_rollback if transaction rolled back and :savepoint option used" do
+    @db.transaction(:rollback=>:always) do
+      @db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){@db.execute('bar')}}}
+    end
+    @db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "SAVEPOINT autopoint_2", "RELEASE SAVEPOINT autopoint_2", "RELEASE SAVEPOINT autopoint_1", "ROLLBACK", "bar"]
+  end
+
   it "should raise an error if you attempt to use after_commit inside a savepoint in a prepared transaction" do
     @db.define_singleton_method(:supports_prepared_transactions?){true}
     proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_commit{@db.execute('foo')}}}}.must_raise(Sequel::Error)

data/spec/core/schema_spec.rb

@@ -1777,17 +1777,21 @@ describe "Schema Parser" do
     @db.schema(:text).first.last[:type].must_equal :string
     @db.schema(:date).first.last[:type].must_equal :date
     @db.schema(:datetime).first.last[:type].must_equal :datetime
+    @db.schema(:smalldatetime).first.last[:type].must_equal :datetime
     @db.schema(:timestamp).first.last[:type].must_equal :datetime
     @db.schema(:"timestamp with time zone").first.last[:type].must_equal :datetime
     @db.schema(:"timestamp without time zone").first.last[:type].must_equal :datetime
     @db.schema(:time).first.last[:type].must_equal :time
     @db.schema(:"time with time zone").first.last[:type].must_equal :time
     @db.schema(:"time without time zone").first.last[:type].must_equal :time
+    @db.schema(:bool).first.last[:type].must_equal :boolean
     @db.schema(:boolean).first.last[:type].must_equal :boolean
     @db.schema(:real).first.last[:type].must_equal :float
     @db.schema(:float).first.last[:type].must_equal :float
+    @db.schema(:"float unsigned").first.last[:type].must_equal :float
     @db.schema(:double).first.last[:type].must_equal :float
     @db.schema(:"double(1,2)").first.last[:type].must_equal :float
+    @db.schema(:"double(1,2) unsigned").first.last[:type].must_equal :float
     @db.schema(:"double precision").first.last[:type].must_equal :float
     @db.schema(:number).first.last[:type].must_equal :decimal
     @db.schema(:numeric).first.last[:type].must_equal :decimal
@@ -1801,6 +1805,8 @@ describe "Schema Parser" do
     @db.schema(:nchar).first.last[:type].must_equal :string
     @db.schema(:nvarchar).first.last[:type].must_equal :string
     @db.schema(:ntext).first.last[:type].must_equal :string
+    @db.schema(:clob).first.last[:type].must_equal :string
+    @db.schema(:ntext).first.last[:type].must_equal :string
     @db.schema(:smalldatetime).first.last[:type].must_equal :datetime
     @db.schema(:binary).first.last[:type].must_equal :blob
     @db.schema(:varbinary).first.last[:type].must_equal :blob

data/spec/extensions/class_table_inheritance_spec.rb

@@ -5,8 +5,8 @@ describe "class_table_inheritance plugin" do
     @db = Sequel.mock(:numrows=>1, :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}] ],
+      {:employees=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string, :allow_null=>false}], [:kind, {:type=>:string}]],
+       :managers=>[[:id, {:type=>:integer}], [:num_staff, {:type=>:integer, :allow_null=>false}] ],
        :executives=>[[:id, {:type=>:integer}], [:num_managers, {:type=>:integer}]],
        :staff=>[[:id, {:type=>:integer}], [:manager_id, {:type=>:integer}]],
        }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
@@ -23,7 +23,9 @@ describe "class_table_inheritance plugin" do
         }[opts[:from] + (opts[:join] || []).map{|x| x.table}]
       end
     end
-    class ::Employee < Sequel::Model(@db)
+    base = Sequel::Model(@db)
+    base.plugin :auto_validations if @use_auto_validations
+    class ::Employee < base
       def _save_refresh; @values[:id] = 1 end
       def self.columns
         dataset.columns || dataset.opts[:from].first.expression.columns
@@ -114,6 +116,26 @@ describe "class_table_inheritance plugin" do
       "SELECT * FROM (SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (employees.kind IN ('Ceo'))) AS employees WHERE (id = 1) LIMIT 1"]
   end
   
+  describe "with auto_validations plugin" do
+    before(:all) do
+      @use_auto_validations = true
+    end
+
+    it "should work" do
+      e = Employee.new
+      e.valid?.must_equal false
+      e.errors.must_equal(:name=>["is not present"])
+
+      e = Manager.new
+      e.valid?.must_equal false
+      e.errors.must_equal(:name=>["is not present"], :num_staff=>["is not present"])
+
+      e = Executive.new
+      e.valid?.must_equal false
+      e.errors.must_equal(:name=>["is not present"], :num_staff=>["is not present"])
+    end
+  end
+    
   it "should return rows with the current class if sti_key is nil" do
     Employee.plugin :class_table_inheritance
     Employee.dataset.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}, {:kind=>'Intern'}]).all.map{|x| x.class}.must_equal [Employee, Employee, Employee, Employee, Employee, Employee]
@@ -232,11 +254,11 @@ describe "class_table_inheritance plugin" do
   end
   
   it "should include schema for columns for tables for ancestor classes" do
-    Employee.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string})
-    Manager.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer})
-    Executive.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer}, :num_managers=>{:type=>:integer})
-    Staff.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :manager_id=>{:type=>:integer})
-    Intern.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string})
+    Employee.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string, :allow_null=>false}, :kind=>{:type=>:string})
+    Manager.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string, :allow_null=>false}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer, :allow_null=>false})
+    Executive.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string, :allow_null=>false}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer, :allow_null=>false}, :num_managers=>{:type=>:integer})
+    Staff.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string, :allow_null=>false}, :kind=>{:type=>:string}, :manager_id=>{:type=>:integer})
+    Intern.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string, :allow_null=>false}, :kind=>{:type=>:string})
   end
 
   it "should use the correct primary key (which should have the same name in all subclasses)" do

data/spec/extensions/core_refinements_spec.rb

@@ -1,6 +1,6 @@
 require_relative "spec_helper"
 
-if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') # || (RUBY_VERSION >= '2.3.0' && RUBY_ENGINE == 'jruby')
+if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') || (RUBY_ENGINE == 'jruby' && (JRUBY_VERSION >= '9.3' || (JRUBY_VERSION.match(/\A9\.2\.(\d+)/) && $1.to_i >= 7)))
 Sequel.extension :core_refinements, :pg_array, :pg_hstore, :pg_row, :pg_range, :pg_row_ops, :pg_range_ops, :pg_array_ops, :pg_hstore_ops, :pg_json, :pg_json_ops
 using Sequel::CoreRefinements
 

data/spec/extensions/hook_class_methods_spec.rb

@@ -22,6 +22,28 @@ describe Sequel::Model, "hook_class_methods plugin" do
     hooks.values.all?(&:frozen?).must_equal true
   end
 
+  deprecated ".hook_blocks method should yield each hook block" do
+    c = model_class.call Sequel::Model
+    a = []
+    c.hook_blocks(:before_save){|b| a << b}
+    a.must_equal []
+
+    pr = proc{adds << 'hi'}
+    c.before_save(&pr)
+    a = []
+    c.hook_blocks(:before_save){|b| a << b}
+    a.must_equal [pr]
+
+    c.before_save(&pr)
+    a = []
+    c.hook_blocks(:before_save){|b| a << b}
+    a.must_equal [pr, pr]
+
+    a = []
+    c.hook_blocks(:after_save){|b| a << b}
+    a.must_equal []
+  end
+
   it "should be definable using a block" do
     adds = []
     c = model_class.call Sequel::Model do

data/spec/extensions/migration_spec.rb

@@ -195,6 +195,19 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
       [:drop_table, :a, {:foo=>:bar}]]
   end
   
+  it "should reverse add_foreign_key with :type option" do
+    Sequel.migration{change{alter_table(:t){add_foreign_key :b, :c, :type=>:f}}}.apply(@db, :down)
+    actions = @db.actions
+    actions.must_equal [[:alter_table, [[:drop_foreign_key, :b, {:type=>:f}]]]]
+    @db.sqls
+    db = Sequel.mock
+    args = nil
+    db.define_singleton_method(:foreign_key_list){|*a| args = a; [{:name=>:fbc, :columns=>[:b]}]}
+    db.alter_table(:t){send(*actions[0][1][0])}
+    db.sqls.must_equal ["ALTER TABLE t DROP CONSTRAINT fbc", "ALTER TABLE t DROP COLUMN b"]
+    args.must_equal [:t]
+  end
+  
   it "should reverse add_foreign_key with :foreign_key_constraint_name option" do
     Sequel.migration{change{alter_table(:t){add_foreign_key :b, :c, :foreign_key_constraint_name=>:f}}}.apply(@db, :down)
     actions = @db.actions

data/spec/extensions/pg_auto_constraint_validations_spec.rb

@@ -161,4 +161,12 @@ describe "pg_auto_constraint_validations plugin" do
     proc{o.save}.must_raise Sequel::ValidationFailed
     o.errors.must_equal(:i=>['is invalid'], :id=>['is invalid'])
   end
+
+  it "should handle overridden constraint failures as validation errors when updating" do
+    o = @c.load(:i=>3)
+    @c.pg_auto_constraint_validation_override(:items_i_ocheck, :i, "foo bar")
+    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_ocheck']
+    proc{o.update(:i=>12)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['foo bar'])
+  end
 end

data/spec/extensions/s_spec.rb

@@ -29,7 +29,7 @@ describe "s extension as refinement" do
 end
 
 
-if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') # || (RUBY_VERSION >= '2.3.0' && RUBY_ENGINE == 'jruby')
+if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') || (RUBY_ENGINE == 'jruby' && (JRUBY_VERSION >= '9.3' || (JRUBY_VERSION.match(/\A9\.2\.(\d+)/) && $1.to_i >= 7)))
 using Sequel::S
 
 describe "s extension as refinement" do

data/spec/extensions/schema_dumper_spec.rb

@@ -800,14 +800,16 @@ END_MIG
   it "should convert mysql types to ruby types" do
     def @d.schema(t, *o)
       i = 0
-      ['double(15,2)', 'double(7,1) unsigned'].map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
+      ['float unsigned', 'double(15,2)', 'double(7,1) unsigned'].map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
     end
     @d.dump_table_schema(:x).must_equal((<<END_MIG).chomp)
 create_table(:x) do
   Float :c1
   Float :c2
+  Float :c3
   
-  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c2), 0)
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c1), 0)
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c3), 0)
 end
 END_MIG
   end

data/spec/integration/plugin_test.rb

@@ -30,6 +30,7 @@ describe "Class Table Inheritance Plugin" do
     end 
     class ::Manager < Employee
       one_to_many :staff_members, :class=>:Staff
+      one_to_one :first_staff_member, :clone=>:staff_members, :order=>:id
     end 
     class ::Executive < Manager
     end 
@@ -150,6 +151,8 @@ describe "Class Table Inheritance Plugin" do
     m = Staff.first.manager
     m.must_equal Manager[@i4]
     m.must_be_kind_of(Executive)
+    Staff.first.update(:manager => Manager[@i3])
+    Staff.first.manager.must_equal Manager[@i3]
   end
   
   it "should handle eagerly loading many_to_one relationships" do
@@ -164,6 +167,18 @@ describe "Class Table Inheritance Plugin" do
   
   it "should handle one_to_many relationships" do
     Executive.first(:name=>'Ex').staff_members.must_equal [Staff[@i2]]
+    i6 = @db[:employees].insert(:name=>'S2', :kind=>'Staff')
+    @db[:staff].insert(:id=>i6, :manager_id=>@i4)
+    Executive.first(:name=>'Ex').add_staff_member(i6)
+    Executive.first(:name=>'Ex').staff_members{|ds| ds.order(:id)}.must_equal [Staff[@i2], Staff[i6]]
+  end
+  
+  it "should handle one_to_many relationships" do
+    Executive.first(:name=>'Ex').first_staff_member.must_equal Staff[@i2]
+    i6 = @db[:employees].insert(:name=>'S2', :kind=>'Staff')
+    @db[:staff].insert(:id=>i6, :manager_id=>@i4)
+    Executive.first(:name=>'Ex').first_staff_member = Staff[i6]
+    Executive.first(:name=>'Ex').staff_members.must_equal [Staff[i6]]
   end
   
   it "should handle eagerly loading one_to_many relationships" do

data/spec/integration/transaction_test.rb

@@ -496,6 +496,56 @@ describe "Database transactions" do
       @db.transaction{@db.transaction(:savepoint=>true){@db.after_rollback{c = 1}}; c.must_be_nil; raise Sequel::Rollback}
       c.must_equal 1
     end
+
+    it "should support after_commit inside savepoints with :savepoint_option" do
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}; c.must_be_nil}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}}; c.must_be_nil}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_commit(:savepoint=>true){c = 1}}}
+      c.must_be_nil
+
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}}
+      c.must_be_nil
+
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}}}
+      c.must_be_nil
+    end
+
+    it "should support after_rollback inside savepoints with :savepoint_option" do
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback(:savepoint=>true){c = 1}; c.must_be_nil}; c.must_equal 1}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback(:savepoint=>true){c = 1}; c.must_be_nil}; c.must_equal 1}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback(:savepoint=>true){c = 1}; c.must_be_nil}; c.must_equal 1}}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true, :rollback=>:always){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}; c.must_equal 1}
+      c.must_equal 1
+    end
   end
 
   if DB.supports_prepared_transactions?