sequel 3.38.0 → 3.39.0

data/spec/core/expression_filters_spec.rb

@@ -60,10 +60,12 @@ describe "Blockless Ruby Filters" do
   end
   
   it "should support ~ via Hash and Regexp (if supported by database)" do
+    def @d.supports_regexp?; true end
     @d.l(:x => /blah/).should == '(x ~ \'blah\')'
   end
   
   it "should support !~ via inverted Hash and Regexp" do
+    def @d.supports_regexp?; true end
     @d.l(~Sequel.expr(:x => /blah/)).should == '(x !~ \'blah\')'
   end
   
@@ -141,7 +143,7 @@ describe "Blockless Ruby Filters" do
     @d.l(Sequel.expr(Sequel.lit('y') => Sequel.lit('z')) & Sequel.lit('x')).should == '((y = z) AND x)'
     @d.l((Sequel.lit('x') > 200) & (Sequel.lit('y') < 200)).should == '((x > 200) AND (y < 200))'
     @d.l(~(Sequel.lit('x') + 1 > 100)).should == '((x + 1) <= 100)'
-    @d.l(Sequel.lit('x').like(/a/)).should == '(x ~ \'a\')'
+    @d.l(Sequel.lit('x').like('a')).should == '(x LIKE \'a\')'
     @d.l(Sequel.lit('x') + 1 > 100).should == '((x + 1) > 100)'
     @d.l((Sequel.lit('x') * :y) < 100.01).should == '((x * y) < 100.01)'
     @d.l((Sequel.lit('x') - Sequel.expr(:y)/2) >= 100000000000000000000000000000000000).should == '((x - (y / 2)) >= 100000000000000000000000000000000000)'
@@ -381,6 +383,14 @@ describe "Blockless Ruby Filters" do
     @d.lit(d.like(:b)).should == '((SELECT a FROM items) LIKE b)'
     @d.lit(d.ilike(:b)).should == '((SELECT a FROM items) ILIKE b)'
   end
+
+  it "should handled emulated char_length function" do
+    @d.lit(Sequel.char_length(:a)).should == 'char_length(a)'
+  end
+
+  it "should handled emulated trim function" do
+    @d.lit(Sequel.trim(:a)).should == 'trim(a)'
+  end
 end
 
 describe Sequel::SQL::VirtualRow do
@@ -523,12 +533,14 @@ end
 describe "Sequel core extension replacements" do
   before do
     @db = Sequel::Database.new
+    @ds = @db.dataset 
+    def @ds.supports_regexp?; true end
     @o = Object.new
     def @o.sql_literal(ds) 'foo' end
   end
 
   def l(arg, should)
-    @db.literal(arg).should == should
+    @ds.literal(arg).should == should
   end
 
   it "Sequel.expr should return items wrapped in Sequel objects" do

data/spec/core/mock_adapter_spec.rb

@@ -446,4 +446,8 @@ describe "Sequel Mock Adapter" do
   specify "should stub out the primary_key method for postgres" do
     Sequel.mock(:host=>'postgres').primary_key(:t).should == :id
   end
+
+  specify "should handle creating tables on oracle" do
+    proc{Sequel.mock(:host=>'oracle').create_table(:a){String :b}}.should_not raise_error
+  end
 end

data/spec/core/object_graph_spec.rb

@@ -92,19 +92,6 @@ describe Sequel::Dataset, " graphing" do
     ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
   end
 
