sequel 3.5.0 → 3.6.0

data/spec/integration/prepared_statement_test.rb

@@ -23,11 +23,43 @@ describe "Prepared Statements and Bound Arguments" do
     @ds.filter(:number=>@ds.ba(:$n)).call(:all, :n=>10).should == [{:id=>1, :number=>10}]
     @ds.filter(:number=>@ds.ba(:$n)).call(:first, :n=>10).should == {:id=>1, :number=>10}
   end
+    
+  specify "should support blocks for select and all" do
+    @ds.filter(:number=>@ds.ba(:$n)).call(:select, :n=>10){|r| r[:number] *= 2}.should == [{:id=>1, :number=>20}]
+    @ds.filter(:number=>@ds.ba(:$n)).call(:all, :n=>10){|r| r[:number] *= 2}.should == [{:id=>1, :number=>20}]
+  end
+    
+  specify "should support binding variables before the call with #bind" do
+    @ds.filter(:number=>@ds.ba(:$n)).bind(:n=>10).call(:select).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).bind(:n=>10).call(:all).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).bind(:n=>10).call(:first).should == {:id=>1, :number=>10}
+    
+    @ds.bind(:n=>10).filter(:number=>@ds.ba(:$n)).call(:select).should == [{:id=>1, :number=>10}]
+    @ds.bind(:n=>10).filter(:number=>@ds.ba(:$n)).call(:all).should == [{:id=>1, :number=>10}]
+    @ds.bind(:n=>10).filter(:number=>@ds.ba(:$n)).call(:first).should == {:id=>1, :number=>10}
+  end
+  
+  specify "should allow overriding variables specified with #bind" do
+    @ds.filter(:number=>@ds.ba(:$n)).bind(:n=>1).call(:select, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).bind(:n=>1).call(:all, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).bind(:n=>1).call(:first, :n=>10).should == {:id=>1, :number=>10}
+    
+    @ds.filter(:number=>@ds.ba(:$n)).bind(:n=>1).bind(:n=>10).call(:select).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).bind(:n=>1).bind(:n=>10).call(:all).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).bind(:n=>1).bind(:n=>10).call(:first).should == {:id=>1, :number=>10}
+  end
 
   specify "should support placeholder literal strings" do
     @ds.filter("number = ?", @ds.ba(:$n)).call(:select, :n=>10).should == [{:id=>1, :number=>10}]
   end
 
+  specify "should support named placeholder literal strings and handle multiple named placeholders correctly" do
+    @ds.filter("number = :n", :n=>@ds.ba(:$n)).call(:select, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.insert(:number=>20)
+    @ds.insert(:number=>30)
+    @ds.filter("number > :n1 AND number < :n2 AND number = :n3", :n3=>@ds.ba(:$n3), :n2=>@ds.ba(:$n2), :n1=>@ds.ba(:$n1)).call(:select, :n3=>20, :n2=>30, :n1=>10).should == [{:id=>2, :number=>20}]
+  end
+
   specify "should support datasets with static sql and placeholders" do
     INTEGRATION_DB["SELECT * FROM items WHERE number = ?", @ds.ba(:$n)].call(:select, :n=>10).should == [{:id=>1, :number=>10}]
   end

data/spec/integration/schema_test.rb

@@ -29,10 +29,8 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items, :reload=>true)
     clear_sqls
     INTEGRATION_DB.schema(:items)
-    sqls_should_be
     clear_sqls
     INTEGRATION_DB.schema(:items, :reload=>true)
-    sqls_should_be "PRAGMA table_info('items')"
   end
 
   specify "should raise an error when the table doesn't exist" do
@@ -53,7 +51,6 @@ describe "Database schema parser" do
     col_info[:type].should == :integer
     clear_sqls
     INTEGRATION_DB.schema(:items)
-    sqls_should_be
   end
 
   cspecify "should parse primary keys from the schema properly", [proc{|db| db.class.adapter_scheme != :jdbc}, :mssql] do
@@ -161,6 +158,14 @@ describe "Database schema modifiers" do
     @ds.insert([10])
     @ds.columns!.should == [:number]
   end
