sequel 4.46.0 → 4.49.0

data/spec/extensions/schema_dumper_spec.rb

@@ -75,8 +75,8 @@ end
 describe "Sequel::Database dump methods" do
   before do
     @d = Sequel::Database.new.extension(:schema_dumper)
-    @d.meta_def(:tables){|o| o[:schema] ? [o[:schema]] : [:t1, :t2]}
-    @d.meta_def(:schema) do |t, *o|
+    def @d.tables(o) o[:schema] ? [o[:schema]] : [:t1, :t2] end
+    def @d.schema(t, *o)
       v = case t
       when :t1, 't__t1', Sequel.identifier(:t__t1)
         [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true, :allow_null=>false}],
@@ -116,12 +116,12 @@ 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, :auto_increment=>true}]]}
+    def @d.schema(*s) [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]] end
     @d.dump_table_schema(:t6).must_equal "create_table(:t6) do\n  primary_key :c1, :type=>:Bignum\nend"
   end
 
   it "should dump non-Integer primary key columns with explicit :type when using :same_db=>true" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]]}
+    def @d.schema(*s) [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]] end
     @d.dump_table_schema(:t6, :same_db=>true).must_equal "create_table(:t6) do\n  primary_key :c1, :type=>:Bignum\nend"
   end
 
@@ -130,16 +130,16 @@ describe "Sequel::Database dump methods" do
   end
 
   it "should handle foreign keys" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :allow_null=>true}]]}
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}]}
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :allow_null=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}] end
     @d.dump_table_schema(:t6).must_equal "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, :auto_increment=>true}]]}
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}]}
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}] end
     s = @d.dump_table_schema(:t6)
     s.must_match(/create_table\(:t6\) do\n  primary_key :c1, /)
     s.must_match(/:table=>:t2/)
@@ -147,9 +147,9 @@ describe "Sequel::Database dump methods" do
   end
 
   it "should handle foreign key options" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :allow_null=>true}]]}
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}]}
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :allow_null=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}] end
     s = @d.dump_table_schema(:t6)
     s.must_match(/create_table\(:t6\) do\n  foreign_key :c1, :t2, /)
     s.must_match(/:key=>\[:c2\]/)
@@ -159,9 +159,9 @@ describe "Sequel::Database dump methods" do
   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, :auto_increment=>true}]]}
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}]}
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}] end
     s = @d.dump_table_schema(:t6)
     s.must_match(/create_table\(:t6\) do\n  primary_key :c1, /)
     s.must_match(/:table=>:t2/)
@@ -172,9 +172,9 @@ describe "Sequel::Database dump methods" do
   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(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}]}
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :allow_null=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}] end
     s = @d.dump_table_schema(:t6)
     s.must_match(/create_table\(:t6\) do\n  foreign_key :c1, :t2, /)
     s.must_match(/:key=>\[:c2\]/)
@@ -184,9 +184,9 @@ describe "Sequel::Database dump methods" do
   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, :auto_increment=>true}]]}
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}]}
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}] end
     s = @d.dump_table_schema(:t6)
     s.must_match(/create_table\(:t6\) do\n  primary_key :c1, /)
     s.must_match(/:table=>:t2/)
@@ -197,7 +197,7 @@ describe "Sequel::Database dump methods" do
   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}]]}
+    def @d.schema(*s) [[:c1, {:db_type=>'somedbspecifictype', :primary_key=>true, :allow_null=>false}]] end
     @d.dump_table_schema(:t7, :same_db => true).must_equal "create_table(:t7) do\n  column :c1, \"somedbspecifictype\", :null=>false\n  \n  primary_key [:c1]\nend"
   end
 
@@ -206,15 +206,15 @@ describe "Sequel::Database dump methods" do
   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(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1, :c2], :table=>:t2, :key=>[:c3, :c4]}]}
