sequel 4.9.0 → 4.10.0

data/spec/integration/dataset_test.rb

@@ -157,6 +157,14 @@ describe "Simple Dataset operations" do
     rows = []
     @ds.order(Sequel.*(:number, 2)).paged_each(:rows_per_fetch=>5, :strategy=>:filter, :filter_values=>proc{|row, _| [row[:number] * 2]}){|row| rows << row}
     rows.should == (1..100).map{|i| {:id=>i, :number=>i*10}}
+
+    if DB.adapter_scheme == :jdbc
+      # check retrival with varying fetch sizes
+      array = (1..100).to_a
+      [1, 2, 5, 10, 33, 50, 100, 1000].each do |i|
+        @ds.with_fetch_size(i).select_order_map(:id).should == array
+      end
+    end
   end
 
   specify "should fetch all results correctly" do
@@ -187,6 +195,15 @@ describe "Simple Dataset operations" do
     @ds.order(:id).limit(2, 1).all.should == [{:id=>2, :number=>20}]
   end
 
+  specify "should fetch correctly with just offset" do
+    @ds.order(:id).offset(0).all.should == [{:id=>1, :number=>10}]
+    @ds.order(:id).offset(1).all.should == []
+    @ds.insert(:number=>20)
+    @ds.order(:id).offset(0).all.should == [{:id=>1, :number=>10}, {:id=>2, :number=>20}]
+    @ds.order(:id).offset(1).all.should == [{:id=>2, :number=>20}]
+    @ds.order(:id).offset(2).all.should == []
+  end
+
   specify "should fetch correctly with a limit and offset using seperate methods" do
     @ds.order(:id).limit(2).offset(0).all.should == [{:id=>1, :number=>10}]
     @ds.order(:id).limit(2).offset(1).all.should == []

data/spec/integration/model_test.rb

@@ -22,6 +22,23 @@ describe "Sequel::Model basic support" do
     Item.find(:name=>'J').should == Item.load(:id=>1, :name=>'J')
   end
   
+  specify ".finder should create method that returns first matching item" do
+    def Item.by_name(name) where(:name=>name) end
+    Item.finder :by_name
+    Item.first_by_name('J').should == nil
+    Item.create(:name=>'J')
+    Item.first_by_name('J').should == Item.load(:id=>1, :name=>'J')
+    Item.first_by_name(['J', 'K']).should == Item.load(:id=>1, :name=>'J')
+  end
+  
+  specify ".prepared_finder should create method that returns first matching item" do
+    def Item.by_name(name) where(:name=>name) end
+    Item.prepared_finder :by_name
+    Item.first_by_name('J').should == nil
+    Item.create(:name=>'J')
+    Item.first_by_name('J').should == Item.load(:id=>1, :name=>'J')
+  end
+  
   specify ".find_or_create should return first matching item, or create it if it doesn't exist" do
     Item.all.should == []
     Item.find_or_create(:name=>'J').should == Item.load(:id=>1, :name=>'J')

data/spec/integration/schema_test.rb

@@ -266,6 +266,10 @@ describe "Database schema modifiers" do
     @db[:items2].all.should == [{:number=>10}]
   end
   
+  specify "should not raise an error if table doesn't exist when using drop_table :if_exists" do
+    proc{@db.drop_table(:items, :if_exists=>true)}.should_not raise_error
+  end if DB.supports_drop_table_if_exists?
+
   describe "views" do
     before do
       @db.drop_view(:items_view) rescue nil
@@ -287,6 +291,16 @@ describe "Database schema modifiers" do
       @db[:items_view].map(:n).should == [1]
     end
 
+    specify "should drop views correctly" do
+      @db.create_view(:items_view, @ds.where(:number=>1))
+      @db.drop_view(:items_view)
+      proc{@db[:items_view].map(:number)}.should raise_error(Sequel::DatabaseError)
+    end
+
+    specify "should not raise an error if view doesn't exist when using drop_view :if_exists" do
+      proc{@db.drop_view(:items_view, :if_exists=>true)}.should_not raise_error
+    end if DB.supports_drop_table_if_exists?
+
     specify "should create or replace views correctly" do
       @db.create_or_replace_view(:items_view, @ds.where(:number=>1))
       @db[:items_view].map(:number).should == [1]

data/spec/integration/transaction_test.rb

@@ -84,7 +84,7 @@ describe "Database transactions" do
   end 
   
   if DB.supports_savepoints?
-    cspecify "should support nested transactions through savepoints using the savepoint option", [:jdbc, :sqlite] do
+    specify "should support nested transactions through savepoints using the savepoint option" do
       @db.transaction do
         @d << {:name => '1'}
         @db.transaction(:savepoint=>true) do
@@ -107,6 +107,30 @@ describe "Database transactions" do
 
       @d.order(:name).map(:name).should == %w{1 4 5 6}
     end
