sequel 5.23.0 → 5.28.0

data/lib/sequel/plugins/sharding.rb

@@ -107,12 +107,18 @@ module Sequel
         # previous row_proc, but calls set_server on the output of that row_proc,
         # ensuring that objects retrieved by a specific shard know which shard they
         # are tied to.
-        def server(s)
-          ds = super
-          if rp = row_proc
-            ds = ds.with_row_proc(proc{|r| rp.call(r).set_server(s)})
+        def row_proc
+          rp = super
+          if rp
+            case server = db.pool.send(:pick_server, opts[:server])
+            when nil, :default, :read_only
+              # nothing
+            else
+              old_rp = rp
+              rp = proc{|r| old_rp.call(r).set_server(server)}
+            end
           end
-          ds
+          rp 
         end
       end
     end

data/lib/sequel/plugins/static_cache.rb

@@ -211,18 +211,23 @@ module Sequel
         # Reload the cache for this model by retrieving all of the instances in the dataset
         # freezing them, and populating the cached array and hash.
         def load_cache
-          a = dataset.all
+          @all = load_static_cache_rows
           h = {}
-          a.each do |o|
+          @all.each do |o|
             o.errors.freeze
             h[o.pk.freeze] = o.freeze
           end
-          @all = a.freeze
           @cache = h.freeze
         end
 
         private
 
+        # Load the static cache rows from the database.
+        def load_static_cache_rows
+          ret = super if defined?(super)
+          ret || dataset.all.freeze
+        end
+
         # Return the frozen object with the given pk, or nil if no such object exists
         # in the cache, without issuing a database query.
         def primary_key_lookup(pk)

data/lib/sequel/plugins/static_cache_cache.rb

@@ -0,0 +1,53 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The static_cache_cache plugin allows for caching the row content for subclasses
+    # that use the static cache plugin (or just the current class).  Using this plugin
+    # can avoid the need to query the database every time loading the plugin into a
+    # model, which can save time when you have a lot of models using the static_cache
+    # plugin.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses that use the static_cache plugin use
+    #   # the cached values in the given file
+    #   Sequel::Model.plugin :static_cache_cache, "static_cache.cache"
+    #
+    #   # Make the AlbumType model the cached values in the given file,
+    #   # should be loaded before the static_cache plugin
+    #   AlbumType.plugin :static_cache_cache, "static_cache.cache"
+    module StaticCacheCache
+      def self.configure(model, file)
+        model.instance_variable_set(:@static_cache_cache_file, file)
+        model.instance_variable_set(:@static_cache_cache, File.exist?(file) ? Marshal.load(File.read(file)) : {})
+      end
+
+      module ClassMethods
+        # Dump the in-memory cached rows to the cache file.
+        def dump_static_cache_cache
+          File.open(@static_cache_cache_file, 'wb'){|f| f.write(Marshal.dump(@static_cache_cache))}
+          nil
+        end
+
+        Plugins.inherited_instance_variables(self, :@static_cache_cache_file=>nil, :@static_cache_cache=>nil)
+
+        private
+
+        # Load the rows for the model from the cache if available.
+        # If not available, load the rows from the database, and
+        # then update the cache with the raw rows.
+        def load_static_cache_rows
+          if rows = Sequel.synchronize{@static_cache_cache[name]}
+            rows.map{|row| call(row)}.freeze
+          else
+            rows = dataset.all.freeze
+            raw_rows = rows.map(&:values)
+            Sequel.synchronize{@static_cache_cache[name] = raw_rows}
+            rows
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/typecast_on_load.rb

@@ -41,7 +41,9 @@ module Sequel
         # Typecast values using #load_typecast when the values are retrieved
         # from the database.
         def call(values)
-          super.load_typecast
+          o = super.load_typecast
+          o.send(:_clear_changed_columns, :initialize)
+          o
         end
 
         # Freeze typecast on load columns when freezing model class.
@@ -63,7 +65,6 @@ module Sequel
               set_column_value("#{c}=", v)
             end
           end
-          _changed_columns.clear
           self
         end
 

data/lib/sequel/sql.rb

@@ -788,8 +788,10 @@ module Sequel
       def coerce(other)
         if other.is_a?(Numeric)
           [SQL::NumericExpression.new(:NOOP, other), self]
-        else
+        elsif defined?(super)
           super 
+        else
+          [self, other]
         end
       end
 
