sequel 2.8.0 → 2.9.0

data/spec/adapters/sqlite_spec.rb

@@ -248,6 +248,20 @@ context "An SQLite dataset" do
   end
 end
 
+context "An SQLite numeric column" do
+  specify "should handle and return BigDecimal values" do
+    SQLITE_DB.create_table!(:d){numeric :d}
+    d = SQLITE_DB[:d]
+    d.insert(:d=>BigDecimal.new('80.0'))
+    d.insert(:d=>BigDecimal.new('NaN'))
+    d.insert(:d=>BigDecimal.new('Infinity'))
+    d.insert(:d=>BigDecimal.new('-Infinity'))
+    ds = d.all
+    ds.shift.should == {:d=>BigDecimal.new('80.0')}
+    ds.map{|x| x[:d].to_s}.should == %w'NaN Infinity -Infinity'
+  end
+end
+
 context "An SQLite dataset AS clause" do
   specify "should use a string literal for :col___alias" do
     SQLITE_DB.literal(:c___a).should == "c AS 'a'"
@@ -421,7 +435,27 @@ context "A SQLite database" do
     @db[:test2] << {:name => 'mmm'}
     @db[:test2].first.should == {:name => 'mmm'}
   end
-  
+
+  specify "should keep column attributes when dropping a column" do
+    @db.create_table! :test3 do
+      primary_key :id
+      text :name
+      integer :value
+    end
+
+    # This lame set of additions and deletions are to test that the primary keys
+    # don't get messed up when we recreate the database.
+    @db[:test3] << { :name => "foo", :value => 1}
+    @db[:test3] << { :name => "foo", :value => 2}
+    @db[:test3] << { :name => "foo", :value => 3}
+    @db[:test3].filter(:id => 2).delete
+    
+    @db.drop_column :test3, :value
+
+    @db['PRAGMA table_info(?)', :test3][:id][:pk].to_i.should == 1
+    @db[:test3].select(:id).all.should == [{:id => 1}, {:id => 3}]
+  end
+
   specify "should not support rename_column operations" do
     proc {@db.rename_column :test2, :value, :zyx}.should raise_error(Sequel::Error)
   end
@@ -435,7 +469,8 @@ context "A SQLite database" do
     @db.add_index :test2, [:name, :value]
   end
   
-  specify "should not support drop_index" do
-    proc {@db.drop_index :test2, :value}.should raise_error(Sequel::Error)
+  specify "should support drop_index" do
+    @db.add_index :test2, :value, :unique => true
+    @db.drop_index :test2, :value
   end
 end  

data/spec/integration/dataset_test.rb

@@ -81,3 +81,54 @@ describe "Simple Dataset operations in transactions" do
     end
   end
 end
