sequel 3.42.0 → 3.43.0

data/spec/extensions/date_arithmetic_spec.rb

@@ -0,0 +1,150 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+asd = begin
+  require 'active_support/duration'
+  true
+rescue LoadError => e
+  skip_warn "date_arithmetic extension (partial): can't load active_support/duration (#{e.class}: #{e})"
+  false
+end
+
+Sequel.extension :date_arithmetic
+
+describe "date_arithmetic extension" do
+  dbf = lambda do |db_type|
+    db = Sequel.connect("mock://#{db_type}")
+    db.extension :date_arithmetic
+    db
+  end
+
+  before do
+    @h0 = {:days=>0}
+    @h1 = {:days=>1, :years=>nil, :hours=>0}
+    @h2 = {:years=>1, :months=>1, :days=>1, :hours=>1, :minutes=>1, :seconds=>1}
+  end
+
+  it "should have Sequel.date_add with an interval hash return an appropriate Sequel::SQL::DateAdd expression" do
+    da = Sequel.date_add(:a, :days=>1)
+    da.should be_a_kind_of(Sequel::SQL::DateAdd)
+    da.expr.should == :a
+    da.interval.should == {:days=>1}
+    Sequel.date_add(:a, :years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1).interval.should == {:years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1}
+  end
+
+  it "should have Sequel.date_sub with an interval hash return an appropriate Sequel::SQL::DateAdd expression" do
+    da = Sequel.date_sub(:a, :days=>1)
+    da.should be_a_kind_of(Sequel::SQL::DateAdd)
+    da.expr.should == :a
+    da.interval.should == {:days=>-1}
+    Sequel.date_sub(:a, :years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1).interval.should == {:years=>-1, :months=>-2, :days=>-3, :hours=>-1, :minutes=>-1, :seconds=>-1}
+  end
+
+  it "should have Sequel.date_* with an interval hash handle nil values" do
+    Sequel.date_sub(:a, :days=>1, :hours=>nil).interval.should == {:days=>-1}
+  end
+
+  it "should raise an error if given string values in an interval hash" do
+    lambda{Sequel.date_add(:a, :days=>'1')}.should raise_error(Sequel::InvalidValue)
+  end
+
+  if asd
+    it "should have Sequel.date_add with an ActiveSupport::Duration return an appropriate Sequel::SQL::DateAdd expression" do
+      da = Sequel.date_add(:a, ActiveSupport::Duration.new(1, [[:days, 1]]))
+      da.should be_a_kind_of(Sequel::SQL::DateAdd)
+      da.expr.should == :a
+      da.interval.should == {:days=>1}
+      Sequel.date_add(:a, ActiveSupport::Duration.new(1, [[:years, 1], [:months, 1], [:days, 1], [:minutes, 61], [:seconds, 1]])).interval.should == {:years=>1, :months=>1, :days=>1, :minutes=>61, :seconds=>1}
+    end
+
+    it "should have Sequel.date_sub with an ActiveSupport::Duration return an appropriate Sequel::SQL::DateAdd expression" do
+      da = Sequel.date_sub(:a, ActiveSupport::Duration.new(1, [[:days, 1]]))
+      da.should be_a_kind_of(Sequel::SQL::DateAdd)
+      da.expr.should == :a
+      da.interval.should == {:days=>-1}
+      Sequel.date_sub(:a, ActiveSupport::Duration.new(1, [[:years, 1], [:months, 1], [:days, 1], [:minutes, 61], [:seconds, 1]])).interval.should == {:years=>-1, :months=>-1, :days=>-1, :minutes=>-61, :seconds=>-1}
+    end
+  end
+
+  it "should correctly literalize on Postgres" do
+    db = dbf.call(:postgres)
+    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).should == "(CAST(a AS timestamp) + CAST('1 days ' AS interval))"
+    db.literal(Sequel.date_add(:a, @h2)).should == "(CAST(a AS timestamp) + CAST('1 years 1 months 1 days 1 hours 1 minutes 1 seconds ' AS interval))"
+  end
+
+  it "should correctly literalize on SQLite" do
+    db = dbf.call(:sqlite)
+    db.literal(Sequel.date_add(:a, @h0)).should == "datetime(a)"
+    db.literal(Sequel.date_add(:a, @h1)).should == "datetime(a, '1 days')"
+    db.literal(Sequel.date_add(:a, @h2)).should == "datetime(a, '1 years', '1 months', '1 days', '1 hours', '1 minutes', '1 seconds')"
+  end
+
+  it "should correctly literalize on MySQL" do
+    db = dbf.call(:mysql)
+    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS DATETIME)"
+    db.literal(Sequel.date_add(:a, @h1)).should == "DATE_ADD(a, INTERVAL 1 DAY)"
+    db.literal(Sequel.date_add(:a, @h2)).should == "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(a, INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
+  end
+
+  it "should correctly literalize on HSQLDB" do
+    db = Sequel.mock
+    def db.database_type; :hsqldb end
+    db.extension :date_arithmetic
+    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(CAST(a AS timestamp) AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).should == "DATE_ADD(CAST(a AS timestamp), INTERVAL 1 DAY)"
+    db.literal(Sequel.date_add(:a, @h2)).should == "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(CAST(a AS timestamp), INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
+  end
+
+  it "should correctly literalize on MSSQL" do
+    db = dbf.call(:mssql)
+    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS datetime)"
+    db.literal(Sequel.date_add(:a, @h1)).should == "DATEADD(day, 1, a)"
+    db.literal(Sequel.date_add(:a, @h2)).should == "DATEADD(second, 1, DATEADD(minute, 1, DATEADD(hour, 1, DATEADD(day, 1, DATEADD(month, 1, DATEADD(year, 1, a))))))"
+  end
+
+  it "should correctly literalize on H2" do
+    db = Sequel.mock
+    def db.database_type; :h2 end
+    db.extension :date_arithmetic
+    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).should == "DATEADD('day', 1, a)"
+    db.literal(Sequel.date_add(:a, @h2)).should == "DATEADD('second', 1, DATEADD('minute', 1, DATEADD('hour', 1, DATEADD('day', 1, DATEADD('month', 1, DATEADD('year', 1, a))))))"
+  end
+
+  it "should correctly literalize on access" do
+    db = dbf.call(:access)
+    db.literal(Sequel.date_add(:a, @h0)).should == "CDate(a)"
+    db.literal(Sequel.date_add(:a, @h1)).should == "DATEADD('d', 1, a)"
+    db.literal(Sequel.date_add(:a, @h2)).should == "DATEADD('s', 1, DATEADD('n', 1, DATEADD('h', 1, DATEADD('d', 1, DATEADD('m', 1, DATEADD('yyyy', 1, a))))))"
+  end
+
+  it "should correctly literalize on Derby" do
+    db = Sequel.mock
+    def db.database_type; :derby end
+    db.extension :date_arithmetic
+    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).should == "{fn timestampadd(SQL_TSI_DAY, 1, timestamp(a))}"
+    db.literal(Sequel.date_add(:a, @h2)).should == "{fn timestampadd(SQL_TSI_SECOND, 1, timestamp({fn timestampadd(SQL_TSI_MINUTE, 1, timestamp({fn timestampadd(SQL_TSI_HOUR, 1, timestamp({fn timestampadd(SQL_TSI_DAY, 1, timestamp({fn timestampadd(SQL_TSI_MONTH, 1, timestamp({fn timestampadd(SQL_TSI_YEAR, 1, timestamp(a))}))}))}))}))}))}"
+    db.literal(Sequel.date_add(Date.civil(2012, 11, 12), @h1)).should == "{fn timestampadd(SQL_TSI_DAY, 1, timestamp((CAST('2012-11-12' AS varchar(255)) || ' 00:00:00')))}"
+  end
+
+  it "should correctly literalize on Oracle" do
+    db = dbf.call(:oracle)
+    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).should == "(a + INTERVAL '1' DAY)"
+    db.literal(Sequel.date_add(:a, @h2)).should == "(a + INTERVAL '1' YEAR + INTERVAL '1' MONTH + INTERVAL '1' DAY + INTERVAL '1' HOUR + INTERVAL '1' MINUTE + INTERVAL '1' SECOND)"
+  end
+
+  it "should correctly literalize on DB2" do
+    db = dbf.call(:db2)
+    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).should == "(CAST(a AS timestamp) + 1 days)"
+    db.literal(Sequel.date_add(:a, @h2)).should == "(CAST(a AS timestamp) + 1 years + 1 months + 1 days + 1 hours + 1 minutes + 1 seconds)"
+  end
+
+  it "should raise error if literalizing on an unsupported database" do
+    db = Sequel.mock
+    db.extension :date_arithmetic
+    lambda{db.literal(Sequel.date_add(:a, @h0))}.should raise_error(Sequel::NotImplemented)
+  end
+end

