sequel 3.21.0 → 3.36.0

data/spec/extensions/schema_caching_spec.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "schema_caching extension" do
+  before do
+    @db = Sequel.mock
+    @schemas = {'"table"'=>[[:column, {:db_type=>"integer", :default=>"nextval('table_id_seq'::regclass)", :allow_null=>false, :primary_key=>true, :type=>:integer, :ruby_default=>nil}]]}
+    @filename = "spec/files/test_schema_#$$.dump" 
+    @db.instance_variable_set(:@schemas, @schemas)
+  end
+  after do
+    File.delete(@filename) if File.exist?(@filename)
+  end
+
+  it "Database#dump_schema_cache should dump cached schema to the given file" do
+    File.exist?(@filename).should be_false
+    @db.dump_schema_cache(@filename)
+    File.exist?(@filename).should be_true
+    File.size(@filename).should > 0
+  end
+
+  it "Database#load_schema_cache should load cached schema from the given file dumped by #dump_schema_cache" do
+    @db.dump_schema_cache(@filename)
+    db = Sequel::Database.new
+    db.load_schema_cache(@filename)
+    @db.instance_variable_get(:@schemas).should == @schemas
+  end
+
+  it "Database#dump_schema_cache? should dump cached schema to the given file unless the file exists" do
+    File.open(@filename, 'wb'){|f|}
+    File.size(@filename).should == 0
+    @db.dump_schema_cache?(@filename)
+    File.size(@filename).should == 0
+  end
+
+  it "Database#load_schema_cache? should load cached schema from the given file if it exists" do
+    db = Sequel::Database.new
+    File.exist?(@filename).should be_false
+    db.load_schema_cache?(@filename)
+    db.instance_variable_get(:@schemas).should == {}
+  end
+end

data/spec/extensions/schema_dumper_spec.rb

@@ -43,19 +43,17 @@ describe "Sequel::Schema::Generator dump methods" do
       index [:b, :c], :unique=>true
     end
 
-    t = <<END_CODE
+    g.dump_indexes(:add_index=>:t).should == (<<END_CODE).strip
 add_index :t, [:a]
 add_index :t, [:c, :e], :name=>:blah
 add_index :t, [:b, :c], :unique=>true
 END_CODE
-    g.dump_indexes(:add_index=>:t).should == t.strip
 
-    t = <<END_CODE
-drop_index :t, [:a]
-drop_index :t, [:c, :e], :name=>:blah
+    g.dump_indexes(:drop_index=>:t).should == (<<END_CODE).strip
 drop_index :t, [:b, :c], :unique=>true
+drop_index :t, [:c, :e], :name=>:blah
+drop_index :t, [:a]
 END_CODE
-    g.dump_indexes(:drop_index=>:t).should == t.strip
   end
 
   it "should raise an error if you try to dump a Generator that uses a constraint with a proc" do
@@ -75,15 +73,8 @@ describe "Sequel::Database dump methods" do
       when :t2
         [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>false}],
          [:c2, {:db_type=>'numeric', :primary_key=>true, :allow_null=>false}]]
-      when :t3
-        [[:c1, {:db_type=>'date', :default=>"'now()'", :allow_null=>true}],
-         [:c2, {:db_type=>'datetime', :allow_null=>false}]]
       when :t5
         [[:c1, {:db_type=>'blahblah', :allow_null=>true}]]
-      when :t6
-        [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true}]]
-      when :t7
-        [[:c1, {:db_type=>'somedbspecifictype', :primary_key=>true, :allow_null=>false}]]
       end
     end
   end
@@ -101,10 +92,73 @@ describe "Sequel::Database dump methods" do
   end
 
   it "should dump non-Integer primary key columns with explicit :type" do
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true}]]}
     @d.dump_table_schema(:t6).should == "create_table(:t6) do\n  primary_key :c1, :type=>Bignum\nend"
   end
 
