sequel 5.18.0 → 5.20.0

data/lib/sequel/plugins/prepared_statements.rb

@@ -149,7 +149,7 @@ module Sequel
         # Use a prepared statement to update this model's columns in the database.
         def _update_without_checking(columns)
           if use_prepared_statements_for?(:update)
-            _set_prepared_statement_server(model.send(:prepared_update, columns.keys)).call(Hash[columns].merge!(pk_hash))
+            _set_prepared_statement_server(model.send(:prepared_update, columns.keys)).call(columns.merge(pk_hash))
           else
             super
           end

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -67,7 +67,7 @@ module Sequel
         # of free columns.
         def before_create
           if v = model.prepared_statements_column_defaults
-            @values = Hash[v].merge!(values)
+            @values = v.merge(values)
           end
           super
         end

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/plugins/validation_helpers.rb

@@ -244,7 +244,7 @@ module Sequel
         def validates_unique(*atts)
           opts = default_validation_helpers_options(:unique)
           if atts.last.is_a?(Hash)
-            opts = Hash[opts].merge!(atts.pop)
+            opts = opts.merge(atts.pop)
           end
           message = validation_error_message(opts[:message])
           from_values = opts[:from] == :values
@@ -302,7 +302,7 @@ module Sequel
         # Merge the given options with the default options for the given type
         # and call validatable_attributes with the merged options.
         def validatable_attributes_for_type(type, atts, opts, &block)
-          validatable_attributes(atts, Hash[default_validation_helpers_options(type)].merge!(opts), &block)
+          validatable_attributes(atts, default_validation_helpers_options(type).merge(opts), &block)
         end
         
         # The validation error message to use, as a string.  If message

data/lib/sequel/sql.rb

@@ -1472,7 +1472,7 @@ module Sequel
 
       # Return a new function call with the given opts merged into the current opts.
       def with_opts(opts)
-        self.class.new!(name, args, Hash[@opts].merge!(opts))
+        self.class.new!(name, args, @opts.merge(opts))
       end
     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 = 18
+  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}
@@ -3930,6 +3948,14 @@ describe 'PostgreSQL enum types' do
     @db.schema(:test_enumt, :reload=>true).first.last[:enum_values].must_equal @initial_enum_values
     @db.rename_enum(:new_enum, :test_enum)
   end
+
+  it "should rename enum values" do
+    @db.rename_enum_value(:test_enum, :b, :x)
+    new_enum_values = @initial_enum_values
+    new_enum_values[new_enum_values.index('b')] = 'x'
+    @db.schema(:test_enumt, :reload=>true).first.last[:enum_values].must_equal new_enum_values
+    @db.rename_enum_value(:test_enum, :x, :b)
+  end if DB.server_version >= 100000
 end
 
 describe "PostgreSQL stored procedures for datasets" do
@@ -3980,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
@@ -4000,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
 
@@ -4009,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

@@ -1679,7 +1679,7 @@ describe "Schema Parser" do
     sch = @db.schema(:x)
     sch.must_equal [[:a, {:db_type=>"x", :ruby_default=>nil}], [:b, {:db_type=>"x", :ruby_default=>nil}]]
     sch[0][1][:db_type].must_be_same_as(sch[1][1][:db_type])
-  end if RUBY_VERSION >= '2.5' && !defined?(JRUBY_VERSION)
+  end if RUBY_VERSION >= '2.5'
 
   it "should set :auto_increment to true by default if unset and a single integer primary key is used" do
     @db.define_singleton_method(:schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer'}]]}
@@ -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/constraint_validations_spec.rb

@@ -20,6 +20,7 @@ describe "constraint_validations extension" do
   before do
     @db = Sequel.mock
     @db.extend(Module.new{attr_writer :schema; def schema(table, *) execute("parse schema for #{table}"); @schema; end})
+    def @db.table_exists?(_) true; end
     @db.extension(:constraint_validations)
   end
 
@@ -36,13 +37,13 @@ describe "constraint_validations extension" do
 
   it "should allow dropping the sequel_constraint_validations table" do
     @db.drop_constraint_validations_table
-    @db.sqls.must_equal ["DROP TABLE sequel_constraint_validations"]
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE (table = 'sequel_constraint_validations')", "DROP TABLE sequel_constraint_validations"]
   end
 
   it "should allow dropping the sequel_constraint_validations table with a non-default table name" do
     @db.constraint_validations_table = :foo
     @db.drop_constraint_validations_table
-    @db.sqls.must_equal ["DROP TABLE foo"]
+    @db.sqls.must_equal ["DELETE FROM foo WHERE (table = 'foo')", "DROP TABLE foo"]
   end
 
   it "should allow dropping validations for a given table" do
@@ -50,6 +51,23 @@ describe "constraint_validations extension" do
     @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE (table = 'foo')"]
   end
 
+  it "should drop validations for a given table when dropping the table" do
+    @db.drop_table(:foo)
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE (table = 'foo')", "DROP TABLE foo"]
+
+    @db.drop_table(:foo, :if_exists => true)
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE (table = 'foo')", "DROP TABLE IF EXISTS foo"]
+
+    @db.drop_table?(:foo)
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE (table = 'foo')", "DROP TABLE foo"]
+  end
+
+  it "should not drop validations for a given table if the constraint validations table does not exist" do
+    def @db.table_exists?(_) false; end
+    @db.drop_table(:foo)
+    @db.sqls.must_equal ["DROP TABLE foo"]
+  end
+
   it "should allow dropping validations for a given table and column" do
     @db.drop_constraint_validations_for(:table=>:foo, :column=>:bar)
     @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE ((table = 'foo') AND (column = 'bar'))"]

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