sequel 3.2.0 → 3.3.0

data/spec/extensions/association_proxies_spec.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel::Plugins::AssociationProxies" do
+  before do
+    class ::Tag < Sequel::Model
+    end
+    class ::Item < Sequel::Model
+      plugin :association_proxies
+      many_to_many :tags
+    end
+    @i = Item.load(:id=>1)
+    @t = @i.tags
+    Item.db.reset
+  end 
+  after do
+    Object.send(:remove_const, :Tag)
+    Object.send(:remove_const, :Item)
+  end
+
+  it "should send method calls to the associated object array if sent an array method" do
+    @i.associations.has_key?(:tags).should == false
+    @t.select{|x| false}.should == []
+    @i.associations.has_key?(:tags).should == true
+  end
+  
+  it "should send method calls to the association dataset sent another method" do
+    @i.associations.has_key?(:tags).should == false
+    @t.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
+    @i.associations.has_key?(:tags).should == false
+  end
+  
+  it "should reload the cached association if sent an array method and the reload flag was given" do
+    @t.select{|x| false}.should == []
+    Item.db.sqls.length == 1
+    @t.select{|x| false}.should == []
+    Item.db.sqls.length == 1
+    @i.tags(true).select{|x| false}.should == []
+    Item.db.sqls.length == 2
+    @t.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
+    Item.db.sqls.length == 2
+  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)}.should raise_error(NoMethodError)
+  end
+end

data/spec/extensions/caching_spec.rb

@@ -155,14 +155,14 @@ describe Sequel::Model, "caching" do
     m.name = 'hey'
     m.save
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
+    $sqls.last.should == "UPDATE items SET name = 'hey' WHERE (id = 1)"
 
     m = @c2[1]
     @cache[m.cache_key].should == m
     m.name = 'hey'
     m.save
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
+    $sqls.last.should == "UPDATE items SET name = 'hey' WHERE (id = 1)"
   end
 
   it "should delete the cache when deleting the record" do

data/spec/extensions/hook_class_methods_spec.rb

@@ -240,11 +240,11 @@ describe "Model#before_update && Model#after_update" do
   
   specify "should be called around record update" do
     @c.before_update {MODEL_DB << "BLAH before"}
-    m = @c.load(:id => 2233)
+    m = @c.load(:id => 2233, :x=>123)
     m.save
     MODEL_DB.sqls.should == [
       'BLAH before',
-      'UPDATE items SET id = 2233 WHERE (id = 2233)',
+      'UPDATE items SET x = 123 WHERE (id = 2233)',
       'BLAH after'
     ]
   end
@@ -277,11 +277,11 @@ describe "Model#before_save && Model#after_save" do
   
   specify "should be called around record update" do
     @c.before_save {MODEL_DB << "BLAH before"}
-    m = @c.load(:id => 2233)
+    m = @c.load(:id => 2233, :x=>123)
     m.save
     MODEL_DB.sqls.should == [
       'BLAH before',
-      'UPDATE items SET id = 2233 WHERE (id = 2233)',
+      'UPDATE items SET x = 123 WHERE (id = 2233)',
       'BLAH after'
     ]
   end
@@ -380,9 +380,9 @@ describe "Model#before_validation && Model#after_validation" do
 
   specify "should be called when calling save" do
     @c.before_validation{MODEL_DB << "BLAH before"}
-    m = @c.load(:id => 2233)
+    m = @c.load(:id => 2233, :x=>123)
     m.save.should == m
-    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after', 'UPDATE items SET id = 2233 WHERE (id = 2233)']
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after', 'UPDATE items SET x = 123 WHERE (id = 2233)']
 
     MODEL_DB.sqls.clear
     m = @c.load(:id => 22)

data/spec/extensions/many_through_many_spec.rb

@@ -23,6 +23,19 @@ describe Sequel::Model, "many_through_many" do
     Object.send(:remove_const, :Tag)
   end
 
