sequel 3.40.0 → 3.41.0

data/spec/core/database_spec.rb

@@ -37,7 +37,8 @@ describe "A new Database" do
   
   specify "should pass the supplied block to the connection pool" do
     cc = nil
-    d = Sequel::Database.new {1234}
+    d = Sequel::Database.new
+    d.meta_def(:connect){|c| 1234}
     d.synchronize {|c| cc = c}
     cc.should == 1234
   end
@@ -538,7 +539,8 @@ end
 
 describe "Database#synchronize" do
   before do
-    @db = Sequel::Database.new(:max_connections => 1){12345}
+    @db = Sequel::Database.new(:max_connections => 1)
+    @db.meta_def(:connect){|c| 12345}
   end
   
   specify "should wrap the supplied block in pool.hold" do
@@ -561,7 +563,9 @@ end
 
 describe "Database#test_connection" do
   before do
-    @db = Sequel::Database.new{@test = rand(100)}
+    @db = Sequel::Database.new
+    pr = proc{@test = rand(100)}
+    @db.meta_def(:connect){|c| pr.call}
   end
   
   specify "should attempt to get a connection" do
@@ -1258,7 +1262,8 @@ end
 describe "A single threaded database" do
   before do
     conn = 1234567
-    @db = Sequel::Database.new(:single_threaded => true) do
+    @db = Sequel::Database.new(:single_threaded => true)
+    @db.meta_def(:connect) do |c|
       conn += 1
     end
   end

data/spec/core/dataset_spec.rb

@@ -1588,6 +1588,15 @@ describe "Dataset#reverse_order" do
   specify "should have #reverse alias" do
     @dataset.order(:name).reverse.sql.should == 'SELECT * FROM test ORDER BY name DESC'
   end
+
+  specify "should accept a block" do
+    @dataset.reverse{name}.sql.should == 'SELECT * FROM test ORDER BY name DESC'
+    @dataset.reverse_order{name}.sql.should == 'SELECT * FROM test ORDER BY name DESC'
+    @dataset.reverse(:foo){name}.sql.should == 'SELECT * FROM test ORDER BY foo DESC, name DESC'
+    @dataset.reverse_order(:foo){name}.sql.should == 'SELECT * FROM test ORDER BY foo DESC, name DESC'
+    @dataset.reverse(Sequel.desc(:foo)){name}.sql.should == 'SELECT * FROM test ORDER BY foo ASC, name DESC'
+    @dataset.reverse_order(Sequel.desc(:foo)){name}.sql.should == 'SELECT * FROM test ORDER BY foo ASC, name DESC'
+  end
 end
 
 describe "Dataset#limit" do
@@ -1620,6 +1629,12 @@ describe "Dataset#limit" do
     @dataset.limit(6, Sequel.function(:a) - 1).sql.should == 'SELECT * FROM test LIMIT 6 OFFSET (a() - 1)'
   end
   
+  specify "should be able to reset limit and offset with nil values" do
+    @dataset.limit(6).limit(nil).sql.should == 'SELECT * FROM test'
+    @dataset.limit(6, 1).limit(nil).sql.should == 'SELECT * FROM test OFFSET 1'
+    @dataset.limit(6, 1).limit(nil, nil).sql.should == 'SELECT * FROM test'
+  end
+  
   specify "should work with fixed sql datasets" do
     @dataset.opts[:sql] = 'select * from cccc'
     @dataset.limit(6, 10).sql.should == 'SELECT * FROM (select * from cccc) AS t1 LIMIT 6 OFFSET 10'

data/spec/core/expression_filters_spec.rb

@@ -551,8 +551,8 @@ describe "Sequel core extension replacements" do
     Sequel.expr({1=>2}).should be_a_kind_of(Sequel::SQL::BooleanExpression)
     Sequel.expr([[1, 2]]).should be_a_kind_of(Sequel::SQL::BooleanExpression)
     Sequel.expr([1]).should be_a_kind_of(Sequel::SQL::Wrapper)
