sequel 3.38.0 → 3.39.0

data/spec/extensions/defaults_setter_spec.rb

@@ -9,6 +9,9 @@ describe "Sequel::Plugins::DefaultsSetter" do
     @c.columns :a
     @pr = proc{|x| db.meta_def(:schema){|*| [[:a, {:ruby_default => x}]]}; c.dataset = c.dataset; c}
   end
+  after do
+    Sequel.datetime_class = Time
+  end
 
   it "should set default value upon initialization" do
     @pr.call(2).new.values.should == {:a=>2}
@@ -22,6 +25,27 @@ describe "Sequel::Plugins::DefaultsSetter" do
     @pr.call(nil).new.values.should == {}
   end
 
+  it "should set a default of false" do
+    @pr.call(false).new.values.should == {:a=>false}
+  end
+
+  it "should handle Sequel::CURRENT_DATE default by using the current Date" do
+    @pr.call(Sequel::CURRENT_DATE).new.a.should == Date.today
+  end
+
+  it "should handle Sequel::CURRENT_TIMESTAMP default by using the current Time" do
+    t = @pr.call(Sequel::CURRENT_TIMESTAMP).new.a
+    t.should be_a_kind_of(Time)
+    (t - Time.now).should < 1
+  end
+
+  it "should handle Sequel::CURRENT_TIMESTAMP default by using the current DateTime if Sequel.datetime_class is DateTime" do
+    Sequel.datetime_class = DateTime
+    t = @pr.call(Sequel::CURRENT_TIMESTAMP).new.a
+    t.should be_a_kind_of(DateTime)
+    (t - DateTime.now).should < 1/86400.0
+  end
+
   it "should not override a given value" do
     @pr.call(2)
     @c.new('a'=>3).values.should == {:a=>3}

data/spec/extensions/eval_inspect_spec.rb

@@ -17,6 +17,13 @@ describe "eval_inspect extension" do
       Sequel::SQL::ColumnAll.new(:a),
       Sequel::SQL::ComplexExpression.new(:'=', :b, :a),
       Sequel::SQL::Constant.new(:a),
+      Sequel::CURRENT_DATE,
+      Sequel::CURRENT_TIMESTAMP,
+      Sequel::CURRENT_TIME,
+      Sequel::SQLTRUE,
+      Sequel::SQLFALSE,
+      Sequel::NULL,
+      Sequel::NOTNULL,
       Sequel::SQL::Function.new(:a, :b, :c),
       Sequel::SQL::Identifier.new(:a),
       Sequel::SQL::JoinClause.new(:inner, :b, :c),
@@ -49,6 +56,8 @@ describe "eval_inspect extension" do
       Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30), :a),
       Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30, 500000.125), :a),
       Sequel::SQL::AliasedExpression.new(BigDecimal.new('1.000000000000000000000000000000000000000000000001'), :a),
+      Sequel::SQL::AliasedExpression.new(Sequel::CURRENT_DATE, :a),
+      Sequel::SQL::AliasedExpression.new(Sequel::CURRENT_TIMESTAMP, :a),
     ].each do |o|
       v = eval(o.inspect)
       v.should == o

data/spec/extensions/identity_map_spec.rb

@@ -55,8 +55,17 @@ describe "Sequel::Plugins::IdentityMap" do
     @c.identity_map_key(1).should_not == @c.identity_map_key(2)
   end
 
-  it "#identity_map_key should be different if the pk is nil" do
-    @c.identity_map_key(nil).should_not == @c.identity_map_key(nil)
+  it "#identity_map_key should be nil for an empty pk values" do
+    @c.identity_map_key(nil).should == nil
+    @c.identity_map_key([]).should == nil
+    @c.identity_map_key([nil]).should == nil
+  end
+
+  it "#load should work even if model doesn't have a primary key" do
+    c = Class.new(@c)
+    c.no_primary_key
+    proc{c.with_identity_map{c.load({})}}.should_not raise_error
+    c.with_identity_map{c.load({}).should_not equal(c.load({}))}
   end
 
   it "#load should return an object if there is no current identity map" do

data/spec/extensions/pg_array_ops_spec.rb