+  it "should default to associating to other models in the same scope" do
+    class ::AssociationModuleTest
+      class Artist < Sequel::Model
+        plugin :many_through_many
+        many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+      end  
+      class Tag < Sequel::Model
+      end  
+    end  
+    
+    ::AssociationModuleTest::Artist.association_reflection(:tags).associated_class.should == ::AssociationModuleTest::Tag
+  end 
+
   it "should raise an error if in invalid form of through is used" do
     proc{@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id]]}.should raise_error(Sequel::Error)
     proc{@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], {:table=>:album_tags, :left=>:album_id}]}.should raise_error(Sequel::Error)

data/spec/extensions/schema_dumper_spec.rb

@@ -253,13 +253,14 @@ END_MIG
 
   it "should convert many database types to ruby types" do
     types = %w"mediumint smallint int integer mediumint(6) smallint(7) int(8) integer(9)
-      tinyint tinyint(1) bigint bigint(20) real float double boolean tinytext mediumtext
+      tinyint tinyint(2) bigint bigint(20) real float double boolean tinytext mediumtext
       longtext text clob date datetime timestamp time char character
       varchar varchar(255) varchar(30) bpchar string money
       decimal decimal(10,2) numeric numeric(15,3) number bytea tinyblob mediumblob longblob
       blob varbinary varbinary(10) binary binary(20) year" +
       ["double precision", "timestamp with time zone", "timestamp without time zone",
-       "time with time zone", "time without time zone", "character varying(20)"]
+       "time with time zone", "time without time zone", "character varying(20)"] +
+      %w"nvarchar ntext smalldatetime smallmoney binary varbinary nchar"
     @d.meta_def(:schema) do |t, *o|
       i = 0
       types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
@@ -274,8 +275,8 @@ create_table(:x) do
   Integer :c6
   Integer :c7
   Integer :c8
-  TrueClass :c9
-  TrueClass :c10
+  Integer :c9
+  Integer :c10
   Bignum :c11
   Bignum :c12
   Float :c13
@@ -320,6 +321,13 @@ create_table(:x) do
   Time :c52, :only_time=>true
   Time :c53, :only_time=>true
   String :c54, :size=>20
+  String :c55
+  String :c56, :text=>true
+  DateTime :c57
+  BigDecimal :c58, :size=>[19, 2]
+  File :c59
+  File :c60
+  String :c61, :fixed=>true
 end
 END_MIG
     @d.dump_table_schema(:x).should == table.chomp

data/spec/extensions/validation_class_methods_spec.rb

@@ -950,7 +950,7 @@ describe "Model#save" do
         o.errors[a] << 'blah' unless v == 5
       end
     end
-    @m = @c.load(:id => 4)
+    @m = @c.load(:id => 4, :x=>6)
     MODEL_DB.reset
   end
 
@@ -963,14 +963,14 @@ describe "Model#save" do
     @m.id = 5
     @m.should be_valid
     @m.save.should_not be_false
-    MODEL_DB.sqls.should == ['UPDATE people SET id = 5 WHERE (id = 5)']
+    MODEL_DB.sqls.should == ['UPDATE people SET x = 6 WHERE (id = 5)']
   end
   
   specify "should skip validations if the :validate=>false option is used" do
     @m.raise_on_save_failure = false
     @m.should_not be_valid
     @m.save(:validate=>false)
-    MODEL_DB.sqls.should == ['UPDATE people SET id = 4 WHERE (id = 4)']
+    MODEL_DB.sqls.should == ['UPDATE people SET x = 6 WHERE (id = 4)']
   end
     
   specify "should raise error if validations fail and raise_on_save_faiure is true" do

data/spec/integration/dataset_test.rb

@@ -57,6 +57,26 @@ describe "Simple Dataset operations" do
     @ds.first.should == {:id=>1, :number=>10}
     sqls_should_be('SELECT * FROM items LIMIT 1')
   end