-  it "#graph should accept an object that responds to dataset as the dataset" do
-    oc = Class.new
-    o = oc.new
-    ds = @ds2
-    oc.send(:define_method, :dataset){ds} 
-    ds = @ds1.graph(o, :x=>:id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    ds = :lines
-    oc.send(:define_method, :dataset){ds} 
-    ds = @ds1.graph(o, :x=>:id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-  end
-
   it "#graph should raise an error if a symbol, dataset, or model is not used" do
     proc{@ds1.graph(Object.new, :x=>:id)}.should raise_error(Sequel::Error)
   end

data/spec/core/schema_spec.rb

@@ -757,20 +757,34 @@ describe "DB#alter_table" do
     @db = Sequel.mock
   end
   
-  specify "should allow adding not null constraint" do
+  specify "should allow adding not null constraint via set_column_allow_null with false argument" do
     @db.alter_table(:cats) do
       set_column_allow_null :score, false
     end
     @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score SET NOT NULL"]
   end
   
-  specify "should allow droping not null constraint" do
+  specify "should allow removing not null constraint via set_column_allow_null with true argument" do
     @db.alter_table(:cats) do
       set_column_allow_null :score, true
     end
     @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score DROP NOT NULL"]
   end
 
+  specify "should allow adding not null constraint via set_column_not_null" do
+    @db.alter_table(:cats) do
+      set_column_not_null :score
+    end
+    @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score SET NOT NULL"]
+  end
+  
+  specify "should allow removing not null constraint via set_column_allow_null without argument" do
+    @db.alter_table(:cats) do
+      set_column_allow_null :score
+    end
+    @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score DROP NOT NULL"]
+  end
+
   specify "should support add_column" do
     @db.alter_table(:cats) do
       add_column :score, :integer
@@ -939,6 +953,40 @@ describe "DB#alter_table" do
       "ALTER TABLE cats ALTER COLUMN score TYPE varchar(30)",
       "ALTER TABLE cats ALTER COLUMN score TYPE enum('a', 'b')"]
   end
+
+  specify "should combine operations into a single query if the database supports it" do
+    @db.meta_def(:supports_combining_alter_table_ops?){true}
+    @db.alter_table(:cats) do
+      add_column :a, Integer
+      drop_column :b
+      set_column_not_null :c
+      rename_column :d, :e
+      set_column_default :f, 'g'
+      set_column_type :h, Integer
+      add_constraint(:i){a > 1}
+      drop_constraint :j
+    end
+    @db.sqls.should == ["ALTER TABLE cats ADD COLUMN a integer, DROP COLUMN b, ALTER COLUMN c SET NOT NULL, RENAME COLUMN d TO e, ALTER COLUMN f SET DEFAULT 'g', ALTER COLUMN h TYPE integer, ADD CONSTRAINT i CHECK (a > 1), DROP CONSTRAINT j"]
+  end
+  
+  specify "should combine operations into consecutive groups of combinable operations if the database supports combining operations" do
+    @db.meta_def(:supports_combining_alter_table_ops?){true}
+    @db.alter_table(:cats) do
+      add_column :a, Integer
+      drop_column :b
+      set_column_not_null :c
+      rename_column :d, :e
+      add_index :e
+      set_column_default :f, 'g'
+      set_column_type :h, Integer
+      add_constraint(:i){a > 1}
+      drop_constraint :j
+    end
+    @db.sqls.should == ["ALTER TABLE cats ADD COLUMN a integer, DROP COLUMN b, ALTER COLUMN c SET NOT NULL, RENAME COLUMN d TO e",
+      "CREATE INDEX cats_e_index ON cats (e)",
+      "ALTER TABLE cats ALTER COLUMN f SET DEFAULT 'g', ALTER COLUMN h TYPE integer, ADD CONSTRAINT i CHECK (a > 1), DROP CONSTRAINT j"]
+  end
+  
 end
 
 describe "Database#create_table" do
@@ -1251,11 +1299,13 @@ describe "Schema Parser" do
   end
 
   specify "should correctly parse all supported data types" do
-    @db.meta_def(:schema_parse_table) do |t, opts|
-      [[:x, {:type=>schema_column_type(t.to_s)}]]
+    sm = Module.new do
+      def schema_parse_table(t, opts)
+        [[:x, {:type=>schema_column_type(t.to_s)}]]
+      end
     end
+    @db.extend(sm)
     @db.schema(:tinyint).first.last[:type].should == :integer
-    @db.schema(:interval).first.last[:type].should == :interval
     @db.schema(:int).first.last[:type].should == :integer
     @db.schema(:integer).first.last[:type].should == :integer
     @db.schema(:bigint).first.last[:type].should == :integer
@@ -1277,6 +1327,7 @@ describe "Schema Parser" do
     @db.schema(:real).first.last[:type].should == :float
     @db.schema(:float).first.last[:type].should == :float
     @db.schema(:double).first.last[:type].should == :float
+    @db.schema(:"double(1,2)").first.last[:type].should == :float
     @db.schema(:"double precision").first.last[:type].should == :float
     @db.schema(:number).first.last[:type].should == :decimal
     @db.schema(:numeric).first.last[:type].should == :decimal
@@ -1296,5 +1347,13 @@ describe "Schema Parser" do
     @db.schema(:binary).first.last[:type].should == :blob
     @db.schema(:varbinary).first.last[:type].should == :blob
     @db.schema(:enum).first.last[:type].should == :enum
+
+    @db = Sequel.mock(:host=>'postgres')
+    @db.extend(sm)
+    @db.schema(:interval).first.last[:type].should == :interval
+
+    @db = Sequel.mock(:host=>'mysql')
+    @db.extend(sm)
+    @db.schema(:set).first.last[:type].should == :set
   end
 end

data/spec/core_extensions_spec.rb

@@ -23,6 +23,7 @@ describe "Core extensions" do
   before do
     db = Sequel::Database.new
     @d = db[:items]
+    def @d.supports_regexp?; true end
     def @d.l(*args, &block)
       literal(filter_expr(*args, &block))
     end

data/spec/extensions/constraint_validations_plugin_spec.rb

@@ -0,0 +1,196 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::ConstraintValidations" do
+  def model_class(opts={})
+    return @c if @c
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @c.columns :name
+    @db.sqls
+    set_fetch(opts)
+    @c.plugin :constraint_validations
+    @c
+  end
+
+  def set_fetch(opts)
+    @db.fetch = {:table=>'items', :message=>nil, :allow_nil=>nil, :constraint_name=>nil, :validation_type=>'presence', :argument=>nil, :column=>'name'}.merge(opts)
+  end
+
+  before do
+    @db = Sequel.mock
+    set_fetch({})
+    @ds = @db[:items]
+    @ds.instance_variable_set(:@columns, [:name])
+    @ds2 = @db.dup[:items2]
+    @ds2.instance_variable_set(:@columns, [:name])
+  end
+
+  it "should load the validation_helpers plugin into the class" do
+    model_class.new.should respond_to(:validates_presence)
+  end
+
+  it "should parse constraint validations when loading plugin" do
+    @c = model_class
+    @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
+    @db.constraint_validations.should == {'items'=>[[:validates_presence, :name]]}
+    @c.constraint_validations.should == [[:validates_presence, :name]]
+  end
+
+  it "should parse constraint validations with a custom constraint validations table" do
+    c = Class.new(Sequel::Model(@db[:items]))
+    @db.sqls
+    c.plugin :constraint_validations, :constraint_validations_table=>:foo
+    @db.sqls.should == ["SELECT * FROM foo"]
+    @db.constraint_validations.should == {'items'=>[[:validates_presence, :name]]}
+    c.constraint_validations.should == [[:validates_presence, :name]]
+  end
+
+  it "should populate constraint_validations when subclassing" do
+    c = Class.new(Sequel::Model(@db))
+    c.plugin :constraint_validations
+    @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
+    sc = Class.new(c)
+    sc.set_dataset @ds
+    @db.sqls.should == []
+    sc.constraint_validations.should == [[:validates_presence, :name]]
+  end
+
+  it "should populate constraint_validations when changing the model's dataset" do
+    c = Class.new(Sequel::Model(@db[:foo]))
+    c.columns :name
+    @db.sqls
+    c.plugin :constraint_validations
+    @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
+    sc = Class.new(c)
+    sc.set_dataset @ds
+    @db.sqls.should == []
+    sc.constraint_validations.should == [[:validates_presence, :name]]
+  end
+
+  it "should reparse constraint validations when changing the model's database" do
+    c = Class.new(Sequel::Model(@ds2))
+    c.plugin :constraint_validations
+    @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
+    sc = Class.new(c)
+    sc.set_dataset @ds
+    @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
+    sc.constraint_validations.should == [[:validates_presence, :name]]
+  end
+
+  it "should reparse constraint validations when changing the model's database with a custom constraint validations table" do
+    c = Class.new(Sequel::Model(@ds2))
+    c.plugin :constraint_validations, :constraint_validations_table=>:foo
+    @db.sqls.should == ["SELECT * FROM foo"]
+    sc = Class.new(c)
+    sc.set_dataset @ds
+    @db.sqls.should == ["SELECT * FROM foo"]
+    sc.constraint_validations.should == [[:validates_presence, :name]]
+  end
+
+  it "should correctly retrieve :message option from constraint validations table" do
+    model_class(:message=>'foo').constraint_validations.should == [[:validates_presence, :name, {:message=>'foo'}]]
+  end
+
+  it "should correctly retrieve :allow_nil option from constraint validations table" do
+    model_class(:allow_nil=>true).constraint_validations.should == [[:validates_presence, :name, {:allow_nil=>true}]]
+  end
+
+  it "should handle presence validation" do
+    model_class(:validation_type=>'presence').constraint_validations.should == [[:validates_presence, :name]]
+  end
+
+  it "should handle exact_length validation" do
+    model_class(:validation_type=>'exact_length', :argument=>'5').constraint_validations.should == [[:validates_exact_length, 5, :name]]
+  end
+
+  it "should handle min_length validation" do
+    model_class(:validation_type=>'min_length', :argument=>'5').constraint_validations.should == [[:validates_min_length, 5, :name]]
+  end
+
+  it "should handle max_length validation" do
+    model_class(:validation_type=>'max_length', :argument=>'5').constraint_validations.should == [[:validates_max_length, 5, :name]]
+  end
+
+  it "should handle length_range validation" do
+    model_class(:validation_type=>'length_range', :argument=>'3..5').constraint_validations.should == [[:validates_length_range, 3..5, :name]]
+  end
+
+  it "should handle length_range validation with an exclusive end" do
+    model_class(:validation_type=>'length_range', :argument=>'3...5').constraint_validations.should == [[:validates_length_range, 3...5, :name]]
+  end
+
+  it "should handle format validation" do
+    model_class(:validation_type=>'format', :argument=>'^foo.*').constraint_validations.should == [[:validates_format, /^foo.*/, :name]]
+  end
+
+  it "should handle format validation with case insensitive format" do
+    model_class(:validation_type=>'iformat', :argument=>'^foo.*').constraint_validations.should == [[:validates_format, /^foo.*/i, :name]]
+  end
+
+  it "should handle includes validation with array of strings" do
+    model_class(:validation_type=>'includes_str_array', :argument=>'a,b,c').constraint_validations.should == [[:validates_includes, %w'a b c', :name]]
+  end
+
+  it "should handle includes validation with array of integers" do
+    model_class(:validation_type=>'includes_int_array', :argument=>'1,2,3').constraint_validations.should == [[:validates_includes, [1, 2, 3], :name]]
+  end
+
+  it "should handle includes validation with inclusive range of integers" do
+    model_class(:validation_type=>'includes_int_range', :argument=>'3..5').constraint_validations.should == [[:validates_includes, 3..5, :name]]
+  end
+
+  it "should handle includes validation with exclusive range of integers" do
+    model_class(:validation_type=>'includes_int_range', :argument=>'3...5').constraint_validations.should == [[:validates_includes, 3...5, :name]]
+  end
+
+  it "should handle like validation" do
+    model_class(:validation_type=>'like', :argument=>'foo').constraint_validations.should == [[:validates_format, /\Afoo\z/, :name]]
+  end
+
+  it "should handle ilike validation" do
+    model_class(:validation_type=>'ilike', :argument=>'foo').constraint_validations.should == [[:validates_format, /\Afoo\z/i, :name]]
+  end
+
+  it "should handle like validation with % metacharacter" do
+    model_class(:validation_type=>'like', :argument=>'%foo%').constraint_validations.should == [[:validates_format, /\A.*foo.*\z/, :name]]
+  end
+
+  it "should handle like validation with %% metacharacter" do
+    model_class(:validation_type=>'like', :argument=>'%%foo%%').constraint_validations.should == [[:validates_format, /\A%foo%\z/, :name]]
+  end
+
+  it "should handle like validation with _ metacharacter" do
+    model_class(:validation_type=>'like', :argument=>'f_o').constraint_validations.should == [[:validates_format, /\Af.o\z/, :name]]
+  end
+
+  it "should handle like validation with Regexp metacharacter" do
+    model_class(:validation_type=>'like', :argument=>'\wfoo\d').constraint_validations.should == [[:validates_format, /\A\\wfoo\\d\z/, :name]]
+  end
+
+  it "should handle unique validation" do
+    model_class(:validation_type=>'unique').constraint_validations.should == [[:validates_unique, [:name]]]
+  end
+
+  it "should handle unique validation with multiple columns" do
+    model_class(:validation_type=>'unique', :column=>'name,id').constraint_validations.should == [[:validates_unique, [:name, :id]]]
+  end
+
+  it "should used parsed constraint validations when validating" do
+    o = model_class.new
+    o.valid?.should == false
+    o.errors.full_messages.should == ['name is not present']
+  end
+
+  it "should handle a table name specified as SQL::Identifier" do
+    set_fetch(:table=>'sch__items')
+    c = Class.new(Sequel::Model(@db[Sequel.identifier(:sch__items)]))
+    c.plugin :constraint_validations
+    c.constraint_validations.should == [[:validates_presence, :name]]
+  end
+
+  it "should handle a table name specified as SQL::QualifiedIdentifier" do
+    set_fetch(:table=>'sch.items')
+    c = Class.new(Sequel::Model(@db[Sequel.qualify(:sch, :items)]))
+    c.plugin :constraint_validations
+    c.constraint_validations.should == [[:validates_presence, :name]]
+  end
+end

data/spec/extensions/constraint_validations_spec.rb

@@ -0,0 +1,316 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "constraint_validations extension" do
+  def parse_insert(s)
+    m = /\AINSERT INTO sequel_constraint_validations \((.*)\) VALUES \((.*)\)\z/.match(s)
+    Hash[*m[1].split(', ').map{|v| v.to_sym}.zip(m[2].split(', ').map{|v| parse_insert_value(v)}).reject{|k, v| v.nil?}.flatten]
+  end
+
+  def parse_insert_value(s)
+    case s
+    when 'NULL'
+      nil
+    when /\A'(.*)'\z/
+      $1
+    else
+      raise Sequel::Error, "unhandled insert value: #{s.inspect}"
+    end
+  end
+
+  before do
+    @db = Sequel.mock
+    @db.extend(Module.new{attr_writer :schema; def schema(table, *) execute("parse schema for #{table}"); @schema; end})
+    @db.extension(:constraint_validations)
+  end
+
+  it "should allow creating the sequel_constraint_validations table" do
+    @db.create_constraint_validations_table
+    @db.sqls.should == ["CREATE TABLE sequel_constraint_validations (table varchar(255) NOT NULL, constraint_name varchar(255), validation_type varchar(255) NOT NULL, column varchar(255) NOT NULL, argument varchar(255), message varchar(255), allow_nil boolean)"]
+  end
+
+  it "should allow creating the sequel_constraint_validations table with a non-default table name" do
+    @db.constraint_validations_table = :foo
+    @db.create_constraint_validations_table
+    @db.sqls.should == ["CREATE TABLE foo (table varchar(255) NOT NULL, constraint_name varchar(255), validation_type varchar(255) NOT NULL, column varchar(255) NOT NULL, argument varchar(255), message varchar(255), allow_nil boolean)"]
+  end
+
+  it "should allow dropping the sequel_constraint_validations table" do
+    @db.drop_constraint_validations_table
+    @db.sqls.should == ["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.should == ["DROP TABLE foo"]
+  end
+
+  it "should allow dropping validations for a given table" do
+    @db.drop_constraint_validations_for(:table=>:foo)
+    @db.sqls.should == ["DELETE FROM sequel_constraint_validations WHERE (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.should == ["DELETE FROM sequel_constraint_validations WHERE ((table = 'foo') AND (column = 'bar'))"]
+  end
+
+  it "should allow dropping validations for a given table and constraint" do
+    @db.drop_constraint_validations_for(:table=>:foo, :constraint=>:bar)
+    @db.sqls.should == ["DELETE FROM sequel_constraint_validations WHERE ((table = 'foo') AND (constraint_name = 'bar'))"]
+  end
+
+  it "should allow dropping validations for a non-default constraint_validations table" do
+    @db.constraint_validations_table = :cv
+    @db.drop_constraint_validations_for(:table=>:foo)
+    @db.sqls.should == ["DELETE FROM cv WHERE (table = 'foo')"]
+  end
+
+  it "should raise an error without deleting if attempting to drop validations with table, column, or constraint" do
+    proc{@db.drop_constraint_validations_for({})}.should raise_error(Sequel::Error)
+    @db.sqls.should == []
+  end
+
+  it "should allow adding constraint validations via create_table validate" do
+    @db.create_table(:foo){String :name; validate{presence :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
+  end
+
+  it "should allow adding constraint validations via alter_table validate" do
+    @db.schema = [[:name, {:type=>:string}]]
+    @db.alter_table(:foo){validate{presence :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(2)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
+    sqls.should == ["parse schema for foo", "BEGIN", "COMMIT", "ALTER TABLE foo ADD CHECK ((name IS NOT NULL) AND (trim(name) != ''))"]
+  end
+
+  it "should handle :message option when adding validations" do
+    @db.create_table(:foo){String :name; validate{presence :name, :message=>'not there'}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo", :message=>'not there'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
+  end
+
+  it "should handle :allow_nil option when adding validations" do
+    @db.create_table(:foo){String :name; validate{presence :name, :allow_nil=>true}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo", :allow_nil=>'t'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK (trim(name) != ''))"]
+  end
+
+  it "should handle :name option when adding validations" do
+    @db.create_table(:foo){String :name; validate{presence :name, :name=>'cons'}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo", :constraint_name=>'cons'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CONSTRAINT cons CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
+  end
+
+  it "should handle multiple columns when adding validations" do
+    @db.create_table(:foo){String :name; String :bar; validate{presence [:name, :bar]}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"bar", :table=>"foo"}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), bar varchar(255), CHECK ((name IS NOT NULL) AND (bar IS NOT NULL) AND (trim(name) != '') AND (trim(bar) != '')))"]
+  end
+
+  it "should handle presence validation on non-String columns" do
+    @db.create_table(:foo){Integer :name; validate{presence :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer, CHECK (name IS NOT NULL))"]
+
+    @db.schema = [[:name, {:type=>:integer}]]
+    @db.alter_table(:foo){validate{presence :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(2)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
+    sqls.should == ["parse schema for foo", "BEGIN", "COMMIT", "ALTER TABLE foo ADD CHECK (name IS NOT NULL)"]
+  end
+
+  it "should handle presence validation on Oracle with IS NOT NULL instead of != ''" do
+    @db = Sequel.mock(:host=>'oracle')
+    @db.extension(:constraint_validations)
+    @db.create_table(:foo){String :name; validate{presence :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) IS NOT NULL)))"]
+  end
+
+  it "should assume column is not a String if it can't determine the type" do
+    @db.create_table(:foo){Integer :name; validate{presence :bar}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"bar", :table=>"foo"}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer, CHECK (bar IS NOT NULL))"]
+
+    @db.schema = [[:name, {:type=>:integer}]]
+    @db.alter_table(:foo){validate{presence :bar}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(2)).should == {:validation_type=>"presence", :column=>"bar", :table=>"foo"}
+    sqls.should == ["parse schema for foo", "BEGIN", "COMMIT", "ALTER TABLE foo ADD CHECK (bar IS NOT NULL)"]
+  end
+
+  it "should handle presence validation on non-String columns with :allow_nil option" do
+    @db.create_table(:foo){Integer :name; validate{presence :name, :allow_nil=>true}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo", :allow_nil=>'t'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer)"]
+  end
+
+  it "should support :exact_length constraint validation" do
+    @db.create_table(:foo){String :name; validate{exact_length 5, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"exact_length", :column=>"name", :table=>"foo", :argument=>'5'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) = 5)))"]
+  end
+
+  it "should support :min_length constraint validation" do
+    @db.create_table(:foo){String :name; validate{min_length 5, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"min_length", :column=>"name", :table=>"foo", :argument=>'5'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) >= 5)))"]
+  end
+
+  it "should support :max_length constraint validation" do
+    @db.create_table(:foo){String :name; validate{max_length 5, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"max_length", :column=>"name", :table=>"foo", :argument=>'5'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) <= 5)))"]
+  end
+
+  it "should support :length_range constraint validation" do
+    @db.create_table(:foo){String :name; validate{length_range 3..5, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"length_range", :column=>"name", :table=>"foo", :argument=>'3..5'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) >= 3) AND (char_length(name) <= 5)))"]
+
+    @db.create_table(:foo){String :name; validate{length_range 3...5, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"length_range", :column=>"name", :table=>"foo", :argument=>'3...5'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) >= 3) AND (char_length(name) < 5)))"]
+  end
+
+  it "should support :format constraint validation" do
+    @db = Sequel.mock(:host=>'postgres')
+    @db.extension(:constraint_validations)
+    @db.create_table(:foo){String :name; validate{format /^foo.*/, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"format", :column=>"name", :table=>"foo", :argument=>'^foo.*'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~ '^foo.*')))"]
+  end
+
+  it "should support :format constraint validation with case insensitive format" do
+    @db = Sequel.mock(:host=>'postgres')
+    @db.extension(:constraint_validations)
+    @db.create_table(:foo){String :name; validate{format /^foo.*/i, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"iformat", :column=>"name", :table=>"foo", :argument=>'^foo.*'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~* '^foo.*')))"]
+  end
+
+  it "should support :includes constraint validation with an array of strings" do
+    @db.create_table(:foo){String :name; validate{includes %w'a b c', :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"includes_str_array", :column=>"name", :table=>"foo", :argument=>'a,b,c'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name IN ('a', 'b', 'c'))))"]
+  end
+
+  it "should support :includes constraint validation with an array of integers" do
+    @db.create_table(:foo){String :name; validate{includes [1, 2, 3], :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"includes_int_array", :column=>"name", :table=>"foo", :argument=>'1,2,3'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name IN (1, 2, 3))))"]
+  end
+
+  it "should support :includes constraint validation with a inclusive range of integers" do
+    @db.create_table(:foo){String :name; validate{includes 3..5, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"includes_int_range", :column=>"name", :table=>"foo", :argument=>'3..5'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name >= 3) AND (name <= 5)))"]
+  end
+
+  it "should support :includes constraint validation with a exclusive range of integers" do
+    @db.create_table(:foo){String :name; validate{includes 3...5, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"includes_int_range", :column=>"name", :table=>"foo", :argument=>'3...5'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name >= 3) AND (name < 5)))"]
+  end
+
+  it "should support :like constraint validation" do
+    @db.create_table(:foo){String :name; validate{like 'foo%', :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"like", :column=>"name", :table=>"foo", :argument=>'foo%'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name LIKE 'foo%')))"]
+  end
+
+  it "should support :ilike constraint validation" do
+    @db.create_table(:foo){String :name; validate{ilike 'foo%', :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"ilike", :column=>"name", :table=>"foo", :argument=>'foo%'}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name ILIKE 'foo%')))"]
+  end
+
+  it "should support :unique constraint validation" do
+    @db.create_table(:foo){String :name; validate{unique :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"unique", :column=>"name", :table=>"foo"}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), UNIQUE (name))"]
+  end
+
+  it "should support :unique constraint validation with multiple columns" do
+    @db.create_table(:foo){String :name; Integer :id; validate{unique [:name, :id]}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"unique", :column=>"name,id", :table=>"foo"}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), id integer, UNIQUE (name, id))"]
+  end
+
+  it "should support :unique constraint validation in alter_table" do
+    @db.alter_table(:foo){validate{unique :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"unique", :column=>"name", :table=>"foo"}
+    sqls.should == ["BEGIN", "COMMIT", "ALTER TABLE foo ADD UNIQUE (name)"]
+  end
+
+  it "should drop constraints and validations when dropping a constraint validation" do
+    @db.alter_table(:foo){String :name; validate{drop :bar}}
+    @db.sqls.should == ["DELETE FROM sequel_constraint_validations WHERE ((table, constraint_name) IN (('foo', 'bar')))", "ALTER TABLE foo DROP CONSTRAINT bar"]
+  end
+
+  it "should raise an error if attempting to validate inclusion with a range of non-integers" do
+    proc{@db.create_table(:foo){String :name; validate{includes 'a'..'z', :name}}}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if attempting to validate inclusion with a range of non-integers or strings" do
+    proc{@db.create_table(:foo){String :name; validate{includes [1.0, 2.0], :name}}}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if attempting to validate inclusion with a unsupported object" do
+    proc{@db.create_table(:foo){String :name; validate{includes 'a', :name}}}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if attempting to drop a constraint validation in a create_table generator" do
+    proc{@db.create_table(:foo){String :name; validate{drop :foo}}}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if attempting to drop a constraint validation without a name" do
+    proc{@db.alter_table(:foo){String :name; validate{drop nil}}}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if attempting attempting to process a constraint validation with an unsupported type" do
+    proc{@db.alter_table(:foo){String :name; validations << {:type=>:foo}}}.should raise_error(Sequel::Error)
+  end
+
+  it "should allow adding constraint validations for tables specified as a SQL::Identifier" do
+    @db.create_table(Sequel.identifier(:sch__foo)){String :name; validate{presence :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"sch__foo"}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE sch__foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
+  end
+
+  it "should allow adding constraint validations for tables specified as a SQL::QualifiedIdentifier" do
+    @db.create_table(Sequel.qualify(:sch, :foo)){String :name; validate{presence :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"sch.foo"}
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE sch.foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
+  end
+end