sequel 3.4.0 → 3.5.0

data/spec/integration/schema_test.rb

@@ -56,7 +56,7 @@ describe "Database schema parser" do
     sqls_should_be
   end
 
-  specify "should parse primary keys from the schema properly" do
+  cspecify "should parse primary keys from the schema properly", [proc{|db| db.class.adapter_scheme != :jdbc}, :mssql] do
     INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
     INTEGRATION_DB.create_table!(:items){primary_key :number}
@@ -81,7 +81,7 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == 'blah'
   end
 
-  specify "should parse types from the schema properly" do
+  cspecify "should parse types from the schema properly", [:do, :mysql], [:jdbc, :mysql] do
     INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
     INTEGRATION_DB.create_table!(:items){Fixnum :number}
@@ -183,7 +183,7 @@ describe "Database schema modifiers" do
     @ds.all.should == [{:number=>10, :name=>nil}]
   end
 
-  specify "should add primary key columns to tables correctly" do
+  cspecify "should add primary key columns to tables correctly", :h2 do
     @db.create_table!(:items){Integer :number}
     @ds.insert(:number=>10)
     @db.alter_table(:items){add_primary_key :id}
@@ -220,7 +220,7 @@ describe "Database schema modifiers" do
     @ds.all.should == [{:n2=>'blah'}, {:n2=>'blah'}]
   end
 
-  specify "should rename columns with not null constraints" do
+  cspecify "should rename columns with not null constraints", [:mysql, :mysql] do
     @db.create_table!(:items){String :n, :null=>false}
     @ds.insert(:n=>'blah')
     @db.alter_table(:items){rename_column :n, :n2}
@@ -231,7 +231,7 @@ describe "Database schema modifiers" do
     proc{@ds.insert}.should raise_error(Sequel::DatabaseError)
   end
 
-  specify "should set column NULL/NOT NULL correctly" do
+  cspecify "should set column NULL/NOT NULL correctly", [:mysql, :mysql] do
     @db.create_table!(:items){Integer :id}
     @ds.insert(:id=>10)
     @db.alter_table(:items){set_column_allow_null :id, false}
@@ -263,7 +263,7 @@ describe "Database schema modifiers" do
     @ds.all.should == [{:id=>"10"}, {:id=>"20"}]
   end
 
-  specify "should add unique constraints and foreign key table constraints correctly" do
+  cspecify "should add unique constraints and foreign key table constraints correctly", :sqlite do
     @db.create_table!(:items){Integer :id; Integer :item_id}
     @db.alter_table(:items) do
       add_unique_constraint [:item_id, :id]
@@ -273,7 +273,7 @@ describe "Database schema modifiers" do
     @ds.columns!.should == [:id, :item_id]
   end
 
-  specify "should remove columns from tables correctly" do
+  cspecify "should remove columns from tables correctly", :h2, :mssql do
     @db.create_table!(:items) do
       primary_key :id
       String :name

data/spec/integration/spec_helper.rb

@@ -22,7 +22,38 @@ class Spec::Example::ExampleGroup
       INTEGRATION_DB.loggers << Logger.new(STDOUT)
       yield
     ensure
-     INTEGRATION_DB.loggers.clear
+     INTEGRATION_DB.loggers.pop
+    end
+  end
+
+  def self.cspecify(message, *checked, &block)
+    pending = false
+    checked.each do |c|
+      case c
+      when INTEGRATION_DB.database_type
+        pending = c
+      when Array
+        case c.length
+        when 1
+          pending = c if c.first == INTEGRATION_DB.class.adapter_scheme
+        when 2
+          if c.first.is_a?(Proc)
+            pending = c if c.first.call(INTEGRATION_DB) && c.last == INTEGRATION_DB.database_type
+          elsif c.last.is_a?(Proc)
+            pending = c if c.first == INTEGRATION_DB.class.adapter_scheme && c.last.call(INTEGRATION_DB)
+          else
+            pending = c if c.first == INTEGRATION_DB.class.adapter_scheme && c.last == INTEGRATION_DB.database_type
+          end
+        when 3
+          pending = c if c[0] == INTEGRATION_DB.class.adapter_scheme && c[1] == INTEGRATION_DB.database_type && c[2].call(INTEGRATION_DB)
+        end          
+      end
+      break if pending
+    end
+    if pending
+      specify(message){pending("Not yet working on #{Array(pending).join(', ')}", &block)}
+    else
+      specify(message, &block)
     end
   end
 end

