sequel_core 1.4.0 → 1.5.0

data/spec/database_spec.rb

@@ -46,7 +46,7 @@ context "Database#uri" do
       set_adapter_scheme :mau
     end
     
-    @db = Sequel('mau://user:pass@localhost:9876/maumau')
+    @db = Sequel.connect('mau://user:pass@localhost:9876/maumau')
   end
   
   specify "should return the connection URI for the database" do
@@ -442,10 +442,10 @@ context "Database#transaction" do
     proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
   end
   
-  specify "should issue ROLLBACK if rollback! is called in the transaction" do
+  specify "should issue ROLLBACK if Sequel::Error::Rollback is called in the transaction" do
     @db.transaction do
       @db.drop_table(:a)
-      rollback!
+      raise Sequel::Error::Rollback
       @db.drop_table(:b)
     end
     
@@ -506,6 +506,7 @@ context "A Database adapter with a scheme" do
     c.opts[:database].should == 'db'
   end
 
+  ### DEPRECATED
   specify "should be accessible through Sequel()" do
     c = Sequel('ccc://localhost/db')
     c.should be_a_kind_of(CCC)
@@ -514,24 +515,27 @@ context "A Database adapter with a scheme" do
   end
 
   specify "should be accessible through Sequel.<adapter>" do
+    class << Sequel
+      def_adapter_method(:ccc)
+    end
     # invalid parameters
     proc {Sequel.ccc('abc', 'def')}.should raise_error(Sequel::Error)
     
     c = Sequel.ccc('mydb')
     c.should be_a_kind_of(CCC)
-    c.opts.should == {:database => 'mydb'}
+    c.opts.should == {:adapter=>:ccc, :database => 'mydb'}
     
     c = Sequel.ccc('mydb', :host => 'localhost')
     c.should be_a_kind_of(CCC)
-    c.opts.should == {:database => 'mydb', :host => 'localhost'}
+    c.opts.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost'}
     
     c = Sequel.ccc
     c.should be_a_kind_of(CCC)
-    c.opts.should == {}
+    c.opts.should == {:adapter=>:ccc}
     
     c = Sequel.ccc(:database => 'mydb', :host => 'localhost')
     c.should be_a_kind_of(CCC)
-    c.opts.should == {:database => 'mydb', :host => 'localhost'}
+    c.opts.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost'}
   end
   
   specify "should be accessible through Sequel.connect with options" do
@@ -836,7 +840,7 @@ context "Database.connect" do
   end
   
   specify "should accept hashes loaded from YAML files" do
-    db = Sequel(YAML.load_file(@fn)['development'])
+    db = Sequel.connect(YAML.load_file(@fn)['development'])
     db.class.should == EEE
     db.opts[:database].should == 'mydb'
     db.opts[:user].should == 'mau'
@@ -877,4 +881,4 @@ context "Database#get" do
     @db.get(:version[])
     @db.sqls.last.should == 'SELECT version()'
   end
-end
+end

data/spec/dataset_spec.rb

@@ -127,33 +127,20 @@ context "A simple dataset" do
       @dataset.insert_sql({}).should == "INSERT INTO test DEFAULT VALUES"
   end
 
-  specify "should format an insert statement with array with keys" do
-    v = [1, 2, 3]
-    v.keys = [:a, :b, :c]
-    @dataset.insert_sql(v).should == "INSERT INTO test (a, b, c) VALUES (1, 2, 3)"
-    
-    v = []
-    v.keys = [:a, :b]
-    @dataset.insert_sql(v).should == "INSERT INTO test DEFAULT VALUES"
-  end
-  
   specify "should format an insert statement with string keys" do
     @dataset.insert_sql('name' => 'wxyz', 'price' => 342).
       should match(/INSERT INTO test \(name, price\) VALUES \('wxyz', 342\)|INSERT INTO test \(price, name\) VALUES \(342, 'wxyz'\)/)
   end
   
-  specify "should format an insert statement with a model instance" do
+  specify "should format an insert statement with an object that respond_to? :values" do
     dbb = Sequel::Database.new
     
-    @c = Class.new(Sequel::Model) do
-      attr_accessor :values
-    end
-    
-    v = @c.new; v.values = {:a => 1}
+    v = Object.new
+    def v.values; {:a => 1}; end
     
     @dataset.insert_sql(v).should == "INSERT INTO test (a) VALUES (1)"
     
-    v = @c.new; v.values = {}
+    def v.values; {}; end
     @dataset.insert_sql(v).should == "INSERT INTO test DEFAULT VALUES"
   end
   
@@ -180,13 +167,6 @@ context "A simple dataset" do
       "UPDATE test SET x = y"
   end
   
-  specify "should format an update statement with array with keys" do
-    v = ['abc']
-    v.keys = [:name]
-    
-    @dataset.update_sql(v).should == "UPDATE test SET name = 'abc'"
-  end
-  
   specify "should be able to return rows for arbitrary SQL" do
     @dataset.select_sql(:sql => 'xxx yyy zzz').should ==
       "xxx yyy zzz"
@@ -332,7 +312,7 @@ context "Dataset#where" do
   
   specify "should accept a subquery" do
     # select all countries that have GDP greater than the average for Asia
-    @dataset.filter('gdp > ?', @d1.select(:gdp.AVG)).sql.should ==
+    @dataset.filter('gdp > ?', @d1.select(:avg[:gdp])).sql.should ==
       "SELECT * FROM test WHERE gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia'))"
 
     @dataset.filter(:id => @d1.select(:id)).sql.should ==
@@ -346,7 +326,7 @@ context "Dataset#where" do
   end
   
   specify "should accept proc expressions" do
-    d = @d1.select(:gdp.AVG)
+    d = @d1.select(:avg[:gdp])
     @dataset.filter {:gdp > d}.sql.should ==
       "SELECT * FROM test WHERE (gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia')))"
     
@@ -501,7 +481,7 @@ end
 context "Dataset#having" do
   setup do
     @dataset = Sequel::Dataset.new(nil).from(:test)
-    @grouped = @dataset.group(:region).select(:region, :population.SUM, :gdp.AVG)
+    @grouped = @dataset.group(:region).select(:region, :sum[:population], :avg[:gdp])
     @d1 = @grouped.having('sum(population) > 10')
     @d2 = @grouped.having(:region => 'Asia')
     @columns = "region, sum(population), avg(gdp)"
@@ -581,6 +561,9 @@ context "Dataset#literal" do
     @dataset.literal('a"x"bc').should == "'a\"x\"bc'"
     @dataset.literal("a'bc").should == "'a''bc'"
     @dataset.literal("a''bc").should == "'a''''bc'"
+    @dataset.literal("a\\bc").should == "'a\\\\bc'"
+    @dataset.literal("a\\\\bc").should == "'a\\\\\\\\bc'"
+    @dataset.literal("a\\'bc").should == "'a\\\\''bc'"
   end
   
   specify "should literalize numbers properly" do
@@ -718,9 +701,9 @@ context "Dataset#select" do
       'SELECT test.d AS e, test.cc FROM test'
 
     # symbol helpers      
-    @d.select(:test.ALL).sql.should ==
+    @d.select(:test.*).sql.should ==
       'SELECT test.* FROM test'
-    @d.select(:test__name.AS(:n)).sql.should ==
+    @d.select(:test__name.as(:n)).sql.should ==
       'SELECT test.name AS n FROM test'
     @d.select(:test__name___n).sql.should ==
       'SELECT test.name AS n FROM test'
@@ -776,7 +759,7 @@ context "Dataset#select_more" do
 
   specify "should add to the currently selected columns" do
     @d.select(:a).select_more(:b).sql.should == 'SELECT a, b FROM test'
-    @d.select(:a.all).select_more(:b.all).sql.should == 'SELECT a.*, b.* FROM test'
+    @d.select(:a.*).select_more(:b.*).sql.should == 'SELECT a.*, b.* FROM test'
   end
 end
 