data/spec/extensions/force_encoding_spec.rb

@@ -126,5 +126,5 @@ describe "force_encoding plugin" do
   end
 end 
 else
-  skip_warn "force_encoding plugin: only works on ruby 1.9"
+  skip_warn "force_encoding plugin: only works on ruby 1.9+"
 end

data/spec/extensions/meta_def_spec.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Metaprogramming" do
+  specify "should add meta_def method to Database, Dataset, and Model classes and instances" do
+    Sequel::Database.meta_def(:foo){1}
+    Sequel::Database.foo.should == 1
+    Sequel::Dataset.meta_def(:foo){2}
+    Sequel::Dataset.foo.should == 2
+    Sequel::Model.meta_def(:foo){3}
+    Sequel::Model.foo.should == 3
+    o = Sequel::Database.new
+    o.meta_def(:foo){4}
+    o.foo.should == 4
+    o = o[:a]
+    o.meta_def(:foo){5}
+    o.foo.should == 5
+    o = Sequel::Model.new
+    o.meta_def(:foo){6}
+    o.foo.should == 6
+  end
+end

data/spec/extensions/spec_helper.rb

@@ -22,6 +22,11 @@ rescue LoadError
   nil
 end
 
+Sequel.extension :meta_def
+
+# Load core_refinements extension first, so pg_* extensions add their own refinements
+Sequel.extension :core_refinements if RUBY_VERSION >= '2.0.0'
+
 # Load most extensions by default, so that any conflicts are easily detectable.
 Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones to_dot columns_introspection server_block arbitrary_servers pg_auto_parameterize pg_statement_cache pg_array pg_array_ops pg_hstore pg_hstore_ops pg_range pg_range_ops pg_json pg_inet pg_row pg_row_ops schema_caching null_dataset select_remove query_literals eval_inspect')
 

