sequel 5.23.0 → 5.28.0

data/spec/extensions/dirty_spec.rb

@@ -162,6 +162,39 @@ describe "Sequel::Plugins::Dirty" do
       @o.save
       @o.column_changes.must_equal({})
     end
+
+    it "should work with the typecast_on_load plugin" do
+      @c.instance_variable_set(:@db_schema, :initial=>{:type=>:integer})
+      @c.plugin :typecast_on_load, :initial
+      
+      @o = @c.call(:initial=>'1')
+      @o.column_changes.must_equal({})
+      @o.save
+      @o.previous_changes.must_equal({})
+    end
+
+    it "should have column_changes work with the typecast_on_load in after hooks" do
+      @c.instance_variable_set(:@db_schema, :initial=>{:type=>:integer})
+      @c.plugin :typecast_on_load, :initial
+      
+      @o = @c.new
+      @o.initial = 1
+      @o.column_changes.must_equal({:initial=>[nil, 1]})
+      column_changes_in_after_save = nil
+      @o.define_singleton_method(:after_save) do
+        column_changes_in_after_save = column_changes
+        super()
+      end
+      @db.fetch = {:initial=>1}
+      @o.save
+      column_changes_in_after_save.must_equal({:initial=>[nil, 1]})
+
+      @o.initial = 2
+      @o.column_changes.must_equal({:initial=>[1, 2]})
+      @o.save
+      column_changes_in_after_save.must_equal({:initial=>[1, 2]})
+      @o.previous_changes.must_equal({:initial=>[1, 2]})
+    end
   end
 
   describe "with existing instance" do

data/spec/extensions/exclude_or_null_spec.rb

@@ -0,0 +1,15 @@
+require_relative "spec_helper"
+
+describe "exclude_or_null extension" do
+  before do
+    @ds = Sequel.mock[:t].extension(:exclude_or_null)
+  end
+
+  it "should add condition where a is false or NULL" do
+    @ds.exclude_or_null(:a).sql.must_equal "SELECT * FROM t WHERE NOT coalesce(a, 'f')"
+  end
+
+  it "should not effect normal exclude" do
+    @ds.exclude(:a).sql.must_equal "SELECT * FROM t WHERE NOT a"
+  end
+end

data/spec/extensions/insert_conflict_spec.rb

@@ -74,4 +74,30 @@ describe "insert_conflict plugin" do
     model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o",
       "SELECT * FROM t WHERE (id = 2) LIMIT 1"]
   end