@@ -791,7 +774,7 @@ context "Dataset#order" do
   end
   
   specify "should accept multiple arguments" do
-    @dataset.order(:name, :price.DESC).sql.should ==
+    @dataset.order(:name, :price.desc).sql.should ==
       'SELECT * FROM test ORDER BY name, price DESC'
   end
   
@@ -833,7 +816,7 @@ context "Dataset#order_by" do
   end
   
   specify "should accept multiple arguments" do
-    @dataset.order_by(:name, :price.DESC).sql.should ==
+    @dataset.order_by(:name, :price.desc).sql.should ==
       'SELECT * FROM test ORDER BY name, price DESC'
   end
   
@@ -864,7 +847,7 @@ context "Dataset#order_more" do
   end
   
   specify "should add to a previous ordering" do
-    @dataset.order(:name).order_more(:stamp.DESC).sql.should ==
+    @dataset.order(:name).order_more(:stamp.desc).sql.should ==
       'SELECT * FROM test ORDER BY name, stamp DESC'
   end
 end
@@ -880,24 +863,24 @@ context "Dataset#reverse_order" do
   end
   
   specify "should invert the order given" do
-    @dataset.reverse_order(:name.DESC).sql.should ==
+    @dataset.reverse_order(:name.desc).sql.should ==
       'SELECT * FROM test ORDER BY name'
   end
   
   specify "should invert the order for ASC expressions" do
-    @dataset.reverse_order(:name.ASC).sql.should ==
+    @dataset.reverse_order(:name.asc).sql.should ==
       'SELECT * FROM test ORDER BY name DESC'
   end
   
   specify "should accept multiple arguments" do
-    @dataset.reverse_order(:name, :price.DESC).sql.should ==
+    @dataset.reverse_order(:name, :price.desc).sql.should ==
       'SELECT * FROM test ORDER BY name DESC, price'
   end
 
   specify "should reverse a previous ordering if no arguments are given" do
     @dataset.order(:name).reverse_order.sql.should ==
       'SELECT * FROM test ORDER BY name DESC'
-    @dataset.order(:clumsy.DESC, :fool).reverse_order.sql.should ==
+    @dataset.order(:clumsy.desc, :fool).reverse_order.sql.should ==
       'SELECT * FROM test ORDER BY clumsy, fool DESC'
   end
   
@@ -965,13 +948,13 @@ context "Dataset#qualified_column_name" do
   end
   
   specify "should return the same if already qualified" do
-    @dataset.qualified_column_name('test.a'.lit, :items).should == 'test.a'
-    @dataset.qualified_column_name(:ccc__b, :items).should == :ccc__b
+    @dataset.send(:qualified_column_name, 'test.a'.lit, :items).should == 'test.a'
+    @dataset.send(:qualified_column_name, :ccc__b, :items).should == :ccc__b
   end
   
   specify "should qualify the column with the supplied table name" do
-    @dataset.qualified_column_name('a'.lit, :items).to_s(@dataset).should == 'items.a'
-    @dataset.qualified_column_name(:b1, :items).to_s(@dataset).should == 'items.b1'
+    @dataset.send(:qualified_column_name, 'a'.lit, :items).to_s(@dataset).should == 'items.a'
+    @dataset.send(:qualified_column_name, :b1, :items).to_s(@dataset).should == 'items.b1'
   end
 end
 
@@ -1250,6 +1233,17 @@ context "Dataset#join_table" do
       'SELECT * FROM items LEFT OUTER JOIN (SELECT * FROM categories WHERE (active = \'t\')) t1 ON (t1.item_id = items.id)'
   end
 