data/spec/extensions/string_stripper_spec.rb

@@ -3,9 +3,10 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "Sequel::Plugins::StringStripper" do
   before do
     @db = Sequel::Database.new
-    @c = Class.new(Sequel::Model(@db))
+    @c = Class.new(Sequel::Model(@db[:test]))
+    @c.columns :name, :b
+    @c.db_schema[:b][:type] = :blob
     @c.plugin :string_stripper
-    @c.columns :name
     @o = @c.new
   end
 
@@ -20,4 +21,45 @@ describe "Sequel::Plugins::StringStripper" do
     @o.name = Date.today
     @o.name.should == Date.today
   end
+
+  it "should not strip strings for blob arguments" do
+    v = Sequel.blob(' name ')
+    @o.name = v
+    @o.name.should equal(v)
+  end
+
+  it "should not strip strings for blob columns" do
+    @o.b = ' name '
+    @o.b.should be_a_kind_of(Sequel::SQL::Blob)
+    @o.b.should == Sequel.blob(' name ')
+  end
+
+  it "should allow skipping of columns using Model.skip_string_stripping" do
+    @c.skip_string_stripping :name
+    v = ' name '
+    @o.name = v
+    @o.name.should equal(v)
+  end
+
+  it "should work correctly in subclasses" do
+    o = Class.new(@c).new
+    o.name = ' name '
+    o.name.should == 'name'
+    o.b = ' name '
+    o.b.should be_a_kind_of(Sequel::SQL::Blob)
+    o.b.should == Sequel.blob(' name ')
+  end
+
+  it "should work correctly for dataset changes" do
+    c = Class.new(Sequel::Model(@db[:test]))
+    c.plugin :string_stripper
+    def @db.schema(*) [[:name, {}], [:b, {:type=>:blob}]] end
+    c.set_dataset(@db[:test2])
+    o = c.new
+    o.name = ' name '
+    o.name.should == 'name'
+    o.b = ' name '
+    o.b.should be_a_kind_of(Sequel::SQL::Blob)
+    o.b.should == Sequel.blob(' name ')
+  end
 end