-    Sequel.expr{|o| o.should be_a_kind_of(Sequel::SQL::VirtualRow)}
-    Sequel.expr{self.should be_a_kind_of(Sequel::SQL::VirtualRow)}
+    Sequel.expr{|o| o.a}.should be_a_kind_of(Sequel::SQL::Identifier)
+    Sequel.expr{a}.should be_a_kind_of(Sequel::SQL::Identifier)
     Sequel.expr(:a).should be_a_kind_of(Sequel::SQL::Identifier)
     Sequel.expr(:a__b).should be_a_kind_of(Sequel::SQL::QualifiedIdentifier)
     Sequel.expr(:a___c).should be_a_kind_of(Sequel::SQL::AliasedExpression)
@@ -966,3 +966,41 @@ describe "Sequel.recursive_map" do
     Sequel.recursive_map([[nil]], proc{|s| s.to_i}).should == [[nil]]
   end
 end
+
+describe "Sequel.delay" do
+  before do
+    @o = Class.new do
+      def a
+        @a ||= 0
+        @a += 1
+      end
+      def _a
+        @a
+      end
+
+      attr_accessor :b
+    end.new
+  end
+
+  specify "should delay calling the block until literalization" do
+    ds = Sequel.mock[:b].where(:a=>Sequel.delay{@o.a})
+    @o._a.should be_nil
+    ds.sql.should == "SELECT * FROM b WHERE (a = 1)"
+    @o._a.should == 1
+    ds.sql.should == "SELECT * FROM b WHERE (a = 2)"
+    @o._a.should == 2
+  end
+
+  specify "should have the condition specifier handling respect delayed evaluations" do
+    ds = Sequel.mock[:b].where(:a=>Sequel.delay{@o.b})
+    ds.sql.should == "SELECT * FROM b WHERE (a IS NULL)"
+    @o.b = 1
+    ds.sql.should == "SELECT * FROM b WHERE (a = 1)"
+    @o.b = [1, 2]
+    ds.sql.should == "SELECT * FROM b WHERE (a IN (1, 2))"
+  end
+
+  specify "should raise if called without a block" do
+    proc{Sequel.delay}.should raise_error(Sequel::Error)
+  end
+end

