sequel 4.45.0 → 4.46.0

data/spec/integration/spec_helper.rb

@@ -26,7 +26,7 @@ Sequel::Model.cache_anonymous_models = false
 
 require './spec/guards_helper'
 
-IDENTIFIER_MANGLING = !ENV['SEQUEL_NO_MANGLE'] unless defined?(IDENTIFIER_MANGLING)
+IDENTIFIER_MANGLING = !!ENV['SEQUEL_IDENTIFIER_MANGLING'] unless defined?(IDENTIFIER_MANGLING)
 
 unless defined?(DB)
   # SEQUEL5: Remove :identifier_mangling=>false

data/spec/model/associations_spec.rb

@@ -2027,13 +2027,19 @@ describe Sequel::Model, "many_to_many" do
     @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT attributes.id, attributes.b FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
   end
   
-  it "should not override a selection consisting completely of qualified columns using symbols" do
+  with_symbol_splitting "should not override a selection consisting completely of qualified columns using symbols" do
     @c1.dataset = @c1.dataset.select(:attributes__id, :attributes__b)
     @c2.many_to_many :attributes, :class => @c1
     @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT attributes.id, attributes.b FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
   end
   
   it "should not override a selection consisting completely of qualified columns using Sequel::SQL::AliasedExpression" do
+    @c1.dataset = @c1.dataset.select(Sequel.qualify(:attributes, :id).as(:a), Sequel[:attributes][:b].as(:c))
+    @c2.many_to_many :attributes, :class => @c1
+    @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT attributes.id AS a, attributes.b AS c FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
+  end
+  
+  with_symbol_splitting "should not override a selection consisting completely of qualified columns using Sequel::SQL::AliasedExpression with qualified symbol" do
     @c1.dataset = @c1.dataset.select(Sequel.qualify(:attributes, :id).as(:a), Sequel.as(:attributes__b, :c))
     @c2.many_to_many :attributes, :class => @c1
     @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT attributes.id AS a, attributes.b AS c FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
@@ -2046,7 +2052,7 @@ describe Sequel::Model, "many_to_many" do
   end
   
   it "should respect :eager_loader_predicate_key when lazily loading" do
-    @c2.many_to_many :attributes, :class => @c1, :eager_loading_predicate_key=>Sequel.subscript(:attributes_nodes__node_id, 0)
+    @c2.many_to_many :attributes, :class => @c1, :eager_loading_predicate_key=>Sequel.subscript(Sequel[:attributes_nodes][:node_id], 0)
     @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id[0] = 1234)'
   end
   
@@ -2059,7 +2065,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1, :conditions => {:a=>32}
     @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((a = 32) AND (attributes_nodes.node_id = 1234))'
 
-    @c2.many_to_many :attributes, :class => @c1, :conditions => ['a = ?', 32]
+    @c2.many_to_many :attributes, :class => @c1, :conditions => Sequel.lit('a = ?', 32)
     @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((a = 32) AND (attributes_nodes.node_id = 1234))'
     @c2.new(:id => 1234).attributes.must_equal [@c1.load({})]
   end
@@ -2110,7 +2116,7 @@ describe Sequel::Model, "many_to_many" do
   end
   
   it "should support an array for the select option" do
-    @c2.many_to_many :attributes, :class => @c1, :select => [Sequel::SQL::ColumnAll.new(:attributes), :attribute_nodes__blah2]
+    @c2.many_to_many :attributes, :class => @c1, :select => [Sequel::SQL::ColumnAll.new(:attributes), Sequel[:attribute_nodes][:blah2]]
 
     @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT attributes.*, attribute_nodes.blah2 FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
   end
@@ -2137,7 +2143,7 @@ describe Sequel::Model, "many_to_many" do
 
   it "should support a :dataset option that is used instead of the default" do
     c1 = @c1
-    @c2.many_to_many :attributes, :class => @c1, :dataset=>proc{c1.join_table(:natural, :an).filter(:an__nodeid=>pk)}, :order=> :a, :limit=>10, :select=>nil do |ds|
+    @c2.many_to_many :attributes, :class => @c1, :dataset=>proc{c1.join_table(:natural, :an).filter(Sequel[:an][:nodeid]=>pk)}, :order=> :a, :limit=>10, :select=>nil do |ds|
       ds.filter(:xxx => @xxx)
     end
 
@@ -2149,7 +2155,7 @@ describe Sequel::Model, "many_to_many" do
   end
 
   it "should support a :dataset option that accepts the reflection as an argument" do
-    @c2.many_to_many :attributes, :class => @c1, :dataset=>lambda{|opts| opts.associated_class.natural_join(:an).filter(:an__nodeid=>pk)}, :order=> :a, :limit=>10, :select=>nil do |ds|
+    @c2.many_to_many :attributes, :class => @c1, :dataset=>lambda{|opts| opts.associated_class.natural_join(:an).filter(Sequel[:an][:nodeid]=>pk)}, :order=> :a, :limit=>10, :select=>nil do |ds|
       ds.filter(:xxx => @xxx)
     end
 
@@ -2173,6 +2179,22 @@ describe Sequel::Model, "many_to_many" do
   end
   
   it "should handle an aliased join table" do
+    @c2.many_to_many :attributes, :class => @c1, :join_table => Sequel[:attribute2node].as(:attributes_nodes)
+    n = @c2.load(:id => 1234)
+    a = @c1.load(:id => 2345)
+    n.attributes_dataset.sql.must_equal "SELECT attributes.* FROM attributes INNER JOIN attribute2node AS attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)"
+    a.must_equal n.add_attribute(a)
+    a.must_equal n.remove_attribute(a)
+    n.remove_all_attributes
+    sqls = DB.sqls
+    ['INSERT INTO attribute2node (node_id, attribute_id) VALUES (1234, 2345)',
+     'INSERT INTO attribute2node (attribute_id, node_id) VALUES (2345, 1234)'].must_include(sqls.shift)
+    ["DELETE FROM attribute2node WHERE ((node_id = 1234) AND (attribute_id = 2345))", 
+     "DELETE FROM attribute2node WHERE ((attribute_id = 2345) AND (node_id = 1234))"].must_include(sqls.shift)
+    sqls.must_equal ["DELETE FROM attribute2node WHERE (node_id = 1234)"]
+  end
+  
+  with_symbol_splitting "should handle an aliased symbol join table" do
     @c2.many_to_many :attributes, :class => @c1, :join_table => :attribute2node___attributes_nodes
     n = @c2.load(:id => 1234)
     a = @c1.load(:id => 2345)