data/spec/integration/timezone_test.rb

@@ -31,19 +31,19 @@ describe "Sequel timezone support" do
     Sequel.datetime_class = Time
   end
 
-  specify "should support using UTC for database storage and local time for the application" do
+  cspecify "should support using UTC for database storage and local time for the application", [:do, proc{|db| db.database_type != :sqlite}] do
     Sequel.database_timezone = :utc
     Sequel.application_timezone = :local
     test_timezone
   end
   
-  specify "should support using local time for database storage and UTC for the application" do
+  cspecify "should support using local time for database storage and UTC for the application", [:do, proc{|db| db.database_type != :sqlite}] do
     Sequel.database_timezone = :local
     Sequel.application_timezone = :utc
     test_timezone
   end
   
-  specify "should support using UTC for both database storage and for application" do
+  cspecify "should support using UTC for both database storage and for application", [:do, proc{|db| db.database_type != :sqlite}] do
     Sequel.default_timezone = :utc
     test_timezone
   end

data/spec/integration/transaction_test.rb

@@ -71,7 +71,7 @@ describe "Database transactions" do
   end 
   
   if INTEGRATION_DB.supports_savepoints?
-    specify "should support nested transactions through savepoints using the savepoint option" do
+    cspecify "should support nested transactions through savepoints using the savepoint option", [:jdbc, :sqlite] do
       @db = INTEGRATION_DB
       @db.transaction do
         @d << {:name => '1'}

data/spec/integration/type_test.rb

@@ -6,7 +6,7 @@ describe "Supported types" do
     INTEGRATION_DB[:items]
   end
 
-  specify "should support casting correctly" do
+  cspecify "should support casting correctly", [:sqlite, :sqlite] do
     ds = create_items_table_with_column(:number, Integer)
     ds.insert(:number => 1)
     ds.select(:number.cast_string.as(:n)).map(:n).should == %w'1'
@@ -45,7 +45,7 @@ describe "Supported types" do
     ds.all.should == [{:number=>2.1}]
   end
   
-  specify "should support generic numeric type" do
+  cspecify "should support generic numeric type", [:odbc, :mssql] do
     ds = create_items_table_with_column(:number, Numeric, :size=>[15, 10])
     ds.insert(:number => BigDecimal.new('2.123456789'))
     ds.all.should == [{:number=>BigDecimal.new('2.123456789')}]
@@ -60,14 +60,14 @@ describe "Supported types" do
     ds.all.should == [{:name=>'Test User'}]
   end
   
-  specify "should support generic date type" do
+  cspecify "should support generic date type", [:do, :sqlite], [:jdbc, :sqlite], :mssql do
     ds = create_items_table_with_column(:dat, Date)
     d = Date.today
     ds.insert(:dat => d)
     ds.first[:dat].should == d
   end
   
-  specify "should support generic datetime type" do
+  cspecify "should support generic datetime type", [:do, :sqlite], [:jdbc, :sqlite] do
     ds = create_items_table_with_column(:tim, DateTime)
     t = DateTime.now
     ds.insert(:tim => t)
@@ -78,14 +78,14 @@ describe "Supported types" do
     ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
   end
   
-  specify "should support generic file type" do
+  cspecify "should support generic file type", [:do], :h2, [:odbc, :mssql] do
     ds = create_items_table_with_column(:name, File)
     ds.insert(:name => ("a\0"*300).to_sequel_blob)
     ds.all.should == [{:name=>("a\0"*300).to_sequel_blob}]
     ds.first[:name].should be_a_kind_of(::Sequel::SQL::Blob)
   end
   