+  
+  specify "should fetch correctly with a limit" do
+    @ds.order(:id).limit(2).all.should == [{:id=>1, :number=>10}]
+    @ds.insert(:number=>20)
+    @ds.order(:id).limit(1).all.should == [{:id=>1, :number=>10}]
+    @ds.order(:id).limit(2).all.should == [{:id=>1, :number=>10}, {:id=>2, :number=>20}]
+  end
+  
+  specify "should fetch correctly with a limit and offset" do
+    @ds.order(:id).limit(2, 0).all.should == [{:id=>1, :number=>10}]
+    @ds.order(:id).limit(2, 1).all.should == []
+    @ds.insert(:number=>20)
+    @ds.order(:id).limit(1, 1).all.should == [{:id=>2, :number=>20}]
+    @ds.order(:id).limit(2, 0).all.should == [{:id=>1, :number=>10}, {:id=>2, :number=>20}]
+    @ds.order(:id).limit(2, 1).all.should == [{:id=>2, :number=>20}]
+  end
+  
+  specify "should fetch correctly with a limit and offset without an order" do
+    @ds.limit(2, 1).all.should == []
+  end
 
   specify "should alias columns correctly" do
     @ds.select(:id___x, :number___n).first.should == {:x=>1, :n=>10}
@@ -326,7 +346,7 @@ if INTEGRATION_DB.dataset.supports_cte?
     end
     
     specify "should give correct results for WITH" do
-      @db[:t].with(:t, @ds.order(:id).filter(:parent_id=>nil).select(:id)).map(:id).should == [1, 2]
+      @db[:t].with(:t, @ds.filter(:parent_id=>nil).select(:id)).order(:id).map(:id).should == [1, 2]
     end
     
     specify "should give correct results for recursive WITH" do
@@ -357,34 +377,44 @@ if INTEGRATION_DB.dataset.supports_window_functions?
       @db.drop_table(:i1)
     end
     
-    specify "should give correct results for window functions" do
-      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id){}}.all.should ==
-        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id){}}.all.should ==
+    specify "should give correct results for aggregate window functions" do
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id){}.as(:sum)}.all.should ==
         [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :order=>id){}}.all.should ==
-        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount){}}.all.should ==
+      @ds.select(:id){sum(:over, :args=>amount){}.as(:sum)}.all.should ==
         [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
     end
+      
+    specify "should give correct results for ranking window functions with orders" do
+      @ds.select(:id){rank(:over, :partition=>group_id, :order=>id){}.as(:rank)}.all.should ==
+        [{:rank=>1, :id=>1}, {:rank=>2, :id=>2}, {:rank=>3, :id=>3}, {:rank=>1, :id=>4}, {:rank=>2, :id=>5}, {:rank=>3, :id=>6}]
+      @ds.select(:id){rank(:over, :order=>id){}.as(:rank)}.all.should ==
+        [{:rank=>1, :id=>1}, {:rank=>2, :id=>2}, {:rank=>3, :id=>3}, {:rank=>4, :id=>4}, {:rank=>5, :id=>5}, {:rank=>6, :id=>6}]
+    end
+      
+    specify "should give correct results for aggregate window functions with orders" do
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id){}.as(:sum)}.all.should ==
+        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.select(:id){sum(:over, :args=>amount, :order=>id){}.as(:sum)}.all.should ==
+        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
+    end
     
-    specify "should give correct results for window functions with frames" do
-      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id, :frame=>:all){}}.all.should ==
+    specify "should give correct results for aggregate window functions with frames" do
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id, :frame=>:all){}.as(:sum)}.all.should ==
         [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :frame=>:all){}}.all.should ==
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :frame=>:all){}.as(:sum)}.all.should ==
         [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :order=>id, :frame=>:all){}}.all.should ==
+      @ds.select(:id){sum(:over, :args=>amount, :order=>id, :frame=>:all){}.as(:sum)}.all.should ==
         [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :frame=>:all){}}.all.should ==