data/spec/integration/associations_test.rb

@@ -608,7 +608,7 @@ describe "Sequel::Model Simple Associations" do
       @els = {:eager_limit_strategy=>:correlated_subquery}
     end
     it_should_behave_like "eager limit strategies"
-  end unless Sequel.guarded?(:mysql, :db2, :oracle, :h2, :cubrid)
+  end unless Sequel.guarded?(:mysql, :db2, :oracle, :h2, :cubrid, :hsqldb)
 
   specify "should handle many_to_one associations with same name as :key" do
     Album.def_column_alias(:artist_id_id, :artist_id)
@@ -821,7 +821,7 @@ describe "Sequel::Model Composite Key Associations" do
       @els = {:eager_limit_strategy=>:correlated_subquery}
     end
     it_should_behave_like "eager limit strategies"
-  end if INTEGRATION_DB.dataset.supports_multiple_column_in? && !Sequel.guarded?(:mysql, :db2, :oracle)
+  end if INTEGRATION_DB.dataset.supports_multiple_column_in? && !Sequel.guarded?(:mysql, :db2, :oracle, :hsqldb)
 
   specify "should have add method accept hashes and create new records" do
     @artist.remove_all_albums

data/spec/integration/plugin_test.rb

@@ -2017,3 +2017,93 @@ describe "Sequel::Plugins::ConstraintValidations" do
     it_should_behave_like "constraint validations"
   end
 end