+  it "should handle foreign keys" do
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :allow_null=>true}]]}
+    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}]}
+    @d.dump_table_schema(:t6).should == "create_table(:t6) do\n  foreign_key :c1, :t2, :key=>[:c2]\nend"
+  end
+
+  it "should handle primary keys that are also foreign keys" do
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true}]]}
+    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}]}
+    s = @d.dump_table_schema(:t6)
+    s.should =~ /create_table\(:t6\) do\n  primary_key :c1, /
+    s.should =~ /:table=>:t2/
+    s.should =~ /:key=>\[:c2\]/
+  end
+
+  it "should handle foreign key options" do
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :allow_null=>true}]]}
+    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}]}
+    s = @d.dump_table_schema(:t6)
+    s.should =~ /create_table\(:t6\) do\n  foreign_key :c1, :t2, /
+    s.should =~ /:key=>\[:c2\]/
+    s.should =~ /:on_delete=>:restrict/
+    s.should =~ /:on_update=>:set_null/
+    s.should =~ /:deferrable=>true/
+  end
+
+  it "should handle foreign key options in the primary key" do
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true}]]}
+    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}]}
+    s = @d.dump_table_schema(:t6)
+    s.should =~ /create_table\(:t6\) do\n  primary_key :c1, /
+    s.should =~ /:table=>:t2/
+    s.should =~ /:key=>\[:c2\]/
+    s.should =~ /:on_delete=>:restrict/
+    s.should =~ /:on_update=>:set_null/
+    s.should =~ /:deferrable=>true/
+  end
+
+  it "should omit foreign key options that are the same as defaults" do
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :allow_null=>true}]]}
+    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}]}
+    s = @d.dump_table_schema(:t6)
+    s.should =~ /create_table\(:t6\) do\n  foreign_key :c1, :t2, /
+    s.should =~ /:key=>\[:c2\]/
+    s.should_not =~ /:on_delete/
+    s.should_not =~ /:on_update/
+    s.should_not =~ /:deferrable/
+  end
+
+  it "should omit foreign key options that are the same as defaults in the primary key" do
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true}]]}
+    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}]}
+    s = @d.dump_table_schema(:t6)
+    s.should =~ /create_table\(:t6\) do\n  primary_key :c1, /
+    s.should =~ /:table=>:t2/
+    s.should =~ /:key=>\[:c2\]/
+    s.should_not =~ /:on_delete/
+    s.should_not =~ /:on_update/
+    s.should_not =~ /:deferrable/
+  end
+
   it "should dump primary key columns with explicit :type equal to the database type when :same_db option is passed" do
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'somedbspecifictype', :primary_key=>true, :allow_null=>false}]]}
     @d.dump_table_schema(:t7, :same_db => true).should == "create_table(:t7) do\n  primary_key :c1, :type=>\"somedbspecifictype\"\nend"
   end
 
@@ -112,6 +166,12 @@ describe "Sequel::Database dump methods" do
     @d.dump_table_schema(:t2).should == "create_table(:t2) do\n  Integer :c1, :null=>false\n  BigDecimal :c2, :null=>false\n  \n  primary_key [:c1, :c2]\nend"
   end
 
