sequel 4.2.0 → 4.3.0

data/lib/sequel/plugins/tree.rb

@@ -23,9 +23,9 @@ module Sequel
     #   end
     module Tree
       # Create parent and children associations.  Any options
-      # specified are passed to both associations.  You can
-      # specify options to use for the parent association
-      # using a :parent option, and options to use for the
+      # specified are passed to both associations.  You can also
+      # specify options to use for just the parent association
+      # using a :parent option, and options to use for just the
       # children association using a :children option.
       def self.apply(model, opts=OPTS)
         opts = opts.dup
@@ -72,7 +72,7 @@ module Sequel
         #
         #   TreeClass.roots_dataset => Sequel#Dataset
         def roots_dataset
-          ds = filter(parent_column => nil)
+          ds = where(Sequel.or(Array(parent_column).zip([])))
           ds = ds.order(*tree_order) if tree_order
           ds
         end
@@ -105,7 +105,7 @@ module Sequel
 
         # Returns true if this is a root node, false otherwise.
         def root?
-          !new? && self[model.parent_column].nil?
+          !new? && possible_root?
         end
 
         # Returns all siblings and a reference to the current node.
@@ -121,6 +121,13 @@ module Sequel
         def siblings
           self_and_siblings - [self]
         end
+
+        private
+
+        # True if if all parent columns values are not NULL.
+        def possible_root?
+          !Array(model.parent_column).map{|c| self[c]}.all?
+        end
       end
 
       # Plugin included when :single_root option is passed.
@@ -135,7 +142,7 @@ module Sequel
         module InstanceMethods
           # Hook that prevents a second root from being created.
           def before_save
-            if self[model.parent_column].nil? && (root = model.root) && pk != root.pk
+            if possible_root? && (root = model.root) && pk != root.pk
               raise TreeMultipleRootError, "there is already a root #{model.name} defined"
             end
             super

data/lib/sequel/sql.rb

@@ -1692,7 +1692,7 @@ module Sequel
 
   # +LiteralString+ is used to represent literal SQL expressions. A 
   # +LiteralString+ is copied verbatim into an SQL statement. Instances of
-  # +LiteralString+ can be created by calling <tt>String#lit</tt>.
+  # +LiteralString+ can be created by calling <tt>Sequel.lit</tt>.
   class LiteralString
     include SQL::OrderMethods
     include SQL::ComplexExpressionMethods

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 2
+  MINOR = 3
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/postgres_spec.rb

@@ -1927,6 +1927,23 @@ describe 'PostgreSQL array handling' do
     end
   end
 
+  specify 'insert and retrieve empty arrays' do
+    @db.create_table!(:items) do
+      column :n, 'integer[]'
+    end
+    @ds.insert(:n=>Sequel.pg_array([], :integer))
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      rs.should == [{:n=>[]}]
+      rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
+      rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+  end
+
   specify 'insert and retrieve custom array types' do
     int2vector = Class.new do
       attr_reader :array

data/spec/core/dataset_spec.rb

@@ -3542,6 +3542,14 @@ describe "Sequel::Dataset#qualify" do
     @ds.select{sum(:over, :args=>:a, :partition=>:b, :order=>:c){}}.qualify.sql.should == 'SELECT sum(t.a) OVER (PARTITION BY t.b ORDER BY t.c) FROM t'
   end
 
+  specify "should handle SQL::DelayedEvaluation" do
+    t = :a
+    ds = @ds.filter(Sequel.delay{t}).qualify
+    ds.sql.should == 'SELECT t.* FROM t WHERE t.a'
+    t = :b
+    ds.sql.should == 'SELECT t.* FROM t WHERE t.b'
+  end
+
   specify "should handle all other objects by returning them unchanged" do
     @ds.select("a").filter{a(3)}.filter('blah').order(Sequel.lit('true')).group(Sequel.lit('a > ?', 1)).having(false).qualify.sql.should == "SELECT 'a' FROM t WHERE (a(3) AND (blah)) GROUP BY a > 1 HAVING 'f' ORDER BY true"
   end