data/spec/extensions/connection_validator_spec.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+shared_examples_for "Sequel::ConnectionValidator" do  
+  before do
+    @db.extend(Module.new do
+      def disconnect_connection(conn)
+        @sqls << 'disconnect'
+      end
+      def valid_connection?(conn)
+        super
+        conn.valid
+      end
+      def connect(server)
+        conn = super
+        conn.extend(Module.new do
+          attr_accessor :valid
+        end)
+        conn.valid = true
+        conn
+      end
+    end)
+    @db.extension(:connection_validator)
+  end
+
+  it "should still allow new connections" do
+    @db.synchronize{|c| c}.should be_a_kind_of(Sequel::Mock::Connection)
+  end
+
+  it "should only validate if connection idle longer than timeout" do
+    c1 = @db.synchronize{|c| c}
+    @db.sqls.should == []
+    @db.synchronize{|c| c}.should equal(c1)
+    @db.sqls.should == []
+    @db.pool.connection_validation_timeout = -1
+    @db.synchronize{|c| c}.should equal(c1)
+    @db.sqls.should == ['SELECT NULL']
+    @db.pool.connection_validation_timeout = 1
+    @db.synchronize{|c| c}.should equal(c1)
+    @db.sqls.should == []
+    @db.synchronize{|c| c}.should equal(c1)
+    @db.sqls.should == []
+  end
+
+  it "should disconnect connection if not valid" do
+    c1 = @db.synchronize{|c| c}
+    @db.sqls.should == []
+    c1.valid = false
+    @db.pool.connection_validation_timeout = -1
+    c2 = @db.synchronize{|c| c}
+    @db.sqls.should == ['SELECT NULL', 'disconnect']
+    c2.should_not equal(c1)
+  end
+
+  it "should disconnect multiple connections repeatedly if they are not valid" do
+    q, q1 = Queue.new, Queue.new
+    c1 = nil
+    c2 = nil
+    @db.pool.connection_validation_timeout = -1
+    @db.synchronize do |c|
+      Thread.new do
+        @db.synchronize do |cc|
+          c2 = cc
+        end
+        q1.pop
+        q.push nil
+      end
+      q1.push nil
+      q.pop
+      c1 = c
+    end
+    c1.valid = false
+    c2.valid = false
+
+    c3 = @db.synchronize{|c| c}
+    @db.sqls.should == ['SELECT NULL', 'disconnect', 'SELECT NULL', 'disconnect']
+    c3.should_not equal(c1)
+    c3.should_not equal(c2)
+  end
+
+  it "should not leak connection references" do
+    c1 = @db.synchronize do |c|
+      @db.pool.instance_variable_get(:@connection_timestamps).should == {}
+      c
+    end
+    @db.pool.instance_variable_get(:@connection_timestamps).should have_key(c1)
+
+    c1.valid = false
+    @db.pool.connection_validation_timeout = -1
+    c2 = @db.synchronize do |c|
+      @db.pool.instance_variable_get(:@connection_timestamps).should == {}
+      c
+    end
+    c2.should_not equal(c1)
+    @db.pool.instance_variable_get(:@connection_timestamps).should_not have_key(c1)
+    @db.pool.instance_variable_get(:@connection_timestamps).should have_key(c2)
+  end
+
+  it "should handle case where determining validity requires a connection" do
+    @db.meta_def(:valid_connection?){|c| synchronize{}; true}
+    @db.pool.connection_validation_timeout = -1
+    c1 = @db.synchronize{|c| c}
+    @db.synchronize{|c| c}.should equal(c1)
+  end
+end
+
+describe "Sequel::ConnectionValidator with threaded pool" do
+  before do
+    @db = Sequel.mock
+  end
+  it_should_behave_like "Sequel::ConnectionValidator"
+end
+describe "Sequel::ConnectionValidator with sharded threaded pool" do
+  before do
+    @db = Sequel.mock(:servers=>{})
+  end
+  it_should_behave_like "Sequel::ConnectionValidator"
+end
+

data/spec/extensions/pg_array_spec.rb

@@ -231,6 +231,10 @@ describe "pg_array extension" do
     proc{@db.typecast_value(:integer_array, {})}.should raise_error(Sequel::InvalidValue)
   end
 
+  it "should support SQL::AliasMethods" do
+    @db.select(Sequel.pg_array([1], :integer).as(:col1)).sql.should == 'SELECT ARRAY[1]::integer[] AS col1'
+  end
+
   it "should support registering custom array types" do
     Sequel::Postgres::PGArray.register('foo')
     @db.typecast_value(:foo_array, []).should be_a_kind_of(Sequel::Postgres::PGArray)

data/spec/extensions/single_table_inheritance_spec.rb

@@ -181,5 +181,47 @@ describe Sequel::Model, "#sti_key" do
       proc{StiTest2.dataset.row_proc.call(:kind=>1)}.should raise_error(Sequel::Error)
       proc{StiTest2.dataset.row_proc.call(:kind=>2)}.should raise_error(Sequel::Error)
     end