+
+    specify "should support nested transactions through savepoints using the auto_savepoint option" do
+      @db.transaction(:auto_savepoint=>true) do
+        @d << {:name => '1'}
+        @db.transaction do
+          @d << {:name => '2'}
+          @db.transaction do
+            @d << {:name => '3'}
+            raise Sequel::Rollback
+          end
+        end
+        @d << {:name => '4'}
+        @db.transaction(:auto_savepoint=>true) do
+          @d << {:name => '6'}
+          @db.transaction do
+            @d << {:name => '7'}
+            raise Sequel::Rollback
+          end
+        end
+        @d << {:name => '5'}
+      end
+
+      @d.order(:name).map(:name).should == %w{1 4 5 6}
+    end
   end
 
   specify "should handle returning inside of the block by committing" do

data/spec/model/association_reflection_spec.rb

@@ -282,9 +282,10 @@ describe Sequel::Model::Associations::AssociationReflection, "#remove_before_des
   end
 end
 
-describe Sequel::Model::Associations::AssociationReflection, "#eager_limit_strategy" do
+describe Sequel::Model::Associations::AssociationReflection, "#filter_by_associations_limit_strategy" do
   before do
-    @c = Class.new(Sequel::Model(:a))
+    @db = Sequel.mock
+    @c = Class.new(Sequel::Model(@db[:a]))
   end
   after do
     Sequel::Model.default_eager_limit_strategy = true
@@ -292,53 +293,83 @@ describe Sequel::Model::Associations::AssociationReflection, "#eager_limit_strat
 
   it "should be nil by default for *_one associations" do
     @c.many_to_one :c, :class=>@c
-    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
     @c.one_to_one :c, :class=>@c
-    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
+    @c.one_through_one :c, :class=>@c
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
   end
 
-  it "should be :ruby by default for *_many associations" do
+  it "should be :correlated_subquery by default for one_to_many and one_to_one with :order associations" do
+    @c.one_to_one :c, :class=>@c, :order=>:a
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should == :correlated_subquery
     @c.one_to_many :cs, :class=>@c, :limit=>1
-    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :correlated_subquery
+  end
+
+  it "should be :ruby by default for many_to_many and one_through_one with :order associations" do
+    @c.one_through_one :c, :class=>@c, :order=>:a
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should == :ruby
     @c.many_to_many :cs, :class=>@c, :limit=>1
-    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :ruby
   end
 
-  it "should be nil for many_to_one associations" do
+  it "should be nil for many_to_one associations even if :eager_limit_strategy or :filter_limit_strategy is used" do
     @c.many_to_one :c, :class=>@c, :eager_limit_strategy=>true
-    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
     @c.many_to_one :c, :class=>@c, :eager_limit_strategy=>:distinct_on
-    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
+    @c.many_to_one :c, :class=>@c, :filter_limit_strategy=>true
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
   end
 
   it "should be a symbol for other associations if given a symbol" do
     @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>:distinct_on
-    @c.association_reflection(:c).eager_limit_strategy.should == :distinct_on
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should == :distinct_on
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>:window_function, :limit=>1
-    @c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
   end
 
   it "should use :distinct_on for one_to_one associations if picking and the association dataset supports ordered distinct on" do
     def (@c.dataset).supports_ordered_distinct_on?() true end
     @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>true
-    @c.association_reflection(:c).eager_limit_strategy.should == :distinct_on
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should == :distinct_on
   end
 
   it "should use :window_function for associations if picking and the association dataset supports window functions" do
     def (@c.dataset).supports_window_functions?() true end
     @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>true
-    @c.association_reflection(:c).eager_limit_strategy.should == :window_function
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should == :window_function
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
-    @c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
     @c.many_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
-    @c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
   end
 
-  it "should use :ruby for *_many associations if picking and the association dataset doesn't window functions" do
+  it "should use :ruby for one_to_many associations if the database doesn't support limits in subqueries" do
+    def (@c.dataset).supports_limits_in_correlated_subqueries?; false; end
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
-    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :ruby
+  end
+
+  it "should use :ruby for one_to_many associations if offset doesn't work in correlated subqueries and an offset is used" do
+    def (@c.dataset).supports_offsets_in_correlated_subqueries?; false; end
+    @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :correlated_subquery
+    @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>[1, 1]
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :ruby
+  end
+
+  it "should use :ruby for one_to_many associations if composite primary key is used and database does not multiple columns in IN" do
+    def (@c.dataset).supports_multiple_column_in?; false; end
+    @c.set_primary_key [:id, :id2]
+    @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1, :key=>[:id, :id2]
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :ruby
+  end
+
+  it "should use :ruby for many_to_many associations if picking and the association dataset doesn't window functions" do
     @c.many_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
-    @c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :ruby
   end
 
   it "should respect Model.default_eager_limit_strategy to *_many associations" do