+  it "should use a composite foreign_key calls if there is a composite foreign key" do
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer'}], [:c2, {:db_type=>'integer'}]]}
+    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1, :c2], :table=>:t2, :key=>[:c3, :c4]}]}
+    @d.dump_table_schema(:t1).should == "create_table(:t1) do\n  Integer :c1\n  Integer :c2\n  \n  foreign_key [:c1, :c2], :t2, :key=>[:c3, :c4]\nend"
+  end
+
   it "should include index information if available" do
     @d.meta_def(:indexes) do |t|
       {:i1=>{:columns=>[:c1], :unique=>false},
@@ -138,7 +198,7 @@ Sequel.migration do
   end
   
   down do
-    drop_table(:t1, :t2)
+    drop_table(:t2, :t1)
   end
 end
 END_MIG
@@ -162,6 +222,92 @@ Sequel.migration do
     end
   end
   
+  down do
+    drop_table(:t2, :t1)
+  end
+end
+END_MIG
+  end
+
+  it "should sort table names topologically when dumping a migration with foreign keys" do
+    @d.meta_def(:tables){|o| [:t1, :t2]}
+    @d.meta_def(:schema) do |t|
+      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true}]]
+    end
+    @d.meta_def(:foreign_key_list) do |t|
+      t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
+    end
+    @d.dump_schema_migration.should == <<-END_MIG
+Sequel.migration do
+  up do
+    create_table(:t2) do
+      primary_key :c1
+    end
+    
+    create_table(:t1) do
+      foreign_key :c2, :t2, :key=>[:c1]
+    end
+  end
+  
+  down do
+    drop_table(:t1, :t2)
+  end
+end
+END_MIG
+  end
+
+  it "should handle circular dependencies when dumping a migration with foreign keys" do
+    @d.meta_def(:tables){|o| [:t1, :t2]}
+    @d.meta_def(:schema) do |t|
+      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer'}]]
+    end
+    @d.meta_def(:foreign_key_list) do |t|
+      t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : [{:columns=>[:c1], :table=>:t1, :key=>[:c2]}]
+    end
+    @d.dump_schema_migration.should == <<-END_MIG
+Sequel.migration do
+  up do
+    create_table(:t1) do
+      Integer :c2
+    end
+    
+    create_table(:t2) do
+      foreign_key :c1, :t1, :key=>[:c2]
+    end
+    
+    alter_table(:t1) do
+      add_foreign_key [:c2], :t2, :key=>[:c1]
+    end
+  end
+  
+  down do
+    drop_table(:t2, :t1)
+  end
+end
+END_MIG
+  end
+
+  it "should sort topologically even if the database raises an error when trying to parse foreign keys for a non-existent table" do
+    @d.meta_def(:tables){|o| [:t1, :t2]}
+    @d.meta_def(:schema) do |t|
+      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true}]]
+    end
+    @d.meta_def(:foreign_key_list) do |t|
+      raise Sequel::DatabaseError unless [:t1, :t2].include?(t)
+      t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
+    end
+    @d.dump_schema_migration.should == <<-END_MIG
+Sequel.migration do
+  up do
+    create_table(:t2) do
+      primary_key :c1
+    end
+    
+    create_table(:t1) do
+      foreign_key :c2, :t2, :key=>[:c1]
+    end
+  end
+  
   down do
     drop_table(:t1, :t2)
   end
@@ -188,7 +334,113 @@ Sequel.migration do
   end
   
   down do
-    drop_table(:t1, :t2)
+    drop_table(:t2, :t1)
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => false option to not include names of indexes" do
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_table_schema(:t1, :index_names=>false).should == "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1]\n  index [:c2, :c1], :unique=>true\nend"
+    @d.dump_schema_migration(:index_names=>false).should == <<-END_MIG
+Sequel.migration do
+  up do
+    create_table(:t1, :ignore_index_errors=>true) do
+      primary_key :c1
+      String :c2, :size=>20
+      
+      index [:c1]
+      index [:c2, :c1], :unique=>true
+    end
+    
+    create_table(:t2, :ignore_index_errors=>true) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+      
+      index [:c1]
+      index [:c2, :c1], :unique=>true
+    end
+  end
+  
+  down do
+    drop_table(:t2, :t1)
+  end
+end
+END_MIG
+  end
+  
+  it "should make :index_names => :namespace option a noop if there is a  global index namespace" do
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_table_schema(:t1, :index_names=>:namespace).should == "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:i1\n  index [:c2, :c1]\nend"
+    @d.dump_schema_migration(:index_names=>:namespace).should == <<-END_MIG
+Sequel.migration do
+  up do
+    create_table(:t1, :ignore_index_errors=>true) do
+      primary_key :c1
+      String :c2, :size=>20
+      
+      index [:c1], :name=>:i1
+      index [:c2, :c1]
+    end
+    
+    create_table(:t2, :ignore_index_errors=>true) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+      
+      index [:c1], :name=>:i1
+      index [:c2, :c1], :name=>:t1_c2_c1_index
+    end
+  end
+  
+  down do
+    drop_table(:t2, :t1)
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => :namespace option to include names of indexes with prepended table name if there is no global index namespace" do
+    @d.meta_def(:global_index_namespace?){false}
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_table_schema(:t1, :index_names=>:namespace).should == "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:t1_i1\n  index [:c2, :c1]\nend"
+    @d.dump_schema_migration(:index_names=>:namespace).should == <<-END_MIG
+Sequel.migration do
+  up do
+    create_table(:t1, :ignore_index_errors=>true) do
+      primary_key :c1
+      String :c2, :size=>20
+      
+      index [:c1], :name=>:t1_i1
+      index [:c2, :c1]
+    end
+    
+    create_table(:t2, :ignore_index_errors=>true) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+      
+      index [:c1], :name=>:t2_i1
+      index [:c2, :c1], :name=>:t2_t1_c2_c1_index
+    end
+  end
+  
+  down do
+    drop_table(:t2, :t1)
   end
 end
 END_MIG