+
+  it "should work if the prepared_statements plugin is loaded before" do
+    db = Sequel.mock(:host=>'sqlite', :fetch=>{:id=>1, :s=>2}, :autoid=>1, :numrows=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model = Class.new(Sequel::Model)
+    model.dataset = db[:t]
+    model.columns :id, :s
+    model.plugin :prepared_statements
+    model.plugin :insert_conflict
+    db.sqls
+    model.create(:s=>'a').update(:s=>'b')
+    db.sqls.must_equal ["INSERT INTO t (s) VALUES ('a')", "SELECT * FROM t WHERE (id = 1) LIMIT 1", "UPDATE t SET s = 'b' WHERE (id = 1)"]
+  end
+
+  it "should work if the prepared_statements plugin is loaded after" do
+    db = Sequel.mock(:host=>'postgres', :fetch=>{:id=>1, :s=>2}, :autoid=>1, :numrows=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model = Class.new(Sequel::Model)
+    model.dataset = db[:t]
+    model.columns :id, :s
+    model.plugin :insert_conflict
+    model.plugin :prepared_statements
+    db.sqls
+    model.create(:s=>'a').update(:s=>'b')
+    db.sqls.must_equal ["INSERT INTO t (s) VALUES ('a') RETURNING *", "UPDATE t SET s = 'b' WHERE (id = 1)"]
+  end
 end

data/spec/extensions/nested_attributes_spec.rb

@@ -492,6 +492,54 @@ describe "NestedAttributes plugin" do
     @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 10)"]
   end
 
+  it "should raise a NoExistingObject error if object to be updated no longer exists, if the :require_modification=>true option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>true, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :name=>'L'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    proc{ar.save}.must_raise Sequel::NoExistingObject
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'L' WHERE (id = 10)"]
+  end
+
+  it "should not raise an Error if object to be updated no longer exists, if the :require_modification=>false option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>false, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :name=>'L'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    ar.save
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'L' WHERE (id = 10)"]
+  end
+
+  it "should raise a NoExistingObject error if object to be deleted no longer exists, if the :require_modification=>true option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>true, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    proc{ar.save}.must_raise Sequel::NoExistingObject
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
+  end
+
+  it "should not raise an Error if object to be deleted no longer exists, if the :require_modification=>false option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>false, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    ar.save
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
+  end
+
   it "should not attempt to validate nested attributes twice for one_to_many associations when creating them" do
     @Artist.nested_attributes :albums
     validated = []

data/spec/extensions/pg_array_ops_spec.rb

@@ -83,9 +83,9 @@ describe "Sequel::Postgres::ArrayOp" do
   end
 
   it "#to_string/join should use the array_to_string function" do
-    @db.literal(@a.to_string).must_equal "array_to_string(a, '', NULL)"
-    @db.literal(@a.join).must_equal "array_to_string(a, '', NULL)"
-    @db.literal(@a.join(':')).must_equal "array_to_string(a, ':', NULL)"
+    @db.literal(@a.to_string).must_equal "array_to_string(a, '')"
+    @db.literal(@a.join).must_equal "array_to_string(a, '')"
+    @db.literal(@a.join(':')).must_equal "array_to_string(a, ':')"
     @db.literal(@a.join(':', '*')).must_equal "array_to_string(a, ':', '*')"
   end
 

data/spec/extensions/pg_auto_constraint_validations_spec.rb

@@ -169,4 +169,41 @@ describe "pg_auto_constraint_validations plugin" do
     proc{o.update(:i=>12)}.must_raise Sequel::ValidationFailed
     o.errors.must_equal(:i=>['foo bar'])
   end
+
+  it "should handle dumping cached metadata and loading metadata from cache" do
+    cache_file = "spec/files/pgacv-spec-#{$$}.cache"
+    begin
+      @ds = @db[:items]
+      @ds.send(:columns=, [:id, :i])
+      @db.fetch = @metadata_results.dup
+      c = Sequel::Model(@ds)
+      def c.name; 'Foo' end
+      @db.sqls
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      @db.sqls.length.must_equal 5
+
+      o = c.new(:i=>12)
+      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
+      proc{o.save}.must_raise Sequel::ValidationFailed
+
+      c.dump_pg_auto_constraint_validations_cache
+
+      @db.fetch = []
+      c = Sequel::Model(@ds)
+      def c.name; 'Foo' end
+      @db.sqls
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      @db.sqls.must_be_empty
+
+      o = c.new(:i=>12)
+      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
+      proc{o.save}.must_raise Sequel::ValidationFailed
+    ensure
+      File.delete(cache_file) if File.file?(cache_file)
+    end
+  end
+
+  it "should raise error if attempting to dump cached metadata when not using caching" do
+    proc{@c.dump_pg_auto_constraint_validations_cache}.must_raise Sequel::Error
+  end
 end

data/spec/extensions/pg_json_ops_spec.rb

@@ -286,4 +286,71 @@ describe "Sequel::Postgres::JSONOp" do
   it "should allow transforming JSONBHash instances into ArrayOp instances" do
     @db.literal(Sequel.pg_jsonb('a'=>1).op['a']).must_equal "('{\"a\":1}'::jsonb -> 'a')"
   end
+
+  it "#path_exists should use the @? operator" do
+    @l[@jb.path_exists('$')].must_equal "(j @? '$')"
+  end
+
+  it "#path_exists result should be a boolean expression" do
+    @jb.path_exists('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_match should use the @@ operator" do
+    @l[@jb.path_match('$')].must_equal "(j @@ '$')"
+  end
+
+  it "#path_match result should be a boolean expression" do
+    @jb.path_match('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_exists! should use the jsonb_path_exists function" do
+    @l[@jb.path_exists!('$')].must_equal "jsonb_path_exists(j, '$')"
+    @l[@jb.path_exists!('$', '{"x":2}')].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}')"
+    @l[@jb.path_exists!('$', x: 2)].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}')"
+    @l[@jb.path_exists!('$', {x: 2}, true)].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_exists! result should be a boolean expression" do
+    @jb.path_exists!('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_match! should use the jsonb_path_match function" do
+    @l[@jb.path_match!('$')].must_equal "jsonb_path_match(j, '$')"
+    @l[@jb.path_match!('$', '{"x":2}')].must_equal "jsonb_path_match(j, '$', '{\"x\":2}')"
+    @l[@jb.path_match!('$', x: 2)].must_equal "jsonb_path_match(j, '$', '{\"x\":2}')"
+    @l[@jb.path_match!('$', {x: 2}, true)].must_equal "jsonb_path_match(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_match! result should be a boolean expression" do
+    @jb.path_match!('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_query should use the jsonb_path_query function" do
+    @l[@jb.path_query('$')].must_equal "jsonb_path_query(j, '$')"
+    @l[@jb.path_query('$', '{"x":2}')].must_equal "jsonb_path_query(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query('$', x: 2)].must_equal "jsonb_path_query(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query('$', {x: 2}, true)].must_equal "jsonb_path_query(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_query_array should use the jsonb_path_query_array function" do
+    @l[@jb.path_query_array('$')].must_equal "jsonb_path_query_array(j, '$')"
+    @l[@jb.path_query_array('$', '{"x":2}')].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_array('$', x: 2)].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_array('$', {x: 2}, true)].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_query_array result should be a JSONBOp" do
+    @l[@jb.path_query_array('$').path_query_array('$')].must_equal "jsonb_path_query_array(jsonb_path_query_array(j, '$'), '$')"
+  end
+
+  it "#path_query_first should use the jsonb_path_query_first function" do
+    @l[@jb.path_query_first('$')].must_equal "jsonb_path_query_first(j, '$')"
+    @l[@jb.path_query_first('$', '{"x":2}')].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_first('$', x: 2)].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_first('$', {x: 2}, true)].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_query_first result should be a JSONBOp" do
+    @l[@jb.path_query_first('$').path_query_first('$')].must_equal "jsonb_path_query_first(jsonb_path_query_first(j, '$'), '$')"
+  end
 end