+      @ds.select(:id){sum(:over, :args=>amount, :frame=>:all){}.as(:sum)}.all.should ==
         [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
         
-      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id, :frame=>:rows){}}.all.should ==
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id, :frame=>:rows){}.as(:sum)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :frame=>:rows){}}.all.should ==
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :frame=>:rows){}.as(:sum)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :order=>id, :frame=>:rows){}}.all.should ==
+      @ds.select(:id){sum(:over, :args=>amount, :order=>id, :frame=>:rows){}.as(:sum)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :frame=>:rows){}}.all.should ==
+      @ds.select(:id){sum(:over, :args=>amount, :frame=>:rows){}.as(:sum)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
     end
   end

data/spec/integration/prepared_statement_test.rb

@@ -49,9 +49,9 @@ describe "Prepared Statements and Bound Arguments" do
   end
 
   specify "should support bound variables with insert" do
-    @ds.call(:insert, {:n=>20, :i=>100}, :id=>@ds.ba(:$i), :number=>@ds.ba(:$n))
+    @ds.call(:insert, {:n=>20}, :number=>@ds.ba(:$n))
     @ds.count.should == 2
-    @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
+    @ds.order(:id).map(:number).should == [10, 20]
   end
 
   specify "should have insert return primary key value when using bound arguments" do
@@ -84,10 +84,10 @@ describe "Prepared Statements and Bound Arguments" do
   end
 
   specify "should support prepared statements with insert" do
-    @ds.prepare(:insert, :insert_n, :id=>@ds.ba(:$i), :number=>@ds.ba(:$n))
-    INTEGRATION_DB.call(:insert_n, :n=>20, :i=>100)
+    @ds.prepare(:insert, :insert_n, :number=>@ds.ba(:$n))
+    INTEGRATION_DB.call(:insert_n, :n=>20)
     @ds.count.should == 2
-    @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
+    @ds.order(:id).map(:number).should == [10, 20]
   end
 
   specify "should have insert return primary key value when using prepared statements" do

data/spec/integration/schema_test.rb

@@ -146,74 +146,151 @@ end
 
 describe "Database schema modifiers" do
   before do
-    @ds = INTEGRATION_DB[:items]
+    @db = INTEGRATION_DB
+    @ds = @db[:items]
     clear_sqls
   end
   after do
-    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+    @db.drop_table(:items) if @db.table_exists?(:items)
   end
 
   specify "should create tables correctly" do
-    INTEGRATION_DB.create_table!(:items){Integer :number}
-    INTEGRATION_DB.table_exists?(:items).should == true
-    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number]
+    @db.create_table!(:items){Integer :number}
+    @db.table_exists?(:items).should == true
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:number]
     @ds.insert([10])
     @ds.columns!.should == [:number]
   end
 
   specify "should handle foreign keys correctly when creating tables" do
-    INTEGRATION_DB.create_table!(:items) do 
+    @db.create_table!(:items) do 
       primary_key :id
       foreign_key :item_id, :items
       unique [:item_id, :id]
       foreign_key [:id, :item_id], :items, :key=>[:item_id, :id]
     end
-    INTEGRATION_DB.table_exists?(:items).should == true
-    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @db.table_exists?(:items).should == true
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
     @ds.columns!.should == [:id, :item_id]
   end
 
   specify "should add columns to tables correctly" do
-    INTEGRATION_DB.create_table!(:items){Integer :number}
-    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number]
-    @ds.columns!.should == [:number]
-    INTEGRATION_DB.alter_table(:items){add_column :name, :text}
-    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name]
+    @db.create_table!(:items){Integer :number}
+    @ds.insert(:number=>10)
+    @db.alter_table(:items){add_column :name, :text}
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name]
     @ds.columns!.should == [:number, :name]
-    unless INTEGRATION_DB.database_type == :sqlite
-      INTEGRATION_DB.alter_table(:items){add_primary_key :id}
-      INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id]
-      @ds.columns!.should == [:number, :name, :id]
-      INTEGRATION_DB.alter_table(:items){add_foreign_key :item_id, :items}
-      INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id, :item_id]
-      @ds.columns!.should == [:number, :name, :id, :item_id]
-      INTEGRATION_DB.alter_table(:items) do
-        add_unique_constraint [:item_id, :id]
-        add_foreign_key [:id, :item_id], :items, :key=>[:item_id, :id]
-      end
-      INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id, :item_id]
-      @ds.columns!.should == [:number, :name, :id, :item_id]
+    @ds.all.should == [{:number=>10, :name=>nil}]
+  end
+
+  specify "should add primary key columns to tables correctly" do
+    @db.create_table!(:items){Integer :number}
+    @ds.insert(:number=>10)
+    @db.alter_table(:items){add_primary_key :id}
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :id]
+    @ds.columns!.should == [:number, :id]
+    @ds.map(:number).should == [10]
+  end
+
+  specify "should add foreign key columns to tables correctly" do
+    @db.create_table!(:items){primary_key :id}
+    i = @ds.insert
+    @db.alter_table(:items){add_foreign_key :item_id, :items}
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @ds.columns!.should == [:id, :item_id]
+    @ds.all.should == [{:id=>i, :item_id=>nil}]
+  end
+
+  specify "should rename columns correctly" do
+    @db.create_table!(:items){Integer :id}
+    @ds.insert(:id=>10)
+    @db.alter_table(:items){rename_column :id, :id2}
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id2]
+    @ds.columns!.should == [:id2]
+    @ds.all.should == [{:id2=>10}]
+  end
+
+  specify "should rename columns with defaults correctly" do
+    @db.create_table!(:items){String :n, :default=>'blah'}
+    @ds.insert
+    @db.alter_table(:items){rename_column :n, :n2}
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:n2]
+    @ds.columns!.should == [:n2]
+    @ds.insert
+    @ds.all.should == [{:n2=>'blah'}, {:n2=>'blah'}]
+  end
+
+  specify "should rename columns with not null constraints" do
+    @db.create_table!(:items){String :n, :null=>false}
+    @ds.insert(:n=>'blah')
+    @db.alter_table(:items){rename_column :n, :n2}
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:n2]
+    @ds.columns!.should == [:n2]
+    @ds.insert(:n2=>'blah')
+    @ds.all.should == [{:n2=>'blah'}, {:n2=>'blah'}]
+    proc{@ds.insert}.should raise_error(Sequel::DatabaseError)
+  end
+
+  specify "should set column NULL/NOT NULL correctly" do
+    @db.create_table!(:items){Integer :id}
+    @ds.insert(:id=>10)
+    @db.alter_table(:items){set_column_allow_null :id, false}
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
+    @ds.columns!.should == [:id]
+    proc{@ds.insert}.should raise_error(Sequel::DatabaseError)
+    @db.alter_table(:items){set_column_allow_null :id, true}
+    @ds.insert
+    @ds.all.should == [{:id=>10}, {:id=>nil}]
+  end
+
+  specify "should set column defaults correctly" do
+    @db.create_table!(:items){Integer :id}
+    @ds.insert(:id=>10)
+    @db.alter_table(:items){set_column_default :id, 20}
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
+    @ds.columns!.should == [:id]
+    @ds.insert
+    @ds.all.should == [{:id=>10}, {:id=>20}]
+  end
+
+  specify "should set column types correctly" do
+    @db.create_table!(:items){Integer :id}
+    @ds.insert(:id=>10)
+    @db.alter_table(:items){set_column_type :id, String}
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
+    @ds.columns!.should == [:id]
+    @ds.insert(:id=>20)
+    @ds.all.should == [{:id=>"10"}, {:id=>"20"}]
+  end
+
+  specify "should add unique constraints and foreign key table constraints correctly" do
+    @db.create_table!(:items){Integer :id; Integer :item_id}
+    @db.alter_table(:items) do
+      add_unique_constraint [:item_id, :id]
+      add_foreign_key [:id, :item_id], :items, :key=>[:item_id, :id]
     end
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @ds.columns!.should == [:id, :item_id]
   end
 
   specify "should remove columns from tables correctly" do
-    INTEGRATION_DB.create_table!(:items) do
+    @db.create_table!(:items) do
       primary_key :id
       String :name
       Integer :number
       foreign_key :item_id, :items
     end
     @ds.insert(:number=>10)
-    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :number, :item_id]
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :number, :item_id]
     @ds.columns!.should == [:id, :name, :number, :item_id]
-    INTEGRATION_DB.drop_column(:items, :number)
-    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :item_id]
+    @db.drop_column(:items, :number)
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :item_id]
     @ds.columns!.should == [:id, :name, :item_id]
-    INTEGRATION_DB.drop_column(:items, :name)
-    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @db.drop_column(:items, :name)
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
     @ds.columns!.should == [:id, :item_id]
-    INTEGRATION_DB.drop_column(:items, :item_id)
-    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
+    @db.drop_column(:items, :item_id)
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
     @ds.columns!.should == [:id]
   end
 end