sequel 5.7.1 → 5.8.0

data/lib/sequel/plugins/subclasses.rb

@@ -21,7 +21,7 @@ module Sequel
     # You can also finalize the associations and then freeze the classes
     # in all descendent classes.  Doing so is a recommended practice after
     # all models have been defined in production and testing, and this makes
-    # it easier that keeping track of the classes to finalize and freeze
+    # it easier than keeping track of the classes to finalize and freeze
     # manually:
     #
     #   c.freeze_descendants

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -94,7 +94,7 @@ module Sequel
         def load_associated_objects(opts, dynamic_opts=OPTS, &block)
           dynamic_opts = load_association_objects_options(dynamic_opts, &block)
           name = opts[:name]
-          if (!associations.include?(name) || dynamic_opts[:eager_reload]) && retrieved_by && !frozen? && !dynamic_opts[:callback] && !dynamic_opts[:reload]
+          if (!associations.include?(name) || dynamic_opts[:eager_reload]) && opts[:allow_eager] != false && retrieved_by && !frozen? && !dynamic_opts[:callback] && !dynamic_opts[:reload]
             begin
               retrieved_by.send(:eager_load, retrieved_with.reject(&:frozen?), name=>dynamic_opts[:eager] || {})
             rescue Sequel::UndefinedAssociation

data/lib/sequel/version.rb

@@ -5,10 +5,10 @@ module Sequel
   MAJOR = 5
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 7
+  MINOR = 8
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
-  TINY  = 1
+  TINY  = 0
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
   VERSION = [MAJOR, MINOR, TINY].join('.').freeze

data/spec/adapters/mysql_spec.rb

@@ -185,7 +185,6 @@ describe "A MySQL dataset" do
   it "should have explain output" do
     @d.explain.must_be_kind_of(String)
     @d.explain(:extended=>true).must_be_kind_of(String)
-    @d.explain.wont_equal @d.explain(:extended=>true)
   end
 
   it "should correctly literalize strings with comment backslashes in them" do

data/spec/adapters/postgres_spec.rb

@@ -93,6 +93,17 @@ describe "PostgreSQL", '#create_table' do
     end
   end
 
+  it "should have #check_constraints method for getting check constraints" do
+    @db.create_table(:tmp_dolls) do
+      Integer :i
+      Integer :j
+      constraint(:ic, Sequel[:i] > 2)
+      constraint(:jc, Sequel[:j] > 2)
+      constraint(:ijc, Sequel[:i] - Sequel[:j] > 2)
+    end
+    @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 not allow to pass both :temp and :unlogged" do
     proc do
       @db.create_table(:temp_unlogged_dolls, :temp => true, :unlogged => true){text :name}
@@ -420,6 +431,7 @@ describe "A PostgreSQL database" do
 
   it "should parse foreign keys for tables in a schema" do
     @db.foreign_key_list(Sequel[:public][:testfk]).must_equal [{:on_delete=>:no_action, :on_update=>:no_action, :columns=>[:i], :key=>[:id], :deferrable=>false, :table=>Sequel.qualify(:public, :testfk), :name=>:testfk_i_fkey}]
+    @db.foreign_key_list(Sequel[:public][:testfk], :schema=>false).must_equal [{:on_delete=>:no_action, :on_update=>:no_action, :columns=>[:i], :key=>[:id], :deferrable=>false, :table=>:testfk, :name=>:testfk_i_fkey, :schema=>:public}]
   end
 
   it "should return uuid fields as strings" do
@@ -440,6 +452,32 @@ describe "A PostgreSQL database" do
   end if uses_pg && DB.server_version >= 90000
 end
 
+describe "A PostgreSQL database " do
+  after do
+    DB.drop_table?(:b, :a)
+  end
+
+  it "should parse foreign keys referencing current table using :reverse option" do
+    DB.create_table!(:a) do
+      primary_key :id
+      Integer :i
+      Integer :j
+      foreign_key :a_id, :a, :foreign_key_constraint_name=>:a_a
+      unique [:i, :j]
+    end
+    DB.create_table!(:b) do
+      foreign_key :a_id, :a, :foreign_key_constraint_name=>:a_a
+      Integer :c
+      Integer :d
+      foreign_key [:c, :d], :a, :key=>[:j, :i], :name=>:a_c_d
+    end
+    DB.foreign_key_list(:a, :reverse=>true).must_equal [
+      {:name=>:a_a, :columns=>[:a_id], :key=>[:id], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:a, :schema=>:public},
+      {:name=>:a_a, :columns=>[:a_id], :key=>[:id], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:b, :schema=>:public},
+      {:name=>:a_c_d, :columns=>[:c, :d], :key=>[:j, :i], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:b, :schema=>:public}]
+  end
+end
+
 describe "A PostgreSQL database with domain types" do
   before(:all) do
     @db = DB