data/spec/extensions/pg_range_spec.rb

@@ -52,13 +52,13 @@ describe "pg_range extension" do
   end
 
   it "should literalize endless Range instances to strings correctly" do
-    @db.literal(eval('1..')).must_equal "'[1,]'"
-    @db.literal(eval('1...')).must_equal "'[1,)'"
+    @db.literal(eval('(1..)')).must_equal "'[1,]'"
+    @db.literal(eval('(1...)')).must_equal "'[1,)'"
   end if endless_range_support
 
   it "should literalize startless Range instances to strings correctly" do
-    @db.literal(eval('..1')).must_equal "'[,1]'"
-    @db.literal(eval('...1')).must_equal "'[,1)'"
+    @db.literal(eval('(..1)')).must_equal "'[,1]'"
+    @db.literal(eval('(...1)')).must_equal "'[,1)'"
   end if startless_range_support
 
   it "should literalize startless, endless Range instances to strings correctly" do
@@ -90,13 +90,13 @@ describe "pg_range extension" do
   end
 
   it "should support using endless Range instances as bound variables" do
-    @db.bound_variable_arg(eval('1..'), nil).must_equal "[1,]"
-    @db.bound_variable_arg(eval('1...'), nil).must_equal "[1,)"
+    @db.bound_variable_arg(eval('(1..)'), nil).must_equal "[1,]"
+    @db.bound_variable_arg(eval('(1...)'), nil).must_equal "[1,)"
   end if endless_range_support
 
   it "should support using startless Range instances as bound variables" do
-    @db.bound_variable_arg(eval('..1'), nil).must_equal "[,1]"
-    @db.bound_variable_arg(eval('...1'), nil).must_equal "[,1)"
+    @db.bound_variable_arg(eval('(..1)'), nil).must_equal "[,1]"
+    @db.bound_variable_arg(eval('(...1)'), nil).must_equal "[,1)"
   end if startless_range_support
 
   it "should support using startless, endless Range instances as bound variables" do
