sequel 5.19.0 → 5.24.0

data/spec/bin_spec.rb

@@ -86,7 +86,7 @@ Begin creating indexes
 Finished creating indexes
 Begin adding foreign key constraints
 Finished adding foreign key constraints
-Database copy finished in \\d\\.\\d+ seconds
+Database copy finished in \\d+\\.\\d+ seconds
 END
     DB2.tables.sort_by{|t| t.to_s}.must_equal [:a, :b]
     DB[:a].all.must_equal [{:a=>1, :name=>'foo'}]

data/spec/core/database_spec.rb

@@ -264,6 +264,25 @@ describe "Database#log_connection_yield" do
     @o.logs.first.first.must_equal :info
     @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah; \[1, 2\]\z/)
   end
+
+  it "should log without a logger defined by forcing skip_logging? to return false" do
+    @db.logger = nil
+    @db.extend(Module.new do
+      def skip_logging?
+        false
+      end
+
+      def log_duration(*)
+        self.did_log = true
+      end
+
+      attr_accessor :did_log
+    end)
+
+    @db.log_connection_yield('some sql', @conn) {}
+
+    @db.did_log.must_equal true
+  end
 end
 
 describe "Database#uri" do
@@ -1140,15 +1159,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)
@@ -2002,6 +2092,18 @@ describe "Database#typecast_value" do
     proc{@db.typecast_value(:datetime, 4)}.must_raise(Sequel::InvalidValue)
   end
 
+  it "should raise an InvalidValue when given an invalid timezone value" do
+    begin
+      Sequel.default_timezone = :blah
+      proc{@db.typecast_value(:datetime, [2019, 2, 3, 4, 5, 6])}.must_raise(Sequel::InvalidValue)
+      Sequel.datetime_class = DateTime
+      proc{@db.typecast_value(:datetime, [2019, 2, 3, 4, 5, 6])}.must_raise(Sequel::InvalidValue)
+    ensure
+      Sequel.default_timezone = nil
+      Sequel.datetime_class = Time
+    end
+  end
+
   it "should handle integers with leading 0 as base 10" do
     @db.typecast_value(:integer, "013").must_equal 13
     @db.typecast_value(:integer, "08").must_equal 8
@@ -2246,6 +2348,17 @@ describe "Database#typecast_value" do
       @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14).must_equal Time.local(2011, 10, 11, 12, 13, 14)
       @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000).must_equal Time.local(2011, 10, 11, 12, 13, 14, 500000)
 
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :offset=>Rational(1, 2)).must_equal Time.new(2011, 10, 11, 12, 13, 14, 43200)
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000, :offset=>Rational(1, 2)).must_equal Time.new(2011, 10, 11, 12, 13, 14.5, 43200)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'offset'=>Rational(1, 2)).must_equal Time.new(2011, 10, 11, 12, 13, 14, 43200)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000, 'offset'=>Rational(1, 2)).must_equal Time.new(2011, 10, 11, 12, 13, 14.5, 43200)
+
+      Sequel.default_timezone = :utc
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14).must_equal Time.utc(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000).must_equal Time.utc(2011, 10, 11, 12, 13, 14, 500000)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14).must_equal Time.utc(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000).must_equal Time.utc(2011, 10, 11, 12, 13, 14, 500000)
+
       Sequel.datetime_class = DateTime
       @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14).must_equal DateTime.civil(2011, 10, 11, 12, 13, 14)
       @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000).must_equal DateTime.civil(2011, 10, 11, 12, 13, Rational(29, 2))
@@ -2255,8 +2368,16 @@ describe "Database#typecast_value" do
       @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000, :offset=>Rational(1, 2)).must_equal DateTime.civil(2011, 10, 11, 12, 13, Rational(29, 2), Rational(1, 2))
       @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'offset'=>Rational(1, 2)).must_equal DateTime.civil(2011, 10, 11, 12, 13, 14, Rational(1, 2))
       @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000, 'offset'=>Rational(1, 2)).must_equal DateTime.civil(2011, 10, 11, 12, 13, Rational(29, 2), Rational(1, 2))
+
+      Sequel.default_timezone = :local
+      offset = Rational(Time.local(2011, 10, 11, 12, 13, 14).utc_offset, 86400)
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14).must_equal DateTime.civil(2011, 10, 11, 12, 13, 14, offset)
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000).must_equal DateTime.civil(2011, 10, 11, 12, 13, Rational(29, 2), offset)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14).must_equal DateTime.civil(2011, 10, 11, 12, 13, 14, offset)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000).must_equal DateTime.civil(2011, 10, 11, 12, 13, Rational(29, 2), offset)
     ensure
       Sequel.datetime_class = Time
+      Sequel.default_timezone = nil
     end
   end
 

data/spec/core/dataset_spec.rb

@@ -3434,6 +3434,16 @@ describe "Dataset#multi_insert" do
       'COMMIT']
   end
   
+  it "should handle :return=>:primary_key option if dataset has a row_proc" do
+    @db.autoid = 1
+    @ds.with_row_proc(lambda{|h| Object.new}).multi_insert(@list, :return=>:primary_key).must_equal [1, 2, 3]
+    @db.sqls.must_equal ['BEGIN',
+      "INSERT INTO items (name) VALUES ('abc')",
+      "INSERT INTO items (name) VALUES ('def')",
+      "INSERT INTO items (name) VALUES ('ghi')",
+      'COMMIT']
+  end
+  
   with_symbol_splitting "should handle splittable symbols for tables" do
     @ds = @ds.from(:sch__tab)
     @ds.multi_insert(@list)
@@ -3715,7 +3725,7 @@ end
 
 describe "Dataset default #fetch_rows, #insert, #update, #delete, #truncate, #execute" do
   before do
-    @db = Sequel.mock(:servers=>{:read_only=>{}}, :autoid=>1)
+    @db = Sequel.mock(:servers=>{:read_only=>{}, :r1=>{}}, :autoid=>1)
     @ds = @db[:items]
   end
 
@@ -3753,6 +3763,18 @@ describe "Dataset default #fetch_rows, #insert, #update, #delete, #truncate, #ex
     @ds.for_update.send(:execute, 'SELECT 1')
     @db.sqls.must_equal ["SELECT 1"]
   end
+  
+  [:execute, :execute_dui, :execute_insert, :execute_ddl].each do |meth|
+    it "##{meth} should respect explicit :server option" do
+      @ds.send(meth, 'SELECT 1', :server=>:r1)
+      @db.sqls.must_equal ["SELECT 1 -- r1"]
+    end
+    
+    it "##{meth} should respect dataset's :server option if :server option not given" do
+      @ds.server(:r1).send(meth, 'SELECT 1')
+      @db.sqls.must_equal ["SELECT 1 -- r1"]
+    end
+  end
 end
 
 describe "Dataset#with_sql_*" do
@@ -4483,6 +4505,16 @@ describe "Sequel timezone support" do
     proc{Sequel.database_to_application_timestamp(Object.new)}.must_raise(Sequel::InvalidValue)
   end
 
+  it "should raise an InvalidValue error when the Time class is used and when a bad application timezone is used when attempting to convert timestamps" do
+    Sequel.application_timezone = :blah
+    proc{Sequel.database_to_application_timestamp('2009-06-01 10:20:30')}.must_raise(Sequel::InvalidValue)
+  end
+  
+  it "should raise an InvalidValue error when the Time class is used and when a bad database timezone is used when attempting to convert timestamps" do
+    Sequel.database_timezone = :blah
+    proc{Sequel.database_to_application_timestamp('2009-06-01 10:20:30')}.must_raise(Sequel::InvalidValue)
+  end
+
   it "should raise an InvalidValue error when the DateTime class is used and when a bad application timezone is used when attempting to convert timestamps" do
     Sequel.application_timezone = :blah
     Sequel.datetime_class = DateTime

data/spec/core/expression_filters_spec.rb

@@ -526,11 +526,35 @@ describe "Blockless Ruby Filters" do
     dsc.new(@d.db).literal(Sequel.trim(:a)).must_equal 'trimFOO(lower(a))'
   end
 
-  it "should endless ranges" do
+  it "should handle endless ranges" do
     endless = eval('1..')
     @d.l{x =~ endless}.must_equal '(x >= 1)'
     @d.l(:x => endless).must_equal '(x >= 1)'
+
+    endless = eval('1...')
+    @d.l{x =~ endless}.must_equal '(x >= 1)'
+    @d.l(:x => endless).must_equal '(x >= 1)'
   end if RUBY_VERSION >= '2.6'
+
+  it "should handle startless ranges" do
+    endless = eval('..1')
+    @d.l{x =~ endless}.must_equal '(x <= 1)'
+    @d.l(:x => endless).must_equal '(x <= 1)'
+
+    endless = eval('...1')
+    @d.l{x =~ endless}.must_equal '(x < 1)'
+    @d.l(:x => endless).must_equal '(x < 1)'
+  end if RUBY_VERSION >= '2.7'
+
+  it "should handle startless, endless ranges" do
+    endless = eval('nil..nil')
+    @d.l{x =~ endless}.must_equal '(1 = 1)'
+    @d.l(:x => endless).must_equal '(1 = 1)'
+
+    endless = eval('nil...nil')
+    @d.l{x =~ endless}.must_equal '(1 = 1)'
+    @d.l(:x => endless).must_equal '(1 = 1)'
+  end if RUBY_VERSION >= '2.7'
 end
 
 describe Sequel::SQL::VirtualRow do

data/spec/core/schema_spec.rb

@@ -240,6 +240,24 @@ describe "DB#create_table" do
     @db.sqls.must_equal ["CREATE TABLE cats (id integer, name text, UNIQUE (name) DEFERRABLE INITIALLY IMMEDIATE)"]
   end
   
