sequel 3.29.0 → 3.30.0

data/spec/extensions/tree_spec.rb

@@ -7,26 +7,11 @@ describe Sequel::Model, "tree plugin" do
     c.class_eval do
       def self.name; 'Node'; end
       columns :id, :name, :parent_id, :i, :pi
+      plugin :tree, opts
     end
-    ds = c.dataset
-    class << ds
-      attr_accessor :row_sets
-      def fetch_rows(sql)
-        @db << sql
-        if rs = row_sets.shift
-          rs.each{|row| yield row}
-        end
-      end
-    end
-    c.plugin :tree, opts
     c
   end
 
-  def y(c, *hs)
-    ds = c.dataset
-    ds.row_sets = hs
-  end
-
   before do
     @c = klass
     @ds = @c.dataset
@@ -71,7 +56,7 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have roots return an array of the tree's roots" do
-    y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+    @ds._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
     @c.roots.should == [@c.load(:id=>1, :parent_id=>nil, :name=>'r')]
     @db.sqls.should == ["SELECT * FROM nodes WHERE (parent_id IS NULL)"]
   end
@@ -81,14 +66,14 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have ancestors return the ancestors of the current node" do
-    y(@c, [{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}])
+    @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
     @o.ancestors.should == [@c.load(:id=>1, :parent_id=>5, :name=>'r'), @c.load(:id=>5, :parent_id=>nil, :name=>'r2')]
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.id = 5) LIMIT 1"]
   end
 
   it "should have descendants return the descendants of the current node" do
-    y(@c, [{:id=>3, :parent_id=>2, :name=>'r'}, {:id=>4, :parent_id=>2, :name=>'r2'}], [{:id=>5, :parent_id=>4, :name=>'r3'}], [])
+    @ds._fetch = [[{:id=>3, :parent_id=>2, :name=>'r'}, {:id=>4, :parent_id=>2, :name=>'r2'}], [{:id=>5, :parent_id=>4, :name=>'r3'}], []]
     @o.descendants.should == [@c.load(:id=>3, :parent_id=>2, :name=>'r'), @c.load(:id=>4, :parent_id=>2, :name=>'r2'), @c.load(:id=>5, :parent_id=>4, :name=>'r3')] 
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.parent_id = 2)",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 3)",
@@ -97,7 +82,7 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have root return the root of the current node" do
-    y(@c, [{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}])
+    @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
     @o.root.should == @c.load(:id=>5, :parent_id=>nil, :name=>'r2')
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.id = 5) LIMIT 1"]
@@ -113,14 +98,14 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have self_and_siblings return the children of the current node's parent" do
-    y(@c, [{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup])
+    @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
     @o.self_and_siblings.should == [@c.load(:id=>7, :parent_id=>1, :name=>'r2'), @o] 
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
   end
 
   it "should have siblings return the children of the current node's parent, except for the current node" do
-    y(@c, [{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup])
+    @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
     @o.siblings.should == [@c.load(:id=>7, :parent_id=>1, :name=>'r2')] 
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
@@ -132,23 +117,23 @@ describe Sequel::Model, "tree plugin" do
     end
 
     it "should have root class method return the root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       @c.root.should == @c.load(:id=>1, :parent_id=>nil, :name=>'r')
     end
 
     it "prevents creating a second root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       lambda { @c.create }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
     end
 
     it "errors when promoting an existing record to a second root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       n = @c.load(:id => 2, :parent_id => 1)
       lambda { n.update(:parent_id => nil) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
     end
 
     it "allows updating existing root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
     end
   end

data/spec/extensions/update_primary_key_spec.rb

@@ -9,57 +9,63 @@ describe "Sequel::Plugins::UpdatePrimaryKey" do
     @c.unrestrict_primary_key
     @o = @c.new
     @ds = @c.dataset
-    @ds.extend(Module.new do
-      attr_accessor :a
-      def fetch_rows(sql)
-        yield(a.dup)
-      end
-
-      def update(h)
-        if literal(opts[:where]) =~ /a = (\d)/ and $1.to_i == a[:a]
-          a.update(h)
-        end
-        super
-      end
-    end)
-    @ds.a = {:a=>1, :b=>3}
-    @ds2 = @ds.naked 
     MODEL_DB.reset
   end
 
   specify "should handle regular updates" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>1, :b=>4}], [{:a=>1, :b=>4}], [{:a=>1, :b=>5}], [{:a=>1, :b=>5}], [{:a=>1, :b=>6}], [{:a=>1, :b=>6}]]
     @c.first.update(:b=>4)