+    def @d.schema(*s) [[:c1, {:db_type=>'integer'}], [:c2, {:db_type=>'integer'}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1, :c2], :table=>:t2, :key=>[:c3, :c4]}] end
     @d.dump_table_schema(:t1).must_equal "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(:supports_index_parsing?){true}
-    @d.meta_def(:indexes) do |t|
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
@@ -255,7 +255,7 @@ END_MIG
   end
 
   it "should sort table names when dumping a migration" do
-    @d.meta_def(:tables){|o| [:t2, :t1]}
+    def @d.tables(o) [:t2, :t1] end
     @d.dump_schema_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
@@ -276,12 +276,12 @@ 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, *o|
+    def @d.tables(o) [:t1, :t2] end
+    def @d.schema(t, *o)
       t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true}]]
     end
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list) do |t|
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t)
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
     end
     @d.dump_schema_migration.must_equal <<-END_MIG
@@ -300,12 +300,12 @@ 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, *o|
+    def @d.tables(o) [:t1, :t2] end
+    def @d.schema(t, *o)
       t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer'}]]
     end
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list) do |t|
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t)
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : [{:columns=>[:c1], :table=>:t1, :key=>[:c2]}]
     end
     @d.dump_schema_migration.must_equal <<-END_MIG
@@ -328,12 +328,12 @@ 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, *o|
+    def @d.tables(o) [:t1, :t2] end
+    def @d.schema(t, *o)
       t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true}]]
     end
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list) do |t|
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t)
       raise Sequel::DatabaseError unless [:t1, :t2].include?(t)
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
     end
@@ -374,8 +374,8 @@ END_MIG
   end
 
   it "should honor the :index_names => false option to not include names of indexes" do
-    @d.meta_def(:supports_index_parsing?){true}
-    @d.meta_def(:indexes) do |t|
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
@@ -406,8 +406,8 @@ END_MIG
   end
   
   it "should make :index_names => :namespace option a noop if there is a  global index namespace" do
-    @d.meta_def(:supports_index_parsing?){true}
-    @d.meta_def(:indexes) do |t|
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
     end
@@ -438,9 +438,9 @@ 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(:supports_index_parsing?){true}
-    @d.meta_def(:indexes) do |t|
+    def @d.global_index_namespace?; false end
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
     end
@@ -471,8 +471,8 @@ END_MIG
   end
 
   it "should honor the :indexes => false option to not include indexes" do
-    @d.meta_def(:supports_index_parsing?){true}
-    @d.meta_def(:indexes) do |t|
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
@@ -497,24 +497,24 @@ 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|
+    def @d.foreign_key_list(t)
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
     end
     @d.dump_schema_migration(:indexes=>false).wont_match(/foreign_key/)
   end
 
   it "should have :foreign_keys option override :indexes => false disabling of foreign keys" do
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list) do |t|
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t)
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
     end
     @d.dump_schema_migration(:indexes=>false, :foreign_keys=>true).must_match(/foreign_key/)
   end
 
   it "should support dumping just indexes as a migration" do
-    @d.meta_def(:tables){|o| [:t1]}
-    @d.meta_def(:supports_index_parsing?){true}
-    @d.meta_def(:indexes) do |t|
+    def @d.tables(o) [:t1] end
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
@@ -529,9 +529,9 @@ 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(:supports_index_parsing?){true}
-    @d.meta_def(:indexes) do |t|
+    def @d.tables(o) [:t1] end
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
@@ -546,9 +546,9 @@ 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(:supports_index_parsing?){true}
-    @d.meta_def(:indexes) do |t|
+    def @d.tables(o) [:t1, :t2] end
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
     end
@@ -566,10 +566,10 @@ 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(:supports_index_parsing?){true}
-    @d.meta_def(:indexes) do |t|
+    def @d.global_index_namespace?; false end
+    def @d.tables(o) [:t1, :t2] end
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
     end
@@ -587,7 +587,7 @@ END_MIG
   end
 
   it "should handle missing index parsing support when dumping index migration" do