@@ -217,12 +469,26 @@ Sequel.migration do
   end
   
   down do
-    drop_table(:t1, :t2)
+    drop_table(:t2, :t1)
   end
 end
 END_MIG
   end
 
+  it "should have :indexes => false option disable foreign keys as well when dumping a whole migration" do
+    @d.meta_def(:foreign_key_list) do |t|
+      t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
+    end
+    @d.dump_schema_migration(:indexes=>false).should_not =~ /foreign_key/
+  end
+
+  it "should have :foreign_keys option override :indexes => false disabling of foreign keys" do
+    @d.meta_def(:foreign_key_list) do |t|
+      t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
+    end
+    @d.dump_schema_migration(:indexes=>false, :foreign_keys=>true).should =~ /foreign_key/
+  end
+
   it "should support dumping just indexes as a migration" do
     @d.meta_def(:tables){|o| [:t1]}
     @d.meta_def(:indexes) do |t|
@@ -237,14 +503,147 @@ Sequel.migration do
   end
   
   down do
+    drop_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
     drop_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => false option to not include names of indexes when dumping just indexes as a migration" do
+    @d.meta_def(:tables){|o| [:t1]}
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_indexes_migration(:index_names=>false).should == <<-END_MIG
+Sequel.migration do
+  up do
+    add_index :t1, [:c1], :ignore_errors=>true
+    add_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
+  end
+  
+  down do
     drop_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
