sequel 3.36.1 → 3.37.0

data/spec/integration/associations_test.rb

@@ -887,11 +887,11 @@ describe "Sequel::Model Associations with clashing column names" do
     @Bar = Class.new(Sequel::Model(:bars))
     @Foo.def_column_alias(:obj_id, :object_id)
     @Bar.def_column_alias(:obj_id, :object_id)
-    @Foo.one_to_many :bars, :primary_key=>:obj_id, :primary_key_column=>:object_id, :key=>:object_id, :key_method=>:obj_id, :eager_loader_key=>:object_id, :class=>@Bar
-    @Foo.one_to_one :bar, :primary_key=>:obj_id, :primary_key_column=>:object_id, :key=>:object_id, :key_method=>:obj_id, :eager_loader_key=>:object_id, :class=>@Bar
+    @Foo.one_to_many :bars, :primary_key=>:obj_id, :primary_key_column=>:object_id, :key=>:object_id, :key_method=>:obj_id, :class=>@Bar
+    @Foo.one_to_one :bar, :primary_key=>:obj_id, :primary_key_column=>:object_id, :key=>:object_id, :key_method=>:obj_id, :class=>@Bar
     @Bar.many_to_one :foo, :key=>:obj_id, :key_column=>:object_id, :primary_key=>:object_id, :primary_key_method=>:obj_id, :class=>@Foo
-    @Foo.many_to_many :mtmbars, :join_table=>:bars_foos, :left_primary_key=>:obj_id, :left_primary_key_column=>:object_id, :right_primary_key=>:object_id, :right_primary_key_method=>:obj_id, :left_key=>:foo_id, :right_key=>:object_id, :eager_loader_key=>:object_id, :class=>@Bar
-    @Bar.many_to_many :mtmfoos, :join_table=>:bars_foos, :left_primary_key=>:obj_id, :left_primary_key_column=>:object_id, :right_primary_key=>:object_id, :right_primary_key_method=>:obj_id, :left_key=>:object_id, :right_key=>:foo_id, :eager_loader_key=>:object_id, :class=>@Foo
+    @Foo.many_to_many :mtmbars, :join_table=>:bars_foos, :left_primary_key=>:obj_id, :left_primary_key_column=>:object_id, :right_primary_key=>:object_id, :right_primary_key_method=>:obj_id, :left_key=>:foo_id, :right_key=>:object_id, :class=>@Bar
+    @Bar.many_to_many :mtmfoos, :join_table=>:bars_foos, :left_primary_key=>:obj_id, :left_primary_key_column=>:object_id, :right_primary_key=>:object_id, :right_primary_key_method=>:obj_id, :left_key=>:object_id, :right_key=>:foo_id, :class=>@Foo
     @foo = @Foo.create(:obj_id=>2)
     @bar = @Bar.create(:obj_id=>2)
     @Foo.db[:bars_foos].insert(2, 2)

data/spec/integration/database_test.rb

@@ -2,10 +2,10 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe Sequel::Database do
   specify "should provide disconnect functionality" do
-    INTEGRATION_DB.test_connection
-    INTEGRATION_DB.pool.size.should == 1
     INTEGRATION_DB.disconnect
     INTEGRATION_DB.pool.size.should == 0
+    INTEGRATION_DB.test_connection
+    INTEGRATION_DB.pool.size.should == 1
   end
 
   specify "should provide disconnect functionality after preparing a statement" do

data/spec/integration/dataset_test.rb

@@ -150,7 +150,7 @@ describe "Simple Dataset operations" do
     @db.drop_table(:items2)
   end
   
-  cspecify "should fetch correctly with a limit and offset without an order", :db2, :mssql, :oracle do
+  specify "should fetch correctly with a limit and offset without an order" do
     @ds.limit(2, 1).all.should == []
   end
 
@@ -301,11 +301,11 @@ describe Sequel::Database do
      "\\'dingo",
      "\\\\''dingo",
     ].each do |str|
-      INTEGRATION_DB.get(str.as(:a)).should == str
+      INTEGRATION_DB.get(str.cast(String)).should == str
       str = "1#{str}1"
-      INTEGRATION_DB.get(str.as(:a)).should == str
+      INTEGRATION_DB.get(str.cast(String)).should == str
       str = "#{str}#{str}"
-      INTEGRATION_DB.get(str.as(:a)).should == str
+      INTEGRATION_DB.get(str.cast(String)).should == str
     end
   end
 

data/spec/integration/eager_loader_test.rb

@@ -12,7 +12,7 @@ describe "Eagerly loading a tree structure" do
       one_to_many :children, :key=>:parent_id
     
       # Only useful when eager loading