@@ -646,8 +684,14 @@ describe "A PostgreSQL dataset" do
     @db.transaction(:isolation=>:serializable, :deferrable=>false, :read_only=>false){}
   end if DB.server_version >= 90100
 
+  it "should support parsing partial indexes with :include_partial option" do
+    @db.add_index :test, [:name, :value], :where=>(Sequel[:value] > 10), :name=>:tnv_partial
+    @db.indexes(:test)[:tnv_partial].must_be_nil
+    @db.indexes(:test, :include_partial=>true)[:tnv_partial].must_equal(:columns=>[:name, :value], :unique=>false, :deferrable=>nil)
+  end
+
   it "should support creating indexes concurrently" do
-    @db.add_index :test, [:name, :value], :concurrently=>true
+    @db.add_index :test, [:name, :value], :concurrently=>true, :name=>'tnv0'
   end
 
   it "should support dropping indexes only if they already exist" do
@@ -1336,7 +1380,7 @@ describe "Postgres::Database schema qualified tables" do
       h.last.first.must_equal :j
 
       @db.indexes(:schema_test).must_equal(:public_test_sti=>{:unique=>false, :columns=>[:j], :deferrable=>nil})
-      @db.foreign_key_list(:schema_test).must_equal [{:on_update=>:no_action, :columns=>[:j], :deferrable=>false, :key=>[:id], :table=>:schema_test, :on_delete=>:no_action, :name=>:schema_test_j_fkey}]
+      @db.foreign_key_list(:schema_test).must_equal [{:on_update=>:no_action, :columns=>[:j], :deferrable=>false, :key=>[:id], :table=>:schema_test, :on_delete=>:no_action, :name=>:schema_test_j_fkey, :schema=>:public}]
     ensure
       @db.drop_table?(Sequel[:public][:schema_test])
     end
@@ -3758,7 +3802,8 @@ end if uses_pg && DB.server_version >= 90000
 describe 'PostgreSQL enum types' do
   before do
     @db = DB
-    @db.create_enum(:test_enum, %w'a b c d')
+    @initial_enum_values = %w'a b c d'
+    @db.create_enum(:test_enum, @initial_enum_values)
 
     @db.create_table!(:test_enumt) do
       test_enum  :t
@@ -3772,7 +3817,7 @@ describe 'PostgreSQL enum types' do
   it "should return correct entries in the schema" do
     s = @db.schema(:test_enumt)
     s.first.last[:type].must_equal :enum
-    s.first.last[:enum_values].must_equal %w'a b c d'
+    s.first.last[:enum_values].must_equal @initial_enum_values
   end
 
   it "should add array parsers for enum values" do
@@ -3793,6 +3838,13 @@ describe 'PostgreSQL enum types' do
     @db.add_enum_value(:test_enum, 'a', :if_not_exists=>true) if @db.server_version >= 90300
     @db.schema(:test_enumt, :reload=>true).first.last[:enum_values].must_equal %w'a f g b c d e'
   end if DB.server_version >= 90100
+
+  it "should rename existing enum" do
+    @db.rename_enum(:test_enum, :new_enum)
+    @db.schema(:test_enumt, :reload=>true).first.last[:db_type].must_equal 'new_enum'
+    @db.schema(:test_enumt, :reload=>true).first.last[:enum_values].must_equal @initial_enum_values
+    @db.rename_enum(:new_enum, :test_enum)
+  end
 end
 
 describe "PostgreSQL stored procedures for datasets" do
@@ -3833,3 +3885,116 @@ describe "PostgreSQL stored procedures for datasets" do
     @ds.call(:all).must_equal [{:id=>1, :numb=>100}]
   end
 end if DB.adapter_scheme == :jdbc