@@ -100,4 +100,13 @@ describe "Sequel::Postgres::ArrayOp" do
   it "should allow transforming PGArray instances into ArrayOp instances" do
     @db.literal(Sequel.pg_array([1,2]).op.push(3)).should == "(ARRAY[1,2] || 3)"
   end
+
+  it "should wrap array arguments in PGArrays" do
+    @db.literal(@a.contains([1, 2])).should == "(a @> ARRAY[1,2])"
+    @db.literal(@a.contained_by([1, 2])).should == "(a <@ ARRAY[1,2])"
+    @db.literal(@a.overlaps([1, 2])).should == "(a && ARRAY[1,2])"
+    @db.literal(@a.push([1, 2])).should == "(a || ARRAY[1,2])"
+    @db.literal(@a.concat([1, 2])).should == "(a || ARRAY[1,2])"
+    @db.literal(@a.unshift([1, 2])).should == "(ARRAY[1,2] || a)"
+  end
 end

data/spec/extensions/pg_row_ops_spec.rb

@@ -22,7 +22,7 @@ describe "Sequel::Postgres::PGRowOp" do
     @db.literal(@a[1][:b]).should == "(a[1]).b"
   end
 
-  it "#splat should return a splatted argument" do
+  it "#splat should return a splatted argument inside parentheses" do
     @db.literal(@a.splat).should == "(a.*)"
   end
 
@@ -34,6 +34,16 @@ describe "Sequel::Postgres::PGRowOp" do
     proc{@a[:a].splat(:b)}.should raise_error(Sequel::Error)
   end
 
+  it "#* should reference all members of the composite type as separate columns if given no arguments" do
+    @db.literal(@a.*).should == "(a).*"
+    @db.literal(@a[:b].*).should == "((a).b).*"
+  end
+
+  it "#* should use a multiplication operation if any arguments are given" do
+    @db.literal(@a.*(1)).should == "(a * 1)"
+    @db.literal(@a[:b].*(1)).should == "((a).b * 1)"
+  end
+
   it "#pg_row should be callable on literal strings" do
     @db.literal(Sequel.lit('a').pg_row[:b]).should == "(a).b"
   end

data/spec/extensions/pg_row_plugin_spec.rb

@@ -42,4 +42,8 @@ describe "Sequel::Plugins::PgRow" do
     @db.bound_variable_arg(1, nil).should == 1
     @db.bound_variable_arg(Sequel.pg_array([@c.load(:street=>'123 Foo St', :city=>'Bar City')]), nil).should == '{"(\\"123 Foo St\\",\\"Bar City\\")"}'
   end
+
+  it "should allow inserting just this model value" do
+    @c2.insert_sql(@c.load(:street=>'123', :city=>'Bar')).should == "INSERT INTO company VALUES (ROW('123', 'Bar')::address)"
+  end
 end

data/spec/extensions/schema_dumper_spec.rb

@@ -1,5 +1,6 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
+
 describe "Sequel::Schema::Generator dump methods" do
   before do
     @d = Sequel::Database.new
@@ -588,22 +589,24 @@ END_MIG
        [:c7, {:db_type=>'date', :default=>"'2008-10-29'", :type=>:date, :allow_null=>true}],
        [:c8, {:db_type=>'datetime', :default=>"'2008-10-29 10:20:30'", :type=>:datetime, :allow_null=>true}],
        [:c9, {:db_type=>'time', :default=>"'10:20:30'", :type=>:time, :allow_null=>true}],