-      many_to_one :ancestors, :eager_loader=>(proc do |eo|
+      many_to_one :ancestors, :eager_loader_key=>nil, :eager_loader=>(proc do |eo|
         # Handle cases where the root node has the same parent_id as primary_key
         # and also when it is NULL
         non_root_nodes = eo[:rows].reject do |n| 
@@ -36,7 +36,7 @@ describe "Eagerly loading a tree structure" do
           end
         end
       end)
-      many_to_one :descendants, :eager_loader=>(proc do |eo|
+      many_to_one :descendants, :eager_loader_key=>nil, :eager_loader=>(proc do |eo|
         id_map = {}
         eo[:rows].each do |n|
           # Initialize an empty array of child associations for each parent node
@@ -185,7 +185,7 @@ describe "has_many :through has_many and has_one :through belongs_to" do
           end
         end), \
         :eager_loader=>(proc do |eo|
-          id_map = eo[:key_hash][Firm.primary_key]
+          id_map = eo[:id_map]
           eo[:rows].each{|firm| firm.associations[:invoices] = []}
           Invoice.eager_graph(:client).filter(:client__firm_id=>id_map.keys).all do |inv|
             id_map[inv.client.firm_id].each do |firm|
@@ -526,7 +526,7 @@ describe "many_to_one/one_to_many not referencing primary key" do
       many_to_one :client, :key=>:client_name, \
         :dataset=>proc{Client.filter(:name=>client_name)}, \
         :eager_loader=>(proc do |eo|
-          id_map = eo[:key_hash][:client_name]
+          id_map = eo[:id_map]
           eo[:rows].each{|inv| inv.associations[:client] = nil}
           Client.filter(:name=>id_map.keys).all do |client|
             id_map[client.name].each{|inv| inv.associations[:client] = client}
@@ -629,11 +629,11 @@ describe "statistics associations" do
        :dataset=>proc{Ticket.filter(:project_id=>id).select{sum(hours).as(hours)}},
        :eager_loader=>(proc do |eo|
         eo[:rows].each{|p| p.associations[:ticket_hours] = nil}
-        Ticket.filter(:project_id=>eo[:key_hash][:id].keys).
+        Ticket.filter(:project_id=>eo[:id_map].keys).
          group(:project_id).
          select{[project_id.as(project_id), sum(hours).as(hours)]}.
          all do |t|
-          p = eo[:key_hash][:id][t.values.delete(:project_id)].first
+          p = eo[:id_map][t.values.delete(:project_id)].first
           p.associations[:ticket_hours] = t
          end
        end)  

data/spec/integration/plugin_test.rb

@@ -100,7 +100,7 @@ describe "Class Table Inheritance Plugin" do
     Employee.filter(:id=>@i2).all.first.manager.id.should == @i4
   end
 
-  cspecify "should insert rows into all tables", [:amalgalite], [:jdbc, :sqlite] do
+  cspecify "should insert rows into all tables", [proc{|db| db.sqlite_version < 30709}, :sqlite] do
     e = Executive.create(:name=>'Ex2', :num_managers=>8, :num_staff=>9)
     i = e.id
     @db[:employees][:id=>i].should == {:id=>i, :name=>'Ex2', :kind=>'Executive'}
@@ -139,7 +139,7 @@ describe "Class Table Inheritance Plugin" do
     Executive.limit(1).eager(:staff_members).first.staff_members.should == [Staff[@i2]]
   end
   
-  cspecify "should handle eagerly graphing one_to_many relationships", [:amalgalite], [:jdbc, :sqlite] do
+  cspecify "should handle eagerly graphing one_to_many relationships", [proc{|db| db.sqlite_version < 30709}, :sqlite] do
     es = Executive.limit(1).eager_graph(:staff_members).all
     es.should == [Executive[@i4]]
     es.map{|x| x.staff_members}.should == [[Staff[@i2]]]

data/spec/integration/spec_helper.rb

@@ -42,7 +42,7 @@ def Sequel.guarded?(*checked)
           return c if c.first == INTEGRATION_DB.adapter_scheme
         when 2
           if c.first.is_a?(Proc)
-            return c if c.first.call(INTEGRATION_DB) && c.last == INTEGRATION_DB.database_type
+            return c if c.last == INTEGRATION_DB.database_type && c.first.call(INTEGRATION_DB)
           elsif c.last.is_a?(Proc)
             return c if c.first == INTEGRATION_DB.adapter_scheme && c.last.call(INTEGRATION_DB)
           else
@@ -69,7 +69,7 @@ end
   
   def self.cspecify(message, *checked, &block)
     if pending = Sequel.guarded?(*checked)
-      specify(message){pending("Not yet working on #{Array(pending).join(', ')}", &block)}
+      specify(message){pending("Not yet working on #{Array(pending).map{|x| x.is_a?(Proc) ? :proc : x}.join(', ')}", &block)}
     else
       specify(message, &block)
     end

data/spec/model/association_reflection_spec.rb

@@ -193,6 +193,11 @@ describe Sequel::Model::Associations::AssociationReflection do
     @c.meta_def(:name){"C"}
   end
 
+  it "#eager_loading_predicate_key should be an alias of predicate_key for backwards compatibility" do
+    @c.one_to_many :cs, :class=>@c
+    @c.dataset.literal(@c.association_reflection(:cs).eager_loading_predicate_key).should == 'foo.c_id'
+  end
+
   it "one_to_many #qualified_primary_key should be a qualified version of the primary key" do
     @c.one_to_many :cs, :class=>@c
     @c.dataset.literal(@c.association_reflection(:cs).qualified_primary_key).should == 'foo.id'

data/spec/model/associations_spec.rb

@@ -125,6 +125,18 @@ describe Sequel::Model, "associate" do
     end
   end
 
+  it "should raise an error if attempting to clone an association of differing type" do
+    c = Class.new(Sequel::Model(:c))
+    c.many_to_one :c
+    proc{c.one_to_many :cs, :clone=>:c}.should raise_error(Sequel::Error)
+  end
+
+  it "should allow cloning of one_to_many to one_to_one associations and vice-versa" do
+    c = Class.new(Sequel::Model(:c))
+    c.one_to_one :c
+    proc{c.one_to_many :cs, :clone=>:c}.should_not raise_error(Sequel::Error)
+    proc{c.one_to_one :c2, :clone=>:cs}.should_not raise_error(Sequel::Error)
+  end
 end
 
 describe Sequel::Model, "many_to_one" do
@@ -672,7 +684,7 @@ describe Sequel::Model, "one_to_one" do
     sqls = MODEL_DB.sqls
     ['INSERT INTO attributes (node_id, id) VALUES (1234, 3)',
       'INSERT INTO attributes (id, node_id) VALUES (3, 1234)'].should(include(sqls.slice! 1))
-    sqls.should == ['UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))', "SELECT * FROM attributes WHERE (id = 3) LIMIT 1"]
+    sqls.should == ['UPDATE attributes SET node_id = NULL WHERE (node_id = 1234)', "SELECT * FROM attributes WHERE (id = 3) LIMIT 1"]
 
     @c2.new(:id => 1234).attribute.should == attrib
     attrib = @c1.load(:id=>3)
@@ -711,7 +723,7 @@ describe Sequel::Model, "one_to_one" do
     sqls = MODEL_DB.sqls
     ['INSERT INTO attributes (node_id, id) VALUES (5, 3)',
       'INSERT INTO attributes (id, node_id) VALUES (3, 5)'].should(include(sqls.slice! 1))
-    sqls.should == ['UPDATE attributes SET node_id = NULL WHERE ((node_id = 5) AND (id != 3))', "SELECT * FROM attributes WHERE (id = 3) LIMIT 1"]
+    sqls.should == ['UPDATE attributes SET node_id = NULL WHERE (node_id = 5)', "SELECT * FROM attributes WHERE (id = 3) LIMIT 1"]
 
     @c2.new(:id => 321, :xxx=>5).attribute.should == attrib
     attrib = @c1.load(:id=>3)
@@ -845,38 +857,6 @@ describe Sequel::Model, "one_to_one" do
     MODEL_DB.sqls.should == []
   end
 
-  it "should define a setter method" do
-    @c2.one_to_one :parent, :class => @c2
-
-    d = @c2.new(:id => 1)
-    f = @c2.new(:id => 3, :node_id=> 4321)
-    @c2.dataset._fetch = @c2.instance_dataset._fetch = {:id => 3, :node_id=>1}
-    d.parent = f
-    f.values.should == {:id => 3, :node_id=>1}
-    d.parent.should == f
-    sqls = MODEL_DB.sqls
-    ["INSERT INTO nodes (node_id, id) VALUES (1, 3)",
-     "INSERT INTO nodes (id, node_id) VALUES (3, 1)"].should include(sqls.slice! 1)
-    sqls.should == ["UPDATE nodes SET node_id = NULL WHERE ((node_id = 1) AND (id != 3))", "SELECT * FROM nodes WHERE (id = 3) LIMIT 1"]
-    
-    d.parent = nil
-    d.parent.should == nil
-    MODEL_DB.sqls.should == ["UPDATE nodes SET node_id = NULL WHERE (node_id = 1)"]
-  end
-  
-  it "should have the setter method respect the :primary_key option" do
-    @c2.one_to_one :parent, :class => @c2, :primary_key=>:blah
-    d = @c2.new(:id => 1, :blah => 3)
-    e = @c2.new(:id => 4321, :node_id=>444)
-    @c2.dataset._fetch = @c2.instance_dataset._fetch = {:id => 4321, :node_id => 3}
-    d.parent = e
-    e.values.should == {:id => 4321, :node_id => 3}
-    sqls = MODEL_DB.sqls
-    ["INSERT INTO nodes (node_id, id) VALUES (3, 4321)",
-     "INSERT INTO nodes (id, node_id) VALUES (4321, 3)"].should include(sqls.slice! 1)
-    sqls.should == ["UPDATE nodes SET node_id = NULL WHERE ((node_id = 3) AND (id != 4321))", "SELECT * FROM nodes WHERE (id = 4321) LIMIT 1"]
-  end
-  
   it "should have the setter method respect the :key option" do
     @c2.one_to_one :parent, :class => @c2, :key=>:blah
     d = @c2.new(:id => 3)
@@ -887,7 +867,7 @@ describe Sequel::Model, "one_to_one" do
     sqls = MODEL_DB.sqls
     ["INSERT INTO nodes (blah, id) VALUES (3, 4321)",
      "INSERT INTO nodes (id, blah) VALUES (4321, 3)"].should include(sqls.slice! 1)
-    sqls.should == ["UPDATE nodes SET blah = NULL WHERE ((blah = 3) AND (id != 4321))", "SELECT * FROM nodes WHERE (id = 4321) LIMIT 1"]
+    sqls.should == ["UPDATE nodes SET blah = NULL WHERE (blah = 3)", "SELECT * FROM nodes WHERE (id = 4321) LIMIT 1"]
   end
   
   it "should persist changes to associated object when the setter is called" do
@@ -1796,7 +1776,7 @@ describe Sequel::Model, "many_to_many" do
       attr_accessor :yyy
       def self.name; 'Attribute'; end
       def self.to_s; 'Attribute'; end
-      columns :id, :y
+      columns :id, :y, :z
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
@@ -1841,6 +1821,11 @@ describe Sequel::Model, "many_to_many" do
     end
   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.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id[0] = 1234))'
+  end
+  
   it "should use explicit key values and join table if given" do
     @c2.many_to_many :attributes, :class => @c1, :left_key => :nodeid, :right_key => :attributeid, :join_table => :attribute2node
     @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attribute2node ON ((attribute2node.attributeid = attributes.id) AND (attribute2node.nodeid = 1234))'
@@ -2058,9 +2043,9 @@ describe Sequel::Model, "many_to_many" do
   end
   
   it "should have the add_ method respect composite keys" do
-    @c2.many_to_many :attributes, :class => @c1, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:id, :x], :right_primary_key=>[:id, :y]
+    @c2.many_to_many :attributes, :class => @c1, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:id, :x], :right_primary_key=>[:id, :z]
     n = @c2.load(:id => 1234, :x=>5)