+
+describe "pg_auto_constraint_validations plugin" do
+  before(:all) do
+    @db = DB
+    @db.create_table!(:test1) do
+      Integer :id, :primary_key=>true
+      Integer :i, :unique=>true, :null=>false
+      constraint :valid_i, Sequel[:i] < 10
+      constraint(:valid_i_id, Sequel[:i] + Sequel[:id] < 20)
+    end
+    @db.create_table!(:test2) do
+      Integer :test2_id, :primary_key=>true
+      foreign_key :test1_id, :test1
+      index [:test1_id], :unique=>true, :where=>(Sequel[:test1_id] < 10)
+    end
+    @c1 = Sequel::Model(:test1)
+    @c2 = Sequel::Model(:test2)
+    @c1.plugin :update_primary_key
+    @c1.plugin :pg_auto_constraint_validations
+    @c2.plugin :pg_auto_constraint_validations
+    @c1.unrestrict_primary_key
+    @c2.unrestrict_primary_key
+  end
+  before do
+    @c2.dataset.delete
+    @c1.dataset.delete
+    @c1.insert(:id=>1, :i=>2)
+    @c2.insert(:test2_id=>3, :test1_id=>1)
+  end
+  after(:all) do
+    @db.drop_table?(:test2, :test1)
+  end
+
+  it "should handle check constraint failures as validation errors when creating" do
+    o = @c1.new(:id=>5, :i=>12)
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is invalid'])
+  end
+
+  it "should handle check constraint failures as validation errors when updating" do
+    o = @c1.new(:id=>5, :i=>3)
+    o.save
+    proc{o.update(:i=>12)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is invalid'])
+  end
+
+  it "should handle unique constraint failures as validation errors when creating" do
+    o = @c1.new(:id=>5, :i=>2)
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is already taken'])
+  end
+
+  it "should handle unique constraint failures as validation errors when updating" do
+    o = @c1.new(:id=>5, :i=>3)
+    o.save
+    proc{o.update(:i=>2)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is already taken'])
+  end
+
+  it "should handle unique constraint failures as validation errors for partial unique indexes" do
+    @c1.create(:id=>2, :i=>3)
+    @c2.create(:test2_id=>6, :test1_id=>2)
+    o = @c2.new(:test2_id=>5, :test1_id=>2)
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:test1_id=>['is already taken'])
+  end
+
+  it "should handle not null constraint failures as validation errors when creating" do
+    o = @c1.new(:id=>5)
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is not present'])
+  end
+
+  it "should handle not null constraint failures as validation errors when updating" do
+    o = @c1.new(:id=>5, :i=>3)
+    o.save
+    proc{o.update(:i=>nil)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is not present'])
+  end
+
+  it "should handle foreign key constraint failures as validation errors when creating" do
+    o = @c2.new(:test2_id=>4, :test1_id=>2)
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:test1_id=>['is invalid'])
+  end
+
+  it "should handle foreign key constraint failures as validation errors when updating" do
+    o = @c2.first
+    proc{o.update(:test1_id=>2)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:test1_id=>['is invalid'])
+  end
+
+  it "should handle foreign key constraint failures in other tables as validation errors when updating" do
+    o = @c1[1]
+    proc{o.update(:id=>2)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:id=>['cannot be changed currently'])
+  end
+
+  it "should handle multi-column constraint failures as validation errors" do
+    c = Class.new(@c1)
+    o = c.new(:id=>18, :i=>8)
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    [{[:i, :id]=>['is invalid']}, {[:id, :i]=>['is invalid']}].must_include o.errors
+  end
+
+  it "should handle multi-column constraint failures as validation errors when using the error_splitter plugin" do
+    c = Class.new(@c1)
+    c.plugin :error_splitter
+    o = c.new(:id=>18, :i=>8)
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is invalid'], :id=>['is invalid'])
+  end
+end if DB.respond_to?(:error_info)

data/spec/adapters/sqlite_spec.rb

@@ -580,6 +580,19 @@ describe "A SQLite database" do
     proc{@db[:test2].insert(:name=>'a')}.must_raise(Sequel::ConstraintViolation, Sequel::UniqueConstraintViolation)
   end
 
+  it "should not ignore adding new constraints when adding not null constraints" do
+    @db.alter_table :test2 do
+      set_column_not_null :value
+      add_constraint(:value_range1, :value => 3..5)
+      add_constraint(:value_range2, :value => 0..9)
+    end
+
+    @db[:test2].insert(:value => 4)
+    proc{@db[:test2].insert(:value => 1)}.must_raise(Sequel::ConstraintViolation)
+    proc{@db[:test2].insert(:value => nil)}.must_raise(Sequel::ConstraintViolation)
+    @db[:test2].select_order_map(:value).must_equal [4]
+  end
+
   it "should show unique constraints in Database#indexes" do
     @db.alter_table(:test2){add_unique_constraint :name}
     @db.indexes(:test2).values.first[:columns].must_equal [:name]

data/spec/core/dataset_spec.rb

@@ -4784,6 +4784,27 @@ describe "Dataset#lock_style and for_update" do
   end
 end
 
+describe "Dataset#nowait" do
+  before do
+    @ds = Sequel.mock.dataset.from(:t).for_update
+  end
+  
+  it "should raise an error if not supported" do
+    proc{@ds.nowait}.must_raise Sequel::Error
+  end
+  
+  it "should use the nowait SYNTAX if supported" do
+    @ds = @ds.with_extend do
+      def supports_nowait?; true end
+      def select_lock_sql(sql) super; sql << " NOWAIT" if @opts[:nowait] end
+    end
+    @ds.sql.must_equal "SELECT * FROM t FOR UPDATE"
+    3.times do
+      @ds.nowait.sql.must_equal "SELECT * FROM t FOR UPDATE NOWAIT"
+    end
+  end
+end
+  
 describe "Dataset#skip_locked" do
   before do
     @ds = Sequel.mock.dataset.from(:t).for_update

data/spec/extensions/association_proxies_spec.rb

@@ -23,9 +23,23 @@ describe "Sequel::Plugins::AssociationProxies" do
     @i.associations.has_key?(:tags).must_equal true
   end
   
+  if RUBY_VERSION < '2.6'
+    deprecated "should issue deprecation warning when using filter on association proxy on ruby <2.6" do
+      @i.associations.has_key?(:tags).must_equal false
+      @t.filter{|x| false}.sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND 'f')"
+      @i.associations.has_key?(:tags).must_equal false
+    end
+  else
+    it "should treat filter on association proxy as array method on ruby 2.6+" do
+      @i.associations.has_key?(:tags).must_equal false
+      @t.filter{|x| false}.must_equal []
+      @i.associations.has_key?(:tags).must_equal true
+    end
+  end
+  
   it "should send method calls to the association dataset if sent a non-array method" do
     @i.associations.has_key?(:tags).must_equal false
