sequel 3.27.0 → 3.28.0

data/spec/integration/schema_test.rb

@@ -6,18 +6,21 @@ describe "Database schema parser" do
     @iom = INTEGRATION_DB.identifier_output_method
     @iim = INTEGRATION_DB.identifier_input_method
     @defsch = INTEGRATION_DB.default_schema
+    @qi = INTEGRATION_DB.quote_identifiers?
     clear_sqls
   end
   after do
     INTEGRATION_DB.identifier_output_method = @iom
     INTEGRATION_DB.identifier_input_method = @iim
     INTEGRATION_DB.default_schema = @defsch
+    INTEGRATION_DB.quote_identifiers = @qi
     INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
   end
 
   specify "should handle a database with a identifier_output_method" do
     INTEGRATION_DB.identifier_output_method = :reverse
     INTEGRATION_DB.identifier_input_method = :reverse
+    INTEGRATION_DB.quote_identifiers = true
     INTEGRATION_DB.default_schema = nil if INTEGRATION_DB.default_schema
     INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items, :reload=>true).should be_a_kind_of(Array)
@@ -85,7 +88,7 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == 'blah'
   end
 
-  specify "should parse types from the schema properly" do
+  cspecify "should parse types from the schema properly", [:jdbc, :db2] do
     INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
     INTEGRATION_DB.create_table!(:items){Fixnum :number}
@@ -233,7 +236,7 @@ describe "Database schema modifiers" do
   specify "should add columns to tables correctly" do
     @db.create_table!(:items){Integer :number}
     @ds.insert(:number=>10)
-    @db.alter_table(:items){add_column :name, :text}
+    @db.alter_table(:items){add_column :name, String}
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name]
     @ds.columns!.should == [:number, :name]
     @ds.all.should == [{:number=>10, :name=>nil}]
@@ -296,7 +299,7 @@ describe "Database schema modifiers" do
     proc{@ds.insert(:n=>nil)}.should raise_error(Sequel::DatabaseError)
   end
 
-  specify "should set column NULL/NOT NULL correctly" do
+  cspecify "should set column NULL/NOT NULL correctly", [:jdbc, :db2] do
     @db.create_table!(:items, :engine=>:InnoDB){Integer :id}
     @ds.insert(:id=>10)
     @db.alter_table(:items){set_column_allow_null :id, false}
@@ -318,7 +321,7 @@ describe "Database schema modifiers" do
     @ds.all.should == [{:id=>10}, {:id=>20}]
   end
 
-  specify "should set column types correctly" do
+  cspecify "should set column types correctly", [:jdbc, :db2] do
     @db.create_table!(:items){Integer :id}
     @ds.insert(:id=>10)
     @db.alter_table(:items){set_column_type :id, String}
@@ -328,7 +331,7 @@ describe "Database schema modifiers" do
     @ds.all.should == [{:id=>"10"}, {:id=>"20"}]
   end
 
-  cspecify "should add unique constraints and foreign key table constraints correctly", :sqlite do
+  cspecify "should add unnamed unique constraints and foreign key table constraints correctly", :sqlite do
     @db.create_table!(:items, :engine=>:InnoDB){Integer :id; Integer :item_id}
     @db.alter_table(:items) do
       add_unique_constraint [:item_id, :id]
@@ -341,6 +344,19 @@ describe "Database schema modifiers" do
     proc{@ds.insert(1, 2)}.should raise_error
   end
 
+  cspecify "should add named unique constraints and foreign key table constraints correctly", :sqlite do
+    @db.create_table!(:items, :engine=>:InnoDB){Integer :id, :null=>false; Integer :item_id, :null=>false}
+    @db.alter_table(:items) do
+      add_unique_constraint [:item_id, :id], :name=>:unique_iii
+      add_foreign_key [:id, :item_id], :items, :key=>[:item_id, :id], :name=>:fk_iii
+    end
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @ds.columns!.should == [:id, :item_id]
+    proc{@ds.insert(1, 1)}.should_not raise_error
+    proc{@ds.insert(1, 1)}.should raise_error
+    proc{@ds.insert(1, 2)}.should raise_error
+  end
+
   cspecify "should drop unique constraints and foreign key table constraints correctly", :sqlite do
     @db.create_table!(:items) do
       Integer :id