@@ -4529,6 +4537,12 @@ describe "Dataset#supports_replace?" do
   end
 end
 
+describe "Dataset#supports_lateral_subqueries?" do
+  it "should be false by default" do
+    Sequel::Dataset.new(nil).supports_lateral_subqueries?.should be_false
+  end
+end
+
 describe "Frozen Datasets" do
   before do
     @ds = Sequel.mock[:test].freeze

data/spec/core/schema_spec.rb

@@ -1532,6 +1532,7 @@ describe "Schema Parser" do
     @db = Sequel.mock(:host=>'postgres')
     @db.extend(sm)
     @db.schema(:interval).first.last[:type].should == :interval
+    @db.schema(:citext).first.last[:type].should == :string
 
     @db = Sequel.mock(:host=>'mysql')
     @db.extend(sm)

data/spec/extensions/error_sql_spec.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "error_sql extension" do
+  before do
+    @db = Sequel.mock(:fetch=>proc{|sql| @db.log_yield(sql){raise StandardError}}).extension(:error_sql)
+  end
+
+  specify "should have Sequel::DatabaseError#sql give the SQL causing the error" do
+    @db["SELECT"].all rescue (e = $!)
+    e.sql.should == "SELECT"
+  end
+
+  specify "should have Sequel::DatabaseError#sql give the SQL causing the error when using a logger" do
+    l = Object.new
+    def l.method_missing(*) end
+    @db.loggers = [l]
+    @db["SELECT"].all rescue (e = $!)
+    e.sql.should == "SELECT"
+  end
+end

data/spec/extensions/migration_spec.rb

@@ -211,6 +211,21 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
   end
 end
 
+describe "Sequel::Migrator.migrator_class" do
+  specify "should return IntegerMigrator if not using timestamp migrations" do
+    Sequel::Migrator.migrator_class("spec/files/integer_migrations").should == Sequel::IntegerMigrator
+  end
+
+  specify "should return TimestampMigrator if using timestamp migrations" do
+    Sequel::Migrator.migrator_class('spec/files/timestamped_migrations').should == Sequel::TimestampMigrator
+  end
+
+  specify "should return self if run on a subclass" do
+    Sequel::IntegerMigrator.migrator_class("spec/files/timestamped_migrations").should == Sequel::IntegerMigrator
+    Sequel::TimestampMigrator.migrator_class("spec/files/integer_migrations").should == Sequel::TimestampMigrator
+  end
+end
+
 describe "Sequel::IntegerMigrator" do
   before do
     dbc = Class.new(Sequel::Mock::Database) do

data/spec/extensions/pagination_spec.rb

@@ -11,6 +11,8 @@ describe "A paginated dataset" do
   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)
+    proc{@d.limit(10).each_page(10){|ds|}}.should raise_error(Sequel::Error)
+    proc{@d.limit(10).each_page(10)}.should raise_error(Sequel::Error)
   end
   
   specify "should set the limit and offset options correctly" do
@@ -21,6 +23,9 @@ describe "A paginated dataset" do
   specify "should set the page count correctly" do
     @paginated.page_count.should == 8
     @d.paginate(1, 50).page_count.should == 4
+
+    @d.meta_def(:count) {0}
+    @d.paginate(1, 50).page_count.should == 1
   end
   
   specify "should set the current page number correctly" do
@@ -61,6 +66,10 @@ describe "A paginated dataset" do
     @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
+
+    @d.meta_def(:count) {0}
+    @d.paginate(1, 30).last_page?.should be_true
+    @d.paginate(2, 30).last_page?.should be_false
   end
 
   specify "should know if current page is first page" do
@@ -96,4 +105,14 @@ describe "Dataset#each_page" do
       'SELECT * FROM items LIMIT 50 OFFSET 150',
     ]
   end
+
+  specify "should return an enumerator if no block is given" do
+    enum = @d.each_page(50)
+    enum.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/pg_array_spec.rb

@@ -147,6 +147,7 @@ describe "pg_array extension" do
   end
 
   it "should literalize with types correctly" do
