sequel 5.8.0 → 5.9.0

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -96,7 +96,7 @@ module Sequel
           name = opts[:name]
           if (!associations.include?(name) || dynamic_opts[:eager_reload]) && opts[:allow_eager] != false && retrieved_by && !frozen? && !dynamic_opts[:callback] && !dynamic_opts[:reload]
             begin
-              retrieved_by.send(:eager_load, retrieved_with.reject(&:frozen?), name=>dynamic_opts[:eager] || {})
+              retrieved_by.send(:eager_load, retrieved_with.reject(&:frozen?), name=>dynamic_opts[:eager] || OPTS)
             rescue Sequel::UndefinedAssociation
               # This can happen if class table inheritance is used and the association
               # is only defined in a subclass.  This particular instance can use the

data/lib/sequel/plugins/tree.rb

@@ -38,10 +38,10 @@ module Sequel
           @tree_order = opts[:order]
         end
         
-        par = opts.merge(opts.fetch(:parent, {}))
+        par = opts.merge(opts.fetch(:parent, OPTS))
         parent = par.fetch(:name, :parent)
         
-        chi = opts.merge(opts.fetch(:children, {}))
+        chi = opts.merge(opts.fetch(:children, OPTS))
         children = chi.fetch(:name, :children)
 
         par[:reciprocal] = children

data/lib/sequel/plugins/validation_class_methods.rb

@@ -419,7 +419,7 @@ module Sequel
         # an empty hash is returned This method is useful when writing methods that
         # take an options hash as the last parameter.
         def extract_options!(array)
-          array.last.is_a?(Hash) ? array.pop : {}
+          array.last.is_a?(Hash) ? array.pop : OPTS
         end
 
         # Add the validation reflection to the class's validations.

data/lib/sequel/sql.rb

@@ -1366,7 +1366,7 @@ module Sequel
       end
 
       # Return a new function with an OVER clause (making it a window function).
-      # See {SQL::Window} for the list of options +over+ can receive.
+      # See Sequel::SQL::Window for the list of options +over+ can receive.
       #
       #   Sequel.function(:row_number).over(partition: :col) # row_number() OVER (PARTITION BY col)
       def over(window=OPTS)
@@ -1703,7 +1703,7 @@ module Sequel
       #   StringExpression.like(:a, 'a%', /^a/i) # (("a" LIKE 'a%' ESCAPE '\') OR ("a" ~* '^a'))
       def self.like(l, *ces)
         l, lre, lci = like_element(l)
-        lci = (ces.last.is_a?(Hash) ? ces.pop : {})[:case_insensitive] ? true : lci
+        lci = (ces.last.is_a?(Hash) ? ces.pop : OPTS)[:case_insensitive] ? true : lci
         ces.map! do |ce|
           r, rre, rci = like_element(ce)
           BooleanExpression.new(LIKE_MAP[[lre||rre, lci||rci]], l, r)

data/lib/sequel/version.rb

@@ -5,13 +5,16 @@ module Sequel
   MAJOR = 5
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 8
+  MINOR = 9
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
   VERSION = [MAJOR, MINOR, TINY].join('.').freeze
+
+  # The version of Sequel you are using, as a number (2.11.0 -> 20110)
+  VERSION_NUMBER = MAJOR*10000 + MINOR*10 + TINY
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
   def self.version

data/spec/adapters/mysql_spec.rb

@@ -69,6 +69,12 @@ describe "MySQL", '#create_table' do
     @db.set_column_type :dolls, :a, Integer, :auto_increment=>true
     @db.schema(:dolls).first.last[:auto_increment].must_equal true
   end
+
+  it "should create generated column" do
+    skip("generated columns not supported, skipping test") unless @db.supports_generated_columns?
+    @db.create_table(:dolls){String :a; String :b, generated_always_as: Sequel.function(:CONCAT, :a, 'plus')}
+    @db.schema(:dolls)[1][1][:generated].must_equal true
+  end
 end
 
 if [:mysql, :mysql2].include?(DB.adapter_scheme)
@@ -203,6 +209,13 @@ describe "A MySQL dataset" do
     ps.call(:v => 1, :n => 'b')
     ds.all.must_equal [{:value=>1, :name=>'b'}]
   end
