sequel 4.36.0 → 5.61.0

data/spec/core/object_graph_spec.rb

@@ -1,303 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
-
-describe Sequel::Dataset, "graphing" do
-  before do
-    @db = Sequel.mock(:columns=>proc do |sql|
-      case sql
-      when /points/
-        [:id, :x, :y]
-      when /lines|foo/
-        [: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
-
-  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(: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
-
-    it "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 "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
-
-    it "should handle a qualified identifier 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)'
-      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
-
-    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(: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)'
-      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 not add columns if graph is called after set_graph_aliases" do
-      ds = @ds1.set_graph_aliases([[:x,[:points, :x]], [:y,[:lines, :y]]])
-      ds.sql.must_equal 'SELECT points.x, lines.y FROM points'
-      ds = ds.graph(:lines, :x=>:id)
-      ds.sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    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=>: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.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 = 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)'
-      ].must_include(ds.sql)
-    end
-
-    it "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, 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)'
-      ].must_include(ds.sql)
-    end
-
-    it "should allow a single array entry to specify a table, assuming the same column as the key" do
-      ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines])
-      ['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)'
-      ].must_include(ds.sql)
-    end
-
-    it "should allow hash values to be symbols specifying table, assuming the same column as the key" do
-      ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines)
-      ['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)'
-      ].must_include(ds.sql)
-    end
-
-    it "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'
-      ].must_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'
-      ].must_include(ds.sql)
-    end
-  end
-
-  describe "#add_graph_aliases" do
-    it "should not modify the current dataset's opts" do
-      ds1 = @ds1.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
-  end
-end

data/spec/core/placeholder_literalizer_spec.rb