@@ -348,24 +379,32 @@ describe Sequel::Model::Associations::AssociationReflection, "#eager_limit_strat
     c.dataset = :a
     c.default_eager_limit_strategy.should == :window_function
     c.one_to_many :cs, :class=>c, :limit=>1
-    c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
     c.many_to_many :cs, :class=>c, :limit=>1
-    c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
 
     Sequel::Model.default_eager_limit_strategy = true
     c = Class.new(Sequel::Model)
     c.dataset = :a
     c.one_to_many :cs, :class=>c, :limit=>1
-    c.association_reflection(:cs).eager_limit_strategy.should == :ruby
+    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :correlated_subquery
     def (c.dataset).supports_window_functions?() true end
     c.many_to_many :cs, :class=>c, :limit=>1
-    c.association_reflection(:cs).eager_limit_strategy.should == :window_function
+    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
   end
 
   it "should ignore Model.default_eager_limit_strategy for one_to_one associations" do
     @c.default_eager_limit_strategy = :window_function
     @c.one_to_one :c, :class=>@c
-    @c.association_reflection(:c).eager_limit_strategy.should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
+  end
+end
+
+describe Sequel::Model::Associations::AssociationReflection, "#apply_eager_dataset_changes" do
+  it "should apply the eager block as well as the association options to the dataset" do
+    @c = Class.new(Sequel::Model(:foo))
+    @c.one_to_many :cs, :class=>@c, :select=>:a, :order=>:b do |ds| ds.where(:c) end
+    @c.association_reflection(:cs).apply_eager_dataset_changes(@c.dataset).sql.should == 'SELECT a FROM foo WHERE c ORDER BY b'
   end
 end
 

data/spec/model/associations_spec.rb

@@ -1860,19 +1860,19 @@ describe Sequel::Model, "many_to_many" do
 
   it "should use implicit key values and join table if omitted" do
     @c2.many_to_many :attributes, :class => @c1 
-    @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 = 1234))'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
   end
   
   it "should use implicit key values and join table if omitted" do
     @c2.one_through_one :attribute, :class => @c1 
-    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) LIMIT 1'
+    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 1'
   end
   
   it "should use implicit class if omitted" do
     begin
       class ::Tag < Sequel::Model; end
       @c2.many_to_many :tags
-      @c2.new(:id => 1234).tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN nodes_tags ON ((nodes_tags.tag_id = tags.id) AND (nodes_tags.node_id = 1234))'
+      @c2.new(:id => 1234).tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN nodes_tags ON (nodes_tags.tag_id = tags.id) WHERE (nodes_tags.node_id = 1234)'
     ensure
       Object.send(:remove_const, :Tag)
     end
@@ -1884,7 +1884,7 @@ describe Sequel::Model, "many_to_many" do
         class Tag < Sequel::Model; end
       end
       @c2.many_to_many :tags, :class=>'::Historical::Tag'
-      @c2.new(:id => 1234).tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN nodes_tags ON ((nodes_tags.tag_id = tags.id) AND (nodes_tags.node_id = 1234))'
+      @c2.new(:id => 1234).tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN nodes_tags ON (nodes_tags.tag_id = tags.id) WHERE (nodes_tags.node_id = 1234)'
     ensure
       Object.send(:remove_const, :Historical)
     end
@@ -1892,41 +1892,41 @@ describe Sequel::Model, "many_to_many" do
   
   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))'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (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))'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attribute2node ON (attribute2node.attributeid = attributes.id) WHERE (attribute2node.nodeid = 1234)'
   end
   
   it "should support a conditions option" do
     @c2.many_to_many :attributes, :class => @c1, :conditions => {:a=>32}
-    @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 = 1234)) WHERE (a = 32)'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == '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.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 = 1234)) WHERE (a = 32)'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == '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.should == [@c1.load({})]
   end
   
   it "should support an order option" do
     @c2.many_to_many :attributes, :class => @c1, :order => :blah
-    @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 = 1234)) ORDER BY blah'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) ORDER BY blah'
   end
   
   it "should support an array for the order option" do
     @c2.many_to_many :attributes, :class => @c1, :order => [:blah1, :blah2]
-    @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 = 1234)) ORDER BY blah1, blah2'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) ORDER BY blah1, blah2'
   end
   
   it "should support :left_primary_key and :right_primary_key options" do
     @c2.many_to_many :attributes, :class => @c1, :left_primary_key=>:xxx, :right_primary_key=>:yyy
-    @c2.new(:id => 1234, :xxx=>5).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.yyy) AND (attributes_nodes.node_id = 5))'
+    @c2.new(:id => 1234, :xxx=>5).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.yyy) WHERE (attributes_nodes.node_id = 5)'
   end
   
   it "should support 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.load(:id => 1234, :x=>5).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.r1 = attributes.id) AND (attributes_nodes.r2 = attributes.y) AND (attributes_nodes.l1 = 1234) AND (attributes_nodes.l2 = 5))'
