sequel 4.47.0 → 4.48.0

data/spec/extensions/pg_inet_spec.rb

@@ -18,6 +18,32 @@ describe "pg_inet extension" do
     @db.literal(IPAddr.new('2001:4f8:3:ba:2e0:81ff:fe22:d1f1')).must_equal "'2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'"
   end unless ipv6_broken
 
+  deprecated "should set up conversion procs correctly" do
+    cp = Sequel::Postgres::PG__TYPES
+    cp[869].call("127.0.0.1").must_equal IPAddr.new('127.0.0.1')
+    cp[650].call("127.0.0.1").must_equal IPAddr.new('127.0.0.1')
+  end
+
+  deprecated "should set up conversion procs for arrays correctly" do
+    cp = Sequel::Postgres::PG__TYPES
+    cp[1041].call("{127.0.0.1}").must_equal [IPAddr.new('127.0.0.1')]
+    cp[651].call("{127.0.0.1}").must_equal [IPAddr.new('127.0.0.1')]
+    cp[1040].call("{127.0.0.1}").must_equal ['127.0.0.1']
+  end
+
+  it "should set up conversion procs correctly" do
+    cp = @db.conversion_procs
+    cp[869].call("127.0.0.1").must_equal IPAddr.new('127.0.0.1')
+    cp[650].call("127.0.0.1").must_equal IPAddr.new('127.0.0.1')
+  end
+
+  it "should set up conversion procs for arrays correctly" do
+    cp = @db.conversion_procs
+    cp[1041].call("{127.0.0.1}").must_equal [IPAddr.new('127.0.0.1')]
+    cp[651].call("{127.0.0.1}").must_equal [IPAddr.new('127.0.0.1')]
+    cp[1040].call("{127.0.0.1}").must_equal ['127.0.0.1']
+  end
+
   it "should not affect literalization of custom objects" do
     o = Object.new
     def o.sql_literal(ds) 'v' end

data/spec/extensions/pg_interval_spec.rb

@@ -34,6 +34,26 @@ describe "pg_interval extension" do
     end
   end
 
+  deprecated "should set up conversion procs correctly" do
+    cp = Sequel::Postgres::PG__TYPES
+    cp[1186].call("1 sec").must_equal ActiveSupport::Duration.new(1, [[:seconds, 1]])
+  end
+
+  deprecated "should set up conversion procs for arrays correctly" do
+    cp = Sequel::Postgres::PG__TYPES
+    cp[1187].call("{1 sec}").must_equal [ActiveSupport::Duration.new(1, [[:seconds, 1]])]
+  end
+
+  it "should set up conversion procs correctly" do
+    cp = @db.conversion_procs
+    cp[1186].call("1 sec").must_equal ActiveSupport::Duration.new(1, [[:seconds, 1]])
+  end
+
+  it "should set up conversion procs for arrays correctly" do
+    cp = @db.conversion_procs
+    cp[1187].call("{1 sec}").must_equal [ActiveSupport::Duration.new(1, [[:seconds, 1]])]
+  end
+
   it "should not affect literalization of custom objects" do
     o = Object.new
     def o.sql_literal(ds) 'v' end

data/spec/extensions/pg_json_spec.rb

@@ -17,6 +17,30 @@ describe "pg_json extension" do
     @db.extension(:pg_array, :pg_json)
   end
 
+  deprecated "should set up conversion procs correctly" do
+    cp = Sequel::Postgres::PG__TYPES
+    cp[114].call("{}").must_equal @hc.new({})
+    cp[3802].call("{}").must_equal @bhc.new({})
+  end
+
+  deprecated "should set up conversion procs for arrays correctly" do
+    cp = Sequel::Postgres::PG__TYPES
+    cp[199].call("{[]}").must_equal [@ac.new([])]
+    cp[3807].call("{[]}").must_equal [@bac.new([])]
+  end
+
+  it "should set up conversion procs correctly" do
+    cp = @db.conversion_procs
+    cp[114].call("{}").must_equal @hc.new({})
+    cp[3802].call("{}").must_equal @bhc.new({})
+  end
+
+  it "should set up conversion procs for arrays correctly" do
+    cp = @db.conversion_procs
+    cp[199].call("{[]}").must_equal [@ac.new([])]
+    cp[3807].call("{[]}").must_equal [@bac.new([])]
+  end
+
   it "should parse json strings correctly" do
     @m.parse_json('[]').class.must_equal(@ac)
     @m.parse_json('[]').to_a.must_equal []

data/spec/extensions/pg_range_spec.rb

@@ -4,10 +4,10 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "pg_range extension" do
   before(:all) do
     Sequel.extension :pg_array, :pg_range