+
+describe "date_arithmetic extension" do
+  asd = begin
+    require 'active_support/duration'
+    require 'active_support/inflector'
+    require 'active_support/core_ext/string/inflections'
+    true
+  rescue LoadError
+    false
+  end
+
+  before(:all) do
+    @db = INTEGRATION_DB
+    @db.extension(:date_arithmetic)
+    if @db.database_type == :sqlite
+      @db.use_timestamp_timezones = false
+    end
+    @date = Date.civil(2010, 7, 12)
+    @dt = Time.local(2010, 7, 12)
+    if asd
+      @d0 = ActiveSupport::Duration.new(0, [[:days, 0]])
+      @d1 = ActiveSupport::Duration.new(1, [[:days, 1]])
+      @d2 = ActiveSupport::Duration.new(1, [[:years, 1], [:months, 1], [:days, 1], [:minutes, 61], [:seconds, 1]])
+    end
+    @h0 = {:days=>0}
+    @h1 = {:days=>1, :years=>nil, :hours=>0}
+    @h2 = {:years=>1, :months=>1, :days=>1, :hours=>1, :minutes=>1, :seconds=>1}
+    @a1 = Time.local(2010, 7, 13)
+    @a2 = Time.local(2011, 8, 13, 1, 1, 1)
+    @s1 = Time.local(2010, 7, 11)
+    @s2 = Time.local(2009, 6, 10, 22, 58, 59)
+    @check = lambda do |meth, in_date, in_interval, should|
+      output = @db.get(Sequel.send(meth, in_date, in_interval))
+      output = Time.parse(output.to_s) unless output.is_a?(Time) || output.is_a?(DateTime)
+      output.year.should == should.year
+      output.month.should == should.month
+      output.day.should == should.day
+      output.hour.should == should.hour
+      output.min.should == should.min
+      output.sec.should == should.sec
+    end
+  end
+  after(:all) do
+    if @db.database_type == :sqlite
+      @db.use_timestamp_timezones = true
+    end
+  end
+
+  if asd
+    specify "be able to use Sequel.date_add to add ActiveSupport::Duration objects to dates and datetimes" do
+      @check.call(:date_add, @date, @d0, @dt)
+      @check.call(:date_add, @date, @d1, @a1)
+      @check.call(:date_add, @date, @d2, @a2)
+
+      @check.call(:date_add, @dt, @d0, @dt)
+      @check.call(:date_add, @dt, @d1, @a1)
+      @check.call(:date_add, @dt, @d2, @a2)
+    end
+
+    specify "be able to use Sequel.date_sub to subtract ActiveSupport::Duration objects from dates and datetimes" do
+      @check.call(:date_sub, @date, @d0, @dt)
+      @check.call(:date_sub, @date, @d1, @s1)
+      @check.call(:date_sub, @date, @d2, @s2)
+
+      @check.call(:date_sub, @dt, @d0, @dt)
+      @check.call(:date_sub, @dt, @d1, @s1)
+      @check.call(:date_sub, @dt, @d2, @s2)
+    end
+  end
+
+  specify "be able to use Sequel.date_add to add interval hashes to dates and datetimes" do
+    @check.call(:date_add, @date, @h0, @dt)
+    @check.call(:date_add, @date, @h1, @a1)
+    @check.call(:date_add, @date, @h2, @a2)
+
+    @check.call(:date_add, @dt, @h0, @dt)
+    @check.call(:date_add, @dt, @h1, @a1)
+    @check.call(:date_add, @dt, @h2, @a2)
+  end
+
+  specify "be able to use Sequel.date_sub to subtract interval hashes from dates and datetimes" do
+    @check.call(:date_sub, @date, @h0, @dt)
+    @check.call(:date_sub, @date, @h1, @s1)
+    @check.call(:date_sub, @date, @h2, @s2)
+
+    @check.call(:date_sub, @dt, @h0, @dt)
+    @check.call(:date_sub, @dt, @h1, @s1)
+    @check.call(:date_sub, @dt, @h2, @s2)
+  end
+end

data/spec/integration/schema_test.rb

@@ -382,7 +382,7 @@ describe "Database schema modifiers" do
     proc{@ds.insert(10)}.should_not raise_error
   end
 
-  specify "should add foreign key columns to tables correctly" do
+  cspecify "should add foreign key columns to tables correctly", :hsqldb do
     @db.create_table!(:items){primary_key :id}
     @ds.insert
     i = @ds.get(:id)

data/spec/model/association_reflection_spec.rb

@@ -190,7 +190,7 @@ end
 describe Sequel::Model::Associations::AssociationReflection do
   before do
     @c = Class.new(Sequel::Model(:foo))
-    @c.meta_def(:name){"C"}
+    def @c.name() "C" end
   end
 
   it "#eager_loading_predicate_key should be an alias of predicate_key for backwards compatibility" do
@@ -276,13 +276,13 @@ describe Sequel::Model::Associations::AssociationReflection, "#eager_limit_strat
   end
 
   it "should use :distinct_on for one_to_one associations if picking and the association dataset supports ordered distinct on" do
-    @c.dataset.meta_def(:supports_ordered_distinct_on?){true}
+    def (@c.dataset).supports_ordered_distinct_on?() true end
     @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>true
     @c.association_reflection(:c).eager_limit_strategy.should == :distinct_on
   end
 
   it "should use :window_function for associations if picking and the association dataset supports window functions" do