@@ -113,7 +113,7 @@ describe "pg_range extension" do
   end
 
   it "should support using arrays of endless Range instances as bound variables" do
-    @db.bound_variable_arg([eval('1..'), eval('2..')], nil).must_equal '{"[1,]","[2,]"}'
+    @db.bound_variable_arg([eval('(1..)'), eval('(2..)')], nil).must_equal '{"[1,]","[2,]"}'
   end if endless_range_support
 
   it "should support using PGRange instances as bound variables" do
@@ -136,6 +136,20 @@ describe "pg_range extension" do
     s[1][1][:ruby_default].must_equal Sequel::Postgres::PGRange.new(1, 5, :exclude_end=>true, :db_type=>'int4range')
   end
 
+  it "should work correctly in hashes" do
+    h = Hash.new(1)
+    h[@R.new(1, 2)] = 2
+    h[@R.new(nil, nil, :empty => true)] = 3
+    h[@R.new(1, 2)].must_equal 2
+    h[@R.new(1, 3)].must_equal 1
+    h[@R.new(2, 2)].must_equal 1
+    h[@R.new(1, 2, :exclude_begin => true)].must_equal 1
+    h[@R.new(1, 2, :exclude_end => true)].must_equal 1
+    h[@R.new(1, 2, :db_type => :int)].must_equal 1
+    h[@R.new(nil, nil, :empty => true)].must_equal 3
+    h[@R.new(nil, nil, :empty => true, :db_type => :int)].must_equal 1
+  end
+
   describe "database typecasting" do
     before do
       @o = @R.new(1, 2, :db_type=>'int4range')
@@ -456,21 +470,21 @@ describe "pg_range extension" do
     end
 
     it "should consider PGRanges equal with a endless Range they represent" do
-      @R.new(1, nil).must_be :==, eval('1..')
-      @R.new(1, nil, :exclude_end=>true).must_be :==, eval('1...')
-      @R.new(1, nil).wont_be :==, eval('1...')
-      @R.new(1, nil, :exclude_end=>true).wont_be :==, eval('1..')
-      @R.new(1, nil).wont_be :==, eval('2..')
-      @R.new(1, nil, :exclude_end=>true).wont_be :==, eval('2...')
+      @R.new(1, nil).must_be :==, eval('(1..)')
+      @R.new(1, nil, :exclude_end=>true).must_be :==, eval('(1...)')
+      @R.new(1, nil).wont_be :==, eval('(1...)')
+      @R.new(1, nil, :exclude_end=>true).wont_be :==, eval('(1..)')
+      @R.new(1, nil).wont_be :==, eval('(2..)')
+      @R.new(1, nil, :exclude_end=>true).wont_be :==, eval('(2...)')
     end if endless_range_support
 
     it "should consider PGRanges equal with a startless Range they represent" do
-      @R.new(nil, 1).must_be :==, eval('..1')
-      @R.new(nil, 1, :exclude_end=>true).must_be :==, eval('...1')
-      @R.new(nil, 1).wont_be :==, eval('...1')
-      @R.new(nil, 1, :exclude_end=>true).wont_be :==, eval('..1')
-      @R.new(nil, 1).wont_be :==, eval('..2')
-      @R.new(nil, 1, :exclude_end=>true).wont_be :==, eval('...2')
+      @R.new(nil, 1).must_be :==, eval('(..1)')
+      @R.new(nil, 1, :exclude_end=>true).must_be :==, eval('(...1)')
+      @R.new(nil, 1).wont_be :==, eval('(...1)')
+      @R.new(nil, 1, :exclude_end=>true).wont_be :==, eval('(..1)')
+      @R.new(nil, 1).wont_be :==, eval('(..2)')
+      @R.new(nil, 1, :exclude_end=>true).wont_be :==, eval('(...2)')
     end if startless_range_support
 
     it "should consider PGRanges equal with a startless, endless Range they represent" do

data/spec/extensions/sharding_spec.rb