@@ -1,163 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Dataset::PlaceholderLiteralizer" do
-  before do
-    @c = Sequel::Dataset::PlaceholderLiteralizer
-    @db = Sequel.mock
-    @ds = @db[:items]
-    @h = {:id=>1}
-    @ds.db.fetch = @h
-  end
-  
-  it "should handle calls with no placeholders" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>1)}
-    loader.first.must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)"]
-  end
-  
-  it "should handle calls with a single placeholder" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
-    loader.first(1).must_equal @h
-    loader.first(2).must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)", "SELECT * FROM items WHERE (a = 2)"]
-  end
-  
-  it "should handle calls with multiple placeholders" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg).where(:b=>Sequel.+(pl.arg, 1)).where(pl.arg)}
-    loader.first(1, :c, :id=>1).must_equal @h
-    loader.first(2, :d, :id=>2).must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE ((a = 1) AND (b = (c + 1)) AND (id = 1))", "SELECT * FROM items WHERE ((a = 2) AND (b = (d + 1)) AND (id = 2))"]
-  end
-  
-  it "should handle calls with placeholders and delayed arguments" do
-    h = :h
-    s = :s
-    d = @ds.having(Sequel.delay{h}).select(Sequel.delay{s})
-    loader = @c.loader(d){|pl, ds| ds.where(:a=>pl.arg).where(:b=>Sequel.+(pl.arg, 1)).where(pl.arg)}
-    loader.first(1, :c, :id=>1).must_equal @h
-    h = :h2
-    s = :s2
-    loader.first(2, :d, :id=>2).must_equal @h
-    @db.sqls.must_equal ["SELECT s FROM items WHERE ((a = 1) AND (b = (c + 1)) AND (id = 1)) HAVING h", "SELECT s2 FROM items WHERE ((a = 2) AND (b = (d + 1)) AND (id = 2)) HAVING h2"]
-  end
-  
-  it "should handle calls with placeholders and delayed arguments that take dataset argument" do
-    d = @ds.select(Sequel.delay{|ds| ds.first_source})
-    loader = @c.loader(d){|pl, ds| ds.where(:a=>pl.arg).where(:b=>Sequel.+(pl.arg, 1)).where(pl.arg)}
-    loader.first(1, :c, :id=>1).must_equal @h
-    loader.first(2, :d, :id=>2).must_equal @h
-    @db.sqls.must_equal ["SELECT items FROM items WHERE ((a = 1) AND (b = (c + 1)) AND (id = 1))", "SELECT items FROM items WHERE ((a = 2) AND (b = (d + 1)) AND (id = 2))"]
-  end
-  
-  it "should handle calls with a placeholders used as filter arguments" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg)}
-    loader.first(:id=>1).must_equal @h
-    loader.first(proc{a(b)}).must_equal @h
-    loader.first("a = 1").must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (id = 1)", "SELECT * FROM items WHERE a(b)", "SELECT * FROM items WHERE (a = 1)"]
-  end
-  
-  it "should handle calls with a placeholders used as right hand side of condition specifiers" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
-    loader.first(1).must_equal @h
-    loader.first([1, 2]).must_equal @h
-    loader.first(nil).must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)", "SELECT * FROM items WHERE (a IN (1, 2))", "SELECT * FROM items WHERE (a IS NULL)"]
-  end
-  
-  it "should handle calls with a placeholder used multiple times" do
-    loader = @c.loader(@ds){|pl, ds| a = pl.arg; ds.where(:a=>a).where(:b=>a)}
-    loader.first(1).must_equal @h
-    loader.first(2).must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE ((a = 1) AND (b = 1))", "SELECT * FROM items WHERE ((a = 2) AND (b = 2))"]
-  end
-  
-  it "should handle calls with a placeholder used multiple times in different capacities" do
-    loader = @c.loader(@ds){|pl, ds| a = pl.arg; ds.where(a).where(:b=>a)}
-    loader.first("a = 1").must_equal @h
-    loader.first(["a = ?", 2]).must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE ((a = 1) AND (b = 'a = 1'))", "SELECT * FROM items WHERE ((a = 2) AND (b IN ('a = ?', 2)))"]
-  end
-  
-  it "should handle calls with manually specified argument positions" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg(1)).where(:b=>pl.arg(0))}
-    loader.first(1, 2).must_equal @h
-    loader.first(2, 1).must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE ((a = 2) AND (b = 1))", "SELECT * FROM items WHERE ((a = 1) AND (b = 2))"]
-  end
-  
-  it "should handle dataset with row procs" do
-    @ds.row_proc = proc{|r| {:foo=>r[:id]+1}}
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
-    loader.first(1).must_equal(:foo=>2)
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)"]
-  end
-  
-  it "should return all rows for #all" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
-    loader.all(1).must_equal [@h]
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)"]
-  end
-  
-  it "should iterate over block for #all" do
-    a = []
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
-    loader.all(1){|r| a << r}.must_equal [@h]
-    a.must_equal [@h]
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)"]
-  end
-  
-  it "should iterate over block for #each" do
-    a = []
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
-    loader.each(1){|r| a << r}
-    a.must_equal [@h]
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)"]
-  end
-  
-  it "should return first value for #get" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
-    loader.get(2).must_equal 1
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 2)"]
-  end
-
-  it "should support modifying dataset used on per-call basis with #run" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
-    loader.with_dataset do |ds|
-      ds = ds.clone
-      ds.row_proc = lambda{|row| [row]}
-      ds
-    end.all(1).must_equal [[@h]]
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)"]
-  end
-  
-  it "should literalize args as NULL if :placeholder_literal_null is set" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg=>:a).clone(:placeholder_literal_null=>true)}
-    loader.sql(1).must_equal "SELECT * FROM items WHERE (NULL = a)"
-  end
-  
-  it "should raise an error if called with an incorrect number of arguments" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
-    proc{loader.first}.must_raise(Sequel::Error)
-    proc{loader.first(1, 2)}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if called with an incorrect number of arguments when manually providing argument positions" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg(1))}
-    proc{loader.first}.must_raise(Sequel::Error)
-    proc{loader.first(1)}.must_raise(Sequel::Error)
-    proc{loader.first(1, 2, 3)}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if argument literalized into a different string than returned by query" do
-    o = Object.new
-    def o.wrap(v)
-      @v = v
-      self
-    end
-    def o.sql_literal(ds)
-      ds.literal(@v)
-    end
-    proc{@c.loader(@ds){|pl, ds| ds.where(o.wrap(pl.arg))}}.must_raise(Sequel::Error)
-  end
-end

data/spec/core/schema_generator_spec.rb