-    @c.dataset.meta_def(:supports_window_functions?){true}
+    def (@c.dataset).supports_window_functions?() true end
     @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>true
     @c.association_reflection(:c).eager_limit_strategy.should == :window_function
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
@@ -314,7 +314,7 @@ describe Sequel::Model::Associations::AssociationReflection, "#eager_limit_strat
     c.dataset = :a
     c.one_to_many :cs, :class=>c, :limit=>1
     c.association_reflection(:cs).eager_limit_strategy.should == :ruby
-    c.dataset.meta_def(:supports_window_functions?){true}
+    def (c.dataset).supports_window_functions?() true end
     c.many_to_many :cs, :class=>c, :limit=>1
     c.association_reflection(:cs).eager_limit_strategy.should == :window_function
 

data/spec/model/associations_spec.rb

@@ -602,7 +602,7 @@ describe Sequel::Model, "many_to_one" do
     c = @c2.load(:id=>123)
     p.raise_on_save_failure = false
     @c2.many_to_one :parent, :class => @c2, :before_set=>:bs
-    p.meta_def(:bs){|x| false}
+    def p.bs(x) false end
     p.should_not_receive(:_parent=)
     proc{p.parent = c}.should raise_error(Sequel::Error)
     
@@ -1038,7 +1038,7 @@ describe Sequel::Model, "one_to_one" do
     c = @c2.load(:id=>123)
     p.raise_on_save_failure = false
     @c2.one_to_one :parent, :class => @c2, :before_set=>:bs
-    p.meta_def(:bs){|x| false}
+    def p.bs(x) false end
     p.should_not_receive(:_parent=)
     proc{p.parent = c}.should raise_error(Sequel::Error)
     

data/spec/model/base_spec.rb

@@ -588,9 +588,9 @@ end
 describe Sequel::Model, ".require_modification" do
   before do
     @ds1 = MODEL_DB[:items]
-    @ds1.meta_def(:provides_accurate_rows_matched?){false}
+    def @ds1.provides_accurate_rows_matched?() false end
     @ds2 = MODEL_DB[:items]
-    @ds2.meta_def(:provides_accurate_rows_matched?){true}
+    def @ds2.provides_accurate_rows_matched?() true end
   end
   after do
     Sequel::Model.require_modification = nil

data/spec/model/eager_loading_spec.rb

@@ -150,7 +150,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should eagerly load a single one_to_one association using the :distinct_on strategy" do
-    EagerTrack.dataset.meta_def(:supports_distinct_on?){true}
+    def (EagerTrack.dataset).supports_distinct_on?() true end
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>true
     a = EagerAlbum.eager(:track).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -160,7 +160,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should eagerly load a single one_to_one association using the :window_function strategy" do
-    EagerTrack.dataset.meta_def(:supports_window_functions?){true}
+    def (EagerTrack.dataset).supports_window_functions?() true end
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>true, :order=>:name
     a = EagerAlbum.eager(:track).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -562,7 +562,7 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should respect the :limit option on a one_to_many association using the :window_function strategy" do
-    EagerTrack.dataset.meta_def(:supports_window_functions?){true}
+    def (EagerTrack.dataset).supports_window_functions?() true end
     EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>true, :order=>:name, :limit=>2
     a = EagerAlbum.eager(:tracks).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -572,7 +572,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should respect the :limit option with an offset on a one_to_many association using the :window_function strategy" do
-    EagerTrack.dataset.meta_def(:supports_window_functions?){true}
+    def (EagerTrack.dataset).supports_window_functions?() true end
     EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>true, :order=>:name, :limit=>[2, 1]
     a = EagerAlbum.eager(:tracks).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -616,7 +616,7 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should respect the limit option on a many_to_many association using the :window_function strategy" do
-    EagerGenre.dataset.meta_def(:supports_window_functions?){true}
+    def (EagerGenre.dataset).supports_window_functions?() true end
     EagerAlbum.many_to_many :first_two_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :eager_limit_strategy=>true, :limit=>2, :order=>:name
     EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]
     as = EagerAlbum.eager(:first_two_genres).all