+    @c2.load(:id => 1234, :x=>5).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.r1 = attributes.id) AND (attributes_nodes.r2 = attributes.y)) WHERE ((attributes_nodes.l1 = 1234) AND (attributes_nodes.l2 = 5))'
   end
   
   it "should not issue query if not all keys have values" do
@@ -1951,13 +1951,13 @@ describe Sequel::Model, "many_to_many" do
   it "should support a select option" do
     @c2.many_to_many :attributes, :class => @c1, :select => :blah
 
-    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT blah FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT blah FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
   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.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.*, attribute_nodes.blah2 FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == '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
   
   it "should accept a block" do
@@ -1967,7 +1967,7 @@ describe Sequel::Model, "many_to_many" do
 
     n = @c2.new(:id => 1234)
     n.xxx = 555
-    n.attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (xxx = 555)'
+    n.attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (xxx = 555))'
   end
 
   it "should allow the :order option while accepting a block" do
@@ -1977,7 +1977,7 @@ describe Sequel::Model, "many_to_many" do
 
     n = @c2.new(:id => 1234)
     n.xxx = 555
-    n.attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (xxx = 555) ORDER BY blah1, blah2'
+    n.attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (xxx = 555)) ORDER BY blah1, blah2'
   end
 
   it "should support a :dataset option that is used instead of the default" do
@@ -1994,7 +1994,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_dataset.join_table(:natural, :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(:an__nodeid=>pk)}, :order=> :a, :limit=>10, :select=>nil do |ds|
       ds.filter(:xxx => @xxx)
     end
 
@@ -2007,9 +2007,9 @@ describe Sequel::Model, "many_to_many" do
 
   it "should support a :limit option" do
     @c2.many_to_many :attributes, :class => @c1 , :limit=>10
-    @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 = 1234)) LIMIT 10'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 10'
     @c2.many_to_many :attributes, :class => @c1 , :limit=>[10, 10]
-    @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 = 1234)) LIMIT 10 OFFSET 10'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 10 OFFSET 10'
   end
 
   it "should have the :eager option affect the _dataset method" do
@@ -2021,7 +2021,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1, :join_table => :attribute2node___attributes_nodes
     n = @c2.load(:id => 1234)
     a = @c1.load(:id => 2345)
-    n.attributes_dataset.sql.should == "SELECT attributes.* FROM attributes INNER JOIN attribute2node AS attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))"
+    n.attributes_dataset.sql.should == "SELECT attributes.* FROM attributes INNER JOIN attribute2node AS attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)"
     a.should == n.add_attribute(a)
     a.should == n.remove_attribute(a)
     n.remove_all_attributes
@@ -2062,7 +2062,6 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1
     
     n = @c2.load(:id => 1234)
-    a = @c1.load(:id => 2345)
     @c1.dataset._fetch = []
     proc{n.add_attribute(2345)}.should raise_error(Sequel::NoMatchingRow)
     DB.sqls.should == ["SELECT * FROM attributes WHERE id = 2345"]
@@ -2100,7 +2099,7 @@ describe Sequel::Model, "many_to_many" do
     n = @c2.new(:id => 1234)
     @c1.dataset._fetch = {:id=>234}
     n.remove_attribute(234).should == @c1.load(:id => 234)
-    DB.sqls.should == ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (attributes.id = 234) LIMIT 1",
+    DB.sqls.should == ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (attributes.id = 234)) LIMIT 1",
       "DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 234))"]
   end
     
@@ -2192,8 +2191,8 @@ describe Sequel::Model, "many_to_many" do
     @c1.dataset._fetch = {:id=>234, :y=>8}
     @c1.load(:id => 234, :y=>8).should == n.remove_attribute([234, 8])
     sqls = DB.sqls
-    ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE ((attributes.id = 234) AND (attributes.y = 8)) LIMIT 1",
-      "SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE ((attributes.y = 8) AND (attributes.id = 234)) LIMIT 1"].should include(sqls.shift)
+    ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (attributes.id = 234) AND (attributes.y = 8)) LIMIT 1",
+      "SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (attributes.y = 8) AND (attributes.id = 234)) LIMIT 1"].should include(sqls.shift)
     sqls.should == ["DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 234))"]
   end
     
@@ -2255,7 +2254,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1
     
     @c2.new(:id => 1234).attributes.should == [@c1.load({})]
-    DB.sqls.should == ['SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))']
+    DB.sqls.should == ['SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)']
   end
 
   it "should populate cache when accessed" do
@@ -2282,7 +2281,7 @@ describe Sequel::Model, "many_to_many" do
     n = @c2.new(:id => 1234)
     n.associations[:attributes] = 42
     n.attributes(true).should_not == 42
-    DB.sqls.should == ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))"]
+    DB.sqls.should == ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)"]
   end
 
   it "should add item to cache if it exists when calling add_" do
