sequel 3.21.0 → 3.41.0

data/spec/model/association_reflection_spec.rb

@@ -2,15 +2,19 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model::Associations::AssociationReflection, "#associated_class" do
   before do
-    @c = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
     class ::ParParent < Sequel::Model; end
   end
+  after do
+    Object.send(:remove_const, :ParParent)
+  end
 
   it "should use the :class value if present" do
     @c.many_to_one :c, :class=>ParParent
     @c.association_reflection(:c).keys.should include(:class)
     @c.association_reflection(:c).associated_class.should == ParParent
   end
+
   it "should figure out the class if the :class value is not present" do
     @c.many_to_one :c, :class=>'ParParent'
     @c.association_reflection(:c).keys.should_not include(:class)
@@ -20,15 +24,19 @@ end
 
 describe Sequel::Model::Associations::AssociationReflection, "#primary_key" do
   before do
-    @c = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
     class ::ParParent < Sequel::Model; end
   end
+  after do
+    Object.send(:remove_const, :ParParent)
+  end
 
   it "should use the :primary_key value if present" do
     @c.many_to_one :c, :class=>ParParent, :primary_key=>:blah__blah
     @c.association_reflection(:c).keys.should include(:primary_key)
     @c.association_reflection(:c).primary_key.should == :blah__blah
   end
+
   it "should use the associated table's primary key if :primary_key is not present" do
     @c.many_to_one :c, :class=>'ParParent'
     @c.association_reflection(:c).keys.should_not include(:primary_key)
@@ -49,8 +57,8 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
   end
 
   it "should use the :reciprocal value if present" do
-    @c = Class.new(Sequel::Model)
-    @d = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
+    @d = Class.new(Sequel::Model(:foo))
     @c.many_to_one :c, :class=>@d, :reciprocal=>:xx
     @c.association_reflection(:c).keys.should include(:reciprocal)
     @c.association_reflection(:c).reciprocal.should == :xx
@@ -111,9 +119,12 @@ end
 
 describe Sequel::Model::Associations::AssociationReflection, "#select" do
   before do
-    @c = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
     class ::ParParent < Sequel::Model; end
   end
+  after do
+    Object.send(:remove_const, :ParParent)
+  end
 
   it "should use the :select value if present" do
     @c.many_to_one :c, :class=>ParParent, :select=>[:par_parents__id]
@@ -123,7 +134,7 @@ describe Sequel::Model::Associations::AssociationReflection, "#select" do
   it "should be the associated_table.* if :select is not present for a many_to_many associaiton" do
     @c.many_to_many :cs, :class=>'ParParent'
     @c.association_reflection(:cs).keys.should_not include(:select)
-    @c.association_reflection(:cs).select.should == :par_parents.*
+    @c.association_reflection(:cs).select.should == Sequel::SQL::ColumnAll.new(:par_parents)
   end
   it "should be if :select is not present for a many_to_one and one_to_many associaiton" do
     @c.one_to_many :cs, :class=>'ParParent'
@@ -143,9 +154,12 @@ end
 
 describe Sequel::Model::Associations::AssociationReflection, "#associated_object_keys" do
   before do
-    @c = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
     class ::ParParent < Sequel::Model; end
   end
+  after do
+    Object.send(:remove_const, :ParParent)
+  end
 
   it "should use the primary keys for a many_to_one association" do
     @c.many_to_one :c, :class=>ParParent
@@ -173,9 +187,41 @@ describe Sequel::Model::Associations::AssociationReflection, "#associated_object
   end
 end
 