@@ -1315,6 +1317,7 @@ module Sequel
       CURRENT_DATE = Constant.new(:CURRENT_DATE)
       CURRENT_TIME = Constant.new(:CURRENT_TIME)
       CURRENT_TIMESTAMP = Constant.new(:CURRENT_TIMESTAMP)
+      DEFAULT = Constant.new(:DEFAULT)
       SQLTRUE = TRUE = BooleanConstant.new(true)
       SQLFALSE = FALSE = BooleanConstant.new(false)
       NULL = BooleanConstant.new(nil)

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 23
+  MINOR = 28
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

data/spec/adapters/postgres_spec.rb

@@ -70,7 +70,7 @@ describe "PostgreSQL", '#create_table' do
 
   it "should create an unlogged table" do
     @db.create_table(:unlogged_dolls, :unlogged => true){text :name}
-  end
+  end if DB.server_version >= 90100
 
   it "should create a table inheriting from another table" do
     @db.create_table(:unlogged_dolls){text :name}
@@ -227,6 +227,24 @@ describe "PostgreSQL", '#create_table' do
     @db.convert_serial_to_identity(:tmp_dolls, :column=>:id)
   end if DB.server_version >= 100002 && DB.get{current_setting('is_superuser')} == 'on'
 
+  it "should support creating generated columns" do
+    @db.create_table(:tmp_dolls){Integer :a; Integer :b; Integer :c, :generated_always_as=>Sequel[:a] * 2 + :b + 1}
+    @db[:tmp_dolls].insert(:a=>100, :b=>10)
+    @db[:tmp_dolls].select_order_map([:a, :b, :c]).must_equal [[100, 10, 211]]
+  end if DB.server_version >= 120000
+
+  it "should support deferred primary key and unique constraints on columns" do
+    @db.create_table(:tmp_dolls){primary_key :id, :primary_key_deferrable=>true; Integer :i, :unique=>true, :unique_deferrable=>true}
+    @db[:tmp_dolls].insert(:i=>10)
+    DB.transaction do
+      @db[:tmp_dolls].insert(:id=>1, :i=>1)
+      @db[:tmp_dolls].insert(:id=>10, :i=>10)
+      @db[:tmp_dolls].where(:i=>1).update(:id=>2)
+      @db[:tmp_dolls].where(:id=>10).update(:i=>2)
+    end
+    @db[:tmp_dolls].select_order_map([:id, :i]).must_equal [[1, 10], [2, 1], [10, 2]]
+  end if DB.server_version >= 90000
+
   it "should support pg_loose_count extension" do
     @db.extension :pg_loose_count
     @db.create_table(:tmp_dolls){text :name}
@@ -350,6 +368,14 @@ describe "PostgreSQL", 'INSERT ON CONFLICT' do
     @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>6}, :update_where=>{Sequel[:ic_test][:b]=>4}).insert(1, 3, 4).must_be_nil
     @ds.all.must_equal [{:a=>1, :b=>5, :c=>5, :c_is_unique=>false}]
   end
+
+  it "Dataset#insert_conflict should support table aliases" do
+    @ds = @db[Sequel[:ic_test].as(:foo)]
+    @ds.insert(1, 2, 5)
+    proc{@ds.insert(1, 3, 4)}.must_raise Sequel::UniqueConstraintViolation
+    @ds.insert_conflict(:target=>:a, :update=>{:b=>Sequel[:foo][:c] + Sequel[:excluded][:c]}).insert(1, 7, 10)
+    @ds.all.must_equal [{:a=>1, :b=>15, :c=>5, :c_is_unique=>false}]
+  end
 end if DB.server_version >= 90500
 
 describe "A PostgreSQL database" do
@@ -589,10 +615,6 @@ describe "A PostgreSQL dataset" do
     @d.from{generate_series(1,3,1).as(:a)}.select{(a.sql_number % 2).as(:a)}.from_self.get{mode.function.within_group(:a)}.must_equal 1
   end if DB.server_version >= 90400
 
-  it "should support filtered aggregate functions" do
-    @d.from{generate_series(1,3,1).as(:a)}.select{(a.sql_number % 2).as(:a)}.from_self.get{count(:a).filter(:a=>1)}.must_equal 2
-  end if DB.server_version >= 90400
-
   it "should support functions with ordinality" do
     @d.from{generate_series(1,10,3).with_ordinality}.select_map([:generate_series, :ordinality]).must_equal [[1, 1], [4, 2], [7, 3], [10, 4]]
   end if DB.server_version >= 90400