@@ -358,7 +374,7 @@ describe "Database schema modifiers" do
     proc{@ds.insert(1, 2)}.should_not raise_error
   end
 
-  cspecify "should remove columns from tables correctly", :h2, :mssql do
+  cspecify "should remove columns from tables correctly", :h2, :mssql, [:jdbc, :db2] do
     @db.create_table!(:items) do
       primary_key :id
       String :name
@@ -379,7 +395,7 @@ describe "Database schema modifiers" do
     @ds.columns!.should == [:id]
   end
 
-  specify "should remove multiple columns in a single alter_table block" do
+  cspecify "should remove multiple columns in a single alter_table block", [:jdbc, :db2] do
     @db.create_table!(:items) do
       primary_key :id
       String :name
@@ -417,10 +433,10 @@ describe "Database#tables" do
     clear_sqls
   end
   after do
-    @db.drop_view :sequel_test_view
-    @db.drop_table :sequel_test_table
     @db.identifier_output_method = @iom
     @db.identifier_input_method = @iim
+    @db.drop_view :sequel_test_view
+    @db.drop_table :sequel_test_table
   end
 
   specify "should return an array of symbols" do
@@ -459,10 +475,10 @@ describe "Database#views" do
     clear_sqls
   end
   after do
-    @db.drop_view :sequel_test_view
-    @db.drop_table :sequel_test_table
     @db.identifier_output_method = @iom
     @db.identifier_input_method = @iim
+    @db.drop_view :sequel_test_view
+    @db.drop_table :sequel_test_table
   end
 
   specify "should return an array of symbols" do

data/spec/integration/spec_helper.rb

@@ -49,6 +49,7 @@ end
   end
 
   def self.cspecify(message, *checked, &block)
+    return specify(message, &block) if ENV['SEQUEL_NO_PENDING']
     pending = false
     checked.each do |c|
       case c
@@ -89,3 +90,12 @@ if defined?(INTEGRATION_DB) || defined?(INTEGRATION_URL) || ENV['SEQUEL_INTEGRAT
 else
   INTEGRATION_DB = Sequel.sqlite('', :quote_identifiers=>false)
 end
+
+if INTEGRATION_DB.adapter_scheme == :ibmdb
+  def INTEGRATION_DB.drop_table(*tables)
+    super
+  rescue Sequel::DatabaseError
+    disconnect
+    super
+  end
+end

data/spec/integration/type_test.rb

@@ -6,7 +6,7 @@ describe "Supported types" do
     INTEGRATION_DB[:items]
   end
 
-  cspecify "should support casting correctly", [:sqlite, :sqlite] do
+  specify "should support casting correctly" do
     ds = create_items_table_with_column(:number, Integer)
     ds.insert(:number => 1)
     ds.select(:number.cast_string.as(:n)).map(:n).should == %w'1'
@@ -100,7 +100,7 @@ describe "Supported types" do
     ds.first[:name].should be_a_kind_of(::Sequel::SQL::Blob)
   end
   
-  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:odbc, :mssql] do
+  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], [:odbc, :mssql] do
     ds = create_items_table_with_column(:number, TrueClass)
     ds.insert(:number => true)
     ds.all.should == [{:number=>true}]

data/spec/model/association_reflection_spec.rb

@@ -184,6 +184,7 @@ describe Sequel::Model::Associations::AssociationReflection, "#remove_before_des
     @c.many_to_many :cs, :class=>@c
     @c.association_reflection(:cs).remove_before_destroy?.should be_true
   end
+
   it "should be false for one_to_one and one_to_many associations" do
     @c.one_to_one :c, :class=>@c
     @c.association_reflection(:c).remove_before_destroy?.should be_false
@@ -192,3 +193,93 @@ describe Sequel::Model::Associations::AssociationReflection, "#remove_before_des
   end
 end
 
