sequel 3.10.0 → 3.11.0

data/spec/core/schema_spec.rb

@@ -299,6 +299,15 @@ context "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (name text, UNIQUE (name))"]
   end
 
+  specify "should not raise on index error for unsupported index definitions if ignore_index_errors is used" do
+    proc {
+      @db.create_table(:cats, :ignore_index_errors=>true) do
+        text :name
+        full_text_index :name
+      end
+    }.should_not raise_error
+  end
+
   specify "should raise on full-text index definitions" do
     proc {
       @db.create_table(:cats) do
@@ -812,8 +821,12 @@ context "Schema Parser" do
     @db.schema(:float).first.last[:type].should == :float
     @db.schema(:double).first.last[:type].should == :float
     @db.schema(:"double precision").first.last[:type].should == :float
+    @db.schema(:number).first.last[:type].should == :decimal
     @db.schema(:numeric).first.last[:type].should == :decimal
     @db.schema(:decimal).first.last[:type].should == :decimal
+    @db.schema(:"number(10,0)").first.last[:type].should == :integer
+    @db.schema(:"numeric(10, 10)").first.last[:type].should == :decimal
+    @db.schema(:"decimal(10,1)").first.last[:type].should == :decimal
     @db.schema(:money).first.last[:type].should == :decimal
     @db.schema(:bytea).first.last[:type].should == :blob
     @db.schema(:blob).first.last[:type].should == :blob

data/spec/extensions/active_model_spec.rb

@@ -8,15 +8,18 @@ describe "ActiveModel plugin" do
         s = f.read
       else
         begin
+          require 'rubygems'
           require 'active_model'
         rescue LoadError
-          puts "0 failures, 0 errors"
+          puts "0 failures, 0 errors, skipping tests"
         else
           require 'test/unit'
           require "test/unit/ui/console/testrunner"
           class AMLintTest < Test::Unit::TestCase
             def setup
               @c = Class.new(Sequel::Model) do
+                set_primary_key :id
+                columns :id, :id2
                 def delete; end
               end
               @c.plugin :active_model
@@ -25,22 +28,42 @@ describe "ActiveModel plugin" do
             end
             include ActiveModel::Lint::Tests
 
-            def test_to_model
+            # Should return self, not a proxy object
+            def test__to_model
               assert_equal @m.to_model.object_id.should, @m.object_id
             end
-
-            def test_new_record
-              assert_equal true, @m.new_record?
-              assert_equal false, @o.new_record?
+            
+            def test__to_key
+              assert_equal nil, @m.to_key
+              @o.id = 1
+              assert_equal [1], @o.to_key
+              @c.set_primary_key [:id2, :id]
+              @o.id2 = 2
+              assert_equal [2, 1], @o.to_key
+              @o.destroy
+              assert_equal nil, @o.to_key
+            end
+            
+            def test__to_param
+              assert_equal nil, @m.to_param
+              @o.id = 1
+              assert_equal '1', @o.to_param
+              @c.set_primary_key [:id2, :id]
+              @o.id2 = 2
+              assert_equal '2-1', @o.to_param
+              @o.meta_def(:to_param_joiner){'|'}
+              assert_equal '2|1', @o.to_param
+              @o.destroy
+              assert_equal nil, @o.to_param
             end
 
-            def test_destroyed
-              assert_equal false, @m.destroyed?
-              assert_equal false, @o.destroyed?
+            def test__persisted?
+              assert_equal false, @m.persisted?
+              assert_equal true, @o.persisted?
               @m.destroy
               @o.destroy
-              assert_equal true, @m.destroyed?
-              assert_equal true, @o.destroyed?
+              assert_equal false, @m.persisted?
+              assert_equal false, @o.persisted?
             end
           end
           Test::Unit::UI::Console::TestRunner.run(AMLintTest)

data/spec/extensions/caching_spec.rb

@@ -57,10 +57,12 @@ describe Sequel::Model, "caching" do
       def update(values)
         $sqls << update_sql(values)
         $cache_dataset_row.merge!(values)
+        1
       end
       
       def delete
         $sqls << delete_sql
+        1
       end
     })
     