-    @ds2.all.should == [{:a=>1, :b=>4}]
+    @c.all.should == [@c.load(:a=>1, :b=>4)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 4 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:b=>5).save
-    @ds2.all.should == [{:a=>1, :b=>5}]
+    @c.all.should == [@c.load(:a=>1, :b=>5)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 5 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:b=>6).save(:b)
-    @ds2.all.should == [{:a=>1, :b=>6}]
+    @c.all.should == [@c.load(:a=>1, :b=>6)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 6 WHERE (a = 1)", "SELECT * FROM a"]
   end
 
   specify "should handle updating the primary key field with another field" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
     @c.first.update(:a=>2, :b=>4)
-    @ds2.all.should == [{:a=>2, :b=>4}]
+    @c.all.should == [@c.load(:a=>2, :b=>4)]
+    sqls = MODEL_DB.sqls
+    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
+    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
   specify "should handle updating just the primary key field when saving changes" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>3}], [{:a=>2, :b=>3}], [{:a=>3, :b=>3}]]
     @c.first.update(:a=>2)
-    @ds2.all.should == [{:a=>2, :b=>3}]
+    @c.all.should == [@c.load(:a=>2, :b=>3)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:a=>3).save(:a)
-    @ds2.all.should == [{:a=>3, :b=>3}]
+    @c.all.should == [@c.load(:a=>3, :b=>3)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 3 WHERE (a = 2)", "SELECT * FROM a"]
   end
 
   specify "should handle saving after modifying the primary key field with another field" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
     @c.first.set(:a=>2, :b=>4).save
-    @ds2.all.should == [{:a=>2, :b=>4}]
+    @c.all.should == [@c.load(:a=>2, :b=>4)]
+    sqls = MODEL_DB.sqls
+    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
+    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
   specify "should handle saving after modifying just the primary key field" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>3}]]
     @c.first.set(:a=>2).save
-    @ds2.all.should == [{:a=>2, :b=>3}]
+    @c.all.should == [@c.load(:a=>2, :b=>3)]
+    sqls = MODEL_DB.sqls
+    ["UPDATE a SET a = 2, b = 3 WHERE (a = 1)", "UPDATE a SET b = 3, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
+    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
   specify "should handle saving after updating the primary key" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>5}]]
     @c.first.update(:a=>2).update(:b=>4).set(:b=>5).save
-    @ds2.all.should == [{:a=>2, :b=>5}]
+    @c.all.should == [@c.load(:a=>2, :b=>5)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "UPDATE a SET b = 4 WHERE (a = 2)", "UPDATE a SET b = 5 WHERE (a = 2)", "SELECT * FROM a"]
   end
 end

data/spec/extensions/validation_class_methods_spec.rb

@@ -527,13 +527,8 @@ describe Sequel::Model do
   end
   
   specify "should raise an error if inclusion_of doesn't receive a valid :in option" do
-    lambda {
-      @c.validates_inclusion_of :value
-    }.should raise_error(ArgumentError)
-    
-    lambda {
-      @c.validates_inclusion_of :value, :in => 1
-    }.should raise_error(ArgumentError)
+    lambda{@c.validates_inclusion_of :value}.should raise_error(ArgumentError)
+    lambda{@c.validates_inclusion_of :value, :in => 1}.should raise_error(ArgumentError)
   end
   
   specify "should raise an error if inclusion_of handles :allow_nil too" do
@@ -570,7 +565,6 @@ describe Sequel::Model do
 
   specify "should validate uniqueness_of with if => false" do
     @c.validates_uniqueness_of :value, :if => :skip
-
     @m.value = 'a'
     @m.should be_valid
   end
@@ -602,16 +596,11 @@ describe "Superclass validations" do
     o = @c2.new
     o.value = 'ab'
     o.valid?.should == false
-    o.errors.full_messages.should == [
-      'value is too short'
-    ]
+    o.errors.full_messages.should == ['value is too short']
 
     o.value = '12'
     o.valid?.should == false