-    a = @c1.load(:id => 2345, :y=>8)
+    a = @c1.load(:id => 2345, :z=>8)
     a.should == n.add_attribute(a)
     sqls = MODEL_DB.sqls
     m = /INSERT INTO attributes_nodes \((\w+), (\w+), (\w+), (\w+)\) VALUES \((\d+), (\d+), (\d+), (\d+)\)/.match(sqls.pop)
@@ -2080,14 +2065,14 @@ describe Sequel::Model, "many_to_many" do
   end
   
   it "should have the add_ method respect composite keys" do
-    @c2.many_to_many :attributes, :class => @c1, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:id, :x], :right_primary_key=>[:id, :y]
-    @c1.set_primary_key [:id, :y]
+    @c2.many_to_many :attributes, :class => @c1, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:id, :x], :right_primary_key=>[:id, :z]
+    @c1.set_primary_key [:id, :z]
     n = @c2.load(:id => 1234, :x=>5)
-    a = @c1.load(:id => 2345, :y=>8)
-    @c1.dataset._fetch = {:id => 2345, :y=>8}
+    a = @c1.load(:id => 2345, :z=>8)
+    @c1.dataset._fetch = {:id => 2345, :z=>8}
     n.add_attribute([2345, 8]).should == a
     sqls = MODEL_DB.sqls