+  
+  specify "should allow creating indexes with tables" do
+    @db.create_table!(:items){Integer :number; index :number}
+    @db.table_exists?(:items).should == true
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:number]
+    @ds.insert([10])
+    @ds.columns!.should == [:number]
+  end
 
   specify "should handle foreign keys correctly when creating tables" do
     @db.create_table!(:items) do 

data/spec/integration/spec_helper.rb

@@ -64,30 +64,6 @@ if defined?(INTEGRATION_DB) || defined?(INTEGRATION_URL) || ENV['SEQUEL_INTEGRAT
     INTEGRATION_DB = Sequel.connect(url)
     #INTEGRATION_DB.instance_variable_set(:@server_version, 80100)
   end
-  class Spec::Example::ExampleGroup
-    def sqls_should_be(*args)
-    end 
-  end
 else
-  sql_logger = Object.new
-  def sql_logger.info(str)
-    $sqls << str 
-  end
-  INTEGRATION_DB = Sequel.sqlite('', :loggers=>[sql_logger], :quote_identifiers=>false)
-  class Spec::Example::ExampleGroup
-    def sqls_should_be(*sqls)
-      sqls.zip($sqls).each do |should_be, is|
-        case should_be
-        when String
-          is.should == should_be
-        when Regexp
-          is.should =~ should_be
-        else
-          raise ArgumentError, "need String or RegExp"
-        end
-      end
-      $sqls.length.should == sqls.length
-      clear_sqls
-    end 
-  end
+  INTEGRATION_DB = Sequel.sqlite('', :quote_identifiers=>false)
 end

data/spec/model/association_reflection_spec.rb

@@ -135,3 +135,41 @@ describe Sequel::Model::Associations::AssociationReflection, "#select" do
   end
 end
 
+describe Sequel::Model::Associations::AssociationReflection, "#can_have_associated_objects?" do
+  it "should be true for any given object (for backward compatibility)" do
+    Sequel::Model::Associations::AssociationReflection.new.can_have_associated_objects?(Object.new).should == true
+  end
+end
+
+describe Sequel::Model::Associations::AssociationReflection, "#associated_object_keys" do
+  before do
+    @c = Class.new(Sequel::Model)
+    class ::ParParent < Sequel::Model; end
+  end
+
+  it "should use the primary keys for a many_to_one association" do
+    @c.many_to_one :c, :class=>ParParent
+    @c.association_reflection(:c).associated_object_keys.should == [:id]
+    @c.many_to_one :c, :class=>ParParent, :primary_key=>:d_id
+    @c.association_reflection(:c).associated_object_keys.should == [:d_id]
+    @c.many_to_one :c, :class=>ParParent, :key=>[:c_id1, :c_id2], :primary_key=>[:id1, :id2]
+    @c.association_reflection(:c).associated_object_keys.should == [:id1, :id2]
+  end
+  it "should use the keys for a one_to_many association" do
+    ParParent.one_to_many :cs, :class=>ParParent
+    ParParent.association_reflection(:cs).associated_object_keys.should == [:par_parent_id]
+    @c.one_to_many :cs, :class=>ParParent, :key=>:d_id
+    @c.association_reflection(:cs).associated_object_keys.should == [:d_id]
+    @c.one_to_many :cs, :class=>ParParent, :key=>[:c_id1, :c_id2], :primary_key=>[:id1, :id2]
+    @c.association_reflection(:cs).associated_object_keys.should == [:c_id1, :c_id2]
+  end
+  it "should use the right primary keys for a many_to_many association" do
+    @c.many_to_many :cs, :class=>ParParent
+    @c.association_reflection(:cs).associated_object_keys.should == [:id]
+    @c.many_to_many :cs, :class=>ParParent, :right_primary_key=>:d_id
+    @c.association_reflection(:cs).associated_object_keys.should == [:d_id]
+    @c.many_to_many :cs, :class=>ParParent, :right_key=>[:c_id1, :c_id2], :right_primary_key=>[:id1, :id2]
+    @c.association_reflection(:cs).associated_object_keys.should == [:id1, :id2]
+  end
+end
+

data/spec/model/associations_spec.rb

@@ -193,6 +193,12 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.parent_id = 1) AND (nodes.id = 234)) LIMIT 1"]
   end
   