@@ -2861,7 +2883,7 @@ describe Sequel::Model, "one_through_one" do
   end
   
   it "should respect :eager_loader_predicate_key when lazily loading" do
-    @c2.one_through_one :attribute, :class => @c1, :eager_loading_predicate_key=>Sequel.subscript(:attributes_nodes__node_id, 0)
+    @c2.one_through_one :attribute, :class => @c1, :eager_loading_predicate_key=>Sequel.subscript(Sequel[:attributes_nodes][:node_id], 0)
     @c2.new(:id => 1234).attribute_dataset.sql.must_equal 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id[0] = 1234) LIMIT 1'
   end
   
@@ -2874,7 +2896,7 @@ describe Sequel::Model, "one_through_one" do
     @c2.one_through_one :attribute, :class => @c1, :conditions => {:a=>32}
     @c2.new(:id => 1234).attribute_dataset.sql.must_equal 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((a = 32) AND (attributes_nodes.node_id = 1234)) LIMIT 1'
 
-    @c2.one_through_one :attribute, :class => @c1, :conditions => ['a = ?', 32]
+    @c2.one_through_one :attribute, :class => @c1, :conditions => Sequel.lit('a = ?', 32)
     @c2.new(:id => 1234).attribute_dataset.sql.must_equal 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((a = 32) AND (attributes_nodes.node_id = 1234)) LIMIT 1'
     @c2.new(:id => 1234).attribute.must_equal @c1.load({})
   end
@@ -2925,7 +2947,7 @@ describe Sequel::Model, "one_through_one" do
   end
   
   it "should support an array for the select option" do
-    @c2.one_through_one :attribute, :class => @c1, :select => [Sequel::SQL::ColumnAll.new(:attributes), :attribute_nodes__blah2]
+    @c2.one_through_one :attribute, :class => @c1, :select => [Sequel::SQL::ColumnAll.new(:attributes), Sequel[:attribute_nodes][:blah2]]
 
     @c2.new(:id => 1234).attribute_dataset.sql.must_equal 'SELECT attributes.*, attribute_nodes.blah2 FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 1'
   end
@@ -2952,7 +2974,7 @@ describe Sequel::Model, "one_through_one" do
 
   it "should support a :dataset option that is used instead of the default" do
     c1 = @c1
-    @c2.one_through_one :attribute, :class => @c1, :dataset=>proc{c1.join_table(:natural, :an).filter(:an__nodeid=>pk)}, :order=> :a, :select=>nil do |ds|
+    @c2.one_through_one :attribute, :class => @c1, :dataset=>proc{c1.join_table(:natural, :an).filter(Sequel[:an][:nodeid]=>pk)}, :order=> :a, :select=>nil do |ds|
       ds.filter(:xxx => @xxx)
     end
 
@@ -2964,7 +2986,7 @@ describe Sequel::Model, "one_through_one" do
   end
 
   it "should support a :dataset option that accepts the reflection as an argument" do
-    @c2.one_through_one :attribute, :class => @c1, :dataset=>lambda{|opts| opts.associated_class.natural_join(:an).filter(:an__nodeid=>pk)}, :order=> :a, :select=>nil do |ds|
+    @c2.one_through_one :attribute, :class => @c1, :dataset=>lambda{|opts| opts.associated_class.natural_join(:an).filter(Sequel[:an][:nodeid]=>pk)}, :order=> :a, :select=>nil do |ds|
       ds.filter(:xxx => @xxx)
     end
 
@@ -2986,6 +3008,12 @@ describe Sequel::Model, "one_through_one" do
   end
   
   it "should handle an aliased join table" do
+    @c2.one_through_one :attribute, :class => @c1, :join_table => Sequel[:attribute2node].as(:attributes_nodes)
+    n = @c2.load(:id => 1234)
+    n.attribute_dataset.sql.must_equal "SELECT attributes.* FROM attributes INNER JOIN attribute2node AS attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 1"
+  end
+  
+  with_symbol_splitting "should handle an aliased join table with splittable symbol" do
     @c2.one_through_one :attribute, :class => @c1, :join_table => :attribute2node___attributes_nodes
     n = @c2.load(:id => 1234)
     n.attribute_dataset.sql.must_equal "SELECT attributes.* FROM attributes INNER JOIN attribute2node AS attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 1"

data/spec/model/base_spec.rb

@@ -123,19 +123,19 @@ describe Sequel::Model, ".def_dataset_method" do
     @c = Class.new(Sequel::Model(:items))
   end
   
-  it "should add a method to the dataset and model if called with a block argument" do
+  deprecated "should add a method to the dataset and model if called with a block argument" do
     @c.def_dataset_method(:return_3){3}
     @c.return_3.must_equal 3
     @c.dataset.return_3.must_equal 3
   end
 
-  it "should handle weird method names" do
+  deprecated "should handle weird method names" do
     @c.def_dataset_method(:"return 3"){3}
     @c.send(:"return 3").must_equal 3
     @c.dataset.send(:"return 3").must_equal 3
   end
 
-  it "should not add a model method if the model already responds to the method" do
+  deprecated "should not add a model method if the model already responds to the method" do
     @c.instance_eval do
       def foo
         1
@@ -156,7 +156,7 @@ describe Sequel::Model, ".def_dataset_method" do
     @c.dataset.bar.must_equal 4
   end
 
-  it "should add all passed methods to the model if called without a block argument" do
+  deprecated "should add all passed methods to the model if called without a block argument" do
     @c.def_dataset_method(:return_3, :return_4)
     proc{@c.return_3}.must_raise(NoMethodError)
     proc{@c.return_4}.must_raise(NoMethodError)
@@ -168,14 +168,14 @@ describe Sequel::Model, ".def_dataset_method" do
     @c.return_4.must_equal 4
   end
 
-  it "should cache calls and readd methods if set_dataset is used" do
+  deprecated "should cache calls and readd methods if set_dataset is used" do
     @c.def_dataset_method(:return_3){3}
     @c.set_dataset :items
     @c.return_3.must_equal 3
     @c.dataset.return_3.must_equal 3
   end
 
-  it "should readd methods to subclasses, if set_dataset is used in a subclass" do
+  deprecated "should readd methods to subclasses, if set_dataset is used in a subclass" do
     @c.def_dataset_method(:return_3){3}
     c = Class.new(@c)
     c.set_dataset :items
@@ -209,6 +209,13 @@ describe Sequel::Model, ".dataset_module" do
     @c.return_3.must_equal 3
   end
 
+  it "should not add private or protected methods defined in the module to the class" do
+    @c.dataset_module{private; def return_3() 3 end}
+    @c.dataset_module{protected; def return_4() 4 end}
+    @c.respond_to?(:return_3).must_equal false
+    @c.respond_to?(:return_4).must_equal false
+  end
+
   it "should cache calls and readd methods if set_dataset is used" do
     @c.dataset_module{def return_3() 3 end}
     @c.set_dataset :items
@@ -562,25 +569,26 @@ describe "Model.db=" do
     @m = Class.new(Sequel::Model(@db1[:blue].filter(:x=>1)))
   end
   
-  it "should affect the underlying dataset" do
+  deprecated "should affect the underlying dataset" do
     @m.db = @db2
     
     @m.dataset.db.must_equal @db2
     @m.dataset.db.wont_equal @db1
   end
 
-  it "should keep the same dataset options" do
+  deprecated "should keep the same dataset options" do
     @m.db = @db2
     @m.dataset.sql.must_equal 'SELECT * FROM blue WHERE (x = 1)'
   end
 
   it "should use the database for subclasses" do
+    @m = Class.new(Sequel::Model)
     @m.db = @db2
     Class.new(@m).db.must_equal @db2
   end
 end
 
-describe Sequel::Model, ".(allowed|restricted)_columns " do
+describe Sequel::Model, ".allowed_columns " do
   before do
     @c = Class.new(Sequel::Model(:blahblah)) do
       columns :x, :y, :z
@@ -590,7 +598,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     DB.reset
   end
   
-  it "should set the allowed columns correctly" do
+  deprecated "should set the allowed columns correctly" do
     @c.allowed_columns.must_be_nil
     @c.set_allowed_columns :x
     @c.allowed_columns.must_equal [:x]
@@ -598,7 +606,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     @c.allowed_columns.must_equal [:x, :y]
   end
 
-  it "should only set allowed columns by default" do
+  deprecated "should only set allowed columns by default" do
     @c.set_allowed_columns :x, :y
     i = @c.new(:x => 1, :y => 2, :z => 3)
     i.values.must_equal(:x => 1, :y => 2)
@@ -655,7 +663,6 @@ describe Sequel::Model, ".strict_param_setting" do
   before do
     @c = Class.new(Sequel::Model(:blahblah)) do
       columns :x, :y, :z, :id
-      set_allowed_columns :x, :y
     end
   end
   
@@ -664,21 +671,24 @@ describe Sequel::Model, ".strict_param_setting" do
   end
 
   it "should raise an error if a missing/restricted column/method is accessed" do
-    proc{@c.new(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
-    proc{@c.create(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{@c.new(:a=>1)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{@c.create(:a=>1)}.must_raise(Sequel::MassAssignmentRestriction)
     c = @c.new
-    proc{c.set(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
-    proc{c.set_all(:use_after_commit_rollback => false)}.must_raise(Sequel::MassAssignmentRestriction)
-    proc{c.set_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
-    proc{c.update(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
-    proc{c.update_all(:use_after_commit_rollback=>false)}.must_raise(Sequel::MassAssignmentRestriction)
-    proc{c.update_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.set(:a=>1)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.update(:a=>1)}.must_raise(Sequel::MassAssignmentRestriction)
+    deprecated do
+      @c.set_allowed_columns :x, :y
+      proc{c.set_all(:use_after_commit_rollback => false)}.must_raise(Sequel::MassAssignmentRestriction)
+      proc{c.set_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
+      proc{c.update_all(:use_after_commit_rollback=>false)}.must_raise(Sequel::MassAssignmentRestriction)
+      proc{c.update_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
+    end
   end
 
   it "should be disabled by strict_param_setting = false" do
     @c.strict_param_setting = false
     @c.strict_param_setting.must_equal false
-    @c.new(:z=>1)
+    @c.new(:a=>1)
   end
 end
 
@@ -737,8 +747,6 @@ describe Sequel::Model, ".[] optimization" do
     @c.simple_table.must_equal 'a'
     @c.set_dataset :b
     @c.simple_table.must_equal 'b'
-    @c.set_dataset :b__a
-    @c.simple_table.must_equal 'b.a'
   end
 
   it "should have simple_table set if passed a simple select all dataset to set_dataset" do
@@ -746,6 +754,13 @@ describe Sequel::Model, ".[] optimization" do
     @c.simple_table.must_equal '"a"'
     @c.set_dataset @ds.from(:b)
     @c.simple_table.must_equal '"b"'
+    @c.set_dataset @ds.from(Sequel[:b][:a])
+    @c.simple_table.must_equal '"b"."a"'
+  end
+
+  with_symbol_splitting "should have simple_table set using qualified symbol" do
+    @c.set_dataset :b__a
+    @c.simple_table.must_equal 'b.a'
     @c.set_dataset @ds.from(:b__a)
     @c.simple_table.must_equal '"b"."a"'
   end
@@ -865,11 +880,16 @@ describe "Model datasets #with_pk with #with_pk!" do
     DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
-  it "should not have #[] consider a string as a primary key lookup" do
+  deprecated "should not have #[] consider a string as a primary key lookup" do
     @ds['foo'].must_equal @c.load(:id=>1)
     DB.sqls.must_equal ["SELECT * FROM a WHERE (foo) LIMIT 1"]
   end
 
+  it "should not have #[] consider a literal string as a primary key lookup" do
+    @ds[Sequel.lit('foo')].must_equal @c.load(:id=>1)
+    DB.sqls.must_equal ["SELECT * FROM a WHERE (foo) LIMIT 1"]
+  end
+
   it "should raise Error if called on a dataset with no primary key" do
     @c.no_primary_key
     @ds.freeze

data/spec/model/class_dataset_methods_spec.rb

@@ -17,7 +17,7 @@ describe Sequel::Model, "class dataset methods"  do
     @db.sqls.must_equal ["SELECT avg(id) AS avg FROM items LIMIT 1"]
     @c.count.must_equal 1
     @db.sqls.must_equal ["SELECT count(*) AS count FROM items LIMIT 1"]
-    @c.cross_join(@c).sql.must_equal "SELECT * FROM items CROSS JOIN items"
+    @c.cross_join(@c.table_name).sql.must_equal "SELECT * FROM items CROSS JOIN items"
     @c.distinct.sql.must_equal "SELECT DISTINCT * FROM items"
     @c.each{|r| r.must_equal @c.load(:id=>1)}.must_equal @d
     @db.sqls.must_equal ["SELECT * FROM items"]
@@ -38,11 +38,11 @@ describe Sequel::Model, "class dataset methods"  do
     @c.for_update.sql.must_equal "SELECT * FROM items FOR UPDATE"
     @c.from.sql.must_equal "SELECT *"
     @c.from_self.sql.must_equal "SELECT * FROM (SELECT * FROM items) AS t1"
-    @c.full_join(@c).sql.must_equal "SELECT * FROM items FULL JOIN items"
-    @c.full_outer_join(@c).sql.must_equal "SELECT * FROM items FULL OUTER JOIN items"
+    @c.full_join(@c.table_name).sql.must_equal "SELECT * FROM items FULL JOIN items"
+    @c.full_outer_join(@c.table_name).sql.must_equal "SELECT * FROM items FULL OUTER JOIN items"
     @c.get(:a).must_equal 1
     @db.sqls.must_equal ["SELECT a FROM items LIMIT 1"]
-    @c.graph(@c, nil, :table_alias=>:a).sql.must_equal "SELECT * FROM items LEFT OUTER JOIN items AS a"
+    @c.graph(@c.table_name, nil, :table_alias=>:a).sql.must_equal "SELECT * FROM items LEFT OUTER JOIN items AS a"
     @db.sqls
     @c.grep(:id, 'a%').sql.must_equal "SELECT * FROM items WHERE ((id LIKE 'a%' ESCAPE '\\'))"
     @c.group(:a).sql.must_equal "SELECT * FROM items GROUP BY a"
@@ -52,18 +52,18 @@ describe Sequel::Model, "class dataset methods"  do
     @c.having(:a).sql.must_equal "SELECT * FROM items HAVING a"
     @c.import([:id], [[1]])
     @db.sqls.must_equal ["BEGIN", "INSERT INTO items (id) VALUES (1)", "COMMIT"]
-    @c.inner_join(@c).sql.must_equal "SELECT * FROM items INNER JOIN items"
+    @c.inner_join(@c.table_name).sql.must_equal "SELECT * FROM items INNER JOIN items"
     @c.insert.must_equal 2
     @db.sqls.must_equal ["INSERT INTO items DEFAULT VALUES"]
     @c.intersect(@d, :from_self=>false).sql.must_equal "SELECT * FROM items INTERSECT SELECT * FROM items"
     @c.interval(:id).must_equal 1
     @db.sqls.must_equal ["SELECT (max(id) - min(id)) AS interval FROM items LIMIT 1"]
-    @c.join(@c).sql.must_equal "SELECT * FROM items INNER JOIN items"
-    @c.join_table(:inner, @c).sql.must_equal "SELECT * FROM items INNER JOIN items"
+    @c.join(@c.table_name).sql.must_equal "SELECT * FROM items INNER JOIN items"
+    @c.join_table(:inner, @c.table_name).sql.must_equal "SELECT * FROM items INNER JOIN items"
     @c.last.must_equal @c.load(:id=>1)
     @db.sqls.must_equal ["SELECT * FROM items ORDER BY id DESC LIMIT 1"]
-    @c.left_join(@c).sql.must_equal "SELECT * FROM items LEFT JOIN items"
-    @c.left_outer_join(@c).sql.must_equal "SELECT * FROM items LEFT OUTER JOIN items"
+    @c.left_join(@c.table_name).sql.must_equal "SELECT * FROM items LEFT JOIN items"
+    @c.left_outer_join(@c.table_name).sql.must_equal "SELECT * FROM items LEFT OUTER JOIN items"
     @c.limit(2).sql.must_equal "SELECT * FROM items LIMIT 2"
     @c.lock_style(:update).sql.must_equal "SELECT * FROM items FOR UPDATE"
     @c.map(:id).must_equal [1]
@@ -75,10 +75,10 @@ describe Sequel::Model, "class dataset methods"  do
     @c.multi_insert([{:id=>1}])
     @db.sqls.must_equal ["BEGIN", "INSERT INTO items (id) VALUES (1)", "COMMIT"]
     @c.naked.row_proc.must_be_nil
-    @c.natural_full_join(@c).sql.must_equal "SELECT * FROM items NATURAL FULL JOIN items"
-    @c.natural_join(@c).sql.must_equal "SELECT * FROM items NATURAL JOIN items"
-    @c.natural_left_join(@c).sql.must_equal "SELECT * FROM items NATURAL LEFT JOIN items"
-    @c.natural_right_join(@c).sql.must_equal "SELECT * FROM items NATURAL RIGHT JOIN items"
+    @c.natural_full_join(@c.table_name).sql.must_equal "SELECT * FROM items NATURAL FULL JOIN items"
+    @c.natural_join(@c.table_name).sql.must_equal "SELECT * FROM items NATURAL JOIN items"
+    @c.natural_left_join(@c.table_name).sql.must_equal "SELECT * FROM items NATURAL LEFT JOIN items"
+    @c.natural_right_join(@c.table_name).sql.must_equal "SELECT * FROM items NATURAL RIGHT JOIN items"
     @c.offset(2).sql.must_equal "SELECT * FROM items OFFSET 2"
     @c.order(:a).sql.must_equal "SELECT * FROM items ORDER BY a"
     @c.order_append(:a).sql.must_equal "SELECT * FROM items ORDER BY a"
@@ -88,8 +88,8 @@ describe Sequel::Model, "class dataset methods"  do
     @c.paged_each{|r| r.must_equal @c.load(:id=>1)}
     @db.sqls.must_equal ["BEGIN", "SELECT * FROM items ORDER BY id LIMIT 1000 OFFSET 0", "COMMIT"]
     @c.qualify.sql.must_equal 'SELECT items.* FROM items'
-    @c.right_join(@c).sql.must_equal "SELECT * FROM items RIGHT JOIN items"
-    @c.right_outer_join(@c).sql.must_equal "SELECT * FROM items RIGHT OUTER JOIN items"
+    @c.right_join(@c.table_name).sql.must_equal "SELECT * FROM items RIGHT JOIN items"
+    @c.right_outer_join(@c.table_name).sql.must_equal "SELECT * FROM items RIGHT OUTER JOIN items"
     @c.select(:a).sql.must_equal "SELECT a FROM items"
     @c.select_all(:items).sql.must_equal "SELECT items.* FROM items"
     @c.select_append(:a).sql.must_equal "SELECT *, a FROM items"
@@ -103,7 +103,9 @@ describe Sequel::Model, "class dataset methods"  do
     @c.select_order_map(:id).must_equal [1]
     @db.sqls.must_equal ["SELECT id FROM items ORDER BY id"]
     @c.server(:a).opts[:server].must_equal :a
-    @c.set_graph_aliases(:a=>:b).opts[:graph_aliases].must_equal(:a=>[:b, :a])
+    deprecated do
+      @c.set_graph_aliases(:a=>:b).opts[:graph_aliases].must_equal(:a=>[:b, :a])
+    end
     @c.single_record.must_equal @c.load(:id=>1)
     @db.sqls.must_equal ["SELECT * FROM items LIMIT 1"]
     @c.single_record!.must_equal @c.load(:id=>1)

data/spec/model/dataset_methods_spec.rb

@@ -77,21 +77,21 @@ describe Sequel::Model::DatasetMethods  do
     @c.db.reset
   end
 
-  it "#join_table should allow use to use a model class when joining" do
+  deprecated "#join_table should allow use to use a model class when joining" do
     @c.join(Class.new(Sequel::Model(:categories)), :item_id => :id).sql.must_equal 'SELECT * FROM items INNER JOIN categories ON (categories.item_id = items.id)'
   end
 
-  it "#join_table should handle model classes that aren't simple selects using a subselect" do
+  deprecated "#join_table should handle model classes that aren't simple selects using a subselect" do
     @c.join(Class.new(Sequel::Model(DB[:categories].where(:foo=>1))), :item_id => :id).sql.must_equal 'SELECT * FROM items INNER JOIN (SELECT * FROM categories WHERE (foo = 1)) AS t1 ON (t1.item_id = items.id)'
   end
 
-  it "#graph should allow use to use a model class when joining" do
+  deprecated "#graph should allow use to use a model class when joining" do
     c = Class.new(Sequel::Model(:categories))
     c.columns :id
     @c.graph(c, :item_id => :id).sql.must_equal 'SELECT items.id, categories.id AS categories_id FROM items LEFT OUTER JOIN categories ON (categories.item_id = items.id)'
   end
 
-  it "#insert_sql should handle a single model instance as an argument" do
+  deprecated "#insert_sql should handle a single model instance as an argument" do
     @c.dataset.insert_sql(@c.load(:id=>1)).must_equal 'INSERT INTO items (id) VALUES (1)'
   end
 

data/spec/model/eager_loading_spec.rb

@@ -381,7 +381,7 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for many_to_one associations" do
-    EagerAlbum.many_to_one :sband, :clone=>:band, :eager_loading_predicate_key=>Sequel./(:bands__id, 3), :primary_key_method=>:id3
+    EagerAlbum.many_to_one :sband, :clone=>:band, :eager_loading_predicate_key=>(Sequel[:bands][:id] / 3), :primary_key_method=>:id3
     EagerBand.dataset = EagerBand.dataset.with_fetch(:id=>6)
     a = EagerAlbum.eager(:sband).all
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM bands WHERE ((bands.id / 3) IN (2))']
@@ -391,7 +391,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for one_to_many associations" do
-    EagerBand.one_to_many :salbums, :clone=>:albums, :eager_loading_predicate_key=>Sequel.*(:albums__band_id, 3), :key_method=>:band_id3, :eager=>nil, :reciprocal=>nil
+    EagerBand.one_to_many :salbums, :clone=>:albums, :eager_loading_predicate_key=>(Sequel[:albums][:band_id] * 3), :key_method=>:band_id3, :eager=>nil, :reciprocal=>nil
     EagerBand.dataset = EagerBand.dataset.with_fetch(:id=>6)
     a = EagerBand.eager(:salbums).all
     DB.sqls.must_equal ['SELECT * FROM bands', 'SELECT * FROM albums WHERE ((albums.band_id * 3) IN (6))']
@@ -401,7 +401,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for many_to_many associations" do
-    EagerAlbum.many_to_many :sgenres, :clone=>:genres, :eager_loading_predicate_key=>Sequel.*(:ag__album_id, 1)
+    EagerAlbum.many_to_many :sgenres, :clone=>:genres, :eager_loading_predicate_key=>(Sequel[:ag][:album_id] * 1)
     a = EagerAlbum.eager(:sgenres).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, (ag.album_id * 1) AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE ((ag.album_id * 1) IN (1))"]
@@ -410,7 +410,7 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for one_through_one associations" do
-    EagerAlbum.one_through_one :sgenre, :clone=>:genre, :eager_loading_predicate_key=>Sequel.*(:ag__album_id, 1)
+    EagerAlbum.one_through_one :sgenre, :clone=>:genre, :eager_loading_predicate_key=>(Sequel[:ag][:album_id] * 1)
     a = EagerAlbum.eager(:sgenre).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, (ag.album_id * 1) AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE ((ag.album_id * 1) IN (1))"]
@@ -445,18 +445,30 @@ describe Sequel::Model, "#eager" do
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT *, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (1))"]
   end
   
-  it "should correctly handle an aliased join table in many_to_many" do
+  with_symbol_splitting "should correctly handle an aliased join table symbol in many_to_many" do
     EagerAlbum.many_to_many :sgenres, :clone=>:genres, :join_table=>:ag___ga
     EagerAlbum.eager(:sgenres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ga.album_id AS x_foreign_key_x FROM genres INNER JOIN ag AS ga ON (ga.genre_id = genres.id) WHERE (ga.album_id IN (1))"]
   end
   
-  it "should correctly handle an aliased join table in one_through_one" do
+  with_symbol_splitting "should correctly handle an aliased join table symbol in one_through_one" do
     EagerAlbum.one_through_one :sgenre, :clone=>:genre, :join_table=>:ag___ga
     EagerAlbum.eager(:sgenre).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ga.album_id AS x_foreign_key_x FROM genres INNER JOIN ag AS ga ON (ga.genre_id = genres.id) WHERE (ga.album_id IN (1))"]
   end
   
+  it "should correctly handle an aliased join table in many_to_many" do
+    EagerAlbum.many_to_many :sgenres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga)
+    EagerAlbum.eager(:sgenres).all
+    DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ga.album_id AS x_foreign_key_x FROM genres INNER JOIN ag AS ga ON (ga.genre_id = genres.id) WHERE (ga.album_id IN (1))"]
+  end
+  
+  it "should correctly handle an aliased join table in one_through_one" do
+    EagerAlbum.one_through_one :sgenre, :clone=>:genre, :join_table=>Sequel[:ag].as(:ga)
+    EagerAlbum.eager(:sgenre).all
+    DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ga.album_id AS x_foreign_key_x FROM genres INNER JOIN ag AS ga ON (ga.genre_id = genres.id) WHERE (ga.album_id IN (1))"]
+  end
+  
   it "should eagerly load multiple associations in a single call" do
     a = EagerAlbum.eager(:genres, :tracks, :band).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -629,7 +641,7 @@ describe Sequel::Model, "#eager" do
     a.first.good_bands.must_equal [EagerBand.load(:id => 2)]
     DB.sqls.must_equal []
 
-    EagerBandMember.many_to_many :good_bands, :clone=>:bands, :conditions=>"x = 1"
+    EagerBandMember.many_to_many :good_bands, :clone=>:bands, :conditions=>Sequel.lit("x = 1")
     a = EagerBandMember.eager(:good_bands).all
     DB.sqls.must_equal ['SELECT * FROM members', 'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON (bm.band_id = bands.id) WHERE ((x = 1) AND (bm.member_id IN (5))) ORDER BY id']
   end
@@ -661,7 +673,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should cache the negative lookup when eagerly loading a *_to_many associations" do
-    a = EagerBand.eager(:albums).filter('id > 100').all
+    a = EagerBand.eager(:albums).where{id > 100}.all
     a.must_equal [EagerBand.load(:id => 101), EagerBand.load(:id =>102)]
     sqls = DB.sqls
     ['SELECT * FROM albums WHERE (albums.band_id IN (101, 102))', 'SELECT * FROM albums WHERE (albums.band_id IN (102, 101))'].must_include(sqls.delete_at(1))
@@ -1238,14 +1250,14 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should work correctly with select_map" do
     ds = GraphAlbum.eager_graph(:band)
-    ds.with_fetch([{:id=>1}, {:id=>2}]).select_map(:albums__id).must_equal [1, 2]
+    ds.with_fetch([{:id=>1}, {:id=>2}]).select_map(Sequel[:albums][:id]).must_equal [1, 2]
     DB.sqls.must_equal ['SELECT albums.id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)']
-    ds.with_fetch([{:id=>1}, {:id=>2}]).select_map([:albums__id, :albums__id]).must_equal [[1, 1], [2, 2]]
+    ds.with_fetch([{:id=>1}, {:id=>2}]).select_map([Sequel[:albums][:id], Sequel[:albums][:id]]).must_equal [[1, 1], [2, 2]]
     DB.sqls.must_equal ['SELECT albums.id, albums.id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)']
   end
 
   it "should work correctly with single_value" do
-    ds = GraphAlbum.eager_graph(:band).select(:albums__id)
+    ds = GraphAlbum.eager_graph(:band).select(Sequel[:albums][:id])
     ds.with_fetch([{:id=>1}]).single_value.must_equal 1
     DB.sqls.must_equal ['SELECT albums.id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) LIMIT 1']
   end
@@ -1471,7 +1483,15 @@ describe Sequel::Model, "#eager_graph" do
     a.first.lgenre.must_equal sub.load(:id => 4)
   end
   
-  it "should correctly handle an aliased join table in many_to_many and one_through_one" do
+  it "should correctly handle an aliased join table in many_to_many and one_through_one with conditions" do
+    c = Class.new(GraphAlbum)
+    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :conditions=>'true', :ignore_conditions_warning=> true
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ga.genre_id)'
+    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :conditions=>'true', :graph_block => proc{true}
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND \'t\')'
+  end
+
+  with_symbol_splitting "should correctly handle an aliased join table symbol in many_to_many and one_through_one with conditions" do
     c = Class.new(GraphAlbum)
     c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga, :conditions=>'true', :ignore_conditions_warning=> true
     c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ga.genre_id)'
@@ -1479,7 +1499,7 @@ describe Sequel::Model, "#eager_graph" do
     c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND \'t\')'
   end
 
-  it "should correctly handle an aliased join table in many_to_many and one_through_one" do
+  with_symbol_splitting "should correctly handle an aliased join table symbol in many_to_many and one_through_one" do
     c = Class.new(GraphAlbum)
     c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga
     c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ga.genre_id)'
@@ -1494,6 +1514,21 @@ describe Sequel::Model, "#eager_graph" do
     c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS genres_0 ON (genres_0.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = genres_0.genre_id)'
   end
   
+  it "should correctly handle an aliased join table in many_to_many and one_through_one" do
+    c = Class.new(GraphAlbum)
+    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga)
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ga.genre_id)'
+
+    c.many_to_many :genre, :clone=>:genre, :join_table=>Sequel[:ag].as(:ga)
+    c.eager_graph(:genre).sql.must_equal 'SELECT albums.id, albums.band_id, genre.id AS genre_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres AS genre ON (genre.id = ga.genre_id)'
+
+    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:albums)
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS albums_0 ON (albums_0.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = albums_0.genre_id)'
+
+    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:genres)
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS genres_0 ON (genres_0.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = genres_0.genre_id)'
+  end
+  
   it "should handle multiple associations in a single call to association_join" do
     GraphAlbum.association_join(:genres, :tracks, :band).sql.must_equal 'SELECT * FROM albums INNER JOIN ag ON (ag.album_id = albums.id) INNER JOIN genres ON (genres.id = ag.genre_id) INNER JOIN tracks ON (tracks.album_id = albums.id) INNER JOIN bands AS band ON (band.id = albums.band_id)'
   end
@@ -1891,13 +1926,13 @@ describe Sequel::Model, "#eager_graph" do
   end
 
   it "should respect the association's :eager_grapher option" do 
-    GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :eager_grapher=>proc{|eo| eo[:self].graph(GraphBand, {:active=>true}, :table_alias=>eo[:table_alias], :join_type=>:inner)}
+    GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :eager_grapher=>proc{|eo| eo[:self].graph(GraphBand.dataset, {:active=>true}, :table_alias=>eo[:table_alias], :join_type=>:inner)}
     GraphAlbum.eager_graph(:active_band).sql.must_equal "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums INNER JOIN bands AS active_band ON (active_band.active IS TRUE)"
 
-    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :eager_grapher=>proc{|eo| eo[:self].graph(GraphTrack, nil, :join_type=>:natural, :table_alias=>eo[:table_alias])}
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :eager_grapher=>proc{|eo| eo[:self].graph(GraphTrack.dataset, nil, :join_type=>:natural, :table_alias=>eo[:table_alias])}
     GraphAlbum.eager_graph(:right_tracks).sql.must_equal 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums NATURAL JOIN tracks AS right_tracks'
 
-    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :eager_grapher=>proc{|eo| eo[:self].graph(:ag, {:album_id=>:id}, :table_alias=>:a123, :implicit_qualifier=>eo[:implicit_qualifier]).graph(GraphGenre, [:album_id], :table_alias=>eo[:table_alias])}
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :eager_grapher=>proc{|eo| eo[:self].graph(:ag, {:album_id=>:id}, :table_alias=>:a123, :implicit_qualifier=>eo[:implicit_qualifier]).graph(GraphGenre.dataset, [:album_id], :table_alias=>eo[:table_alias])}
     GraphAlbum.eager_graph(:active_genres).sql.must_equal "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag AS a123 ON (a123.album_id = albums.id) LEFT OUTER JOIN genres AS active_genres USING (album_id)"
   end
 
@@ -1916,8 +1951,8 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_only_conditions=>{:active=>true}
     GraphAlbum.eager_graph(:active_genres).sql.must_equal "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON (ag.active IS TRUE) LEFT OUTER JOIN genres AS active_genres ON (active_genres.id = ag.genre_id)"
 
-    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_only_conditions=>(Sequel.expr(:price) + 2 > 100), :graph_join_table_only_conditions=>"active"
-    GraphAlbum.eager_graph(:active_genres).sql.must_equal "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON (active) LEFT OUTER JOIN genres AS active_genres ON ((price + 2) > 100)"
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_only_conditions=>(Sequel.expr(:price) + 2 > 100), :graph_join_table_only_conditions=>Sequel.identifier("active")
+    GraphAlbum.eager_graph(:active_genres).sql.must_equal "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON active LEFT OUTER JOIN genres AS active_genres ON ((price + 2) > 100)"
   end
 
   it "should create unique table aliases for all associations" do
@@ -1929,8 +1964,13 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.eager_graph(:right_tracks).sql.must_equal 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON (right_tracks.album_id = albums.id) ORDER BY right_tracks.id, right_tracks.album_id'
   end
 
+  with_symbol_splitting "should not qualify qualified symbols in association's :order" do
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[Sequel.desc(:blah__id), :blah__id]
+    GraphAlbum.eager_graph(:right_tracks).sql.must_equal 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON (right_tracks.album_id = albums.id) ORDER BY blah.id DESC, blah.id'
+  end
+
   it "should only qualify unqualified symbols, identifiers, or ordered versions in association's :order" do
-    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[Sequel.identifier(:blah__id), Sequel.identifier(:blah__id).desc, Sequel.desc(:blah__id), :blah__id, :album_id, Sequel.desc(:album_id), 1, Sequel.lit('RANDOM()'), Sequel.qualify(:b, :a)]
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[Sequel.identifier(:blah__id), Sequel.identifier(:blah__id).desc, Sequel[:blah][:id].desc, Sequel[:blah][:id], :album_id, Sequel.desc(:album_id), 1, Sequel.lit('RANDOM()'), Sequel.qualify(:b, :a)]
     GraphAlbum.eager_graph(:right_tracks).sql.must_equal 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON (right_tracks.album_id = albums.id) ORDER BY right_tracks.blah__id, right_tracks.blah__id DESC, blah.id DESC, blah.id, right_tracks.album_id, right_tracks.album_id DESC, 1, RANDOM(), b.a'
   end
 
@@ -1983,20 +2023,40 @@ describe Sequel::Model, "#eager_graph" do
   end
   
   it "should handle eager loading with schemas and aliases of different types" do
-    GraphAlbum.eager_graph(:band).join(:s__genres, [:b_id]).eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
+    GraphAlbum.eager_graph(:band).join(Sequel[:s][:genres], [:b_id]).eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
     GraphAlbum.eager_graph(:band).join(Sequel.qualify(:s, :genres), [:b_id]).eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
-    GraphAlbum.eager_graph(:band).join(Sequel.expr(:s__b).as('genres'), [:b_id]).eager_graph(:genres).sql.must_equal  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
-    GraphAlbum.eager_graph(:band).join(:s__b, [:b_id], :table_alias=>Sequel.identifier(:genres)).eager_graph(:genres).sql.must_equal  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
+    GraphAlbum.eager_graph(:band).join(Sequel[:s][:b].as('genres'), [:b_id]).eager_graph(:genres).sql.must_equal  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
+    GraphAlbum.eager_graph(:band).join(Sequel[:s][:b], [:b_id], :table_alias=>Sequel.identifier(:genres)).eager_graph(:genres).sql.must_equal  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
     GraphAlbum.eager_graph(:band).join(Sequel.identifier(:genres), [:b_id]).eager_graph(:genres).sql.must_equal  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
     GraphAlbum.eager_graph(:band).join('genres', [:b_id]).eager_graph(:genres).sql.must_equal  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
   end
   
+  with_symbol_splitting "should handle eager loading with splittable symbols" do
+    GraphAlbum.eager_graph(:band).join(:s__genres, [:b_id]).eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
+    GraphAlbum.eager_graph(:band).join(Sequel.expr(:s__b).as('genres'), [:b_id]).eager_graph(:genres).sql.must_equal  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
+    GraphAlbum.eager_graph(:band).join(:s__b, [:b_id], :table_alias=>Sequel.identifier(:genres)).eager_graph(:genres).sql.must_equal  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
+  end
+  
   it "should raise errors if invalid aliases or table styles are used" do
     proc{GraphAlbum.from_self(:alias=>Sequel.qualify(:s, :bands)).eager_graph(:band)}.must_raise(Sequel::Error)
     proc{GraphAlbum.from(Sequel.lit('?', :bands)).eager_graph(:band)}.must_raise(Sequel::Error)
   end
 
   it "should eagerly load schema qualified tables correctly with joins" do
+    c1 = Class.new(GraphAlbum)
+    c2 = Class.new(GraphGenre)
+    ds = c1.dataset.from(Sequel[:s][:a]).with_extend{def columns; [:id] end}
+    c1.dataset = ds
+    ds = c1.dataset
+    c2.dataset = c2.dataset.from(Sequel[:s][:g])
+    c1.many_to_many :a_genres, :class=>c2, :left_primary_key=>:id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>Sequel[:s][:ag]
+    ds = c1.join(Sequel[:s][:t], [:b_id]).eager_graph(:a_genres)
+    ds.sql.must_equal 'SELECT a.id, a_genres.id AS a_genres_id FROM (SELECT * FROM s.a INNER JOIN s.t USING (b_id)) AS a LEFT OUTER JOIN s.ag AS ag ON (ag.album_id = a.id) LEFT OUTER JOIN s.g AS a_genres ON (a_genres.id = ag.genre_id)'
+    ds = c1.eager_graph(:a_genres)
+    ds.sql.must_equal 'SELECT s.a.id, a_genres.id AS a_genres_id FROM s.a LEFT OUTER JOIN s.ag AS ag ON (ag.album_id = s.a.id) LEFT OUTER JOIN s.g AS a_genres ON (a_genres.id = ag.genre_id)'
+  end
+
+  with_symbol_splitting "should eagerly load schema qualified table symbols correctly with joins" do
     c1 = Class.new(GraphAlbum)
     c2 = Class.new(GraphGenre)
     ds = c1.dataset.from(:s__a).with_extend{def columns; [:id] end}
@@ -2152,7 +2212,7 @@ describe "Sequel::Models with double underscores in table names" do
   it "should have working eager_graph implementations" do
     @db.fetch = {:id=>1, :foo_id=>1, :foos_id=>1, :foos_foo_id=>1}
     foos = @Foo.eager_graph(:foos).all
-    @db.sqls.must_equal ["SELECT fo__os.id, fo__os.foo_id, foos.id AS foos_id, foos.foo_id AS foos_foo_id FROM fo__os LEFT OUTER JOIN (SELECT * FROM fo__os) AS foos ON (foos._id = fo__os.id)"]
+    @db.sqls.must_equal ["SELECT fo__os.id, fo__os.foo_id, foos.id AS foos_id, foos.foo_id AS foos_foo_id FROM fo__os LEFT OUTER JOIN fo__os AS foos ON (foos._id = fo__os.id)"]
     foos.must_equal [@Foo.load(:id=>1, :foo_id=>1)]
     foos.first.foos.must_equal [@Foo.load(:id=>1, :foo_id=>1)]
   end
@@ -2163,7 +2223,7 @@ describe "Sequel::Models with double underscores in table names" do
     @db.sqls
     @db.fetch = {:id=>1, :foo_id=>1, :foos_id=>1, :foos_foo_id=>1}
     foos = @Foo.eager_graph(:foos).all
-    @db.sqls.must_equal ["SELECT s.fo__os.id, s.fo__os.foo_id, foos.id AS foos_id, foos.foo_id AS foos_foo_id FROM s.fo__os LEFT OUTER JOIN (SELECT * FROM s.fo__os) AS foos ON (foos._id = s.fo__os.id)"]
+    @db.sqls.must_equal ["SELECT s.fo__os.id, s.fo__os.foo_id, foos.id AS foos_id, foos.foo_id AS foos_foo_id FROM s.fo__os LEFT OUTER JOIN s.fo__os AS foos ON (foos._id = s.fo__os.id)"]
     foos.must_equal [@Foo.load(:id=>1, :foo_id=>1)]
     foos.first.foos.must_equal [@Foo.load(:id=>1, :foo_id=>1)]
   end