viking-sequel 3.10.0

data/spec/extensions/optimistic_locking_spec.rb

@@ -0,0 +1,100 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "optimistic_locking plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:people)) do
+    end
+    h = {1=>{:id=>1, :name=>'John', :lock_version=>2}}
+    lv = @lv = "lock_version"
+    @c.dataset.quote_identifiers = false
+    @c.dataset.meta_def(:h){h}
+    @c.dataset.meta_def(:lv){lv}
+    @c.dataset.meta_def(:update) do |opts|
+      case update_sql(opts)
+      when /UPDATE people SET (name|#{lv}) = ('Jim'|'Bob'|\d+), (?:name|#{lv}) = ('Jim'|'Bob'|\d+) WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
+        name, nlv = $1 == 'name' ? [$2, $3] : [$3, $2]
+        m = h[$4.to_i]
+        if m && m[:lock_version] == $5.to_i
+          m.merge!(:name=>name.gsub("'", ''), :lock_version=>nlv.to_i)
+          1
+        else
+          0
+        end
+      else
+        puts update_sql(opts)
+      end
+    end
+    @c.dataset.instance_eval do
+      def fetch_rows(sql)
+        m = h[1].dup
+        v = m.delete(:lock_version)
+        m[lv.to_sym] = v
+        yield(m)
+      end
+    end
+    @c.dataset.meta_def(:delete) do
+      case delete_sql
+      when /DELETE FROM people WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
+        m = h[$1.to_i]
+        if m && m[lv.to_sym] == $2.to_i
+          h.delete[$1.to_i]
+          1
+        else
+          0
+        end
+      else
+        puts delete_sql
+      end
+    end
+    @c.columns :id, :name, :lock_version
+    @c.plugin :optimistic_locking
+  end
+
+  specify "should raise an error when updating a stale record" do
+    p1 = @c[1]
+    p2 = @c[1]
+    p1.update(:name=>'Jim')
+    proc{p2.update(:name=>'Bob')}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
+  end 
+
+  specify "should raise an error when destroying a stale record" do
+    p1 = @c[1]
+    p2 = @c[1]
+    p1.update(:name=>'Jim')
+    proc{p2.destroy}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
+  end 
+
+  specify "should not raise an error when updating the same record twice" do
+    p1 = @c[1]
+    p1.update(:name=>'Jim')
+    proc{p1.update(:name=>'Bob')}.should_not raise_error
+  end
+
+  specify "should allow changing the lock column via model.lock_column=" do
+    @lv.replace('lv')
+    @c.columns :id, :name, :lv
+    @c.lock_column = :lv
+    p1 = @c[1]
+    p2 = @c[1]
+    p1.update(:name=>'Jim')
+    proc{p2.update(:name=>'Bob')}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
+  end
+
+  specify "should allow changing the lock column via plugin option" do
+    @lv.replace('lv')
+    @c.columns :id, :name, :lv
+    @c.plugin :optimistic_locking, :lock_column=>:lv
+    p1 = @c[1]
+    p2 = @c[1]
+    p1.update(:name=>'Jim')
+    proc{p2.destroy}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
+  end
+
+  specify "should work when subclassing" do
+    c = Class.new(@c)
+    p1 = c[1]
+    p2 = c[1]
+    p1.update(:name=>'Jim')
+    proc{p2.update(:name=>'Bob')}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
+  end 
+end

data/spec/extensions/pagination_spec.rb

@@ -0,0 +1,99 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+context "A paginated dataset" do
+  before do
+    @d = Sequel::Dataset.new(nil)
+    @d.meta_def(:count) {153}
+    
+    @paginated = @d.paginate(1, 20)
+  end
+  
+  specify "should raise an error if the dataset already has a limit" do
+    proc{@d.limit(10).paginate(1,10)}.should raise_error(Sequel::Error)
+    proc{@paginated.paginate(2,20)}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should set the limit and offset options correctly" do
+    @paginated.opts[:limit].should == 20
+    @paginated.opts[:offset].should == 0
+  end
+  
+  specify "should set the page count correctly" do
+    @paginated.page_count.should == 8
+    @d.paginate(1, 50).page_count.should == 4
+  end
+  
+  specify "should set the current page number correctly" do
+    @paginated.current_page.should == 1
+    @d.paginate(3, 50).current_page.should == 3
+  end
+  
+  specify "should return the next page number or nil if we're on the last" do
+    @paginated.next_page.should == 2
+    @d.paginate(4, 50).next_page.should be_nil
+  end
+  
+  specify "should return the previous page number or nil if we're on the last" do
+    @paginated.prev_page.should be_nil
+    @d.paginate(4, 50).prev_page.should == 3
+  end
+  
+  specify "should return the page range" do
+    @paginated.page_range.should == (1..8)
+    @d.paginate(4, 50).page_range.should == (1..4)
+  end
+  
+  specify "should return the record range for the current page" do
+    @paginated.current_page_record_range.should == (1..20)
+    @d.paginate(4, 50).current_page_record_range.should == (151..153)
+    @d.paginate(5, 50).current_page_record_range.should == (0..0)
+  end
+
+  specify "should return the record count for the current page" do
+    @paginated.current_page_record_count.should == 20
+    @d.paginate(3, 50).current_page_record_count.should == 50
+    @d.paginate(4, 50).current_page_record_count.should == 3
+    @d.paginate(5, 50).current_page_record_count.should == 0
+  end
+
+  specify "should know if current page is last page" do
+    @paginated.last_page?.should be_false
+    @d.paginate(2, 20).last_page?.should be_false
+    @d.paginate(5, 30).last_page?.should be_false
+    @d.paginate(6, 30).last_page?.should be_true
+  end
+
+  specify "should know if current page is first page" do
+    @paginated.first_page?.should be_true
+    @d.paginate(1, 20).first_page?.should be_true
+    @d.paginate(2, 20).first_page?.should be_false
+  end
+
+  specify "should work with fixed sql" do
+    ds = @d.clone(:sql => 'select * from blah')
+    ds.meta_def(:count) {150}
+    ds.paginate(2, 50).sql.should == 'SELECT * FROM (select * from blah) AS t1 LIMIT 50 OFFSET 50'
+  end
+end
+
+context "Dataset#each_page" do
+  before do
+    @d = Sequel::Dataset.new(nil).from(:items)
+    @d.meta_def(:count) {153}
+  end
+  
+  specify "should raise an error if the dataset already has a limit" do
+    proc{@d.limit(10).each_page(10){}}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should iterate over each page in the resultset as a paginated dataset" do
+    a = []
+    @d.each_page(50) {|p| a << p}
+    a.map {|p| p.sql}.should == [
+      'SELECT * FROM items LIMIT 50 OFFSET 0',
+      'SELECT * FROM items LIMIT 50 OFFSET 50',
+      'SELECT * FROM items LIMIT 50 OFFSET 100',
+      'SELECT * FROM items LIMIT 50 OFFSET 150',
+    ]
+  end
+end

data/spec/extensions/pretty_table_spec.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+require 'stringio'
+
+context "Dataset#print" do
+  before do
+    @output = StringIO.new
+    @orig_stdout = $stdout
+    $stdout = @output
+    @dataset = Sequel::Dataset.new(nil).from(:items)
+    def @dataset.fetch_rows(sql)
+      yield({:a=>1, :b=>2})
+      yield({:a=>3, :b=>4})
+      yield({:a=>5, :b=>6})
+    end
+  end
+
+  after do
+    $stdout = @orig_stdout
+  end
+
+  specify "should print out a table with the values" do
+    @dataset.print(:a, :b)
+    @output.rewind
+    @output.read.should == \
+      "+-+-+\n|a|b|\n+-+-+\n|1|2|\n|3|4|\n|5|6|\n+-+-+\n"
+  end
+
+  specify "should default to the dataset's columns" do
+    @dataset.meta_def(:columns) {[:a, :b]}
+    @dataset.print
+    @output.rewind
+    @output.read.should == \
+      "+-+-+\n|a|b|\n+-+-+\n|1|2|\n|3|4|\n|5|6|\n+-+-+\n"
+  end
+end
+
+context "PrettyTable" do
+  before do
+    @data1 = [
+      {:x => 3, :y => 4}
+    ]
+    
+    @data2 = [
+      {:a => 23, :b => 45},
+      {:a => 45, :b => 2377}
+    ]
+
+    @data3 = [
+      {:aaa => 1},
+      {:bb => 2},
+      {:c => 3}
+    ]
+
+    @output = StringIO.new
+    @orig_stdout = $stdout
+    $stdout = @output
+  end
+
+  after do
+    $stdout = @orig_stdout
+  end
+  
+  specify "should infer the columns if not given" do
+    Sequel::PrettyTable.print(@data1)
+    @output.rewind
+    @output.read.should =~ \
+      /\n(\|x\|y\|)|(\|y\|x\|)\n/
+  end
+  
+  specify "should calculate the maximum width of each column correctly" do
+    Sequel::PrettyTable.print(@data2, [:a, :b])
+    @output.rewind
+    @output.read.should == \
+      "+--+----+\n|a |b   |\n+--+----+\n|23|  45|\n|45|2377|\n+--+----+\n"
+  end
+
+  specify "should also take header width into account" do
+    Sequel::PrettyTable.print(@data3, [:aaa, :bb, :c])
+    @output.rewind
+    @output.read.should == \
+      "+---+--+-+\n|aaa|bb|c|\n+---+--+-+\n|  1|  | |\n|   | 2| |\n|   |  |3|\n+---+--+-+\n"
+  end
+  
+  specify "should print only the specified columns" do
+    Sequel::PrettyTable.print(@data2, [:a])
+    @output.rewind
+    @output.read.should == \
+      "+--+\n|a |\n+--+\n|23|\n|45|\n+--+\n"
+  end
+end

data/spec/extensions/query_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+context "Database#dataset" do
+  before do
+    @db = Sequel::Database.new
+  end
+
+  specify "should delegate to Dataset#query if block is provided" do
+    @d = @db.query {select :x; from :y}
+    @d.should be_a_kind_of(Sequel::Dataset)
+    @d.sql.should == "SELECT x FROM y"
+  end
+end
+
+context "Dataset#query" do
+  before do
+    @d = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should support #from" do
+    q = @d.query {from :xxx}
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM xxx"
+  end
+  
+  specify "should support #select" do
+    q = @d.query do
+      select :a, :b___mongo
+      from :yyy
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT a, b AS mongo FROM yyy"
+  end
+  
+  specify "should support #where" do
+    q = @d.query do
+      from :zzz
+      where(:x + 2 > :y + 3)
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM zzz WHERE ((x + 2) > (y + 3))"
+
+    q = @d.from(:zzz).query do
+      where((:x.sql_number > 1) & (:y.sql_number > 2))
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM zzz WHERE ((x > 1) AND (y > 2))"
+
+    q = @d.from(:zzz).query do
+      where :x => 33
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM zzz WHERE (x = 33)"
+  end
+  
+  specify "should support #group_by and #having" do
+    q = @d.query do
+      from :abc
+      group_by :id
+      having(:x.sql_number >= 2)
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM abc GROUP BY id HAVING (x >= 2)"
+  end
+  
+  specify "should support #order, #order_by" do
+    q = @d.query do
+      from :xyz
+      order_by :stamp
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM xyz ORDER BY stamp"
+  end
+  
+  specify "should raise on non-chainable method calls" do
+    proc {@d.query {first_source}}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should raise on each, insert, update, delete" do
+    proc {@d.query {each}}.should raise_error(Sequel::Error)
+    proc {@d.query {insert(:x => 1)}}.should raise_error(Sequel::Error)
+    proc {@d.query {update(:x => 1)}}.should raise_error(Sequel::Error)
+    proc {@d.query {delete}}.should raise_error(Sequel::Error)
+  end
+end

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