+  it "should not issue query if not all keys have values" do
+    @c2.many_to_one :parent, :class => @c2, :key=>[:id, :parent_id], :primary_key=>[:parent_id, :id]
+    @c2.new(:id => 1, :parent_id => nil).parent.should == nil
+    MODEL_DB.sqls.should == []
+  end
+  
   it "should raise an Error unless same number of composite keys used" do
     proc{@c2.many_to_one :parent, :class => @c2, :primary_key=>[:parent_id, :id]}.should raise_error(Sequel::Error)
     proc{@c2.many_to_one :parent, :class => @c2, :key=>[:id, :parent_id], :primary_key=>:id}.should raise_error(Sequel::Error)
@@ -552,11 +558,13 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.reset
 
     @c1 = Class.new(Sequel::Model(:attributes)) do
+      def _refresh(ds); end
       unrestrict_primary_key
       columns :id, :node_id, :y
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
+      def _refresh(ds); end
       unrestrict_primary_key
       attr_accessor :xxx
       
@@ -567,6 +575,7 @@ describe Sequel::Model, "one_to_many" do
     @dataset = @c2.dataset
     
     @c2.dataset.extend(Module.new {
+      def empty?; false; end
       def fetch_rows(sql)
         @db << sql
         yield Hash.new
@@ -574,6 +583,7 @@ describe Sequel::Model, "one_to_many" do
     })
 
     @c1.dataset.extend(Module.new {
+      def empty?; opts.has_key?(:empty) ? (super; true) : false; end
       def fetch_rows(sql)
         @db << sql
         yield Hash.new
@@ -632,6 +642,12 @@ describe Sequel::Model, "one_to_many" do
     @c2.load(:id => 1234, :x=>234).attributes_dataset.sql.should == 'SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (attributes.id = 234))'
   end
   
+  it "should not issue query if not all keys have values" do
+    @c2.one_to_many :attributes, :class => @c1, :key =>[:node_id, :id], :primary_key=>[:id, :x]
+    @c2.load(:id => 1234, :x=>nil).attributes.should == []
+    MODEL_DB.sqls.should == []
+  end
+  
   it "should raise an Error unless same number of composite keys used" do
     proc{@c2.one_to_many :attributes, :class => @c1, :key=>[:node_id, :id]}.should raise_error(Sequel::Error)
     proc{@c2.one_to_many :attributes, :class => @c1, :primary_key=>[:node_id, :id]}.should raise_error(Sequel::Error)
@@ -640,7 +656,7 @@ describe Sequel::Model, "one_to_many" do
     proc{@c2.one_to_many :attributes, :class => @c1, :key=>[:node_id, :id, :x], :primary_key=>[:parent_id, :id]}.should raise_error(Sequel::Error)
   end
 
-  it "should define an add_ method" do
+  it "should define an add_ method that works on existing records" do
     @c2.one_to_many :attributes, :class => @c1
     
     n = @c2.new(:id => 1234)
@@ -648,20 +664,77 @@ describe Sequel::Model, "one_to_many" do
     a.save
     MODEL_DB.reset
     a.should == n.add_attribute(a)
+    a.values.should == {:node_id => 1234, :id => 2345}
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 1234 WHERE (id = 2345)']
   end
 
-  it "should define a remove_ method" do
+  it "should define an add_ method that works on new records" do
     @c2.one_to_many :attributes, :class => @c1
     
     n = @c2.new(:id => 1234)
-    a = @c1.new(:id => 2345)
+    a = @c1.new(:id => 234)
+    # do not save
+    MODEL_DB.reset
+    a.should == n.add_attribute(a)
+    MODEL_DB.sqls.first.should =~ /INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/
+    a.values.should == {:node_id => 1234, :id => 234}
+  end
+
+  it "should define a remove_ method that works on existing records" do
+    @c2.one_to_many :attributes, :class => @c1
+    
+    n = @c2.new(:id => 1234)
+    a = @c1.new(:id => 2345, :node_id => 1234)
     a.save
     MODEL_DB.reset
     a.should == n.remove_attribute(a)
+    a.values.should == {:node_id => nil, :id => 2345}
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = NULL WHERE (id = 2345)']
   end
+
+  it "should have the remove_ method raise an error if the passed object is not already associated" do
+    @c2.one_to_many :attributes, :class => @c1
+    @c1.dataset.opts[:empty] = true
+    
+    n = @c2.new(:id => 1234)
+    a = @c1.load(:id => 2345, :node_id => 1234)
+    MODEL_DB.reset
+    proc{n.remove_attribute(a)}.should raise_error(Sequel::Error)
+    MODEL_DB.sqls.should == ["SELECT 1 FROM attributes WHERE ((attributes.node_id = 1234) AND (id = 2345)) LIMIT 1"]
+  end
+
+  it "should accept a hash for the add_ method and create a new record" do
+    @c2.one_to_many :attributes, :class => @c1
+    n = @c2.new(:id => 1234)
+    MODEL_DB.reset
+    @c1.load(:node_id => 1234, :id => 234).should == n.add_attribute(:id => 234)
+    MODEL_DB.sqls.first.should =~ /INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/
+  end
+
+  it "should raise an error in the add_ method if the passed associated object is not of the correct type" do
+    @c2.one_to_many :attributes, :class => @c1
+    proc{@c2.new(:id => 1234).add_attribute(@c2.new)}.should raise_error(Sequel::Error)
+  end
+
+  it "should accept a primary key for the remove_ method and remove an existing record" do
+    @c2.one_to_many :attributes, :class => @c1
+    n = @c2.new(:id => 1234)
+    ds = @c1.dataset
+    def ds.fetch_rows(sql)
+      db << sql
+      yield({:id=>234, :node_id=>1234})
+    end
+    MODEL_DB.reset
+    @c1.load(:node_id => nil, :id => 234).should == n.remove_attribute(234)
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (id = 234)) LIMIT 1',
+      'UPDATE attributes SET node_id = NULL WHERE (id = 234)']
+  end
   