+
+describe "Dataset UNION, EXCEPT, and INTERSECT" do
+  before do
+    INTEGRATION_DB.create_table!(:i1){integer :number}
+    INTEGRATION_DB.create_table!(:i2){integer :number}
+    INTEGRATION_DB.create_table!(:i3){integer :number}
+    @ds1 = INTEGRATION_DB[:i1]
+    @ds1.insert(:number=>10)
+    @ds1.insert(:number=>20)
+    @ds2 = INTEGRATION_DB[:i2]
+    @ds2.insert(:number=>10)
+    @ds2.insert(:number=>30)
+    @ds3 = INTEGRATION_DB[:i3]
+    @ds3.insert(:number=>10)
+    @ds3.insert(:number=>40)
+    clear_sqls
+  end
+  
+  specify "should give the correct results for simple UNION, EXCEPT, and INTERSECT" do
+    @ds1.union(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30'
+    unless @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
+      @ds1.except(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'20'
+      @ds1.intersect(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'10'
+    end
+  end
+  
+  specify "should give the correct results for compound UNION, EXCEPT, and INTERSECT" do
+    @ds1.union(@ds2).union(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30 40'
+    @ds1.union(@ds2.union(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30 40'
+    unless @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
+      @ds1.union(@ds2).except(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'20 30'
+      @ds1.union(@ds2.except(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30'
+      @ds1.union(@ds2).intersect(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10 '
+      @ds1.union(@ds2.intersect(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10 20'
+      
+      @ds1.except(@ds2).union(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 40'
+      @ds1.except(@ds2.union(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'20'
+      @ds1.except(@ds2).except(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'20'
+      @ds1.except(@ds2.except(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10 20'
+      @ds1.except(@ds2).intersect(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w''
+      @ds1.except(@ds2.intersect(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'20'
+      
+      @ds1.intersect(@ds2).union(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10 40'
+      @ds1.intersect(@ds2.union(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10'
+      @ds1.intersect(@ds2).except(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w''
+      @ds1.intersect(@ds2.except(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w''
+      @ds1.intersect(@ds2).intersect(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10'
+      @ds1.intersect(@ds2.intersect(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10'
+    end
+  end
+end

data/spec/integration/schema_test.rb

@@ -25,6 +25,10 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items, :reload=>true).should == INTEGRATION_DB.schema(nil, :reload=>true)[:items]
   end
 
+  specify "should raise an error when the table doesn't exist" do
+    proc{INTEGRATION_DB.schema(:no_table)}.should raise_error(Sequel::Error)
+  end
+
   specify "should return the schema correctly" do
     INTEGRATION_DB.create_table!(:items){integer :number}
     schema = INTEGRATION_DB.schema(:items, :reload=>true)

data/spec/sequel_core/core_ext_spec.rb

@@ -27,7 +27,7 @@ context "Range#interval" do
     (1..10).interval.should == 9
     
     r = rand(100000) + 10
-    t1 = Time.now; t2 = t1 + r
+    t1 = Time.now.to_i; t2 = t1 + r
     (t1..t2).interval.should == r
   end
 
@@ -35,7 +35,7 @@ context "Range#interval" do
     (1...10).interval.should == 8
     
     r = rand(100000) + 10
-    t1 = Time.now; t2 = t1 + r
+    t1 = Time.now.to_i; t2 = t1 + r
     (t1...t2).interval.should == r - 1
   end
 end

data/spec/sequel_core/dataset_spec.rb

@@ -686,6 +686,9 @@ context "Dataset#literal" do
 
   specify "should literalize BigDecimal instances correctly" do
     @dataset.literal(BigDecimal.new("80")).should == "80.0"
+    @dataset.literal(BigDecimal.new("NaN")).should == "'NaN'"
+    @dataset.literal(BigDecimal.new("Infinity")).should == "'Infinity'"
+    @dataset.literal(BigDecimal.new("-Infinity")).should == "'-Infinity'"
   end
 
   specify "should raise an Error if the object can't be literalized" do
@@ -1168,6 +1171,15 @@ context "Dataset#count" do
     @c.sql.should == "SELECT COUNT(*) FROM (select abc from xyz) AS t1 LIMIT 1"
   end
 
+  specify "should count properly when using UNION, INTERSECT, or EXCEPT" do
+    @dataset.union(@dataset).count.should == 1
+    @c.sql.should == "SELECT COUNT(*) FROM (SELECT * FROM test UNION SELECT * FROM test) AS t1 LIMIT 1"
+    @dataset.intersect(@dataset).count.should == 1
+    @c.sql.should == "SELECT COUNT(*) FROM (SELECT * FROM test INTERSECT SELECT * FROM test) AS t1 LIMIT 1"
+    @dataset.except(@dataset).count.should == 1
+    @c.sql.should == "SELECT COUNT(*) FROM (SELECT * FROM test EXCEPT SELECT * FROM test) AS t1 LIMIT 1"
+  end
+
   specify "should return limit if count is greater than it" do
     @dataset.limit(5).count.should == 1
     @c.sql.should == "SELECT COUNT(*) FROM (SELECT * FROM test LIMIT 5) AS t1 LIMIT 1"
@@ -1722,7 +1734,7 @@ context "Dataset #first and #last" do
   end
 end
 
-context "Dataset set operations" do
+context "Dataset compound operations" do
   setup do
     @a = Sequel::Dataset.new(nil).from(:a).filter(:z => 1)
     @b = Sequel::Dataset.new(nil).from(:b).filter(:z => 2)
@@ -1748,6 +1760,28 @@ context "Dataset set operations" do
     @b.except(@a, true).sql.should == \
       "SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)"
   end
+    
+  specify "should handle chained compound operations" do
+    @a.union(@b).union(@a, true).sql.should == \
+      "SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)"
+    @a.intersect(@b, true).intersect(@a).sql.should == \
+      "SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1)"
+    @a.except(@b).except(@a, true).sql.should == \
+      "SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)"
+    @a.union(@b, true).intersect(@a).except(@b, true).union(@a).intersect(@b, true).except(@a).sql.should == \
+      "SELECT * FROM a WHERE (z = 1) UNION ALL SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1) EXCEPT ALL SELECT * FROM b WHERE (z = 2) UNION SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM b WHERE (z = 2) EXCEPT SELECT * FROM a WHERE (z = 1)"
+  end
+  
+  specify "should use a subselect when using a compound operation with a dataset that already has a compound operation" do
+    @a.union(@b.union(@a, true)).sql.should == \
+      "SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM (SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1))"
+    @a.intersect(@b.intersect(@a), true).sql.should == \
+      "SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1))"
+    @a.except(@b.except(@a, true)).sql.should == \
+      "SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1))"
+    @a.union(@b.intersect(@a.except(@b, true)), true).union(@a.intersect(@b.except(@a), true)).sql.should == \
+      "SELECT * FROM a WHERE (z = 1) UNION ALL SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT ALL SELECT * FROM b WHERE (z = 2))) UNION SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT SELECT * FROM a WHERE (z = 1)))"
+  end
 end
 
 context "Dataset#[]" do

data/spec/sequel_core/schema_spec.rb

@@ -650,6 +650,13 @@ context "Schema Parser" do
     Sequel.convert_tinyint_to_bool = true
   end
 
+  specify "should raise an error if there are no columns" do
+    @db.meta_def(:schema_parse_table) do |t, opts|
+      []
+    end
+    proc{@db.schema(:x)}.should raise_error(Sequel::Error)
+  end
+
   specify "should parse the schema correctly for a single table" do
     sqls = @sqls
     proc{@db.schema(:x)}.should raise_error(Sequel::Error)

data/spec/sequel_model/association_reflection_spec.rb

@@ -8,12 +8,12 @@ describe Sequel::Model::Associations::AssociationReflection, "#associated_class"
 
   it "should use the :class value if present" do
     @c.many_to_one :c, :class=>ParParent
-    @c.association_reflection(:c).should include(:class)
+    @c.association_reflection(:c).keys.should include(:class)
     @c.association_reflection(:c).associated_class.should == ParParent
   end
   it "should figure out the class if the :class value is not present" do
     @c.many_to_one :c, :class=>'ParParent'
-    @c.association_reflection(:c).should_not include(:class)
+    @c.association_reflection(:c).keys.should_not include(:class)
     @c.association_reflection(:c).associated_class.should == ParParent
   end
 end
@@ -26,12 +26,12 @@ describe Sequel::Model::Associations::AssociationReflection, "#primary_key" do
 
   it "should use the :primary_key value if present" do
     @c.many_to_one :c, :class=>ParParent, :primary_key=>:blah__blah
-    @c.association_reflection(:c).should include(:primary_key)
+    @c.association_reflection(:c).keys.should include(:primary_key)
     @c.association_reflection(:c).primary_key.should == :blah__blah
   end
   it "should use the associated table's primary key if :primary_key is not present" do
     @c.many_to_one :c, :class=>'ParParent'
-    @c.association_reflection(:c).should_not include(:primary_key)
+    @c.association_reflection(:c).keys.should_not include(:primary_key)
     @c.association_reflection(:c).primary_key.should == :id
   end
 end
@@ -41,7 +41,7 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     @c = Class.new(Sequel::Model)
     @d = Class.new(Sequel::Model)
     @c.many_to_one :c, :class=>@d, :reciprocal=>:xx
-    @c.association_reflection(:c).should include(:reciprocal)
+    @c.association_reflection(:c).keys.should include(:reciprocal)
     @c.association_reflection(:c).reciprocal.should == :xx
   end
 
@@ -54,13 +54,13 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     ParParent.many_to_many :par_parent_threes
     ParParentThree.many_to_many :par_parents
 
-    ParParent.association_reflection(:par_parent_two).should_not include(:reciprocal)
+    ParParent.association_reflection(:par_parent_two).keys.should_not include(:reciprocal)
     ParParent.association_reflection(:par_parent_two).reciprocal.should == :par_parents
-    ParParentTwo.association_reflection(:par_parents).should_not include(:reciprocal)
+    ParParentTwo.association_reflection(:par_parents).keys.should_not include(:reciprocal)
     ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
-    ParParent.association_reflection(:par_parent_threes).should_not include(:reciprocal)
+    ParParent.association_reflection(:par_parent_threes).keys.should_not include(:reciprocal)
     ParParent.association_reflection(:par_parent_threes).reciprocal.should == :par_parents
-    ParParentThree.association_reflection(:par_parents).should_not include(:reciprocal)
+    ParParentThree.association_reflection(:par_parents).keys.should_not include(:reciprocal)
     ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
   end
 end
@@ -73,20 +73,20 @@ describe Sequel::Model::Associations::AssociationReflection, "#select" do
 
   it "should use the :select value if present" do
     @c.many_to_one :c, :class=>ParParent, :select=>[:par_parents__id]
-    @c.association_reflection(:c).should include(:select)
+    @c.association_reflection(:c).keys.should include(:select)
     @c.association_reflection(:c).select.should == [:par_parents__id]
   end
   it "should be the associated_table.* if :select is not present for a many_to_many associaiton" do
     @c.many_to_many :cs, :class=>'ParParent'
-    @c.association_reflection(:cs).should_not include(:select)
+    @c.association_reflection(:cs).keys.should_not include(:select)
     @c.association_reflection(:cs).select.should == :par_parents.*
   end
   it "should be if :select is not present for a many_to_one and one_to_many associaiton" do
     @c.one_to_many :cs, :class=>'ParParent'
-    @c.association_reflection(:cs).should_not include(:select)
+    @c.association_reflection(:cs).keys.should_not include(:select)
     @c.association_reflection(:cs).select.should == nil
     @c.many_to_one :c, :class=>'ParParent'
-    @c.association_reflection(:c).should_not include(:select)
+    @c.association_reflection(:c).keys.should_not include(:select)
     @c.association_reflection(:c).select.should == nil
   end
 end

data/spec/sequel_model/hooks_spec.rb

@@ -213,7 +213,8 @@ describe "Model#before_create && Model#after_create" do
 
   specify ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
     @c.before_create{false}
-    proc{@c.create(:x => 2)}.should raise_error(Sequel::Error)
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.create(:x => 2)}.should raise_error(Sequel::BeforeHookFailed)
     MODEL_DB.sqls.should == []
   end
 
@@ -248,7 +249,8 @@ describe "Model#before_update && Model#after_update" do
 
   specify "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
     @c.before_update{false}
-    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::Error)
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
     MODEL_DB.sqls.should == []
   end
 
@@ -295,7 +297,8 @@ describe "Model#before_save && Model#after_save" do
 
   specify "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
     @c.before_save{false}
-    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::Error)
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
     MODEL_DB.sqls.should == []
   end
 
@@ -334,7 +337,7 @@ describe "Model#before_destroy && Model#after_destroy" do
 
   specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
     @c.before_destroy{false}
-    proc{@c.load(:id => 2233).destroy}.should raise_error(Sequel::Error)
+    proc{@c.load(:id => 2233).destroy}.should raise_error(Sequel::BeforeHookFailed)
     MODEL_DB.sqls.should == []
   end
 
@@ -393,7 +396,8 @@ describe "Model#before_validation && Model#after_validation" do
 
   specify "#save should cancel the save and raise an error if before_validation returns false and raise_on_save_failure is true" do
     @c.before_validation{false}
-    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::Error)
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
     MODEL_DB.sqls.should == []
   end
 

data/spec/sequel_model/validations_spec.rb

@@ -897,7 +897,7 @@ describe "Model#save" do
   end
   
   specify "should raise error if validations fail and raise_on_save_faiure is true" do
-    proc{@m.save}.should raise_error(Sequel::Error)
+    proc{@m.save}.should raise_error(Sequel::ValidationFailed)
   end
   
   specify "should return nil if validations fail and raise_on_save_faiure is false" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 2.8.0
+  version: 2.9.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-05 00:00:00 -08:00
+date: 2009-01-12 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -156,6 +156,7 @@ files:
 - lib/sequel_model/record.rb
 - lib/sequel_model/schema.rb
 - lib/sequel_model/validations.rb
+- lib/sequel_model/exceptions.rb
 has_rdoc: true
 homepage: http://sequel.rubyforge.org
 post_install_message: