sequel 5.11.0 → 5.12.0

data/lib/sequel/version.rb

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

data/spec/adapters/oracle_spec.rb

@@ -325,3 +325,47 @@ describe "An Oracle database with xml types" do
     DB.from(Sequel.lit('xml_test x')).select(Sequel.lit("x.xml_col.getCLOBVal() v")).all.must_equal [{:v=>"<a href=\"b\">c</a>\n"}]
   end
 end
+
+describe "Clob Bound Argument Type" do
+  before(:all) do
+    @db = DB
+    @db.create_table!(:items) do
+      primary_key :id
+      clob :c
+    end
+    @ds = @db[:items]
+  end
+  before do
+    @ds.delete
+  end
+  after(:all) do
+    @db.drop_table?(:items)
+  end
+
+  it "should handle clob type in prepared statement arguments" do
+    @ds.delete
+    clob = "\"'[]`a0 "
+    @ds.prepare(:insert, :ps_clob, {:c=>@db.adapter_scheme == :oracle ? :$c__clob : :$c}).call(:c=>clob)
+    @ds.get(:c).must_equal clob
+  end
+end
+
+describe "CLOB Returning Procedure" do
+  before do
+    DB.run <<SQL
+CREATE OR REPLACE PROCEDURE testCLOB(outParam OUT CLOB)
+IS
+BEGIN
+  outParam := 'Hello World CLOB OUT parameter';
+END;
+SQL
+  end
+  after do
+    DB.run("DROP PROCEDURE testCLOB")
+  end
+
+  it "should work correctly with output clobs" do
+    res = DB.execute("begin testCLOB(:1); end;", {:arguments => [[nil, 'clob']]}) {|c| c[1].read }
+    res.must_equal 'Hello World CLOB OUT parameter'
+  end
+end if DB.adapter_scheme == :oracle

data/spec/adapters/postgres_spec.rb

@@ -1239,6 +1239,45 @@ describe "A PostgreSQL database" do
   end if DB.server_version >= 90600
 end
 
+describe "Sequel::Postgres::Database" do
+  before do
+    @db = DB
+    @db.create_table!(:posts){Integer :a}
+  end
+  after do
+    @db.run("DROP PROCEDURE test_procedure_posts(int, int)")
+    @db.drop_table?(:posts)
+  end
+
+  it "#call_procedure should call a procedure that returns a row" do
+    @db.run <<SQL
+CREATE OR REPLACE PROCEDURE test_procedure_posts(inout a int, inout b int)
+LANGUAGE SQL
+AS $$
+INSERT INTO posts VALUES (a) RETURNING *;
+INSERT INTO posts VALUES (a * 2) RETURNING *;
+SELECT max(posts.a), min(posts.a) FROM posts;
+$$;
+SQL
+    @db.call_procedure(:test_procedure_posts, 1, nil).must_equal(:a=>2, :b=>1)
+    @db.call_procedure(:test_procedure_posts, 3, nil).must_equal(:a=>6, :b=>1)
+  end
+
+
+  it "#call_procedure should call a procedure that doesn't return a row" do
+    @db.run <<SQL
+CREATE OR REPLACE PROCEDURE test_procedure_posts(int, int)
+LANGUAGE SQL
+AS $$
+INSERT INTO posts VALUES ($1) RETURNING *;
+INSERT INTO posts VALUES ($1 * 2) RETURNING *;
+$$;
+SQL
+    @db.call_procedure(:test_procedure_posts, 1, nil).must_be_nil
+    @db.call_procedure(:test_procedure_posts, 3, nil).must_be_nil
+  end
+end if DB.adapter_scheme == :postgres && DB.server_version >= 110000
+
 describe "Postgres::Dataset#import" do
   before do
     @db = DB

data/spec/core/dataset_spec.rb

@@ -3825,7 +3825,7 @@ end
 describe "Dataset prepared statements and bound variables " do
   before do
     @db = Sequel.mock
-    @ds = @db[:items].with_extend{def insert_select_sql(*v) "#{insert_sql(*v)} RETURNING *" end}
+    @ds = @db[:items].with_extend{def insert_select_sql(*v) insert_sql(*v) << " RETURNING *" end}
   end
   
   it "#call should take a type and bind hash and interpolate it" do
@@ -3868,9 +3868,10 @@ describe "Dataset prepared statements and bound variables " do
     pss << @ds.filter(:num=>:$n).prepare(:delete, :dn)
     pss << @ds.filter(:num=>:$n).prepare(:update, :un, :num=>:$n2)
     pss << @ds.prepare(:insert, :in, :num=>:$n)
+    pss << @ds.prepare(:insert_pk, :inp, :num=>:$n)
     pss << @ds.prepare(:insert_select, :ins, :num=>:$n)
-    @db.prepared_statements.keys.sort_by{|k| k.to_s}.must_equal [:ah, :dn, :en, :fn, :in, :ins, :sh, :shg, :sm, :sn, :un]
-    [:en, :sn, :sm, :ah, :sh, :shg, :fn, :dn, :un, :in, :ins].each_with_index{|x, i| @db.prepared_statements[x].must_equal pss[i]}
+    @db.prepared_statements.keys.sort_by{|k| k.to_s}.must_equal [:ah, :dn, :en, :fn, :in, :inp, :ins, :sh, :shg, :sm, :sn, :un]
+    [:en, :sn, :sm, :ah, :sh, :shg, :fn, :dn, :un, :in, :inp, :ins].each_with_index{|x, i| @db.prepared_statements[x].must_equal pss[i]}
     @db.call(:en, :n=>1){}
     @db.call(:sn, :n=>1)
     @db.call(:sm, :n=>1)
@@ -3881,6 +3882,7 @@ describe "Dataset prepared statements and bound variables " do
     @db.call(:dn, :n=>1)
     @db.call(:un, :n=>1, :n2=>2)
     @db.call(:in, :n=>1)