+  it "should raise an error in the remove_ method if the passed associated object is not of the correct type" do
+    @c2.one_to_many :attributes, :class => @c1
+    proc{@c2.new(:id => 1234).remove_attribute(@c2.new)}.should raise_error(Sequel::Error)
+  end
+
   it "should have add_ method respect the :primary_key option" do
     @c2.one_to_many :attributes, :class => @c1, :primary_key=>:xxx
     
@@ -672,6 +745,21 @@ describe Sequel::Model, "one_to_many" do
     a.should == n.add_attribute(a)
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 5 WHERE (id = 2345)']
   end
+  
+  it "should have add_ method not add the same object to the cached association array if the object is already in the array" do
+    @c2.one_to_many :attributes, :class => @c1
+    
+    n = @c2.new(:id => 1234)
+    a = @c1.new(:id => 2345)
+    a.save
+    MODEL_DB.reset
+    n.associations[:attributes] = []
+    a.should == n.add_attribute(a)
+    a.should == n.add_attribute(a)
+    a.values.should == {:node_id => 1234, :id => 2345}
+    MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 1234 WHERE (id = 2345)'] * 2
+    n.attributes.should == [a]
+  end
 
   it "should have add_ method respect composite keys" do
     @c2.one_to_many :attributes, :class => @c1, :key =>[:node_id, :y], :primary_key=>[:id, :x]
@@ -691,6 +779,22 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(id = 2345\)/
   end
   
