sequel 3.9.0 → 3.10.0

data/spec/extensions/association_proxies_spec.rb

@@ -43,5 +43,8 @@ describe "Sequel::Plugins::AssociationProxies" do
   it "should not return a proxy object for associations that do not return an array" do
     Item.many_to_one :tag
     proc{@i.tag.filter(:a=>1)}.should raise_error(NoMethodError)
+    
+    Tag.one_to_one :item
+    proc{Tag.load(:id=>1, :item_id=>2).item.filter(:a=>1)}.should raise_error(NoMethodError)
   end
 end

data/spec/extensions/composition_spec.rb

@@ -0,0 +1,194 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+require 'yaml'
+require 'json'
+
+describe "Serialization plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.plugin :composition
+    @c.columns :id, :year, :month, :day
+    @o = @c.load(:id=>1, :year=>1, :month=>2, :day=>3)
+    MODEL_DB.reset
+  end
+  
+  it ".composition should add compositions" do
+    @o.should_not respond_to(:date)
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @o.date.should == Date.new(1, 2, 3)
+  end
+
+  it "loading the plugin twice should not remove existing compositions" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @c.plugin :composition
+    @c.compositions.keys.should == [:date]
+  end
+
+  it ".composition should raise an error if :composer and :decomposer options are not present and :mapping option is not provided" do
+    proc{@c.composition :date}.should raise_error(Sequel::Error)
+    proc{@c.composition :date, :composer=>proc{}, :decomposer=>proc{}}.should_not raise_error
+    proc{@c.composition :date, :mapping=>[]}.should_not raise_error
+  end
+
+  it ".compositions should return the reflection hash of compositions" do
+    @c.compositions.should == {}
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @c.compositions.keys.should == [:date]
+    r = @c.compositions.values.first
+    r[:mapping].should == [:year, :month, :day]
+    r[:composer].should be_a_kind_of(Proc)
+    r[:decomposer].should be_a_kind_of(Proc)
+  end
+
+  it "#compositions should be a hash of cached values of compositions" do
+    @o.compositions.should == {}
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @o.date
+    @o.compositions.should == {:date=>Date.new(1, 2, 3)}
+  end
+
+  it "should work with custom :composer and :decomposer options" do
+    @c.composition :date, :composer=>proc{Date.new(year+1, month+2, day+3)}, :decomposer=>proc{[:year, :month, :day].each{|s| self.send("#{s}=", date.send(s) * 2)}}
+    @o.date.should == Date.new(2, 4, 6)
+    @o.save
+    MODEL_DB.sqls.last.should include("year = 4")
+    MODEL_DB.sqls.last.should include("month = 8")
+    MODEL_DB.sqls.last.should include("day = 12")
+  end
+
+  it "should allow call super in composition getter and setter method definition in class" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @c.class_eval do
+      def date
+        super + 1
+      end
+      def date=(v)
+        super(v - 3)
+      end
+    end
+    @o.date.should == Date.new(1, 2, 4)
+    @o.compositions[:date].should == Date.new(1, 2, 3)
+    @o.date = Date.new(1, 3, 5)
+    @o.compositions[:date].should == Date.new(1, 3, 2)
+    @o.date.should == Date.new(1, 3, 3)
+  end
+
+  it "should mark the object as modified whenever the composition is set" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @o.modified?.should == false
+    @o.date = Date.new(3, 4, 5)
+    @o.modified?.should == true
+  end
+
+  it "should only decompose existing compositions" do
+    called = false
+    @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
+    called.should == false
+    @o.save
+    called.should == false
+    @o.date = Date.new(1,2,3)
+    called.should == false
+    @o.save_changes
+    called.should == true
+  end
+
+  it "should clear compositions cache when reloading" do
+    @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
+    @o.date = Date.new(3, 4, 5)
+    @o.reload
+    @o.compositions.should == {}
+  end
+
+  it "should instantiate compositions lazily" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @o.compositions.should == {}
+    @o.date
+    @o.compositions.should == {:date=>Date.new(1,2,3)}
+  end
+
+  it "should cache value of composition" do
+    times = 0
+    @c.composition :date, :composer=>proc{times+=1}, :decomposer=>proc{called = true}
+    times.should == 0
+    @o.date
+    times.should == 1
+    @o.date
+    times.should == 1
+  end
+
+  it ":class option should take an string, symbol, or class" do
+    @c.composition :date1, :class=>'Date', :mapping=>[:year, :month, :day]
+    @c.composition :date2, :class=>:Date, :mapping=>[:year, :month, :day]
+    @c.composition :date3, :class=>Date, :mapping=>[:year, :month, :day]
+    @o.date1.should == Date.new(1, 2, 3)
+    @o.date2.should == Date.new(1, 2, 3)
+    @o.date3.should == Date.new(1, 2, 3)
+  end
+
+  it ":mapping option should work with a single array of symbols" do
+    c = Class.new do
+      def initialize(y, m)
+        @y, @m = y, m
+      end
+      def year
+        @y * 2
+      end
+      def month
+        @m * 3
+      end
+    end
+    @c.composition :date, :class=>c, :mapping=>[:year, :month]
+    @o.date.year.should == 2
+    @o.date.month.should == 6
+    @o.date = c.new(3, 4)
+    @o.save
+    MODEL_DB.sqls.last.should include("year = 6")
+    MODEL_DB.sqls.last.should include("month = 12")
+  end
+
+  it ":mapping option should work with an array of two pairs of symbols" do
+    c = Class.new do
+      def initialize(y, m)
+        @y, @m = y, m
+      end
+      def y
+        @y * 2
+      end
+      def m
+        @m * 3
+      end
+    end
+    @c.composition :date, :class=>c, :mapping=>[[:year, :y], [:month, :m]]
+    @o.date.y.should == 2
+    @o.date.m.should == 6
+    @o.date = c.new(3, 4)
+    @o.save
+    MODEL_DB.sqls.last.should include("year = 6")
+    MODEL_DB.sqls.last.should include("month = 12")
+  end
+
+  it ":mapping option :composer should return nil if all values are nil" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @c.new.date.should == nil
+  end
+
+  it ":mapping option :decomposer should set all related fields to nil if nil" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @o.date = nil
+    @o.save
+    MODEL_DB.sqls.last.should include("year = NULL")
+    MODEL_DB.sqls.last.should include("month = NULL")
+    MODEL_DB.sqls.last.should include("day = NULL")
+  end
+
+  it "should work correctly with subclasses" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    c = Class.new(@c)
+    o = c.load(:id=>1, :year=>1, :month=>2, :day=>3)
+    o.date.should == Date.new(1, 2, 3)
+    o.save
+    MODEL_DB.sqls.last.should include("year = 1")
+    MODEL_DB.sqls.last.should include("month = 2")
+    MODEL_DB.sqls.last.should include("day = 3")
+  end
+end