-    sqls.shift.should =~ /SELECT \* FROM attributes WHERE \(\((id|y) = (8|2345)\) AND \((id|y) = (8|2345)\)\) LIMIT 1/
+    sqls.shift.should =~ /SELECT \* FROM attributes WHERE \(\((id|z) = (8|2345)\) AND \((id|z) = (8|2345)\)\) LIMIT 1/
     sqls.pop.should =~ /INSERT INTO attributes_nodes \([lr][12], [lr][12], [lr][12], [lr][12]\) VALUES \((1234|5|2345|8), (1234|5|2345|8), (1234|5|2345|8), (1234|5|2345|8)\)/
     sqls.should == []
   end
@@ -2102,9 +2087,9 @@ describe Sequel::Model, "many_to_many" do
   end
   
   it "should have the remove_ method respect composite keys" do
-    @c2.many_to_many :attributes, :class => @c1, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:id, :x], :right_primary_key=>[:id, :y]
+    @c2.many_to_many :attributes, :class => @c1, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:id, :x], :right_primary_key=>[:id, :z]
     n = @c2.load(:id => 1234, :x=>5)
-    a = @c1.load(:id => 2345, :y=>8)
+    a = @c1.load(:id => 2345, :z=>8)
     a.should == n.remove_attribute(a)
     MODEL_DB.sqls.should == ["DELETE FROM attributes_nodes WHERE ((l1 = 1234) AND (l2 = 5) AND (r1 = 2345) AND (r2 = 8))"]
   end
@@ -2964,11 +2949,11 @@ describe "Sequel::Model Associations with clashing column names" do
     @Bar.columns :id, :object_id
     @Foo.def_column_alias(:obj_id, :object_id)
     @Bar.def_column_alias(:obj_id, :object_id)
-    @Foo.one_to_many :bars, :primary_key=>:obj_id, :primary_key_column=>:object_id, :key=>:object_id, :key_method=>:obj_id, :eager_loader_key=>:object_id, :class=>@Bar
-    @Foo.one_to_one :bar, :primary_key=>:obj_id, :primary_key_column=>:object_id, :key=>:object_id, :key_method=>:obj_id, :eager_loader_key=>:object_id, :class=>@Bar
+    @Foo.one_to_many :bars, :primary_key=>:obj_id, :primary_key_column=>:object_id, :key=>:object_id, :key_method=>:obj_id,  :class=>@Bar
+    @Foo.one_to_one :bar, :primary_key=>:obj_id, :primary_key_column=>:object_id, :key=>:object_id, :key_method=>:obj_id, :class=>@Bar
     @Bar.many_to_one :foo, :key=>:obj_id, :key_column=>:object_id, :primary_key=>:object_id, :primary_key_method=>:obj_id, :class=>@Foo
