sequel 4.21.0 → 4.22.0

data/spec/extensions/auto_validations_spec.rb

@@ -11,7 +11,7 @@ describe "Sequel::Plugins::AutoValidations" do
        [:name, {:primary_key=>false, :type=>:string, :allow_null=>false, :max_length=>50}],
        [:num, {:primary_key=>false, :type=>:integer, :allow_null=>true}],
        [:d, {:primary_key=>false, :type=>:date, :allow_null=>false}],
-       [:nnd, {:primary_key=>false, :type=>:string, :allow_null=>false, :ruby_default=>'nnd'}]]
+       [:nnd, {:primary_key=>false, :type=>:string, :allow_null=>false, :default=>'nnd'}]]
     end
     def db.supports_index_parsing?() true end
     def db.indexes(t, *)

data/spec/extensions/blacklist_security_spec.rb

@@ -16,8 +16,8 @@ describe Sequel::Model, "#(set|update)_except" do
 
   it "should raise errors if not all hash fields can be set and strict_param_setting is true" do
     @c.strict_param_setting = true
-    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3, :id=>4}, :x, :y)}.should raise_error(Sequel::Error)
-    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3}, :x, :y)}.should raise_error(Sequel::Error)
+    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3, :id=>4}, :x, :y)}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3}, :x, :y)}.should raise_error(Sequel::MassAssignmentRestriction)
     (o = @c.new).set_except({:z => 3}, :x, :y)
     o.values.should == {:z=>3}
   end

data/spec/extensions/csv_serializer_spec.rb

@@ -0,0 +1,173 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::CsvSerializer" do
+  before do
+    artist = @Artist = Class.new(Sequel::Model(:artists))
+    @Artist.class_eval do
+      def self.name; 'Artist' end
+      unrestrict_primary_key
+      plugin :csv_serializer
+      columns :id, :name
+      def_column_accessor :id, :name
+      @db_schema = {:id=>{:type=>:integer}}
+    end
+    @Album = Class.new(Sequel::Model(:albums))
+    @Album.class_eval do
+      def self.name; 'Album' end
+      unrestrict_primary_key
+      attr_accessor :blah
+      plugin :csv_serializer
+      columns :id, :name, :artist_id
+      def_column_accessor :id, :name, :artist_id
+      @db_schema = {:id=>{:type=>:integer}, :artist_id=>{:type=>:integer}}
+      many_to_one :artist, :class=>artist
+    end
+    @artist = @Artist.load(:id=>2, :name=>'YJM')
+    @artist.associations[:albums] = []
+    @album = @Album.load(:id=>1, :name=>'RF')
+    @album.artist = @artist
+    @album.blah = 'Blah'
+  end
+
+  it "should round trip successfully" do
+    @Artist.from_csv(@artist.to_csv).should == @artist
+    @Album.from_csv(@album.to_csv).should == @album
+  end
+
+  it "should handle ruby objects in values" do
+    @Artist.send(:define_method, :name=) do |v|
+      super(Date.parse(v))
+    end
+    a = @Artist.load(:name=>Date.today)
+    opts = {:columns=>[:name]}
+    @Artist.from_csv(a.to_csv(opts), opts).should == a
+  end
+
+  it "should handle the :only option" do
+    @Artist.from_csv(@artist.to_csv(:only=>:name), :only=>:name).should == @Artist.load(:name=>@artist.name)
+    @Album.from_csv(@album.to_csv(:only=>[:id, :name]), :only=>[:id, :name]).should == @Album.load(:id=>@album.id, :name=>@album.name)
+  end
+
+  it "should handle the :except option" do
+    @Artist.from_csv(@artist.to_csv(:except=>:id), :except=>:id).should == @Artist.load(:name=>@artist.name)
+    @Album.from_csv(@album.to_csv(:except=>[:id, :artist_id]), :except=>[:id, :artist_id]).should == @Album.load(:name=>@album.name)
+  end
+
+  it "should handle the :include option for arbitrary attributes" do
+    @Album.from_csv(@album.to_csv(:include=>:blah), :include=>:blah).blah.should == @album.blah
+  end
+
+  it "should handle multiple inclusions using an array for the :include option" do
+    a = @Album.from_csv(@album.to_csv(:include=>[:blah]), :include=>:blah)
+    a.blah.should == @album.blah
+  end
+
+  it "#from_csv should set column values" do
+    @artist.from_csv('AS', :only=>:name)
+    @artist.name.should == 'AS'
+    @artist.id.should == 2
+
+    @artist.from_csv('1', :only=>:id)
+    @artist.name.should == 'AS'
+    @artist.id.should == 1
+  end
+
+  it ".array_from_csv should support :headers to specify headers" do
+    @albums = @Album.array_from_csv("AS,2\nDF,3", :headers=>['name', 'artist_id'])
+    @albums.map(&:name).should == %w'AS DF'
+    @albums.map(&:artist_id).should == [2, 3]
+
+    @albums = @Album.array_from_csv("2,AS\n3,DF", :headers=>[nil, 'name'])
+    @albums.map(&:name).should == %w'AS DF'
+    @albums.map(&:artist_id).should == [nil, nil]
+  end
+
+  it ".from_csv should support :headers to specify headers" do
+    @album = @Album.from_csv('AS,2', :headers=>['name', 'artist_id'])
+    @album.name.should == 'AS'
+    @album.artist_id.should == 2
+
+    @album = @Album.from_csv('2,AS', :headers=>[nil, 'name'])
+    @album.name.should == 'AS'
+    @album.artist_id.should == nil
+  end
+
+  it "#from_csv should support :headers to specify headers" do
+    @album.from_csv('AS,2', :headers=>['name'])
+    @album.name.should == 'AS'
+    @album.artist_id.should == 2
+
+    @album.from_csv('2,AS', :headers=>[nil, 'name'])
+    @album.name.should == 'AS'
+    @album.artist_id.should == 2
+  end
+
+  it "should support a to_csv class and dataset method" do
+    @Album.dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
+    @Artist.dataset._fetch = {:id=>2, :name=>'YJM'}
+    @Album.array_from_csv(@Album.to_csv).should == [@album]
+    @Album.array_from_csv(@Album.dataset.to_csv(:only=>:name), :only=>:name).should == [@Album.load(:name=>@album.name)]
+  end
+
+  it "should have dataset to_csv method respect :array option" do
+    a = @Album.new(:id=>1, :name=>'RF', :artist_id=>3)
+    @Album.array_from_csv(@Album.to_csv(:array=>[a])).should == [a]
+  end
+
+  it "#to_csv should respect class options" do
+    @Album = Class.new(Sequel::Model(:albums))
+    artist = @Artist
+    @Album.class_eval do
+      attr_accessor :blah
+      plugin :csv_serializer, :except => :id, :write_headers=>true, :include=>:blah
+      columns :id, :name, :artist_id
+      many_to_one :artist, :class=>artist
+    end
+    @album = @Album.load(:id=>2, :name=>'JK')
+    @album.artist = @artist
+    @album.blah = 'Gak'
+
+    @album.to_csv.should == "name,artist_id,blah\nJK,2,Gak\n"
+    @album.to_csv(:write_headers=>false).should == "JK,2,Gak\n"
+    @album.to_csv(:headers=>[:name]).should == "name\nJK\n"
+    @album.to_csv(:headers=>[:name, :id]).should == "name,id\nJK,2\n"
+    @album.to_csv(:only=>[:name]).should == "name,blah\nJK,Gak\n"
+    @album.to_csv(:except=>nil).should == "id,name,artist_id,blah\n2,JK,2,Gak\n"
+    @album.to_csv(:except=>[:blah]).should == "id,name,artist_id\n2,JK,2\n"
+  end
+
+  it "should store the default options in csv_serializer_opts" do
+    @Album.csv_serializer_opts.should == {}
+    c = Class.new(@Album)
+    @Album.csv_serializer_opts[:include] = :blah
+    c.plugin :csv_serializer, :naked=>false
+    c.csv_serializer_opts.should == {:naked=>false}
+    @Album.csv_serializer_opts.should == {:include=>:blah}
+  end
+
+  it "should work correctly when subclassing" do
+    @Artist2 = Class.new(@Artist)
+    @Artist2.plugin :csv_serializer, :only=>:name
+    @Artist3 = Class.new(@Artist2)
+    @Artist3.from_csv(@Artist3.load(:id=>2, :name=>'YYY').to_csv).should == @Artist3.load(:name=>'YYY')
+  end
+
+  it "should raise an error if attempting to set a restricted column and :all_columns is not used" do
+    @Artist.restrict_primary_key
+    proc{@Artist.from_csv(@artist.to_csv)}.should raise_error(Sequel::MassAssignmentRestriction)
+  end
+
+  it "should use a dataset's selected columns" do
+    columns = [:id]
+    ds = @Artist.select(*columns).limit(1)
+    ds.instance_variable_set(:@columns, columns)
+    ds._fetch = [:id => 10]
+    ds.to_csv(:write_headers => true).should == "id\n10\n"
+  end
+
+  it "should pass all the examples from the documentation" do
+    @album.to_csv(:write_headers=>true).should == "id,name,artist_id\n1,RF,2\n"
+    @album.to_csv(:only=>:name).should == "RF\n"
+    @album.to_csv(:except=>[:id, :artist_id]).should == "RF\n"
+  end
+end

data/spec/extensions/json_serializer_spec.rb

@@ -157,7 +157,7 @@ describe "Sequel::Plugins::JsonSerializer" do
 
   it "should raise an exception for json keys that aren't associations, columns, or setter methods" do
     Album.send(:undef_method, :blah=)
-    proc{Album.from_json(@album.to_json(:include=>:blah))}.should raise_error(Sequel::Error)
+    proc{Album.from_json(@album.to_json(:include=>:blah))}.should raise_error(Sequel::MassAssignmentRestriction)
   end
 
   it "should support a to_json class and dataset method" do
@@ -269,7 +269,7 @@ describe "Sequel::Plugins::JsonSerializer" do
 
   it "should raise an error if attempting to set a restricted column and :all_columns is not used" do
     Artist.restrict_primary_key
-    proc{Artist.from_json(@artist.to_json)}.should raise_error(Sequel::Error)
+    proc{Artist.from_json(@artist.to_json)}.should raise_error(Sequel::MassAssignmentRestriction)
   end
 
   it "should raise an error if an unsupported association is passed in the :associations option" do

data/spec/extensions/nested_attributes_spec.rb

@@ -433,7 +433,7 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     a.associations[:artist] = ar
     @Album.nested_attributes :artist
-    proc{a.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})}.should raise_error(Sequel::Error)
+    proc{a.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})}.should raise_error(Sequel::MassAssignmentRestriction)
     @Album.nested_attributes :artist, :destroy=>true
     proc{a.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})}.should_not raise_error
   end
@@ -443,7 +443,7 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     a.associations[:artist] = ar
     @Album.nested_attributes :artist
-    proc{a.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})}.should raise_error(Sequel::Error)
+    proc{a.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})}.should raise_error(Sequel::MassAssignmentRestriction)
     @Album.nested_attributes :artist, :remove=>true
     proc{a.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})}.should_not raise_error
   end
@@ -545,7 +545,7 @@ describe "NestedAttributes plugin" do
   
   it "should not accept nested attributes unless explicitly specified" do
     @Artist.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at
-    proc{@Artist.create({:name=>'Ar', :tags_attributes=>[{:name=>'T'}]})}.should raise_error(Sequel::Error)
+    proc{@Artist.create({:name=>'Ar', :tags_attributes=>[{:name=>'T'}]})}.should raise_error(Sequel::MassAssignmentRestriction)
     @db.sqls.should == []
   end
   
@@ -646,8 +646,8 @@ describe "NestedAttributes plugin" do
       "UPDATE tags SET name = 'T2' WHERE (id = 30)",
       "INSERT INTO tags (name) VALUES ('T3')",
       ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
-    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
-    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
+    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.should raise_error(Sequel::MassAssignmentRestriction)
   end
 
   it "should accept a proc for the :fields option that accepts the associated object and returns an array of fields" do
@@ -664,8 +664,8 @@ describe "NestedAttributes plugin" do
       "UPDATE tags SET name = 'T2' WHERE (id = 30)",
       "INSERT INTO tags (name) VALUES ('T3')",
       ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
-    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
-    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
+    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.should raise_error(Sequel::MassAssignmentRestriction)
   end
 
   it "should allow per-call options via the set_nested_attributes method" do
@@ -682,8 +682,8 @@ describe "NestedAttributes plugin" do
       "UPDATE tags SET name = 'T2' WHERE (id = 30)",
       "INSERT INTO tags (name) VALUES ('T3')",
       ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