+describe Sequel::Model::Associations::AssociationReflection, "#eager_limit_strategy" do
+  before do
+    @c = Class.new(Sequel::Model(:a))
+  end
+  after do
+    Sequel::Model.default_eager_limit_strategy = nil
+  end
+
+  it "should be nil by default for *_one associations" do
+    @c.many_to_one :c, :class=>@c
+    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+    @c.one_to_one :c, :class=>@c
+    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+  end
+
+  it "should be :ruby by default for *_many associations" do
+    @c.one_to_many :cs, :class=>@c, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+    @c.many_to_many :cs, :class=>@c, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+  end
+
+  it "should be nil for many_to_one associations" do
+    @c.many_to_one :c, :class=>@c, :eager_limit_strategy=>true
+    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+    @c.many_to_one :c, :class=>@c, :eager_limit_strategy=>:distinct_on
+    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+  end
+
+  it "should be a symbol for other associations if given a symbol" do
+    @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>:distinct_on
+    @c.association_reflection(:c).eager_limit_strategy.should == :distinct_on
+    @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>:window_function, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+  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}
+    @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}
+    @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
+    @c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+    @c.many_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+  end
+
+  it "should use :ruby for *_many associations if picking and the association dataset doesn't window functions" do
+    @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+    @c.many_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
+    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+  end
+
+  it "should respect Model.default_eager_limit_strategy to *_many associations" do
+    Sequel::Model.default_eager_limit_strategy = :window_function
+    Sequel::Model.default_eager_limit_strategy.should == :window_function
+    c = Class.new(Sequel::Model)
+    c.dataset = :a
+    c.default_eager_limit_strategy.should == :window_function
+    c.one_to_many :cs, :class=>c, :limit=>1
+    c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+    c.many_to_many :cs, :class=>c, :limit=>1
+    c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+
+    Sequel::Model.default_eager_limit_strategy = true
+    c = Class.new(Sequel::Model)
+    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}
+    c.many_to_many :cs, :class=>c, :limit=>1
+    c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+
+    c.default_eager_limit_strategy = :correlated_subquery
+    c.many_to_many :cs, :class=>c, :limit=>1
+    c.association_reflection(:cs).eager_limit_strategy.should == :correlated_subquery
+  end
+
+  it "should ignore Model.default_eager_limit_strategy for one_to_one associations" do
+    @c.default_eager_limit_strategy = :correlated_subquery
+    @c.one_to_one :c, :class=>@c
+    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+  end
+end

data/spec/model/associations_spec.rb

@@ -560,6 +560,19 @@ describe Sequel::Model, "many_to_one" do
     parent.pk.should == 20
   end
 
+  it "should support after_load association callback that changes the cached object" do
+    h = []
+    @c2.many_to_one :parent, :class => @c2, :after_load=>:al
+    @c2.class_eval do
+      def al(v)
+        associations[:parent] = :foo
+      end
+    end
+    p = @c2.load(:id=>10, :parent_id=>20)
+    p.parent.should == :foo
+    p.associations[:parent].should == :foo
+  end
+
   it "should raise error and not call internal add or remove method if before callback returns false, even if raise_on_save_failure is false" do
     # The reason for this is that assignment in ruby always returns the argument instead of the result
     # of the method, so we can't return nil to signal that the association callback prevented the modification

data/spec/model/base_spec.rb

@@ -302,7 +302,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
   before do
     @c = Class.new(Sequel::Model(:blahblah)) do
       columns :x, :y, :z
-      def _refresh(ds)
+      def _save_refresh
         self
       end
     end
@@ -544,47 +544,34 @@ describe "Model datasets #with_pk" do
 
   it "should return the first record where the primary key matches" do
     @ds.with_pk(1).should == @c.load(:id=>1)
-    @sqls.should == ["SELECT * FROM a WHERE (id = 1) LIMIT 1"]
+    @sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
   it "should handle existing filters" do
     @ds.filter(:a=>2).with_pk(1)
-    @sqls.should == ["SELECT * FROM a WHERE ((a = 2) AND (id = 1)) LIMIT 1"]
+    @sqls.should == ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
   end
 
   it "should work with string values" do
     @ds.with_pk("foo")
-    @sqls.should == ["SELECT * FROM a WHERE (id = 'foo') LIMIT 1"]
+    @sqls.should == ["SELECT * FROM a WHERE (a.id = 'foo') LIMIT 1"]
   end
 
   it "should handle an array for composite primary keys" do
     @c.set_primary_key :id1, :id2
     @ds.with_pk([1, 2])
-    @sqls.should == ["SELECT * FROM a WHERE ((id1 = 1) AND (id2 = 2)) LIMIT 1"]
-  end
-
-  it "should raise an error if a single primary key is given when a composite primary key should be used" do
-    @c.set_primary_key :id1, :id2
-    proc{@ds.with_pk(1)}.should raise_error(Sequel::Error)
-  end
-
-  it "should raise an error if a composite primary key is given when a single primary key should be used" do
-    proc{@ds.with_pk([1, 2])}.should raise_error(Sequel::Error)
-  end
-
-  it "should raise an error if the wrong number of composite keys is given" do
-    @c.set_primary_key :id1, :id2
-    proc{@ds.with_pk([1, 2, 3])}.should raise_error(Sequel::Error)
+    ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
+    "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].should include(@sqls.first)
+    @sqls.length.should == 1
   end
 
   it "should have #[] consider an integer as a primary key lookup" do
     @ds[1].should == @c.load(:id=>1)
-    @sqls.should == ["SELECT * FROM a WHERE (id = 1) LIMIT 1"]
+    @sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
   it "should not have #[] consider a string as a primary key lookup" do
     @ds['foo'].should == @c.load(:id=>1)
     @sqls.should == ["SELECT * FROM a WHERE (foo) LIMIT 1"]
   end
-
 end

data/spec/model/eager_loading_spec.rb

@@ -136,18 +136,68 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.length.should == 2
   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}
+    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)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT DISTINCT ON (tracks.album_id) * FROM tracks WHERE (tracks.album_id IN (1)) ORDER BY tracks.album_id']
+    a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
+    MODEL_DB.sqls.length.should == 2
+  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}
+    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)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x = 1)']
+    a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
+    MODEL_DB.sqls.length.should == 2
+  end
+  
+  it "should eagerly load a single one_to_one association using the :correlated_subquery strategy" do
+    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>:correlated_subquery, :order=>:name
+    a = EagerAlbum.eager(:track).all
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) ORDER BY name LIMIT 1))) ORDER BY name']
+    a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
+    MODEL_DB.sqls.length.should == 2
+  end
+  
+  it "should handle qualified order clauses when eagerly loading a single one_to_one association using the :correlated_subquery strategy" do
+    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>:correlated_subquery, :order=>[:tracks__name, :tracks__name.desc, :name.qualify(:tracks), :name.qualify(:t), 1]
+    a = EagerAlbum.eager(:track).all
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) ORDER BY t1.name, t1.name DESC, t1.name, t.name, 1 LIMIT 1))) ORDER BY tracks.name, tracks.name DESC, tracks.name, t.name, 1']
+    a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
+    MODEL_DB.sqls.length.should == 2
+  end
+  
+  it "should handle qualified composite keys when eagerly loading a single one_to_one association using the :correlated_subquery strategy" do
+    c1 = Class.new(EagerAlbum)
+    c2 = Class.new(EagerTrack)
+    c1.set_primary_key [:id, :band_id]
+    c2.set_primary_key [:id, :album_id]
+    c1.one_to_one :track, :class=>c2, :key=>[:album_id, :id], :eager_limit_strategy=>:correlated_subquery
+    c2.dataset.extend(Module.new do
+      def fetch_rows(sql)
+        MODEL_DB << sql
+        yield({:id => 2, :album_id=>1})
+      end
+    end)
+    a = c1.eager(:track).all
+    a.should == [c1.load(:id => 1, :band_id => 2)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (((tracks.album_id, tracks.id) IN ((1, 2))) AND ((tracks.id, tracks.album_id) IN (SELECT t1.id, t1.album_id FROM tracks AS t1 WHERE ((t1.album_id = tracks.album_id) AND (t1.id = tracks.id)) LIMIT 1)))']
+    a.first.track.should == c2.load(:id => 2, :album_id=>1)
+    MODEL_DB.sqls.length.should == 2
+  end
+  
   it "should eagerly load a single one_to_many association" do
     a = EagerAlbum.eager(:tracks).all
-    a.should be_a_kind_of(Array)
-    a.size.should == 1
-    a.first.should be_a_kind_of(EagerAlbum)
-    a.first.values.should == {:id => 1, :band_id => 2}
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
     MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
-    a = a.first
-    a.tracks.should be_a_kind_of(Array)
-    a.tracks.size.should == 1
-    a.tracks.first.should be_a_kind_of(EagerTrack)
-    a.tracks.first.values.should == {:id => 3, :album_id=>1}
+    a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
     MODEL_DB.sqls.length.should == 2
   end
   
@@ -564,6 +614,135 @@ describe Sequel::Model, "#eager" do
     as.first.special_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
   end
 
+  it "should respect the :limit option on a one_to_many association" do
+    EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>2
+    EagerTrack.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:album_id=>1, :id=>2})
+        yield({:album_id=>1, :id=>3})
+        yield({:album_id=>1, :id=>4})
+      end
+    })
+    as = EagerAlbum.eager(:first_two_tracks).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE (tracks.album_id IN (1))"]
+    as.length.should == 1
+    as.first.first_two_tracks.should == [EagerTrack.load(:album_id=>1, :id=>2), EagerTrack.load(:album_id=>1, :id=>3)]
+
+    MODEL_DB.reset
+    EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>[2,1]
+    as = EagerAlbum.eager(:first_two_tracks).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE (tracks.album_id IN (1))"]
+    as.length.should == 1
+    as.first.first_two_tracks.should == [EagerTrack.load(:album_id=>1, :id=>3), EagerTrack.load(:album_id=>1, :id=>4)]
+  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}
+    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)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x <= 2)']
+    a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
+    MODEL_DB.sqls.length.should == 2
+  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}
+    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)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 4))']
+    a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
+    MODEL_DB.sqls.length.should == 2
+  end
+  
+  it "should respect the :limit option on a one_to_many association using the :correlated_subquery strategy" do
+    EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>:correlated_subquery, :order=>:name, :limit=>2
+    a = EagerAlbum.eager(:tracks).all
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) ORDER BY name LIMIT 2))) ORDER BY name']
+    a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
+    MODEL_DB.sqls.length.should == 2
+  end
+  
+  it "should respect the :limit option with an offset on a one_to_many association using the :correlated_subquery strategy" do
+    EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>:correlated_subquery, :order=>:name, :limit=>[2, 1]
+    a = EagerAlbum.eager(:tracks).all
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) ORDER BY name LIMIT 2 OFFSET 1))) ORDER BY name']
+    a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
+    MODEL_DB.sqls.length.should == 2
+  end
+  
+  it "should respect the limit option on a many_to_many association" do
+    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, :limit=>2
+    EagerGenre.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:x_foreign_key_x=>2, :id=>5})
+        yield({:x_foreign_key_x=>2, :id=>6})
+        yield({:x_foreign_key_x=>2, :id=>7})
+      end
+    })
+    as = EagerAlbum.eager(:first_two_genres).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (2)))"]
+    as.length.should == 1
+    as.first.first_two_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
+    
+    MODEL_DB.reset
+    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, :limit=>[2, 1]
+    as = EagerAlbum.eager(:first_two_genres).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (2)))"]
+    as.length.should == 1
+    as.first.first_two_genres.should == [EagerGenre.load(:id=>6), EagerGenre.load(:id=>7)]
+  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}
+    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.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:x_foreign_key_x=>2, :id=>5})
+        yield({:x_foreign_key_x=>2, :id=>6})
+      end
+    })
+    as = EagerAlbum.eager(:first_two_genres).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id ORDER BY name) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (2)))) AS t1 WHERE (x_sequel_row_number_x <= 2)"]
+    as.length.should == 1
+    as.first.first_two_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
+
+    MODEL_DB.reset
+    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, 1], :order=>:name
+    as = EagerAlbum.eager(:first_two_genres).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id ORDER BY name) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (2)))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 4))"]
+    as.length.should == 1
+    as.first.first_two_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
+  end
+
+  it "should respect the limit option on a many_to_many association using the :correlated_subquery strategy" do
+    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=>:correlated_subquery, :limit=>2, :order=>:name
+    EagerGenre.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:x_foreign_key_x=>2, :id=>5})
+        yield({:x_foreign_key_x=>2, :id=>6})
+      end
+    })
+    as = EagerAlbum.eager(:first_two_genres).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (2))) WHERE (genres.id IN (SELECT t1.id FROM genres AS t1 INNER JOIN ag AS t2 ON ((t2.genre_id = t1.id) AND (t2.album_id = ag.album_id)) ORDER BY name LIMIT 2)) ORDER BY name"]
+    as.length.should == 1
+    as.first.first_two_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
+
+    MODEL_DB.reset
+    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=>:correlated_subquery, :limit=>[2, 1], :order=>:name
+    as = EagerAlbum.eager(:first_two_genres).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (2))) WHERE (genres.id IN (SELECT t1.id FROM genres AS t1 INNER JOIN ag AS t2 ON ((t2.genre_id = t1.id) AND (t2.album_id = ag.album_id)) ORDER BY name LIMIT 2 OFFSET 1)) ORDER BY name"]
+    as.length.should == 1
+    as.first.first_two_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
+  end
+
   it "should use the :eager_loader association option when eager loading" do
     EagerAlbum.many_to_one :special_band, :eager_loader=>(proc do |key_hash, records, assocs| 
       item = EagerBand.filter(:album_id=>records.collect{|r| [r.pk, r.pk*2]}.flatten).order(:name).first
@@ -1340,6 +1519,27 @@ describe Sequel::Model, "#eager_graph" do
     as.first.inner_genres.should == [GraphGenre.load(:id=>5), GraphGenre.load(:id=>6)]
   end
 
+  it "should respect composite primary keys for classes when eager loading" do 
+    c1 = Class.new(GraphAlbum)
+    c2 = Class.new(GraphBand)
+    c1.set_primary_key [:band_id, :id]
+    c2.set_primary_key [:vocalist_id, :id]
+    c1.many_to_many :sbands, :class=>c2, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :join_table=>:b
+    c2.one_to_many :salbums, :class=>c1, :key=>[:band_id, :id]
+    ds = c1.eager_graph(:sbands=>:salbums)
+    ds.sql.should == 'SELECT albums.id, albums.band_id, sbands.id AS sbands_id, sbands.vocalist_id, salbums.id AS salbums_id, salbums.band_id AS salbums_band_id FROM albums LEFT OUTER JOIN b ON ((b.l1 = albums.band_id) AND (b.l2 = albums.id)) LEFT OUTER JOIN bands AS sbands ON ((sbands.vocalist_id = b.r1) AND (sbands.id = b.r2)) LEFT OUTER JOIN albums AS salbums ON ((salbums.band_id = sbands.vocalist_id) AND (salbums.id = sbands.id))'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>3, :band_id=>2, :sbands_id=>5, :vocalist_id=>6, :salbums_id=>7, :salbums_band_id=>8})
+      yield({:id=>3, :band_id=>2, :sbands_id=>5, :vocalist_id=>6, :salbums_id=>9, :salbums_band_id=>10})
+      yield({:id=>3, :band_id=>2, :sbands_id=>6, :vocalist_id=>22, :salbums_id=>nil, :salbums_band_id=>nil})
+      yield({:id=>7, :band_id=>8, :sbands_id=>nil, :vocalist_id=>nil, :salbums_id=>nil, :salbums_band_id=>nil})
+    end
+    as = ds.all
+    as.should == [c1.load(:id=>3, :band_id=>2), c1.load(:id=>7, :band_id=>8)]
+    as.map{|x| x.sbands}.should == [[c2.load(:id=>5, :vocalist_id=>6), c2.load(:id=>6, :vocalist_id=>22)], []]
+    as.map{|x| x.sbands.map{|y| y.salbums}}.should == [[[c1.load(:id=>7, :band_id=>8), c1.load(:id=>9, :band_id=>10)], []], []]
+  end
+
   it "should respect the association's :graph_select option" do 
     GraphAlbum.many_to_one :inner_band, :class=>'GraphBand', :key=>:band_id, :graph_select=>:vocalist_id
     GraphAlbum.eager_graph(:inner_band).sql.should == 'SELECT albums.id, albums.band_id, inner_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS inner_band ON (inner_band.id = albums.band_id)'