-    @pg_types = Sequel::Postgres::PG_TYPES.dup
+    @pg_types = Sequel::Postgres::PG__TYPES.dup # SEQUEL5: Remove
   end
   after(:all) do
-    Sequel::Postgres::PG_TYPES.replace(@pg_types)
+    Sequel::Postgres::PG__TYPES.replace(@pg_types) # SEQUEL5: Remove
   end
 
   before do
@@ -21,6 +21,46 @@ describe "pg_range extension" do
     @db.extension(:pg_array, :pg_range)
   end
 
+  deprecated "should set up conversion procs correctly" do
+    cp = Sequel::Postgres::PG__TYPES
+    cp[3904].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int4range')
+    cp[3906].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'numrange')
+    cp[3908].call("[2011-01-02 10:20:30,2011-02-03 10:20:30)").must_equal @R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tsrange')
+    cp[3910].call("[2011-01-02 10:20:30,2011-02-03 10:20:30)").must_equal @R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tstzrange')
+    cp[3912].call("[2011-01-02,2011-02-03)").must_equal  @R.new(Date.new(2011, 1, 2),Date.new(2011, 2, 3), :exclude_begin=>false, :exclude_end=>true, :db_type=>'daterange')
+    cp[3926].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int8range')
+  end
+
+  deprecated "should set up conversion procs for arrays correctly" do
+    cp = Sequel::Postgres::PG__TYPES
+    cp[3905].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int4range')]
+    cp[3907].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'numrange')]
+    cp[3909].call("{\"[2011-01-02 10:20:30,2011-02-03 10:20:30)\"}").must_equal [@R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tsrange')]
+    cp[3911].call("{\"[2011-01-02 10:20:30,2011-02-03 10:20:30)\"}").must_equal [@R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tstzrange')]
+    cp[3913].call("{\"[2011-01-02,2011-02-03)\"}").must_equal [@R.new(Date.new(2011, 1, 2),Date.new(2011, 2, 3), :exclude_begin=>false, :exclude_end=>true, :db_type=>'daterange')]
+    cp[3927].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int8range')]
+  end
+
+  it "should set up conversion procs correctly" do
+    cp = @db.conversion_procs
+    cp[3904].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int4range')
+    cp[3906].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'numrange')
+    cp[3908].call("[2011-01-02 10:20:30,2011-02-03 10:20:30)").must_equal @R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tsrange')
+    cp[3910].call("[2011-01-02 10:20:30,2011-02-03 10:20:30)").must_equal @R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tstzrange')
+    cp[3912].call("[2011-01-02,2011-02-03)").must_equal  @R.new(Date.new(2011, 1, 2),Date.new(2011, 2, 3), :exclude_begin=>false, :exclude_end=>true, :db_type=>'daterange')
+    cp[3926].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int8range')
+  end
+
+  it "should set up conversion procs for arrays correctly" do
+    cp = @db.conversion_procs
+    cp[3905].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int4range')]
+    cp[3907].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'numrange')]
+    cp[3909].call("{\"[2011-01-02 10:20:30,2011-02-03 10:20:30)\"}").must_equal [@R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tsrange')]
+    cp[3911].call("{\"[2011-01-02 10:20:30,2011-02-03 10:20:30)\"}").must_equal [@R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tstzrange')]
+    cp[3913].call("{\"[2011-01-02,2011-02-03)\"}").must_equal [@R.new(Date.new(2011, 1, 2),Date.new(2011, 2, 3), :exclude_begin=>false, :exclude_end=>true, :db_type=>'daterange')]
+    cp[3927].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int8range')]
+  end
+
   it "should literalize Range instances to strings correctly" do
     @db.literal(Date.new(2011, 1, 2)...Date.new(2011, 3, 2)).must_equal "'[2011-01-02,2011-03-02)'"
     @db.literal(Time.local(2011, 1, 2, 10, 20, 30)...Time.local(2011, 2, 3, 10, 20, 30)).must_equal "'[2011-01-02 10:20:30,2011-02-03 10:20:30)'"
@@ -131,43 +171,87 @@ describe "pg_range extension" do
     end
   end
 
-  it "should support registering custom range types" do
+  deprecated "should support registering custom range types" do
     @R.register('foorange')
     @db.typecast_value(:foorange, 1..2).must_be_kind_of(@R)
     @db.fetch = [{:name=>'id', :db_type=>'foorange'}]
     @db.schema(:items).map{|e| e[1][:type]}.must_equal [:foorange]
   end
 
-  it "should support using a block as a custom conversion proc given as block" do
+  deprecated "should support using a block as a custom conversion proc given as block" do
     @R.register('foo2range'){|s| (s*2).to_i}
     @db.typecast_value(:foo2range, '[1,2]').must_be :==, (11..22)
   end
 
-  it "should support using a block as a custom conversion proc given as :converter option" do
+  deprecated "should support using a block as a custom conversion proc given as :converter option" do
     @R.register('foo3range', :converter=>proc{|s| (s*2).to_i})
     @db.typecast_value(:foo3range, '[1,2]').must_be :==, (11..22)
   end
 
-  it "should support using an existing scaler conversion proc via the :subtype_oid option" do
+  deprecated "should support using an existing scaler conversion proc via the :subtype_oid option" do
     @R.register('foo4range', :subtype_oid=>16)
     @db.typecast_value(:foo4range, '[t,f]').must_equal @R.new(true, false, :db_type=>'foo4range')
   end
 
-  it "should raise an error if using :subtype_oid option with unexisting scalar conversion proc" do
+  deprecated "should raise an error if using :subtype_oid option with unexisting scalar conversion proc" do
     proc{@R.register('fooirange', :subtype_oid=>0)}.must_raise(Sequel::Error)
   end
 
-  it "should raise an error if using :converter option and a block argument" do
+  deprecated "should raise an error if using :converter option and a block argument" do
     proc{@R.register('fooirange', :converter=>proc{}){}}.must_raise(Sequel::Error)
   end
 
-  it "should raise an error if using :subtype_oid option and a block argument" do
+  deprecated "should raise an error if using :subtype_oid option and a block argument" do
     proc{@R.register('fooirange', :subtype_oid=>16){}}.must_raise(Sequel::Error)
   end
 
-  it "should support registering custom types with :oid option" do
+  deprecated "should support registering custom types with :oid option" do
     @R.register('foo5range', :oid=>331)
-    Sequel::Postgres::PG_TYPES[331].call('[1,3)').must_be_kind_of(@R)
+    Sequel::Postgres::PG__TYPES[331].call('[1,3)').must_be_kind_of(@R)
+  end
+
+  deprecated "should not support registering custom range types on a per-Database basis for frozen databases" do
+    @db.freeze
+    proc{@db.register_range_type('banana', :oid=>7865){|s| s}}.must_raise RuntimeError, TypeError
+  end
+
+  it "should support registering custom range types" do
+    @db.register_range_type('foorange')
+    @db.typecast_value(:foorange, 1..2).must_be_kind_of(@R)
+    @db.fetch = [{:name=>'id', :db_type=>'foorange'}]
+    @db.schema(:items).map{|e| e[1][:type]}.must_equal [:foorange]
+  end
+
+  it "should support using a block as a custom conversion proc given as block" do
+    @db.register_range_type('foo2range'){|s| (s*2).to_i}
+    @db.typecast_value(:foo2range, '[1,2]').must_be :==, (11..22)
+  end
+
+  it "should support using a block as a custom conversion proc given as :converter option" do
+    @db.register_range_type('foo3range', :converter=>proc{|s| (s*2).to_i})
+    @db.typecast_value(:foo3range, '[1,2]').must_be :==, (11..22)
+  end
+
+  it "should support using an existing scaler conversion proc via the :subtype_oid option" do
+    @db.register_range_type('foo4range', :subtype_oid=>16)
+    @db.typecast_value(:foo4range, '[t,f]').must_equal @R.new(true, false, :db_type=>'foo4range')
+  end
+
+  it "should raise an error if using :subtype_oid option with unexisting scalar conversion proc" do
+    proc{@db.register_range_type('fooirange', :subtype_oid=>0)}.must_raise(Sequel::Error)
+  end
+
+  it "should raise an error if using :converter option and a block argument" do
+    proc{@db.register_range_type('fooirange', :converter=>proc{}){}}.must_raise(Sequel::Error)
+  end
+
+  it "should raise an error if using :subtype_oid option and a block argument" do
+    proc{@db.register_range_type('fooirange', :subtype_oid=>16){}}.must_raise(Sequel::Error)
+  end
+
+  it "should support registering custom types with :oid option" do
+    @db.register_range_type('foo5range', :oid=>331)
+    @db.conversion_procs[331].call('[1,3)').must_be_kind_of(@R)
   end
 
   it "should not support registering custom range types on a per-Database basis for frozen databases" do
@@ -222,7 +306,7 @@ describe "pg_range extension" do
 
   describe "parser" do
     before do
-      @p = Sequel::Postgres::PG_TYPES[3904]
+      @p = @R::Parser.new('int4range', proc(&:to_i))
       @sp = @R::Parser.new(nil)
     end
 
@@ -265,14 +349,14 @@ describe "pg_range extension" do
     end
   end
 
-  it "should set appropriate timestamp range conversion procs when resetting conversion procs" do
+  deprecated "should set appropriate timestamp range conversion procs when resetting conversion procs" do
     @db.reset_conversion_procs
     procs = @db.conversion_procs
     procs[3908].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').must_be :==, (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
     procs[3910].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').must_be :==, (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
   end
 
-  it "should set appropriate timestamp range array conversion procs when resetting conversion procs" do
+  deprecated "should set appropriate timestamp range array conversion procs when resetting conversion procs" do
     @db.reset_conversion_procs
     procs = @db.conversion_procs
     procs[3909].call('{"[2011-10-20 11:12:13,2011-10-20 11:12:14]"}').must_be :==, [Time.local(2011, 10, 20, 11, 12, 13)..Time.local(2011, 10, 20, 11, 12, 14)]

data/spec/extensions/pg_row_spec.rb

@@ -9,8 +9,18 @@ describe "pg_row extension" do
     @db.sqls
   end
 
+  deprecated "should parse record objects as arrays" do
+    a = Sequel::Postgres::PG__TYPES[2249].call("(a,b,c)")
+    a.class.must_equal(@m::ArrayRow)
+    a.to_a.must_be_kind_of(Array)
+    a[0].must_equal 'a'
+    a.must_equal %w'a b c'
+    a.db_type.must_be_nil
+    @db.literal(a).must_equal "ROW('a', 'b', 'c')"
+  end
+
   it "should parse record objects as arrays" do
-    a = Sequel::Postgres::PG_TYPES[2249].call("(a,b,c)")
+    a = @db.conversion_procs[2249].call("(a,b,c)")
     a.class.must_equal(@m::ArrayRow)
     a.to_a.must_be_kind_of(Array)
     a[0].must_equal 'a'
@@ -20,7 +30,7 @@ describe "pg_row extension" do
   end
 
   it "should parse arrays of record objects as arrays of arrays" do
-    as = Sequel::Postgres::PG_TYPES[2287].call('{"(a,b,c)","(d,e,f)"}')
+    as = @db.conversion_procs[2287].call('{"(a,b,c)","(d,e,f)"}')
     as.must_equal [%w'a b c', %w'd e f']
     as.each do |a|
       a.class.must_equal(@m::ArrayRow)
@@ -135,7 +145,7 @@ describe "pg_row extension" do
     p.column_converters.must_equal [Array]
   end
 
-  it "should reload registered row types when reseting conversion procs" do
+  deprecated "should reload registered row types when reseting conversion procs" do
     db = Sequel.mock(:host=>'postgres')
     db.extend_datasets{def quote_identifiers?; false end}
     db.extension(:pg_row)
@@ -292,7 +302,7 @@ describe "pg_row extension" do
     @db.typecast_value(:pg_row_foo, 'bar'=>'1', 'baz'=>'b').must_equal(:bar=>1, :baz=>'bb')
   end
 
-  it "should handle conversion procs that aren't added until later" do
+  deprecated "should handle conversion procs that aren't added until later" do
     @db.conversion_procs[5] = proc{|s| s * 2}
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
     c = proc{|h| [h]}

data/spec/extensions/prepared_statements_safe_spec.rb

@@ -53,7 +53,7 @@ describe "prepared_statements_safe plugin" do
     c = Class.new(Sequel::Model)
     c.plugin :prepared_statements_safe
     c1 = Class.new(c)
-    c1.meta_def(:get_db_schema){@db_schema = {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}}}
+    def c1.get_db_schema; @db_schema = {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}} end
     c1.set_dataset(:people)
     c1.prepared_statements_column_defaults.must_equal(:name=>'foo')
     Class.new(c1).prepared_statements_column_defaults.must_equal(:name=>'foo')

data/spec/extensions/query_literals_spec.rb

@@ -2,7 +2,9 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "query_literals extension" do
   before do
-    @ds = Sequel.mock.dataset.from(:t).extension(:query_literals)
+    deprecated do
+      @ds = Sequel.mock.dataset.from(:t).extension(:query_literals)
+    end
   end
 
   it "should not use special support if given a block" do

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
@@ -803,11 +802,10 @@ END_MIG
   end
 
   it "should convert oracle special types to ruby types" do
-    @d.meta_def(:database_type){:oracle}
-    types = ['number not null', 'date not null', 'varchar2(4 byte) not null']
-    @d.meta_def(:schema) do |t, *o|
+    def @d.database_type; :oracle end
+    def @d.schema(t, *o)
       i = 0
-      types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>false}]}
+      ['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
@@ -819,24 +817,24 @@ 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",
@@ -844,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