+  specify "should support joining multiple datasets" do
+    ds = Sequel::Dataset.new(nil).from(:categories)
+    ds2 = Sequel::Dataset.new(nil).from(:nodes).select(:name)
+    ds3 = Sequel::Dataset.new(nil).from(:attributes).filter("name = 'blah'")
+
+    @d.join_table(:left_outer, ds, :item_id => :id).join_table(:inner, ds2, :node_id=>:id).join_table(:right_outer, ds3, :attribute_id=>:id).sql.should ==
+      'SELECT * FROM items LEFT OUTER JOIN (SELECT * FROM categories) t1 ON (t1.item_id = items.id) ' \
+      'INNER JOIN (SELECT name FROM nodes) t2 ON (t2.node_id = t1.id) ' \
+      "RIGHT OUTER JOIN (SELECT * FROM attributes WHERE name = 'blah') t3 ON (t3.attribute_id = t2.id)"
+  end
+
   specify "should support joining objects that respond to :table_name" do
     ds = Object.new
     def ds.table_name; :categories end
@@ -1515,16 +1509,16 @@ context "Dataset#last" do
   
   specify "should invert the order" do
     @d.order(:a).last
-    @d.literal(@c.last_dataset.opts[:order]).should == @d.literal([:a.DESC])
+    @d.literal(@c.last_dataset.opts[:order]).should == @d.literal([:a.desc])
     
-    @d.order(:b.DESC).last
+    @d.order(:b.desc).last
     @d.literal(@c.last_dataset.opts[:order]).should == @d.literal(:b)
     
     @d.order(:c, :d).last
-    @d.literal(@c.last_dataset.opts[:order]).should == @d.literal([:c.DESC, :d.DESC])
+    @d.literal(@c.last_dataset.opts[:order]).should == @d.literal([:c.desc, :d.desc])
     
-    @d.order(:e.DESC, :f).last
-    @d.literal(@c.last_dataset.opts[:order]).should == @d.literal([:e, :f.DESC])
+    @d.order(:e.desc, :f).last
+    @d.literal(@c.last_dataset.opts[:order]).should == @d.literal([:e, :f.desc])
   end
   
   specify "should return the first matching record if a hash is specified" do
@@ -1704,7 +1698,7 @@ context "Dataset#set_row_proc" do
   end
   
   specify "should cause dataset to pass all rows through the filter" do
-    @dataset.set_row_proc {|h| h[:der] = h[:kind] + 2; h}
+    @dataset.row_proc = proc{|h| h[:der] = h[:kind] + 2; h}
     
     rows = @dataset.all
     rows.size.should == 10
@@ -1713,7 +1707,7 @@ context "Dataset#set_row_proc" do
   end
   
   specify "should be copied over when dataset is cloned" do
-    @dataset.set_row_proc {|h| h[:der] = h[:kind] + 2; h}
+    @dataset.row_proc = proc{|h| h[:der] = h[:kind] + 2; h}
     
     @dataset.filter(:a => 1).first.should == {:kind => 1, :der => 3}
   end
@@ -2039,6 +2033,11 @@ context "A paginated dataset" do
     @paginated = @d.paginate(1, 20)
   end
   
+  specify "should raise an error if the dataset already has a limit" do
+    proc{@d.limit(10).paginate(1,10)}.should raise_error(Sequel::Error)
+    proc{@paginated.paginate(2,20)}.should raise_error(Sequel::Error)
+  end
+  
   specify "should set the limit and offset options correctly" do
     @paginated.opts[:limit].should == 20
     @paginated.opts[:offset].should == 0
@@ -2095,6 +2094,10 @@ context "Dataset#each_page" do
     @d.meta_def(:count) {153}
   end
   
+  specify "should raise an error if the dataset already has a limit" do
+    proc{@d.limit(10).each_page(10){}}.should raise_error(Sequel::Error)
+  end
+  
   specify "should iterate over each page in the resultset as a paginated dataset" do
     a = []
     @d.each_page(50) {|p| a << p}
@@ -2484,7 +2487,7 @@ context "Dataset#transform" do
   end
   
   specify "should work correctly together with set_row_proc" do
-    @ds.set_row_proc {|r| r[:z] = r[:x] * 2; r}
+    @ds.row_proc = proc{|r| r[:z] = r[:x] * 2; r}
     @ds.raw = {:x => Marshal.dump("wow"), :y => 'hello'}
     @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"}
 
@@ -2550,7 +2553,7 @@ context "Dataset#transform" do
     @ds2.insert(:x => :toast)
     @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{:toast.to_yaml}')"
 
-    @ds.set_row_proc {|r| r[:z] = r[:x] * 2; r}
+    @ds.row_proc = proc{|r| r[:z] = r[:x] * 2; r}
     @ds.raw = {:x => "wow".to_yaml, :y => 'hello'}
     @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"}
     f = nil
@@ -2578,7 +2581,7 @@ context "Dataset#transform" do
     @ds2.insert(:x => :toast)
     @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{Base64.encode64(Marshal.dump(:toast))}')"
 
-    @ds.set_row_proc {|r| r[:z] = r[:x] * 2; r}
+    @ds.row_proc = proc{|r| r[:z] = r[:x] * 2; r}
     @ds.raw = {:x => Base64.encode64(Marshal.dump("wow")), :y => 'hello'}
     @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"}
     f = nil
@@ -2616,11 +2619,10 @@ context "Dataset#to_csv" do
   setup do
     @c = Class.new(Sequel::Dataset) do
       attr_accessor :data
-      attr_accessor :cols
+      attr_accessor :columns
       
       def fetch_rows(sql, &block)
-        @columns = @cols
-        @data.each {|r| r.keys = @columns; block[r]}
+        @data.each(&block)
       end
       
       # naked should return self here because to_csv wants a naked result set.
@@ -2630,11 +2632,8 @@ context "Dataset#to_csv" do
     end
     
     @ds = @c.new(nil).from(:items)
-
-    @ds.cols = [:a, :b, :c]
-    @ds.data = [
-      [1, 2, 3], [4, 5, 6], [7, 8, 9]
-    ]
+    @ds.columns = [:a, :b, :c]
+    @ds.data = [ {:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}, {:a=>7, :b=>8, :c=>9} ]
   end
   
   specify "should format a CSV representation of the records" do
@@ -2648,25 +2647,7 @@ context "Dataset#to_csv" do
   end
 end
 
-context "Dataset#each_hash" do
-  setup do
-    @c = Class.new(Sequel::Dataset) do
-      def each(&block)
-        a = [[1, 2, 3], [4, 5, 6]]
-        a.each {|r| r.keys = [:a, :b, :c]; block[r]}
-      end
-    end
-    
-    @ds = @c.new(nil).from(:items)
-  end
-  
-  specify "should yield records converted to hashes" do
-    hashes = []
-    @ds.each_hash {|h| hashes << h}
-    hashes.should == [{:a => 1, :b => 2, :c => 3}, {:a => 4, :b => 5, :c => 6}]
-  end
-end
-
+### DEPRECATED
 context "Dataset magic methods" do
   setup do
     @c = Class.new(Sequel::Dataset) do

data/spec/object_graph_spec.rb

@@ -0,0 +1,202 @@
+require File.join(File.dirname(__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
+  end
+
+  it "#graph should not modify the current dataset's opts" do
+    o1 = @ds1.opts
+    o2 = o1.dup
+    ds1 = @ds1.graph(@ds2, :x=>:id)
+    @ds1.opts.should == o1
+    @ds1.opts.should == o2
+    ds1.opts.should_not == o1
+  end
+
+  it "#graph should accept a dataset as the dataset" 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 accept a symbol table name as the dataset" do
+    ds = @ds1.graph(:lines, :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 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 accept a :table_alias option" do
+    ds = @ds1.graph(:lines, {:x=>:id}, :table_alias=>:planes)
+    ds.sql.should == 'SELECT points.id, points.x, points.y, planes.id AS planes_id, planes.x AS planes_x, planes.y AS planes_y, planes.graph_id FROM points LEFT OUTER JOIN lines planes ON (planes.x = points.id)'
+  end
+
+  it "#graph should accept a :join_type option" do
+    ds = @ds1.graph(:lines, {:x=>:id}, :join_type=>:inner)
+    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 INNER JOIN lines ON (lines.x = points.id)'
+  end
+
+  it "#graph should accept a :select_option" do
+    ds = @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id)
+    ds.sql.should == 'SELECT points.id, points.x, points.y, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN graphs ON (graphs.id = lines.graph_id)'
+  end
+
+  it "#graph should pass all join_conditions to join_table" do
+    ds = @ds1.graph(@ds2, :x=>:id, :y=>:id)
+    ['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)',
+    '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.y = points.id) AND (lines.x = points.id)'
+    ].should(include(ds.sql))
+  end
+
+  it "#graph should not add columns if graph is called after set_graph_aliases" do
+    ds = @ds1.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
+    ['SELECT points.x, lines.y FROM points',
+    'SELECT lines.y, points.x FROM points'
+    ].should(include(ds.sql))
+    ds = ds.graph(:lines, :x=>:id)
+    ['SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
+    'SELECT lines.y, points.x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ].should(include(ds.sql))
+  end
+
+  it "#graph should allow graphing of multiple datasets" do
+    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_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, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x AS graphs_lines_x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN graphs ON (graphs.id = lines.graph_id)'
+  end
+
+  it "#graph should allow graphing of the same dataset multiple times" do
+    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph)
+    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, graph.id AS graph_id_0, graph.x AS graph_x, graph.y AS graph_y, graph.graph_id AS graph_graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN lines graph ON (graph.y = points.id)'
+  end
+
+  it "#graph should raise an error if the table/table alias has already been used" do
+    proc{@ds1.graph(@ds1, :x=>:id)}.should raise_error(Sequel::Error)
+    proc{@ds1.graph(@ds2, :x=>:id)}.should_not raise_error
+    proc{@ds1.graph(@ds2, :x=>:id).graph(@ds2, :x=>:id)}.should raise_error(Sequel::Error)
+    proc{@ds1.graph(@ds2, :x=>:id).graph(@ds2, {:x=>:id}, :table_alias=>:blah)}.should_not raise_error
+  end
+
+  it "#set_graph_aliases should not modify the current dataset's opts" do
+    o1 = @ds1.opts
+    o2 = o1.dup
+    ds1 = @ds1.set_graph_aliases(:x=>[:graphs,:id])
+    @ds1.opts.should == o1
+    @ds1.opts.should == o2
+    ds1.opts.should_not == o1
+  end
+
+  it "#set_graph_aliases should specify the graph mapping" do
+    ds = @ds1.graph(:lines, :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 = ds.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
+    ['SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
+    'SELECT lines.y, points.x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ].should(include(ds.sql))
+  end
+
+  it "#set_graph_aliases should only alias columns if necessary" do
+    ds = @ds1.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
+    ['SELECT points.x, lines.y FROM points',
+    'SELECT lines.y, points.x FROM points'
+    ].should(include(ds.sql))
+
+    ds = @ds1.set_graph_aliases(:x1=>[:points, :x], :y=>[:lines, :y])
+    ['SELECT points.x AS x1, lines.y FROM points',
+    'SELECT lines.y, points.x AS x1 FROM points'
+    ].should(include(ds.sql))
+  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}}
+
+    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}}
+  end
+
+  it "#graph_each should not included tables graphed with the :select 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}}
+  end
+
+  it "#graph_each should only include the columns selected with #set_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}}
+
+    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=>{}}
+  end
+
+  it "#graph_each should run the row_proc and transform 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}
+    @ds1.transform(:x=>[
+      proc{|v| 123},
+      proc{|v| 123}
+    ])
+    @ds2.transform(:x=>[
+      proc{|v| 321},
+      proc{|v| 321}
+    ])
+    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=>246, :y=>6}, :lines=>{:id=>12, :x=>963, :y=>18, :graph_id=>21}}
+  end
+end