data/spec/extensions/identity_map_spec.rb

@@ -155,6 +155,22 @@ describe "Sequel::Plugins::IdentityMap" do
     end
   end
 
+  it "should not use the identity map as a lookup cache for a one_to_one association" do
+    c = @c2
+    @c2.one_to_one :artist, :class=>@c1, :key=>:artist_id
+    @c.with_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      o = @c2.load(:id=>2)
+      a = o.artist
+      a.should be_a_kind_of(@c1)
+      MODEL_DB.sqls.length.should == 1
+      o.reload
+      MODEL_DB.sqls.length.should == 2
+      o.artist.should == a
+      MODEL_DB.sqls.length.should == 3
+    end
+  end
+  
   it "should not use the identity map as a lookup cache if the assocation has a nil :key option" do
     c = @c2
     @c1.many_to_one :artist, :class=>@c2, :key=>nil, :dataset=>proc{c.filter(:artist_id=>artist_id)}

data/spec/extensions/nested_attributes_spec.rb

@@ -45,9 +45,10 @@ describe "NestedAttributes plugin" do
     @Album.columns :id, :name, :artist_id
     @Tag.columns :id, :name
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Artist.one_to_one :first_album, :class=>@Album, :key=>:artist_id
     @Album.many_to_one :artist, :class=>@Artist
     @Album.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at