-  specify "should support generic boolean type" do
+  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:odbc, :mssql] do
     ds = create_items_table_with_column(:number, TrueClass)
     ds.insert(:number => true)
     ds.all.should == [{:number=>true}]

data/spec/model/association_reflection_spec.rb

@@ -73,6 +73,24 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_twos
     ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
   end
+  
+  it "should handle composite keys" do
+    ParParent.many_to_one :par_parent_two, :key=>[:a, :b], :primary_key=>[:c, :b]
+    ParParent.many_to_one :par_parent_three, :key=>[:d, :e], :primary_key=>[:c, :b]
+    ParParentTwo.one_to_many :par_parents, :primary_key=>[:c, :b], :key=>[:a, :b]
+    ParParentThree.one_to_many :par_parents, :primary_key=>[:c, :b], :key=>[:d, :e]
+
+    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
+    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_three
+
+    ParParent.many_to_many :par_parent_twos, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:pl1, :pl2], :right_primary_key=>[:pr1, :pr2], :join_table=>:jt
+    ParParent.many_to_many :par_parent_threes, :right_key=>[:l1, :l2], :left_key=>[:r1, :r2], :left_primary_key=>[:pl1, :pl2], :right_primary_key=>[:pr1, :pr2], :join_table=>:jt
+    ParParentTwo.many_to_many :par_parents, :right_key=>[:l1, :l2], :left_key=>[:r1, :r2], :right_primary_key=>[:pl1, :pl2], :left_primary_key=>[:pr1, :pr2], :join_table=>:jt
+    ParParentThree.many_to_many :par_parents, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :right_primary_key=>[:pl1, :pl2], :left_primary_key=>[:pr1, :pr2], :join_table=>:jt
+
+    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_twos
+    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
+  end
 
   it "should figure out the reciprocal if the :reciprocal value is not present" do
     ParParent.many_to_one :par_parent_two

data/spec/model/associations_spec.rb

@@ -186,6 +186,19 @@ describe Sequel::Model, "many_to_one" do
     @c2.new(:id => 1, :blah => 567).parent
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.pk = 567) LIMIT 1"]
   end
+  
+  it "should support composite keys" do
+    @c2.many_to_one :parent, :class => @c2, :key=>[:id, :parent_id], :primary_key=>[:parent_id, :id]
+    @c2.new(:id => 1, :parent_id => 234).parent
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.parent_id = 1) AND (nodes.id = 234)) LIMIT 1"]
+  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)
+    proc{@c2.many_to_one :parent, :class => @c2, :key=>:id, :primary_key=>[:parent_id, :id]}.should raise_error(Sequel::Error)
+    proc{@c2.many_to_one :parent, :class => @c2, :key=>[:id, :parent_id, :blah], :primary_key=>[:parent_id, :id]}.should raise_error(Sequel::Error)
+  end
 
   it "should use :select option if given" do
     @c2.many_to_one :parent, :class => @c2, :key => :blah, :select=>[:id, :name]
@@ -265,6 +278,21 @@ describe Sequel::Model, "many_to_one" do
     d.values.should == {:id => 1, :parent_id => 8}
   end
   
+  it "should have the setter method respect composite keys" do
+    @c2.many_to_one :parent, :class => @c2, :key=>[:id, :parent_id], :primary_key=>[:parent_id, :id]
+
+    d = @c2.new(:id => 1, :parent_id=> 234)
+    d.parent = @c2.new(:id => 4, :parent_id=>52)
+    d.values.should == {:id => 52, :parent_id => 4}
+
+    d.parent = nil
+    d.values.should == {:id => nil, :parent_id => nil}
+
+    e = @c2.new(:id => 6677, :parent_id=>8)
+    d.parent = e
+    d.values.should == {:id => 8, :parent_id => 6677}
+  end
+  
   it "should not persist changes until saved" do
     @c2.many_to_one :parent, :class => @c2
 