@@ -2608,7 +2607,7 @@ describe Sequel::Model, "many_to_many" do
   
   it "should support a :distinct option that uses the DISTINCT clause" do
     @c2.many_to_many :attributes, :class => @c1, :distinct=>true
-    @c2.load(:id=>10).attributes_dataset.sql.should == "SELECT DISTINCT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 10))"
+    @c2.load(:id=>10).attributes_dataset.sql.should == "SELECT DISTINCT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 10)"
   end
 
   it "should not apply association options when removing all associated records" do
@@ -2625,7 +2624,7 @@ describe Sequel::Model, "many_to_many" do
     end
     @c1.dataset._fetch = {:id=>2}
     @c2.load(:id=>1).remove_attribute(2)
-    DB.sqls.should == ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1)) WHERE ((join_table_att = 3) AND (attributes.id = 2)) LIMIT 1",
+    DB.sqls.should == ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1) AND (join_table_att = 3) AND (attributes.id = 2)) LIMIT 1",
       "DELETE FROM attributes_nodes WHERE ((node_id = 1) AND (attribute_id = 2))"] 
   end
 end
@@ -2657,46 +2656,46 @@ describe Sequel::Model, "one_through_one" do
 
   it "should use implicit key values and join table if omitted" do
     @c2.one_through_one :attribute, :class => @c1 
-    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) LIMIT 1'
+    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 1'
   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.new(:id => 1234).attribute_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)) LIMIT 1'
+    @c2.new(:id => 1234).attribute_dataset.sql.should == '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
   
   it "should use explicit key values and join table if given" do
     @c2.one_through_one :attribute, :class => @c1, :left_key => :nodeid, :right_key => :attributeid, :join_table => :attribute2node
-    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attribute2node ON ((attribute2node.attributeid = attributes.id) AND (attribute2node.nodeid = 1234)) LIMIT 1'
+    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attribute2node ON (attribute2node.attributeid = attributes.id) WHERE (attribute2node.nodeid = 1234) LIMIT 1'
   end
   
   it "should support a conditions option" do
     @c2.one_through_one :attribute, :class => @c1, :conditions => {:a=>32}
-    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (a = 32) LIMIT 1'
+    @c2.new(:id => 1234).attribute_dataset.sql.should == '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.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (a = 32) LIMIT 1'
+    @c2.new(:id => 1234).attribute_dataset.sql.should == '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.should == @c1.load({})
   end
   
   it "should support an order option" do
     @c2.one_through_one :attribute, :class => @c1, :order => :blah
-    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) ORDER BY blah LIMIT 1'
+    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) ORDER BY blah LIMIT 1'
   end
   
   it "should support an array for the order option" do
     @c2.one_through_one :attribute, :class => @c1, :order => [:blah1, :blah2]
-    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) ORDER BY blah1, blah2 LIMIT 1'
+    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) ORDER BY blah1, blah2 LIMIT 1'
   end
   
   it "should support :left_primary_key and :right_primary_key options" do
     @c2.one_through_one :attribute, :class => @c1, :left_primary_key=>:xxx, :right_primary_key=>:yyy
-    @c2.new(:id => 1234, :xxx=>5).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.yyy) AND (attributes_nodes.node_id = 5)) LIMIT 1'
+    @c2.new(:id => 1234, :xxx=>5).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.yyy) WHERE (attributes_nodes.node_id = 5) LIMIT 1'
   end
   
   it "should support composite keys" do
     @c2.one_through_one :attribute, :class => @c1, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:id, :x], :right_primary_key=>[:id, :y]
-    @c2.load(:id => 1234, :x=>5).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.r1 = attributes.id) AND (attributes_nodes.r2 = attributes.y) AND (attributes_nodes.l1 = 1234) AND (attributes_nodes.l2 = 5)) LIMIT 1'
+    @c2.load(:id => 1234, :x=>5).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.r1 = attributes.id) AND (attributes_nodes.r2 = attributes.y)) WHERE ((attributes_nodes.l1 = 1234) AND (attributes_nodes.l2 = 5)) LIMIT 1'
   end
   
   it "should not issue query if not all keys have values" do
@@ -2721,13 +2720,13 @@ describe Sequel::Model, "one_through_one" do
   it "should support a select option" do
     @c2.one_through_one :attribute, :class => @c1, :select => :blah
 
-    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT blah FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) LIMIT 1'
+    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT blah FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 1'
   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.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.*, attribute_nodes.blah2 FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) LIMIT 1'
+    @c2.new(:id => 1234).attribute_dataset.sql.should == '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
   
   it "should accept a block" do
@@ -2737,7 +2736,7 @@ describe Sequel::Model, "one_through_one" do
 
     n = @c2.new(:id => 1234)
     n.xxx = 555
-    n.attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (xxx = 555) LIMIT 1'
+    n.attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (xxx = 555)) LIMIT 1'
   end
 
   it "should allow the :order option while accepting a block" do
@@ -2747,7 +2746,7 @@ describe Sequel::Model, "one_through_one" do
 
     n = @c2.new(:id => 1234)
     n.xxx = 555
-    n.attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (xxx = 555) ORDER BY blah1, blah2 LIMIT 1'
+    n.attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (xxx = 555)) ORDER BY blah1, blah2 LIMIT 1'
   end
 
   it "should support a :dataset option that is used instead of the default" do
@@ -2764,7 +2763,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_dataset.join_table(:natural, :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(:an__nodeid=>pk)}, :order=> :a, :select=>nil do |ds|
       ds.filter(:xxx => @xxx)
     end
 
@@ -2777,7 +2776,7 @@ describe Sequel::Model, "one_through_one" do
 
   it "should support a :limit option to specify an offset" do
     @c2.one_through_one :attribute, :class => @c1 , :limit=>[nil, 10]
-    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) LIMIT 1 OFFSET 10'
+    @c2.new(:id => 1234).attribute_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 1 OFFSET 10'
   end
 
   it "should have the :eager option affect the _dataset method" do
@@ -2788,14 +2787,12 @@ describe Sequel::Model, "one_through_one" do
   it "should handle an aliased join table" do
     @c2.one_through_one :attribute, :class => @c1, :join_table => :attribute2node___attributes_nodes
     n = @c2.load(:id => 1234)
-    a = @c1.load(:id => 2345)
-    n.attribute_dataset.sql.should == "SELECT attributes.* FROM attributes INNER JOIN attribute2node AS attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) LIMIT 1"
+    n.attribute_dataset.sql.should == "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
   
   it "should raise an error if the model object doesn't have a valid primary key" do
     @c2.one_through_one :attribute, :class => @c1 
     a = @c2.new
-    n = @c1.load(:id=>123)
     proc{a.attribute_dataset}.should raise_error(Sequel::Error)
   end
   
@@ -2803,7 +2800,7 @@ describe Sequel::Model, "one_through_one" do
     @c2.one_through_one :attribute, :class => @c1
     
     @c2.new(:id => 1234).attribute.should == @c1.load({})
-    DB.sqls.should == ['SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) LIMIT 1']
+    DB.sqls.should == ['SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 1']
   end
 
   it "should populate cache when accessed" do
@@ -2830,7 +2827,7 @@ describe Sequel::Model, "one_through_one" do
     n = @c2.new(:id => 1234)
     n.associations[:attribute] = 42
     n.attribute(true).should_not == 42
-    DB.sqls.should == ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) LIMIT 1"]
+    DB.sqls.should == ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 1"]
   end
 
   it "should not add associations methods directly to class" do
@@ -2861,7 +2858,7 @@ describe Sequel::Model, "one_through_one" do
 
   it "should support a :distinct option that uses the DISTINCT clause" do
     @c2.one_through_one :attribute, :class => @c1, :distinct=>true
-    @c2.load(:id=>10).attribute_dataset.sql.should == "SELECT DISTINCT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 10)) LIMIT 1"
+    @c2.load(:id=>10).attribute_dataset.sql.should == "SELECT DISTINCT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 10) LIMIT 1"
   end
 end
 
@@ -2888,6 +2885,7 @@ describe "Filtering by associations" do
 
       many_to_one :artist, :class=>artist, :key=>:artist_id
       one_to_many :tracks, :class=>track, :key=>:album_id
+      one_to_one :track, :class=>track, :key=>:album_id
       one_to_one :album_info, :class=>album_info, :key=>:album_id
       many_to_many :tags, :class=>tag, :left_key=>:album_id, :join_table=>:albums_tags, :right_key=>:tag_id
 
@@ -2937,6 +2935,9 @@ describe "Filtering by associations" do
       one_through_one :al_ctag, :clone=>:l_ctag, :conditions=>c
     end
   end
+  after do
+    @Album.default_eager_limit_strategy = true
+  end
 
   it "should be able to filter on many_to_one associations" do
     @Album.filter(:artist=>@Artist.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE (albums.artist_id = 3)'
@@ -2994,6 +2995,47 @@ describe "Filtering by associations" do
     @Album.filter(:l_track=>@Track.load(:id=>5, :album_id=>3)).sql.should == "SELECT * FROM albums WHERE (albums.id IN (SELECT tracks.album_id FROM tracks WHERE ((tracks.album_id IS NOT NULL) AND (tracks.id IN (SELECT DISTINCT ON (tracks.album_id) tracks.id FROM tracks ORDER BY tracks.album_id, name)) AND (tracks.id = 5))))"
   end
 
+  it "should be able to filter on one_to_one associations with :filter_limit_strategy" do
+    @Album.one_to_one :l_track2, :clone=>:track, :filter_limit_strategy=>:window_function
+    @Album.filter(:l_track2=>@Track.load(:id=>5, :album_id=>3)).sql.should == "SELECT * FROM albums WHERE (albums.id IN (SELECT tracks.album_id FROM tracks WHERE ((tracks.album_id IS NOT NULL) AND (tracks.id IN (SELECT id FROM (SELECT tracks.id, row_number() OVER (PARTITION BY tracks.album_id) AS x_sequel_row_number_x FROM tracks) AS t1 WHERE (x_sequel_row_number_x = 1))) AND (tracks.id = 5))))"
+  end
+
+  it "should be able to filter on one_to_one associations with :eager_limit_strategy" do
+    @Album.one_to_one :l_track2, :clone=>:track, :eager_limit_strategy=>:window_function
+    @Album.filter(:l_track2=>@Track.load(:id=>5, :album_id=>3)).sql.should == "SELECT * FROM albums WHERE (albums.id IN (SELECT tracks.album_id FROM tracks WHERE ((tracks.album_id IS NOT NULL) AND (tracks.id IN (SELECT id FROM (SELECT tracks.id, row_number() OVER (PARTITION BY tracks.album_id) AS x_sequel_row_number_x FROM tracks) AS t1 WHERE (x_sequel_row_number_x = 1))) AND (tracks.id = 5))))"
+  end
+
+  it "should be able to filter on one_to_one associations with :order and :filter_limit_strategy" do
+    @Album.one_to_one :l_track2, :clone=>:l_track, :filter_limit_strategy=>:window_function
+    @Album.filter(:l_track2=>@Track.load(:id=>5, :album_id=>3)).sql.should == "SELECT * FROM albums WHERE (albums.id IN (SELECT tracks.album_id FROM tracks WHERE ((tracks.album_id IS NOT NULL) AND (tracks.id IN (SELECT id FROM (SELECT tracks.id, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks) AS t1 WHERE (x_sequel_row_number_x = 1))) AND (tracks.id = 5))))"
+  end
+
+  it "should be able to filter on one_to_one associations with :order and :eager_limit_strategy" do
+    @Album.one_to_one :l_track2, :clone=>:l_track, :eager_limit_strategy=>:window_function
+    @Album.filter(:l_track2=>@Track.load(:id=>5, :album_id=>3)).sql.should == "SELECT * FROM albums WHERE (albums.id IN (SELECT tracks.album_id FROM tracks WHERE ((tracks.album_id IS NOT NULL) AND (tracks.id IN (SELECT id FROM (SELECT tracks.id, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks) AS t1 WHERE (x_sequel_row_number_x = 1))) AND (tracks.id = 5))))"
+  end
+
+  it "should be able to filter on one_to_one associations with :order and Model.default_eager_limit_strategy" do
+    @Album.default_eager_limit_strategy = :window_function
+    @Album.one_to_one :l_track2, :clone=>:l_track
+    @Album.filter(:l_track2=>@Track.load(:id=>5, :album_id=>3)).sql.should == "SELECT * FROM albums WHERE (albums.id IN (SELECT tracks.album_id FROM tracks WHERE ((tracks.album_id IS NOT NULL) AND (tracks.id IN (SELECT id FROM (SELECT tracks.id, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks) AS t1 WHERE (x_sequel_row_number_x = 1))) AND (tracks.id = 5))))"
+  end
+
+  it "should be able to filter on one_to_one associations with :order and :eager_limit_strategy=>:union" do
+    @Album.one_to_one :l_track2, :clone=>:l_track, :eager_limit_strategy=>:union
+    @Album.filter(:l_track2=>@Track.load(:id=>5, :album_id=>3)).sql.should == "SELECT * FROM albums WHERE (albums.id IN (SELECT tracks.album_id FROM tracks WHERE ((tracks.album_id IS NOT NULL) AND (tracks.id IN (SELECT DISTINCT ON (tracks.album_id) tracks.id FROM tracks ORDER BY tracks.album_id, name)) AND (tracks.id = 5))))"
+  end
+
+  it "should be able to filter on one_to_one associations with :order and :eager_limit_strategy=>:ruby" do
+    @Album.one_to_one :l_track2, :clone=>:l_track, :eager_limit_strategy=>:ruby
+    @Album.filter(:l_track2=>@Track.load(:id=>5, :album_id=>3)).sql.should == "SELECT * FROM albums WHERE (albums.id IN (SELECT tracks.album_id FROM tracks WHERE ((tracks.album_id IS NOT NULL) AND (tracks.id IN (SELECT DISTINCT ON (tracks.album_id) tracks.id FROM tracks ORDER BY tracks.album_id, name)) AND (tracks.id = 5))))"
+  end
+
+  it "should be able to filter on one_to_one associations with :filter_limit_strategy :correlated_subquery" do
+    @Album.one_to_one :l_track2, :clone=>:track, :filter_limit_strategy=>:correlated_subquery
+    @Album.filter(:l_track2=>@Track.load(:id=>5, :album_id=>3)).sql.should == "SELECT * FROM albums WHERE (albums.id IN (SELECT tracks.album_id FROM tracks WHERE ((tracks.album_id IS NOT NULL) AND (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) LIMIT 1)) AND (tracks.id = 5))))"
+  end
+
   it "should be able to filter on many_to_many associations with :limit" do
     @Album.filter(:l_tags=>@Tag.load(:id=>3)).sql.should == "SELECT * FROM albums WHERE (albums.id IN (SELECT albums_tags.album_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id IS NOT NULL) AND ((albums_tags.album_id, tags.id) IN (SELECT b, c FROM (SELECT albums_tags.album_id AS b, tags.id AS c, row_number() OVER (PARTITION BY albums_tags.album_id) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id)) AS t1 WHERE (x_sequel_row_number_x <= 10))) AND (tags.id = 3))))"
   end
@@ -3070,6 +3112,11 @@ describe "Filtering by associations" do
     @Album.filter(:l_ctracks=>@Track.load(:id=>5, :album_id1=>3, :album_id2=>4)).sql.should == "SELECT * FROM albums WHERE ((albums.id1, albums.id2) IN (SELECT tracks.album_id1, tracks.album_id2 FROM tracks WHERE ((tracks.album_id1 IS NOT NULL) AND (tracks.album_id2 IS NOT NULL) AND (tracks.id IN (SELECT id FROM (SELECT tracks.id, row_number() OVER (PARTITION BY tracks.album_id1, tracks.album_id2) AS x_sequel_row_number_x FROM tracks) AS t1 WHERE (x_sequel_row_number_x <= 10))) AND (tracks.id = 5))))"
   end
 
+  it "should be able to filter on one_to_many associations with composite keys and :filter_limit_strategy :correlated_subquery" do
+    @Album.one_to_one :l_ctracks2, :clone=>:l_ctracks, :filter_limit_strategy=>:correlated_subquery
+    @Album.filter(:l_ctracks2=>@Track.load(:id=>5, :album_id1=>3, :album_id2=>4)).sql.should == "SELECT * FROM albums WHERE ((albums.id1, albums.id2) IN (SELECT tracks.album_id1, tracks.album_id2 FROM tracks WHERE ((tracks.album_id1 IS NOT NULL) AND (tracks.album_id2 IS NOT NULL) AND (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE ((t1.album_id1 = tracks.album_id1) AND (t1.album_id2 = tracks.album_id2)) LIMIT 1)) AND (tracks.id = 5))))"
+  end
+
   it "should be able to filter on one_to_one associations with :order and composite keys" do
     @Album.filter(:l_ctrack=>@Track.load(:id=>5, :album_id1=>3, :album_id2=>4)).sql.should == "SELECT * FROM albums WHERE ((albums.id1, albums.id2) IN (SELECT tracks.album_id1, tracks.album_id2 FROM tracks WHERE ((tracks.album_id1 IS NOT NULL) AND (tracks.album_id2 IS NOT NULL) AND (tracks.id IN (SELECT DISTINCT ON (tracks.album_id1, tracks.album_id2) tracks.id FROM tracks ORDER BY tracks.album_id1, tracks.album_id2, name)) AND (tracks.id = 5))))"
   end
@@ -3814,9 +3861,9 @@ describe "Sequel::Model Associations with clashing column names" do
     @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))"]
+    @db.sqls.should == ["SELECT * FROM foos LIMIT 1", "SELECT bars.* FROM bars INNER JOIN bars_foos ON (bars_foos.object_id = bars.object_id) WHERE (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))"]
+    @db.sqls.should == ["SELECT * FROM bars LIMIT 1", "SELECT foos.* FROM foos INNER JOIN bars_foos ON (bars_foos.foo_id = foos.object_id) WHERE (bars_foos.object_id = 2)"]
   end
 
   it "should have working eager loading methods" do
@@ -3828,10 +3875,10 @@ describe "Sequel::Model Associations with clashing column names" do
     @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.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) WHERE (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)))"]
+    @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) WHERE (bars_foos.object_id IN (2))"]
   end
 
   it "should have working eager graphing methods" do
@@ -3963,9 +4010,9 @@ describe "Sequel::Model Associations with non-column expression keys" do
     @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))"]
+    @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]) WHERE (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))"]
+    @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]) WHERE (bars_foos.bar_ids[0] = 2)"]
   end
 
   it "should have working eager loading methods" do
@@ -3977,10 +4024,10 @@ describe "Sequel::Model Associations with non-column expression keys" do
     @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.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]) WHERE (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)))"]
+    @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]) WHERE (bars_foos.bar_ids[0] IN (2))"]
   end
 
   it "should have working eager graphing methods" do