-    o.errors.full_messages.should == [
-      'value is too short',
-      'value is invalid'
-    ]
+    o.errors.full_messages.should == ['value is too short', 'value is invalid']
 
     o.value = 'abcde'
     o.valid?.should be_true
@@ -626,9 +615,7 @@ describe "Superclass validations" do
 
     o.value = '12'
     o.valid?.should == false
-    o.errors.full_messages.should == [
-      'value is invalid'
-    ]
+    o.errors.full_messages.should == ['value is invalid']
 
     o.value = 'abcde'
     o.valid?.should be_true
@@ -824,22 +811,18 @@ describe Sequel::Model, "Validations" do
         uniqueness_of :username
       end
     end
-    User.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        @db << sql
-        
-        case sql
-        when /COUNT.*username = '0records'/
-          yield({:v => 0})
-        when /COUNT.*username = '2records'/
-          yield({:v => 2})
-        when /COUNT.*username = '1record'/
-          yield({:v => 1})
-        when /username = '1record'/
-          yield({:id => 3, :username => "1record", :password => "test"})
-        end
+    User.dataset._fetch = proc do |sql|
+      case sql
+      when /COUNT.*username = '0records'/
+        {:v => 0}
+      when /COUNT.*username = '2records'/
+        {:v => 2}
+      when /COUNT.*username = '1record'/
+        {:v => 1}
+      when /username = '1record'/
+        {:id => 3, :username => "1record", :password => "test"}
       end
-    })
+    end
     
     @user = User.new(:username => "2records", :password => "anothertest")
     @user.should_not be_valid
@@ -869,26 +852,22 @@ describe Sequel::Model, "Validations" do
         uniqueness_of [:username, :password]
       end
     end
-    User.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        @db << sql
-        
-        case sql
-        when /COUNT.*username = '0records'/
-          yield({:v => 0})
-        when /COUNT.*username = '2records'/
-          yield({:v => 2})
-        when /COUNT.*username = '1record'/
-          yield({:v => 1})
-        when /username = '1record'/
-          if sql =~ /password = 'anothertest'/
-            yield({:id => 3, :username => "1record", :password => "anothertest"})
-          else
-            yield({:id => 4, :username => "1record", :password => "test"})
-          end
+    User.dataset._fetch = proc do |sql|
+      case sql
+      when /COUNT.*username = '0records'/
+        {:v => 0}
+      when /COUNT.*username = '2records'/
+        {:v => 2}
+      when /COUNT.*username = '1record'/
+        {:v => 1}
+      when /username = '1record'/
+        if sql =~ /password = 'anothertest'/
+          {:id => 3, :username => "1record", :password => "anothertest"}
+        else
+          {:id => 4, :username => "1record", :password => "test"}
         end
       end
-    })
+    end
     
     @user = User.new(:username => "2records", :password => "anothertest")
     @user.should_not be_valid

data/spec/extensions/validation_helpers_spec.rb

@@ -317,18 +317,14 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @c.columns(:id, :username, :password)
     @c.set_dataset MODEL_DB[:items]
     @c.set_validations{validates_unique(:username)}
-    @c.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        @db << sql
-        
-        case sql
-        when /COUNT.*username = '0records'/
-          yield({:v => 0})
-        when /COUNT.*username = '1record'/
-          yield({:v => 1})
-        end
+    @c.dataset._fetch = proc do |sql|
+      case sql
+      when /COUNT.*username = '0records'/
+        {:v => 0}
+      when /COUNT.*username = '1record'/
+        {:v => 1}
       end
-    })
+    end
     
     @user = @c.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
@@ -359,18 +355,14 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @c.columns(:id, :username, :password)
     @c.set_dataset MODEL_DB[:items]
     @c.set_validations{validates_unique([:username, :password])}
-    @c.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        @db << sql
-        
-        case sql
-        when /COUNT.*username = '0records'/
-          yield({:v => 0})
-        when /COUNT.*username = '1record'/
-          yield({:v => 1})
-        end
+    @c.dataset._fetch = proc do |sql|
+      case sql
+      when /COUNT.*username = '0records'/
+        {:v => 0}
+      when /COUNT.*username = '1record'/
+        {:v => 1}
       end
-    })
+    end
     
     @user = @c.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
@@ -401,12 +393,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @c.columns(:id, :username, :password)
     @c.set_dataset MODEL_DB[:items]
     @c.set_validations{validates_unique(:username){|ds| ds.filter(:active)}}