@@ -1246,7 +1268,7 @@ describe "A PostgreSQL database" do
   end
 
   it "should support indexes with index type" do
-    @db.create_table(:posts){point :p; index :p, :type => 'gist'}
+    @db.create_table(:posts){box :geom; index :geom, :type => 'gist'}
   end
 
   it "should support unique indexes with index type" do
@@ -2678,6 +2700,8 @@ describe 'PostgreSQL array handling' do
     if @db.server_version >= 90000
       @ds.get(Sequel.pg_array(:i5).join).must_equal '15'
       @ds.get(Sequel.pg_array(:i5).join(':')).must_equal '1:5'
+    end
+    if @db.server_version >= 90100
       @ds.get(Sequel.pg_array(:i5).join(':', '*')).must_equal '1:*:5'
     end
     if @db.server_version >= 90300
@@ -3323,6 +3347,65 @@ describe 'PostgreSQL json type' do
       @db.from(jo.each_text).select_order_map(:key).must_equal %w'a b'
       @db.from(jo.each_text).order(:key).where(:key=>'b').get(:value).gsub(' ', '').must_match(/\{"d":\{"e":3\},"c":2\}|\{"c":2,"d":\{"e":3\}\}/)
 
+      if DB.server_version >= 120000  && json_type == :jsonb
+        @db.get(jo.path_exists('$.b.d.e')).must_equal true
+        @db.get(jo.path_exists('$.b.d.f')).must_equal false
+
+        @db.get(jo.path_exists!('$.b.d.e')).must_equal true
+        @db.get(jo.path_exists!('$.b.d.f')).must_equal false
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', '{"x":2}')).must_equal true
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', '{"x":4}')).must_equal false
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', x: 2)).must_equal true
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', x: 4)).must_equal false
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', {x: 2}, true)).must_equal true
+        @db.get(jo.path_exists!('$.b.d.e ? (@ > $x)', {x: 4}, false)).must_equal false
+
+        @db.get(jo.path_match('$.b.d.e')).must_be_nil
+        @db.get(jo.path_match('$.b.d.f')).must_be_nil
+        @db.get(pg_json.call('b'=>{'d'=>{'e'=>true}}).op.path_match('$.b.d.e')).must_equal true
+        @db.get(pg_json.call('b'=>{'d'=>{'e'=>false}}).op.path_match('$.b.d.e')).must_equal false
+
+        proc{@db.get(jo.path_match!('$.b.d.e'))}.must_raise(Sequel::DatabaseError)
+        proc{@db.get(jo.path_match!('$.b.d.f'))}.must_raise(Sequel::DatabaseError)
+        @db.get(jo.path_match!('$.b.d.e', {}, true)).must_be_nil
+        @db.get(jo.path_match!('$.b.d.f', {}, true)).must_be_nil
+        @db.get(pg_json.call('b'=>{'d'=>{'e'=>true}}).op.path_match!('$.b.d.e')).must_equal true
+        @db.get(pg_json.call('b'=>{'d'=>{'e'=>false}}).op.path_match!('$.b.d.e')).must_equal false
+        @db.get(jo.path_match!('$.b.d.e > $x', '{"x":2}')).must_equal true
+        @db.get(jo.path_match!('$.b.d.e > $x', '{"x":4}')).must_equal false
+        @db.get(jo.path_match!('$.b.d.e > $x', x: 2)).must_equal true
+        @db.get(jo.path_match!('$.b.d.e > $x', x: 4)).must_equal false
+        @db.get(jo.path_match!('$.b.d.e > $x', {x: 2}, false)).must_equal true
+        @db.get(jo.path_match!('$.b.d.e > $x', {x: 4}, true)).must_equal false
+
+        @db.get(jo.path_query_first('$.b.d.e')).must_equal 3
+        @db.get(jo.path_query_first('$.b.d.f')).must_be_nil
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', '{"x":2}')).must_equal 3
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', '{"x":4}')).must_be_nil
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', x: 2)).must_equal 3
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', x: 4)).must_be_nil
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', {x: 2}, true)).must_equal 3
+        @db.get(jo.path_query_first('$.b.d.e ? (@ > $x)', {x: 4}, false)).must_be_nil
+
+        @db.get(jo.path_query_array('$.b.d.e')).must_equal [3]
+        @db.get(jo.path_query_array('$.b.d.f')).must_equal []
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', '{"x":2}')).must_equal [3]
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', '{"x":4}')).must_equal []
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', x: 2)).must_equal [3]
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', x: 4)).must_equal []
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', {x: 2}, true)).must_equal [3]
+        @db.get(jo.path_query_array('$.b.d.e ? (@ > $x)', {x: 4}, false)).must_equal []
+
+        @db.from(jo.path_query('$.b.d.e').as(:a, [:b])).get(:b).must_equal 3
+        @db.from(jo.path_query('$.b.d.f').as(:a, [:b])).get(:b).must_be_nil
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', '{"x":2}').as(:a, [:b])).get(:b).must_equal 3
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', '{"x":4}').as(:a, [:b])).get(:b).must_be_nil
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', x: 2).as(:a, [:b])).get(:b).must_equal 3
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', x: 4).as(:a, [:b])).get(:b).must_be_nil
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', {x: 2}, true).as(:a, [:b])).get(:b).must_equal 3
+        @db.from(jo.path_query('$.b.d.e ? (@ > $x)', {x: 4}, false).as(:a, [:b])).get(:b).must_be_nil
+      end
+
       Sequel.extension :pg_row_ops
       @db.create_table!(:items) do
         Integer :a