+    @db.literal(@m::PGArray.new([], :int4)).should == "'{}'::int4[]"
     @db.literal(@m::PGArray.new([1], :int4)).should == 'ARRAY[1]::int4[]'
     @db.literal(@m::PGArray.new([nil], :text)).should == 'ARRAY[NULL]::text[]'
     @db.literal(@m::PGArray.new([nil, 1], :int8)).should == 'ARRAY[NULL,1]::int8[]'
@@ -230,7 +231,7 @@ describe "pg_array extension" do
       end
 
       @db.literal(@db.typecast_value(meth, [array_in])).should == "ARRAY[#{output}]::#{db_type}[]"
-      @db.literal(@db.typecast_value(meth, [])).should == "ARRAY[]::#{db_type}[]"
+      @db.literal(@db.typecast_value(meth, [])).should == "'{}'::#{db_type}[]"
     end
     proc{@db.typecast_value(:integer_array, {})}.should raise_error(Sequel::InvalidValue)
   end
@@ -311,7 +312,7 @@ describe "pg_array extension" do
 
   it "should support registering custom types with :array_type option" do
     Sequel::Postgres::PGArray.register('foo', :oid=>3, :array_type=>:blah)
-    @db.literal(Sequel::Postgres::PG_TYPES[3].call('{}')).should == 'ARRAY[]::blah[]'
+    @db.literal(Sequel::Postgres::PG_TYPES[3].call('{}')).should == "'{}'::blah[]"
   end
 
   it "should use and not override existing database typecast method if :typecast_method option is given" do

data/spec/extensions/rcte_tree_spec.rb

@@ -39,6 +39,18 @@ describe Sequel::Model, "rcte_tree" do
     @o.descendants_dataset.sql.should == 'WITH t(id, name, parent_id, i, pi) AS (SELECT id, name, parent_id, i, pi FROM nodes WHERE (parent_id = 2) UNION ALL SELECT nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes INNER JOIN t ON (t.id = nodes.parent_id)) SELECT * FROM t AS nodes'
   end
   
+  it "should use the correct SQL for eager loading when recursive CTEs require column aliases" do
+    @c.dataset.meta_def(:recursive_cte_requires_column_aliases?){true}
+    @c.plugin :rcte_tree
+    @ds._fetch = [[{:id=>1, :name=>'A', :parent_id=>3}]]
+    @c.eager(:ancestors).all
+    DB.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x, id, name, parent_id, i, pi) AS (SELECT id AS x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes WHERE (id IN (3)) UNION ALL SELECT t.x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes INNER JOIN t ON (t.parent_id = nodes.id)) SELECT * FROM t AS nodes"]
+
+    @ds._fetch = [[{:id=>1, :name=>'A', :parent_id=>3}]]
+    @c.eager(:descendants).all
+    DB.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x, id, name, parent_id, i, pi) AS (SELECT parent_id AS x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes WHERE (parent_id IN (1)) UNION ALL SELECT t.x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes INNER JOIN t ON (t.id = nodes.parent_id)) SELECT * FROM t AS nodes"]
+  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'
@@ -242,3 +254,126 @@ describe Sequel::Model, "rcte_tree" do
     sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(\(parent_id IN \([267], [267], [267]\)\) AND \(i = 1\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(i = 1\)\) SELECT \* FROM t AS nodes WHERE \(i = 1\)/
   end
 end
+
+describe Sequel::Model, "rcte_tree with composite keys" do
+  before do
+    @c = Class.new(Sequel::Model(DB[:nodes]))
+    @c.class_eval do
+      def self.name; 'Node'; end
+      columns :id, :id2, :name, :parent_id, :parent_id2, :i, :pi
+      set_primary_key [:id, :id2]
+    end
+    @ds = @c.dataset
+    @o = @c.load(:id=>2, :id2=>5, :parent_id=>1, :parent_id2=>6, :name=>'AA', :i=>3, :pi=>4)
+    DB.reset
+  end
+
+  it "should use the correct SQL for lazy associations" do
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @o.parent_dataset.sql.should == 'SELECT * FROM nodes WHERE ((nodes.id = 1) AND (nodes.id2 = 6)) LIMIT 1'
+    @o.children_dataset.sql.should == 'SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (nodes.parent_id2 = 5))'
+    @o.ancestors_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON ((t.parent_id = nodes.id) AND (t.parent_id2 = nodes.id2))) SELECT * FROM t AS nodes'
+    @o.descendants_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE ((parent_id = 2) AND (parent_id2 = 5)) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON ((t.id = nodes.parent_id) AND (t.id2 = nodes.parent_id2))) SELECT * FROM t AS nodes'
+  end
+  
+  it "should use the correct SQL for lazy associations when recursive CTEs require column aliases" do
+    @c.dataset.meta_def(:recursive_cte_requires_column_aliases?){true}
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @o.ancestors_dataset.sql.should == 'WITH t(id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT id, id2, name, parent_id, parent_id2, i, pi FROM nodes WHERE ((id = 1) AND (id2 = 6)) UNION ALL SELECT nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.parent_id = nodes.id) AND (t.parent_id2 = nodes.id2))) SELECT * FROM t AS nodes'
+    @o.descendants_dataset.sql.should == 'WITH t(id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT id, id2, name, parent_id, parent_id2, i, pi FROM nodes WHERE ((parent_id = 2) AND (parent_id2 = 5)) UNION ALL SELECT nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.id = nodes.parent_id) AND (t.id2 = nodes.parent_id2))) SELECT * FROM t AS nodes'
+  end
+  
+  it "should use the correct SQL for eager loading when recursive CTEs require column aliases" do
+    @c.dataset.meta_def(:recursive_cte_requires_column_aliases?){true}
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @ds._fetch = [[{:id=>1, :id2=>2, :name=>'A', :parent_id=>3, :parent_id2=>4}]]
+    @c.eager(:ancestors).all
+    DB.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x_0, x_root_x_1, id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT id AS x_root_x_0, id2 AS x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes WHERE ((id, id2) IN ((3, 4))) UNION ALL SELECT t.x_root_x_0, t.x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.parent_id = nodes.id) AND (t.parent_id2 = nodes.id2))) SELECT * FROM t AS nodes"]
+
+    @ds._fetch = [[{:id=>1, :id2=>2, :name=>'A', :parent_id=>3, :parent_id2=>4}]]
+    @c.eager(:descendants).all
+    DB.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x_0, x_root_x_1, id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT parent_id AS x_root_x_0, parent_id2 AS x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes WHERE ((parent_id, parent_id2) IN ((1, 2))) UNION ALL SELECT t.x_root_x_0, t.x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.id = nodes.parent_id) AND (t.id2 = nodes.parent_id2))) SELECT * FROM t AS nodes"]
+  end
+  
+  it "should add all parent associations when lazily loading ancestors" do
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @ds._fetch = [[{:id=>1, :id2=>6, :name=>'A', :parent_id=>3, :parent_id2=>5}, {:id=>4, :id2=>8, :name=>'B', :parent_id=>nil, :parent_id2=>nil}, {:id=>3, :id2=>5, :name=>'?', :parent_id=>4, :parent_id2=>8}]]
+    @o.ancestors.should == [@c.load(:id=>1, :id2=>6, :name=>'A', :parent_id=>3, :parent_id2=>5), @c.load(:id=>4, :id2=>8, :name=>'B', :parent_id=>nil, :parent_id2=>nil), @c.load(:id=>3, :id2=>5, :name=>'?', :parent_id=>4, :parent_id2=>8)]
+    @o.associations[:parent].should == @c.load(:id=>1, :id2=>6, :name=>'A', :parent_id=>3, :parent_id2=>5)
+    @o.associations[:parent].associations[:parent].should == @c.load(:id=>3, :id2=>5, :name=>'?', :parent_id=>4, :parent_id2=>8)
+    @o.associations[:parent].associations[:parent].associations[:parent].should == @c.load(:id=>4, :id2=>8, :name=>'B', :parent_id=>nil, :parent_id2=>nil)
+    @o.associations[:parent].associations[:parent].associations[:parent].associations.fetch(:parent, 1).should == nil
+  end
+  
+  it "should add all children associations when lazily loading descendants" do
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @ds._fetch = [[{:id=>3, :id2=>4, :name=>'??', :parent_id=>1, :parent_id2=>2}, {:id=>1, :id2=>2, :name=>'A', :parent_id=>2, :parent_id2=>5}, {:id=>4, :id2=>5, :name=>'B', :parent_id=>2, :parent_id2=>5}, {:id=>5, :id2=>7, :name=>'?', :parent_id=>3, :parent_id2=>4}]]
+    @o.descendants.should == [@c.load(:id=>3, :id2=>4, :name=>'??', :parent_id=>1, :parent_id2=>2), @c.load(:id=>1, :id2=>2, :name=>'A', :parent_id=>2, :parent_id2=>5), @c.load(:id=>4, :id2=>5, :name=>'B', :parent_id=>2, :parent_id2=>5), @c.load(:id=>5, :id2=>7, :name=>'?', :parent_id=>3, :parent_id2=>4)]
+    @o.associations[:children].should == [@c.load(:id=>1, :id2=>2, :name=>'A', :parent_id=>2, :parent_id2=>5), @c.load(:id=>4, :id2=>5, :name=>'B', :parent_id=>2, :parent_id2=>5)]
+    @o.associations[:children].map{|c1| c1.associations[:children]}.should == [[@c.load(:id=>3, :id2=>4, :name=>'??', :parent_id=>1, :parent_id2=>2)], []]
+    @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children]}}.should == [[[@c.load(:id=>5, :id2=>7, :name=>'?', :parent_id=>3, :parent_id2=>4)]], []]
+    @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children].map{|c3| c3.associations[:children]}}}.should == [[[[]]], []]
+  end
+  
+  it "should eagerly load ancestors" do
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @ds._fetch = [[{:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'}, {:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'}, {:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D'}, {:id=>9, :id2=>10, :parent_id=>nil, :parent_id2=>nil, :name=>'E'}],
+      [{:id=>2, :id2=>3, :name=>'AA', :parent_id=>1, :parent_id2=>2, :x_root_x_0=>2, :x_root_x_1=>3},
+       {:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9, :x_root_x_0=>1, :x_root_x_1=>2}, {:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9, :x_root_x_0=>2, :x_root_x_1=>3},
+       {:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil, :x_root_x_0=>2, :x_root_x_1=>3}, {:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil, :x_root_x_0=>1, :x_root_x_1=>2}]]
+    os = @ds.eager(:ancestors).all
+    sqls = DB.sqls
+    sqls.first.should == "SELECT * FROM nodes"
+    sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x_0, id2 AS x_root_x_1, nodes\.\* FROM nodes WHERE \(\(id, id2\) IN \(\([12], [23]\), \([12], [23]\)\)\) UNION ALL SELECT t\.x_root_x_0, t\.x_root_x_1, nodes\.\* FROM nodes INNER JOIN t ON \(\(t\.parent_id = nodes\.id\) AND \(t\.parent_id2 = nodes\.id2\)\)\) SELECT \* FROM t AS nodes/
+    os.should == [@c.load(:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'), @c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D'), @c.load(:id=>9, :id2=>10, :parent_id=>nil, :parent_id2=>nil, :name=>'E')]
+    os.map{|o| o.ancestors}.should == [[@c.load(:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9), @c.load(:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil)],
+      [@c.load(:id=>2, :id2=>3, :name=>'AA', :parent_id=>1, :parent_id2=>2), @c.load(:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9), @c.load(:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil)],
+      [@c.load(:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9), @c.load(:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil)],
+      []]
+    os.map{|o| o.parent}.should == [@c.load(:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9), @c.load(:id=>2, :id2=>3, :name=>'AA', :parent_id=>1, :parent_id2=>2), @c.load(:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9), nil]
+    os.map{|o| o.parent.parent if o.parent}.should == [@c.load(:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil), @c.load(:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9), @c.load(:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil), nil]
+    os.map{|o| o.parent.parent.parent if o.parent and o.parent.parent}.should == [nil, @c.load(:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>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]
+    DB.sqls.should == []
+  end
+  
+  it "should eagerly load descendants" do
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @ds._fetch = [[{:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'}, {:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'}, {:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D'}],
+      [{:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C', :x_root_x_0=>2, :x_root_x_1=>3}, {:id=>9, :id2=>10, :parent_id=>2, :parent_id2=>3, :name=>'E', :x_root_x_0=>2, :x_root_x_1=>3},
+       {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>6, :x_root_x_1=>7}, {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>2, :x_root_x_1=>3},
+       {:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8, :x_root_x_0=>7, :x_root_x_1=>8}, {:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5, :x_root_x_0=>7, :x_root_x_1=>8}]]
+    os = @ds.eager(:descendants).all
+    sqls = DB.sqls
+    sqls.first.should == "SELECT * FROM nodes"
+    sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x_0, parent_id2 AS x_root_x_1, nodes\.\* FROM nodes WHERE \(\(parent_id, parent_id2\) IN \(\([267], [378]\), \([267], [378]\), \([267], [378]\)\)\) UNION ALL SELECT t\.x_root_x_0, t\.x_root_x_1, nodes\.\* FROM nodes INNER JOIN t ON \(\(t\.id = nodes\.parent_id\) AND \(t\.id2 = nodes\.parent_id2\)\)\) SELECT \* FROM t AS nodes/
+    os.should == [@c.load(:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'), @c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D')]
+    os.map{|o| o.descendants}.should == [[@c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>9, :id2=>10, :parent_id=>2, :parent_id2=>3, :name=>'E'), @c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)],
+      [@c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)],
+      [@c.load(:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8), @c.load(:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5)]]
+    os.map{|o| o.children}.should == [[@c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>9, :id2=>10, :parent_id=>2, :parent_id2=>3, :name=>'E')], [@c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)], [@c.load(:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8)]]
+    os.map{|o1| o1.children.map{|o2| o2.children}}.should == [[[@c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)], []], [[]], [[@c.load(:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5)]]]
+    os.map{|o1| o1.children.map{|o2| o2.children.map{|o3| o3.children}}}.should == [[[[]], []], [[]], [[[]]]]
+    DB.sqls.should == []
+  end
+  
+  it "should eagerly load descendants to a given level" do
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @ds._fetch = [[{:id=>2, :id2=>3, :parent_id=>1, :parent_id=>2, :name=>'AA'}, {:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'}, {:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D'}],
+      [{:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C', :x_root_x_0=>2, :x_root_x_1=>3, :x_level_x=>0}, {:id=>9, :id2=>10, :parent_id=>2, :parent_id2=>3, :name=>'E', :x_root_x_0=>2, :x_root_x_1=>3, :x_level_x=>0},
+       {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>6, :x_root_x_1=>7, :x_level_x=>0}, {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>2, :x_root_x_1=>3, :x_level_x=>1},
+       {:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8, :x_root_x_0=>7, :x_root_x_1=>8, :x_level_x=>0}, {:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5, :x_root_x_0=>7, :x_root_x_1=>8, :x_level_x=>1}]]
+    os = @ds.eager(:descendants=>2).all
+    sqls = DB.sqls
+    sqls.first.should == "SELECT * FROM nodes"
+    sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x_0, parent_id2 AS x_root_x_1, nodes\.\*, 0 AS x_level_x FROM nodes WHERE \(\(parent_id, parent_id2\) IN \(\([267], [378]\), \([267], [378]\), \([267], [378]\)\)\) UNION ALL SELECT t\.x_root_x_0, t\.x_root_x_1, nodes\.\*, \(t\.x_level_x \+ 1\) AS x_level_x FROM nodes INNER JOIN t ON \(\(t\.id = nodes\.parent_id\) AND \(t\.id2 = nodes\.parent_id2\)\) WHERE \(t\.x_level_x < 1\)\) SELECT \* FROM t AS nodes/
+    os.should == [@c.load(:id=>2, :id2=>3, :parent_id=>1, :parent_id=>2, :name=>'AA'), @c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D')]
+    os.map{|o| o.descendants}.should == [[@c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>9, :id2=>10, :parent_id=>2, :parent_id2=>3, :name=>'E'), @c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)],
+      [@c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)],
+      [@c.load(:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8), @c.load(:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5)]]
+    os.map{|o| o.associations[:children]}.should == [[@c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>9, :id2=>10, :parent_id=>2, :parent_id2=>3, :name=>'E')], [@c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)], [@c.load(:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8)]]
+    os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children]}}.should == [[[@c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)], []], [[]], [[@c.load(:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5)]]]
+    os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children].map{|o3| o3.associations[:children]}}}.should == [[[[]], []], [[]], [[nil]]]
+    DB.sqls.should == []
+  end
+end