data/spec/extensions/instance_filters_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "instance_filters plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:people)) do
+    end
+    @sql = sql = ''
+    @v = v = [1]
+    @c.dataset.quote_identifiers = false
+    @c.dataset.meta_def(:update) do |opts|
+      sql.replace(update_sql(opts))
+      return v.first
+    end
+    @c.dataset.meta_def(:delete) do
+      sql.replace(delete_sql)
+      return v.first
+    end
+    @c.columns :id, :name, :num
+    @c.plugin :instance_filters
+    @p = @c.load(:id=>1, :name=>'John', :num=>1)
+  end
+
+  specify "should raise an error when updating a stale record" do
+    @p.update(:name=>'Bob')
+    @sql.should == "UPDATE people SET name = 'Bob' WHERE (id = 1)"
+    @p.instance_filter(:name=>'Jim')
+    @v.replace([0])
+    proc{@p.update(:name=>'Joe')}.should raise_error(Sequel::Plugins::InstanceFilters::Error)
+    @sql.should == "UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"
+  end 
+
+  specify "should raise an error when destroying a stale record" do
+    @p.destroy
+    @sql.should == "DELETE FROM people WHERE (id = 1)"
+    @p.instance_filter(:name=>'Jim')
+    @v.replace([0])
+    proc{@p.destroy}.should raise_error(Sequel::Plugins::InstanceFilters::Error)
+    @sql.should == "DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"
+  end 
+  
+  specify "should apply all instance filters" do
+    @p.instance_filter(:name=>'Jim')
+    @p.instance_filter{num > 2}
+    @p.update(:name=>'Bob')
+    @sql.should == "UPDATE people SET name = 'Bob' WHERE ((id = 1) AND (name = 'Jim') AND (num > 2))"
+  end 
+
+  specify "should drop instance filters after updating" do
+    @p.instance_filter(:name=>'Joe')
+    @p.update(:name=>'Joe')
+    @sql.should == "UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Joe'))"
+    @p.update(:name=>'Bob')
+    @sql.should == "UPDATE people SET name = 'Bob' WHERE (id = 1)"
+  end
+end

data/spec/extensions/spec_helper.rb

@@ -18,10 +18,12 @@ class MockDataset < Sequel::Dataset
   
   def update(*args)
     @db.execute update_sql(*args)
+    1
   end
   
   def delete(*args)
     @db.execute delete_sql(*args)
+    1
   end
   
   def fetch_rows(sql)

data/spec/integration/dataset_test.rb

@@ -38,11 +38,18 @@ describe "Simple Dataset operations" do
     @ds.filter(1=>1).delete.should == 1
     @ds.count.should == 0
   end
-
+  
   specify "should update correctly" do
     @ds.update(:number=>:number+1).should == 1
     @ds.all.should == [{:id=>1, :number=>11}]
   end
+  
+  cspecify "should have update return the number of matched rows", [:mysql, :mysql], [:do, :mysql], [:ado] do
+    @ds.update(:number=>:number).should == 1
+    @ds.filter(:id=>1).update(:number=>:number).should == 1
+    @ds.filter(:id=>2).update(:number=>:number).should == 0
+    @ds.all.should == [{:id=>1, :number=>10}]
+  end
 
   specify "should fetch all results correctly" do
     @ds.all.should == [{:id=>1, :number=>10}]
@@ -52,6 +59,10 @@ describe "Simple Dataset operations" do
     @ds.first.should == {:id=>1, :number=>10}
   end
   
+  specify "should have distinct work with limit" do
+    @ds.limit(1).distinct.all.should == [{:id=>1, :number=>10}]
+  end
+  
   specify "should fetch correctly with a limit" do
     @ds.order(:id).limit(2).all.should == [{:id=>1, :number=>10}]
     @ds.insert(:number=>20)

data/spec/integration/model_test.rb

@@ -75,6 +75,18 @@ describe "Sequel::Model basic support" do
     i.save(:num)
     Item.all.should == [Item.load(:id=>1, :name=>'K', :num=>2)]
   end
+  
+  specify "#save should check that the only a single row is modified, unless require_modification is false" do
+    i = Item.create(:name=>'a')
+    i.require_modification = true
+    i.delete
+    proc{i.save}.should raise_error(Sequel::NoExistingObject)
+    proc{i.delete}.should raise_error(Sequel::NoExistingObject)
+    
+    i.require_modification = false
+    i.save
+    i.delete
+  end
 
   specify ".to_hash should return a hash keyed on primary key if no argument provided" do
     i = Item.create(:name=>'J')

data/spec/integration/plugin_test.rb

@@ -47,7 +47,7 @@ describe "Class Table Inheritance Plugin" do
     clear_sqls
   end
   after do
-    @db.drop_table :executives, :managers, :staff, :employees
+    @db.drop_table :staff, :executives, :managers, :employees
     [:Executive, :Manager, :Staff, :Employee].each{|s| Object.send(:remove_const, s)}
   end
 