-    @Artist.nested_attributes :albums, :destroy=>true, :remove=>true
+    @Artist.nested_attributes :albums, :first_album, :destroy=>true, :remove=>true
     @Album.nested_attributes :artist, :tags, :destroy=>true, :remove=>true
   end
   
@@ -58,6 +59,15 @@ describe "NestedAttributes plugin" do
     @mods.should == [[:is, :artists, {:name=>"Ar"}, 1], [:is, :albums, {:name=>"Al", :artist_id=>1}, 2]]
   end
   
+  it "should support creating new one_to_one objects" do
+    a = @Artist.new(:name=>'Ar')
+    a.id = 1
+    a.first_album_attributes = {:name=>'Al'}
+    @mods.should == []
+    a.save
+    @mods.should == [[:is, :artists, {:name=>"Ar", :id=>1}, 1], [:is, :albums, {:name=>"Al"}, 2], [:u, :albums, {:artist_id=>nil}, "((artist_id = 1) AND (id != 2))"], [:u, :albums, {:name=>"Al", :artist_id=>1}, "(id = 2)"]]
+  end
+  
   it "should support creating new one_to_many objects" do
     a = @Artist.new({:name=>'Ar', :albums_attributes=>[{:name=>'Al'}]})
     @mods.should == []
@@ -88,6 +98,16 @@ describe "NestedAttributes plugin" do
     @mods.should == [[:u, :albums, {:name=>"Al"}, '(id = 10)'], [:u, :artists, {:name=>"Ar2"}, '(id = 20)']]
   end
   
+  it "should support updating one_to_one objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:first_album] = al
+    ar.set(:first_album_attributes=>{:id=>10, :name=>'Al2'})
+    @mods.should == []
+    ar.save
+    @mods.should == [[:u, :artists, {:name=>"Ar"}, '(id = 20)'], [:u, :albums, {:name=>"Al2"}, '(id = 10)']]
+  end
+  
   it "should support updating one_to_many objects" do
     al = @Album.load(:id=>10, :name=>'Al')
     ar = @Artist.load(:id=>20, :name=>'Ar')
@@ -118,6 +138,17 @@ describe "NestedAttributes plugin" do
     @mods.should == [[:u, :albums, {:artist_id=>nil, :name=>'Al'}, '(id = 10)']]
   end
   
+  it "should support removing one_to_one objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:first_album] = al
+    ar.set(:first_album_attributes=>{:id=>10, :_remove=>'t'})
+    @mods.should == []
+    ar.save
+    @mods.should == [[:u, :albums, {:artist_id=>nil}, "(artist_id = 20)"], [:u, :artists, {:name=>"Ar"}, "(id = 20)"]]
+    
+  end
+  
   it "should support removing one_to_many objects" do
     al = @Album.load(:id=>10, :name=>'Al')
     ar = @Artist.load(:id=>20, :name=>'Ar')
@@ -148,6 +179,16 @@ describe "NestedAttributes plugin" do
     @mods.should == [[:u, :albums, {:artist_id=>nil, :name=>'Al'}, '(id = 10)'], [:d, :artists, '(id = 20)']]
   end
   
+  it "should support destroying one_to_one objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:first_album] = al
+    ar.set(:first_album_attributes=>{:id=>10, :_delete=>'t'})
+    @mods.should == []
+    ar.save
+    @mods.should == [[:u, :albums, {:artist_id=>nil}, "(artist_id = 20)"], [:u, :artists, {:name=>"Ar"}, "(id = 20)"], [:d, :albums, "(id = 10)"]]
+  end
+  
   it "should support destroying one_to_many objects" do
     al = @Album.load(:id=>10, :name=>'Al')
     ar = @Artist.load(:id=>20, :name=>'Ar')
@@ -239,6 +280,8 @@ describe "NestedAttributes plugin" do
     proc{a.save}.should raise_error(Sequel::ValidationFailed)
     a.errors.full_messages.should == ['artist name cannot be Ar']
     @mods.should == []