-    proc{al.set_nested_attributes(:tags, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::Error)
-    proc{al.set_nested_attributes(:tags, [{:name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::Error)
+    proc{al.set_nested_attributes(:tags, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{al.set_nested_attributes(:tags, [{:name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::MassAssignmentRestriction)
   end
 
   it "should have set_nested_attributes method raise error if called with a bad association" do

data/spec/extensions/pg_array_spec.rb

@@ -387,4 +387,9 @@ describe "pg_array extension" do
     @db.schema_type_class(:banana_array).should == Sequel::Postgres::PGArray
     @db.schema_type_class(:integer).should == Integer
   end
+
+  it "should convert ruby arrays to pg arrays as :default option values" do
+    @db.create_table('a'){column :b, 'c[]', :default=>[]; Integer :d}
+    @db.sqls.should == ['CREATE TABLE a (b c[] DEFAULT (ARRAY[]::c[]), d integer)']
+  end
 end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -77,6 +77,13 @@ describe Sequel::Model, "single table inheritance plugin" do
     DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTest')", "SELECT * FROM sti_tests WHERE (id = 10) LIMIT 1", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "SELECT * FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub1')) AND (id = 10)) LIMIT 1", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub2')", "SELECT * FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub2')) AND (id = 10)) LIMIT 1"]
   end
 
+  it "should destroy the model correctly" do
+    StiTest.load(:id=>1).destroy
+    StiTestSub1.load(:id=>1).destroy
+    StiTestSub2.load(:id=>1).destroy
+    DB.sqls.should == ["DELETE FROM sti_tests WHERE id = 1", "DELETE FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub1')) AND (id = 1))", "DELETE FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub2')) AND (id = 1))"]
+  end
+
   it "should handle validations on the type column field" do
     o = StiTestSub1.new
     def o.validate
@@ -200,6 +207,7 @@ describe Sequel::Model, "single table inheritance plugin" do
       StiTest2.dataset.row_proc.call(:kind=>0).should be_a_instance_of(StiTest2)
       StiTest2.dataset.row_proc.call(:kind=>1).should be_a_instance_of(StiTest3)
       StiTest2.dataset.row_proc.call(:kind=>2).should be_a_instance_of(StiTest4)
+      StiTest3.sti_model_map.should == StiTest2.sti_model_map
 
       StiTest2.create.kind.should == 4
       StiTest3.create.kind.should == 5
@@ -264,6 +272,19 @@ describe Sequel::Model, "single table inheritance plugin" do
        "SELECT * FROM sti_test2s WHERE (sti_test2s.kind IN (1, 0))"].should include(StiTest3.dataset.sql)
     end
 
+    it "should destroy the model correctly" do
+      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{'sti3'=>'StiTest3', 'sti3b'=>'StiTest3', 'sti4'=>'StiTest4'}
+      class ::StiTest3 < ::StiTest2; end
+      class ::StiTest4 < ::StiTest2; end
+      StiTest2.load(:id=>1).destroy
+      StiTest3.load(:id=>1).destroy
+      sqls = DB.sqls
+      sqls.shift.should == "DELETE FROM sti_test2s WHERE id = 1"
+      ["DELETE FROM sti_test2s WHERE ((sti_test2s.kind IN ('sti3', 'sti3b')) AND (id = 1))",
+       "DELETE FROM sti_test2s WHERE ((sti_test2s.kind IN ('sti3b', 'sti3')) AND (id = 1))"].should include(sqls.pop)
+      sqls.should == []
+    end
+
     it "should honor a :key_chooser" do
       StiTest2.plugin :single_table_inheritance, :kind, :key_chooser => proc{|inst| inst.model.to_s.downcase }
       class ::StiTest3 < ::StiTest2; end

data/spec/extensions/touch_spec.rb

@@ -171,7 +171,7 @@ describe "Touch plugin" do
 
   specify "should raise an error if given a column argument in touch that doesn't exist" do
     @Artist.plugin :touch
-    proc{@a.touch(:x)}.should raise_error(Sequel::Error)
+    proc{@a.touch(:x)}.should raise_error(Sequel::MassAssignmentRestriction)
   end
 
   specify "should raise an Error when a nonexistent association is given" do

data/spec/extensions/tree_spec.rb

@@ -23,6 +23,10 @@ describe Sequel::Model, "tree plugin" do
     @c.associations.sort_by{|x| x.to_s}.should == [:children, :parent]
   end
   
+  it "should define the correct reciprocals" do
+    @c.associations.sort_by{|x| x.to_s}.map{|x| @c.association_reflection(x).reciprocal}.should == [:parent, :children]
+  end
+  
   it "should define the correct associations when giving options" do
     klass(:children=>{:name=>:cs}, :parent=>{:name=>:p}).associations.sort_by{|x| x.to_s}.should == [:cs, :p]
   end

data/spec/extensions/xml_serializer_spec.rb

@@ -149,7 +149,7 @@ describe "Sequel::Plugins::XmlSerializer" do
 
   it "should raise an exception for xml tags that aren't associations, columns, or setter methods" do
     Album.send(:undef_method, :blah=)
-    proc{Album.from_xml(@album.to_xml(:include=>:blah))}.should raise_error(Sequel::Error)
+    proc{Album.from_xml(@album.to_xml(:include=>:blah))}.should raise_error(Sequel::MassAssignmentRestriction)
   end
 
   it "should support a to_xml class and dataset method" do
@@ -184,7 +184,7 @@ describe "Sequel::Plugins::XmlSerializer" do
 
   it "should raise an error if attempting to set a restricted column and :all_columns is not used" do
     Artist.restrict_primary_key
-    proc{Artist.from_xml(@artist.to_xml)}.should raise_error(Sequel::Error)
+    proc{Artist.from_xml(@artist.to_xml)}.should raise_error(Sequel::MassAssignmentRestriction)
   end
 
   it "should raise an error if an unsupported association is passed in the :associations option" do
@@ -193,7 +193,7 @@ describe "Sequel::Plugins::XmlSerializer" do
   end
 
   it "should raise an error if using from_xml and XML represents an array" do
-    proc{Artist.from_xml(Artist.to_xml(:array=>[@artist]))}.should raise_error(Sequel::Error)
+    proc{Artist.from_xml(Artist.to_xml(:array=>[@artist]))}.should raise_error(Sequel::MassAssignmentRestriction)
   end
 
   it "should raise an error if using array_from_xml and XML does not represent an array" do

data/spec/integration/prepared_statement_test.rb

@@ -355,7 +355,7 @@ describe "Bound Argument Types" do
     @ds.filter(:s=>:$x).prepare(:first, :ps_string).call(:x=>@vs[:s])[:s].should == @vs[:s]
   end
 
-  cspecify "should handle boolean type", [:do, :sqlite], [:odbc, :mssql], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
+  cspecify "should handle boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     @ds.filter(:b=>:$x).prepare(:first, :ps_string).call(:x=>@vs[:b])[:b].should == @vs[:b]
   end
 end

data/spec/integration/schema_test.rb

@@ -113,6 +113,13 @@ describe "Database schema parser" do
     DB.schema(:items).first.last[:ruby_default].should == 'blah'
   end
 
+  specify "should make :default nil for a NULL default" do
+    DB.create_table!(:items){Integer :number}
+    DB.schema(:items).first.last[:default].should == nil
+    DB.create_table!(:items){Integer :number, :default=>0}
+    DB.schema(:items).first.last[:default].should_not == nil
+  end
+
   specify "should parse current timestamp defaults from the schema properly" do
     DB.create_table!(:items){Time :a, :default=>Sequel::CURRENT_TIMESTAMP}
     DB.schema(:items).first.last[:ruby_default].should == Sequel::CURRENT_TIMESTAMP

data/spec/integration/type_test.rb

@@ -113,7 +113,7 @@ describe "Supported types" do
     ds.first[:name].should be_a_kind_of(::Sequel::SQL::Blob)
   end
   
-  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], [:odbc, :mssql], :oracle do
+  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     ds = create_items_table_with_column(:number, TrueClass)
     ds.insert(:number => true)
     ds.all.should == [{:number=>true}]
@@ -122,7 +122,7 @@ describe "Supported types" do
     ds.all.should == [{:number=>true}]
   end
   
-  cspecify "should support generic boolean type with defaults", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], [:odbc, :mssql], :oracle do
+  cspecify "should support generic boolean type with defaults", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     ds = create_items_table_with_column(:number, TrueClass, :default=>true)
     ds.insert
     ds.all.should == [{:number=>true}]

data/spec/model/associations_spec.rb

@@ -672,20 +672,33 @@ describe Sequel::Model, "many_to_one" do
   end
 
   it "should raise error and not call internal add or remove method if before callback returns false, even if raise_on_save_failure is false" do
-    # The reason for this is that assignment in ruby always returns the argument instead of the result
-    # of the method, so we can't return nil to signal that the association callback prevented the modification
     p = @c2.new
     c = @c2.load(:id=>123)
     p.raise_on_save_failure = false
     @c2.many_to_one :parent, :class => @c2, :before_set=>:bs
     def p.bs(x) false end
     p.should_not_receive(:_parent=)
-    proc{p.parent = c}.should raise_error(Sequel::Error)
+    proc{p.parent = c}.should raise_error(Sequel::HookFailed)
+    
+    p.parent.should == nil
+    p.associations[:parent] = c
+    p.parent.should == c
+    proc{p.parent = nil}.should raise_error(Sequel::HookFailed)
+  end
+
+  it "should raise error and not call internal add or remove method if before callback calls cancel_action, even if raise_on_save_failure is false" do
+    p = @c2.new
+    c = @c2.load(:id=>123)
+    p.raise_on_save_failure = false
+    @c2.many_to_one :parent, :class => @c2, :before_set=>:bs
+    def p.bs(x) cancel_action end
+    p.should_not_receive(:_parent=)
+    proc{p.parent = c}.should raise_error(Sequel::HookFailed)
     
     p.parent.should == nil
     p.associations[:parent] = c
     p.parent.should == c
-    proc{p.parent = nil}.should raise_error(Sequel::Error)
+    proc{p.parent = nil}.should raise_error(Sequel::HookFailed)
   end
 
   it "should raise an error if a callback is not a proc or symbol" do
@@ -1095,20 +1108,33 @@ describe Sequel::Model, "one_to_one" do
   end
 
   it "should raise error and not call internal add or remove method if before callback returns false, even if raise_on_save_failure is false" do
-    # The reason for this is that assignment in ruby always returns the argument instead of the result
-    # of the method, so we can't return nil to signal that the association callback prevented the modification
-    p = @c2.new
+    p = @c2.load(:id=>321)
     c = @c2.load(:id=>123)
     p.raise_on_save_failure = false
     @c2.one_to_one :parent, :class => @c2, :before_set=>:bs
     def p.bs(x) false end
     p.should_not_receive(:_parent=)
-    proc{p.parent = c}.should raise_error(Sequel::Error)
+    proc{p.parent = c}.should raise_error(Sequel::HookFailed)
     
-    p.parent.should == nil
+    p.associations[:parent].should == nil
     p.associations[:parent] = c
     p.parent.should == c
-    proc{p.parent = nil}.should raise_error(Sequel::Error)
+    proc{p.parent = nil}.should raise_error(Sequel::HookFailed)
+  end
+
+  it "should raise error and not call internal add or remove method if before callback returns false, even if raise_on_save_failure is false" do
+    p = @c2.load(:id=>321)
+    c = @c2.load(:id=>123)
+    p.raise_on_save_failure = false
+    @c2.one_to_one :parent, :class => @c2, :before_set=>:bs
+    def p.bs(x) cancel_action end
+    p.should_not_receive(:_parent=)
+    proc{p.parent = c}.should raise_error(Sequel::HookFailed)
+    
+    p.associations[:parent].should == nil
+    p.associations[:parent] = c
+    p.parent.should == c
+    proc{p.parent = nil}.should raise_error(Sequel::HookFailed)
   end
 
   it "should not validate the associated object in setter if the :validate=>false option is used" do
@@ -1837,11 +1863,11 @@ describe Sequel::Model, "one_to_many" do
     p.should_not_receive(:_add_attribute)
     p.should_not_receive(:_remove_attribute)
     p.associations[:attributes] = []
-    proc{p.add_attribute(c)}.should raise_error(Sequel::Error)
+    proc{p.add_attribute(c)}.should raise_error(Sequel::HookFailed)
     p.attributes.should == []
     p.associations[:attributes] = [c]
     p.should_receive(:br).once.with(c).and_return(false)
-    proc{p.remove_attribute(c)}.should raise_error(Sequel::Error)
+    proc{p.remove_attribute(c)}.should raise_error(Sequel::HookFailed)
     p.attributes.should == [c]
   end
 
@@ -1861,6 +1887,39 @@ describe Sequel::Model, "one_to_many" do
     p.remove_attribute(c).should == nil
     p.attributes.should == [c]
   end
+
+  it "should raise error and not call internal add or remove method if before callback calls cancel_action if raise_on_save_failure is true" do
+    p = @c2.load(:id=>10)
+    c = @c1.load(:id=>123)
+    @c2.one_to_many :attributes, :class => @c1, :before_add=>:ba, :before_remove=>:br
+    def p.ba(o); cancel_action; end
+    p.should_not_receive(:_add_attribute)
+    p.should_not_receive(:_remove_attribute)
+    p.associations[:attributes] = []
+    proc{p.add_attribute(c)}.should raise_error(Sequel::HookFailed)
+    p.attributes.should == []
+    p.associations[:attributes] = [c]
+    def p.br(o); cancel_action; end
+    proc{p.remove_attribute(c)}.should raise_error(Sequel::HookFailed)
+    p.attributes.should == [c]
+  end
+
+  it "should return nil and not call internal add or remove method if before callback calls cancel_action if raise_on_save_failure is false" do
+    p = @c2.load(:id=>10)
+    c = @c1.load(:id=>123)
+    p.raise_on_save_failure = false
+    @c2.one_to_many :attributes, :class => @c1, :before_add=>:ba, :before_remove=>:br
+    def p.ba(o); cancel_action; end
+    p.should_not_receive(:_add_attribute)
+    p.should_not_receive(:_remove_attribute)
+    p.associations[:attributes] = []
+    p.add_attribute(c).should == nil
+    p.attributes.should == []
+    p.associations[:attributes] = [c]
+    def p.br(o); cancel_action; end
+    p.remove_attribute(c).should == nil
+    p.attributes.should == [c]
+  end
 end
 
 describe Sequel::Model, "many_to_many" do
@@ -2642,11 +2701,11 @@ describe Sequel::Model, "many_to_many" do
     p.should_not_receive(:_remove_attribute)
     p.associations[:attributes] = []
     p.raise_on_save_failure = true
-    proc{p.add_attribute(c)}.should raise_error(Sequel::Error)
+    proc{p.add_attribute(c)}.should raise_error(Sequel::HookFailed)
     p.attributes.should == []
     p.associations[:attributes] = [c]
     p.should_receive(:br).once.with(c).and_return(false)
-    proc{p.remove_attribute(c)}.should raise_error(Sequel::Error)
+    proc{p.remove_attribute(c)}.should raise_error(Sequel::HookFailed)
     p.attributes.should == [c]
   end
 
@@ -2667,6 +2726,41 @@ describe Sequel::Model, "many_to_many" do
     p.attributes.should == [c]
   end
 
+  it "should raise error and not call internal add or remove method if before callback calls cancel_action if raise_on_save_failure is true" do
+    p = @c2.load(:id=>10)
+    c = @c1.load(:id=>123)
+    @c2.many_to_many :attributes, :class => @c1, :before_add=>:ba, :before_remove=>:br
+    def p.ba(o) cancel_action end
+    p.should_receive(:ba).once.with(c).and_return(false)
+    p.should_not_receive(:_add_attribute)
+    p.should_not_receive(:_remove_attribute)
+    p.associations[:attributes] = []
+    p.raise_on_save_failure = true
+    proc{p.add_attribute(c)}.should raise_error(Sequel::HookFailed)
+    p.attributes.should == []
+    p.associations[:attributes] = [c]
+    def p.br(o) cancel_action end
+    proc{p.remove_attribute(c)}.should raise_error(Sequel::HookFailed)
+    p.attributes.should == [c]
+  end
+
+  it "should return nil and not call internal add or remove method if before callback calls cancel_action if raise_on_save_failure is false" do
+    p = @c2.load(:id=>10)
+    c = @c1.load(:id=>123)
+    p.raise_on_save_failure = false
+    @c2.many_to_many :attributes, :class => @c1, :before_add=>:ba, :before_remove=>:br
+    def p.ba(o) cancel_action end
+    p.should_not_receive(:_add_attribute)
+    p.should_not_receive(:_remove_attribute)
+    p.associations[:attributes] = []
+    p.add_attribute(c).should == nil
+    p.attributes.should == []
+    p.associations[:attributes] = [c]
+    def p.br(o) cancel_action end
+    p.remove_attribute(c).should == nil
+    p.attributes.should == [c]
+  end
+
   it "should support a :uniq option that removes duplicates from the association" do
     @c2.many_to_many :attributes, :class => @c1, :uniq=>true
     @c1.dataset._fetch = [{:id=>20}, {:id=>30}, {:id=>20}, {:id=>30}]