@@ -1,203 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
-
-describe Sequel::Schema::Generator do
-  before 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}}
-      index :title
-      index [:title, :body], :unique => true
-      foreign_key :node_id, :nodes
-      foreign_key :deferrable_node_id, :nodes, :deferrable => true
-      primary_key [:title, :parent_id], :name => :cpk
-      foreign_key [:node_id, :prop_id], :nodes_props, :name => :cfk
-    end
-    @columns, @indexes, @constraints = @generator.columns, @generator.indexes, @generator.constraints
-  end
-  
-  it "should respond to everything" do
-    @generator.respond_to?(:foo).must_equal true
-  end if RUBY_VERSION >= '1.9'
-
-  it "should primary key column first" do
-    @columns.first[:name].must_equal :id
-    @columns.first[:primary_key].must_equal true
-    @columns[3][:name].must_equal :parent_id
-    @columns[3][:primary_key].must_equal nil
-  end
-  
-  it "should respect existing column order if primary_key :keep_order is used" do
-    generator = Sequel::Schema::Generator.new(Sequel.mock) do
-      string :title
-      primary_key :id, :keep_order=>true
-    end
-
-    columns = generator.columns
-    columns.last[:name].must_equal :id
-    columns.last[:primary_key].must_equal true
-    columns.first[:name].must_equal :title
-    columns.first[:primary_key].must_equal nil
-  end
-  
-  it "should handle SQL::Identifier and SQL::QualifiedIdentifier as foreign_key arguments" do
-    generator = Sequel::Schema::Generator.new(Sequel.mock) do
-      foreign_key :a_id, Sequel.identifier(:as)
-      foreign_key :b_id, Sequel.qualify(:c, :b)
-    end
-
-    columns = generator.columns
-    columns.first.values_at(:name, :table).must_equal [:a_id, Sequel.identifier(:as)]
-    columns.last.values_at(:name, :table).must_equal [:b_id, Sequel.qualify(:c, :b)]
-  end
-  
-  it "counts definitions correctly" do
-    @columns.size.must_equal 6
-    @indexes.size.must_equal 2
-    @constraints.size.must_equal 4
-  end
-  
-  it "retrieves primary key name" do
-    @generator.primary_key_name.must_equal :id
-  end
-
-  it "keeps columns in order" do
-    @columns[1][:name].must_equal :title
-    @columns[1][:type].must_equal :string
-    @columns[2][:name].must_equal :body
-    @columns[2][:type].must_equal :text
-  end
-  
-  it "creates foreign key column" do
-    @columns[3][:name].must_equal :parent_id
-    @columns[3][:type].must_equal Integer
-    @columns[4][:name].must_equal :node_id
-    @columns[4][:type].must_equal Integer
-  end
-
-  it "creates deferrable altered foreign key column" do
-    @columns[5][:name].must_equal :deferrable_node_id
-    @columns[5][:type].must_equal Integer
-    @columns[5][:deferrable].must_equal true
-  end
-  
-  it "uses table for foreign key columns, if specified" do
-    @columns[3][:table].must_equal nil
-    @columns[4][:table].must_equal :nodes
-    @constraints[3][:table].must_equal :nodes_props
-  end
-  
-  it "finds columns" do
-    [:title, :body, :parent_id, :id].each do |col|
-      @generator.has_column?(col).must_equal true
-    end
-    @generator.has_column?(:foo).wont_equal true
-  end
-  
-  it "creates constraints" do
-    @constraints[0][:name].must_equal nil
-    @constraints[0][:type].must_equal :check
-    @constraints[0][:check].must_equal ['price > 100']
-
-    @constraints[1][:name].must_equal :xxx
-    @constraints[1][:type].must_equal :check
-    @constraints[1][:check].must_be_kind_of Proc
-
-    @constraints[2][:name].must_equal :cpk
-    @constraints[2][:type].must_equal :primary_key
-    @constraints[2][:columns].must_equal [ :title, :parent_id ]
-
-    @constraints[3][:name].must_equal :cfk
-    @constraints[3][:type].must_equal :foreign_key
-    @constraints[3][:columns].must_equal [ :node_id, :prop_id ]
-    @constraints[3][:table].must_equal :nodes_props
-  end
-  
-  it "creates indexes" do
-    @indexes[0][:columns].must_include(:title)
-    @indexes[1][:columns].must_include(:title)
-    @indexes[1][:columns].must_include(:body)
-  end
-end
-
-describe Sequel::Schema::AlterTableGenerator do
-  before do
-    @generator = Sequel::Schema::AlterTableGenerator.new(Sequel.mock) do
-      add_column :aaa, :text
-      drop_column :bbb
-      rename_column :ccc, :ho
-      set_column_type :ddd, :float
-      set_column_default :eee, 1
-      add_index [:fff, :ggg]
-      drop_index :hhh
-      drop_index :hhh, :name=>:blah_blah
-      add_full_text_index :blah
-      add_spatial_index :geom
-      add_index :blah, :type => :hash
-      add_index :blah, :where => {:something => true}
-      add_constraint :con1, 'fred > 100'
-      drop_constraint :con2
-      add_unique_constraint [:aaa, :bbb, :ccc], :name => :con3
-      add_primary_key :id
-      add_foreign_key :node_id, :nodes
-      add_primary_key [:aaa, :bbb]
-      add_foreign_key [:node_id, :prop_id], :nodes_props
-      add_foreign_key [:node_id, :prop_id], :nodes_props, :name => :fkey
-      drop_foreign_key :node_id
-      drop_foreign_key [:node_id, :prop_id]
-      drop_foreign_key [:node_id, :prop_id], :name => :fkey
-    end
-  end
-  
-  it "should generate operation records" do
-    @generator.operations.must_equal [
-      {:op => :add_column, :name => :aaa, :type => :text},
-      {:op => :drop_column, :name => :bbb},
-      {:op => :rename_column, :name => :ccc, :new_name => :ho},
-      {:op => :set_column_type, :name => :ddd, :type => :float},
-      {:op => :set_column_default, :name => :eee, :default => 1},
-      {:op => :add_index, :columns => [:fff, :ggg]},
-      {:op => :drop_index, :columns => [:hhh]},
-      {:op => :drop_index, :columns => [:hhh], :name=>:blah_blah},
-      {:op => :add_index, :columns => [:blah], :type => :full_text},
-      {:op => :add_index, :columns => [:geom], :type => :spatial},
-      {:op => :add_index, :columns => [:blah], :type => :hash},
-      {:op => :add_index, :columns => [:blah], :where => {:something => true}},
-      {:op => :add_constraint, :type => :check, :name => :con1, :check => ['fred > 100']},
-      {:op => :drop_constraint, :name => :con2},
-      {:op => :add_constraint, :type => :unique, :name => :con3, :columns => [:aaa, :bbb, :ccc]},
-      {:op => :add_column, :name => :id, :type => Integer, :primary_key=>true, :auto_increment=>true},
-      {:op => :add_column, :name => :node_id, :type => Integer, :table=>:nodes},
-      {:op => :add_constraint, :type => :primary_key, :columns => [:aaa, :bbb]},
-      {:op => :add_constraint, :type => :foreign_key, :columns => [:node_id, :prop_id], :table => :nodes_props},
-      {:op => :add_constraint, :type => :foreign_key, :columns => [:node_id, :prop_id], :table => :nodes_props, :name => :fkey},
-      {:op => :drop_constraint, :type => :foreign_key, :columns => [:node_id]},
-      {:op => :drop_column, :name => :node_id},
-      {:op => :drop_constraint, :type => :foreign_key, :columns => [:node_id, :prop_id]},
-      {:op => :drop_constraint, :type => :foreign_key, :columns => [:node_id, :prop_id], :name => :fkey},
-    ]
-  end
-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(Sequel.mock) do
-      String :a
-      Integer :b
-      Fixnum :c
-      Bignum :d
-      Float :e
-      BigDecimal :f
-      Date :g
-      DateTime :h
-      Time :i
-      Numeric :j
-      File :k
-      TrueClass :l
-      FalseClass :m
-    end.columns.map{|c| c[:type]}.must_equal [String, Integer, Fixnum, :Bignum, Float, BigDecimal, Date, DateTime, Time, Numeric, File, TrueClass, FalseClass]
-  end
-end