+    drop_index :t1, [:c1], :ignore_errors=>true
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => :namespace option be a noop if there is a global index namespace" do
+    @d.meta_def(:tables){|o| [:t1, :t2]}
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_indexes_migration(:index_names=>:namespace).should == <<-END_MIG
+Sequel.migration do
+  up do
+    add_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
+    add_index :t1, [:c2, :c1], :ignore_errors=>true
+    
+    add_index :t2, [:c1], :ignore_errors=>true, :name=>:i1
+    add_index :t2, [:c2, :c1], :ignore_errors=>true, :name=>:t1_c2_c1_index
+  end
+  
+  down do
+    drop_index :t2, [:c2, :c1], :ignore_errors=>true, :name=>:t1_c2_c1_index
+    drop_index :t2, [:c1], :ignore_errors=>true, :name=>:i1
+    
+    drop_index :t1, [:c2, :c1], :ignore_errors=>true
+    drop_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => :namespace option to include names of indexes with prepended table name when dumping just indexes as a migration if there is no global index namespace" do
+    @d.meta_def(:global_index_namespace?){false}
+    @d.meta_def(:tables){|o| [:t1, :t2]}
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_indexes_migration(:index_names=>:namespace).should == <<-END_MIG
+Sequel.migration do
+  up do
+    add_index :t1, [:c1], :ignore_errors=>true, :name=>:t1_i1
+    add_index :t1, [:c2, :c1], :ignore_errors=>true
+    
+    add_index :t2, [:c1], :ignore_errors=>true, :name=>:t2_i1
+    add_index :t2, [:c2, :c1], :ignore_errors=>true, :name=>:t2_t1_c2_c1_index
+  end
+  
+  down do
+    drop_index :t2, [:c2, :c1], :ignore_errors=>true, :name=>:t2_t1_c2_c1_index
+    drop_index :t2, [:c1], :ignore_errors=>true, :name=>:t2_i1
+    
+    drop_index :t1, [:c2, :c1], :ignore_errors=>true
+    drop_index :t1, [:c1], :ignore_errors=>true, :name=>:t1_i1
+  end
+end
+END_MIG
+  end
+
+  it "should handle missing index parsing support when dumping index migration" do
+    @d.meta_def(:tables){|o| [:t1]}
+    @d.dump_indexes_migration.should == <<-END_MIG
+Sequel.migration do
+  up do
+    
+  end
+  
+  down do
+    
+  end
+end
+END_MIG
+  end
+
+  it "should handle missing foreign key parsing support when dumping foreign key migration" do
+    @d.meta_def(:tables){|o| [:t1]}
+    @d.dump_foreign_key_migration.should == <<-END_MIG
+Sequel.migration do
+  up do
+    
+  end
+end
+END_MIG
+  end
+
+  it "should support dumping just foreign_keys as a migration" do
+    @d.meta_def(:tables){|o| [:t1, :t2, :t3]}
+    @d.meta_def(:schema) do |t|
+      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer'}]]
+    end
+    @d.meta_def(:foreign_key_list) do |t, *a|
+      case t
+      when :t1
+        [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}]
+      when :t2
+        [{:columns=>[:c1, :c3], :table=>:t1, :key=>[:c2, :c4]}]
+      else
+        []
+      end
+    end
+    @d.dump_foreign_key_migration.should == <<-END_MIG
+Sequel.migration do
+  up do
+    alter_table(:t1) do
+      add_foreign_key [:c2], :t2, :key=>[:c1]
+    end
+    
+    alter_table(:t2) do
+      add_foreign_key [:c1, :c3], :t1, :key=>[:c2, :c4]
+    end
   end
 end
 END_MIG
   end
 
   it "should handle not null values and defaults" do
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'date', :default=>"'now()'", :allow_null=>true}], [:c2, {:db_type=>'datetime', :allow_null=>false}]]}
     @d.dump_table_schema(:t3).should == "create_table(:t3) do\n  Date :c1\n  DateTime :c2, :null=>false\nend"
   end
   
@@ -263,8 +662,8 @@ END_MIG
       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=>Time.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=>Time.parse(\"10:20:30\")\n  column :c10, \"interval\", :default=>\"'6 weeks'\".lit\nend"
+    @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=>\"'6 weeks'\".lit\nend"
   end
   
   it "should not use a '...'.lit as a fallback if using MySQL with the :same_db option" do
@@ -291,12 +690,14 @@ END_MIG
       ["double precision", "timestamp with time zone", "timestamp without time zone",
        "time with time zone", "time without time zone", "character varying(20)"] +
       %w"nvarchar ntext smalldatetime smallmoney binary varbinary nchar" +
-      ["timestamp(6) without time zone", "timestamp(6) with time zone", "int(12) unsigned", 'bigint unsigned']
+      ["timestamp(6) without time zone", "timestamp(6) with time zone", 'mediumint(10) unsigned', 'int(9) unsigned',
+       'int(10) unsigned', "int(12) unsigned", 'bigint unsigned', 'tinyint(3) unsigned', 'identity', 'int identity'] +
+      %w"integer(10)"
     @d.meta_def(:schema) do |t, *o|
       i = 0
       types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
     end
-    table = <<END_MIG
+    @d.dump_table_schema(:x).should == (<<END_MIG).chomp
 create_table(:x) do
   Integer :c1
   Integer :c2
@@ -362,9 +763,15 @@ create_table(:x) do
   DateTime :c62, :size=>6
   DateTime :c63, :size=>6
   Integer :c64
-  Bignum :c65
+  Integer :c65
+  Bignum :c66
+  Bignum :c67
+  Bignum :c68
+  Integer :c69
+  Integer :c70
+  Integer :c71
+  Integer :c72
 end
 END_MIG
-    @d.dump_table_schema(:x).should == table.chomp
   end
 end