sequel 3.21.0 → 3.41.0

data/spec/core/object_graph_spec.rb

@@ -2,16 +2,21 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
 describe Sequel::Dataset, " graphing" do
   before do
-    dbc = Class.new
-    @db = dbc.new
-    @ds1 = Sequel::Dataset.new(@db).from(:points)
-    @ds2 = Sequel::Dataset.new(@db).from(:lines)
-    @ds3 = Sequel::Dataset.new(@db).from(:graphs)
-    dss = {:points=>@ds1, :lines=>@ds2, :graphs=>@ds3}
-    dbc.send(:define_method, :[]){|ds| dss[ds]} 
-    def @ds1.columns; [:id, :x, :y] end
-    def @ds2.columns; [:id, :x, :y, :graph_id] end
-    def @ds3.columns; [:id, :name, :x, :y, :lines_x] end
+    @db = Sequel.mock(:columns=>proc do |sql|
+      case sql
+      when /points/
+        [:id, :x, :y]
+      when /lines/
+        [:id, :x, :y, :graph_id]
+      else
+        [:id, :name, :x, :y, :lines_x]
+      end
+    end)
+    @ds1 = @db.from(:points)
+    @ds2 = @db.from(:lines)
+    @ds3 = @db.from(:graphs)
+    [@ds1, @ds2, @ds3].each{|ds| ds.columns}
+    @db.sqls
   end
 
   it "#graph should not modify the current dataset's opts" do
@@ -23,11 +28,49 @@ describe Sequel::Dataset, " graphing" do
     ds1.opts.should_not == o1
   end
 
+  it "#graph should not modify the current dataset's opts if current dataset is already graphed" do
+    ds2 = @ds1.graph(@ds2)
+    proc{@ds1.graph(@ds2)}.should_not raise_error
+    proc{ds2.graph(@ds3)}.should_not raise_error
+    proc{ds2.graph(@ds3)}.should_not raise_error
+  end
+
   it "#graph should accept a simple dataset and pass the table to join" do
     ds = @ds1.graph(@ds2, :x=>:id)
     ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
   end
 
+  it "#graph should use currently selected columns as the basis for the selected columns in a new graph" do
+    ds = @ds1.select(:id).graph(@ds2, :x=>:id)
+    ds.sql.should == 'SELECT points.id, lines.id AS lines_id, lines.x, lines.y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ds._fetch = {:id=>1, :lines_id=>2, :x=>3, :y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(:id, :x).graph(@ds2, :x=>:id)
+    ds.sql.should == 'SELECT points.id, points.x, lines.id AS lines_id, lines.x AS lines_x, lines.y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(Sequel.identifier(:id), Sequel.qualify(:points, :x)).graph(@ds2, :x=>:id)
+    ds.sql.should == 'SELECT points.id, points.x, lines.id AS lines_id, lines.x AS lines_x, lines.y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(Sequel.identifier(:id).qualify(:points), Sequel.identifier(:x).as(:y)).graph(@ds2, :x=>:id)
+    ds.sql.should == 'SELECT points.id, points.x AS y, lines.id AS lines_id, lines.x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(:id, Sequel.identifier(:x).qualify(Sequel.identifier(:points)).as(Sequel.identifier(:y))).graph(@ds2, :x=>:id)
+    ds.sql.should == 'SELECT points.id, points.x AS y, lines.id AS lines_id, lines.x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+  end
+
+  it "#graph should raise error if currently selected expressions cannot be handled" do
+    proc{@ds1.select(1).graph(@ds2, :x=>:id)}.should raise_error(Sequel::Error)
+  end
+
   it "#graph should accept a complex dataset and pass it directly to join" do
     ds = @ds1.graph(@ds2.filter(:x=>1), {:x=>:id})
     ds.sql.should == 'SELECT points.id, points.x, points.y, t1.id AS t1_id, t1.x AS t1_x, t1.y AS t1_y, t1.graph_id FROM points LEFT OUTER JOIN (SELECT * FROM lines WHERE (x = 1)) AS t1 ON (t1.x = points.id)'
@@ -49,19 +92,6 @@ describe Sequel::Dataset, " graphing" do
     ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
   end
 