+describe Sequel::Model::Associations::AssociationReflection do
+  before do
+    @c = Class.new(Sequel::Model(:foo))
+    @c.meta_def(:name){"C"}
+  end
+
+  it "#eager_loading_predicate_key should be an alias of predicate_key for backwards compatibility" do
+    @c.one_to_many :cs, :class=>@c
+    @c.dataset.literal(@c.association_reflection(:cs).eager_loading_predicate_key).should == 'foo.c_id'
+  end
+
+  it "one_to_many #qualified_primary_key should be a qualified version of the primary key" do
+    @c.one_to_many :cs, :class=>@c
+    @c.dataset.literal(@c.association_reflection(:cs).qualified_primary_key).should == 'foo.id'
+  end
+
+  it "many_to_many #associated_key_column should be the left key" do
+    @c.many_to_many :cs, :class=>@c
+    @c.association_reflection(:cs).associated_key_column.should == :c_id
+  end
+
+  it "many_to_many #qualified_right_key should be a qualified version of the primary key" do
+    @c.many_to_many :cs, :class=>@c, :right_key=>:c2_id
+    @c.dataset.literal(@c.association_reflection(:cs).qualified_right_key).should == 'cs_cs.c2_id'
+  end
+
+  it "many_to_many #qualified_right_primary_key should be a qualified version of the primary key" do
+    @c.many_to_many :cs, :class=>@c
+    @c.dataset.literal(@c.association_reflection(:cs).qualified_right_primary_key).should == 'foo.id'
+  end
+end
+
 describe Sequel::Model::Associations::AssociationReflection, "#remove_before_destroy?" do
   before do
-    @c = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:foo))
   end
 
   it "should be true for many_to_one and many_to_many associations" do
@@ -184,6 +230,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 +239,155 @@ 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
+
+describe Sequel::Model, " association reflection methods" do
+  before do
+    @c1 = Class.new(Sequel::Model(:nodes)) do
+      def self.name; 'Node'; end
+      def self.to_s; 'Node'; end
+    end
+    MODEL_DB.reset
+  end
+  
+  it "#all_association_reflections should include all association reflection hashes" do
+    @c1.all_association_reflections.should == []
+
+    @c1.associate :many_to_one, :parent, :class => @c1
+    @c1.all_association_reflections.collect{|v| v[:name]}.should == [:parent]
+    @c1.all_association_reflections.collect{|v| v[:type]}.should == [:many_to_one]
+    @c1.all_association_reflections.collect{|v| v[:class]}.should == [@c1]
+
+    @c1.associate :one_to_many, :children, :class => @c1
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:name]}.should == [:children, :parent]
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:type]}.should == [:one_to_many, :many_to_one]
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:class]}.should == [@c1, @c1]
+  end
+
+  it "#association_reflection should return nil for nonexistent association" do
+    @c1.association_reflection(:blah).should == nil
+  end
+
+  it "#association_reflection should return association reflection hash if association exists" do
+    @c1.associate :many_to_one, :parent, :class => @c1
+    @c1.association_reflection(:parent).should be_a_kind_of(Sequel::Model::Associations::AssociationReflection)
+    @c1.association_reflection(:parent)[:name].should == :parent
+    @c1.association_reflection(:parent)[:type].should == :many_to_one
+    @c1.association_reflection(:parent)[:class].should == @c1
+
+    @c1.associate :one_to_many, :children, :class => @c1
+    @c1.association_reflection(:children).should be_a_kind_of(Sequel::Model::Associations::AssociationReflection)
+    @c1.association_reflection(:children)[:name].should == :children
+    @c1.association_reflection(:children)[:type].should == :one_to_many
+    @c1.association_reflection(:children)[:class].should == @c1
+  end
+
+  it "#associations should include all association names" do
+    @c1.associations.should == []
+    @c1.associate :many_to_one, :parent, :class => @c1
+    @c1.associations.should == [:parent]
+    @c1.associate :one_to_many, :children, :class => @c1
+    @c1.associations.sort_by{|x|x.to_s}.should == [:children, :parent]
+  end
+
+  it "association reflections should be copied upon subclasing" do
+    @c1.associate :many_to_one, :parent, :class => @c1
+    c = Class.new(@c1)
+    @c1.associations.should == [:parent]
+    c.associations.should == [:parent]
+    c.associate :many_to_one, :parent2, :class => @c1
+    @c1.associations.should == [:parent]
+    c.associations.sort_by{|x| x.to_s}.should == [:parent, :parent2]
+    c.instance_methods.map{|x| x.to_s}.should include('parent')
+  end
+end