@@ -1538,6 +1738,40 @@ describe Sequel::Model, "#eager_graph" do
     ds.sql.should == 'SELECT a.id, a_genres.id AS a_genres_id FROM (SELECT * FROM s.a INNER JOIN s.t USING (b_id)) AS a LEFT OUTER JOIN s.ag AS ag ON (ag.album_id = a.id) LEFT OUTER JOIN s.g AS a_genres ON (a_genres.id = ag.genre_id)'
   end
 
+  it "should respect :after_load callbacks on associations when eager graphing" do
+    GraphAlbum.many_to_one :al_band, :class=>GraphBand, :key=>:band_id, :after_load=>proc{|o, a| a.id *=2}
+    GraphAlbum.one_to_many :al_tracks, :class=>GraphTrack, :key=>:album_id, :after_load=>proc{|o, os| os.each{|a| a.id *=2}}
+    GraphAlbum.many_to_many :al_genres, :class=>GraphGenre, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :after_load=>proc{|o, os| os.each{|a| a.id *=2}}
+    ds = GraphAlbum.eager_graph(:al_band, :al_tracks, :al_genres)
+    ds.sql.should == "SELECT albums.id, albums.band_id, al_band.id AS al_band_id, al_band.vocalist_id, al_tracks.id AS al_tracks_id, al_tracks.album_id, al_genres.id AS al_genres_id FROM albums LEFT OUTER JOIN bands AS al_band ON (al_band.id = albums.band_id) LEFT OUTER JOIN tracks AS al_tracks ON (al_tracks.album_id = albums.id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS al_genres ON (al_genres.id = ag.genre_id)"
+    def ds.fetch_rows(sql)
+      yield({:id=>1, :band_id=>2, :al_band_id=>3, :vocalist_id=>4, :al_tracks_id=>5, :album_id=>6, :al_genres_id=>7})
+    end
+    a = ds.all.first
+    a.should == GraphAlbum.load(:id => 1, :band_id => 2)
+    a.al_band.should == GraphBand.load(:id=>6, :vocalist_id=>4)
+    a.al_tracks.should == [GraphTrack.load(:id=>10, :album_id=>6)]
+    a.al_genres.should == [GraphGenre.load(:id=>14)]
+  end
+
+  it "should respect limits on associations when eager graphing" do
+    GraphAlbum.many_to_one :al_band, :class=>GraphBand, :key=>:band_id
+    GraphAlbum.one_to_many :al_tracks, :class=>GraphTrack, :key=>:album_id, :limit=>2
+    GraphAlbum.many_to_many :al_genres, :class=>GraphGenre, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>2
+    ds = GraphAlbum.eager_graph(:al_band, :al_tracks, :al_genres)
+    ds.sql.should == "SELECT albums.id, albums.band_id, al_band.id AS al_band_id, al_band.vocalist_id, al_tracks.id AS al_tracks_id, al_tracks.album_id, al_genres.id AS al_genres_id FROM albums LEFT OUTER JOIN bands AS al_band ON (al_band.id = albums.band_id) LEFT OUTER JOIN tracks AS al_tracks ON (al_tracks.album_id = albums.id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS al_genres ON (al_genres.id = ag.genre_id)"
+    def ds.fetch_rows(sql)
+      yield({:id=>1, :band_id=>2, :al_band_id=>3, :vocalist_id=>4, :al_tracks_id=>5, :album_id=>6, :al_genres_id=>7})
+      yield({:id=>1, :band_id=>2, :al_band_id=>8, :vocalist_id=>9, :al_tracks_id=>10, :album_id=>11, :al_genres_id=>12})
+      yield({:id=>1, :band_id=>2, :al_band_id=>13, :vocalist_id=>14, :al_tracks_id=>15, :album_id=>16, :al_genres_id=>17})
+    end
+    a = ds.all.first
+    a.should == GraphAlbum.load(:id => 1, :band_id => 2)
+    a.al_band.should == GraphBand.load(:id=>3, :vocalist_id=>4)
+    a.al_tracks.should == [GraphTrack.load(:id=>5, :album_id=>6), GraphTrack.load(:id=>10, :album_id=>11)]
+    a.al_genres.should == [GraphGenre.load(:id=>7), GraphGenre.load(:id=>12)]
+  end
+
   it "should eagerly load a many_to_one association with a custom callback" do
     ds = GraphAlbum.eager_graph(:band => proc {|ds| ds.select_columns(:id)})
     ds.sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0 FROM albums LEFT OUTER JOIN (SELECT id FROM bands) AS band ON (band.id = albums.band_id)'