@@ -3602,19 +3685,19 @@ describe 'PostgreSQL range types' do
   end if uses_pg_or_jdbc
 
   it 'handle endless ranges' do
-    @db.get(Sequel.cast(eval('1...'), :int4range)).must_be :==, eval('1...')
-    @db.get(Sequel.cast(eval('1...'), :int4range)).wont_be :==, eval('2...')
-    @db.get(Sequel.cast(eval('1...'), :int4range)).wont_be :==, eval('1..')
-    @db.get(Sequel.cast(eval('2...'), :int4range)).must_be :==, eval('2...')
-    @db.get(Sequel.cast(eval('2...'), :int4range)).wont_be :==, eval('2..')
-    @db.get(Sequel.cast(eval('2...'), :int4range)).wont_be :==, eval('1...')
+    @db.get(Sequel.cast(eval('(1...)'), :int4range)).must_be :==, eval('(1...)')
+    @db.get(Sequel.cast(eval('(1...)'), :int4range)).wont_be :==, eval('(2...)')
+    @db.get(Sequel.cast(eval('(1...)'), :int4range)).wont_be :==, eval('(1..)')
+    @db.get(Sequel.cast(eval('(2...)'), :int4range)).must_be :==, eval('(2...)')
+    @db.get(Sequel.cast(eval('(2...)'), :int4range)).wont_be :==, eval('(2..)')
+    @db.get(Sequel.cast(eval('(2...)'), :int4range)).wont_be :==, eval('(1...)')
   end if RUBY_VERSION >= '2.6'
 
   it 'handle startless ranges' do