+
+    it "should work with non-bijective mappings" do
+      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{0=>'StiTest3', 1=>'StiTest3', 2=>'StiTest4'}
+      class ::StiTest3 < ::StiTest2; end
+      class ::StiTest4 < ::StiTest2; end
+      StiTest2.dataset.row_proc.call(:kind=>0).should be_a_instance_of(StiTest3)
+      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.create.kind.should == 1
+      StiTest4.create.kind.should == 2
+    end
+
+    it "should work with non-bijective mappings and key map procs" do
+      StiTest2.plugin :single_table_inheritance, :kind,
+        :key_map=>proc{|model| model.to_s == 'StiTest4' ? 2 : [0,1] }
+      class ::StiTest3 < ::StiTest2; end
+      class ::StiTest4 < ::StiTest2; end
+
+      StiTest2.dataset.sql.should == "SELECT * FROM sti_test2s"
+      StiTest3.dataset.sql.should == "SELECT * FROM sti_test2s WHERE (sti_test2s.kind IN (0, 1))"
+      StiTest4.dataset.sql.should == "SELECT * FROM sti_test2s WHERE (sti_test2s.kind IN (2))"
+    end
+
+    it "should create correct sql with non-bijective mappings" do
+      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{0=>'StiTest3', 1=>'StiTest3', 2=>'StiTest4'}
+      class ::StiTest3 < ::StiTest2; end
+      class ::StiTest4 < ::StiTest2; end
+    
+      StiTest2.dataset.sql.should == "SELECT * FROM sti_test2s"
+      StiTest3.dataset.sql.should == "SELECT * FROM sti_test2s WHERE (sti_test2s.kind IN (0, 1))"
+    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
+      class ::StiTest4 < ::StiTest2; end
+
+      StiTest3.create.kind.should == 'stitest3'
+      StiTest4.create.kind.should == 'stitest4'
+    end
+
   end
 end

data/spec/extensions/touch_spec.rb

@@ -110,6 +110,46 @@ describe "Touch plugin" do
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
   end
 
+  specify "should be able to touch many_to_one associations" do
+    @Album.plugin :touch, :associations=>:artist
+    @Album.load(:id=>3, :artist_id=>4).touch
+    MODEL_DB.sqls.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 3)",
+      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 4)"]
+  end
+
+  specify "should be able to touch many_to_one associations" do
+    @Artist.one_to_one :album, :class=>@Album, :key=>:artist_id
+    @Artist.plugin :touch, :associations=>:album
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should be able to touch many_to_many associations" do
+    @Artist.many_to_many :albums, :class=>@Album, :left_key=>:artist_id, :join_table=>:aa
+    @Artist.plugin :touch, :associations=>:albums
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "SELECT albums.* FROM albums INNER JOIN aa ON ((aa.album_id = albums.id) AND (aa.artist_id = 1))",
+      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should be able to touch many_through_many associations" do
+    @Artist.plugin :many_through_many
+    @Artist.many_through_many :albums, [[:aa, :artist_id, :album_id]], :class=>@Album
+    @Artist.plugin :touch, :associations=>:albums
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "SELECT albums.* FROM albums INNER JOIN aa ON ((aa.album_id = albums.id) AND (aa.artist_id = 1))",
+      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should handle touching many_to_one associations with no associated object" do
+    @Album.plugin :touch, :associations=>:artist
+    @Album.load(:id=>3, :artist_id=>nil).touch
+    MODEL_DB.sqls.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 3)"]
+  end
+
   specify "should not update a column that doesn't exist" do
     @Album.plugin :touch, :column=>:x
     a = @Album.load(:id=>1)

data/spec/extensions/validation_class_methods_spec.rb

@@ -578,7 +578,7 @@ describe Sequel::Model do
   specify "should validate uniqueness_of with allow_missing => true" do
     @c.validates_uniqueness_of :value, :allow_missing => true
     @m.should be_valid
-    @m.value = nil
+    @m.value = 1
     @m.should_not be_valid
   end
 end
@@ -858,6 +858,12 @@ describe Sequel::Model, "Validations" do
     @user = User.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
     @user.errors.full_messages.should == []
+
+    User.db.sqls
+    @user = User.new(:password => "anothertest")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+    User.db.sqls.should == []
   end
   
   it "should validate the uniqueness of multiple columns" do