@@ -752,3 +752,63 @@ if INTEGRATION_DB.dataset.supports_cte?
     end
   end
 end
+
+describe "Instance Filters plugin" do 
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:items) do
+      primary_key :id
+      String :name
+      Integer :cost
+      Integer :number
+    end
+    class ::Item < Sequel::Model(@db)
+      plugin :instance_filters
+    end
+    @i = Item.create(:name=>'J', :number=>1, :cost=>2)
+    @i.instance_filter(:number=>1)
+    @i.set(:name=>'K')
+  end
+  after do
+    @db.drop_table(:items)
+    Object.send(:remove_const, :Item)
+  end
+  
+  specify "should not raise an error if saving only updates one row" do
+    @i.save
+    @i.refresh.name.should == 'K'
+  end
+  
+  specify "should raise error if saving doesn't update a row" do
+    @i.this.update(:number=>2)
+    proc{@i.save}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should apply all instance filters" do
+    @i.instance_filter{cost <= 2}
+    @i.this.update(:number=>2)
+    proc{@i.save}.should raise_error(Sequel::Error)
+    @i.this.update(:number=>1, :cost=>3)
+    proc{@i.save}.should raise_error(Sequel::Error)
+    @i.this.update(:cost=>2)
+    @i.save
+    @i.refresh.name.should == 'K'
+  end
+  
+  specify "should clear instance filters after successful save" do
+    @i.save
+    @i.this.update(:number=>2)
+    @i.update(:name=>'L')
+    @i.refresh.name.should == 'L'
+  end
+  
+  specify "should not raise an error if deleting only deletes one row" do
+    @i.destroy
+    proc{@i.refresh}.should raise_error(Sequel::Error, 'Record not found')
+  end
+  
+  specify "should raise error if destroying doesn't delete a row" do
+    @i.this.update(:number=>2)
+    proc{@i.destroy}.should raise_error(Sequel::Error)
+  end
+end

data/spec/integration/schema_test.rb

@@ -87,10 +87,10 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
     INTEGRATION_DB.create_table!(:items){Float :number}
     INTEGRATION_DB.schema(:items).first.last[:type].should == :float
-    INTEGRATION_DB.create_table!(:items){BigDecimal :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :decimal
-    INTEGRATION_DB.create_table!(:items){Numeric :number}
+    INTEGRATION_DB.create_table!(:items){BigDecimal :number, :size=>[11, 2]}
     INTEGRATION_DB.schema(:items).first.last[:type].should == :decimal
+    INTEGRATION_DB.create_table!(:items){Numeric :number, :size=>[12, 0]}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
     INTEGRATION_DB.create_table!(:items){String :number}
     INTEGRATION_DB.schema(:items).first.last[:type].should == :string
     INTEGRATION_DB.create_table!(:items){Date :number}
@@ -159,6 +159,17 @@ describe "Database schema modifiers" do
     @ds.columns!.should == [:number]
   end
   
+  specify "should rename tables correctly" do
+    @db.drop_table(:items) rescue nil
+    @db.create_table!(:items2){Integer :number}
+    @db.rename_table(:items2, :items)
+    @db.table_exists?(:items).should == true
+    @db.table_exists?(:items2).should == false
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:number]
+    @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

data/spec/model/base_spec.rb

@@ -327,6 +327,33 @@ describe Sequel::Model, ".strict_param_setting" do
   end
 end
 
+describe Sequel::Model, ".require_modification" do
+  before do
+    @ds1 = MODEL_DB[:items]
+    @ds1.meta_def(:provides_accurate_rows_matched?){false}
+    @ds2 = MODEL_DB[:items]
+    @ds2.meta_def(:provides_accurate_rows_matched?){true}
+  end
+  after do
+    Sequel::Model.require_modification = nil
+  end
+
+  it "should depend on whether the dataset provides an accurate number of rows matched by default" do
+    Class.new(Sequel::Model(@ds1)).require_modification.should == false
+    Class.new(Sequel::Model(@ds2)).require_modification.should == true
+  end
+
+  it "should obey global setting regardless of dataset support if set" do
+    Sequel::Model.require_modification = true
+    Class.new(Sequel::Model(@ds1)).require_modification.should == true
+    Class.new(Sequel::Model(@ds2)).require_modification.should == true
+    
+    Sequel::Model.require_modification = false
+    Class.new(Sequel::Model(@ds1)).require_modification.should == false
+    Class.new(Sequel::Model(@ds2)).require_modification.should == false
+  end
+end
+
 describe Sequel::Model, ".[] optimization" do
   before do
     @c = Class.new(Sequel::Model(:a))