-    @d.meta_def(:tables){|o| [:t1]}
+    def @d.tables(o) [:t1] end
     @d.dump_indexes_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
@@ -598,7 +598,7 @@ END_MIG
   end
 
   it "should handle missing foreign key parsing support when dumping foreign key migration" do
-    @d.meta_def(:tables){|o| [:t1]}
+    def @d.tables(o) [:t1] end
     @d.dump_foreign_key_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
@@ -609,12 +609,12 @@ 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, *o|
+    def @d.tables(o) [:t1, :t2, :t3] end
+    def @d.schema(t, *o)
       t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer'}]]
     end
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list) do |t, *a|
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t, *a)
       case t
       when :t1
         [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}]
@@ -640,12 +640,12 @@ 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}]]}
+    def @d.schema(*s) [[:c1, {:db_type=>'date', :default=>"'now()'", :allow_null=>true}], [:c2, {:db_type=>'datetime', :allow_null=>false}]] end
     @d.dump_table_schema(:t3).must_equal "create_table(:t3) do\n  Date :c1\n  DateTime :c2, :null=>false\nend"
   end
   
   it "should handle converting common defaults" do
-    @d.meta_def(:schema) do |t, *os|
+    def @d.schema(t, *os)
       s = [[:c1, {:db_type=>'boolean', :default=>"false", :type=>:boolean, :allow_null=>true}],
        [:c2, {:db_type=>'varchar', :default=>"'blah'", :type=>:string, :allow_null=>true}],
        [:c3, {:db_type=>'integer', :default=>"-1", :type=>:integer, :allow_null=>true}],
@@ -667,10 +667,10 @@ END_MIG
   end
   
   it "should not use a literal string as a fallback if using MySQL with the :same_db option" do
-    @d.meta_def(:database_type){:mysql}
-    @d.meta_def(:supports_index_parsing?){false}
-    @d.meta_def(:supports_foreign_key_parsing?){false}
-    @d.meta_def(:schema) do |t, *os|
+    def @d.database_type; :mysql end
+    def @d.supports_index_parsing?; false end
+    def @d.supports_foreign_key_parsing?; false end
+    def @d.schema(t, *os)
       s = [[:c10, {:db_type=>'foo', :default=>"'6 weeks'", :type=>nil, :allow_null=>true}]]
       s.each{|_, c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
       s
@@ -683,7 +683,8 @@ END_MIG
   end
 
   it "should convert many database types to ruby types" do
-    types = %w"mediumint smallint int integer mediumint(6) smallint(7) int(8) integer(9)
+    def @d.schema(t, *o)
+      types = %w"mediumint smallint int integer mediumint(6) smallint(7) int(8) integer(9)
       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
@@ -695,7 +696,6 @@ END_MIG
       ["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) bit bool"
-    @d.meta_def(:schema) do |t, *o|
       i = 0
       types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
     end
@@ -787,10 +787,9 @@ END_MIG
   end
 
   it "should convert mysql types to ruby types" do
-    types = ['double(15,2)', 'double(7,1) unsigned']
-    @d.meta_def(:schema) do |t, *o|
+    def @d.schema(t, *o)
       i = 0
-      types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
+      ['double(15,2)', 'double(7,1) unsigned'].map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
     end
     @d.dump_table_schema(:x).must_equal((<<END_MIG).chomp)
 create_table(:x) do
@@ -802,25 +801,40 @@ end
 END_MIG
   end
 
+  it "should convert oracle special types to ruby types" do
+    def @d.database_type; :oracle end
+    def @d.schema(t, *o)
+      i = 0
+      ['number not null', 'date not null', 'varchar2(4 byte) not null'].map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>false}]}
+    end
+    @d.dump_table_schema(:x).must_equal((<<END_MIG).chomp)
+create_table(:x) do
+  BigDecimal :c1, :null=>false
+  Date :c2, :null=>false
+  String :c3, :null=>false
+end
+END_MIG
+  end
+
   it "should force specify :null option for MySQL timestamp columns when using :same_db" do
-    @d.meta_def(:database_type){:mysql}
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>true}]]}
+    def @d.database_type; :mysql end
+    def @d.schema(*s) [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>true}]] end
     @d.dump_table_schema(:t3, :same_db=>true).must_equal "create_table(:t3) do\n  column :c1, \"timestamp\", :null=>true\n  \n  primary_key [:c1]\nend"
 
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>false}]]}
+    def @d.schema(*s) [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>false}]] end
     @d.dump_table_schema(:t3, :same_db=>true).must_equal "create_table(:t3) do\n  column :c1, \"timestamp\", :null=>false\n  \n  primary_key [:c1]\nend"
   end
 
   it "should use separate primary_key call with non autoincrementable types" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'varchar(8)', :primary_key=>true, :auto_increment=>false}]]}
+    def @d.schema(*s) [[:c1, {:db_type=>'varchar(8)', :primary_key=>true, :auto_increment=>false}]] end
     @d.dump_table_schema(:t3).must_equal "create_table(:t3) do\n  String :c1, :size=>8\n  \n  primary_key [:c1]\nend"
     @d.dump_table_schema(:t3, :same_db=>true).must_equal "create_table(:t3) do\n  column :c1, \"varchar(8)\"\n  \n  primary_key [:c1]\nend"
   end
 
   it "should use explicit type for non integer foreign_key types" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'date', :primary_key=>true, :auto_increment=>false}]]}
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list){|t, *a| [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4}
+    def @d.schema(*s) [[:c1, {:db_type=>'date', :primary_key=>true, :auto_increment=>false}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t, *a) [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4 end
     ["create_table(:t4) do\n  foreign_key :c1, :t3, :type=>Date, :key=>[:c1]\n  \n  primary_key [:c1]\nend",
      "create_table(:t4) do\n  foreign_key :c1, :t3, :key=>[:c1], :type=>Date\n  \n  primary_key [:c1]\nend"].must_include(@d.dump_table_schema(:t4))
     ["create_table(:t4) do\n  foreign_key :c1, :t3, :type=>\"date\", :key=>[:c1]\n  \n  primary_key [:c1]\nend",
@@ -828,16 +842,16 @@ END_MIG
   end
 
   it "should correctly handing autoincrementing primary keys that are also foreign keys" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true}]]}
-    @d.meta_def(:supports_foreign_key_parsing?){true}
-    @d.meta_def(:foreign_key_list){|t, *a| [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4}
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t, *a) [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4 end
     ["create_table(:t4) do\n  primary_key :c1, :table=>:t3, :key=>[:c1]\nend",
      "create_table(:t4) do\n  primary_key :c1, :key=>[:c1], :table=>:t3\nend"].must_include(@d.dump_table_schema(:t4))
   end
 
   it "should handle dumping on PostgreSQL using qualified tables" do
     @d = Sequel.connect('mock://postgres').extension(:schema_dumper)
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>true}]]}
+    def @d.schema(*s) [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>true}]] end
     @d.dump_table_schema(Sequel.qualify(:foo, :bar), :same_db=>true).must_equal "create_table(Sequel::SQL::QualifiedIdentifier.new(:foo, :bar)) do\n  column :c1, \"timestamp\"\n  \n  primary_key [:c1]\nend"
   end
 end

data/spec/extensions/sequel_3_dataset_methods_spec.rb

@@ -2,7 +2,9 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Dataset#to_csv" do
   before do
-    @ds = Sequel.mock(:fetch=>[{:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}, {:a=>7, :b=>8, :c=>9}])[:items].columns(:a, :b, :c).extension(:sequel_3_dataset_methods)
+    deprecated do
+      @ds = Sequel.mock(:fetch=>[{:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}, {:a=>7, :b=>8, :c=>9}])[:items].columns(:a, :b, :c).extension(:sequel_3_dataset_methods)
+    end
   end
   
   it "should format a CSV representation of the records" do
@@ -15,7 +17,7 @@ describe "Dataset#to_csv" do
 end
 
 describe "Dataset#[]=" do
-  it "should perform an update on the specified filter" do
+  deprecated "should perform an update on the specified filter" do
     db = Sequel.mock
     ds = db[:items].extension(:sequel_3_dataset_methods)
     ds[:a => 1] = {:x => 3}
@@ -26,7 +28,9 @@ end
 describe "Dataset#insert_multiple" do
   before do
     @db = Sequel.mock(:autoid=>2)
-    @ds = @db[:items].extension(:sequel_3_dataset_methods)
+    deprecated do
+      @ds = @db[:items].extension(:sequel_3_dataset_methods)
+    end
   end
   
   it "should insert all items in the supplied array" do
@@ -92,7 +96,7 @@ unless Sequel.mock.dataset.frozen?
 end
 
 describe "Dataset#set" do
-  it "should act as alias to #update" do
+  deprecated "should act as alias to #update" do
     db = Sequel.mock
     ds = db[:items].extension(:sequel_3_dataset_methods)
     ds.set({:x => 3})
@@ -101,13 +105,13 @@ describe "Dataset#set" do
 end
 
 describe "Sequel::Dataset#qualify_to_first_source" do
-  it "should qualify to the first source" do
+  deprecated "should qualify to the first source" do
     Sequel.mock.dataset.extension(:sequel_3_dataset_methods).from(:t).filter{a<b}.qualify_to_first_source.sql.must_equal 'SELECT t.* FROM t WHERE (t.a < t.b)'
   end
 end
 
 describe "Sequel::Dataset#qualify_to" do
-  it "should qualify to the given table" do
+  deprecated "should qualify to the given table" do
     Sequel.mock.dataset.extension(:sequel_3_dataset_methods).from(:t).filter{a<b}.qualify_to(:e).sql.must_equal 'SELECT e.* FROM t WHERE (e.a < e.b)'
   end
 end

data/spec/extensions/sequel_4_dataset_methods_spec.rb