+  it "should accept a array of composite primary key values for the remove_ method and remove an existing record" do
+    @c1.set_primary_key :id, :y
+    @c2.one_to_many :attributes, :class => @c1, :key=>:node_id, :primary_key=>:id
+    n = @c2.new(:id => 123)
+    ds = @c1.dataset
+    def ds.fetch_rows(sql)
+      db << sql
+      yield({:id=>234, :node_id=>123, :y=>5})
+    end
+    MODEL_DB.reset
+    @c1.load(:node_id => nil, :y => 5, :id => 234).should == n.remove_attribute([234, 5])
+    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.first.should =~ /SELECT \* FROM attributes WHERE \(\(attributes.node_id = 123\) AND \(\((id|y) = (234|5)\) AND \((id|y) = (234|5)\)\)\) LIMIT 1/
+    MODEL_DB.sqls.last.should =~ /UPDATE attributes SET node_id = NULL WHERE \(\((id|y) = (234|5)\) AND \((id|y) = (234|5)\)\)/
+  end
+  
   it "should raise an error in add_ and remove_ if the passed object returns false to save (is not valid)" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
@@ -714,7 +818,6 @@ describe Sequel::Model, "one_to_many" do
     a = @c2.new
     n = @c1.load(:id=>123)
     proc{a.attributes_dataset}.should raise_error(Sequel::Error)
-    proc{a.attributes}.should raise_error(Sequel::Error)
     proc{a.add_attribute(n)}.should raise_error(Sequel::Error)
     proc{a.remove_attribute(n)}.should raise_error(Sequel::Error)
     proc{a.remove_all_attributes}.should raise_error(Sequel::Error)
@@ -1056,6 +1159,7 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true
     attrib = @c1.new(:id=>3)
     d = @c1.dataset
+    @c1.class_eval{remove_method :_refresh}
     def d.fetch_rows(s); yield({:id=>3}) end
     @c2.new(:id => 1234).attribute = attrib
     ['INSERT INTO attributes (node_id, id) VALUES (1234, 3)',
@@ -1086,6 +1190,7 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true, :primary_key=>:xxx
     attrib = @c1.new(:id=>3)
     d = @c1.dataset
+    @c1.class_eval{remove_method :_refresh}
     def d.fetch_rows(s); yield({:id=>3}) end
     @c2.new(:id => 1234, :xxx=>5).attribute = attrib
     ['INSERT INTO attributes (node_id, id) VALUES (5, 3)',
@@ -1410,6 +1515,12 @@ describe Sequel::Model, "many_to_many" do
     @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))'
   end
   
+  it "should not issue query if not all keys have values" 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=>nil).attributes.should == []
+    MODEL_DB.sqls.should == []
+  end
+  
   it "should raise an Error unless same number of composite keys used" do
     proc{@c2.many_to_many :attributes, :class => @c1, :left_key=>[:node_id, :id]}.should raise_error(Sequel::Error)
     proc{@c2.many_to_many :attributes, :class => @c1, :left_primary_key=>[:node_id, :id]}.should raise_error(Sequel::Error)
@@ -1504,7 +1615,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.new(:id => 1234).attributes_dataset.opts[:eager].should == {:attributes=>nil}
   end
   
-  it "should define an add_ method" do
+  it "should define an add_ method that works on existing records" do
     @c2.many_to_many :attributes, :class => @c1
     
     n = @c2.load(:id => 1234)
@@ -1515,7 +1626,18 @@ describe Sequel::Model, "many_to_many" do
     ].should(include(MODEL_DB.sqls.first))
   end
 
-  it "should define a remove_ method" do
+  it "should allow passing a hash to the add_ method which creates a new record" do
+    @c2.many_to_many :attributes, :class => @c1
+    
+    n = @c2.load(:id => 1234)
+    @c1.load(:id => 1).should == n.add_attribute(:id => 1)
+    MODEL_DB.sqls.first.should == 'INSERT INTO attributes (id) VALUES (1)'
+    ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 1)',
+     'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (1, 1234)'
+    ].should(include(MODEL_DB.sqls.last))
+  end
+
+  it "should define a remove_ method that works on existing records" do
     @c2.many_to_many :attributes, :class => @c1
     
     n = @c2.new(:id => 1234)
@@ -1524,6 +1646,30 @@ describe Sequel::Model, "many_to_many" do
     MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 2345))'
   end
 
+  it "should raise an error in the add_ method if the passed associated object is not of the correct type" do
+    @c2.many_to_many :attributes, :class => @c1
+    proc{@c2.new(:id => 1234).add_attribute(@c2.new)}.should raise_error(Sequel::Error)
+  end
+
+  it "should accept a primary key for the remove_ method and remove an existing record" do
+    @c2.many_to_many :attributes, :class => @c1
+    n = @c2.new(:id => 1234)
+    ds = @c1.dataset
+    def ds.fetch_rows(sql)
+      db << sql
+      yield({:id=>234})
+    end
+    MODEL_DB.reset
+    @c1.load(:id => 234).should == n.remove_attribute(234)
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE (id = 234) LIMIT 1',
+      'DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 234))']
+  end
+    
+  it "should raise an error in the remove_ method if the passed associated object is not of the correct type" do
+    @c2.many_to_many :attributes, :class => @c1
+    proc{@c2.new(:id => 1234).remove_attribute(@c2.new)}.should raise_error(Sequel::Error)
+  end
+
   it "should have the add_ method respect the :left_primary_key and :right_primary_key options" do
     @c2.many_to_many :attributes, :class => @c1, :left_primary_key=>:xxx, :right_primary_key=>:yyy
     
@@ -1535,6 +1681,17 @@ describe Sequel::Model, "many_to_many" do
     ].should(include(MODEL_DB.sqls.first))
   end
   
+  it "should have add_ method not add the same object to the cached association array if the object is already in the array" do
+    @c2.many_to_many :attributes, :class => @c1
+    
+    n = @c2.load(:id => 1234).set(:xxx=>5)
+    a = @c1.load(:id => 2345).set(:yyy=>8)
+    n.associations[:attributes] = []
+    a.should == n.add_attribute(a)
+    a.should == n.add_attribute(a)
+    n.attributes.should == [a]
+  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]
     n = @c2.load(:id => 1234, :x=>5)
@@ -1572,12 +1729,27 @@ describe Sequel::Model, "many_to_many" do
     MODEL_DB.sqls.should == ["DELETE FROM attributes_nodes WHERE ((l1 = 1234) AND (l2 = 5) AND (r1 = 2345) AND (r2 = 8))"]
   end
 
+  it "should accept a array of composite primary key values for the remove_ method and remove an existing record" do
+    @c1.set_primary_key [:id, :y]
+    @c2.many_to_many :attributes, :class => @c1
+    n = @c2.new(:id => 1234)
+    ds = @c1.dataset
+    def ds.fetch_rows(sql)
+      db << sql
+      yield({:id=>234, :y=>8})
+    end
+    MODEL_DB.reset
+    @c1.load(:id => 234, :y=>8).should == n.remove_attribute([234, 8])
+    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.first.should =~ /SELECT \* FROM attributes WHERE \(\((id|y) = (234|8)\) AND \((id|y) = (234|8)\)\) LIMIT 1/
+    MODEL_DB.sqls.last.should == 'DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 234))'
+  end
+    
   it "should raise an error if the model object doesn't have a valid primary key" do
     @c2.many_to_many :attributes, :class => @c1 
     a = @c2.new
     n = @c1.load(:id=>123)
     proc{a.attributes_dataset}.should raise_error(Sequel::Error)
-    proc{a.attributes}.should raise_error(Sequel::Error)
     proc{a.add_attribute(n)}.should raise_error(Sequel::Error)
     proc{a.remove_attribute(n)}.should raise_error(Sequel::Error)
     proc{a.remove_all_attributes}.should raise_error(Sequel::Error)
@@ -1957,7 +2129,6 @@ describe Sequel::Model, "many_to_many" do
   end
 
   it "should support a :uniq option that removes duplicates from the association" do
-    h = []
     @c2.many_to_many :attributes, :class => @c1, :uniq=>true
     @c1.class_eval do
       def @dataset.fetch_rows(sql)
@@ -1969,6 +2140,11 @@ describe Sequel::Model, "many_to_many" do
     end
     @c2.load(:id=>10, :parent_id=>20).attributes.should == [@c1.load(:id=>20), @c1.load(:id=>30)]
   end
+  
+  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))"
+  end
 end
 
 describe Sequel::Model, " association reflection methods" do