tdiary 5.0.6 → 5.0.7

data/vendor/bundle/gems/sequel-5.3.0/spec/extensions/rcte_tree_spec.rb

@@ -0,0 +1,381 @@
+require_relative "spec_helper"
+
+describe Sequel::Model, "rcte_tree" do
+  before do
+    @db = Sequel.mock
+    @db.extend_datasets do
+      def supports_cte?(*) true end
+    end
+    @c = Class.new(Sequel::Model(@db[:nodes]))
+    @c.class_eval do
+      def self.name; 'Node'; end
+      columns :id, :name, :parent_id, :i, :pi
+    end
+    @ds = @c.dataset
+    @o = @c.load(:id=>2, :parent_id=>1, :name=>'AA', :i=>3, :pi=>4)
+    @db.sqls
+  end
+
+  it "should define the correct associations" do
+    @c.plugin :rcte_tree
+    @c.associations.sort_by{|x| x.to_s}.must_equal [: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}.must_equal [:as, :cs, :ds, :p]
+  end
+
+  it "should use the correct SQL for lazy associations" do
+    @c.plugin :rcte_tree
+    @o.parent_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1'
+    @o.children_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.parent_id = 2)'
+    @o.ancestors_dataset.sql.must_equal '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 AS nodes'
+    @o.descendants_dataset.sql.must_equal '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 AS nodes'
+  end
+  
+  it "should use the correct SQL for lazy associations when recursive CTEs require column aliases" do
+    @c.dataset = @c.dataset.with_extend{def recursive_cte_requires_column_aliases?; true end}
+    @c.plugin :rcte_tree
+    @o.parent_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1'
+    @o.children_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.parent_id = 2)'
+    @o.ancestors_dataset.sql.must_equal 'WITH t(id, name, parent_id, i, pi) AS (SELECT id, name, parent_id, i, pi FROM nodes WHERE (id = 1) UNION ALL SELECT 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'
+    @o.descendants_dataset.sql.must_equal '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 = @c.dataset.with_extend{def recursive_cte_requires_column_aliases?; true end}
+    @c.plugin :rcte_tree
+    @c.dataset = @c.dataset.with_fetch([[{:id=>1, :name=>'A', :parent_id=>3}]])
+    @c.eager(:ancestors).all
+    @db.sqls.must_equal ["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"]
+
+    @c.dataset = @c.dataset.with_fetch([[{:id=>1, :name=>'A', :parent_id=>3}]])
+    @c.eager(:descendants).all
+    @db.sqls.must_equal ["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.must_equal 'SELECT * FROM nodes WHERE (nodes.i = 4) ORDER BY name LIMIT 1'
+    @o.cs_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.pi = 3) ORDER BY name'
+    @o.as_dataset.sql.must_equal '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 AS nodes ORDER BY name'
+    @o.ds_dataset.sql.must_equal '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 AS nodes ORDER BY name'
+  end
+
+  it "should use the correct SQL for lazy associations with :conditions option" do
+    @c.plugin :rcte_tree, :conditions => {:i => 1}
+    @o.parent_dataset.sql.must_equal 'SELECT * FROM nodes WHERE ((i = 1) AND (nodes.id = 1)) LIMIT 1'
+    @o.children_dataset.sql.must_equal 'SELECT * FROM nodes WHERE ((i = 1) AND (nodes.parent_id = 2))'
+    @o.ancestors_dataset.sql.must_equal 'WITH t AS (SELECT * FROM nodes WHERE ((id = 1) AND (i = 1)) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.parent_id = nodes.id) WHERE (i = 1)) SELECT * FROM t AS nodes WHERE (i = 1)'
+    @o.descendants_dataset.sql.must_equal 'WITH t AS (SELECT * FROM nodes WHERE ((parent_id = 2) AND (i = 1)) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.id = nodes.parent_id) WHERE (i = 1)) SELECT * FROM t AS nodes WHERE (i = 1)'
+  end
+  
+  it "should add all parent associations when lazily loading ancestors" do
+    @c.plugin :rcte_tree
+    @c.dataset = @c.dataset.with_fetch([[{:id=>1, :name=>'A', :parent_id=>3}, {:id=>4, :name=>'B', :parent_id=>nil}, {:id=>3, :name=>'?', :parent_id=>4}]])
+    @o.ancestors.must_equal [@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].must_equal @c.load(:id=>1, :name=>'A', :parent_id=>3)
+    @o.associations[:parent].associations[:parent].must_equal @c.load(:id=>3, :name=>'?', :parent_id=>4)
+    @o.associations[:parent].associations[:parent].associations[:parent].must_equal @c.load(:id=>4, :name=>'B', :parent_id=>nil)
+    @o.associations[:parent].associations[:parent].associations[:parent].associations.fetch(:parent, 1).must_be_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}
+    @c.dataset = @c.dataset.with_fetch([[{:i=>4, :name=>'A', :pi=>5}, {:i=>6, :name=>'B', :pi=>nil}, {:i=>5, :name=>'?', :pi=>6}]])
+    @o.as.must_equal [@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].must_equal @c.load(:i=>4, :name=>'A', :pi=>5)
+    @o.associations[:p].associations[:p].must_equal @c.load(:i=>5, :name=>'?', :pi=>6)
+    @o.associations[:p].associations[:p].associations[:p].must_equal @c.load(:i=>6, :name=>'B', :pi=>nil)
+    @o.associations[:p].associations[:p].associations[:p].associations.fetch(:p, 1).must_be_nil
+  end
+  
+  it "should add all parent and children associations when lazily loading descendants" do
+    @c.plugin :rcte_tree
+    @c.dataset = @c.dataset.with_fetch([[{: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.must_equal [@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].must_equal [@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]}.must_equal [[@c.load(:id=>3, :name=>'??', :parent_id=>1)], []]
+    @o.associations[:children].map{|c1| c1.associations[:parent]}.must_equal [@o, @o]
+    @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children]}}.must_equal [[[@c.load(:id=>5, :name=>'?', :parent_id=>3)]], []]
+    @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:parent]}}.must_equal [[@o.children.first], []]
+    @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children].map{|c3| c3.associations[:children]}}}.must_equal [[[[]]], []]
+    @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children].map{|c3| c3.associations[:parent]}}}.must_equal [[[@o.children.first.children.first]], []]
+  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}
+    @c.dataset = @c.dataset.with_fetch([[{:i=>7, :name=>'??', :pi=>5}, {:i=>5, :name=>'A', :pi=>3}, {:i=>6, :name=>'B', :pi=>3}, {:i=>8, :name=>'?', :pi=>7}]])
+    @o.ds.must_equal [@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].must_equal [@c.load(:i=>5, :name=>'A', :pi=>3), @c.load(:i=>6, :name=>'B', :pi=>3)]
+    @o.associations[:cs].map{|c1| c1.associations[:cs]}.must_equal [[@c.load(:i=>7, :name=>'??', :pi=>5)], []]
+    @o.associations[:cs].map{|c1| c1.associations[:cs].map{|c2| c2.associations[:cs]}}.must_equal [[[@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]}}}.must_equal [[[[]]], []]
+  end
+  
+  it "should eagerly load ancestors" do
+    @c.plugin :rcte_tree
+    @ds = @c.dataset = @c.dataset.with_fetch([[{: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
+    @db.sqls.must_equal ["SELECT * FROM nodes",
+      'WITH t AS (SELECT id AS x_root_x, nodes.* FROM nodes WHERE (id IN (1, 2)) UNION ALL SELECT t.x_root_x, nodes.* FROM nodes INNER JOIN t ON (t.parent_id = nodes.id)) SELECT * FROM t AS nodes']
+    os.must_equal [@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}.must_equal [[@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}.must_equal [@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}.must_equal [@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}.must_equal [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}.must_equal [nil, nil, nil, nil]
+    @db.sqls.must_equal []
+  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 = @c.dataset = @c.dataset.with_fetch([[{: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
+    @db.sqls.must_equal ["SELECT * FROM nodes",
+      'WITH cte AS (SELECT i AS kal, nodes.* FROM nodes WHERE (i IN (1, 2)) UNION ALL SELECT cte.kal, nodes.* FROM nodes INNER JOIN cte ON (cte.pi = nodes.i)) SELECT * FROM cte AS nodes']
+    os.must_equal [@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}.must_equal [[@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}.must_equal [@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}.must_equal [@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}.must_equal [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}.must_equal [nil, nil, nil, nil]
+  end
+
+  it "should eagerly load ancestors respecting association option :conditions" do
+    @c.plugin :rcte_tree, :conditions => {:i => 1}
+    @ds = @c.dataset = @c.dataset.with_fetch([[{: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}]])
+    @ds.eager(:ancestors).all
+    @db.sqls.must_equal ["SELECT * FROM nodes",
+      'WITH t AS (SELECT id AS x_root_x, nodes.* FROM nodes WHERE ((id IN (1, 2)) AND (i = 1)) UNION ALL SELECT t.x_root_x, nodes.* FROM nodes INNER JOIN t ON (t.parent_id = nodes.id) WHERE (i = 1)) SELECT * FROM t AS nodes WHERE (i = 1)']
+  end
+
+  it "should eagerly load descendants" do
+    @c.plugin :rcte_tree
+    @ds = @c.dataset = @c.dataset.with_fetch([[{: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
+    @db.sqls.must_equal ["SELECT * FROM nodes",
+      'WITH t AS (SELECT parent_id AS x_root_x, nodes.* FROM nodes WHERE (parent_id IN (2, 6, 7)) UNION ALL SELECT t.x_root_x, nodes.* FROM nodes INNER JOIN t ON (t.id = nodes.parent_id)) SELECT * FROM t AS nodes']
+    os.must_equal [@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}.must_equal [[@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}.must_equal [[@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}}.must_equal [[[@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.parent}}.must_equal [[os[0], os[0]], [os[1]], [os[2]]]
+    os.map{|o1| o1.children.map{|o2| o2.children.map{|o3| o3.children}}}.must_equal [[[[]], []], [[]], [[[]]]]
+    os.map{|o1| o1.children.map{|o2| o2.children.map{|o3| o3.parent}}}.must_equal [[[os[0].children[0]], []], [[]], [[os[2].children[0]]]]
+    @db.sqls.must_equal []
+  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 = @c.dataset = @c.dataset.with_fetch([[{: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
+    @db.sqls.must_equal ["SELECT * FROM nodes",
+      'WITH cte AS (SELECT pi AS kal, nodes.* FROM nodes WHERE (pi IN (2, 6, 7)) UNION ALL SELECT cte.kal, nodes.* FROM nodes INNER JOIN cte ON (cte.i = nodes.pi)) SELECT * FROM cte AS nodes']
+    os.must_equal [@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}.must_equal [[@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}.must_equal [[@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}}.must_equal [[[@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}}}.must_equal [[[[]], []], [[]], [[[]]]]
+    @db.sqls.must_equal []
+  end
+  
+  it "should eagerly load descendants to a given level" do
+    @c.plugin :rcte_tree
+    @ds = @c.dataset = @c.dataset.with_fetch([[{: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
+    @db.sqls.must_equal ["SELECT * FROM nodes",
+      'WITH t AS (SELECT parent_id AS x_root_x, nodes.*, CAST(0 AS integer) AS x_level_x FROM nodes WHERE (parent_id IN (2, 6, 7)) 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 AS nodes']
+    os.must_equal [@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}.must_equal [[@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]}.must_equal [[@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]}}.must_equal [[[@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]}}}.must_equal [[[[]], []], [[]], [[nil]]]
+    @db.sqls.must_equal []
+  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 = @c.dataset = @c.dataset.with_fetch([[{: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
+    @db.sqls.must_equal ["SELECT * FROM nodes",
+      'WITH cte AS (SELECT pi AS kal, nodes.*, CAST(0 AS integer) AS lal FROM nodes WHERE (pi IN (2, 6, 7)) 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 AS nodes']
+    os.must_equal [@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}.must_equal [[@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]}.must_equal [[@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]}}.must_equal [[[@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]}}}.must_equal [[[[]], []], [[]], [[nil]]]
+    @db.sqls.must_equal []
+  end
+
+  it "should eagerly load descendants respecting association option :conditions" do
+    @c.plugin :rcte_tree, :conditions => {:i => 1}
+    @ds = @c.dataset = @c.dataset.with_fetch([[{: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}]])
+    @ds.eager(:descendants).all
+    @db.sqls.must_equal ["SELECT * FROM nodes",
+      'WITH t AS (SELECT parent_id AS x_root_x, nodes.* FROM nodes WHERE ((parent_id IN (2, 6, 7)) 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
+    @db = Sequel.mock
+    @db.extend_datasets do
+      def supports_cte?(*) true end
+    end
+    @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.sqls
+  end
+
+  it "should use the correct SQL for lazy associations" do
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @o.parent_dataset.sql.must_equal 'SELECT * FROM nodes WHERE ((nodes.id = 1) AND (nodes.id2 = 6)) LIMIT 1'
+    @o.children_dataset.sql.must_equal 'SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (nodes.parent_id2 = 5))'
+    @o.ancestors_dataset.sql.must_equal '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.must_equal '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 = @c.dataset.with_extend{def recursive_cte_requires_column_aliases?; true end}
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @o.ancestors_dataset.sql.must_equal '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.must_equal '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 = @c.dataset.with_extend{def recursive_cte_requires_column_aliases?; true end}
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @c.dataset = @c.dataset.with_fetch([[{:id=>1, :id2=>2, :name=>'A', :parent_id=>3, :parent_id2=>4}]])
+    @c.eager(:ancestors).all
+    @db.sqls.must_equal ["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"]
+
+    @c.dataset = @c.dataset.with_fetch([[{:id=>1, :id2=>2, :name=>'A', :parent_id=>3, :parent_id2=>4}]])
+    @c.eager(:descendants).all
+    @db.sqls.must_equal ["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]
+    @c.dataset = @c.dataset.with_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.must_equal [@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].must_equal @c.load(:id=>1, :id2=>6, :name=>'A', :parent_id=>3, :parent_id2=>5)
+    @o.associations[:parent].associations[:parent].must_equal @c.load(:id=>3, :id2=>5, :name=>'?', :parent_id=>4, :parent_id2=>8)
+    @o.associations[:parent].associations[:parent].associations[:parent].must_equal @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).must_be_nil
+  end
+  
+  it "should add all children associations when lazily loading descendants" do
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @c.dataset = @c.dataset.with_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.must_equal [@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].must_equal [@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]}.must_equal [[@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]}}.must_equal [[[@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]}}}.must_equal [[[[]]], []]
+  end
+  
+  it "should eagerly load ancestors" do
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @ds = @c.dataset = @c.dataset.with_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
+    @db.sqls.must_equal ["SELECT * FROM nodes",
+      'WITH t AS (SELECT id AS x_root_x_0, id2 AS x_root_x_1, nodes.* FROM nodes WHERE ((id, id2) IN ((1, 2), (2, 3))) 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.must_equal [@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}.must_equal [[@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}.must_equal [@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}.must_equal [@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}.must_equal [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}.must_equal [nil, nil, nil, nil]
+    @db.sqls.must_equal []
+  end
+  
+  it "should eagerly load descendants" do
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @ds = @c.dataset = @c.dataset.with_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
+    @db.sqls.must_equal ["SELECT * FROM nodes",
+      '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 ((2, 3), (6, 7), (7, 8))) 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.must_equal [@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}.must_equal [[@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}.must_equal [[@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}}.must_equal [[[@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}}}.must_equal [[[[]], []], [[]], [[[]]]]
+    @db.sqls.must_equal []
+  end
+  
+  it "should eagerly load descendants to a given level" do
+    @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
+    @ds = @c.dataset = @c.dataset.with_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, :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
+    @db.sqls.must_equal ["SELECT * FROM nodes",
+      'WITH t AS (SELECT parent_id AS x_root_x_0, parent_id2 AS x_root_x_1, nodes.*, CAST(0 AS integer) AS x_level_x FROM nodes WHERE ((parent_id, parent_id2) IN ((2, 3), (6, 7), (7, 8))) 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.must_equal [@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}.must_equal [[@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]}.must_equal [[@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]}}.must_equal [[[@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]}}}.must_equal [[[[]], []], [[]], [[nil]]]
+    @db.sqls.must_equal []
+  end
+end

data/vendor/bundle/gems/sequel-5.3.0/spec/extensions/schema_dumper_spec.rb

@@ -0,0 +1,868 @@
+require_relative "spec_helper"
+
+describe "Sequel::Schema::CreateTableGenerator dump methods" do
+  before do
+    @d = Sequel::Database.new.extension(:schema_dumper)
+    @g = Sequel::Schema::CreateTableGenerator
+  end
+
+  it "should allow the same table information to be converted to a string for evaling inside of another instance with the same result" do
+    g = @g.new(@d) do
+      Integer :a
+      varchar :b
+      column :dt, DateTime
+      column :vc, :varchar
+      primary_key :c
+      foreign_key :d, :a
+      foreign_key :e
+      foreign_key [:d, :e], :name=>:cfk
+      constraint :blah, "a=1"
+      check :a=>1
+      unique [:e]
+      index :a
+      index [:c, :e]
+      index [:b, :c], :type=>:hash
+      index [:d], :unique=>true
+      spatial_index :a
+      full_text_index [:b, :c]
+    end
+    g2 = @g.new(@d) do
+      instance_eval(g.dump_columns, __FILE__, __LINE__)
+      instance_eval(g.dump_constraints, __FILE__, __LINE__)
+      instance_eval(g.dump_indexes, __FILE__, __LINE__)
+    end
+    g.columns.must_equal g2.columns
+    g.constraints.must_equal g2.constraints
+    g.indexes.must_equal g2.indexes
+  end
+
+  it "should respect :keep_order option to primary_key" do
+    g = @g.new(@d) do
+      Integer :a
+      primary_key :c, :keep_order=>true
+    end
+    g2 = @g.new(@d) do
+      instance_eval(g.dump_columns, __FILE__, __LINE__)
+    end
+    g.columns.must_equal g2.columns
+  end
+
+  it "should allow dumping indexes as separate add_index and drop_index methods" do
+    g = @g.new(@d) do
+      index :a
+      index [:c, :e], :name=>:blah
+      index [:b, :c], :unique=>true
+    end
+
+    g.dump_indexes(:add_index=>:t).must_equal((<<END_CODE).strip)
+add_index :t, [:a]
+add_index :t, [:c, :e], :name=>:blah
+add_index :t, [:b, :c], :unique=>true
+END_CODE
+
+    g.dump_indexes(:drop_index=>:t).must_equal((<<END_CODE).strip)
+drop_index :t, [:b, :c], :unique=>true
+drop_index :t, [:c, :e], :name=>:blah
+drop_index :t, [:a]
+END_CODE
+  end
+
+  it "should raise an error if you try to dump a Generator that uses a constraint with a proc" do
+    proc{@g.new(@d){check{a>1}}.dump_constraints}.must_raise(Sequel::Error)
+  end
+end
+
+describe "Sequel::Database dump methods" do
+  before do
+    @d = Sequel::Database.new.extension(:schema_dumper)
+    def @d.tables(o) o[:schema] ? [o[:schema]] : [:t1, :t2] end
+    def @d.schema(t, *o)
+      v = case t
+      when :t1, 't__t1', Sequel.identifier(:t__t1)
+        [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true, :allow_null=>false}],
+         [:c2, {:db_type=>'varchar(20)', :allow_null=>true}]]
+      when :t2
+        [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>false}],
+         [:c2, {:db_type=>'numeric', :primary_key=>true, :allow_null=>false}]]
+      when :t3
+        [[:c2, {:db_type=>'varchar(20)', :allow_null=>true}],
+         [:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true, :allow_null=>false}]]
+      when :t5
+        [[:c1, {:db_type=>'blahblah', :allow_null=>true}]]
+      end
+
+      if o.first.is_a?(Hash) && o.first[:schema]
+        v.last.last[:db_type] = o.first[:schema]
+      end
+
+      v
+    end
+  end
+
+  it "should support dumping table with :schema option" do
+    @d.dump_table_schema(:t1, :schema=>'varchar(15)').must_equal "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>15\nend"
+  end
+
+  it "should support dumping table schemas as create_table method calls" do
+    @d.dump_table_schema(:t1).must_equal "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+  end
+
+  it "should support dumping table schemas when given a string" do
+    @d.dump_table_schema('t__t1').must_equal "create_table(\"t__t1\") do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+  end
+
+  it "should support dumping table schemas when given an identifier" do
+    @d.dump_table_schema(Sequel.identifier(:t__t1)).must_equal "create_table(Sequel::SQL::Identifier.new(:t__t1)) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+  end
+
+  it "should dump non-Integer primary key columns with explicit :type" do
+    def @d.schema(*s) [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]] end
+    @d.dump_table_schema(:t6).must_equal "create_table(:t6) do\n  primary_key :c1, :type=>:Bignum\nend"
+  end
+
+  it "should dump non-Integer primary key columns with explicit :type when using :same_db=>true" do
+    def @d.schema(*s) [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]] end
+    @d.dump_table_schema(:t6, :same_db=>true).must_equal "create_table(:t6) do\n  primary_key :c1, :type=>:Bignum\nend"
+  end
+
+  it "should dump auto incrementing primary keys with :keep_order option if they are not first" do
+    @d.dump_table_schema(:t3).must_equal "create_table(:t3) do\n  String :c2, :size=>20\n  primary_key :c1, :keep_order=>true\nend"
+  end
+
+  it "should handle foreign keys" do
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :allow_null=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}] end
+    @d.dump_table_schema(:t6).must_equal "create_table(:t6) do\n  foreign_key :c1, :t2, :key=>[:c2]\nend"
+  end
+
+  it "should handle primary keys that are also foreign keys" do
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}] end
+    @d.dump_table_schema(:t6).must_equal((<<OUTPUT).chomp)
+create_table(:t6) do
+  primary_key :c1, :table=>:t2, :key=>[:c2]
+end
+OUTPUT
+  end
+
+  it "should handle foreign key options" do
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :allow_null=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}] end
+    @d.dump_table_schema(:t6).must_equal((<<OUTPUT).chomp)
+create_table(:t6) do
+  foreign_key :c1, :t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true
+end
+OUTPUT
+  end
+
+  it "should handle foreign key options in the primary key" do
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}] end
+    @d.dump_table_schema(:t6).must_equal((<<OUTPUT).chomp)
+create_table(:t6) do
+  primary_key :c1, :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true
+end
+OUTPUT
+  end
+
+  it "should omit foreign key options that are the same as defaults" do
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :allow_null=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}] end
+    @d.dump_table_schema(:t6).must_equal((<<OUTPUT).chomp)
+create_table(:t6) do
+  foreign_key :c1, :t2, :key=>[:c2]
+end
+OUTPUT
+  end
+
+  it "should omit foreign key options that are the same as defaults in the primary key" do
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}] end
+    @d.dump_table_schema(:t6).must_equal((<<OUTPUT).chomp)
+create_table(:t6) do
+  primary_key :c1, :table=>:t2, :key=>[:c2]
+end
+OUTPUT
+  end
+
+  it "should dump primary key columns with explicit type equal to the database type when :same_db option is passed" do
+    def @d.schema(*s) [[:c1, {:db_type=>'somedbspecifictype', :primary_key=>true, :allow_null=>false}]] end
+    @d.dump_table_schema(:t7, :same_db => true).must_equal "create_table(:t7) do\n  column :c1, \"somedbspecifictype\", :null=>false\n  \n  primary_key [:c1]\nend"
+  end
+
+  it "should use a composite primary_key calls if there is a composite primary key" do
+    @d.dump_table_schema(:t2).must_equal "create_table(:t2) do\n  Integer :c1, :null=>false\n  BigDecimal :c2, :null=>false\n  \n  primary_key [:c1, :c2]\nend"
+  end
+
+  it "should use a composite foreign_key calls if there is a composite foreign key" do
+    def @d.schema(*s) [[:c1, {:db_type=>'integer'}], [:c2, {:db_type=>'integer'}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(*s) [{:columns=>[:c1, :c2], :table=>:t2, :key=>[:c3, :c4]}] end
+    @d.dump_table_schema(:t1).must_equal "create_table(:t1) do\n  Integer :c1\n  Integer :c2\n  \n  foreign_key [:c1, :c2], :t2, :key=>[:c3, :c4]\nend"
+  end
+
+  it "should include index information if available" do
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_table_schema(:t1).must_equal "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:i1\n  index [:c2, :c1], :unique=>true\nend"
+  end
+
+  it "should support dumping the whole database as a migration with a :schema option" do
+    @d.dump_schema_migration(:schema=>'t__t1').must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    create_table("t__t1") do
+      primary_key :c1
+      String :c2
+    end
+  end
+end
+END_MIG
+  end
+
+  it "should support dumping the whole database as a migration" do
+    @d.dump_schema_migration.must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    create_table(:t1) do
+      primary_key :c1
+      String :c2, :size=>20
+    end
+    
+    create_table(:t2) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+    end
+  end
+end
+END_MIG
+  end
+
+  it "should sort table names when dumping a migration" do
+    def @d.tables(o) [:t2, :t1] end
+    @d.dump_schema_migration.must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    create_table(:t1) do
+      primary_key :c1
+      String :c2, :size=>20
+    end
+    
+    create_table(:t2) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+    end
+  end
+end
+END_MIG
+  end
+
+  it "should sort table names topologically when dumping a migration with foreign keys" do
+    def @d.tables(o) [:t1, :t2] end
+    def @d.schema(t, *o)
+      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true}]]
+    end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t)
+      t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
+    end
+    @d.dump_schema_migration.must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    create_table(:t2) do
+      primary_key :c1
+    end
+    
+    create_table(:t1) do
+      foreign_key :c2, :t2, :key=>[:c1]
+    end
+  end
+end
+END_MIG
+  end
+
+  it "should handle circular dependencies when dumping a migration with foreign keys" do
+    def @d.tables(o) [:t1, :t2] end
+    def @d.schema(t, *o)
+      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer'}]]
+    end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t)
+      t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : [{:columns=>[:c1], :table=>:t1, :key=>[:c2]}]
+    end
+    @d.dump_schema_migration.must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    create_table(:t1) do
+      Integer :c2
+    end
+    
+    create_table(:t2) do
+      foreign_key :c1, :t1, :key=>[:c2]
+    end
+    
+    alter_table(:t1) do
+      add_foreign_key [:c2], :t2, :key=>[:c1]
+    end
+  end
+end
+END_MIG
+  end
+
+  it "should sort topologically even if the database raises an error when trying to parse foreign keys for a non-existent table" do
+    def @d.tables(o) [:t1, :t2] end
+    def @d.schema(t, *o)
+      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true}]]
+    end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t)
+      raise Sequel::DatabaseError unless [:t1, :t2].include?(t)
+      t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
+    end
+    @d.dump_schema_migration.must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    create_table(:t2) do
+      primary_key :c1
+    end
+    
+    create_table(:t1) do
+      foreign_key :c2, :t2, :key=>[:c1]
+    end
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :same_db option to not convert types" do
+    @d.dump_table_schema(:t1, :same_db=>true).must_equal "create_table(:t1) do\n  primary_key :c1\n  column :c2, \"varchar(20)\"\nend"
+    @d.dump_schema_migration(:same_db=>true).must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    create_table(:t1) do
+      primary_key :c1
+      column :c2, "varchar(20)"
+    end
+    
+    create_table(:t2) do
+      column :c1, "integer", :null=>false
+      column :c2, "numeric", :null=>false
+      
+      primary_key [:c1, :c2]
+    end
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => false option to not include names of indexes" do
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_table_schema(:t1, :index_names=>false).must_equal "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1]\n  index [:c2, :c1], :unique=>true\nend"
+    @d.dump_schema_migration(:index_names=>false).must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    create_table(:t1, :ignore_index_errors=>true) do
+      primary_key :c1
+      String :c2, :size=>20
+      
+      index [:c1]
+      index [:c2, :c1], :unique=>true
+    end
+    
+    create_table(:t2, :ignore_index_errors=>true) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+      
+      index [:c1]
+      index [:c2, :c1], :unique=>true
+    end
+  end
+end
+END_MIG
+  end
+  
+  it "should make :index_names => :namespace option a noop if there is a  global index namespace" do
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_table_schema(:t1, :index_names=>:namespace).must_equal "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:i1\n  index [:c2, :c1]\nend"
+    @d.dump_schema_migration(:index_names=>:namespace).must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    create_table(:t1, :ignore_index_errors=>true) do
+      primary_key :c1
+      String :c2, :size=>20
+      
+      index [:c1], :name=>:i1
+      index [:c2, :c1]
+    end
+    
+    create_table(:t2, :ignore_index_errors=>true) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+      
+      index [:c1], :name=>:i1
+      index [:c2, :c1], :name=>:t1_c2_c1_index
+    end
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => :namespace option to include names of indexes with prepended table name if there is no global index namespace" do
+    def @d.global_index_namespace?; false end
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_table_schema(:t1, :index_names=>:namespace).must_equal "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:t1_i1\n  index [:c2, :c1]\nend"
+    @d.dump_schema_migration(:index_names=>:namespace).must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    create_table(:t1, :ignore_index_errors=>true) do
+      primary_key :c1
+      String :c2, :size=>20
+      
+      index [:c1], :name=>:t1_i1
+      index [:c2, :c1]
+    end
+    
+    create_table(:t2, :ignore_index_errors=>true) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+      
+      index [:c1], :name=>:t2_i1
+      index [:c2, :c1], :name=>:t2_t1_c2_c1_index
+    end
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :indexes => false option to not include indexes" do
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_table_schema(:t1, :indexes=>false).must_equal "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+    @d.dump_schema_migration(:indexes=>false).must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    create_table(:t1) do
+      primary_key :c1
+      String :c2, :size=>20
+    end
+    
+    create_table(:t2) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+    end
+  end
+end
+END_MIG
+  end
+
+  it "should have :indexes => false option disable foreign keys as well when dumping a whole migration" do
+    def @d.foreign_key_list(t)
+      t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
+    end
+    @d.dump_schema_migration(:indexes=>false).wont_match(/foreign_key/)
+  end
+
+  it "should have :foreign_keys option override :indexes => false disabling of foreign keys" do
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t)
+      t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
+    end
+    @d.dump_schema_migration(:indexes=>false, :foreign_keys=>true).must_equal(<<OUTPUT)
+Sequel.migration do
+  change do
+    create_table(:t2) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+    end
+    
+    create_table(:t1) do
+      primary_key :c1
+      foreign_key :c2, :t2, :type=>String, :size=>20, :key=>[:c1]
+    end
+  end
+end
+OUTPUT
+  end
+
+  it "should support dumping just indexes as a migration" do
+    def @d.tables(o) [:t1] end
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_indexes_migration.must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    add_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
+    add_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => false option to not include names of indexes when dumping just indexes as a migration" do
+    def @d.tables(o) [:t1] end
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_indexes_migration(:index_names=>false).must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    add_index :t1, [:c1], :ignore_errors=>true
+    add_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => :namespace option be a noop if there is a global index namespace" do
+    def @d.tables(o) [:t1, :t2] end
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_indexes_migration(:index_names=>:namespace).must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    add_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
+    add_index :t1, [:c2, :c1], :ignore_errors=>true
+    
+    add_index :t2, [:c1], :ignore_errors=>true, :name=>:i1
+    add_index :t2, [:c2, :c1], :ignore_errors=>true, :name=>:t1_c2_c1_index
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => :namespace option to include names of indexes with prepended table name when dumping just indexes as a migration if there is no global index namespace" do
+    def @d.global_index_namespace?; false end
+    def @d.tables(o) [:t1, :t2] end
+    def @d.supports_index_parsing?; true end
+    def @d.indexes(t)
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_indexes_migration(:index_names=>:namespace).must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    add_index :t1, [:c1], :ignore_errors=>true, :name=>:t1_i1
+    add_index :t1, [:c2, :c1], :ignore_errors=>true
+    
+    add_index :t2, [:c1], :ignore_errors=>true, :name=>:t2_i1
+    add_index :t2, [:c2, :c1], :ignore_errors=>true, :name=>:t2_t1_c2_c1_index
+  end
+end
+END_MIG
+  end
+
+  it "should handle missing index parsing support when dumping index migration" do
+    def @d.tables(o) [:t1] end
+    @d.dump_indexes_migration.must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    
+  end
+end
+END_MIG
+  end
+
+  it "should handle missing foreign key parsing support when dumping foreign key migration" do
+    def @d.tables(o) [:t1] end
+    @d.dump_foreign_key_migration.must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    
+  end
+end
+END_MIG
+  end
+
+  it "should support dumping just foreign_keys as a migration" do
+    def @d.tables(o) [:t1, :t2, :t3] end
+    def @d.schema(t, *o)
+      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer'}]]
+    end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t, *a)
+      case t
+      when :t1
+        [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}]
+      when :t2
+        [{:columns=>[:c1, :c3], :table=>:t1, :key=>[:c2, :c4]}]
+      else
+        []
+      end
+    end
+    @d.dump_foreign_key_migration.must_equal <<-END_MIG
+Sequel.migration do
+  change do
+    alter_table(:t1) do
+      add_foreign_key [:c2], :t2, :key=>[:c1]
+    end
+    
+    alter_table(:t2) do
+      add_foreign_key [:c1, :c3], :t1, :key=>[:c2, :c4]
+    end
+  end
+end
+END_MIG
+  end
+
+  it "should handle not null values and defaults" do
+    def @d.schema(*s) [[:c1, {:db_type=>'date', :default=>"'now()'", :allow_null=>true}], [:c2, {:db_type=>'datetime', :allow_null=>false}]] end
+    @d.dump_table_schema(:t3).must_equal "create_table(:t3) do\n  Date :c1\n  DateTime :c2, :null=>false\nend"
+  end
+  
+  it "should handle converting common defaults" do
+    def @d.schema(t, *os)
+      s = [[:c1, {:db_type=>'boolean', :default=>"false", :type=>:boolean, :allow_null=>true}],
+       [:c2, {:db_type=>'varchar', :default=>"'blah'", :type=>:string, :allow_null=>true}],
+       [:c3, {:db_type=>'integer', :default=>"-1", :type=>:integer, :allow_null=>true}],
+       [:c4, {:db_type=>'float', :default=>"1.0", :type=>:float, :allow_null=>true}],
+       [:c5, {:db_type=>'decimal', :default=>"100.50", :type=>:decimal, :allow_null=>true}],
+       [:c6, {:db_type=>'blob', :default=>"'blah'", :type=>:blob, :allow_null=>true}],
+       [:c7, {:db_type=>'date', :default=>"'2008-10-29'", :type=>:date, :allow_null=>true}],
+       [:c8, {:db_type=>'datetime', :default=>"'2008-10-29 10:20:30'", :type=>:datetime, :allow_null=>true}],
+       [:c9, {:db_type=>'time', :default=>"'10:20:30'", :type=>:time, :allow_null=>true}],
+       [:c10, {:db_type=>'foo', :default=>"'6 weeks'", :type=>nil, :allow_null=>true}],
+       [:c11, {:db_type=>'date', :default=>"CURRENT_DATE", :type=>:date, :allow_null=>true}],
+       [:c12, {:db_type=>'timestamp', :default=>"now()", :type=>:datetime, :allow_null=>true}]]
+      s.each{|_, c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
+      s
+    end
+    e = RUBY_VERSION >= '2.4' ? 'e' : 'E'
+    @d.dump_table_schema(:t4).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>BigDecimal.new(\"0.1005#{e}3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.new(2008, 10, 29)\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  Time :c9, :default=>Sequel::SQLTime.parse(\"10:20:30.0\"), :only_time=>true\n  String :c10\n  Date :c11, :default=>Sequel::CURRENT_DATE\n  DateTime :c12, :default=>Sequel::CURRENT_TIMESTAMP\nend"
+    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal.new(\"0.1005#{e}3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.new(2008, 10, 29)\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  column :c9, \"time\", :default=>Sequel::SQLTime.parse(\"10:20:30.0\")\n  column :c10, \"foo\", :default=>Sequel::LiteralString.new(\"'6 weeks'\")\n  column :c11, \"date\", :default=>Sequel::CURRENT_DATE\n  column :c12, \"timestamp\", :default=>Sequel::CURRENT_TIMESTAMP\nend"
+  end
+  
+  it "should not use a literal string as a fallback if using MySQL with the :same_db option" do
+    def @d.database_type; :mysql end
+    def @d.supports_index_parsing?; false end
+    def @d.supports_foreign_key_parsing?; false end
+    def @d.schema(t, *os)
+      s = [[:c10, {:db_type=>'foo', :default=>"'6 weeks'", :type=>nil, :allow_null=>true}]]
+      s.each{|_, c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
+      s
+    end
+    @d.dump_table_schema(:t5, :same_db=>true).must_equal "create_table(:t5) do\n  column :c10, \"foo\"\nend"
+  end
+
+  it "should convert unknown database types to strings" do
+    @d.dump_table_schema(:t5).must_equal "create_table(:t5) do\n  String :c1\nend"
+  end
+
+  it "should convert many database types to ruby types" do
+    def @d.schema(t, *o)
+      types = %w"mediumint smallint int integer mediumint(6) smallint(7) int(8) integer(9)
+      tinyint tinyint(2) bigint bigint(20) real float double boolean tinytext mediumtext
+      longtext text clob date datetime timestamp time char character
+      varchar varchar(255) varchar(30) bpchar string money
+      decimal decimal(10,2) numeric numeric(15,3) number bytea tinyblob mediumblob longblob
+      blob varbinary varbinary(10) binary binary(20) year" +
+      ["double precision", "timestamp with time zone", "timestamp without time zone",
+       "time with time zone", "time without time zone", "character varying(20)"] +
+      %w"nvarchar ntext smalldatetime smallmoney binary varbinary nchar" +
+      ["timestamp(6) without time zone", "timestamp(6) with time zone", 'mediumint(10) unsigned', 'int(9) unsigned',
+       'int(10) unsigned', "int(12) unsigned", 'bigint unsigned', 'tinyint(3) unsigned', 'identity', 'int identity'] +
+      %w"integer(10) bit bool"
+      i = 0
+      types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
+    end
+    @d.dump_table_schema(:x).must_equal((<<END_MIG).chomp)
+create_table(:x) do
+  Integer :c1
+  Integer :c2
+  Integer :c3
+  Integer :c4
+  Integer :c5
+  Integer :c6
+  Integer :c7
+  Integer :c8
+  Integer :c9
+  Integer :c10
+  Bignum :c11
+  Bignum :c12
+  Float :c13
+  Float :c14
+  Float :c15
+  TrueClass :c16
+  String :c17, :text=>true
+  String :c18, :text=>true
+  String :c19, :text=>true
+  String :c20, :text=>true
+  String :c21, :text=>true
+  Date :c22
+  DateTime :c23
+  DateTime :c24
+  Time :c25, :only_time=>true
+  String :c26, :fixed=>true
+  String :c27, :fixed=>true
+  String :c28
+  String :c29, :size=>255
+  String :c30, :size=>30
+  String :c31
+  String :c32
+  BigDecimal :c33, :size=>[19, 2]
+  BigDecimal :c34
+  BigDecimal :c35, :size=>[10, 2]
+  BigDecimal :c36
+  BigDecimal :c37, :size=>[15, 3]
+  BigDecimal :c38
+  File :c39
+  File :c40
+  File :c41
+  File :c42
+  File :c43
+  File :c44
+  File :c45, :size=>10
+  File :c46
+  File :c47, :size=>20
+  Integer :c48
+  Float :c49
+  DateTime :c50
+  DateTime :c51
+  Time :c52, :only_time=>true
+  Time :c53, :only_time=>true
+  String :c54, :size=>20
+  String :c55
+  String :c56, :text=>true
+  DateTime :c57
+  BigDecimal :c58, :size=>[19, 2]
+  File :c59
+  File :c60
+  String :c61, :fixed=>true
+  DateTime :c62, :size=>6
+  DateTime :c63, :size=>6
+  Integer :c64
+  Integer :c65
+  Bignum :c66
+  Bignum :c67
+  Bignum :c68
+  Integer :c69
+  Integer :c70
+  Integer :c71
+  Integer :c72
+  TrueClass :c73
+  TrueClass :c74
+  
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c64), 0)
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c65), 0)
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c66), 0)
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c67), 0)
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c68), 0)
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c69), 0)
+end
+END_MIG
+  end
+
+  it "should convert mysql types to ruby types" do
+    def @d.schema(t, *o)
+      i = 0
+      ['double(15,2)', 'double(7,1) unsigned'].map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
+    end
+    @d.dump_table_schema(:x).must_equal((<<END_MIG).chomp)
+create_table(:x) do
+  Float :c1
+  Float :c2
+  
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c2), 0)
+end
+END_MIG
+  end
+
+  it "should convert oracle special types to ruby types" do
+    def @d.database_type; :oracle end
+    def @d.schema(t, *o)
+      i = 0
+      ['number not null', 'date not null', 'varchar2(4 byte) not null'].map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>false}]}
+    end
+    @d.dump_table_schema(:x).must_equal((<<END_MIG).chomp)
+create_table(:x) do
+  BigDecimal :c1, :null=>false
+  Date :c2, :null=>false
+  String :c3, :null=>false
+end
+END_MIG
+  end
+
+  it "should force specify :null option for MySQL timestamp columns when using :same_db" do
+    def @d.database_type; :mysql end
+    def @d.schema(*s) [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>true}]] end
+    @d.dump_table_schema(:t3, :same_db=>true).must_equal "create_table(:t3) do\n  column :c1, \"timestamp\", :null=>true\n  \n  primary_key [:c1]\nend"
+
+    def @d.schema(*s) [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>false}]] end
+    @d.dump_table_schema(:t3, :same_db=>true).must_equal "create_table(:t3) do\n  column :c1, \"timestamp\", :null=>false\n  \n  primary_key [:c1]\nend"
+  end
+
+  it "should use separate primary_key call with non autoincrementable types" do
+    def @d.schema(*s) [[:c1, {:db_type=>'varchar(8)', :primary_key=>true, :auto_increment=>false}]] end
+    @d.dump_table_schema(:t3).must_equal "create_table(:t3) do\n  String :c1, :size=>8\n  \n  primary_key [:c1]\nend"
+    @d.dump_table_schema(:t3, :same_db=>true).must_equal "create_table(:t3) do\n  column :c1, \"varchar(8)\"\n  \n  primary_key [:c1]\nend"
+  end
+
+  it "should use explicit type for non integer foreign_key types" do
+    def @d.schema(*s) [[:c1, {:db_type=>'date', :primary_key=>true, :auto_increment=>false}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t, *a) [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4 end
+    ["create_table(:t4) do\n  foreign_key :c1, :t3, :type=>Date, :key=>[:c1]\n  \n  primary_key [:c1]\nend",
+     "create_table(:t4) do\n  foreign_key :c1, :t3, :key=>[:c1], :type=>Date\n  \n  primary_key [:c1]\nend"].must_include(@d.dump_table_schema(:t4))
+    ["create_table(:t4) do\n  foreign_key :c1, :t3, :type=>\"date\", :key=>[:c1]\n  \n  primary_key [:c1]\nend",
+     "create_table(:t4) do\n  foreign_key :c1, :t3, :key=>[:c1], :type=>\"date\"\n  \n  primary_key [:c1]\nend"].must_include(@d.dump_table_schema(:t4, :same_db=>true))
+  end
+
+  it "should correctly handing autoincrementing primary keys that are also foreign keys" do
+    def @d.schema(*s) [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true}]] end
+    def @d.supports_foreign_key_parsing?; true end
+    def @d.foreign_key_list(t, *a) [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4 end
+    ["create_table(:t4) do\n  primary_key :c1, :table=>:t3, :key=>[:c1]\nend",
+     "create_table(:t4) do\n  primary_key :c1, :key=>[:c1], :table=>:t3\nend"].must_include(@d.dump_table_schema(:t4))
+  end
+
+  it "should handle dumping on PostgreSQL using qualified tables" do
+    @d = Sequel.connect('mock://postgres').extension(:schema_dumper)
+    def @d.schema(*s) [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>true}]] end
+    @d.dump_table_schema(Sequel.qualify(:foo, :bar), :same_db=>true).must_equal "create_table(Sequel::SQL::QualifiedIdentifier.new(:foo, :bar)) do\n  column :c1, \"timestamp\"\n  \n  primary_key [:c1]\nend"
+  end
+end