-    @c.dataset.extend(Module.new {
-      def fetch_rows (sql)
-        @db << sql
-        yield({:v => 0})
-      end
-    })
+    @c.dataset._fetch = {:v=>0}
     
     MODEL_DB.reset
     @c.new(:username => "0records", :password => "anothertest").should be_valid
@@ -419,13 +406,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @c.columns(:id, :username, :password)
     @c.set_dataset MODEL_DB[:items]
     @c.set_validations{validates_unique([:username, :password], :only_if_modified=>true)}
-    
-    @c.dataset.extend(Module.new {
-      def fetch_rows (sql)
-        @db << sql
-        yield({:v => 0})
-      end
-    })
+    @c.dataset._fetch = {:v=>0}
     
     MODEL_DB.reset
     @c.new(:username => "0records", :password => "anothertest").should be_valid

data/spec/integration/dataset_test.rb

@@ -1148,7 +1148,14 @@ end
 describe "Dataset string methods" do
   before(:all) do
     @db = INTEGRATION_DB
-    @db.create_table!(:a){String :a; String :b}
+    csc = {}
+    cic = {}
+    csc[:collate] = @db.dataset_class::CASE_SENSITIVE_COLLATION if defined? @db.dataset_class::CASE_SENSITIVE_COLLATION
+    cic[:collate] = @db.dataset_class::CASE_INSENSITIVE_COLLATION if defined? @db.dataset_class::CASE_INSENSITIVE_COLLATION
+    @db.create_table!(:a) do
+      String :a, csc
+      String :b, cic
+    end
     @ds = @db[:a].order(:a)
   end
   before do
@@ -1200,7 +1207,7 @@ describe "Dataset string methods" do
   it "#like should be case sensitive" do
     @ds.insert('foo', 'bar')
     @ds.filter(:a.like('Foo')).all.should == []
-    @ds.filter(:a.like('baR')).all.should == []
+    @ds.filter(:b.like('baR')).all.should == []
     @ds.filter(:a.like('FOO', 'BAR')).all.should == []
     @ds.exclude(:a.like('Foo')).all.should == [{:a=>'foo', :b=>'bar'}]
     @ds.exclude(:a.like('baR')).all.should == [{:a=>'foo', :b=>'bar'}]
@@ -1219,8 +1226,8 @@ describe "Dataset string methods" do
   
   it "should work with strings created with sql_string_join" do
     @ds.insert('foo', 'bar')
-    @ds.get([:a, :b].sql_string_join).should == 'foobar'
-    @ds.get([:a, :b].sql_string_join(' ')).should == 'foo bar'
+    @ds.get([:a, "bar"].sql_string_join).should == 'foobar'
+    @ds.get(["foo", :b].sql_string_join(' ')).should == 'foo bar'
   end
 end
 
@@ -1249,6 +1256,11 @@ describe "Dataset identifier methods" do
     @ds.first.should == {:BA=>1}
   end
   
+  it "should work with a nil identifier_output_method" do
+    @ds.identifier_output_method = nil
+    [{:ab=>1}, {:AB=>1}].should include(@ds.first)
+  end
+
   it "should work when not quoting identifiers" do
     @ds.quote_identifiers = false
     @ds.first.should == {:ab=>1}

data/spec/integration/prepared_statement_test.rb

@@ -223,7 +223,7 @@ describe "Prepared Statements and Bound Arguments" do
 end
 
 describe "Bound Argument Types" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.create_table!(:items) do
       primary_key :id
@@ -244,6 +244,8 @@ describe "Bound Argument Types" do
   end
   after do
     Sequel.datetime_class = Time
+  end
+  after(:all) do
     @db.drop_table(:items)
   end
 
@@ -256,7 +258,7 @@ describe "Bound Argument Types" do
     @ds.filter(:dt=>:$x).prepare(:first, :ps_datetime).call(:x=>@vs[:dt])[:dt].should == @vs[:dt]
   end
 
-  cspecify "should handle time type", [:do], [:jdbc, :sqlite] do
+  cspecify "should handle time type", [:do], [:jdbc, :sqlite], [:oracle] do
     @ds.filter(:t=>:$x).prepare(:first, :ps_time).call(:x=>@vs[:t])[:t].should == @vs[:t]
   end