-    @db.get(Sequel.cast(eval('...1'), :int4range)).must_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_begin=>true, :exclude_end=>true, :db_type=>"int4range")
-    @db.get(Sequel.cast(eval('...1'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 2, :exclude_begin=>true, :exclude_end=>true, :db_type=>"int4range")
-    @db.get(Sequel.cast(eval('...1'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_end=>true, :db_type=>"int4range")
-    @db.get(Sequel.cast(eval('...1'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_begin=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('(...1)'), :int4range)).must_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_begin=>true, :exclude_end=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('(...1)'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 2, :exclude_begin=>true, :exclude_end=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('(...1)'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_end=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('(...1)'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_begin=>true, :db_type=>"int4range")
   end if RUBY_VERSION >= '2.7'
 
   it 'handle startless ranges' do
@@ -4345,4 +4428,49 @@ describe "pg_auto_constraint_validations plugin" do
     proc{o.save}.must_raise Sequel::ValidationFailed
     o.errors.must_equal(:i=>['is invalid'], :id=>['is invalid'])
   end
-end if DB.respond_to?(:error_info)
+
+  it "should handle dumping cached metadata and loading metadata from cache" do
+    cache_file = "spec/files/pgacv-#{$$}.cache"
+    begin
+      c = Class.new(Sequel::Model)
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      c1 = Class.new(c)
+      def c1.name; 'Foo' end
+      c1.dataset = DB[:test1]
+      c2 = Class.new(c)
+      def c2.name; 'Bar' end
+      c2.dataset = DB[:test2]
+      c1.unrestrict_primary_key
+      c2.unrestrict_primary_key
+
+      o = c1.new(:id=>5, :i=>12)
+      proc{o.save}.must_raise Sequel::ValidationFailed
+      o.errors.must_equal(:i=>['is invalid'])
+      o = c2.new(:test2_id=>4, :test1_id=>2)
+      proc{o.save}.must_raise Sequel::ValidationFailed
+      o.errors.must_equal(:test1_id=>['is invalid'])
+
+      c.dump_pg_auto_constraint_validations_cache
+
+      c = Class.new(Sequel::Model)
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      c1 = Class.new(c)
+      def c1.name; 'Foo' end
+      c1.dataset = DB[:test1]
+      c2 = Class.new(c)
+      def c2.name; 'Bar' end
+      c2.dataset = DB[:test2]
+      c1.unrestrict_primary_key
+      c2.unrestrict_primary_key
+
+      o = c1.new(:id=>5, :i=>12)
+      proc{o.save}.must_raise Sequel::ValidationFailed
+      o.errors.must_equal(:i=>['is invalid'])
+      o = c2.new(:test2_id=>4, :test1_id=>2)
+      proc{o.save}.must_raise Sequel::ValidationFailed
+      o.errors.must_equal(:test1_id=>['is invalid'])
+    ensure
+      File.delete(cache_file) if File.file?(cache_file)
+    end
+  end
+end if DB.respond_to?(:error_info) && DB.server_version >= 90300

data/spec/adapters/sqlite_spec.rb

@@ -623,7 +623,7 @@ describe "SQLite", 'INSERT ON CONFLICT' do
     @ds.insert_conflict(:target=>:a).insert(1, 3, 4, false)
     @ds.insert_conflict(:target=>:c, :conflict_where=>:c_is_unique).insert(11, 12, 3, true)
     @ds.all.must_equal [{:a=>1, :b=>2, :c=>3, :c_is_unique=>false}, {:a=>10, :b=>11, :c=>3, :c_is_unique=>true}]
-  end
+  end unless DB.adapter_scheme == :amalgalite
 
   it "Dataset#insert_ignore and insert_conflict should work with multi_insert/import" do
     @ds.insert(1, 2, 3, false)

data/spec/bin_spec.rb

@@ -25,7 +25,7 @@ DB2 = Sequel.connect("#{CONN_PREFIX}#{BIN_SPEC_DB2}", :test=>false)
 
 ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
 gem 'minitest'
-require 'minitest/autorun'
+require 'minitest/global_expectations/autorun'
 
 describe "bin/sequel" do
   def bin(opts={})

data/spec/core/database_spec.rb

@@ -264,6 +264,25 @@ describe "Database#log_connection_yield" do
     @o.logs.first.first.must_equal :info
     @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah; \[1, 2\]\z/)
   end
+
+  it "should log without a logger defined by forcing skip_logging? to return false" do
+    @db.logger = nil
+    @db.extend(Module.new do
+      def skip_logging?
+        false
+      end
+
+      def log_duration(*)
+        self.did_log = true
+      end
+
+      attr_accessor :did_log
+    end)
+
+    @db.log_connection_yield('some sql', @conn) {}
+
+    @db.did_log.must_equal true
+  end
 end
 
 describe "Database#uri" do
@@ -2448,7 +2467,7 @@ describe "Database#typecast_value" do
       @db.typecast_value(:date, 'a')
       true.must_equal false
     rescue Sequel::InvalidValue => e
-      e.inspect.must_equal '#<Sequel::InvalidValue: ArgumentError: invalid date>'
+      e.inspect.must_match(/\A#\<Sequel::InvalidValue: (Argument|Date::)Error: invalid date\>\z/)
     end
   end
 end

data/spec/core/expression_filters_spec.rb

@@ -214,8 +214,13 @@ describe "Blockless Ruby Filters" do
     @d.lit(1 + Sequel.lit('?', :x)).must_equal '(1 + x)'
   end
 
-  it "should raise a NoMethodError if coerce is called with a non-Numeric" do
-    proc{Sequel.expr(:x).coerce(:a)}.must_raise NoMethodError
+  it "should not break Date/DateTime equality" do
+    (Date.today == Sequel.expr(:x)).must_equal false
+    (DateTime.now == Sequel.expr(:x)).must_equal false
+  end
+
+  it "should have coerce return array if called on a non-numeric" do
+    Sequel.expr(:x).coerce(:a).must_equal [Sequel.expr(:x), :a]
   end
 
   it "should support AND conditions via &" do
@@ -348,6 +353,11 @@ describe "Blockless Ruby Filters" do
     @d.l({:x => Sequel::FALSE}).must_equal '(x IS FALSE)'
     @d.l({:x => Sequel::SQLTRUE}).must_equal '(x IS TRUE)'
     @d.l({:x => Sequel::SQLFALSE}).must_equal '(x IS FALSE)'
+
+    @d.l({:x => Sequel::CURRENT_DATE}).must_equal '(x = CURRENT_DATE)'
+    @d.l({:x => Sequel::CURRENT_TIME}).must_equal '(x = CURRENT_TIME)'
+    @d.l({:x => Sequel::CURRENT_TIMESTAMP}).must_equal '(x = CURRENT_TIMESTAMP)'
+    @d.l({:x => Sequel::DEFAULT}).must_equal '(x = DEFAULT)'
   end
   
   it "should support negation of SQL::Constants" do
@@ -527,21 +537,21 @@ describe "Blockless Ruby Filters" do
   end
 
   it "should handle endless ranges" do
-    endless = eval('1..')
+    endless = eval('(1..)')
     @d.l{x =~ endless}.must_equal '(x >= 1)'
     @d.l(:x => endless).must_equal '(x >= 1)'
 
-    endless = eval('1...')
+    endless = eval('(1...)')
     @d.l{x =~ endless}.must_equal '(x >= 1)'
     @d.l(:x => endless).must_equal '(x >= 1)'
   end if RUBY_VERSION >= '2.6'
 
   it "should handle startless ranges" do
-    endless = eval('..1')
+    endless = eval('(..1)')
     @d.l{x =~ endless}.must_equal '(x <= 1)'
     @d.l(:x => endless).must_equal '(x <= 1)'
 
-    endless = eval('...1')
+    endless = eval('(...1)')
     @d.l{x =~ endless}.must_equal '(x < 1)'
     @d.l(:x => endless).must_equal '(x < 1)'
   end if RUBY_VERSION >= '2.7'
@@ -736,14 +746,23 @@ describe Sequel::SQL::VirtualRow do
     @d.l{mode.function.within_group(:a, :b)}.must_equal 'mode() WITHIN GROUP (ORDER BY "a", "b")' 
   end
 
+  it "should handle emualted filtered aggregate function calls" do
+    @d.l{count.function.*.filter(Sequel.&(:a, :b))}.must_equal 'count((CASE WHEN ("a" AND "b") THEN 1 ELSE NULL END))' 
+    @d.l{count.function.*.filter(:a=>1)}.must_equal 'count((CASE WHEN ("a" = 1) THEN 1 ELSE NULL END))'
+    @d.l{count(:a).filter{b > 1}}.must_equal 'count((CASE WHEN ("b" > 1) THEN "a" ELSE NULL END))'
+    @d.l{count(:a).filter(:a=>1){b > 1}}.must_equal 'count((CASE WHEN (("a" = 1) AND ("b" > 1)) THEN "a" ELSE NULL END))'
+  end
+
   it "should handle filtered aggregate function calls" do
+    @d = @d.with_extend{def supports_filtered_aggregates?; true end}
     @d.l{count.function.*.filter(Sequel.&(:a, :b))}.must_equal 'count(*) FILTER (WHERE ("a" AND "b"))' 
     @d.l{count.function.*.filter(:a=>1)}.must_equal 'count(*) FILTER (WHERE ("a" = 1))'
     @d.l{count.function.*.filter{b > 1}}.must_equal 'count(*) FILTER (WHERE ("b" > 1))'
     @d.l{count.function.*.filter(:a=>1){b > 1}}.must_equal 'count(*) FILTER (WHERE (("a" = 1) AND ("b" > 1)))'
   end
 
-  it "should handle fitlered ordered-set and hypothetical-set function calls" do
+  it "should handle filtered ordered-set and hypothetical-set function calls" do
+    @d = @d.with_extend{def supports_filtered_aggregates?; true end}
     @d.l{mode.function.within_group(:a).filter(:a=>1)}.must_equal 'mode() WITHIN GROUP (ORDER BY "a") FILTER (WHERE ("a" = 1))' 
   end