-  it "#graph should accept an object that responds to dataset as the dataset" do
-    oc = Class.new
-    o = oc.new
-    ds = @ds2
-    oc.send(:define_method, :dataset){ds} 
-    ds = @ds1.graph(o, :x=>:id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    ds = :lines
-    oc.send(:define_method, :dataset){ds} 
-    ds = @ds1.graph(o, :x=>:id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-  end
-
   it "#graph should raise an error if a symbol, dataset, or model is not used" do
     proc{@ds1.graph(Object.new, :x=>:id)}.should raise_error(Sequel::Error)
   end
@@ -97,7 +127,7 @@ describe Sequel::Dataset, " graphing" do
   end
 
   it "#graph should accept a block instead of conditions and pass it to join_table" do
-    ds = @ds1.graph(@ds2){|ja, lja, js| [[:x.qualify(ja), :id.qualify(lja)], [:y.qualify(ja), :id.qualify(lja)]]}
+    ds = @ds1.graph(@ds2){|ja, lja, js| [[Sequel.qualify(ja, :x), Sequel.qualify(lja, :id)], [Sequel.qualify(ja, :y), Sequel.qualify(lja, :id)]]}
     ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON ((lines.x = points.id) AND (lines.y = points.id))'
   end
 
@@ -154,7 +184,7 @@ describe Sequel::Dataset, " graphing" do
   end
 
   it "#set_graph_aliases should allow a third entry to specify an expression to use other than the default" do
-    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x, 1], :y=>[:lines, :y, :random.sql_function])
+    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x, 1], :y=>[:lines, :y, Sequel.function(:random)])
     ['SELECT 1 AS x, random() AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
     'SELECT random() AS y, 1 AS x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     ].should(include(ds.sql))
@@ -187,144 +217,73 @@ describe Sequel::Dataset, " graphing" do
   end
 
   it "#graph_each should split the result set into component tables" do
-    ds = @ds1.graph(@ds2, :x=>:id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}}
-
-    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}
+    @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}],
+      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}],
+      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graph_id_0=>8, :graph_x=>9, :graph_y=>10, :graph_graph_id=>11}]]
 
-    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graph_id_0=>8, :graph_x=>9, :graph_y=>10, :graph_graph_id=>11})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}
+    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}}]
+    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
+    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}]
   end
 
   it "#ungraphed should remove the splitting of result sets into component tables" do
-    ds = @ds1.graph(@ds2, :x=>:id).ungraphed
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7})
-    end
-    ds.all.should == [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}]
+    @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}
+    @ds1.graph(@ds2, :x=>:id).ungraphed.all.should == [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}]
   end
 
   it "#graph_each should give a nil value instead of a hash when all values for a table are nil" do
-    ds = @ds1.graph(@ds2, :x=>:id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :lines=>nil}
+    @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil}],
+      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil},
+      {:id=>2,:x=>4,:y=>5,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil},
+      {:id=>3,:x=>5,:y=>6,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>7, :name=>8, :graphs_x=>9, :graphs_y=>10, :graphs_lines_x=>11},
+      {:id=>3,:x=>5,:y=>6,:lines_id=>7,:lines_x=>5,:lines_y=>8,:graph_id=>9, :graphs_id=>9, :name=>10, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}]]
 
-    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil})
-      yield({:id=>2,:x=>4,:y=>5,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil})
-      yield({:id=>3,:x=>5,:y=>6,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>7, :name=>8, :graphs_x=>9, :graphs_y=>10, :graphs_lines_x=>11})
-      yield({:id=>3,:x=>5,:y=>6,:lines_id=>7,:lines_x=>5,:lines_y=>8,:graph_id=>9, :graphs_id=>9, :name=>10, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12})
-    end
-    results = ds.all
-    results.length.should == 4
-    results[0].should == {:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>nil}
-    results[1].should == {:points=>{:id=>2, :x=>4, :y=>5}, :lines=>nil, :graphs=>nil}
-    results[2].should == {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>7, :name=>8, :x=>9, :y=>10, :lines_x=>11}}
-    results[3].should == {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>7, :x=>5, :y=>8, :graph_id=>9}, :graphs=>{:id=>9, :name=>10, :x=>10, :y=>11, :lines_x=>12}}
+    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>nil}]
+    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>nil},
+      {:points=>{:id=>2, :x=>4, :y=>5}, :lines=>nil, :graphs=>nil},
+      {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>7, :name=>8, :x=>9, :y=>10, :lines_x=>11}},
+      {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>7, :x=>5, :y=>8, :graph_id=>9}, :graphs=>{:id=>9, :name=>10, :x=>10, :y=>11, :lines_x=>12}}]
   end
 
   it "#graph_each should not give a nil value instead of a hash when any value for a table is false" do
-    ds = @ds1.graph(@ds2, :x=>:id)
-    def ds.fetch_rows(sql, &block)
-      block.call(:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>false,:lines_y=>nil,:graph_id=>nil)
-    end
-    ds.all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>nil, :x=>false, :y=>nil, :graph_id=>nil}}]
+    @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>false,:lines_y=>nil,:graph_id=>nil}
+    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>nil, :x=>false, :y=>nil, :graph_id=>nil}}]
   end
 
   it "#graph_each should not included tables graphed with the :select => false option in the result set" do
