sequel 5.11.0 → 5.12.0

data/spec/extensions/caller_logging_spec.rb

@@ -0,0 +1,52 @@
+require_relative "spec_helper"
+require 'logger'
+
+describe "caller_logging extension" do
+  before do
+    @db = Sequel.mock(:extensions=>[:caller_logging])
+    @log_stream = StringIO.new
+    @db.loggers << Logger.new(@log_stream)
+    @ds = @db[:items]
+  end
+
+  exec_sql_line = __LINE__ + 2
+  def exec_sql(sql)
+    @db[sql].all
+  end
+
+  it "should log caller information, skipping internal Sequel code" do
+    exec_sql("SELECT * FROM items")
+    @log_stream.rewind
+    lines = @log_stream.read.split("\n")
+    lines.length.must_equal 1
+    lines[0].must_match(/ \(source: #{__FILE__}:#{exec_sql_line}:in `exec_sql'\) SELECT \* FROM items\z/)
+  end
+
+  it "should allow formatting of caller information" do
+    @db.caller_logging_formatter = lambda{|line| line.sub(/\A.+(caller_logging_spec\.rb:\d+).+\z/, '\1:')}
+    exec_sql("SELECT * FROM items")
+    @log_stream.rewind
+    lines = @log_stream.read.split("\n")
+    lines.length.must_equal 1
+    lines[0].must_match(/ caller_logging_spec\.rb:#{exec_sql_line}: SELECT \* FROM items\z/)
+  end
+
+  it "should allow ignoring additional caller lines in application" do
+    @db.caller_logging_ignore = /exec_sql/
+    exec_sql("SELECT * FROM items"); line = __LINE__
+    @log_stream.rewind
+    lines = @log_stream.read.split("\n")
+    lines.length.must_equal 1
+    lines[0].must_match(/ \(source: #{__FILE__}:#{line}:in `block.+\) SELECT \* FROM items\z/)
+  end
+
+  it "should not log caller information if all callers lines are filtered" do
+    @db.caller_logging_ignore = /./
+    exec_sql("SELECT * FROM items"); line = __LINE__
+    @log_stream.rewind
+    lines = @log_stream.read.split("\n")
+    lines.length.must_equal 1
+    lines[0].must_match(/ SELECT \* FROM items\z/)
+    lines[0].wont_match(/ source: #{__FILE__}/)
+  end
+end

data/spec/extensions/eager_graph_eager_spec.rb

@@ -0,0 +1,100 @@
+require_relative "spec_helper"
+
+describe "eager_graph_eager plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.columns :id, :parent_id
+    @c.plugin :eager_graph_eager
+    @c.one_to_many :children, :class=>@c, :key=>:parent_id
+    @c.many_to_one :parent, :class=>@c
+    @c.db.sqls
+  end
+
+  it "should support Dataset#eager_graph_eager for eager loading dependencies of eager_graph associations for one_to_many associations" do
+    a = @c.eager_graph(:children).
+      with_fetch([{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>2, :parent_id=>nil}]).
+      eager_graph_eager([:children], :children=>proc{|ds| ds.with_fetch(:id=>4, :parent_id=>3)}).
+      all
+    @c.db.sqls.must_equal ["SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)",
+      "SELECT * FROM items WHERE (items.parent_id IN (3))"]
+
+    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map(&:children).must_equal [[@c.load(:id=>3, :parent_id=>1)], []]
+    a.first.children.first.children.must_equal [@c.load(:id=>4, :parent_id=>3)]
+    @c.db.sqls.must_equal []
+  end
+
+  it "should support Dataset#eager_graph_eager for eager loading dependencies of eager_graph associations for many_to_one associations" do
+    a = @c.eager_graph(:parent).
+      with_fetch([{:id=>4, :parent_id=>3, :parent_id_0=>3, :parent_parent_id=>1}, {:id=>2, :parent_id=>nil}]).
+      eager_graph_eager([:parent], :parent=>proc{|ds| ds.with_fetch(:id=>1, :parent_id=>nil)}).
+      all
+    @c.db.sqls.must_equal ["SELECT items.id, items.parent_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id FROM items LEFT OUTER JOIN items AS parent ON (parent.id = items.parent_id)",
+      "SELECT * FROM items WHERE (items.id IN (1))"]
+
+    a.must_equal [@c.load(:id=>4, :parent_id=>3), @c.load(:id=>2, :parent_id=>nil)]
+    a.map(&:parent).must_equal [@c.load(:id=>3, :parent_id=>1), nil]
+    a.first.parent.parent.must_equal @c.load(:id=>1, :parent_id=>nil)
+    @c.db.sqls.must_equal []
+  end
+
+  it "should support multiple entries in dependency chain" do
+    a = @c.eager_graph(:children=>:children).
+      with_fetch([{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1, :children_0_id=>4, :children_0_parent_id=>3}, {:id=>2, :parent_id=>nil}]).
+      eager_graph_eager([:children, :children], :children=>proc{|ds| ds.with_fetch(:id=>5, :parent_id=>4)}).
+      all
+    @c.db.sqls.must_equal ["SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id, children_0.id AS children_0_id, children_0.parent_id AS children_0_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id) LEFT OUTER JOIN items AS children_0 ON (children_0.parent_id = children.id)",
+      "SELECT * FROM items WHERE (items.parent_id IN (4))"]
+
+    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map(&:children).must_equal [[@c.load(:id=>3, :parent_id=>1)], []]
+    a.first.children.first.children.must_equal [@c.load(:id=>4, :parent_id=>3)]
+    a.first.children.first.children.first.children.must_equal [@c.load(:id=>5, :parent_id=>4)]
+    @c.db.sqls.must_equal []
+  end
+
+  it "should support multiple dependency chains" do
+    a = @c.eager_graph(:children, :parent).
+      with_fetch([{:id=>4, :parent_id=>3, :children_id=>5, :children_parent_id=>4, :parent_id_0=>3, :parent_parent_id=>1}, {:id=>2, :parent_id=>nil}]).
+      eager_graph_eager([:children], :children=>proc{|ds| ds.with_fetch(:id=>6, :parent_id=>5)}).
+      eager_graph_eager([:parent], :parent=>proc{|ds| ds.with_fetch(:id=>1, :parent_id=>nil)}).
+      all
+    @c.db.sqls.must_equal ["SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id) LEFT OUTER JOIN items AS parent ON (parent.id = items.parent_id)",
+      "SELECT * FROM items WHERE (items.parent_id IN (5))",
+      "SELECT * FROM items WHERE (items.id IN (1))"]
+
+    a.must_equal [@c.load(:id=>4, :parent_id=>3), @c.load(:id=>2, :parent_id=>nil)]
+    a.map(&:children).must_equal [[@c.load(:id=>5, :parent_id=>4)], []]
+    a.map(&:parent).must_equal [@c.load(:id=>3, :parent_id=>1), nil]
+    a.first.children.first.children.must_equal [@c.load(:id=>6, :parent_id=>5)]
+    a.first.parent.parent.must_equal @c.load(:id=>1, :parent_id=>nil)
+    @c.db.sqls.must_equal []
+  end
+
+  it "should raise for invalid dependency chains" do
+    proc{@c.dataset.eager_graph_eager([], :children)}.must_raise Sequel::Error
+    proc{@c.dataset.eager_graph_eager(:children, :children)}.must_raise Sequel::Error
+    proc{@c.dataset.eager_graph_eager(['foo'], :children)}.must_raise Sequel::Error
+    proc{@c.dataset.eager_graph_eager([:foo], :children)}.must_raise Sequel::Error
+  end
+
+  it "should handle cases where not all associated objects are unique" do
+    a = @c.eager_graph(:parent=>:children).
+      with_fetch([
+        {:id=>4, :parent_id=>3, :parent_id_0=>3, :parent_parent_id=>1, :children_id=>4, :children_parent_id=>3},
+        {:id=>5, :parent_id=>3, :parent_id_0=>3, :parent_parent_id=>1, :children_id=>4, :children_parent_id=>3},
+        {:id=>4, :parent_id=>3, :parent_id_0=>3, :parent_parent_id=>1, :children_id=>5, :children_parent_id=>3},
+        {:id=>5, :parent_id=>3, :parent_id_0=>3, :parent_parent_id=>1, :children_id=>5, :children_parent_id=>3}
+      ]).
+      eager_graph_eager([:parent], :parent=>proc{|ds| ds.with_fetch(:id=>1, :parent_id=>nil)}).
+      all
+    @c.db.sqls.must_equal ["SELECT items.id, items.parent_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS parent ON (parent.id = items.parent_id) LEFT OUTER JOIN items AS children ON (children.parent_id = parent.id)",
+      "SELECT * FROM items WHERE (items.id IN (1))"]
+
+    a.must_equal [@c.load(:id=>4, :parent_id=>3), @c.load(:id=>5, :parent_id=>3)]
+    a.map(&:parent).must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>3, :parent_id=>1)]
+    a.map(&:parent).map(&:children).must_equal [a, a]
+    a.map(&:parent).map(&:parent).must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>1, :parent_id=>nil)]
+    @c.db.sqls.must_equal []
+  end
+end

data/spec/extensions/finder_spec.rb

@@ -118,7 +118,7 @@ describe Sequel::Model, ".prepared_finder" do
     @db.extend_datasets do
       def select_sql
         sql = super
-        sql << ' -- prepared' if is_a?(Sequel::Dataset::PreparedStatementMethods)
+        sql << ' -- prepared' if is_a?(Sequel::Dataset::PreparedStatementMethods) && !opts[:sql]
         sql
       end
     end

data/spec/extensions/prepared_statements_spec.rb

@@ -61,7 +61,7 @@ describe "prepared_statements plugin" do
           server(:default).with_sql_first(insert_select_sql(h))
         end
         def insert_select_sql(*v)
-          "#{insert_sql(*v)} RETURNING #{(opts[:returning] && !opts[:returning].empty?) ? opts[:returning].map{|c| literal(c)}.join(', ') : '*'}"
+          insert_sql(*v) << " RETURNING #{(opts[:returning] && !opts[:returning].empty?) ? opts[:returning].map{|c| literal(c)}.join(', ') : '*'}"
         end
       end
       @c.create(:name=>'foo').must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
@@ -107,7 +107,7 @@ describe "prepared_statements plugin" do
           server(:default).with_sql_first(insert_select_sql(h))
         end
         def insert_select_sql(*v)
-          "#{insert_sql(*v)} RETURNING #{(opts[:returning] && !opts[:returning].empty?) ? opts[:returning].map{|c| literal(c)}.join(', ') : '*'}"
+          insert_sql(*v) << " RETURNING #{(opts[:returning] && !opts[:returning].empty?) ? opts[:returning].map{|c| literal(c)}.join(', ') : '*'}"
         end
       end
       @c.new(:name=>'foo').set_server(:read_only).save.must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
@@ -130,21 +130,16 @@ describe "prepared_statements plugin" do
     it "should correctly handle with schema type when placeholder type specifiers are required" do
       @c.dataset = @ds.with_extend do
         def requires_placeholder_type_specifiers?; true end
-        def prepare(*)
-          super.with_extend do 
+        def prepared_statement_modules
+          [Module.new do
             def literal_symbol_append(sql, v)
-              if @opts[:bind_vars] && (match = /\A\$(.*)\z/.match(v.to_s))
-                s = match[1].split('__')[0].to_sym
-                if prepared_arg?(s)
-                  literal_append(sql, prepared_arg(s))
-                else
-                  sql << v.to_s
-                end
+              if @opts[:bind_vars] && /\A\$(.*)\z/ =~ v
+                literal_append(sql, prepared_arg($1.split('__')[0].to_sym))
               else
                 super
               end
             end
-          end
+          end]
         end
       end
       @c.db_schema[:id][:type] = :integer

data/spec/extensions/static_cache_spec.rb

@@ -264,6 +264,20 @@ describe "Sequel::Plugins::StaticCache" do
       @c.as_hash[3].must_equal @c.all.first
       @db.sqls.must_equal ['SELECT * FROM t2']
     end
+
+    it "should have load_cache" do
+      a = @c.all.sort_by{|o| o.id}
+      a.first.must_equal @c1
+      a.last.must_equal @c2
+      @db.sqls.must_equal []
+
+      @c.load_cache
+
+      a = @c.all.sort_by{|o| o.id}
+      a.first.must_equal @c1
+      a.last.must_equal @c2
+      @db.sqls.must_equal ['SELECT * FROM t']
+    end
   end
 
   describe "without options" do

data/spec/extensions/tactical_eager_loading_spec.rb

@@ -1,6 +1,6 @@
 require_relative "spec_helper"
 
-describe "Sequel::Plugins::TacticalEagerLoading" do
+describe "tactical_eager_loading plugin" do
   def sql_match(*args)
     sqls = DB.sqls
     sqls.length.must_equal args.length
@@ -139,3 +139,264 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
     Marshal.dump(ts.map{|x| x.marshallable!})
   end
 end
+
+describe "tactical_eager_loading plugin eager_graph_support" do
+  before do
+    @c = Class.new(Sequel::Model)
+    @c.class_eval do
+      set_dataset DB[:t]
+      columns :id, :parent_id
+      plugin :tactical_eager_loading
+      many_to_one :parent, :class=>self
+      one_to_many :children, :class=>self, :key=>:parent_id
+    end
+    DB.reset
+  end
+
+  it "should allow eager loading of associated objects from one_to_many associated objects retrieved via eager_graph" do
+    a = @c.eager_graph(:children).
+      with_fetch([
+        {:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1},
+        {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1},
+        {:id=>2, :parent_id=>nil, :children_id=>5, :children_parent_id=>2}
+      ]).all
+    @c.db.sqls.must_equal ["SELECT t.id, t.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM t LEFT OUTER JOIN t AS children ON (children.parent_id = t.id)"]
+
+    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map(&:children).must_equal [
+      [@c.load(:id=>3, :parent_id=>1),
+       @c.load(:id=>4, :parent_id=>1)],
+      [@c.load(:id=>5, :parent_id=>2)]]
+    @c.db.sqls.must_equal []
+
+    @c.dataset = @c.dataset.with_fetch([[{:id=>6, :parent_id=>3}, {:id=>7, :parent_id=>4}, {:id=>8, :parent_id=>5}],
+      [{:id=>9, :parent_id=>6}, {:id=>10, :parent_id=>7}, {:id=>11, :parent_id=>8}]])
+
+    a.map(&:children).map{|v| v.map(&:children)}.must_equal [
+      [[@c.load(:id=>6, :parent_id=>3)],
+       [@c.load(:id=>7, :parent_id=>4)]],
+      [[@c.load(:id=>8, :parent_id=>5)]]]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.parent_id IN (3, 4, 5))"]
+
+    a.map(&:children).map{|v| v.map(&:children).map{|v1| v1.map(&:children)}}.must_equal [
+      [[[@c.load(:id=>9, :parent_id=>6)]],
+       [[@c.load(:id=>10, :parent_id=>7)]]],
+      [[[@c.load(:id=>11, :parent_id=>8)]]]]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.parent_id IN (6, 7, 8))"]
+  end
+
+  it "should allow eager loading of associated objects from many_to_one associated objects retrieved via eager_graph" do
+    a = @c.eager_graph(:parent).
+      with_fetch([
+        {:id=>9, :parent_id=>6, :parent_id_0=>6, :parent_parent_id=>3},
+        {:id=>10, :parent_id=>7, :parent_id_0=>7, :parent_parent_id=>4},
+        {:id=>11, :parent_id=>8, :parent_id_0=>8, :parent_parent_id=>5}
+      ]).all
+    @c.db.sqls.must_equal ["SELECT t.id, t.parent_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id FROM t LEFT OUTER JOIN t AS parent ON (parent.id = t.parent_id)"]
+
+    a.must_equal [@c.load(:id=>9, :parent_id=>6), @c.load(:id=>10, :parent_id=>7), @c.load(:id=>11, :parent_id=>8)]
+    a.map(&:parent).must_equal [@c.load(:id=>6, :parent_id=>3), @c.load(:id=>7, :parent_id=>4), @c.load(:id=>8, :parent_id=>5)]
+    @c.db.sqls.must_equal []
+
+    @c.dataset = @c.dataset.with_fetch([[{:id=>5, :parent_id=>2}, {:id=>4, :parent_id=>nil}, {:id=>3, :parent_id=>1}],
+      [{:id=>2, :parent_id=>nil}, {:id=>1, :parent_id=>nil}]])
+
+    a.map(&:parent).map(&:parent).must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>nil), @c.load(:id=>5, :parent_id=>2)]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.id IN (3, 4, 5))"]
+    a.map(&:parent).map(&:parent).map(&:parent).must_equal [@c.load(:id=>1, :parent_id=>nil), nil, @c.load(:id=>2, :parent_id=>nil)]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.id IN (2, 1))"]
+  end
+
+  it "should allow eager loading of associated objects when using chained one_to_many associations" do
+    a = @c.eager_graph(:children=>:children).
+      with_fetch([
+        {:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1, :children_0_id=>6, :children_0_parent_id=>3},
+        {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1, :children_0_id=>7, :children_0_parent_id=>4},
+        {:id=>2, :parent_id=>nil, :children_id=>5, :children_parent_id=>2, :children_0_id=>8, :children_0_parent_id=>5}
+      ]).all
+    @c.db.sqls.must_equal ["SELECT t.id, t.parent_id, children.id AS children_id, children.parent_id AS children_parent_id, children_0.id AS children_0_id, children_0.parent_id AS children_0_parent_id FROM t LEFT OUTER JOIN t AS children ON (children.parent_id = t.id) LEFT OUTER JOIN t AS children_0 ON (children_0.parent_id = children.id)"]
+
+    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map(&:children).must_equal [
+      [@c.load(:id=>3, :parent_id=>1),
+       @c.load(:id=>4, :parent_id=>1)],
+      [@c.load(:id=>5, :parent_id=>2)]]
+
+    a.map(&:children).map{|v| v.map(&:children)}.must_equal [
+      [[@c.load(:id=>6, :parent_id=>3)],
+       [@c.load(:id=>7, :parent_id=>4)]],
+      [[@c.load(:id=>8, :parent_id=>5)]]]
+    @c.db.sqls.must_equal []
+
+    @c.dataset = @c.dataset.with_fetch([{:id=>9, :parent_id=>6}, {:id=>10, :parent_id=>7}, {:id=>11, :parent_id=>8}])
+    a.map(&:children).map{|v| v.map(&:children).map{|v1| v1.map(&:children)}}.must_equal [
+      [[[@c.load(:id=>9, :parent_id=>6)]],
+       [[@c.load(:id=>10, :parent_id=>7)]]],
+      [[[@c.load(:id=>11, :parent_id=>8)]]]]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.parent_id IN (6, 7, 8))"]
+  end
+
+  it "should allow eager loading of associated objects when using chained many_to_one associations" do
+    a = @c.eager_graph(:parent=>:parent).
+      with_fetch([
+        {:id=>9, :parent_id=>6, :parent_id_0=>6, :parent_parent_id=>3, :parent_0_id=>3, :parent_0_parent_id=>1},
+        {:id=>10, :parent_id=>7, :parent_id_0=>7, :parent_parent_id=>4, :parent_0_id=>4, :parent_0_parent_id=>1},
+        {:id=>11, :parent_id=>8, :parent_id_0=>8, :parent_parent_id=>5, :parent_0_id=>5, :parent_0_parent_id=>2}
+      ]).all
+    @c.db.sqls.must_equal ["SELECT t.id, t.parent_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id, parent_0.id AS parent_0_id, parent_0.parent_id AS parent_0_parent_id FROM t LEFT OUTER JOIN t AS parent ON (parent.id = t.parent_id) LEFT OUTER JOIN t AS parent_0 ON (parent_0.id = parent.parent_id)"]
+
+    a.must_equal [@c.load(:id=>9, :parent_id=>6), @c.load(:id=>10, :parent_id=>7), @c.load(:id=>11, :parent_id=>8)]
+    a.map(&:parent).must_equal [@c.load(:id=>6, :parent_id=>3), @c.load(:id=>7, :parent_id=>4), @c.load(:id=>8, :parent_id=>5)]
+    a.map(&:parent).map(&:parent).must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1), @c.load(:id=>5, :parent_id=>2)]
+    @c.db.sqls.must_equal []
+
+    @c.dataset = @c.dataset.with_fetch([{:id=>2, :parent_id=>nil}, {:id=>1, :parent_id=>nil}])
+    a.map(&:parent).map(&:parent).map(&:parent).must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.id IN (1, 2))"]
+  end
+
+  it "should allow eager loading of associated objects when using chained many_to_one=>one_to_many associations" do
+    a = @c.eager_graph(:parent=>:children).
+      with_fetch([
+        {:id=>9, :parent_id=>6, :parent_id_0=>6, :parent_parent_id=>3, :children_id=>9, :children_parent_id=>6},
+        {:id=>10, :parent_id=>7, :parent_id_0=>7, :parent_parent_id=>4, :children_id=>10, :children_parent_id=>7},
+        {:id=>11, :parent_id=>8, :parent_id_0=>8, :parent_parent_id=>5, :children_id=>11, :children_parent_id=>8},
+        {:id=>9, :parent_id=>6, :parent_id_0=>6, :parent_parent_id=>3, :children_id=>12, :children_parent_id=>6},
+        {:id=>10, :parent_id=>7, :parent_id_0=>7, :parent_parent_id=>4, :children_id=>13, :children_parent_id=>7},
+        {:id=>11, :parent_id=>8, :parent_id_0=>8, :parent_parent_id=>5, :children_id=>14, :children_parent_id=>8}
+      ]).all
+    @c.db.sqls.must_equal ["SELECT t.id, t.parent_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM t LEFT OUTER JOIN t AS parent ON (parent.id = t.parent_id) LEFT OUTER JOIN t AS children ON (children.parent_id = parent.id)"]
+
+    a.must_equal [@c.load(:id=>9, :parent_id=>6), @c.load(:id=>10, :parent_id=>7), @c.load(:id=>11, :parent_id=>8)]
+    a.map(&:parent).must_equal [@c.load(:id=>6, :parent_id=>3), @c.load(:id=>7, :parent_id=>4), @c.load(:id=>8, :parent_id=>5)]
+    a.map(&:parent).map(&:children).must_equal [
+      [@c.load(:id=>9, :parent_id=>6), @c.load(:id=>12, :parent_id=>6)],
+      [@c.load(:id=>10, :parent_id=>7), @c.load(:id=>13, :parent_id=>7)],
+      [@c.load(:id=>11, :parent_id=>8), @c.load(:id=>14, :parent_id=>8)]]
+    @c.db.sqls.must_equal []
+
+    @c.dataset = @c.dataset.with_fetch([{:id=>19, :parent_id=>9}, {:id=>24, :parent_id=>14}])
+    a.map(&:parent).map(&:children).map{|v| v.map(&:children)}
+    #.must_equal [
+    #  [[@c.load(:id=>19, :parent_id=>9)], []],
+    #  [[], []],
+    #  [[], @c.load(:id=>24, :parent_id=>14)]]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.parent_id IN (9, 10, 11, 12, 13, 14))"]
+  end
+
+  it "should allow eager loading of associated objects when using chained one_to_many associations with partial data" do
+    a = @c.eager_graph(:children=>:children).
+      with_fetch([
+        {:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1, :children_0_id=>6, :children_0_parent_id=>3},
+        {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1, :children_0_id=>nil, :children_0_parent_id=>nil},
+        {:id=>2, :parent_id=>nil, :children_id=>nil, :children_parent_id=>nil, :children_0_id=>nil, :children_0_parent_id=>nil}
+      ]).all
+    @c.db.sqls.must_equal ["SELECT t.id, t.parent_id, children.id AS children_id, children.parent_id AS children_parent_id, children_0.id AS children_0_id, children_0.parent_id AS children_0_parent_id FROM t LEFT OUTER JOIN t AS children ON (children.parent_id = t.id) LEFT OUTER JOIN t AS children_0 ON (children_0.parent_id = children.id)"]
+
+    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map(&:children).must_equal [
+      [@c.load(:id=>3, :parent_id=>1),
+       @c.load(:id=>4, :parent_id=>1)],
+      []]
+
+    a.map(&:children).map{|v| v.map(&:children)}.must_equal [
+      [[@c.load(:id=>6, :parent_id=>3)],
+       []],
+      []]
+    @c.db.sqls.must_equal []
+
+    @c.dataset = @c.dataset.with_fetch([{:id=>9, :parent_id=>6}])
+    a.map(&:children).map{|v| v.map(&:children).map{|v1| v1.map(&:children)}}.must_equal [
+      [[[@c.load(:id=>9, :parent_id=>6)]],
+       []],
+      []]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.parent_id IN (6))"]
+  end
+
+  it "should allow eager loading of associated objects when using chained many_to_one associations with partial data" do
+    a = @c.eager_graph(:parent=>:parent).
+      with_fetch([
+        {:id=>9, :parent_id=>6, :parent_id_0=>6, :parent_parent_id=>3, :parent_0_id=>3, :parent_0_parent_id=>1},
+        {:id=>10, :parent_id=>7, :parent_id_0=>7, :parent_parent_id=>nil, :parent_0_id=>nil, :parent_0_parent_id=>nil},
+        {:id=>11, :parent_id=>nil, :parent_id_0=>nil, :parent_parent_id=>nil, :parent_0_id=>nil, :parent_0_parent_id=>nil}
+      ]).all
+    @c.db.sqls.must_equal ["SELECT t.id, t.parent_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id, parent_0.id AS parent_0_id, parent_0.parent_id AS parent_0_parent_id FROM t LEFT OUTER JOIN t AS parent ON (parent.id = t.parent_id) LEFT OUTER JOIN t AS parent_0 ON (parent_0.id = parent.parent_id)"]
+
+    a.must_equal [@c.load(:id=>9, :parent_id=>6), @c.load(:id=>10, :parent_id=>7), @c.load(:id=>11, :parent_id=>nil)]
+    a.map(&:parent).must_equal [@c.load(:id=>6, :parent_id=>3), @c.load(:id=>7, :parent_id=>nil), nil]
+    a.map(&:parent).map{|v| v.parent if v}.must_equal [@c.load(:id=>3, :parent_id=>1), nil, nil]
+    @c.db.sqls.must_equal []
+
+    @c.dataset = @c.dataset.with_fetch([{:id=>1, :parent_id=>nil}])
+    a.map(&:parent).map{|v| v.parent.parent if v && v.parent}.must_equal [@c.load(:id=>1, :parent_id=>nil), nil, nil]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.id IN (1))"]
+  end
+
+  it "should skip setup of eager loading when using eager_graph for association not using plugin" do
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      set_dataset DB[:t]
+      columns :id, :t_id
+    end
+    @c.many_to_one :f, :class=>c, :key=>:parent_id
+    @c.one_to_many :fs, :class=>c
+    c.many_to_one :t, :class=>@c
+    c.one_to_many :ts, :class=>@c, :key=>:parent_id
+
+    a = @c.eager_graph(:f, :parent, :fs=>:t).
+      with_fetch([
+        {:id=>5, :parent_id=>4, :f_id=>4, :t_id=>20, :parent_id_0=>4, :parent_parent_id=>3, :fs_id=>5, :fs_t_id=>30, :t_0_id=>30, :t_0_parent_id=>40},
+        {:id=>15, :parent_id=>14, :f_id=>14, :t_id=>30, :parent_id_0=>14, :parent_parent_id=>13, :fs_id=>15, :fs_t_id=>40, :t_0_id=>40, :t_0_parent_id=>50},
+      ]).
+      all
+    @c.db.sqls.must_equal ["SELECT t.id, t.parent_id, f.id AS f_id, f.t_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id, fs.id AS fs_id, fs.t_id AS fs_t_id, t_0.id AS t_0_id, t_0.parent_id AS t_0_parent_id FROM t LEFT OUTER JOIN t AS f ON (f.id = t.parent_id) LEFT OUTER JOIN t AS parent ON (parent.id = t.parent_id) LEFT OUTER JOIN t AS fs ON (fs._id = t.id) LEFT OUTER JOIN t AS t_0 ON (t_0.id = fs.t_id)"]
+
+    a.must_equal [@c.load(:id=>5, :parent_id=>4), @c.load(:id=>15, :parent_id=>14)]
+    a.map(&:f).must_equal [c.load(:id=>4, :t_id=>20), c.load(:id=>14, :t_id=>30)]
+    a.map(&:parent).must_equal [@c.load(:id=>4, :parent_id=>3), @c.load(:id=>14, :parent_id=>13)]
+    a.map(&:fs).must_equal [[c.load(:id=>5, :t_id=>30)], [c.load(:id=>15, :t_id=>40)]]
+    a.map(&:fs).map{|v| v.map(&:t)}.must_equal [[@c.load(:id=>30, :parent_id=>40)], [@c.load(:id=>40, :parent_id=>50)]]
+    @c.db.sqls.must_equal []
+
+    @c.dataset = @c.dataset.with_fetch([[{:id=>3, :parent_id=>1}, {:id=>13, :parent_id=>1}],
+      [{:id=>1, :parent_id=>nil}],
+      [{:id=>20, :parent_id=>nil}],
+      [{:id=>30, :parent_id=>nil}],
+      [{:id=>50, :parent_id=>nil}, {:id=>40, :parent_id=>nil}]
+      ])
+    a.map(&:parent).map(&:parent).must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>13, :parent_id=>1)]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.id IN (3, 13))"]
+    a.map(&:parent).map(&:parent).map(&:parent).must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>1, :parent_id=>nil)]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.id IN (1))"]
+
+    a.map(&:f).map(&:t).must_equal [@c.load(:id=>20, :parent_id=>nil), @c.load(:id=>30, :parent_id=>nil)]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE id = 20", "SELECT * FROM t WHERE id = 30"]
+
+    a.map(&:fs).map{|v| v.map(&:t).map(&:parent)}.must_equal [[@c.load(:id=>40, :parent_id=>nil)], [@c.load(:id=>50, :parent_id=>nil)]]
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.id IN (40, 50))"]
+  end
+
+  it "should skip frozen objects when eager loading for model objects" do
+    a = @c.eager_graph(:parent).
+      with_fetch([
+        {:id=>9, :parent_id=>6, :parent_id_0=>6, :parent_parent_id=>3},
+        {:id=>10, :parent_id=>7, :parent_id_0=>7, :parent_parent_id=>4},
+        {:id=>11, :parent_id=>8, :parent_id_0=>8, :parent_parent_id=>5}
+      ]).all
+    @c.db.sqls.must_equal ["SELECT t.id, t.parent_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id FROM t LEFT OUTER JOIN t AS parent ON (parent.id = t.parent_id)"]
+
+    a.must_equal [@c.load(:id=>9, :parent_id=>6), @c.load(:id=>10, :parent_id=>7), @c.load(:id=>11, :parent_id=>8)]
+    a.map(&:parent).must_equal [@c.load(:id=>6, :parent_id=>3), @c.load(:id=>7, :parent_id=>4), @c.load(:id=>8, :parent_id=>5)]
+    @c.db.sqls.must_equal []
+
+    @c.dataset = @c.dataset.with_fetch([[{:id=>3, :parent_id=>1}, {:id=>5, :parent_id=>2}], [{:id=>4, :parent_id=>nil}]])
+    parents = a.map(&:parent)
+    parents[1].freeze
+    parents[0].parent.must_equal @c.load(:id=>3, :parent_id=>1)
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE (t.id IN (3, 5))"]
+    parents[1].parent.must_equal @c.load(:id=>4, :parent_id=>nil)
+    @c.db.sqls.must_equal ["SELECT * FROM t WHERE id = 4"]
+    parents[2].parent.must_equal @c.load(:id=>5, :parent_id=>2)
+    @c.db.sqls.must_equal []
+  end
+end