@@ -520,13 +548,12 @@ describe Sequel::Model, "many_to_one" do
 end
 
 describe Sequel::Model, "one_to_many" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
 
     @c1 = Class.new(Sequel::Model(:attributes)) do
       unrestrict_primary_key
-      columns :id, :node_id
+      columns :id, :node_id, :y
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
@@ -535,7 +562,7 @@ describe Sequel::Model, "one_to_many" do
       
       def self.name; 'Node'; end
       def self.to_s; 'Node'; end
-      columns :id
+      columns :id, :x
     end
     @dataset = @c2.dataset
     
@@ -599,6 +626,19 @@ describe Sequel::Model, "one_to_many" do
     a.should be_a_kind_of(Sequel::Dataset)
     a.sql.should == 'SELECT * FROM attributes WHERE (attributes.nodeid = 1234)'
   end
+  
+  it "should support_composite keys" do
+    @c2.one_to_many :attributes, :class => @c1, :key =>[:node_id, :id], :primary_key=>[:id, :x]
+    @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 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)
+    proc{@c2.one_to_many :attributes, :class => @c1, :key=>[:node_id, :id], :primary_key=>:id}.should raise_error(Sequel::Error)
+    proc{@c2.one_to_many :attributes, :class => @c1, :key=>:id, :primary_key=>[:node_id, :id]}.should raise_error(Sequel::Error)
+    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
     @c2.one_to_many :attributes, :class => @c1
@@ -633,6 +673,23 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 5 WHERE (id = 2345)']
   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]
+    
+    n = @c2.load(:id => 1234, :x=>5)
+    a = @c1.load(:id => 2345)
+    a.should == n.add_attribute(a)
+    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id = 1234|y = 5), (node_id = 1234|y = 5) WHERE \(id = 2345\)/
+  end
+  
+  it "should have remove_ method respect composite keys" do
+    @c2.one_to_many :attributes, :class => @c1, :key =>[:node_id, :y], :primary_key=>[:id, :x]
+    
+    n = @c2.load(:id => 1234, :x=>5)
+    a = @c1.load(:id => 2345, :node_id=>1234, :y=>5)
+    a.should == n.remove_attribute(a)
+    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(id = 2345\)/
+  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
@@ -643,6 +700,15 @@ describe Sequel::Model, "one_to_many" do
     proc{n.remove_attribute(a)}.should raise_error(Sequel::Error)
   end
 
+  it "should not validate the associated object in add_ and remove_ if the :validate=>false option is used" do
+    @c2.one_to_many :attributes, :class => @c1, :validate=>false
+    n = @c2.new(:id => 1234)
+    a = @c1.new(:id => 2345)
+    def a.valid?; false; end
+    n.add_attribute(a).should == a
+    n.remove_attribute(a).should == a
+  end
+
   it "should raise an error if the model object doesn't have a valid primary key" do
     @c2.one_to_many :attributes, :class => @c1 
     a = @c2.new
@@ -914,6 +980,12 @@ describe Sequel::Model, "one_to_many" do
     @c2.new(:id => 1234, :xxx=>5).remove_all_attributes
     MODEL_DB.sqls.first.should == 'UPDATE attributes SET node_id = NULL WHERE (node_id = 5)'
   end
+  
+  it "should have the remove_all_ method respect composite keys" do
+    @c2.one_to_many :attributes, :class => @c1, :key=>[:node_id, :y], :primary_key=>[:id, :x]
+    @c2.new(:id => 1234, :x=>5).remove_all_attributes
+    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(\(node_id = 1234\) AND \(y = 5\)\)/
+  end
 
   it "remove_all should set the cached instance variable to []" do
     @c2.one_to_many :attributes, :class => @c1
@@ -929,7 +1001,7 @@ describe Sequel::Model, "one_to_many" do
     d = @c1.dataset
     def d.fetch_rows(s); end
     node.attributes.should == []
-    def attrib.save; self end
+    def attrib.save(*); self end
     node.add_attribute(attrib)
     node.associations[:attributes].should == [attrib]
     node.remove_all_attributes.should == [attrib]
@@ -951,7 +1023,7 @@ describe Sequel::Model, "one_to_many" do
     node = @c2.new(:id => 1234)
     node.attributes.should == []
     attrib.node.should == nil
-    def attrib.save; self end
+    def attrib.save(*); self end
     node.add_attribute(attrib)
     attrib.associations[:node].should == node 
     node.remove_all_attributes
@@ -1026,6 +1098,16 @@ describe Sequel::Model, "one_to_many" do
     @c2.new(:id => 621, :xxx=>5).attribute = attrib
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 5 WHERE (id = 3)',
       'UPDATE attributes SET node_id = NULL WHERE ((node_id = 5) AND (id != 3))']
+    end
+    
+  it "should have the setter method for the :one_to_one option respect composite keys" do
+    @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true, :key=>[:node_id, :y], :primary_key=>[:id, :x]
+    attrib = @c1.load(:id=>3, :y=>6)
+    d = @c1.dataset
+    def d.fetch_rows(s); yield({:id=>3, :y=>6}) end
+    @c2.load(:id => 1234, :x=>5).attribute = attrib
+    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id = 1234|y = 5), (node_id = 1234|y = 5) WHERE \(id = 3\)/
+    MODEL_DB.sqls.last.should =~ /UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(\(\(node_id = 1234\) AND \(y = 5\)\) AND \(id != 3\)\)/
   end
 
   it "should raise an error if the one_to_one getter would be the same as the association name" do
@@ -1215,7 +1297,7 @@ describe Sequel::Model, "many_to_many" do
       attr_accessor :yyy
       def self.name; 'Attribute'; end
       def self.to_s; 'Attribute'; end
-      columns :id
+      columns :id, :y
       def _refresh(ds)
         self.id = 1
         self
@@ -1228,7 +1310,7 @@ describe Sequel::Model, "many_to_many" do
       
       def self.name; 'Node'; end
       def self.to_s; 'Node'; end
-      columns :id
+      columns :id, :x
     end
     @dataset = @c2.dataset
 
@@ -1323,6 +1405,24 @@ describe Sequel::Model, "many_to_many" do
     @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))'
   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))'
+  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)
+    proc{@c2.many_to_many :attributes, :class => @c1, :left_key=>[:node_id, :id], :left_primary_key=>:id}.should raise_error(Sequel::Error)
+    proc{@c2.many_to_many :attributes, :class => @c1, :left_key=>:id, :left_primary_key=>[:node_id, :id]}.should raise_error(Sequel::Error)
+    proc{@c2.many_to_many :attributes, :class => @c1, :left_key=>[:node_id, :id, :x], :left_primary_key=>[:parent_id, :id]}.should raise_error(Sequel::Error)
+    
+    proc{@c2.many_to_many :attributes, :class => @c1, :right_primary_key=>[:node_id, :id]}.should raise_error(Sequel::Error)
+    proc{@c2.many_to_many :attributes, :class => @c1, :right_key=>[:node_id, :id], :right_primary_key=>:id}.should raise_error(Sequel::Error)
+    proc{@c2.many_to_many :attributes, :class => @c1, :right_key=>:id, :left_primary_key=>[:node_id, :id]}.should raise_error(Sequel::Error)
+    proc{@c2.many_to_many :attributes, :class => @c1, :right_key=>[:node_id, :id, :x], :right_primary_key=>[:parent_id, :id]}.should raise_error(Sequel::Error)
+  end
+  
   it "should support a select option" do
     @c2.many_to_many :attributes, :class => @c1, :select => :blah
 
@@ -1434,6 +1534,26 @@ describe Sequel::Model, "many_to_many" do
      'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (8, 5)'
     ].should(include(MODEL_DB.sqls.first))
   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)
+    a = @c1.load(:id => 2345, :y=>8)
+    a.should == n.add_attribute(a)
+    m = /INSERT INTO attributes_nodes \((\w+), (\w+), (\w+), (\w+)\) VALUES \((\d+), (\d+), (\d+), (\d+)\)/.match(MODEL_DB.sqls.first)
+    m.should_not == nil
+    map = {'l1'=>1234, 'l2'=>5, 'r1'=>2345, 'r2'=>8}
+    %w[l1 l2 r1 r2].each do |x|
+      v = false
+      4.times do |i| i += 1
+        if m[i] == x
+          m[i+4].should == map[x].to_s
+          v = true
+        end
+      end
+      v.should == true
+    end
+  end
 
   it "should have the remove_ 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
@@ -1443,6 +1563,14 @@ describe Sequel::Model, "many_to_many" do
     a.should == n.remove_attribute(a)
     MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE ((node_id = 5) AND (attribute_id = 8))'
   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]
+    n = @c2.load(:id => 1234, :x=>5)
+    a = @c1.load(:id => 2345, :y=>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
 
   it "should raise an error if the model object doesn't have a valid primary key" do
     @c2.many_to_many :attributes, :class => @c1 
@@ -1455,7 +1583,7 @@ describe Sequel::Model, "many_to_many" do
     proc{a.remove_all_attributes}.should raise_error(Sequel::Error)
   end
   
-  it "should save the associated object first if passed a new model object" do
+  it "should save the associated object first in add_ if passed a new model object" do
     @c2.many_to_many :attributes, :class => @c1 
     n = @c1.new
     a = @c2.load(:id=>123)
@@ -1464,6 +1592,32 @@ describe Sequel::Model, "many_to_many" do
     n.new?.should == false
   end
 
+  it "should raise a ValidationFailed in add_ if the associated object is new and invalid" do
+    @c2.many_to_many :attributes, :class => @c1 
+    n = @c1.new
+    a = @c2.load(:id=>123)
+    def n.valid?; false; end
+    proc{a.add_attribute(n)}.should raise_error(Sequel::ValidationFailed)
+  end
+
+  it "should raise an Error in add_ if the associated object is new and invalid and raise_on_save_failure is false" do
+    @c2.many_to_many :attributes, :class => @c1 
+    n = @c1.new
+    n.raise_on_save_failure = false
+    a = @c2.load(:id=>123)
+    def n.valid?; false; end
+    proc{a.add_attribute(n)}.should raise_error(Sequel::Error)
+  end
+
+  it "should not attempt to validate the associated object in add_ if the :validate=>false option is used" do
+    @c2.many_to_many :attributes, :class => @c1, :validate=>false
+    n = @c1.new
+    a = @c2.load(:id=>123)
+    def n.valid?; false; end
+    a.add_attribute(n)
+    n.new?.should == false
+  end
+
   it "should raise an error if trying to remove a model object that doesn't have a valid primary key" do
     @c2.many_to_many :attributes, :class => @c1 
     n = @c1.new
@@ -1597,6 +1751,12 @@ describe Sequel::Model, "many_to_many" do
     @c2.new(:id => 1234, :xxx=>5).remove_all_attributes
     MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE (node_id = 5)'
   end
+  
+  it "should have the remove_all_ method respect composite keys" do
+    @c2.many_to_many :attributes, :class => @c1, :left_primary_key=>[:id, :x], :left_key=>[:l1, :l2]
+    @c2.load(:id => 1234, :x=>5).remove_all_attributes
+    MODEL_DB.sqls.should == ['DELETE FROM attributes_nodes WHERE ((l1 = 1234) AND (l2 = 5))']
+  end
 
   it "remove_all should set the cached instance variable to []" do
     @c2.many_to_many :attributes, :class => @c1