-    @t.filter(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
+    @t.where(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
     @i.associations.has_key?(:tags).must_equal false
   end
   
@@ -35,8 +49,8 @@ describe "Sequel::Plugins::AssociationProxies" do
     end
     @i.associations.has_key?(:tags).must_equal false
     @t.where(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
-    @t.filter(Sequel.lit('a = 1')).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
-    @t.filter{{:a=>1}}.sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
+    @t.where(Sequel.lit('a = 1')).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
+    @t.where{{:a=>1}}.sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
 
     @i.associations.has_key?(:tags).must_equal false
     Item.plugin :association_proxies do |opts|
@@ -63,16 +77,16 @@ describe "Sequel::Plugins::AssociationProxies" do
     Item.db.sqls.length.must_equal 0
     @i.tags(:reload=>true).select{|x| false}.must_equal []
     Item.db.sqls.length.must_equal 1
-    @t.filter(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
+    @t.where(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
     Item.db.sqls.length.must_equal 0
   end
   
   it "should not return a proxy object for associations that do not return an array" do
     Item.many_to_one :tag
-    proc{@i.tag.filter(:a=>1)}.must_raise(NoMethodError)
+    proc{@i.tag.where(:a=>1)}.must_raise(NoMethodError)
     
     Tag.one_to_one :item
-    proc{Tag.load(:id=>1, :item_id=>2).item.filter(:a=>1)}.must_raise(NoMethodError)
+    proc{Tag.load(:id=>1, :item_id=>2).item.where(:a=>1)}.must_raise(NoMethodError)
   end
 
   it "should work correctly in subclasses" do
@@ -80,7 +94,7 @@ describe "Sequel::Plugins::AssociationProxies" do
     i.associations.has_key?(:tags).must_equal false
     i.tags.select{|x| false}.must_equal []
     i.associations.has_key?(:tags).must_equal true
-    i.tags.filter(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
+    i.tags.where(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
   end
   
 end

data/spec/extensions/connection_expiration_spec.rb

@@ -79,6 +79,17 @@ connection_expiration_specs = shared_description do
       @db.pool.instance_variable_get(:@connection_expiration_timestamps).size.must_equal 0
     end
 
+    it "should not vary expiration timestamps by default" do
+      c1 = @db.synchronize{|c| c}
+      @db.pool.instance_variable_get(:@connection_expiration_timestamps)[c1].last.must_equal 2
+    end
+
+    it "should support #connection_expiration_random_delay to vary expiration timestamps" do
+      @db.pool.connection_expiration_random_delay = 1
+      c1 = @db.synchronize{|c| c}
+      @db.pool.instance_variable_get(:@connection_expiration_timestamps)[c1].last.wont_equal 2
+    end
+
     def multiple_connections
       q, q1 = Queue.new, Queue.new
       c1 = nil
@@ -101,7 +112,8 @@ connection_expiration_specs = shared_description do
     # Set the timestamp back in time to simulate sleep / passage of time.
     def simulate_sleep(conn, sleep_time = 3)
       timestamps = @db.pool.instance_variable_get(:@connection_expiration_timestamps)
-      timestamps[conn] -= sleep_time
+      timer, max = timestamps[conn]
+      timestamps[conn] = [timer - sleep_time, max]
       @db.pool.instance_variable_set(:@connection_expiration_timestamps, timestamps)
     end
   end

data/spec/extensions/pg_auto_constraint_validations_spec.rb

@@ -0,0 +1,165 @@
+require_relative "spec_helper"
+
+describe "pg_auto_constraint_validations plugin" do
+  def create_model(ds)
+    @ds = ds
+    @ds.send(:columns=, [:id, :i])
+    @db.fetch = @metadata_results.dup
+    c = Sequel::Model(@ds)
+    c.plugin :pg_auto_constraint_validations
+    c
+  end
+
+  before do
+    info = @info = {:schema=>'public', :table=>'items'}
+    error = @error = []
+    @db = Sequel.mock(:host=>'postgres')
+    def @db.schema(*) [[:i, {}], [:id, {}]] end
+    @set_error = lambda{|ec, ei| @db.fetch = @db.autoid = @db.numrows = ec; info.merge!(ei)}
+    @db.define_singleton_method(:error_info){|e| info}
+    @metadata_results = [
+     [{:constraint=>'items_i_check', :column=>'i', :definition=>'CHECK i'}, {:constraint=>'items_i_id_check', :column=>'i', :definition=>'CHECK i + id < 20'}, {:constraint=>'items_i_id_check', :column=>'id', :definition=>'CHECK i + id < 20'}],
+     [{:name=>'items_i_uidx', :unique=>true, :column=>'i', :deferrable=>false}, {:name=>'items_i2_idx', :unique=>false, :column=>'i', :deferrable=>false}],
+     [{:name=>'items_i_fk', :column=>'i', :on_update=>'a', :on_delete=>'a', :table=>'items2', :refcolumn=>'id', :schema=>'public'}],
+     [{:name=>'items2_i_fk', :column=>'id', :on_update=>'a', :on_delete=>'a', :table=>'items2', :refcolumn=>'i', :schema=>'public'}],
+     [{:nspname=>'public', :relname=>'items'}]
+    ]
+    @c = create_model(@db[:items])
+  end
+
+  it "should handle check constraint failures as validation errors when creating" do
+    o = @c.new(:i=>12)
+    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is invalid'])
+  end
+
+  it "should handle check constraint failures as validation errors when updating" do
+    o = @c.load(:i=>3)
+    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
+    proc{o.update(:i=>12)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is invalid'])
+  end
+
+  it "should handle unique constraint failures as validation errors when creating" do
+    o = @c.new(:i=>2)
+    @set_error[Sequel::UniqueConstraintViolation, :constraint=>'items_i_uidx']
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is already taken'])
+  end
+
+  it "should handle unique constraint failures as validation errors when updating" do
+    o = @c.load(:id=>5, :i=>3)
+    @set_error[Sequel::UniqueConstraintViolation, :constraint=>'items_i_uidx']
+    proc{o.update(:i=>2)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is already taken'])
+  end
+
+  it "should handle not null constraint failures as validation errors when creating" do
+    o = @c.new(:i=>5)
+    @set_error[Sequel::NotNullConstraintViolation, :column=>'i']
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is not present'])
+  end
+
+  it "should handle not null constraint failures as validation errors when updating" do
+    o = @c.load(:i=>3)
+    @set_error[Sequel::NotNullConstraintViolation, :column=>'i']
+    proc{o.update(:i=>nil)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is not present'])
+  end
+
+  it "should handle foreign key constraint failures as validation errors when creating" do
+    o = @c.new(:i=>3)
+    @set_error[Sequel::ForeignKeyConstraintViolation, :constraint=>'items_i_fk', :message_primary=>'insert or']
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is invalid'])
+  end
+
+  it "should handle foreign key constraint failures as validation errors when updating" do
+    o = @c.load(:i=>1)
+    @set_error[Sequel::ForeignKeyConstraintViolation, :constraint=>'items_i_fk', :message_primary=>'insert or']
+    proc{o.update(:i=>3)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is invalid'])
+  end
+
+  it "should handle foreign key constraint failures in other tables as validation errors when updating" do
+    o = @c.load(:i=>1)
+    @set_error[Sequel::ForeignKeyConstraintViolation, :constraint=>'items2_i_fk', :message_primary=>'update or', :schema=>'public', :table=>'items2']
+    proc{o.update(:i=>3)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['cannot be changed currently'])
+  end
+
+  it "should handle symbol, string, and identifier table names" do
+    [@db[:items], @db.from('items'), @db.from{items}, @db.from{public[:items]}].each do |ds|
+      c = create_model(ds)
+      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
+      o = c.new(:i=>3)
+      proc{o.save}.must_raise Sequel::ValidationFailed
+      o.errors.must_equal(:i=>['is invalid'])
+    end
+  end
+
+  it "should skip handling of other table types such as subqueries and functions" do
+    [@db.from{foo(:bar)}, @db[:a, :b]].each do |ds|
+      @db.fetch = @metadata_results.dup
+      @c.dataset = ds
+      o = @c.new(:i=>3)
+      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
+      proc{o.save}.must_raise Sequel::CheckConstraintViolation
+    end
+  end
+
+  it "should skip handling if the error_info method is not supported" do
+    @db.singleton_class.send(:remove_method, :error_info)
+    c = create_model(@db[:items])
+    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
+    o = c.new(:i=>3)
+    proc{o.save}.must_raise Sequel::CheckConstraintViolation
+  end
+
+  it "should not handle constraint failures if they can't be converted" do
+    o = @c.new(:i=>12)
+    @set_error[Sequel::NotNullConstraintViolation, {}]
+    proc{o.save}.must_raise Sequel::NotNullConstraintViolation
+  end
+
+  it "should reraise original exception if there is an error" do
+    o = @c.new(:i=>12)
+    def o.add_pg_constraint_validation_error; end
+    @set_error[Sequel::NotNullConstraintViolation, :column=>'i']
+    proc{o.save}.must_raise Sequel::NotNullConstraintViolation
+  end
+
+  it "should not handle constraint failures if schema or table do not match" do
+    o = @c.new(:i=>12)
+    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check', :schema=>'x']
+    proc{o.save}.must_raise Sequel::CheckConstraintViolation
+    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check', :schema=>'public', :table=>'x']
+    proc{o.save}.must_raise Sequel::CheckConstraintViolation
+  end
+
+  it "should handle constraint failures when disabling insert returning" do
+    c = create_model(@db[:items].disable_insert_returning)
+    o = c.new(:i=>12)
+    o.id = 1
+    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is invalid'])
+  end
+
+  it "should handle multi-column constraint failures as validation errors" do
+    o = @c.new(:i=>12)
+    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal([:i, :id]=>['is invalid'])
+  end
+
+  it "should handle multi-column constraint failures as validation errors when using the error_splitter plugin" do
+    @c.plugin :error_splitter
+    o = @c.new(:i=>12)
+    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['is invalid'], :id=>['is invalid'])
+  end
+end