-    @Foo.many_to_many :mtmbars, :join_table=>:bars_foos, :left_primary_key=>:obj_id, :left_primary_key_column=>:object_id, :right_primary_key=>:object_id, :right_primary_key_method=>:obj_id, :left_key=>:foo_id, :right_key=>:object_id, :eager_loader_key=>:object_id, :class=>@Bar
-    @Bar.many_to_many :mtmfoos, :join_table=>:bars_foos, :left_primary_key=>:obj_id, :left_primary_key_column=>:object_id, :right_primary_key=>:object_id, :right_primary_key_method=>:obj_id, :left_key=>:object_id, :right_key=>:foo_id, :eager_loader_key=>:object_id, :class=>@Foo
+    @Foo.many_to_many :mtmbars, :join_table=>:bars_foos, :left_primary_key=>:obj_id, :left_primary_key_column=>:object_id, :right_primary_key=>:object_id, :right_primary_key_method=>:obj_id, :left_key=>:foo_id, :right_key=>:object_id, :class=>@Bar
+    @Bar.many_to_many :mtmfoos, :join_table=>:bars_foos, :left_primary_key=>:obj_id, :left_primary_key_column=>:object_id, :right_primary_key=>:object_id, :right_primary_key_method=>:obj_id, :left_key=>:object_id, :right_key=>:foo_id, :class=>@Foo
     @foo = @Foo.load(:id=>1, :object_id=>2)
     @bar = @Bar.load(:id=>1, :object_id=>2)
     @db.sqls
@@ -2976,33 +2961,61 @@ describe "Sequel::Model Associations with clashing column names" do
 
   it "should have working regular association methods" do
     @Bar.first.foo.should == @foo
+    @db.sqls.should == ["SELECT * FROM bars LIMIT 1", "SELECT * FROM foos WHERE (foos.object_id = 2) LIMIT 1"]
     @Foo.first.bars.should == [@bar]
+    @db.sqls.should == ["SELECT * FROM foos LIMIT 1", "SELECT * FROM bars WHERE (bars.object_id = 2)"]
     @Foo.first.bar.should == @bar
+    @db.sqls.should == ["SELECT * FROM foos LIMIT 1", "SELECT * FROM bars WHERE (bars.object_id = 2) LIMIT 1"]
     @Foo.first.mtmbars.should == [@bar]
+    @db.sqls.should == ["SELECT * FROM foos LIMIT 1", "SELECT bars.* FROM bars INNER JOIN bars_foos ON ((bars_foos.object_id = bars.object_id) AND (bars_foos.foo_id = 2))"]
     @Bar.first.mtmfoos.should == [@foo]
+    @db.sqls.should == ["SELECT * FROM bars LIMIT 1", "SELECT foos.* FROM foos INNER JOIN bars_foos ON ((bars_foos.foo_id = foos.object_id) AND (bars_foos.object_id = 2))"]
   end
 
   it "should have working eager loading methods" do
     @Bar.eager(:foo).all.map{|o| [o, o.foo]}.should == [[@bar, @foo]]
+    @db.sqls.should == ["SELECT * FROM bars", "SELECT * FROM foos WHERE (foos.object_id IN (2))"]
     @Foo.eager(:bars).all.map{|o| [o, o.bars]}.should == [[@foo, [@bar]]]
+    @db.sqls.should == ["SELECT * FROM foos", "SELECT * FROM bars WHERE (bars.object_id IN (2))"]
     @Foo.eager(:bar).all.map{|o| [o, o.bar]}.should == [[@foo, @bar]]
+    @db.sqls.should == ["SELECT * FROM foos", "SELECT * FROM bars WHERE (bars.object_id IN (2))"]
     @db.fetch = [[{:id=>1, :object_id=>2}], [{:id=>1, :object_id=>2, :x_foreign_key_x=>2}]]
     @Foo.eager(:mtmbars).all.map{|o| [o, o.mtmbars]}.should == [[@foo, [@bar]]]
+    @db.sqls.should == ["SELECT * FROM foos", "SELECT bars.*, bars_foos.foo_id AS x_foreign_key_x FROM bars INNER JOIN bars_foos ON ((bars_foos.object_id = bars.object_id) AND (bars_foos.foo_id IN (2)))"]
     @db.fetch = [[{:id=>1, :object_id=>2}], [{:id=>1, :object_id=>2, :x_foreign_key_x=>2}]]
     @Bar.eager(:mtmfoos).all.map{|o| [o, o.mtmfoos]}.should == [[@bar, [@foo]]]
+    @db.sqls.should == ["SELECT * FROM bars", "SELECT foos.*, bars_foos.object_id AS x_foreign_key_x FROM foos INNER JOIN bars_foos ON ((bars_foos.foo_id = foos.object_id) AND (bars_foos.object_id IN (2)))"]
   end
 
   it "should have working eager graphing methods" do
     @db.fetch = {:id=>1, :object_id=>2, :foo_id=>1, :foo_object_id=>2}
     @Bar.eager_graph(:foo).all.map{|o| [o, o.foo]}.should == [[@bar, @foo]]
+    @db.sqls.should == ["SELECT bars.id, bars.object_id, foo.id AS foo_id, foo.object_id AS foo_object_id FROM bars LEFT OUTER JOIN foos AS foo ON (foo.object_id = bars.object_id)"]
     @db.fetch = {:id=>1, :object_id=>2, :bars_id=>1, :bars_object_id=>2}
     @Foo.eager_graph(:bars).all.map{|o| [o, o.bars]}.should == [[@foo, [@bar]]]