-       [:c10, {:db_type=>'interval', :default=>"'6 weeks'", :type=>:interval, :allow_null=>true}]]
+       [:c10, {:db_type=>'foo', :default=>"'6 weeks'", :type=>nil, :allow_null=>true}],
+       [:c11, {:db_type=>'date', :default=>"CURRENT_DATE", :type=>:date, :allow_null=>true}],
+       [:c12, {:db_type=>'timestamp', :default=>"now()", :type=>:datetime, :allow_null=>true}]]
       s.each{|_, c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
       s
     end
-    @d.dump_table_schema(:t4).gsub(/[+-]\d\d:\d\d"\)/, '")').should == "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>BigDecimal.new(\"0.1005E3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.parse(\"2008-10-29\")\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30\")\n  Time :c9, :default=>Sequel::SQLTime.parse(\"10:20:30\"), :only_time=>true\n  String :c10\nend"
-    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d:\d\d"\)/, '")').should == "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal.new(\"0.1005E3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.parse(\"2008-10-29\")\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30\")\n  column :c9, \"time\", :default=>Sequel::SQLTime.parse(\"10:20:30\")\n  column :c10, \"interval\", :default=>Sequel::LiteralString.new(\"'6 weeks'\")\nend"
+    @d.dump_table_schema(:t4).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').should == "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>BigDecimal.new(\"0.1005E3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.new(2008, 10, 29)\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  Time :c9, :default=>Sequel::SQLTime.parse(\"10:20:30.0\"), :only_time=>true\n  String :c10\n  Date :c11, :default=>Sequel::CURRENT_DATE\n  DateTime :c12, :default=>Sequel::CURRENT_TIMESTAMP\nend"
+    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').should == "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal.new(\"0.1005E3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.new(2008, 10, 29)\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  column :c9, \"time\", :default=>Sequel::SQLTime.parse(\"10:20:30.0\")\n  column :c10, \"foo\", :default=>Sequel::LiteralString.new(\"'6 weeks'\")\n  column :c11, \"date\", :default=>Sequel::CURRENT_DATE\n  column :c12, \"timestamp\", :default=>Sequel::CURRENT_TIMESTAMP\nend"
   end
   
   it "should not use a literal string as a fallback if using MySQL with the :same_db option" do
     @d.meta_def(:database_type){:mysql}
     @d.meta_def(:schema) do |t, *os|
-      s = [[:c10, {:db_type=>'interval', :default=>"'6 weeks'", :type=>:interval, :allow_null=>true}]]
+      s = [[:c10, {:db_type=>'foo', :default=>"'6 weeks'", :type=>nil, :allow_null=>true}]]
       s.each{|_, c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
       s
     end
-    @d.dump_table_schema(:t5, :same_db=>true).should == "create_table(:t5) do\n  column :c10, \"interval\"\nend"
+    @d.dump_table_schema(:t5, :same_db=>true).should == "create_table(:t5) do\n  column :c10, \"foo\"\nend"
   end
 
   it "should convert unknown database types to strings" do

data/spec/extensions/subclasses_spec.rb

@@ -49,4 +49,18 @@ describe Sequel::Model, "Subclasses plugin" do
     ssc1.descendents.should == [sssc1]
     sssc1.descendents.should == []
   end
+
+  specify "plugin block should be called with each subclass created" do
+    c = Class.new(Sequel::Model)
+    a = []
+    c.plugin(:subclasses){|sc| a << sc}
+    sc1 = Class.new(c)
+    a.should == [sc1]
+    sc2 = Class.new(c)
+    a.should == [sc1, sc2]
+    sc3 = Class.new(sc1)
+    a.should == [sc1, sc2, sc3]
+    sc4 = Class.new(sc3)
+    a.should == [sc1, sc2, sc3, sc4]
+  end
 end

data/spec/extensions/validation_helpers_spec.rb

@@ -340,7 +340,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     ds1 = @c.dataset.filter([[:username, '0records']])
     ds2 = ds1.exclude(:id=>1)
-    @c.dataset.should_receive(:filter).with([[:username, '0records']]).twice.and_return(ds1)
+    @c.dataset.should_receive(:where).with([[:username, '0records']]).twice.and_return(ds1)
     ds1.should_receive(:exclude).with(:id=>1).once.and_return(ds2)
 
     @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
@@ -378,7 +378,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     ds1 = @c.dataset.filter([[:username, '0records'], [:password, 'anothertest']])
     ds2 = ds1.exclude(:id=>1)
-    @c.dataset.should_receive(:filter).with([[:username, '0records'], [:password, 'anothertest']]).twice.and_return(ds1)
+    @c.dataset.should_receive(:where).with([[:username, '0records'], [:password, 'anothertest']]).twice.and_return(ds1)
     ds1.should_receive(:exclude).with(:id=>1).once.and_return(ds2)
 
     @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
@@ -402,6 +402,19 @@ describe "Sequel::Plugins::ValidationHelpers" do
                     "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND active AND (id != 3)) LIMIT 1"]
   end
 