@@ -907,6 +913,18 @@ describe Sequel::Model, "Validations" do
     @user = User.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
     @user.errors.full_messages.should == []
+
+    User.db.sqls
+    @user = User.new(:password => "anothertest")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+    @user = User.new(:username => "0records")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+    @user = User.new
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+    User.db.sqls.should == []
   end
   
   it "should have a validates block that contains multiple validations" do

data/spec/extensions/validation_helpers_spec.rb

@@ -331,6 +331,11 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @user = @c.load(:id=>3, :username => "0records", :password => "anothertest")
     @user.should be_valid
 
+    MODEL_DB.sqls
+    @user = @c.new(:password => "anothertest")
+    @user.should be_valid
+    MODEL_DB.sqls.should == []
+
     @user = @c.new(:username => "1record", :password => "anothertest")
     @user.should_not be_valid
     @user.errors.full_messages.should == ['username is already taken']
@@ -369,6 +374,18 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @user = @c.load(:id=>3, :username => "0records", :password => "anothertest")
     @user.should be_valid
 
+    MODEL_DB.sqls
+    @user = @c.new(:password => "anothertest")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+    @user = @c.new(:username => "0records")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+    @user = @c.new
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+    MODEL_DB.sqls.should == []
+
     @user = @c.new(:username => "1record", :password => "anothertest")
     @user.should_not be_valid
     @user.errors.full_messages.should == ['username and password is already taken']

data/spec/integration/database_test.rb

@@ -35,4 +35,18 @@ describe Sequel::Database do
   specify "should not have the connection pool swallow non-StandardError based exceptions" do
     proc{INTEGRATION_DB.pool.hold{raise Interrupt, "test"}}.should raise_error(Interrupt)
   end
+
+  specify "should be able to disconnect connections more than once without exceptions" do
+    conn = INTEGRATION_DB.synchronize{|c| c}
+    INTEGRATION_DB.disconnect
+    INTEGRATION_DB.disconnect_connection(conn)
+    INTEGRATION_DB.disconnect_connection(conn)
+  end
+
+  cspecify "should provide ability to check connections for validity", [:do, :postgres] do
+    conn = INTEGRATION_DB.synchronize{|c| c}
+    INTEGRATION_DB.valid_connection?(conn).should be_true
+    INTEGRATION_DB.disconnect
+    INTEGRATION_DB.valid_connection?(conn).should be_false
+  end
 end

data/spec/integration/dataset_test.rb

@@ -717,19 +717,19 @@ describe Sequel::SQL::Constants do
   cspecify "should have working CURRENT_TIME", [:do, :mysql], [:jdbc, :sqlite], [:mysql2] do
     @db.create_table!(:constants){Time :t, :only_time=>true}
     @ds.insert(:t=>Sequel::CURRENT_TIME)
-    (Time.now - @c[@ds.get(:t)]).should be_within(2).of(0)
+    (Time.now - @c[@ds.get(:t)]).should be_within(60).of(0)
   end
 
   cspecify "should have working CURRENT_TIMESTAMP", [:jdbc, :sqlite], [:swift] do
     @db.create_table!(:constants){DateTime :ts}
     @ds.insert(:ts=>Sequel::CURRENT_TIMESTAMP)
-    (Time.now - @c[@ds.get(:ts)]).should be_within(2).of(0)
+    (Time.now - @c[@ds.get(:ts)]).should be_within(60).of(0)
   end
 
   cspecify "should have working CURRENT_TIMESTAMP when used as a column default", [:jdbc, :sqlite], [:swift] do
     @db.create_table!(:constants){DateTime :ts, :default=>Sequel::CURRENT_TIMESTAMP}
     @ds.insert
-    (Time.now - @c[@ds.get(:ts)]).should be_within(2).of(0)
+    (Time.now - @c[@ds.get(:ts)]).should be_within(60).of(0)
   end
 end