@@ -186,4 +186,12 @@ describe "sharding plugin" do
     ["UPDATE albums SET artist_id = 2, name = 'RF' WHERE (id = 1) -- s1", "UPDATE albums SET name = 'RF', artist_id = 2 WHERE (id = 1) -- s1"].must_include(sqls.slice!(2))
     sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s2", "BEGIN -- s1", "COMMIT -- s1"]
   end 
+
+  it "should have objects retrieved from a specific shard using with_server from server_block extension" do
+    album = @db.extension(:server_block).with_server(:s1) do
+      @Album.first
+    end
+    album.update(:name=>'MO')
+    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s1"]
+  end 
 end

data/spec/extensions/spec_helper.rb

@@ -7,7 +7,7 @@ end
 
 ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
 gem 'minitest'
-require 'minitest/autorun'
+require 'minitest/global_expectations/autorun'
 require 'minitest/hooks/default'
 require 'minitest/shared_description'
 

data/spec/extensions/static_cache_cache_spec.rb

@@ -0,0 +1,35 @@
+require_relative "spec_helper"
+
+describe "static_cache_cache plugin" do
+  before do
+    @db = Sequel.mock
+    @db.fetch = [{:id=>1, :name=>'A'}, {:id=>2, :name=>'B'}]
+    @c = Class.new(Sequel::Model(@db[:t]))
+    def @c.name; 'Foo' end
+    @c.columns :id, :name
+    @file = "spec/files/static_cache_cache-spec-#{$$}.cache"
+  end
+  after do
+    File.delete(@file) if File.file?(@file)
+  end
+
+  it "should allow dumping and loading static cache rows from a cache file" do
+    @c.plugin :static_cache_cache, @file
+    @db.sqls
+    @c.plugin :static_cache
+    @db.sqls.must_equal ['SELECT * FROM t']
+    @c.all.must_equal [@c.load(:id=>1, :name=>'A'), @c.load(:id=>2, :name=>'B')]
+
+    @c.dump_static_cache_cache
+
+    @db.fetch = []
+    c = Class.new(Sequel::Model(@db[:t]))
+    def c.name; 'Foo' end
+    c.columns :id, :name
+    @c.plugin :static_cache_cache, @file
+    @db.sqls
+    @c.plugin :static_cache
+    @db.sqls.must_be_empty
+    @c.all.must_equal [@c.load(:id=>1, :name=>'A'), @c.load(:id=>2, :name=>'B')]
+  end
+end

data/spec/guards_helper.rb

@@ -1,6 +1,6 @@
 ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
 gem 'minitest'
-require 'minitest/autorun'
+require 'minitest/global_expectations/autorun'
 require 'minitest/hooks/default'
 require 'minitest/shared_description'
 

data/spec/integration/dataset_test.rb

@@ -92,6 +92,17 @@ describe "Simple Dataset operations" do
     @ds.from_self(:alias=>:items).graph(@ds.from_self, {:id=>:id}, :table_alias=>:b).extension(:graph_each).all.must_equal [{:items=>{:id=>1, :number=>10}, :b=>{:id=>1, :number=>10}}]
   end
 
+  cspecify "should have insert and update work with Sequel::DEFAULT", :sqlite do
+    @db.create_table!(:items) do
+      Integer :number, :default=>10
+    end
+    @ds.insert(:number=>Sequel::DEFAULT)
+    @ds.select_map(:number).must_equal [10]
+    @ds.insert(:number=>20)
+    @ds.update(:number=>Sequel::DEFAULT)
+    @ds.select_map(:number).must_equal [10, 10]
+  end
+
   cspecify "should have insert work correctly when inserting a row with all NULL values", :hsqldb do
     @db.create_table!(:items) do
       String :name
@@ -443,6 +454,20 @@ describe Sequel::Dataset do
     @d.extension(:sequel_4_dataset_methods).interval(:value).to_i.must_equal 6
   end
 
+  it "should support or emulate filtered aggregate functions" do
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 324)
+    @d.get{count.function.*.filter{value > 100}}.must_equal 3
+    @d.get{count.function.*.filter{value > 200}}.must_equal 2
+    @d.get{count.function.*.filter{value > 400}}.must_equal 1
+    @d.get{count.function.*.filter{value > 500}}.must_equal 0
+    @d.get{count(:value).filter{value > 100}}.must_equal 3
+    @d.get{count(:value).filter{value > 200}}.must_equal 2
+    @d.get{count(:value).filter{value > 400}}.must_equal 1
+    @d.get{count(:value).filter{value > 500}}.must_equal 0
+  end
+
   it "should return the correct records" do
     @d.to_a.must_equal []
     @d.insert(:name => 'abc', :value => 123)