+  it "should support validates_unique with a custom filter" do
+    @c.columns(:id, :username, :password)
+    @c.set_dataset MODEL_DB[:items]
+    @c.set_validations{validates_unique(:username, :where=>proc{|ds, obj, cols| ds.where(cols.map{|c| [Sequel.function(:lower, c), obj.send(c).downcase]})})}
+    @c.dataset._fetch = {:v=>0}
+    
+    MODEL_DB.reset
+    @c.new(:username => "0RECORDS", :password => "anothertest").should be_valid
+    @c.load(:id=>3, :username => "0RECORDS", :password => "anothertest").should be_valid
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE (lower(username) = '0records') LIMIT 1",
+                    "SELECT COUNT(*) AS count FROM items WHERE ((lower(username) = '0records') AND (id != 3)) LIMIT 1"]
+  end
+
   it "should support :only_if_modified option for validates_unique, and not check uniqueness for existing records if values haven't changed" do
     @c.columns(:id, :username, :password)
     @c.set_dataset MODEL_DB[:items]

data/spec/integration/dataset_test.rb

@@ -428,6 +428,9 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
     @ds2.insert(:number=>10)
     @ds2.insert(:number=>30)
   end
+  after do
+    INTEGRATION_DB.drop_table?(:i1, :i2, :i3)
+  end
   
   specify "should give the correct results for simple UNION, EXCEPT, and INTERSECT" do
     @ds1.union(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30'
@@ -1399,7 +1402,7 @@ describe "Dataset string methods" do
     @ds.filter(Sequel.expr(:b).like('baR')).all.should == []
     @ds.filter(Sequel.expr(:a).like('FOO', 'BAR')).all.should == []
     @ds.exclude(Sequel.expr(:a).like('Foo')).all.should == [{:a=>'foo', :b=>'bar'}]
-    @ds.exclude(Sequel.expr(:a).like('baR')).all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.exclude(Sequel.expr(:b).like('baR')).all.should == [{:a=>'foo', :b=>'bar'}]
     @ds.exclude(Sequel.expr(:a).like('FOO', 'BAR')).all.should == [{:a=>'foo', :b=>'bar'}]
   end
   
@@ -1413,6 +1416,45 @@ describe "Dataset string methods" do
     @ds.exclude(Sequel.expr(:a).ilike('FOO', 'BAR')).all.should == []
   end
   
+  if INTEGRATION_DB.dataset.supports_regexp?
+    it "#like with regexp return matching rows" do
+      @ds.insert('foo', 'bar')
+      @ds.filter(Sequel.expr(:a).like(/fo/)).all.should == [{:a=>'foo', :b=>'bar'}]
+      @ds.filter(Sequel.expr(:a).like(/fo$/)).all.should == []
+      @ds.filter(Sequel.expr(:a).like(/fo/, /ar/)).all.should == [{:a=>'foo', :b=>'bar'}]
+      @ds.exclude(Sequel.expr(:a).like(/fo/)).all.should == []
+      @ds.exclude(Sequel.expr(:a).like(/fo$/)).all.should == [{:a=>'foo', :b=>'bar'}]
+      @ds.exclude(Sequel.expr(:a).like(/fo/, /ar/)).all.should == []
+    end
+    
+    it "#like with regexp should be case sensitive if regexp is case sensitive" do
+      @ds.insert('foo', 'bar')
+      @ds.filter(Sequel.expr(:a).like(/Fo/)).all.should == []
+      @ds.filter(Sequel.expr(:b).like(/baR/)).all.should == []
+      @ds.filter(Sequel.expr(:a).like(/FOO/, /BAR/)).all.should == []
+      @ds.exclude(Sequel.expr(:a).like(/Fo/)).all.should == [{:a=>'foo', :b=>'bar'}]
+      @ds.exclude(Sequel.expr(:b).like(/baR/)).all.should == [{:a=>'foo', :b=>'bar'}]
+      @ds.exclude(Sequel.expr(:a).like(/FOO/, /BAR/)).all.should == [{:a=>'foo', :b=>'bar'}]
+
+      @ds.filter(Sequel.expr(:a).like(/Fo/i)).all.should == [{:a=>'foo', :b=>'bar'}]
+      @ds.filter(Sequel.expr(:b).like(/baR/i)).all.should == [{:a=>'foo', :b=>'bar'}]
+      @ds.filter(Sequel.expr(:a).like(/FOO/i, /BAR/i)).all.should == [{:a=>'foo', :b=>'bar'}]
+      @ds.exclude(Sequel.expr(:a).like(/Fo/i)).all.should == []
+      @ds.exclude(Sequel.expr(:b).like(/baR/i)).all.should == []
+      @ds.exclude(Sequel.expr(:a).like(/FOO/i, /BAR/i)).all.should == []
+    end
+    
+    it "#ilike with regexp should return matching rows, in a case insensitive manner" do
+      @ds.insert('foo', 'bar')
+      @ds.filter(Sequel.expr(:a).ilike(/Fo/)).all.should == [{:a=>'foo', :b=>'bar'}]
+      @ds.filter(Sequel.expr(:b).ilike(/baR/)).all.should == [{:a=>'foo', :b=>'bar'}]
+      @ds.filter(Sequel.expr(:a).ilike(/FOO/, /BAR/)).all.should == [{:a=>'foo', :b=>'bar'}]
+      @ds.exclude(Sequel.expr(:a).ilike(/Fo/)).all.should == []
+      @ds.exclude(Sequel.expr(:b).ilike(/baR/)).all.should == []
+      @ds.exclude(Sequel.expr(:a).ilike(/FOO/, /BAR/)).all.should == []
+    end
+  end
+  
   it "should work with strings created with Sequel.join" do
     @ds.insert('foo', 'bar')
     @ds.get(Sequel.join([:a, "bar"])).should == 'foobar'
@@ -1520,3 +1562,35 @@ if INTEGRATION_DB.dataset.supports_modifying_joins?
     end
   end
 end
+
+describe "Emulated functions" do
+  before(:all) do
+    @db = INTEGRATION_DB
+    @db.create_table!(:a){String :a}
+    @ds = @db[:a]
+  end
+  after(:all) do
+    @db.drop_table?(:a)
+  end
+  after do
+    @ds.delete
+  end
+  
+  specify "Sequel.char_length should return the length of characters in the string" do
+    @ds.get(Sequel.char_length(:a)).should == nil
+    @ds.insert(:a=>'foo')
+    @ds.get(Sequel.char_length(:a)).should == 3
+    # Check behavior with leading/trailing blanks
+    @ds.update(:a=>' foo22 ')
+    @ds.get(Sequel.char_length(:a)).should == 7
+  end
+  
+  specify "Sequel.trim should return the string with spaces trimmed from both sides" do
+    @ds.get(Sequel.trim(:a)).should == nil
+    @ds.insert(:a=>'foo')
+    @ds.get(Sequel.trim(:a)).should == 'foo'
+    # Check behavior with leading/trailing blanks
+    @ds.update(:a=>' foo22 ')
+    @ds.get(Sequel.trim(:a)).should == 'foo22'
+  end
+end

data/spec/integration/plugin_test.rb

@@ -1617,3 +1617,149 @@ describe "Caching plugins" do
     it_should_behave_like "a caching plugin"
   end
 end
+
+describe "Sequel::Plugins::ConstraintValidations" do
+  before(:all) do
+    @db = INTEGRATION_DB
+    @db.extension(:constraint_validations)
+    @db.create_constraint_validations_table
+    @ds = @db[:cv_test]
+    @regexp = regexp = @db.dataset.supports_regexp?
+    @validate_block = proc do
+      presence :pre, :name=>:p
+      exact_length 5, :exactlen, :name=>:el
+      min_length 5, :minlen, :name=>:minl
+      max_length 5, :maxlen, :name=>:maxl
+      length_range 3..5, :lenrange, :name=>:lr
+      if regexp
+        format /^foo\d+/, :form, :name=>:f
+      end
+      like 'foo%', :lik, :name=>:l
+      ilike 'foo%', :ilik, :name=>:il
+      includes %w'abc def', :inc, :name=>:i
+      unique :uniq, :name=>:u
+      max_length 6, :minlen, :name=>:maxl2
+    end
+    @valid_row = {:pre=>'a', :exactlen=>'12345', :minlen=>'12345', :maxlen=>'12345', :lenrange=>'1234', :lik=>'fooabc', :ilik=>'FooABC', :inc=>'abc', :uniq=>'u'}
+    @violations = [
+      [:pre, [nil, '', ' ']],
+      [:exactlen, [nil, '', '1234', '123456']],
+      [:minlen, [nil, '', '1234']],
+      [:maxlen, [nil, '123456']],
+      [:lenrange, [nil, '', '12', '123456']],
+      [:lik, [nil, '', 'fo', 'fotabc', 'FOOABC']],
+      [:ilik, [nil, '', 'fo', 'fotabc']],
+      [:inc, [nil, '', 'ab', 'abcd']],
+    ]
+
+    if @regexp
+      @valid_row[:form] = 'foo1'
+      @violations << [:form, [nil, '', 'foo', 'fooa']]
+    end
+  end
+  after(:all) do
+    @db.drop_constraint_validations_table
+  end
+
+  shared_examples_for "constraint validations" do
+    cspecify "should set up constraints that work even outside the model", :mysql do 
+      proc{@ds.insert(@valid_row)}.should_not raise_error
+
+      # Test for unique constraint
+      proc{@ds.insert(@valid_row)}.should raise_error(Sequel::DatabaseError)
+
+      @ds.delete
+      @violations.each do |col, vals|
+        try = @valid_row.dup
+        vals += ['1234567'] if col == :minlen
+        vals.each do |val|
+          try[col] = val
+          proc{@ds.insert(try)}.should raise_error(Sequel::DatabaseError)
+        end
+      end
+
+      # Test for dropping of constraint
+      @db.alter_table(:cv_test){validate{drop :maxl2}}
+      proc{@ds.insert(@valid_row.merge(:minlen=>'1234567'))}.should_not raise_error
+    end
+
+    it "should set up automatic validations inside the model" do 
+      c = Class.new(Sequel::Model(@ds))
+      c.plugin :constraint_validations
+      c.delete
+      proc{c.create(@valid_row)}.should_not raise_error
+
+      # Test for unique validation 
+      c.new(@valid_row).should_not be_valid
+
+      c.delete
+      @violations.each do |col, vals|
+        try = @valid_row.dup
+        vals.each do |val|
+          try[col] = val
+          c.new(try).should_not be_valid
+        end
+      end
+    end
+  end
+
+  describe "via create_table" do
+    before(:all) do
+      regexp = @regexp
+      validate_block = @validate_block
+      @db.create_table!(:cv_test) do
+        primary_key :id
+        String :pre
+        String :exactlen
+        String :minlen
+        String :maxlen
+        String :lenrange
+        if regexp
+          String :form
+        end
+        String :lik
+        String :ilik
+        String :inc
+        String :uniq, :null=>false
+        validate(&validate_block)
+      end
+    end
+    after(:all) do
+      @db.drop_table?(:cv_test)
+      @db.drop_constraint_validations_for(:table=>:cv_test)
+    end
+
+    it_should_behave_like "constraint validations"
+  end
+
+  describe "via alter_table" do
+    before(:all) do
+      regexp = @regexp
+      validate_block = @validate_block
+      @db.create_table!(:cv_test) do
+        primary_key :id
+        String :lik
+        String :ilik
+        String :inc
+        String :uniq, :null=>false
+      end
+      @db.alter_table(:cv_test) do
+        add_column :pre, String
+        add_column :exactlen, String
+        add_column :minlen, String
+        add_column :maxlen, String
+        add_column :lenrange, String
+        if regexp
+          add_column :form, String
+        end
+        validate(&validate_block)
+      end
+    end
+    after(:all) do
+      @db.drop_table?(:cv_test)
+      @db.drop_constraint_validations_for(:table=>:cv_test)
+    end
+
+    it_should_behave_like "constraint validations"
+  end
+end