+
+  it "should support generated columns" do
+    skip("generated columns not supported, skipping test") unless DB.supports_generated_columns?
+    DB.alter_table(:items) {add_column :b, String, :generated_always_as => Sequel.function(:CONCAT, :name, 'plus')}
+    @d.insert(name: 'hello')
+    @d.first[:b].must_equal 'helloplus'
+  end
 end
 
 describe "Dataset#distinct" do
@@ -219,6 +232,8 @@ describe "Dataset#distinct" do
   end
 
   it "#distinct with arguments should return results distinct on those arguments" do
+    skip("ONLY_FULL_GROUP_BY sql_mode set, skipping DISTINCT ON emulation test") if @db.get(Sequel.lit '@@sql_mode').include?('ONLY_FULL_GROUP_BY')
+
     @ds.insert(20, 10)
     @ds.insert(30, 10)
     @ds.order(:b, :a).distinct.map(:a).must_equal [20, 30]
@@ -501,6 +516,15 @@ describe "A MySQL database" do
     @db << 'DELETE FROM items'
     @db[:items].first.must_be_nil
   end
+
+  it "should have schema handle generated columns" do
+    skip("generated columns not supported, skipping test") unless @db.supports_generated_columns?
+    @db.create_table(:items) {String :a}
+    @db.alter_table(:items){add_column :b, String, :generated_always_as=>Sequel.function(:CONCAT, :a, 'plus'), :generated_type=>:stored, :unique=>true}
+    @db.schema(:items)[1][1][:generated].must_equal true
+    @db.alter_table(:items){add_column :c, String, :generated_always_as=>Sequel.function(:CONCAT, :a, 'minus'), :generated_type=>:virtual}
+    @db.schema(:items)[2][1][:generated].must_equal true
+  end
 end  
 
 # Socket tests should only be run if the MySQL server is on localhost

data/spec/adapters/postgres_spec.rb

@@ -2186,10 +2186,10 @@ describe 'PostgreSQL array handling' do
       column :n, 'numeric[]'
     end
     @tp.call.must_equal [:decimal_array]