+    @db.call(:inp, :n=>1)
     @db.call(:ins, :n=>1)
     @db.sqls.must_equal [
       'SELECT * FROM items WHERE (num = 1)',
@@ -3893,15 +3895,27 @@ describe "Dataset prepared statements and bound variables " do
       'DELETE FROM items WHERE (num = 1)',
       'UPDATE items SET num = 2 WHERE (num = 1)',
       'INSERT INTO items (num) VALUES (1)',
+      'INSERT INTO items (num) VALUES (1)',
       'INSERT INTO items (num) VALUES (1) RETURNING *']
   end
     
+  it "should give correct results for recursive WITH" do
+    ps = @ds.with_extend{def supports_cte?(type=nil) true end}.
+      select(Sequel[:i].as(:id), Sequel[:pi].as(:parent_id)).
+      with_recursive(:t, @ds.filter(:parent_id=>:$n), @ds.join(:t, :i=>:parent_id).filter(Sequel[:t][:i]=>:parent_id).
+      select(Sequel[:i1][:id], Sequel[:i1][:parent_id]), :args=>[:i, :pi]).
+      order(:id).
+      prepare(:select, :cte_sel)
+    ps.call(:n=>1).must_equal []
+    @db.sqls.must_equal ["WITH t(i, pi) AS (SELECT * FROM items WHERE (parent_id = 1) UNION ALL SELECT i1.id, i1.parent_id FROM items INNER JOIN t ON (t.i = items.parent_id) WHERE (t.i = parent_id)) SELECT i AS id, pi AS parent_id FROM items ORDER BY id"]
+  end
+
   it "#call and #prepare should handle returning" do
     @ds = @ds.with_extend do
       def supports_returning?(_) true end
-      def insert_sql(*v) "#{super(*v)} RETURNING *" end
-      def update_sql(*v) "#{super(*v)} RETURNING *" end
-      def delete_sql; "#{super()} RETURNING *" end
+      def insert_sql(*) super << " RETURNING *" end
+      def update_sql(*) super << " RETURNING *" end
+      def delete_sql; super << " RETURNING *" end
     end
     @ds = @ds.returning
     @ds.call(:insert, {:n=>1}, :num=>:$n)
@@ -4010,6 +4024,9 @@ describe Sequel::Dataset::UnnumberedArgumentMapper do
       def execute_insert(sql, opts={}, &block)
         super(sql, opts.merge({:arguments=>bind_arguments}), &block)
       end
+      def prepared_statement_modules
+        [Sequel::Dataset::UnnumberedArgumentMapper]
+      end
     end
     @ps = []
     @ps << @ds.prepare(:select, :s)
@@ -4018,9 +4035,6 @@ describe Sequel::Dataset::UnnumberedArgumentMapper do
     @ps << @ds.prepare(:delete, :d)
     @ps << @ds.prepare(:insert, :i, :num=>:$n)
     @ps << @ds.prepare(:update, :u, :num=>:$n)
-    @ps.map! do |p|
-      p.with_extend(Sequel::Dataset::UnnumberedArgumentMapper)
-    end
   end
 
   it "#inspect should show the actual SQL submitted to the database" do

data/spec/core/object_graph_spec.rb

@@ -1,6 +1,6 @@
 require_relative "spec_helper"
 