@@ -0,0 +1,121 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Dataset#and" do
+  before do
+    @dataset = Sequel.mock.dataset.from(:test).extension(:sequel_4_dataset_methods)
+    @d1 = @dataset.where(:x => 1)
+  end
+  
+  it "should add a WHERE filter if none exists" do
+    @dataset.and(:a => 1).sql.must_equal 'SELECT * FROM test WHERE (a = 1)'
+  end
+  
+  it "should add an expression to the where clause" do
+    @d1.and(:y => 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y = 2))'
+  end
+  
+  it "should accept placeholder literal string filters" do
+    @d1.and(Sequel.lit('y > ?', 2)).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
+  end
+
+  it "should accept expression filters" do
+    @d1.and(Sequel.expr(:yy) > 3).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
+  end
+      
+  it "should accept string filters with placeholders" do
+    @d1.extension(:auto_literal_strings).and('y > ?', 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
+  end
+
+  it "should accept blocks passed to filter" do
+    @d1.and{yy > 3}.sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
+  end
+  
+  it "should correctly add parens to give predictable results" do
+    @d1.or(:y => 2).and(:z => 3).sql.must_equal 'SELECT * FROM test WHERE (((x = 1) OR (y = 2)) AND (z = 3))'
+    @d1.and(:y => 2).or(:z => 3).sql.must_equal 'SELECT * FROM test WHERE (((x = 1) AND (y = 2)) OR (z = 3))'
+  end
+end
+
+describe "Dataset#exclude_where" do
+  before do
+    @dataset = Sequel.mock.dataset.from(:test).extension(:sequel_4_dataset_methods)
+  end
+
+  it "should correctly negate the expression and add it to the where clause" do
+    @dataset.exclude_where(:region=>'Asia').sql.must_equal "SELECT * FROM test WHERE (region != 'Asia')"
+    @dataset.exclude_where(:region=>'Asia').exclude_where(:region=>'NA').sql.must_equal "SELECT * FROM test WHERE ((region != 'Asia') AND (region != 'NA'))"
+  end
+
+  it "should affect the where clause even if having clause is already used" do
+    @dataset.group_and_count(:name).having{count > 2}.exclude_where(:region=>'Asia').sql.
+      must_equal "SELECT name, count(*) AS count FROM test WHERE (region != 'Asia') GROUP BY name HAVING (count > 2)"
+  end
+end
+
+describe "Dataset#interval" do
+  before do
+    @db = Sequel.mock(:fetch=>{:v => 1234}).extension(:sequel_4_dataset_methods)
+    @ds = @db[:test].freeze
+  end
+  
+  it "should generate the correct SQL statement" do
+    5.times do
+      @ds.interval(:stamp)
+      @db.sqls.must_equal ["SELECT (max(stamp) - min(stamp)) AS interval FROM test LIMIT 1"]
+    end
+
+    @ds.filter(Sequel.expr(:price) > 100).interval(:stamp)
+    @db.sqls.must_equal ["SELECT (max(stamp) - min(stamp)) AS interval FROM test WHERE (price > 100) LIMIT 1"]
+  end
+  
+  it "should use a subselect for the same conditions as count" do
+    ds = @ds.order(:stamp).limit(5)
+    5.times do
+      ds.interval(:stamp).must_equal 1234
+      @db.sqls.must_equal ['SELECT (max(stamp) - min(stamp)) AS interval FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1']
+    end
+  end
+
+  it "should accept virtual row blocks" do
+    5.times do
+      @ds.interval{a(b)}
+      @db.sqls.must_equal ["SELECT (max(a(b)) - min(a(b))) AS interval FROM test LIMIT 1"]
+    end
+  end
+end
+
+describe "Dataset#range" do
+  before do
+    @db = Sequel.mock(:fetch=>{:v1 => 1, :v2 => 10}).extension(:sequel_4_dataset_methods)
+    @ds = @db[:test].freeze
+  end
+  
+  it "should generate a correct SQL statement" do
+    5.times do
+      @ds.range(:stamp)
+      @db.sqls.must_equal ["SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test LIMIT 1"]
+    end
+
+    @ds.filter(Sequel.expr(:price) > 100).range(:stamp)
+    @db.sqls.must_equal ["SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test WHERE (price > 100) LIMIT 1"]
+  end
+  
+  it "should return a range object" do
+    5.times do
+      @ds.range(:tryme).must_equal(1..10)
+    end
+  end
+  
+  it "should use a subselect for the same conditions as count" do
+    @ds.order(:stamp).limit(5).range(:stamp).must_equal(1..10)
+    @db.sqls.must_equal ['SELECT min(stamp) AS v1, max(stamp) AS v2 FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1']
+  end
+  
+  it "should accept virtual row blocks" do
+    5.times do
+      @ds.range{a(b)}
+      @db.sqls.must_equal ["SELECT min(a(b)) AS v1, max(a(b)) AS v2 FROM test LIMIT 1"]
+    end
+  end
+end
+

data/spec/extensions/serialization_spec.rb

@@ -59,7 +59,7 @@ describe "Serialization plugin" do
     DB.sqls.map{|s| s.sub("...\n", '')}.must_equal ["INSERT INTO items (abc) VALUES ('--- 1\n')", "INSERT INTO items (abc) VALUES ('--- hello\n')"]
   end
 
-  it "serialized_columns should be the columns serialized" do
+  deprecated "serialized_columns should be the columns serialized" do
     @c.plugin :serialization, :yaml, :abc
     @c.serialized_columns.must_equal [:abc]
   end