sequel 3.33.0 → 3.34.0

data/spec/extensions/prepared_statements_spec.rb

@@ -32,6 +32,10 @@ describe "prepared_statements plugin" do
   end
 
   specify "should correctly create instance if dataset supports insert_select" do
+    ds = @c.instance_dataset 
+    def ds.supports_insert_select?
+      true
+    end
     def @ds.supports_insert_select?
       true
     end

data/spec/extensions/pretty_table_spec.rb

@@ -63,6 +63,12 @@ describe "PrettyTable" do
       /\n(\|x\|y\|)|(\|y\|x\|)\n/
   end
   
+  specify "should have #string return the string without printing" do
+    Sequel::PrettyTable.string(@data1).should =~ /\n(\|x\|y\|)|(\|y\|x\|)\n/
+    @output.rewind
+    @output.read.should == ''
+  end
+  
   specify "should calculate the maximum width of each column correctly" do
     Sequel::PrettyTable.print(@data2, [:a, :b])
     @output.rewind

data/spec/extensions/query_literals_spec.rb

@@ -0,0 +1,168 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "query_literals extension" do
+  before do
+    @ds = Sequel::Dataset.new(nil).from(:t)
+    @ds.extend(Sequel::QueryLiterals)
+  end
+
+  it "should not use special support if given a block" do
+    @ds.select('a, b, c'){d}.sql.should == 'SELECT \'a, b, c\', d FROM t'
+  end
+
+  it "should have #select use literal string if given a single string" do
+    @ds.select('a, b, c').sql.should == 'SELECT a, b, c FROM t'
+  end
+
+  it "should have #select use placeholder literal string if given a string and additional arguments" do
+    @ds.select('a, b, ?', 1).sql.should == 'SELECT a, b, 1 FROM t'
+  end
+
+  it "should have #select work the standard way if initial string is a literal string already" do
+    @ds.select('a, b, ?'.lit, 1).sql.should == 'SELECT a, b, ?, 1 FROM t'
+  end
+
+  it "should have #select work regularly if not given a string as the first argument" do
+    @ds.select(:a, 1).sql.should == 'SELECT a, 1 FROM t'
+  end
+
+  describe 'with existing selection' do
+    before do
+      @ds = @ds.select(:d)
+    end
+
+    it "should have #select_more use literal string if given a single string" do
+      @ds.select_more('a, b, c').sql.should == 'SELECT d, a, b, c FROM t'
+    end
+
+    it "should have #select_ use placeholder literal string if given a string and additional arguments" do
+      @ds.select_more('a, b, ?', 1).sql.should == 'SELECT d, a, b, 1 FROM t'
+    end
+
+    it "should have #select_more work the standard way if initial string is a literal string already" do
+      @ds.select_more('a, b, ?'.lit, 1).sql.should == 'SELECT d, a, b, ?, 1 FROM t'
+    end
+
+    it "should have #select_more work regularly if not given a string as the first argument" do
+      @ds.select_more(:a, 1).sql.should == 'SELECT d, a, 1 FROM t'
+    end
+  end
+
+  it "should have #select_append use literal string if given a single string" do
+    @ds.select_append('a, b, c').sql.should == 'SELECT *, a, b, c FROM t'
+  end
+
+  it "should have #select_append use placeholder literal string if given a string and additional arguments" do
+    @ds.select_append('a, b, ?', 1).sql.should == 'SELECT *, a, b, 1 FROM t'
+  end
+
+  it "should have #select_append work the standard way if initial string is a literal string already" do
+    @ds.select_append('a, b, ?'.lit, 1).sql.should == 'SELECT *, a, b, ?, 1 FROM t'
+  end
+
+  it "should have #select_append work regularly if not given a string as the first argument" do
+    @ds.select_append(:a, 1).sql.should == 'SELECT *, a, 1 FROM t'
+  end
+
+  it "should have #select_group use literal string if given a single string" do
+    @ds.select_group('a, b, c').sql.should == 'SELECT a, b, c FROM t GROUP BY a, b, c'
+  end
+
+  it "should have #select_group use placeholder literal string if given a string and additional arguments" do
+    @ds.select_group('a, b, ?', 1).sql.should == 'SELECT a, b, 1 FROM t GROUP BY a, b, 1'
+  end
+
+  it "should have #select_group work the standard way if initial string is a literal string already" do
+    @ds.select_group('a, b, ?'.lit, 1).sql.should == 'SELECT a, b, ?, 1 FROM t GROUP BY a, b, ?, 1'
+  end
+
+  it "should have #select_group work regularly if not given a string as the first argument" do
+    @ds.select_group(:a, 1).sql.should == 'SELECT a, 1 FROM t GROUP BY a, 1'
+  end
+
+  it "should have #group use literal string if given a single string" do
+    @ds.group('a, b, c').sql.should == 'SELECT * FROM t GROUP BY a, b, c'
+  end
+
+  it "should have #group use placeholder literal string if given a string and additional arguments" do
+    @ds.group('a, b, ?', 1).sql.should == 'SELECT * FROM t GROUP BY a, b, 1'
+  end
+
+  it "should have #select_group work the standard way if initial string is a literal string already" do
+    @ds.group('a, b, ?'.lit, 1).sql.should == 'SELECT * FROM t GROUP BY a, b, ?, 1'
+  end
+
+  it "should have #select_group work regularly if not given a string as the first argument" do
+    @ds.group(:a, 1).sql.should == 'SELECT * FROM t GROUP BY a, 1'
+  end
+
+  it "should have #group_and_count use literal string if given a single string" do
+    @ds.group_and_count('a, b, c').sql.should == 'SELECT a, b, c, count(*) AS count FROM t GROUP BY a, b, c'
+  end
+
+  it "should have #group_and_count use placeholder literal string if given a string and additional arguments" do
+    @ds.group_and_count('a, b, ?', 1).sql.should == 'SELECT a, b, 1, count(*) AS count FROM t GROUP BY a, b, 1'
+  end
+
+  it "should have #group_and_count work the standard way if initial string is a literal string already" do
+    @ds.group_and_count('a, b, ?'.lit, 1).sql.should == 'SELECT a, b, ?, 1, count(*) AS count FROM t GROUP BY a, b, ?, 1'
+  end
+
+  it "should have #group_and_count work regularly if not given a string as the first argument" do
+    @ds.group_and_count(:a, 1).sql.should == 'SELECT a, 1, count(*) AS count FROM t GROUP BY a, 1'
+  end
+
+  it "should have #order use literal string if given a single string" do
+    @ds.order('a, b, c').sql.should == 'SELECT * FROM t ORDER BY a, b, c'
+  end
+
+  it "should have #order use placeholder literal string if given a string and additional arguments" do
+    @ds.order('a, b, ?', 1).sql.should == 'SELECT * FROM t ORDER BY a, b, 1'
+  end
+
+  it "should have #order work the standard way if initial string is a literal string already" do
+    @ds.order('a, b, ?'.lit, 1).sql.should == 'SELECT * FROM t ORDER BY a, b, ?, 1'
+  end
+
+  it "should have #order work regularly if not given a string as the first argument" do
+    @ds.order(:a, 1).sql.should == 'SELECT * FROM t ORDER BY a, 1'
+  end
+
+  describe 'with existing order' do
+    before do
+      @ds = @ds.order(:d)
+    end
+
+    it "should have #order_more use literal string if given a single string" do
+      @ds.order_more('a, b, c').sql.should == 'SELECT * FROM t ORDER BY d, a, b, c'
+    end
+
+    it "should have #order_more use placeholder literal string if given a string and additional arguments" do
+      @ds.order_more('a, b, ?', 1).sql.should == 'SELECT * FROM t ORDER BY d, a, b, 1'
+    end
+
+    it "should have #order_more work the standard way if initial string is a literal string already" do
+      @ds.order_more('a, b, ?'.lit, 1).sql.should == 'SELECT * FROM t ORDER BY d, a, b, ?, 1'
+    end
+
+    it "should have #order_more work regularly if not given a string as the first argument" do
+      @ds.order_more(:a, 1).sql.should == 'SELECT * FROM t ORDER BY d, a, 1'
+    end
+
+    it "should have #order_prepend use literal string if given a single string" do
+      @ds.order_prepend('a, b, c').sql.should == 'SELECT * FROM t ORDER BY a, b, c, d'
+    end
+
+    it "should have #order_append use placeholder literal string if given a string and additional arguments" do
+      @ds.order_prepend('a, b, ?', 1).sql.should == 'SELECT * FROM t ORDER BY a, b, 1, d'
+    end
+
+    it "should have #order_append work the standard way if initial string is a literal string already" do
+      @ds.order_prepend('a, b, ?'.lit, 1).sql.should == 'SELECT * FROM t ORDER BY a, b, ?, 1, d'
+    end
+
+    it "should have #order_append work regularly if not given a string as the first argument" do
+      @ds.order_prepend(:a, 1).sql.should == 'SELECT * FROM t ORDER BY a, 1, d'
+    end
+  end
+end

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

@@ -73,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
@@ -99,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
 
@@ -110,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},
@@ -136,7 +198,7 @@ Sequel.migration do
   end
   
   down do
-    drop_table(:t1, :t2)
+    drop_table(:t2, :t1)
   end
 end
 END_MIG
@@ -160,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
@@ -186,7 +334,7 @@ Sequel.migration do
   end
   
   down do
-    drop_table(:t1, :t2)
+    drop_table(:t2, :t1)
   end
 end
 END_MIG
@@ -215,12 +363,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|
@@ -242,7 +404,64 @@ 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
   
@@ -289,7 +508,7 @@ 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", "int(12) unsigned", 'bigint unsigned', 'tinyint(3) unsigned']
     @d.meta_def(:schema) do |t, *o|
       i = 0
       types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
@@ -361,6 +580,7 @@ create_table(:x) do
   DateTime :c63, :size=>6
   Integer :c64
   Bignum :c65
+  Integer :c66
 end
 END_MIG
   end