+  it "should handle deferred unique column constraints" do
+    @db.create_table(:cats) do
+      integer :id, :unique=>true, :unique_deferrable=>true
+      integer :i, :unique=>true, :unique_deferrable=>:immediate
+      integer :j, :unique=>true, :unique_deferrable=>false
+    end
+    @db.sqls.must_equal ["CREATE TABLE cats (id integer UNIQUE DEFERRABLE INITIALLY DEFERRED, i integer UNIQUE DEFERRABLE INITIALLY IMMEDIATE, j integer UNIQUE NOT DEFERRABLE)"]
+  end
+  
+  it "should handle deferred primary key column constraints" do
+    @db.create_table(:cats) do
+      integer :id, :primary_key=>true, :primary_key_deferrable=>true
+      integer :i, :primary_key=>true, :primary_key_deferrable=>:immediate
+      integer :j, :primary_key=>true, :primary_key_deferrable=>false
+    end
+    @db.sqls.must_equal ["CREATE TABLE cats (id integer PRIMARY KEY DEFERRABLE INITIALLY DEFERRED, i integer PRIMARY KEY DEFERRABLE INITIALLY IMMEDIATE, j integer PRIMARY KEY NOT DEFERRABLE)"]
+  end
+  
   it "should accept unsigned definition" do
     @db.create_table(:cats) do
       integer :value, :unsigned => true
@@ -1777,17 +1795,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 +1823,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/insert_conflict_spec.rb

@@ -0,0 +1,103 @@
+require_relative "spec_helper"
+
+describe "insert_conflict plugin" do
+  def model_class(adapter)
+    db = Sequel.mock(:host=>adapter, :fetch=>{:id=>1, :s=>2}, :autoid=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model = Class.new(Sequel::Model)
+    model.dataset = db[:t]
+    model.columns :id, :s, :o
+    model.plugin :insert_conflict
+    db.sqls
+    model
+  end
+
+  def model_class_plugin_first(adapter)
+    model = Class.new(Sequel::Model)
+    model.plugin :insert_conflict
+    model = Class.new(model)
+    db = Sequel.mock(:host=>adapter, :fetch=>{:id=>1, :s=>2}, :autoid=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model.dataset = db[:t]
+    model.columns :id, :s, :o
+    db.sqls
+    model
+  end
+
+  it "should use INSERT ON CONFLICT when inserting on PostgreSQL" do
+    model = model_class(:postgres)
+    model.new(:s=>'A', :o=>1).insert_conflict.save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING RETURNING *"]
+
+    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o RETURNING *"]
+  end
+
+  it "should use INSERT ON CONFLICT when inserting on SQLITE" do
+    model = model_class(:sqlite)
+    model.new(:s=>'A', :o=>1).insert_conflict.save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING",
+      "SELECT * FROM t WHERE (id = 1) LIMIT 1"]
+
+    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o",
+      "SELECT * FROM t WHERE (id = 2) LIMIT 1"]
+  end
+
+  it "should raise Error if calling insert_conflict on a model instance that isn't new" do
+    m = model_class(:postgres).load(:s=>'A', :o=>1)
+    proc{m.insert_conflict}.must_raise Sequel::Error
+  end
+
+  it "should raise if loading plugin into a model class with a dataset that doesn't support insert_conflict" do
+    model = Class.new(Sequel::Model)
+    model.dataset = Sequel.mock[:t]
+    proc{model.plugin :insert_conflict}.must_raise Sequel::Error
+  end
+
+  it "should work if loading into a model class without a dataset on PostgreSQL" do
+    model = model_class_plugin_first(:postgres)
+    model.new(:s=>'A', :o=>1).insert_conflict.save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING RETURNING *"]
+
+    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o RETURNING *"]
+  end
+
+  it "should work if loading into a model class without a dataset on SQLITE" do
+    model = model_class_plugin_first(:sqlite)
+    model.new(:s=>'A', :o=>1).insert_conflict.save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING",
+      "SELECT * FROM t WHERE (id = 1) LIMIT 1"]
+
+    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o",
+      "SELECT * FROM t WHERE (id = 2) LIMIT 1"]
+  end
+
+  it "should work if the prepared_statements plugin is loaded before" do
+    db = Sequel.mock(:host=>'sqlite', :fetch=>{:id=>1, :s=>2}, :autoid=>1, :numrows=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model = Class.new(Sequel::Model)
+    model.dataset = db[:t]
+    model.columns :id, :s
+    model.plugin :prepared_statements
+    model.plugin :insert_conflict
+    db.sqls
+    model.create(:s=>'a').update(:s=>'b')
+    db.sqls.must_equal ["INSERT INTO t (s) VALUES ('a')", "SELECT * FROM t WHERE (id = 1) LIMIT 1", "UPDATE t SET s = 'b' WHERE (id = 1)"]
+  end
+
+  it "should work if the prepared_statements plugin is loaded after" do
+    db = Sequel.mock(:host=>'postgres', :fetch=>{:id=>1, :s=>2}, :autoid=>1, :numrows=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model = Class.new(Sequel::Model)
+    model.dataset = db[:t]
+    model.columns :id, :s
+    model.plugin :insert_conflict
+    model.plugin :prepared_statements
+    db.sqls
+    model.create(:s=>'a').update(:s=>'b')
+    db.sqls.must_equal ["INSERT INTO t (s) VALUES ('a') RETURNING *", "UPDATE t SET s = 'b' WHERE (id = 1)"]
+  end
+end