@@ -568,22 +593,21 @@ describe Sequel::Dataset do
 end
 
 describe "Simple Dataset operations" do
-  before do
+  before(:all) do
     DB.create_table!(:items) do
       Integer :number
       TrueClass :flag
     end
-    @ds = DB[:items]
+    @ds = DB[:items].order(:number)
+    @ds.insert(:number=>1, :flag=>true)
+    @ds.insert(:number=>2, :flag=>false)
+    @ds.insert(:number=>3, :flag=>nil)
   end
-  after do
+  after(:all) do
     DB.drop_table?(:items)
   end
 
   it "should deal with boolean conditions correctly" do
-    @ds.insert(:number=>1, :flag=>true)
-    @ds.insert(:number=>2, :flag=>false)
-    @ds.insert(:number=>3, :flag=>nil)
-    @ds = @ds.order(:number)
     @ds.filter(:flag=>true).map(:number).must_equal [1]
     @ds.filter(:flag=>false).map(:number).must_equal [2]
     @ds.filter(:flag=>nil).map(:number).must_equal [3]
@@ -591,6 +615,22 @@ describe "Simple Dataset operations" do
     @ds.exclude(:flag=>false).map(:number).must_equal [1, 3]
     @ds.exclude(:flag=>nil).map(:number).must_equal [1, 2]
   end
+
+  cspecify "should deal with boolean equality conditions correctly", :derby do
+    @ds.filter(true=>:flag).map(:number).must_equal [1]
+    @ds.filter(false=>:flag).map(:number).must_equal [2]
+    @ds.filter(nil=>:flag).map(:number).must_equal []
+    @ds.exclude(true=>:flag).map(:number).must_equal [2]
+    @ds.exclude(false=>:flag).map(:number).must_equal [1]
+    @ds.exclude(nil=>:flag).map(:number).must_equal []
+  end
+
+  cspecify "should have exclude_or_null work correctly", :mssql, :derby, :oracle, :db2, :sqlanywhere do
+    @ds = @ds.extension(:exclude_or_null)
+    @ds.exclude_or_null(true=>:flag).map(:number).must_equal [2, 3]
+    @ds.exclude_or_null(false=>:flag).map(:number).must_equal [1, 3]
+    @ds.exclude_or_null(nil=>:flag).map(:number).must_equal [1, 2, 3]
+  end
 end
 
 describe "Simple Dataset operations in transactions" do
@@ -1553,20 +1593,20 @@ describe "Sequel::Dataset DSL support" do
   
   it "should work with endless ranges as hash values" do
     @ds.insert(20, 10)
-    @ds.filter(:a=>eval('30..')).all.must_equal []
-    @ds.filter(:a=>eval('20...')).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>eval('20..')).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>eval('10..')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(30..)')).all.must_equal []
+    @ds.filter(:a=>eval('(20...)')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(20..)')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(10..)')).all.must_equal [{:a=>20, :b=>10}]
   end if RUBY_VERSION >= '2.6'
   
   it "should work with startless ranges as hash values" do
     @ds.insert(20, 10)
-    @ds.filter(:a=>eval('..30')).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>eval('...30')).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>eval('..20')).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>eval('...20')).all.must_equal []
-    @ds.filter(:a=>eval('..10')).all.must_equal []
-    @ds.filter(:a=>eval('...10')).all.must_equal []
+    @ds.filter(:a=>eval('(..30)')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(...30)')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(..20)')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('(...20)')).all.must_equal []
+    @ds.filter(:a=>eval('(..10)')).all.must_equal []
+    @ds.filter(:a=>eval('(...10)')).all.must_equal []
 
     @ds.filter(:a=>eval('nil..nil')).all.must_equal [{:a=>20, :b=>10}]
   end if RUBY_VERSION >= '2.7'