data/spec/model/plugins_spec.rb

@@ -163,39 +163,17 @@ describe Sequel::Model, ".plugin" do
     m.get_stamp.should == t
   end
 
-  it "should define a plugin_opts instance method if the plugin has an InstanceMethods module" do
-    @c.plugin :timestamped, 1, 2=>3
-    @c.new.timestamped_opts.should == [1, {2=>3}]
-  end
-
   it "should extend the class with a ClassMethods module if the plugin includes it" do
     @c.plugin @t
     @c.def.should == 234
   end
 
-  it "should define a plugin_opts class method if the plugin has a ClassMethods module" do
-    @c.plugin :timestamped, 1, 2=>3
-    @c.timestamped_opts.should == [1, {2=>3}]
-  end
-
   it "should extend the class's dataset with a DatasetMethods module if the plugin includes it" do
     @c.plugin @t
     @c.dataset.ghi.should == 345
     @c.ghi.should == 345
   end
 
-  it "should define a plugin_opts dataset method if the plugin has a DatasetMethods module" do
-    @c.plugin :timestamped, 1, 2=>3
-    @c.dataset.timestamped_opts.should == [1, {2=>3}]
-  end
-  
-  it "should use a single arg for the plugin_opts method if only a single arg was given" do
-    @c.plugin :timestamped, 1
-    @c.new.timestamped_opts.should == 1
-    @c.timestamped_opts.should == 1
-    @c.dataset.timestamped_opts.should == 1
-  end
-  
   it "should save the DatasetMethods module and apply it later if the class doesn't have a dataset" do
     c = Class.new(Sequel::Model)
     c.plugin @t

data/spec/model/record_spec.rb

@@ -97,6 +97,22 @@ describe "Model#save" do
     MODEL_DB.sqls.should == ["UPDATE items SET x = 1 WHERE (id = 3)"]
   end
   
+  it "should raise a NoExistingObject exception if the dataset update call doesn't return 1, unless require_modification is false" do
+    o = @c.load(:id => 3, :x => 1)
+    o.this.meta_def(:update){|*a| 0}
+    proc{o.save}.should raise_error(Sequel::NoExistingObject)
+    o.this.meta_def(:update){|*a| 2}
+    proc{o.save}.should raise_error(Sequel::NoExistingObject)
+    o.this.meta_def(:update){|*a| 1}
+    proc{o.save}.should_not raise_error
+    
+    o.require_modification = false
+    o.this.meta_def(:update){|*a| 0}
+    proc{o.save}.should_not raise_error
+    o.this.meta_def(:update){|*a| 2}
+    proc{o.save}.should_not raise_error
+  end
+  
   it "should update only the given columns if given" do
     o = @c.load(:id => 3, :x => 1, :y => nil)
     o.save(:y)
@@ -788,7 +804,7 @@ describe Sequel::Model, "#destroy" do
     MODEL_DB.reset
     @model = Class.new(Sequel::Model(:items))
     @model.columns :id
-    @model.dataset.meta_def(:delete) {MODEL_DB.execute delete_sql}
+    @model.dataset.meta_def(:delete){MODEL_DB.execute delete_sql;1}
     
     @instance = @model.load(:id => 1234)
   end
@@ -797,6 +813,21 @@ describe Sequel::Model, "#destroy" do
     @model.send(:define_method, :after_destroy){3}
     @instance.destroy.should == @instance
   end
+  
+  it "should raise a NoExistingObject exception if the dataset delete call doesn't return 1" do
+    @instance.this.meta_def(:delete){|*a| 0}
+    proc{@instance.delete}.should raise_error(Sequel::NoExistingObject)
+    @instance.this.meta_def(:delete){|*a| 2}
+    proc{@instance.delete}.should raise_error(Sequel::NoExistingObject)
+    @instance.this.meta_def(:delete){|*a| 1}
+    proc{@instance.delete}.should_not raise_error
+    
+    @instance.require_modification = false
+    @instance.this.meta_def(:delete){|*a| 0}
+    proc{@instance.delete}.should_not raise_error
+    @instance.this.meta_def(:delete){|*a| 2}
+    proc{@instance.delete}.should_not raise_error
+  end
 
   it "should run within a transaction if use_transactions is true" do
     @instance.use_transactions = true