+    @db.sqls.should == ["SELECT foos.id, foos.object_id, bars.id AS bars_id, bars.object_id AS bars_object_id FROM foos LEFT OUTER JOIN bars ON (bars.object_id = foos.object_id)"]
     @db.fetch = {:id=>1, :object_id=>2, :bar_id=>1, :bar_object_id=>2}
     @Foo.eager_graph(:bar).all.map{|o| [o, o.bar]}.should == [[@foo, @bar]]
+    @db.sqls.should == ["SELECT foos.id, foos.object_id, bar.id AS bar_id, bar.object_id AS bar_object_id FROM foos LEFT OUTER JOIN bars AS bar ON (bar.object_id = foos.object_id)"]
     @db.fetch = {:id=>1, :object_id=>2, :mtmfoos_id=>1, :mtmfoos_object_id=>2}
     @Bar.eager_graph(:mtmfoos).all.map{|o| [o, o.mtmfoos]}.should == [[@bar, [@foo]]]
+    @db.sqls.should == ["SELECT bars.id, bars.object_id, mtmfoos.id AS mtmfoos_id, mtmfoos.object_id AS mtmfoos_object_id FROM bars LEFT OUTER JOIN bars_foos ON (bars_foos.object_id = bars.object_id) LEFT OUTER JOIN foos AS mtmfoos ON (mtmfoos.object_id = bars_foos.foo_id)"]
     @db.fetch = {:id=>1, :object_id=>2, :mtmbars_id=>1, :mtmbars_object_id=>2}
     @Foo.eager_graph(:mtmbars).all.map{|o| [o, o.mtmbars]}.should == [[@foo, [@bar]]]
+    @db.sqls.should == ["SELECT foos.id, foos.object_id, mtmbars.id AS mtmbars_id, mtmbars.object_id AS mtmbars_object_id FROM foos LEFT OUTER JOIN bars_foos ON (bars_foos.foo_id = foos.object_id) LEFT OUTER JOIN bars AS mtmbars ON (mtmbars.object_id = bars_foos.object_id)"]
+  end
+
+  it "should have working filter by associations with model instances" do
+    @Bar.first(:foo=>@foo).should == @bar
+    @db.sqls.should == ["SELECT * FROM bars WHERE (bars.object_id = 2) LIMIT 1"]
+    @Foo.first(:bars=>@bar).should == @foo
+    @db.sqls.should == ["SELECT * FROM foos WHERE (foos.object_id = 2) LIMIT 1"]
+    @Foo.first(:bar=>@bar).should == @foo
+    @db.sqls.should == ["SELECT * FROM foos WHERE (foos.object_id = 2) LIMIT 1"]
+    @Foo.first(:mtmbars=>@bar).should == @foo
+    @db.sqls.should == ["SELECT * FROM foos WHERE (foos.object_id IN (SELECT bars_foos.foo_id FROM bars_foos WHERE ((bars_foos.object_id = 2) AND (bars_foos.foo_id IS NOT NULL)))) LIMIT 1"]
+    @Bar.first(:mtmfoos=>@foo).should == @bar
+    @db.sqls.should == ["SELECT * FROM bars WHERE (bars.object_id IN (SELECT bars_foos.object_id FROM bars_foos WHERE ((bars_foos.foo_id = 2) AND (bars_foos.object_id IS NOT NULL)))) LIMIT 1"]
   end
 
   it "should have working modification methods" do
@@ -3045,6 +3058,100 @@ describe "Sequel::Model Associations with clashing column names" do
   end
 end 
 