-    @ds.insert(Sequel.pg_array([BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')], :numeric))
+    @ds.insert(Sequel.pg_array([BigDecimal('1.000000000000000000001'), nil, BigDecimal('1')], :numeric))
     @ds.count.must_equal 1
     rs = @ds.all
-    rs.must_equal [{:n=>[BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')]}]
+    rs.must_equal [{:n=>[BigDecimal('1.000000000000000000001'), nil, BigDecimal('1')]}]
     rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
     rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
     @ds.delete
@@ -2197,9 +2197,9 @@ describe 'PostgreSQL array handling' do
     @ds.all.must_equal rs
 
     @ds.delete
-    @ds.insert(Sequel.pg_array([[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]], :numeric))
+    @ds.insert(Sequel.pg_array([[BigDecimal('1.0000000000000000000000000000001'), nil], [nil, BigDecimal('1')]], :numeric))
     rs = @ds.all
-    rs.must_equal [{:n=>[[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]]}]
+    rs.must_equal [{:n=>[[BigDecimal('1.0000000000000000000000000000001'), nil], [nil, BigDecimal('1')]]}]
     rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
     rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
     @ds.delete
@@ -2469,11 +2469,11 @@ describe 'PostgreSQL array handling' do
       column :t, 'text[]'
     end
     c = Class.new(Sequel::Model(@db[:items]))
-    h = {:i=>[1,2, nil], :f=>[[1, 2.5], [3, 4.5]], :d=>[1, BigDecimal.new('1.000000000000000000001')], :t=>[%w'a b c', ['NULL', nil, '1']]}
+    h = {:i=>[1,2, nil], :f=>[[1, 2.5], [3, 4.5]], :d=>[1, BigDecimal('1.000000000000000000001')], :t=>[%w'a b c', ['NULL', nil, '1']]}
     o = c.create(h)
     o.i.must_equal [1, 2, nil]
     o.f.must_equal [[1, 2.5], [3, 4.5]]
-    o.d.must_equal [BigDecimal.new('1'), BigDecimal.new('1.000000000000000000001')]
+    o.d.must_equal [BigDecimal('1'), BigDecimal('1.000000000000000000001')]
     o.t.must_equal [%w'a b c', ['NULL', nil, '1']]
     c.where(:i=>o.i, :f=>o.f, :d=>o.d, :t=>o.t).all.must_equal [o]
     o2 = c.new(h)
@@ -2487,10 +2487,10 @@ describe 'PostgreSQL array handling' do
       column :t, 'varchar[]'
     end
     c = Class.new(Sequel::Model(@db[:items]))
-    o = c.create(:i=>[1,2, nil], :f=>[[1, 2.5], [3, 4.5]], :d=>[1, BigDecimal.new('1.000000000000000000001')], :t=>[%w'a b c', ['NULL', nil, '1']])
+    o = c.create(:i=>[1,2, nil], :f=>[[1, 2.5], [3, 4.5]], :d=>[1, BigDecimal('1.000000000000000000001')], :t=>[%w'a b c', ['NULL', nil, '1']])
     o.i.must_equal [1, 2, nil]
     o.f.must_equal [[1, 2.5], [3, 4.5]]
-    o.d.must_equal [BigDecimal.new('1'), BigDecimal.new('1.000000000000000000001')]
+    o.d.must_equal [BigDecimal('1'), BigDecimal('1.000000000000000000001')]
     o.t.must_equal [%w'a b c', ['NULL', nil, '1']]
     c.where(:i=>o.i, :f=>o.f, :d=>o.d, :t=>o.t).all.must_equal [o]
     o2 = c.new(h)
@@ -3225,7 +3225,7 @@ describe 'PostgreSQL range types' do
     @db = DB
     @ds = @db[:items]
     @map = {:i4=>'int4range', :i8=>'int8range', :n=>'numrange', :d=>'daterange', :t=>'tsrange', :tz=>'tstzrange'}
-    @r = {:i4=>1...2, :i8=>2...3, :n=>BigDecimal.new('1.0')..BigDecimal.new('2.0'), :d=>Date.today...(Date.today+1), :t=>Time.local(2011, 1)..Time.local(2011, 2), :tz=>Time.local(2011, 1)..Time.local(2011, 2)}
+    @r = {:i4=>1...2, :i8=>2...3, :n=>BigDecimal('1.0')..BigDecimal('2.0'), :d=>Date.today...(Date.today+1), :t=>Time.local(2011, 1)..Time.local(2011, 2), :tz=>Time.local(2011, 1)..Time.local(2011, 2)}
     @ra = {}
     @pgr = {}
     @pgra = {}

data/spec/adapters/sqlite_spec.rb

@@ -77,12 +77,12 @@ describe "An SQLite database" do
   it "should handle and return BigDecimal values for numeric columns" do
     DB.create_table!(:fk){numeric :d}
     d = DB[:fk]
-    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'))
+    d.insert(:d=>BigDecimal('80.0'))
+    d.insert(:d=>BigDecimal('NaN'))
+    d.insert(:d=>BigDecimal('Infinity'))
+    d.insert(:d=>BigDecimal('-Infinity'))
     ds = d.all
-    ds.shift.must_equal(:d=>BigDecimal.new('80.0'))
+    ds.shift.must_equal(:d=>BigDecimal('80.0'))
     ds.map{|x| x[:d].to_s}.must_equal %w'NaN Infinity -Infinity'
     DB
   end
@@ -153,19 +153,19 @@ describe "SQLite type conversion" do
   it "should handle integers/floats/strings/decimals in numeric/decimal columns" do
     @db.create_table(:items){Numeric :a}
     @db[:items].insert(100)
-    @db[:items].select_map(:a).must_equal [BigDecimal.new('100')]
+    @db[:items].select_map(:a).must_equal [BigDecimal('100')]
     @db[:items].get(:a).must_be_kind_of(BigDecimal)
 
     @db[:items].update(:a=>100.1)
-    @db[:items].select_map(:a).must_equal [BigDecimal.new('100.1')]
+    @db[:items].select_map(:a).must_equal [BigDecimal('100.1')]
     @db[:items].get(:a).must_be_kind_of(BigDecimal)
 
     @db[:items].update(:a=>'100.1')
-    @db[:items].select_map(:a).must_equal [BigDecimal.new('100.1')]
+    @db[:items].select_map(:a).must_equal [BigDecimal('100.1')]
     @db[:items].get(:a).must_be_kind_of(BigDecimal)
 
-    @db[:items].update(:a=>BigDecimal.new('100.1'))
-    @db[:items].select_map(:a).must_equal [BigDecimal.new('100.1')]
+    @db[:items].update(:a=>BigDecimal('100.1'))
+    @db[:items].select_map(:a).must_equal [BigDecimal('100.1')]
     @db[:items].get(:a).must_be_kind_of(BigDecimal)
   end
 

data/spec/core/connection_pool_spec.rb

@@ -549,6 +549,28 @@ ThreadedConnectionPoolSpecs = shared_description do
     @pool.size.must_equal 0
     d.must_equal [2, 1, 3, 4]
   end
+
+
+  it "should handle dead threads with checked out connections" do
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>1))
+
+    skip = true
+    # Leave allocated connection to emulate dead thread with checked out connection
+    pool.define_singleton_method(:release){|*a| return if skip; super(*a)}
+    Thread.new{pool.hold{Thread.current.kill}}.join
+    skip = false
+
+    pool.allocated.wont_be :empty?
+    pool.available_connections.must_be :empty?
+
+    pool.hold{|c1| c1}
+    pool.allocated.must_be :empty?
+    pool.available_connections.wont_be :empty?
+
+    pool.disconnect
+    pool.allocated.must_be :empty?
+    pool.available_connections.must_be :empty?
+  end
 end
 
 describe "Threaded Unsharded Connection Pool" do

data/spec/core/database_spec.rb

@@ -2167,7 +2167,7 @@ describe "Database#typecast_value" do
     [1.0, 1, '1.0', BigDecimal('1.0')].each do |i|
       v = @db.typecast_value(:decimal, i)
       v.must_be_kind_of(BigDecimal)
-      v.must_equal BigDecimal.new('1.0')
+      v.must_equal BigDecimal('1.0')
     end
   end
 
@@ -2426,8 +2426,8 @@ describe "Database#column_schema_to_ruby_default" do
     p[1.0, :float].must_equal 1.0
     p['1.0', :float].must_equal 1.0
     p['-1.0', :float].must_equal(-1.0)
-    p['1.0', :decimal].must_equal BigDecimal.new('1.0')
-    p['-1.0', :decimal].must_equal BigDecimal.new('-1.0')
+    p['1.0', :decimal].must_equal BigDecimal('1.0')
+    p['-1.0', :decimal].must_equal BigDecimal('-1.0')
     p[true, :boolean].must_equal true
     p[false, :boolean].must_equal false
     p['1', :boolean].must_equal true
@@ -2463,7 +2463,7 @@ describe "Database#column_schema_to_ruby_default" do
     p["'a'::bpchar", :string].must_equal "a"
     p["(-1)", :integer].must_equal(-1)
     p["(-1.0)", :float].must_equal(-1.0)
-    p['(-1.0)', :decimal].must_equal BigDecimal.new('-1.0')
+    p['(-1.0)', :decimal].must_equal BigDecimal('-1.0')
     p["'a'::bytea", :blob].must_equal Sequel.blob('a')
     p["'a'::bytea", :blob].must_be_kind_of(Sequel::SQL::Blob)
     p["'2009-10-29'::date", :date].must_equal Date.new(2009,10,29)
@@ -2475,7 +2475,7 @@ describe "Database#column_schema_to_ruby_default" do
     p["a", :string].must_equal "a"
     p["NULL", :string].must_equal "NULL"
     p["-1", :float].must_equal(-1.0)
-    p['-1', :decimal].must_equal BigDecimal.new('-1.0')
+    p['-1', :decimal].must_equal BigDecimal('-1.0')
     p["2009-10-29", :date].must_equal Date.new(2009,10,29)
     p["2009-10-29 10:20:30", :datetime].must_equal DateTime.parse('2009-10-29 10:20:30')
     p["10:20:30", :time].must_equal Time.parse('10:20:30')
@@ -2486,7 +2486,7 @@ describe "Database#column_schema_to_ruby_default" do
     p["(N'a')", :string].must_equal "a"
     p["((-12))", :integer].must_equal(-12)
     p["((12.1))", :float].must_equal 12.1
-    p["((-12.1))", :decimal].must_equal BigDecimal.new('-12.1')
+    p["((-12.1))", :decimal].must_equal BigDecimal('-12.1')
   end
 end
 

data/spec/core/dataset_spec.rb

@@ -623,7 +623,7 @@ describe "Dataset#where" do
   it "should raise an error if an numeric is used" do
     proc{@dataset.filter(1)}.must_raise(Sequel::Error)
     proc{@dataset.filter(1.0)}.must_raise(Sequel::Error)
-    proc{@dataset.filter(BigDecimal.new('1.0'))}.must_raise(Sequel::Error)
+    proc{@dataset.filter(BigDecimal('1.0'))}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if a NumericExpression or StringExpression is used" do
@@ -1082,10 +1082,10 @@ describe "Dataset#literal" do
   end
 
   it "should literalize BigDecimal instances correctly" do
-    @dataset.literal(BigDecimal.new("80")).must_equal "80.0"
-    @dataset.literal(BigDecimal.new("NaN")).must_equal "'NaN'"
-    @dataset.literal(BigDecimal.new("Infinity")).must_equal "'Infinity'"
-    @dataset.literal(BigDecimal.new("-Infinity")).must_equal "'-Infinity'"
+    @dataset.literal(BigDecimal("80")).must_equal "80.0"
+    @dataset.literal(BigDecimal("NaN")).must_equal "'NaN'"
+    @dataset.literal(BigDecimal("Infinity")).must_equal "'Infinity'"
+    @dataset.literal(BigDecimal("-Infinity")).must_equal "'-Infinity'"
   end
 
   it "should literalize PlaceholderLiteralStrings correctly" do
@@ -3799,6 +3799,17 @@ describe "Dataset#with_sql_*" do
     @ds.with_sql_single_value('SELECT * FROM foo')
     @ds.columns.must_equal [:x]
   end
+
+  it "#_with_sql_dataset (private) should return a clone that doesn't use separate dataset for columns" do
+    @ds = @ds.with_extend{def fetch_rows(sql) self.columns = [:id]; super end}
+    @ds.send(:cache_set, :_columns, [:foo])
+    ds = @ds.send(:_with_sql_dataset)
+    ds.must_be_same_as ds.send(:_with_sql_dataset)
+    ds.with_sql_first('SELECT * FROM foo').must_equal(:id=>1)
+    ds.columns.must_equal [:id]
+    @ds.with_sql_first('SELECT * FROM foo').must_equal(:id=>1)
+    @ds.columns.must_equal [:foo]
+  end
 end
 
 describe "Dataset prepared statements and bound variables " do

data/spec/core/expression_filters_spec.rb

@@ -186,7 +186,7 @@ describe "Blockless Ruby Filters" do
     @d.lit(1 + Sequel.expr(:x)).must_equal '(1 + x)'
     @d.lit(2**65 - Sequel.+(:x, 1)).must_equal "(#{2**65} - (x + 1))"
     @d.lit(1.0 / Sequel.function(:x)).must_equal '(1.0 / x())'
-    @d.lit(BigDecimal.new('1.0') * Sequel[:a][:y]).must_equal '(1.0 * a.y)'
+    @d.lit(BigDecimal('1.0') * Sequel[:a][:y]).must_equal '(1.0 * a.y)'
     @d.lit(2 ** Sequel.cast(:x, Integer)).must_equal 'power(2, CAST(x AS integer))'
     @d.lit(1 + Sequel.lit('x')).must_equal '(1 + x)'
     @d.lit(1 + Sequel.lit('?', :x)).must_equal '(1 + x)'

data/spec/core/schema_spec.rb

@@ -1679,7 +1679,7 @@ describe "Schema Parser" do
     sch = @db.schema(:x)
     sch.must_equal [[:a, {:db_type=>"x", :ruby_default=>nil}], [:b, {:db_type=>"x", :ruby_default=>nil}]]
     sch[0][1][:db_type].must_be_same_as(sch[1][1][:db_type])
-  end if RUBY_VERSION >= '2.5'
+  end if RUBY_VERSION >= '2.5' && !defined?(JRUBY_VERSION)
 
   it "should set :auto_increment to true by default if unset and a single integer primary key is used" do
     @db.define_singleton_method(:schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer'}]]}

data/spec/core/version_spec.rb

@@ -4,4 +4,11 @@ describe "Sequel.version" do
   it "should be in the form X.Y.Z with all being numbers" do
     Sequel.version.must_match(/\A\d+\.\d+\.\d+\z/)
   end
+
+  it "MAJOR/MINOR/TINY/VERSION_NUMBER should be integers" do
+    Sequel::MAJOR.must_be_kind_of(Integer)
+    Sequel::MINOR.must_be_kind_of(Integer)
+    Sequel::TINY.must_be_kind_of(Integer)
+    Sequel::VERSION_NUMBER.must_be_kind_of(Integer)
+  end
 end

data/spec/extensions/connection_expiration_spec.rb

@@ -3,11 +3,12 @@ require_relative "spec_helper"
 connection_expiration_specs = shared_description do
   describe "connection expiration" do
     before do
-      @db.extend(Module.new do
+      @m = Module.new do
         def disconnect_connection(conn)
           @sqls << 'disconnect'
         end
-      end)
+      end
+      @db.extend @m
       @db.extension(:connection_expiration)
       @db.pool.connection_expiration_timeout = 2
     end
@@ -21,6 +22,23 @@ connection_expiration_specs = shared_description do
       @db.pool.connection_expiration_timeout.must_equal 2
     end
 
+    it "should handle Database#disconnect calls while the connection is checked out" do
+      @db.synchronize{|c| @db.disconnect}
+    end
+
+    it "should handle disconnected connections" do
+      proc{@db.synchronize{|c| raise Sequel::DatabaseDisconnectError}}.must_raise Sequel::DatabaseDisconnectError
+      @db.sqls.must_equal ['disconnect']
+    end
+
+    it "should handle :connection_handling => :disconnect setting" do
+      @db = Sequel.mock(@db.opts.merge(:connection_handling => :disconnect))
+      @db.extend @m
+      @db.extension(:connection_expiration)
+      @db.synchronize{}
+      @db.sqls.must_equal ['disconnect']
+    end
+
     it "should only expire if older than timeout" do
       c1 = @db.synchronize{|c| c}
       @db.sqls.must_equal []

data/spec/extensions/connection_validator_spec.rb

@@ -3,7 +3,7 @@ require_relative "spec_helper"
 connection_validator_specs = shared_description do
   describe "connection validator" do
     before do
-      @db.extend(Module.new do
+      @m = Module.new do
         def disconnect_connection(conn)
           @sqls << 'disconnect'
         end
@@ -19,7 +19,8 @@ connection_validator_specs = shared_description do
           conn.valid = true
           conn
         end
-      end)
+      end
+      @db.extend @m
       @db.extension(:connection_validator)
     end
 
@@ -52,6 +53,23 @@ connection_validator_specs = shared_description do
       c2.wont_be_same_as(c1)
     end
 
+    it "should handle Database#disconnect calls while the connection is checked out" do
+      @db.synchronize{|c| @db.disconnect}
+    end
+
+    it "should handle disconnected connections" do
+      proc{@db.synchronize{|c| raise Sequel::DatabaseDisconnectError}}.must_raise Sequel::DatabaseDisconnectError
+      @db.sqls.must_equal ['disconnect']
+    end
+
+    it "should handle :connection_handling => :disconnect setting" do
+      @db = Sequel.mock(@db.opts.merge(:connection_handling => :disconnect))
+      @db.extend @m
+      @db.extension(:connection_validator)
+      @db.synchronize{}
+      @db.sqls.must_equal ['disconnect']
+    end
+
     it "should disconnect multiple connections repeatedly if they are not valid" do
       q, q1 = Queue.new, Queue.new
       c1 = nil
@@ -124,4 +142,3 @@ describe "Sequel::ConnectionValidator with sharded threaded pool" do
   end
   include connection_validator_specs
 end
-