-    ds = @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :lines_x=>12})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}
+    @db.fetch = {:id=>1,:x=>2,:y=>3,:graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :lines_x=>12}
+    @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
   end
 
   it "#graph_each should only include the columns selected with #set_graph_aliases and #add_graph_aliases, if called" do
-    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
-    def ds.fetch_rows(sql, &block)
-      yield({:x=>2,:y=>3})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:x=>2}, :lines=>{:y=>3}}
+    @db.fetch = [nil, [{:x=>2,:y=>3}], nil, [{:x=>2}], [{:x=>2, :q=>18}]]
 
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
     ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x])
-    def ds.fetch_rows(sql, &block)
-      yield({:x=>2})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:x=>2}, :lines=>nil}
-
+    ds.all.should == [{:points=>{:x=>2}, :lines=>nil}]
     ds = ds.add_graph_aliases(:q=>[:points, :r, 18])
-    def ds.fetch_rows(sql, &block)
-      yield({:x=>2, :q=>18})
-    end
     ds.all.should == [{:points=>{:x=>2, :r=>18}, :lines=>nil}]
   end
 
   it "#graph_each should correctly map values when #set_graph_aliases is used with a third argument for each entry" do
-    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :z1, 2], :y=>[:lines, :z2, :random.sql_function])
-    def ds.fetch_rows(sql, &block)
-      yield({:x=>2,:y=>3})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:z1=>2}, :lines=>{:z2=>3}}
+    @db.fetch = [nil, {:x=>2,:y=>3}]
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :z1, 2], :y=>[:lines, :z2, Sequel.function(:random)]).all.should == [{:points=>{:z1=>2}, :lines=>{:z2=>3}}]
   end
 
   it "#graph_each should correctly map values when #set_graph_aliases is used with a single argument for each entry" do
-    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines])
-    def ds.fetch_rows(sql, &block)
-      yield({:x=>2,:y=>3})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:x=>2}, :lines=>{:y=>3}}
+    @db.fetch = [nil, {:x=>2,:y=>3}]
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines]).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
   end
 
   it "#graph_each should correctly map values when #set_graph_aliases is used with a symbol for each entry" do
-    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines)
-    def ds.fetch_rows(sql, &block)
-      yield({:x=>2,:y=>3})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:x=>2}, :lines=>{:y=>3}}
+    @db.fetch = [nil, {:x=>2,:y=>3}]
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
   end
 
   it "#graph_each should run the row_proc for graphed datasets" do
     @ds1.row_proc = proc{|h| h.keys.each{|k| h[k] *= 2}; h}
     @ds2.row_proc = proc{|h| h.keys.each{|k| h[k] *= 3}; h}
-    ds = @ds1.graph(@ds2, :x=>:id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>2, :x=>4, :y=>6}, :lines=>{:id=>12, :x=>15, :y=>18, :graph_id=>21}}
+    @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}
+    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>2, :x=>4, :y=>6}, :lines=>{:id=>12, :x=>15, :y=>18, :graph_id=>21}}]
   end
 end

data/spec/core/schema_generator_spec.rb

@@ -2,13 +2,13 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
 describe Sequel::Schema::Generator do
   before do
-    @generator = Sequel::Schema::Generator.new(SchemaDummyDatabase.new) do
+    @generator = Sequel::Schema::Generator.new(Sequel.mock) do
       string :title
       column :body, :text
       foreign_key :parent_id
       primary_key :id
       check 'price > 100'
-      constraint(:xxx) {:yyy == :zzz}
+      constraint(:xxx) {{:yyy => :zzz}}
       index :title
       index [:title, :body], :unique => true
       foreign_key :node_id, :nodes
@@ -97,7 +97,7 @@ end
 
 describe Sequel::Schema::AlterTableGenerator do
   before do
-    @generator = Sequel::Schema::AlterTableGenerator.new(SchemaDummyDatabase.new) do
+    @generator = Sequel::Schema::AlterTableGenerator.new(Sequel.mock) do
       add_column :aaa, :text
       drop_column :bbb
       rename_column :ccc, :ho
@@ -147,7 +147,7 @@ end
 
 describe "Sequel::Schema::Generator generic type methods" do
   it "should store the type class in :type for each column" do
-    Sequel::Schema::Generator.new(SchemaDummyDatabase.new) do
+    Sequel::Schema::Generator.new(Sequel.mock) do
       String :a
       Integer :b
       Fixnum :c