+    # Should preserve attributes
+    a.artist.name.should == 'Ar'
   end
   
   it "should not attempt to validate nested attributes if the :validate=>false association option is used" do

data/spec/extensions/rcte_tree_spec.rb

@@ -0,0 +1,205 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "rcte_tree" do
+  before do
+    @c = Class.new(Sequel::Model(MODEL_DB[:nodes]))
+    @c.class_eval do
+      def self.name; 'Node'; end
+      columns :id, :name, :parent_id, :i, :pi
+    end
+    @ds = @c.dataset
+    class << @ds
+      attr_accessor :row_sets
+      def fetch_rows(sql)
+        @db << sql
+        row_sets.shift.each{|row| yield row}
+      end
+    end
+    @o = @c.load(:id=>2, :parent_id=>1, :name=>'AA', :i=>3, :pi=>4)
+    MODEL_DB.reset
+  end
+
+  it "should define the correct associations" do
+    @c.plugin :rcte_tree
+    @c.associations.sort_by{|x| x.to_s}.should == [:ancestors, :children, :descendants, :parent]
+  end
+  
+  it "should define the correct associations when giving options" do
+    @c.plugin :rcte_tree, :ancestors=>{:name=>:as}, :children=>{:name=>:cs}, :descendants=>{:name=>:ds}, :parent=>{:name=>:p}
+    @c.associations.sort_by{|x| x.to_s}.should == [:as, :cs, :ds, :p]
+  end
+
+  it "should use the correct SQL for lazy associations" do
+    @c.plugin :rcte_tree
+    @o.parent_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1'
+    @o.children_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.parent_id = 2)'
+    @o.ancestors_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE (id = 1) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.parent_id = nodes.id)) SELECT * FROM t'
+    @o.descendants_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE (parent_id = 2) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.id = nodes.parent_id)) SELECT * FROM t'
+  end
+  
+  it "should use the correct SQL for lazy associations when giving options" do
+    @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :cte_name=>:cte, :order=>:name, :ancestors=>{:name=>:as}, :children=>{:name=>:cs}, :descendants=>{:name=>:ds}, :parent=>{:name=>:p}
+    @o.p_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.i = 4) ORDER BY name LIMIT 1'
+    @o.cs_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.pi = 3) ORDER BY name'
+    @o.as_dataset.sql.should == 'WITH cte AS (SELECT * FROM nodes WHERE (i = 4) UNION ALL SELECT nodes.* FROM nodes INNER JOIN cte ON (cte.pi = nodes.i)) SELECT * FROM cte ORDER BY name'
+    @o.ds_dataset.sql.should == 'WITH cte AS (SELECT * FROM nodes WHERE (pi = 3) UNION ALL SELECT nodes.* FROM nodes INNER JOIN cte ON (cte.i = nodes.pi)) SELECT * FROM cte ORDER BY name'
+  end
+  
+  it "should add all parent associations when lazily loading ancestors" do
+    @c.plugin :rcte_tree
+    @ds.row_sets = [[{:id=>1, :name=>'A', :parent_id=>3}, {:id=>4, :name=>'B', :parent_id=>nil}, {:id=>3, :name=>'?', :parent_id=>4}]]
+    @o.ancestors.should == [@c.load(:id=>1, :name=>'A', :parent_id=>3), @c.load(:id=>4, :name=>'B', :parent_id=>nil), @c.load(:id=>3, :name=>'?', :parent_id=>4)]
+    @o.associations[:parent].should == @c.load(:id=>1, :name=>'A', :parent_id=>3)
+    @o.associations[:parent].associations[:parent].should == @c.load(:id=>3, :name=>'?', :parent_id=>4)
+    @o.associations[:parent].associations[:parent].associations[:parent].should == @c.load(:id=>4, :name=>'B', :parent_id=>nil)
+    @o.associations[:parent].associations[:parent].associations[:parent].associations.fetch(:parent, 1).should == nil
+  end
+  
+  it "should add all parent associations when lazily loading ancestors and giving options" do
+    @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :ancestors=>{:name=>:as}, :parent=>{:name=>:p}
+    @ds.row_sets = [[{:i=>4, :name=>'A', :pi=>5}, {:i=>6, :name=>'B', :pi=>nil}, {:i=>5, :name=>'?', :pi=>6}]]
+    @o.as.should == [@c.load(:i=>4, :name=>'A', :pi=>5), @c.load(:i=>6, :name=>'B', :pi=>nil), @c.load(:i=>5, :name=>'?', :pi=>6)]
+    @o.associations[:p].should == @c.load(:i=>4, :name=>'A', :pi=>5)
+    @o.associations[:p].associations[:p].should == @c.load(:i=>5, :name=>'?', :pi=>6)
+    @o.associations[:p].associations[:p].associations[:p].should == @c.load(:i=>6, :name=>'B', :pi=>nil)
+    @o.associations[:p].associations[:p].associations[:p].associations.fetch(:p, 1).should == nil
+  end
+  
+  it "should add all children associations when lazily loading descendants" do
+    @c.plugin :rcte_tree
+    @ds.row_sets = [[{:id=>3, :name=>'??', :parent_id=>1}, {:id=>1, :name=>'A', :parent_id=>2}, {:id=>4, :name=>'B', :parent_id=>2}, {:id=>5, :name=>'?', :parent_id=>3}]]
+    @o.descendants.should == [@c.load(:id=>3, :name=>'??', :parent_id=>1), @c.load(:id=>1, :name=>'A', :parent_id=>2), @c.load(:id=>4, :name=>'B', :parent_id=>2), @c.load(:id=>5, :name=>'?', :parent_id=>3)]
+    @o.associations[:children].should == [@c.load(:id=>1, :name=>'A', :parent_id=>2), @c.load(:id=>4, :name=>'B', :parent_id=>2)]
+    @o.associations[:children].map{|c1| c1.associations[:children]}.should == [[@c.load(:id=>3, :name=>'??', :parent_id=>1)], []]
+    @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children]}}.should == [[[@c.load(:id=>5, :name=>'?', :parent_id=>3)]], []]
+    @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children].map{|c3| c3.associations[:children]}}}.should == [[[[]]], []]
+  end
+  
+  it "should add all children associations when lazily loading descendants and giving options" do
+    @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :children=>{:name=>:cs}, :descendants=>{:name=>:ds}
+    @ds.row_sets = [[{:i=>7, :name=>'??', :pi=>5}, {:i=>5, :name=>'A', :pi=>3}, {:i=>6, :name=>'B', :pi=>3}, {:i=>8, :name=>'?', :pi=>7}]]
+    @o.ds.should == [@c.load(:i=>7, :name=>'??', :pi=>5), @c.load(:i=>5, :name=>'A', :pi=>3), @c.load(:i=>6, :name=>'B', :pi=>3), @c.load(:i=>8, :name=>'?', :pi=>7)]
+    @o.associations[:cs].should == [@c.load(:i=>5, :name=>'A', :pi=>3), @c.load(:i=>6, :name=>'B', :pi=>3)]
+    @o.associations[:cs].map{|c1| c1.associations[:cs]}.should == [[@c.load(:i=>7, :name=>'??', :pi=>5)], []]
+    @o.associations[:cs].map{|c1| c1.associations[:cs].map{|c2| c2.associations[:cs]}}.should == [[[@c.load(:i=>8, :name=>'?', :pi=>7)]], []]
+    @o.associations[:cs].map{|c1| c1.associations[:cs].map{|c2| c2.associations[:cs].map{|c3| c3.associations[:cs]}}}.should == [[[[]]], []]
+  end
+  
+  it "should eagerly load ancestors" do
+    @c.plugin :rcte_tree
+    @ds.row_sets = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}, {:id=>9, :parent_id=>nil, :name=>'E'}],
+      [{:id=>2, :name=>'AA', :parent_id=>1, :x_root_x=>2},
+       {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>1}, {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>2},
+       {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>2}, {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>1}]]
+    os = @ds.eager(:ancestors).all
+    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
+    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(id IN \([12], [12]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\)\) SELECT \* FROM t/
+    os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D'), @c.load(:id=>9, :parent_id=>nil, :name=>'E')]
+    os.map{|o| o.ancestors}.should == [[@c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>8, :name=>'?', :parent_id=>nil)],
+      [@c.load(:id=>2, :name=>'AA', :parent_id=>1), @c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>8, :name=>'?', :parent_id=>nil)],
+      [@c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>8, :name=>'?', :parent_id=>nil)],
+      []]
+    os.map{|o| o.parent}.should == [@c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>2, :name=>'AA', :parent_id=>1), @c.load(:id=>1, :name=>'00', :parent_id=>8), nil]
+    os.map{|o| o.parent.parent if o.parent}.should == [@c.load(:id=>8, :name=>'?', :parent_id=>nil), @c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>8, :name=>'?', :parent_id=>nil), nil]
+    os.map{|o| o.parent.parent.parent if o.parent and o.parent.parent}.should == [nil, @c.load(:id=>8, :name=>'?', :parent_id=>nil), nil, nil]
+    os.map{|o| o.parent.parent.parent.parent if o.parent and o.parent.parent and o.parent.parent.parent}.should == [nil, nil, nil, nil]
+    MODEL_DB.new_sqls.should == []
+  end
+  
+  it "should eagerly load ancestors when giving options" do
+    @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :key_alias=>:kal, :cte_name=>:cte, :ancestors=>{:name=>:as}, :parent=>{:name=>:p}
+    @ds.row_sets = [[{:i=>2, :pi=>1, :name=>'AA'}, {:i=>6, :pi=>2, :name=>'C'}, {:i=>7, :pi=>1, :name=>'D'}, {:i=>9, :pi=>nil, :name=>'E'}],
+      [{:i=>2, :name=>'AA', :pi=>1, :kal=>2},
+       {:i=>1, :name=>'00', :pi=>8, :kal=>1}, {:i=>1, :name=>'00', :pi=>8, :kal=>2},
+       {:i=>8, :name=>'?', :pi=>nil, :kal=>2}, {:i=>8, :name=>'?', :pi=>nil, :kal=>1}]]
+    os = @ds.eager(:as).all
+    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
+    MODEL_DB.new_sqls.last.should =~ /WITH cte AS \(SELECT i AS kal, nodes\.\* FROM nodes WHERE \(i IN \([12], [12]\)\) UNION ALL SELECT cte\.kal, nodes\.\* FROM nodes INNER JOIN cte ON \(cte\.pi = nodes\.i\)\) SELECT \* FROM cte/
+    os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D'), @c.load(:i=>9, :pi=>nil, :name=>'E')]
+    os.map{|o| o.as}.should == [[@c.load(:i=>1, :name=>'00', :pi=>8), @c.load(:i=>8, :name=>'?', :pi=>nil)],
+      [@c.load(:i=>2, :name=>'AA', :pi=>1), @c.load(:i=>1, :name=>'00', :pi=>8), @c.load(:i=>8, :name=>'?', :pi=>nil)],
+      [@c.load(:i=>1, :name=>'00', :pi=>8), @c.load(:i=>8, :name=>'?', :pi=>nil)],
+      []]
+    os.map{|o| o.p}.should == [@c.load(:i=>1, :name=>'00', :pi=>8), @c.load(:i=>2, :name=>'AA', :pi=>1), @c.load(:i=>1, :name=>'00', :pi=>8), nil]
+    os.map{|o| o.p.p if o.p}.should == [@c.load(:i=>8, :name=>'?', :pi=>nil), @c.load(:i=>1, :name=>'00', :pi=>8), @c.load(:i=>8, :name=>'?', :pi=>nil), nil]
+    os.map{|o| o.p.p.p if o.p and o.p.p}.should == [nil, @c.load(:i=>8, :name=>'?', :pi=>nil), nil, nil]
+    os.map{|o| o.p.p.p.p if o.p and o.p.p and o.p.p.p}.should == [nil, nil, nil, nil]
+    MODEL_DB.new_sqls.should == []
+  end
+  
+  it "should eagerly load descendants" do
+    @c.plugin :rcte_tree
+    @ds.row_sets = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
+      [{:id=>6, :parent_id=>2, :name=>'C', :x_root_x=>2}, {:id=>9, :parent_id=>2, :name=>'E', :x_root_x=>2},
+       {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2},
+       {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7}]]
+    os = @ds.eager(:descendants).all
+    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
+    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\)\) SELECT \* FROM t/
+    os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D')]
+    os.map{|o| o.descendants}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E'), @c.load(:id=>3, :name=>'00', :parent_id=>6)],
+      [@c.load(:id=>3, :name=>'00', :parent_id=>6)],
+      [@c.load(:id=>4, :name=>'?', :parent_id=>7), @c.load(:id=>5, :name=>'?', :parent_id=>4)]]
+    os.map{|o| o.children}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E')], [@c.load(:id=>3, :name=>'00', :parent_id=>6)], [@c.load(:id=>4, :name=>'?', :parent_id=>7)]]
+    os.map{|o1| o1.children.map{|o2| o2.children}}.should == [[[@c.load(:id=>3, :name=>'00', :parent_id=>6)], []], [[]], [[@c.load(:id=>5, :name=>'?', :parent_id=>4)]]]
+    os.map{|o1| o1.children.map{|o2| o2.children.map{|o3| o3.children}}}.should == [[[[]], []], [[]], [[[]]]]
+    MODEL_DB.new_sqls.should == []
+  end
+  
+  it "should eagerly load descendants when giving options" do
+    @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :key_alias=>:kal, :cte_name=>:cte, :children=>{:name=>:cs}, :descendants=>{:name=>:ds}
+    @ds.row_sets = [[{:i=>2, :pi=>1, :name=>'AA'}, {:i=>6, :pi=>2, :name=>'C'}, {:i=>7, :pi=>1, :name=>'D'}],
+      [{:i=>6, :pi=>2, :name=>'C', :kal=>2}, {:i=>9, :pi=>2, :name=>'E', :kal=>2},
+       {:i=>3, :name=>'00', :pi=>6, :kal=>6}, {:i=>3, :name=>'00', :pi=>6, :kal=>2},
+       {:i=>4, :name=>'?', :pi=>7, :kal=>7}, {:i=>5, :name=>'?', :pi=>4, :kal=>7}]]
+    os = @ds.eager(:ds).all
+    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
+    MODEL_DB.new_sqls.last.should =~ /WITH cte AS \(SELECT pi AS kal, nodes\.\* FROM nodes WHERE \(pi IN \([267], [267], [267]\)\) UNION ALL SELECT cte\.kal, nodes\.\* FROM nodes INNER JOIN cte ON \(cte\.i = nodes\.pi\)\) SELECT \* FROM cte/
+    os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D')]
+    os.map{|o| o.ds}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E'), @c.load(:i=>3, :name=>'00', :pi=>6)],
+      [@c.load(:i=>3, :name=>'00', :pi=>6)],
+      [@c.load(:i=>4, :name=>'?', :pi=>7), @c.load(:i=>5, :name=>'?', :pi=>4)]]
+    os.map{|o| o.cs}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E')], [@c.load(:i=>3, :name=>'00', :pi=>6)], [@c.load(:i=>4, :name=>'?', :pi=>7)]]
+    os.map{|o1| o1.cs.map{|o2| o2.cs}}.should == [[[@c.load(:i=>3, :name=>'00', :pi=>6)], []], [[]], [[@c.load(:i=>5, :name=>'?', :pi=>4)]]]
+    os.map{|o1| o1.cs.map{|o2| o2.cs.map{|o3| o3.cs}}}.should == [[[[]], []], [[]], [[[]]]]
+    MODEL_DB.new_sqls.should == []
+  end
+  
+  it "should eagerly load descendants to a given level" do
+    @c.plugin :rcte_tree
+    @ds.row_sets = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
+      [{:id=>6, :parent_id=>2, :name=>'C', :x_root_x=>2, :x_level_x=>0}, {:id=>9, :parent_id=>2, :name=>'E', :x_root_x=>2, :x_level_x=>0},
+       {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6, :x_level_x=>0}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2, :x_level_x=>1},
+       {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7, :x_level_x=>0}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7, :x_level_x=>1}]]
+    os = @ds.eager(:descendants=>2).all
+    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
+    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\*, 0 AS x_level_x FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\*, \(t\.x_level_x \+ 1\) AS x_level_x FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(t\.x_level_x < 1\)\) SELECT \* FROM t/
+    os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D')]
+    os.map{|o| o.descendants}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E'), @c.load(:id=>3, :name=>'00', :parent_id=>6)],
+      [@c.load(:id=>3, :name=>'00', :parent_id=>6)],
+      [@c.load(:id=>4, :name=>'?', :parent_id=>7), @c.load(:id=>5, :name=>'?', :parent_id=>4)]]
+    os.map{|o| o.associations[:children]}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E')], [@c.load(:id=>3, :name=>'00', :parent_id=>6)], [@c.load(:id=>4, :name=>'?', :parent_id=>7)]]
+    os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children]}}.should == [[[@c.load(:id=>3, :name=>'00', :parent_id=>6)], []], [[]], [[@c.load(:id=>5, :name=>'?', :parent_id=>4)]]]
+    os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children].map{|o3| o3.associations[:children]}}}.should == [[[[]], []], [[]], [[nil]]]
+    MODEL_DB.new_sqls.should == []
+  end
+  
+  it "should eagerly load descendants to a given level when giving options" do
+    @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :key_alias=>:kal, :level_alias=>:lal, :cte_name=>:cte, :children=>{:name=>:cs}, :descendants=>{:name=>:ds}
+    @ds.row_sets = [[{:i=>2, :pi=>1, :name=>'AA'}, {:i=>6, :pi=>2, :name=>'C'}, {:i=>7, :pi=>1, :name=>'D'}],
+      [{:i=>6, :pi=>2, :name=>'C', :kal=>2, :lal=>0}, {:i=>9, :pi=>2, :name=>'E', :kal=>2, :lal=>0},
+       {:i=>3, :name=>'00', :pi=>6, :kal=>6, :lal=>0}, {:i=>3, :name=>'00', :pi=>6, :kal=>2, :lal=>1},
+       {:i=>4, :name=>'?', :pi=>7, :kal=>7, :lal=>0}, {:i=>5, :name=>'?', :pi=>4, :kal=>7, :lal=>1}]]
+    os = @ds.eager(:ds=>2).all
+    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
+    MODEL_DB.new_sqls.last.should =~ /WITH cte AS \(SELECT pi AS kal, nodes\.\*, 0 AS lal FROM nodes WHERE \(pi IN \([267], [267], [267]\)\) UNION ALL SELECT cte\.kal, nodes\.\*, \(cte\.lal \+ 1\) AS lal FROM nodes INNER JOIN cte ON \(cte\.i = nodes\.pi\) WHERE \(cte\.lal < 1\)\) SELECT \* FROM cte/
+    os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D')]
+    os.map{|o| o.ds}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E'), @c.load(:i=>3, :name=>'00', :pi=>6)],
+      [@c.load(:i=>3, :name=>'00', :pi=>6)],
+      [@c.load(:i=>4, :name=>'?', :pi=>7), @c.load(:i=>5, :name=>'?', :pi=>4)]]
+    os.map{|o| o.associations[:cs]}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E')], [@c.load(:i=>3, :name=>'00', :pi=>6)], [@c.load(:i=>4, :name=>'?', :pi=>7)]]
+    os.map{|o1| o1.associations[:cs].map{|o2| o2.associations[:cs]}}.should == [[[@c.load(:i=>3, :name=>'00', :pi=>6)], []], [[]], [[@c.load(:i=>5, :name=>'?', :pi=>4)]]]
+    os.map{|o1| o1.associations[:cs].map{|o2| o2.associations[:cs].map{|o3| o3.associations[:cs]}}}.should == [[[[]], []], [[]], [[nil]]]
+    MODEL_DB.new_sqls.should == []
+  end
+end