data/spec/extensions/tree_spec.rb

@@ -138,3 +138,133 @@ describe Sequel::Model, "tree plugin" do
     end
   end
 end
+
+describe Sequel::Model, "tree plugin with composite keys" do
+  def klass(opts={})
+    @db = DB
+    c = Class.new(Sequel::Model(@db[:nodes]))
+    c.class_eval do
+      def self.name; 'Node'; end
+      columns :id, :id2, :name, :parent_id, :parent_id2, :i, :pi
+      set_primary_key [:id, :id2]
+      plugin :tree, opts.merge(:key=>[:parent_id, :parent_id2])
+    end
+    c
+  end
+
+  before do
+    @c = klass
+    @ds = @c.dataset
+    @o = @c.load(:id=>2, :id2=>5, :parent_id=>1, :parent_id2=>6, :name=>'AA', :i=>3, :pi=>4)
+    @db.reset
+  end
+
+  
+  it "should use the correct SQL for lazy associations" do
+    @o.parent_dataset.sql.should == 'SELECT * FROM nodes WHERE ((nodes.id = 1) AND (nodes.id2 = 6)) LIMIT 1'
+    @o.children_dataset.sql.should == 'SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (nodes.parent_id2 = 5))'
+  end
+  
+  it "should have parent_column give an array of symbols of the parent column" do
+    @c.parent_column.should == [:parent_id, :parent_id2]
+  end
+
+  it "should have roots return an array of the tree's roots" do
+    @ds._fetch = [{:id=>1, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}]
+    @c.roots.should == [@c.load(:id=>1, :parent_id=>nil, :parent_id2=>nil, :name=>'r')]
+    @db.sqls.should == ["SELECT * FROM nodes WHERE ((parent_id IS NULL) OR (parent_id2 IS NULL))"]
+  end
+
+  it "should have roots_dataset be a dataset representing the tree's roots" do
+    @c.roots_dataset.sql.should == "SELECT * FROM nodes WHERE ((parent_id IS NULL) OR (parent_id2 IS NULL))"
+  end
+
+  it "should have ancestors return the ancestors of the current node" do
+    @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>5, :parent_id2=>7, :name=>'r'}], [{:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2'}]]
+    @o.ancestors.should == [@c.load(:id=>1, :id2=>6, :parent_id=>5, :parent_id2=>7, :name=>'r'), @c.load(:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2')]
+    sqls = @db.sqls
+    sqls.length.should == 2
+    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].should include(sqls[0])
+    ["SELECT * FROM nodes WHERE ((id = 5) AND (id2 = 7)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 7) AND (id = 5)) LIMIT 1"].should include(sqls[1])
+  end
+
+  it "should have descendants return the descendants of the current node" do
+    @ds._fetch = [[{:id=>3, :id2=>7, :parent_id=>2, :parent_id2=>5, :name=>'r'}, {:id=>4, :id2=>8, :parent_id=>2, :parent_id2=>5, :name=>'r2'}], [{:id=>5, :id2=>9, :parent_id=>4, :parent_id2=>8, :name=>'r3'}], []]
+    @o.descendants.should == [@c.load(:id=>3, :id2=>7, :parent_id=>2, :parent_id2=>5, :name=>'r'), @c.load(:id=>4, :id2=>8, :parent_id=>2, :parent_id2=>5, :name=>'r2'), @c.load(:id=>5, :id2=>9, :parent_id=>4, :parent_id2=>8, :name=>'r3')] 
+    @db.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (nodes.parent_id2 = 5))",
+      "SELECT * FROM nodes WHERE ((nodes.parent_id = 3) AND (nodes.parent_id2 = 7))",
+      "SELECT * FROM nodes WHERE ((nodes.parent_id = 5) AND (nodes.parent_id2 = 9))",
+      "SELECT * FROM nodes WHERE ((nodes.parent_id = 4) AND (nodes.parent_id2 = 8))"]
+  end
+
+  it "should have root return the root of the current node" do
+    @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>5, :parent_id2=>7, :name=>'r'}], [{:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2'}]]
+    @o.root.should == @c.load(:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2')
+    sqls = @db.sqls
+    sqls.length.should == 2
+    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].should include(sqls[0])
+    ["SELECT * FROM nodes WHERE ((id = 5) AND (id2 = 7)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 7) AND (id = 5)) LIMIT 1"].should include(sqls[1])
+  end
+
+  it "should have root? return true for a root node and false for a child node" do
+    @c.load(:parent_id => nil, :parent_id2=>nil).root?.should be_true
+    @c.load(:parent_id => 1, :parent_id2=>nil).root?.should be_true
+    @c.load(:parent_id => nil, :parent_id2=>2).root?.should be_true
+    @c.load(:parent_id => 1, :parent_id2=>2).root?.should be_false
+  end
+
+  it "should have root? return false for an new node" do
+    @c.new.root?.should be_false
+  end
+
+  it "should have self_and_siblings return the children of the current node's parent" do
+    @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>3, :parent_id2=>7, :name=>'r'}], [{:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2'}, @o.values.dup]]
+    @o.self_and_siblings.should == [@c.load(:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2'), @o] 
+    sqls = @db.sqls
+    sqls.length.should == 2
+    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].should include(sqls[0])
+    sqls[1].should == "SELECT * FROM nodes WHERE ((nodes.parent_id = 1) AND (nodes.parent_id2 = 6))"
+  end
+
+  it "should have siblings return the children of the current node's parent, except for the current node" do
+    @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>3, :parent_id2=>7, :name=>'r'}], [{:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2'}, @o.values.dup]]
+    @o.siblings.should == [@c.load(:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2')] 
+    sqls = @db.sqls
+    sqls.length.should == 2
+    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].should include(sqls[0])
+    sqls[1].should == "SELECT * FROM nodes WHERE ((nodes.parent_id = 1) AND (nodes.parent_id2 = 6))"
+  end
+
+  describe ":single_root option" do
+    before do
+      @c = klass(:single_root => true)
+    end
+
+    it "prevents creating a second root" do
+      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}]
+      lambda { @c.create }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>1, :parent_id2=>nil, :name=>'r'}]
+      lambda { @c.create(:parent_id2=>1) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>2, :name=>'r'}]
+      lambda { @c.create(:parent_id=>2) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+    end
+
+    it "errors when promoting an existing record to a second root" do
+      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}]
+      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id => nil, :parent_id2=>nil) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>1, :parent_id2=>nil, :name=>'r'}]
+      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id => nil) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>2, :name=>'r'}]
+      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id2 => nil) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+    end
+
+    it "allows updating existing root" do
+      @c.dataset._fetch = {:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}
+      lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
+      @c.dataset._fetch = {:id=>1, :id2=>6, :parent_id=>1, :parent_id2=>nil, :name=>'r'}
+      lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
+      @c.dataset._fetch = {:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>2, :name=>'r'}
+      lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
+    end
+  end
+end