+describe "Sequel::Model Associations with non-column expression keys" do
+  before do
+    @db = Sequel.mock(:fetch=>{:id=>1, :object_ids=>[2]})
+    @Foo = Class.new(Sequel::Model(@db[:foos]))
+    @Bar = Class.new(Sequel::Model(@db[:bars]))
+    @Foo.columns :id, :object_ids
+    @Bar.columns :id, :object_ids
+    m = Module.new{def obj_id; object_ids[0]; end}
+    @Foo.include m
+    @Bar.include m
+
+    @Foo.one_to_many :bars, :primary_key=>:obj_id, :primary_key_column=>Sequel.subscript(:object_ids, 0), :key=>Sequel.subscript(:object_ids, 0), :key_method=>:obj_id,  :class=>@Bar
+    @Foo.one_to_one :bar, :primary_key=>:obj_id, :primary_key_column=>Sequel.subscript(:object_ids, 0), :key=>Sequel.subscript(:object_ids, 0), :key_method=>:obj_id, :class=>@Bar
+    @Bar.many_to_one :foo, :key=>:obj_id, :key_column=>Sequel.subscript(:object_ids, 0), :primary_key=>Sequel.subscript(:object_ids, 0), :primary_key_method=>:obj_id, :class=>@Foo
+    @Foo.many_to_many :mtmbars, :join_table=>:bars_foos, :left_primary_key=>:obj_id, :left_primary_key_column=>Sequel.subscript(:object_ids, 0), :right_primary_key=>Sequel.subscript(:object_ids, 0), :right_primary_key_method=>:obj_id, :left_key=>Sequel.subscript(:foo_ids, 0), :right_key=>Sequel.subscript(:bar_ids, 0), :class=>@Bar
+    @Bar.many_to_many :mtmfoos, :join_table=>:bars_foos, :left_primary_key=>:obj_id, :left_primary_key_column=>Sequel.subscript(:object_ids, 0), :right_primary_key=>Sequel.subscript(:object_ids, 0), :right_primary_key_method=>:obj_id, :left_key=>Sequel.subscript(:bar_ids, 0), :right_key=>Sequel.subscript(:foo_ids, 0), :class=>@Foo
+    @foo = @Foo.load(:id=>1, :object_ids=>[2])
+    @bar = @Bar.load(:id=>1, :object_ids=>[2])
+    @db.sqls
+  end
+
+  it "should have working regular association methods" do
+    @Bar.first.foo.should == @foo
+    @db.sqls.should == ["SELECT * FROM bars LIMIT 1", "SELECT * FROM foos WHERE (foos.object_ids[0] = 2) LIMIT 1"]
+    @Foo.first.bars.should == [@bar]
+    @db.sqls.should == ["SELECT * FROM foos LIMIT 1", "SELECT * FROM bars WHERE (bars.object_ids[0] = 2)"]
+    @Foo.first.bar.should == @bar
+    @db.sqls.should == ["SELECT * FROM foos LIMIT 1", "SELECT * FROM bars WHERE (bars.object_ids[0] = 2) LIMIT 1"]
+    @Foo.first.mtmbars.should == [@bar]
+    @db.sqls.should == ["SELECT * FROM foos LIMIT 1", "SELECT bars.* FROM bars INNER JOIN bars_foos ON ((bars_foos.bar_ids[0] = bars.object_ids[0]) AND (bars_foos.foo_ids[0] = 2))"]
+    @Bar.first.mtmfoos.should == [@foo]
+    @db.sqls.should == ["SELECT * FROM bars LIMIT 1", "SELECT foos.* FROM foos INNER JOIN bars_foos ON ((bars_foos.foo_ids[0] = foos.object_ids[0]) AND (bars_foos.bar_ids[0] = 2))"]
+  end
+
+  it "should have working eager loading methods" do
+    @Bar.eager(:foo).all.map{|o| [o, o.foo]}.should == [[@bar, @foo]]
+    @db.sqls.should == ["SELECT * FROM bars", "SELECT * FROM foos WHERE (foos.object_ids[0] IN (2))"]
+    @Foo.eager(:bars).all.map{|o| [o, o.bars]}.should == [[@foo, [@bar]]]
+    @db.sqls.should == ["SELECT * FROM foos", "SELECT * FROM bars WHERE (bars.object_ids[0] IN (2))"]
+    @Foo.eager(:bar).all.map{|o| [o, o.bar]}.should == [[@foo, @bar]]
+    @db.sqls.should == ["SELECT * FROM foos", "SELECT * FROM bars WHERE (bars.object_ids[0] IN (2))"]
+    @db.fetch = [[{:id=>1, :object_ids=>[2]}], [{:id=>1, :object_ids=>[2], :x_foreign_key_x=>2}]]
+    @Foo.eager(:mtmbars).all.map{|o| [o, o.mtmbars]}.should == [[@foo, [@bar]]]
+    @db.sqls.should == ["SELECT * FROM foos", "SELECT bars.*, bars_foos.foo_ids[0] AS x_foreign_key_x FROM bars INNER JOIN bars_foos ON ((bars_foos.bar_ids[0] = bars.object_ids[0]) AND (bars_foos.foo_ids[0] IN (2)))"]
+    @db.fetch = [[{:id=>1, :object_ids=>[2]}], [{:id=>1, :object_ids=>[2], :x_foreign_key_x=>2}]]
+    @Bar.eager(:mtmfoos).all.map{|o| [o, o.mtmfoos]}.should == [[@bar, [@foo]]]
+    @db.sqls.should == ["SELECT * FROM bars", "SELECT foos.*, bars_foos.bar_ids[0] AS x_foreign_key_x FROM foos INNER JOIN bars_foos ON ((bars_foos.foo_ids[0] = foos.object_ids[0]) AND (bars_foos.bar_ids[0] IN (2)))"]
+  end
+
+  it "should have working eager graphing methods" do
+    @db.fetch = {:id=>1, :object_ids=>[2], :foo_id=>1, :foo_object_ids=>[2]}
+    @Bar.eager_graph(:foo).all.map{|o| [o, o.foo]}.should == [[@bar, @foo]]
+    @db.sqls.should == ["SELECT bars.id, bars.object_ids, foo.id AS foo_id, foo.object_ids AS foo_object_ids FROM bars LEFT OUTER JOIN foos AS foo ON (foo.object_ids[0] = bars.object_ids[0])"]
+    @db.fetch = {:id=>1, :object_ids=>[2], :bars_id=>1, :bars_object_ids=>[2]}
+    @Foo.eager_graph(:bars).all.map{|o| [o, o.bars]}.should == [[@foo, [@bar]]]
+    @db.sqls.should == ["SELECT foos.id, foos.object_ids, bars.id AS bars_id, bars.object_ids AS bars_object_ids FROM foos LEFT OUTER JOIN bars ON (bars.object_ids[0] = foos.object_ids[0])"]
+    @db.fetch = {:id=>1, :object_ids=>[2], :bar_id=>1, :bar_object_ids=>[2]}
+    @Foo.eager_graph(:bar).all.map{|o| [o, o.bar]}.should == [[@foo, @bar]]
+    @db.sqls.should == ["SELECT foos.id, foos.object_ids, bar.id AS bar_id, bar.object_ids AS bar_object_ids FROM foos LEFT OUTER JOIN bars AS bar ON (bar.object_ids[0] = foos.object_ids[0])"]
+    @db.fetch = {:id=>1, :object_ids=>[2], :mtmfoos_id=>1, :mtmfoos_object_ids=>[2]}
+    @Bar.eager_graph(:mtmfoos).all.map{|o| [o, o.mtmfoos]}.should == [[@bar, [@foo]]]
+    @db.sqls.should == ["SELECT bars.id, bars.object_ids, mtmfoos.id AS mtmfoos_id, mtmfoos.object_ids AS mtmfoos_object_ids FROM bars LEFT OUTER JOIN bars_foos ON (bars_foos.bar_ids[0] = bars.object_ids[0]) LEFT OUTER JOIN foos AS mtmfoos ON (mtmfoos.object_ids[0] = bars_foos.foo_ids[0])"]
+    @db.fetch = {:id=>1, :object_ids=>[2], :mtmbars_id=>1, :mtmbars_object_ids=>[2]}
+    @Foo.eager_graph(:mtmbars).all.map{|o| [o, o.mtmbars]}.should == [[@foo, [@bar]]]
+    @db.sqls.should == ["SELECT foos.id, foos.object_ids, mtmbars.id AS mtmbars_id, mtmbars.object_ids AS mtmbars_object_ids FROM foos LEFT OUTER JOIN bars_foos ON (bars_foos.foo_ids[0] = foos.object_ids[0]) LEFT OUTER JOIN bars AS mtmbars ON (mtmbars.object_ids[0] = bars_foos.bar_ids[0])"]
+  end
+
+  it "should have working filter by associations with model instances" do
+    @Bar.first(:foo=>@foo).should == @bar
+    @db.sqls.should == ["SELECT * FROM bars WHERE (bars.object_ids[0] = 2) LIMIT 1"]
+    @Foo.first(:bars=>@bar).should == @foo
+    @db.sqls.should == ["SELECT * FROM foos WHERE (foos.object_ids[0] = 2) LIMIT 1"]
+    @Foo.first(:bar=>@bar).should == @foo
+    @db.sqls.should == ["SELECT * FROM foos WHERE (foos.object_ids[0] = 2) LIMIT 1"]
+    @Foo.first(:mtmbars=>@bar).should == @foo
+    @db.sqls.should == ["SELECT * FROM foos WHERE (foos.object_ids[0] IN (SELECT bars_foos.foo_ids[0] FROM bars_foos WHERE ((bars_foos.bar_ids[0] = 2) AND (bars_foos.foo_ids[0] IS NOT NULL)))) LIMIT 1"]
+    @Bar.first(:mtmfoos=>@foo).should == @bar
+    @db.sqls.should == ["SELECT * FROM bars WHERE (bars.object_ids[0] IN (SELECT bars_foos.bar_ids[0] FROM bars_foos WHERE ((bars_foos.foo_ids[0] = 2) AND (bars_foos.bar_ids[0] IS NOT NULL)))) LIMIT 1"]
+  end
+
+  it "should have working filter by associations with model datasets" do
+    @Bar.first(:foo=>@Foo.where(:id=>@foo.id)).should == @bar
+    @db.sqls.should == ["SELECT * FROM bars WHERE (bars.object_ids[0] IN (SELECT foos.object_ids[0] FROM foos WHERE ((id = 1) AND (foos.object_ids[0] IS NOT NULL)))) LIMIT 1"]
+    @Foo.first(:bars=>@Bar.where(:id=>@bar.id)).should == @foo
+    @db.sqls.should == ["SELECT * FROM foos WHERE (foos.object_ids[0] IN (SELECT bars.object_ids[0] FROM bars WHERE ((id = 1) AND (bars.object_ids[0] IS NOT NULL)))) LIMIT 1"]
+    @Foo.first(:bar=>@Bar.where(:id=>@bar.id)).should == @foo
+    @db.sqls.should == ["SELECT * FROM foos WHERE (foos.object_ids[0] IN (SELECT bars.object_ids[0] FROM bars WHERE ((id = 1) AND (bars.object_ids[0] IS NOT NULL)))) LIMIT 1"]
+    @Foo.first(:mtmbars=>@Bar.where(:id=>@bar.id)).should == @foo
+    @db.sqls.should == ["SELECT * FROM foos WHERE (foos.object_ids[0] IN (SELECT bars_foos.foo_ids[0] FROM bars_foos WHERE ((bars_foos.bar_ids[0] IN (SELECT bars.object_ids[0] FROM bars WHERE ((id = 1) AND (bars.object_ids[0] IS NOT NULL)))) AND (bars_foos.foo_ids[0] IS NOT NULL)))) LIMIT 1"]
+    @Bar.first(:mtmfoos=>@Foo.where(:id=>@foo.id)).should == @bar
+    @db.sqls.should == ["SELECT * FROM bars WHERE (bars.object_ids[0] IN (SELECT bars_foos.bar_ids[0] FROM bars_foos WHERE ((bars_foos.foo_ids[0] IN (SELECT foos.object_ids[0] FROM foos WHERE ((id = 1) AND (foos.object_ids[0] IS NOT NULL)))) AND (bars_foos.bar_ids[0] IS NOT NULL)))) LIMIT 1"]
+  end
+end
+
 describe "Model#pk_or_nil" do
   before do
     @m = Class.new(Sequel::Model)