-describe Sequel::Dataset, "graphing" do
+describe Sequel::Dataset do
   before do
     @db = Sequel.mock(:columns=>proc do |sql|
       case sql
@@ -19,288 +19,318 @@ describe Sequel::Dataset, "graphing" do
     @db.sqls
   end
 
-  describe "#graph" do
-    it "should not modify the current dataset's opts" do
-      o1 = @ds1.opts
-      o2 = o1.dup
-      ds1 = @ds1.graph(@ds2, :x=>:id)
-      @ds1.opts.must_equal o1
-      @ds1.opts.must_equal o2
-      ds1.opts.wont_equal o1
-    end
-
-    it "should not modify the current dataset's opts if current dataset is already graphed" do
-      ds2 = @ds1.graph(@ds2)
-      @ds1.graph(@ds2)
-      ds2.graph(@ds3)
-      ds2.graph(@ds3)
-    end
-
-    it "should accept a simple dataset and pass the table to join" do
-      ds = @ds1.graph(@ds2, :x=>:id)
-      ds.sql.must_equal '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 "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.must_equal '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 = @ds1.select(:id, :x).graph(@ds2, :x=>:id)
-      ds.sql.must_equal '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 = @ds1.select(Sequel.identifier(:id), Sequel.qualify(:points, :x)).graph(@ds2, :x=>:id)
-      ds.sql.must_equal '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 = @ds1.select(Sequel.identifier(:id).qualify(:points), Sequel.identifier(:x).as(:y)).graph(@ds2, :x=>:id)
-      ds.sql.must_equal '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 = @ds1.select(:id, Sequel.identifier(:x).qualify(Sequel.identifier(:points)).as(Sequel.identifier(:y))).graph(@ds2, :x=>:id)
-      ds.sql.must_equal '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)'
-    end
-
-    it "should requalify currently selected columns in new graph if current dataset joins tables" do
-      ds = @ds1.cross_join(:lines).select(Sequel[:points][:id], Sequel[:lines][:id].as(:lid), Sequel[:lines][:x], Sequel[:lines][:y]).graph(@ds3, :x=>:id)
-      ds.sql.must_equal 'SELECT points.id, points.lid, 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 (SELECT points.id, lines.id AS lid, lines.x, lines.y FROM points CROSS JOIN lines) AS points LEFT OUTER JOIN graphs ON (graphs.x = points.id)'
-    end
-
-    with_symbol_splitting "should requalify currently selected columns in new graph if current dataset joins tables with splittable symbols" do
-      ds = @ds1.cross_join(:lines).select(:points__id, :lines__id___lid, :lines__x, :lines__y).graph(@ds3, :x=>:id)
-      ds.sql.must_equal 'SELECT points.id, points.lid, 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 (SELECT points.id, lines.id AS lid, lines.x, lines.y FROM points CROSS JOIN lines) AS points LEFT OUTER JOIN graphs ON (graphs.x = points.id)'
-    end
-
-    it "should raise error if currently selected expressions cannot be handled" do
-      proc{@ds1.select(1).graph(@ds2, :x=>:id)}.must_raise(Sequel::Error)
-    end
-
-    it "should accept a complex dataset and pass it directly to join" do
-      ds = @ds1.graph(@ds2.select_all(:lines), {:x=>:id})
-      ds.sql.must_equal '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 "should accept a complex dataset and pass it directly to join" do
-      ds = @ds1.graph(@ds2.filter(:x=>1), {:x=>:id})
-      ds.sql.must_equal '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)'
-      ds = @ds1.graph(@ds2.select_all(:lines).filter(:x=>1), {:x=>:id})
-      ds.sql.must_equal '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 lines.* FROM lines WHERE (x = 1)) AS t1 ON (t1.x = points.id)'
-    end
-
-    it "should work on from_self datasets" do
-      ds = @ds1.from_self.graph(@ds2, :x=>:id)
-      ds.sql.must_equal 'SELECT t1.id, t1.x, t1.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM (SELECT * FROM points) AS t1 LEFT OUTER JOIN lines ON (lines.x = t1.id)'
-      ds = @ds1.graph(@ds2.from_self, :x=>:id)
-      ds.sql.must_equal '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 (SELECT * FROM lines) AS t1) AS t1 ON (t1.x = points.id)'
-      ds = @ds1.from_self.from_self.graph(@ds2.from_self.from_self, :x=>:id)
-      ds.sql.must_equal 'SELECT t1.id, t1.x, t1.y, t2.id AS t2_id, t2.x AS t2_x, t2.y AS t2_y, t2.graph_id FROM (SELECT * FROM (SELECT * FROM points) AS t1) AS t1 LEFT OUTER JOIN (SELECT * FROM (SELECT * FROM (SELECT * FROM lines) AS t1) AS t1) AS t2 ON (t2.x = t1.id)'
-      ds = @ds1.from(@ds1, @ds3).graph(@ds2.from_self, :x=>:id)
-      ds.sql.must_equal 'SELECT t1.id, t1.x, t1.y, t3.id AS t3_id, t3.x AS t3_x, t3.y AS t3_y, t3.graph_id FROM (SELECT * FROM (SELECT * FROM points) AS t1, (SELECT * FROM graphs) AS t2) AS t1 LEFT OUTER JOIN (SELECT * FROM (SELECT * FROM lines) AS t1) AS t3 ON (t3.x = t1.id)'
-    end
-
-    it "should accept a symbol table name as the dataset" do
-      ds = @ds1.graph(:lines, :x=>:id)
-      ds.sql.must_equal '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
-
-    with_symbol_splitting "should accept a schema qualified symbolic table name as the dataset" do
-      ds = @ds1.graph(:schema__lines, :x=>:id)
-      ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
-    end
-
-    it "should accept a qualified identifier table name as the dataset" do
-      ds = @ds1.graph(Sequel[:schema][:lines], :x=>:id)
-      ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
-    end
-
-    with_symbol_splitting "allows giving table alias in symbolic argument" do
-      ds = @ds1.graph(:lines___sketch, :x=>:id)
-      ds.sql.must_equal 'SELECT points.id, points.x, points.y, sketch.id AS sketch_id, sketch.x AS sketch_x, sketch.y AS sketch_y, sketch.graph_id FROM points LEFT OUTER JOIN lines AS sketch ON (sketch.x = points.id)'
-      ds = @ds1.graph(:schema__lines___sketch, :x=>:id)
-      ds.sql.must_equal 'SELECT points.id, points.x, points.y, sketch.id AS sketch_id, sketch.x AS sketch_x, sketch.y AS sketch_y, sketch.graph_id FROM points LEFT OUTER JOIN schema.lines AS sketch ON (sketch.x = points.id)'
-    end
-
-    it "should accept a SQL::Identifier as the dataset" do
-      ds = @ds1.graph(Sequel.identifier(:lines), :x=>:id)
-      ds.sql.must_equal '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 = @ds1.graph(Sequel.identifier('lines'), :x=>:id)
-      ds.sql.must_equal '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 AS lines ON (lines.x = points.id)'
-    end
-
-    it "should handle a SQL::Identifier with double underscores correctly" do
-      ds = @ds1.graph(Sequel.identifier(:lin__es), :x=>:id)
-      ds.sql.must_equal 'SELECT points.id, points.x, points.y, lin__es.id AS lin__es_id, lin__es.name, lin__es.x AS lin__es_x, lin__es.y AS lin__es_y, lin__es.lines_x FROM points LEFT OUTER JOIN lin__es ON (lin__es.x = points.id)'
-      ds = @ds1.from(Sequel.identifier(:poi__nts)).graph(Sequel.identifier(:lin__es), :x=>:id)
-      ds.sql.must_equal 'SELECT poi__nts.id, poi__nts.name, poi__nts.x, poi__nts.y, poi__nts.lines_x, lin__es.id AS lin__es_id, lin__es.name AS lin__es_name, lin__es.x AS lin__es_x, lin__es.y AS lin__es_y, lin__es.lines_x AS lin__es_lines_x FROM poi__nts LEFT OUTER JOIN lin__es ON (lin__es.x = poi__nts.id)'
-      ds = @ds1.from(Sequel.identifier(:poi__nts).qualify(:foo)).graph(Sequel.identifier(:lin__es).qualify(:bar), :x=>:id)
-      ds.sql.must_equal 'SELECT foo.poi__nts.id, foo.poi__nts.x, foo.poi__nts.y, foo.poi__nts.graph_id, lin__es.id AS lin__es_id, lin__es.name, lin__es.x AS lin__es_x, lin__es.y AS lin__es_y, lin__es.lines_x FROM foo.poi__nts LEFT OUTER JOIN bar.lin__es AS lin__es ON (lin__es.x = foo.poi__nts.id)'
-    end
-
-    it "should accept a SQL::QualifiedIdentifier as the dataset" do
-      ds = @ds1.graph(Sequel.qualify(:schema, :lines), :x=>:id)
-      ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
-      ds = @ds1.graph(Sequel.qualify('schema', 'lines'), :x=>:id)
-      ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
-      ds = @ds1.graph(Sequel.qualify(Sequel.identifier(:schema), Sequel.identifier(:lines)), :x=>:id)
-      ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
-      ds = @ds1.graph(Sequel.qualify(Sequel.identifier('schema'), Sequel.identifier('lines')), :x=>:id)
-      ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
-    end
-
-    with_symbol_splitting "should handle a qualified identifier symbol as the source" do
-      ds = @ds1.from(:schema__points).graph(:lines, :x=>:id)
-      ds.sql.must_equal 'SELECT schema.points.id, schema.points.x, schema.points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM schema.points LEFT OUTER JOIN lines ON (lines.x = schema.points.id)'
-    end
-
-    it "should handle a qualified identifier as the source" do
-      ds = @ds1.from(Sequel.qualify(:schema, :points)).graph(:lines, :x=>:id)
-      ds.sql.must_equal 'SELECT schema.points.id, schema.points.x, schema.points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM schema.points LEFT OUTER JOIN lines ON (lines.x = schema.points.id)'
-    end
-
-    with_symbol_splitting "should accept a SQL::AliasedExpression with splittable symbol as the dataset" do
-      ds = @ds1.graph(Sequel.as(:schema__lines, :foo), :x=>:id)
-      ds.sql.must_equal 'SELECT points.id, points.x, points.y, foo.id AS foo_id, foo.x AS foo_x, foo.y AS foo_y, foo.graph_id FROM points LEFT OUTER JOIN schema.lines AS foo ON (foo.x = points.id)'
-    end
-
-    it "should accept a SQL::AliasedExpression as the dataset" do
-      ds = @ds1.graph(Sequel.as(:lines, :foo), :x=>:id)
-      ds.sql.must_equal 'SELECT points.id, points.x, points.y, foo.id AS foo_id, foo.x AS foo_x, foo.y AS foo_y, foo.graph_id FROM points LEFT OUTER JOIN lines AS foo ON (foo.x = points.id)'
-      ds = @ds1.graph(Sequel.as(Sequel.identifier(:lines), :foo), :x=>:id)
-      ds.sql.must_equal 'SELECT points.id, points.x, points.y, foo.id AS foo_id, foo.x AS foo_x, foo.y AS foo_y, foo.graph_id FROM points LEFT OUTER JOIN lines AS foo ON (foo.x = points.id)'
-      ds = @ds1.graph(Sequel.as(Sequel.qualify(:schema, :lines), :foo), :x=>:id)
-      ds.sql.must_equal 'SELECT points.id, points.x, points.y, foo.id AS foo_id, foo.x AS foo_x, foo.y AS foo_y, foo.graph_id FROM points LEFT OUTER JOIN schema.lines AS foo ON (foo.x = points.id)'
-    end
-
-    it "should raise an error if a symbol, dataset, or model is not used" do
-      proc{@ds1.graph(Object.new, :x=>:id)}.must_raise(Sequel::Error)
-    end
-
-    it "should accept a :table_alias option" do
-      ds = @ds1.graph(:lines, {:x=>:id}, :table_alias=>:planes)
-      ds.sql.must_equal '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 AS planes ON (planes.x = points.id)'
-    end
-
-    it "should accept a :implicit_qualifier option" do
-      ds = @ds1.graph(:lines, {:x=>:id}, :implicit_qualifier=>:planes)
-      ds.sql.must_equal '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 = planes.id)'
-    end
-
-    it "should accept a :join_type option" do
-      ds = @ds1.graph(:lines, {:x=>:id}, :join_type=>:inner)
-      ds.sql.must_equal '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 "should accept a :join_only option" do
-      ds = @ds1.graph(:lines, {:x=>:id}, :join_only=>true)
-      ds.sql.must_equal 'SELECT * FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    end
-
-    it "should not select any columns from the graphed table if :select option is false" do
-      ds = @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id)
-      ds.sql.must_equal '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 "should use the given columns if :select option is used" do
-      ds = @ds1.graph(:lines, {:x=>:id}, :select=>[:x, :graph_id]).graph(:graphs, :id=>:graph_id)
-      ds.sql.must_equal 'SELECT points.id, points.x, points.y, lines.x AS lines_x, 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 "should pass all join_conditions to join_table" do
-      ds = @ds1.graph(@ds2, [[:x, :id], [:y, :id]])
-      ds.sql.must_equal '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
-
-    it "should accept a block instead of conditions and pass it to join_table" do
-      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.must_equal '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
-
-    it "should raise Error if set_graph_aliases is called on an ungraphed dataset" do
-      proc{@ds1.set_graph_aliases([[:x,[:points, :x]], [:y,[:lines, :y]]])}.must_raise Sequel::Error
-    end
-
-    it "should allow graphing of multiple datasets" do
-      ds = @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id)
-      ds.sql.must_equal '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 "should allow graphing of the same dataset multiple times" do
-      ds = @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>Sequel[:points][:id]}, :table_alias=>:graph)
-      ds.sql.must_equal '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 AS graph ON (graph.y = points.id)'
-    end
-
-    with_symbol_splitting "should allow graphing of the same dataset multiple times when using splittable symbols" do
-      ds = @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph)
-      ds.sql.must_equal '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 AS graph ON (graph.y = points.id)'
-    end
-
-    it "should raise an error if the table/table alias has already been used" do
-      proc{@ds1.graph(@ds1, :x=>:id)}.must_raise(Sequel::Error)
-      @ds1.graph(@ds2, :x=>:id)
-      proc{@ds1.graph(@ds2, :x=>:id).graph(@ds2, :x=>:id)}.must_raise(Sequel::Error)
-      @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:x=>:id}, :table_alias=>:blah)
-    end
-  end
-
-  describe "#set_graph_aliases" do
-    it "should not modify the current dataset's opts" do
-      o1 = @ds1.opts
-      o2 = o1.dup
-      ds1 = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:graphs,:id])
-      @ds1.opts.must_equal o1
-      @ds1.opts.must_equal o2
-      ds1.opts.wont_equal o1
-    end
-
-    it "should specify the graph mapping" do
-      ds = @ds1.graph(:lines, :x=>:id)
-      ds.sql.must_equal '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.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    end
-
-    it "should allow a third entry to specify an expression to use other than the default" do
-      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x, 1], :y=>[:lines, :y, Sequel.function(:random)]).sql.must_equal 'SELECT 1 AS x, random() AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    end
-
-    it "should allow a single array entry to specify a table, assuming the same column as the key" do
-      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    end
-
-    it "should allow hash values to be symbols specifying table, assuming the same column as the key" do
-      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    end
-
-    it "should only alias columns if necessary" do
-      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    end
-
-    it "should only alias columns if necessary" do
-      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x1=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x AS x1, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    end
-  end
-
-  describe "#add_graph_aliases" do
-    it "should not modify the current dataset's opts" do
-      ds1 = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:graphs,:id])
-      o1 = ds1.opts
-      o2 = o1.dup
-      ds2 = ds1.add_graph_aliases(:y=>[:blah,:id])
-      ds1.opts.must_equal o1
-      ds1.opts.must_equal o2
-      ds2.opts.wont_equal o1
-    end
-
-    it "should add columns to the graph mapping" do
-      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :q]).add_graph_aliases(:y=>[:lines, :r]).sql.must_equal 'SELECT points.q AS x, lines.r AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    end
-
-    it "should raise an error if called without existing graph aliases" do
-      proc{@ds1.add_graph_aliases(:y=>[:lines, :r])}.must_raise(Sequel::Error)
-    end
-  end
-
-  describe "#ungraphed" do
-    it "should remove the splitting of result sets into component tables" do
-      @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.must_equal [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}]
-    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.must_equal o1
+    @ds1.opts.must_equal o2
+    ds1.opts.wont_equal o1
+  end
+
+  it "#graph should not modify the current dataset's opts if current dataset is already graphed" do
+    ds2 = @ds1.graph(@ds2)
+    @ds1.graph(@ds2)
+    ds2.graph(@ds3)
+    ds2.graph(@ds3)
+  end
+
+  it "#graph should accept a simple dataset and pass the table to join" do
+    ds = @ds1.graph(@ds2, :x=>:id)
+    ds.sql.must_equal '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.must_equal '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 = @ds1.select(:id, :x).graph(@ds2, :x=>:id)
+    ds.sql.must_equal '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 = @ds1.select(Sequel.identifier(:id), Sequel.qualify(:points, :x)).graph(@ds2, :x=>:id)
+    ds.sql.must_equal '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 = @ds1.select(Sequel.identifier(:id).qualify(:points), Sequel.identifier(:x).as(:y)).graph(@ds2, :x=>:id)
+    ds.sql.must_equal '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 = @ds1.select(:id, Sequel.identifier(:x).qualify(Sequel.identifier(:points)).as(Sequel.identifier(:y))).graph(@ds2, :x=>:id)
+    ds.sql.must_equal '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)'
+  end
+
+  it "#graph should requalify currently selected columns in new graph if current dataset joins tables" do
+    ds = @ds1.cross_join(:lines).select(Sequel[:points][:id], Sequel[:lines][:id].as(:lid), Sequel[:lines][:x], Sequel[:lines][:y]).graph(@ds3, :x=>:id)
+    ds.sql.must_equal 'SELECT points.id, points.lid, 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 (SELECT points.id, lines.id AS lid, lines.x, lines.y FROM points CROSS JOIN lines) AS points LEFT OUTER JOIN graphs ON (graphs.x = points.id)'
+  end
+
+  with_symbol_splitting "#graph should requalify currently selected columns in new graph if current dataset joins tables with splittable symbols" do
+    ds = @ds1.cross_join(:lines).select(:points__id, :lines__id___lid, :lines__x, :lines__y).graph(@ds3, :x=>:id)
+    ds.sql.must_equal 'SELECT points.id, points.lid, 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 (SELECT points.id, lines.id AS lid, lines.x, lines.y FROM points CROSS JOIN lines) AS points LEFT OUTER JOIN graphs ON (graphs.x = points.id)'
+  end
+
+  it "#graph should handle selection expression without introspectable alias using a subselect" do
+    ds = @ds1.select(Sequel.lit('1 AS v'))
+    ds.columns :v
+    ds.graph(@ds2, :x=>:v).sql.must_equal "SELECT points.v, lines.id, lines.x, lines.y, lines.graph_id FROM (SELECT 1 AS v FROM points) AS points LEFT OUTER JOIN lines ON (lines.x = points.v)"
+  end
+
+  it "#graph should accept a complex dataset and pass it directly to join" do
+    ds = @ds1.graph(@ds2.select_all(:lines), {:x=>:id})
+    ds.sql.must_equal '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 complex dataset and pass it directly to join" do
+    ds = @ds1.graph(@ds2.filter(:x=>1), {:x=>:id})
+    ds.sql.must_equal '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)'
+    ds = @ds1.graph(@ds2.select_all(:lines).filter(:x=>1), {:x=>:id})
+    ds.sql.must_equal '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 lines.* FROM lines WHERE (x = 1)) AS t1 ON (t1.x = points.id)'
+  end
+
+  it "#graph should work on from_self datasets" do
+    ds = @ds1.from_self.graph(@ds2, :x=>:id)
+    ds.sql.must_equal 'SELECT t1.id, t1.x, t1.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM (SELECT * FROM points) AS t1 LEFT OUTER JOIN lines ON (lines.x = t1.id)'
+    ds = @ds1.graph(@ds2.from_self, :x=>:id)
+    ds.sql.must_equal '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 (SELECT * FROM lines) AS t1) AS t1 ON (t1.x = points.id)'
+    ds = @ds1.from_self.from_self.graph(@ds2.from_self.from_self, :x=>:id)
+    ds.sql.must_equal 'SELECT t1.id, t1.x, t1.y, t2.id AS t2_id, t2.x AS t2_x, t2.y AS t2_y, t2.graph_id FROM (SELECT * FROM (SELECT * FROM points) AS t1) AS t1 LEFT OUTER JOIN (SELECT * FROM (SELECT * FROM (SELECT * FROM lines) AS t1) AS t1) AS t2 ON (t2.x = t1.id)'
+    ds = @ds1.from(@ds1, @ds3).graph(@ds2.from_self, :x=>:id)
+    ds.sql.must_equal 'SELECT t1.id, t1.x, t1.y, t3.id AS t3_id, t3.x AS t3_x, t3.y AS t3_y, t3.graph_id FROM (SELECT * FROM (SELECT * FROM points) AS t1, (SELECT * FROM graphs) AS t2) AS t1 LEFT OUTER JOIN (SELECT * FROM (SELECT * FROM lines) AS t1) AS t3 ON (t3.x = t1.id)'
+  end
+
+  it "#graph should accept a symbol table name as the dataset" do
+    ds = @ds1.graph(:lines, :x=>:id)
+    ds.sql.must_equal '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
+
+  with_symbol_splitting "#graph should accept a schema qualified symbolic table name as the dataset" do
+    ds = @ds1.graph(:schema__lines, :x=>:id)
+    ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
+  end
+
+  it "#graph should accept a qualified identifier table name as the dataset" do
+    ds = @ds1.graph(Sequel[:schema][:lines], :x=>:id)
+    ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
+  end
+
+  with_symbol_splitting "#graph allows giving table alias in symbolic argument" do
+    ds = @ds1.graph(:lines___sketch, :x=>:id)
+    ds.sql.must_equal 'SELECT points.id, points.x, points.y, sketch.id AS sketch_id, sketch.x AS sketch_x, sketch.y AS sketch_y, sketch.graph_id FROM points LEFT OUTER JOIN lines AS sketch ON (sketch.x = points.id)'
+    ds = @ds1.graph(:schema__lines___sketch, :x=>:id)
+    ds.sql.must_equal 'SELECT points.id, points.x, points.y, sketch.id AS sketch_id, sketch.x AS sketch_x, sketch.y AS sketch_y, sketch.graph_id FROM points LEFT OUTER JOIN schema.lines AS sketch ON (sketch.x = points.id)'
+  end
+
+  it "#graph should accept a SQL::Identifier as the dataset" do
+    ds = @ds1.graph(Sequel.identifier(:lines), :x=>:id)
+    ds.sql.must_equal '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 = @ds1.graph(Sequel.identifier('lines'), :x=>:id)
+    ds.sql.must_equal '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 AS lines ON (lines.x = points.id)'
+  end
+
+  it "#graph should handle a SQL::Identifier with double underscores correctly" do
+    ds = @ds1.graph(Sequel.identifier(:lin__es), :x=>:id)
+    ds.sql.must_equal 'SELECT points.id, points.x, points.y, lin__es.id AS lin__es_id, lin__es.name, lin__es.x AS lin__es_x, lin__es.y AS lin__es_y, lin__es.lines_x FROM points LEFT OUTER JOIN lin__es ON (lin__es.x = points.id)'
+    ds = @ds1.from(Sequel.identifier(:poi__nts)).graph(Sequel.identifier(:lin__es), :x=>:id)
+    ds.sql.must_equal 'SELECT poi__nts.id, poi__nts.name, poi__nts.x, poi__nts.y, poi__nts.lines_x, lin__es.id AS lin__es_id, lin__es.name AS lin__es_name, lin__es.x AS lin__es_x, lin__es.y AS lin__es_y, lin__es.lines_x AS lin__es_lines_x FROM poi__nts LEFT OUTER JOIN lin__es ON (lin__es.x = poi__nts.id)'
+    ds = @ds1.from(Sequel.identifier(:poi__nts).qualify(:foo)).graph(Sequel.identifier(:lin__es).qualify(:bar), :x=>:id)
+    ds.sql.must_equal 'SELECT foo.poi__nts.id, foo.poi__nts.x, foo.poi__nts.y, foo.poi__nts.graph_id, lin__es.id AS lin__es_id, lin__es.name, lin__es.x AS lin__es_x, lin__es.y AS lin__es_y, lin__es.lines_x FROM foo.poi__nts LEFT OUTER JOIN bar.lin__es AS lin__es ON (lin__es.x = foo.poi__nts.id)'
+  end
+
+  it "#graph should accept a SQL::QualifiedIdentifier as the dataset" do
+    ds = @ds1.graph(Sequel.qualify(:schema, :lines), :x=>:id)
+    ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
+    ds = @ds1.graph(Sequel.qualify('schema', 'lines'), :x=>:id)
+    ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
+    ds = @ds1.graph(Sequel.qualify(Sequel.identifier(:schema), Sequel.identifier(:lines)), :x=>:id)
+    ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
+    ds = @ds1.graph(Sequel.qualify(Sequel.identifier('schema'), Sequel.identifier('lines')), :x=>:id)
+    ds.sql.must_equal '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 schema.lines AS lines ON (lines.x = points.id)'
+  end
+
+  with_symbol_splitting "#graph should handle a qualified identifier symbol as the source" do
+    ds = @ds1.from(:schema__points).graph(:lines, :x=>:id)
+    ds.sql.must_equal 'SELECT schema.points.id, schema.points.x, schema.points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM schema.points LEFT OUTER JOIN lines ON (lines.x = schema.points.id)'
+  end
+
+  it "#graph should handle a qualified identifier as the source" do
+    ds = @ds1.from(Sequel.qualify(:schema, :points)).graph(:lines, :x=>:id)
+    ds.sql.must_equal 'SELECT schema.points.id, schema.points.x, schema.points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM schema.points LEFT OUTER JOIN lines ON (lines.x = schema.points.id)'
+  end
+
+  with_symbol_splitting "#graph should accept a SQL::AliasedExpression with splittable symbol as the dataset" do
+    ds = @ds1.graph(Sequel.as(:schema__lines, :foo), :x=>:id)
+    ds.sql.must_equal 'SELECT points.id, points.x, points.y, foo.id AS foo_id, foo.x AS foo_x, foo.y AS foo_y, foo.graph_id FROM points LEFT OUTER JOIN schema.lines AS foo ON (foo.x = points.id)'
+  end
+
+  it "#graph should accept a SQL::AliasedExpression as the dataset" do
+    ds = @ds1.graph(Sequel.as(:lines, :foo), :x=>:id)
+    ds.sql.must_equal 'SELECT points.id, points.x, points.y, foo.id AS foo_id, foo.x AS foo_x, foo.y AS foo_y, foo.graph_id FROM points LEFT OUTER JOIN lines AS foo ON (foo.x = points.id)'
+    ds = @ds1.graph(Sequel.as(Sequel.identifier(:lines), :foo), :x=>:id)
+    ds.sql.must_equal 'SELECT points.id, points.x, points.y, foo.id AS foo_id, foo.x AS foo_x, foo.y AS foo_y, foo.graph_id FROM points LEFT OUTER JOIN lines AS foo ON (foo.x = points.id)'
+    ds = @ds1.graph(Sequel.as(Sequel.qualify(:schema, :lines), :foo), :x=>:id)
+    ds.sql.must_equal 'SELECT points.id, points.x, points.y, foo.id AS foo_id, foo.x AS foo_x, foo.y AS foo_y, foo.graph_id FROM points LEFT OUTER JOIN schema.lines AS foo ON (foo.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)}.must_raise(Sequel::Error)
+  end
+
+  it "#graph should accept a :table_alias option" do
+    ds = @ds1.graph(:lines, {:x=>:id}, :table_alias=>:planes)
+    ds.sql.must_equal '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 AS planes ON (planes.x = points.id)'
+  end
+
+  it "#graph should accept a :implicit_qualifier option" do
+    ds = @ds1.graph(:lines, {:x=>:id}, :implicit_qualifier=>:planes)
+    ds.sql.must_equal '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 = planes.id)'
+  end
+
+  it "#graph should accept a :join_type option" do
+    ds = @ds1.graph(:lines, {:x=>:id}, :join_type=>:inner)
+    ds.sql.must_equal '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 :join_only option" do
+    ds = @ds1.graph(:lines, {:x=>:id}, :join_only=>true)
+    ds.sql.must_equal 'SELECT * FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+  end
+
+  it "#graph should not select any columns from the graphed table if :select option is false" do
+    ds = @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id)
+    ds.sql.must_equal '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 use the given columns if :select option is used" do
+    ds = @ds1.graph(:lines, {:x=>:id}, :select=>[:x, :graph_id]).graph(:graphs, :id=>:graph_id)
+    ds.sql.must_equal 'SELECT points.id, points.x, points.y, lines.x AS lines_x, 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 pass all join_conditions to join_table" do
+    ds = @ds1.graph(@ds2, [[:x, :id], [:y, :id]])
+    ds.sql.must_equal '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
+
+  it "#graph should accept a block instead of conditions and pass it to join_table" do
+    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.must_equal '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
+
+  it "#graph should raise Error if set_graph_aliases is called on an ungraphed dataset" do
+    proc{@ds1.set_graph_aliases([[:x,[:points, :x]], [:y,[:lines, :y]]])}.must_raise Sequel::Error
+  end
+
+  it "#graph should allow graphing of multiple datasets" do
+    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id)
+    ds.sql.must_equal '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=>Sequel[:points][:id]}, :table_alias=>:graph)
+    ds.sql.must_equal '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 AS graph ON (graph.y = points.id)'
+  end
+
+  with_symbol_splitting "#graph should allow graphing of the same dataset multiple times when using splittable symbols" do
+    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph)
+    ds.sql.must_equal '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 AS 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)}.must_raise(Sequel::Error)
+    @ds1.graph(@ds2, :x=>:id)
+    proc{@ds1.graph(@ds2, :x=>:id).graph(@ds2, :x=>:id)}.must_raise(Sequel::Error)
+    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:x=>:id}, :table_alias=>:blah)
+  end
+
+  it "#graph should handle ColumnAll values in selections" do
+    @ds1.select_all(:points).graph(:lines, :x=>:id).sql.must_equal "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)"
+    @ds1.from{points}.select_all(:points).graph(:lines, :x=>:id).sql.must_equal "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)"
+    @ds1.select_all(:points).graph(:lines, :x=>:id).sql.must_equal "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)"
+    @ds1.from_self(:alias=>:p).select_all(:p).graph(:lines, :x=>:id).sql.must_equal "SELECT p.id, p.x, p.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM (SELECT * FROM points) AS p LEFT OUTER JOIN lines ON (lines.x = p.id)"
+    @ds1.from{points.as(p)}.select_all(:p).graph(:lines, :x=>:id).sql.must_equal "SELECT p.id, p.x, p.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points AS p LEFT OUTER JOIN lines ON (lines.x = p.id)"
+    @ds1.from(Sequel[:s][:points]).select_all(Sequel[:s][:points]).graph(:lines, :x=>:id).sql.must_equal "SELECT s.points.id, s.points.x, s.points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM s.points LEFT OUTER JOIN lines ON (lines.x = s.points.id)"
+    @ds1.from(Sequel[:s][:points].as(:p)).select_all(:p).graph(:lines, :x=>:id).sql.must_equal "SELECT p.id, p.x, p.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM s.points AS p LEFT OUTER JOIN lines ON (lines.x = p.id)"
+
+    @ds1.select_all('points').graph(:lines, :x=>:id).sql.must_equal "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)"
+    @ds1.from_self(:alias=>'p').select_all(:p).graph(:lines, :x=>:id).sql.must_equal "SELECT p.id, p.x, p.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM (SELECT * FROM points) AS p LEFT OUTER JOIN lines ON (lines.x = p.id)"
+
+    @ds1.select_all(Sequel.identifier('points')).graph(:lines, :x=>:id).sql.must_equal "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)"
+    @ds1.from_self(:alias=>Sequel.identifier(:p)).select_all(:p).graph(:lines, :x=>:id).sql.must_equal "SELECT p.id, p.x, p.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM (SELECT * FROM points) AS p LEFT OUTER JOIN lines ON (lines.x = p.id)"
+
+    ds = @ds1.select_all(:points).select_append{(points[:id]+lines[:id]).as(:id2)}.join(:lines, :x=>:id)
+    ds.columns :id, :x, :y, :id2
+    ds.graph(:graphs, :id=>:graph_id).sql.must_equal "SELECT points.id, points.x, points.y, points.id2, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x FROM (SELECT points.*, (points.id + lines.id) AS id2 FROM points INNER JOIN lines ON (lines.x = points.id)) AS points LEFT OUTER JOIN graphs ON (graphs.id = points.graph_id)"
+
+    ds = @ds1.select_all(:lines).select_append{(points[:id]+lines[:id]).as(:id2)}.join(:lines, :x=>:id)
+    ds.columns :id, :x, :y, :graph_id, :id2
+    ds.graph(:graphs, :id=>:graph_id).sql.must_equal "SELECT points.id, points.x, points.y, points.graph_id, points.id2, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x FROM (SELECT lines.*, (points.id + lines.id) AS id2 FROM points INNER JOIN lines ON (lines.x = points.id)) AS points LEFT OUTER JOIN graphs ON (graphs.id = points.graph_id)"
+
+    ds = @ds1.select_all(:l).select_append{(points[:id]+lines[:id]).as(:id2)}.join(Sequel[:lines].as(:l), :x=>:id)
+    ds.columns :id, :x, :y, :graph_id, :id2
+    ds.graph(:graphs, :id=>:graph_id).sql.must_equal "SELECT points.id, points.x, points.y, points.graph_id, points.id2, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x FROM (SELECT l.*, (points.id + lines.id) AS id2 FROM points INNER JOIN lines AS l ON (l.x = points.id)) AS points LEFT OUTER JOIN graphs ON (graphs.id = points.graph_id)"
+
+    ds = @ds1.select_all(:l).select_append{(points[:id]+lines[:id]).as(:id2)}.join(Sequel.as(:lines, :l), :x=>:id)
+    ds.columns :id, :x, :y, :graph_id, :id2
+    ds.graph(:graphs, :id=>:graph_id).sql.must_equal "SELECT points.id, points.x, points.y, points.graph_id, points.id2, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x FROM (SELECT l.*, (points.id + lines.id) AS id2 FROM points INNER JOIN lines AS l ON (l.x = points.id)) AS points LEFT OUTER JOIN graphs ON (graphs.id = points.graph_id)"
+
+    ds = @ds1.select_all(:l).select_append{(points[:id]+lines[:id]).as(:id2)}.join(@ds1.db[:graphs].as(:l), :id=>:y)
+    ds.columns :id, :name, :x, :y, :lines_x, :id2
+    ds.graph(:lines, :x=>:id).sql.must_equal "SELECT points.id, points.name, points.x, points.y, points.lines_x, points.id2, lines.id AS lines_id, lines.x AS lines_x_0, lines.y AS lines_y, lines.graph_id FROM (SELECT l.*, (points.id + lines.id) AS id2 FROM points INNER JOIN (SELECT * FROM graphs) AS l ON (l.id = points.y)) AS points LEFT OUTER JOIN lines ON (lines.x = points.id)"
+  end
+
+  it "#set_graph_aliases should not modify the current dataset's opts" do
+    o1 = @ds1.opts
+    o2 = o1.dup
+    ds1 = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:graphs,:id])
+    @ds1.opts.must_equal o1
+    @ds1.opts.must_equal o2
+    ds1.opts.wont_equal o1
+  end
+
+  it "#set_graph_aliases should specify the graph mapping" do
+    ds = @ds1.graph(:lines, :x=>:id)
+    ds.sql.must_equal '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.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+  end
+
+  it "#set_graph_aliases should allow a third entry to specify an expression to use other than the default" do
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x, 1], :y=>[:lines, :y, Sequel.function(:random)]).sql.must_equal 'SELECT 1 AS x, random() AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+  end
+
+  it "#set_graph_aliases should allow a single array entry to specify a table, assuming the same column as the key" do
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+  end
+
+  it "#set_graph_aliases should allow hash values to be symbols specifying table, assuming the same column as the key" do
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+  end
+
+  it "#set_graph_aliases should only alias columns if necessary" do
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+  end
+
+  it "#set_graph_aliases should only alias columns if necessary" do
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x1=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x AS x1, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+  end
+
+  it "#add_graph_aliases should not modify the current dataset's opts" do
+    ds1 = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:graphs,:id])
+    o1 = ds1.opts
+    o2 = o1.dup
+    ds2 = ds1.add_graph_aliases(:y=>[:blah,:id])
+    ds1.opts.must_equal o1
+    ds1.opts.must_equal o2
+    ds2.opts.wont_equal o1
+  end
+
+  it "#add_graph_aliases should add columns to the graph mapping" do
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :q]).add_graph_aliases(:y=>[:lines, :r]).sql.must_equal 'SELECT points.q AS x, lines.r AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+  end
+
+  it "#add_graph_aliases should raise an error if called without existing graph aliases" do
+    proc{@ds1.add_graph_aliases(:y=>[:lines, :r])}.must_raise(Sequel::Error)
+  end
+
+  it "#ungraphed should remove the splitting of result sets into component tables" do
+    @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.must_equal [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}]
   end
 end