sequel 5.19.0 → 5.24.0

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/subset_conditions.rb

@@ -26,8 +26,8 @@ module Sequel
     #   Album.where(Album.published_conditions | {ready: true}).sql
     #   # SELECT * FROM albums WHERE ((published IS TRUE) OR (ready IS TRUE))
     module SubsetConditions
-      def self.apply(mod, &block)
-        mod.instance_exec do
+      def self.apply(model, &block)
+        model.instance_exec do
           @dataset_module_class = Class.new(@dataset_module_class) do
             include DatasetModuleMethods
           end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -188,13 +188,17 @@ module Sequel
         #                   Sequel will attempt to insert a NULL value into the database, instead of using the
         #                   database's default.
         # :allow_nil :: Whether to skip the validation if the value is nil.
-        # :if :: A symbol (indicating an instance_method) or proc (which is instance_execed)
+        # :if :: A symbol (indicating an instance_method) or proc (which is used to define an instance method)
         #        skipping this validation if it returns nil or false.
         # :tag :: The tag to use for this validation.
         def validates_each(*atts, &block)
           opts = extract_options!(atts)
           blank_meth = db.method(:blank_object?).to_proc
           blk = if (i = opts[:if]) || (am = opts[:allow_missing]) || (an = opts[:allow_nil]) || (ab = opts[:allow_blank])
+            if i.is_a?(Proc)
+              i = Plugins.def_sequel_method(self, "validation_class_methods_if", 0, &i)
+            end
+
             proc do |o,a,v|
               next if i && !validation_if_proc(o, i)
               next if an && Array(v).all?(&:nil?)
@@ -434,8 +438,6 @@ module Sequel
           case i
           when Symbol
             o.get_column_value(i)
-          when Proc
-            o.instance_exec(&i)
           else
             raise(::Sequel::Error, "invalid value for :if validation option")
           end

data/lib/sequel/sql.rb

@@ -1086,11 +1086,23 @@ module Sequel
       def self.from_value_pair(l, r)
         case r
         when Range
-          expr = new(:>=, l, r.begin)
+          unless r.begin.nil?
+            begin_expr = new(:>=, l, r.begin)
+          end
           unless r.end.nil?
-            expr = new(:AND, expr, new(r.exclude_end? ? :< : :<=, l, r.end))
+            end_expr = new(r.exclude_end? ? :< : :<=, l, r.end)
+          end
+          if begin_expr
+            if end_expr
+              new(:AND, begin_expr, end_expr)
+            else
+              begin_expr
+            end
+          elsif end_expr
+            end_expr
+          else
+            new(:'=', 1, 1)
           end
-          expr
         when ::Array
           r = r.dup.freeze unless r.frozen?
           new(:IN, l, r)

data/lib/sequel/timezones.rb

@@ -54,7 +54,14 @@ module Sequel
             convert_output_datetime_other(v, output_timezone)
           end
         else
-          v.public_send(output_timezone == :utc ? :getutc : :getlocal)
+          case output_timezone
+          when :utc
+            v.getutc
+          when :local
+            v.getlocal
+          else
+            convert_output_time_other(v, output_timezone)
+          end
         end
       else
         v
@@ -110,7 +117,7 @@ module Sequel
     # same time and just modifying the timezone.
     def convert_input_datetime_no_offset(v, input_timezone)
       case input_timezone
-      when :utc, nil
+      when nil, :utc
         v # DateTime assumes UTC if no offset is given
       when :local
         offset = local_offset_for_datetime(v)
@@ -119,7 +126,7 @@ module Sequel
         convert_input_datetime_other(v, input_timezone)
       end
     end
-    
+
     # Convert the given +DateTime+ to the given input_timezone that is not supported
     # by default (i.e. one other than +nil+, <tt>:local</tt>, or <tt>:utc</tt>).  Raises an +InvalidValue+ by default.
     # Can be overridden in extensions.
@@ -127,6 +134,13 @@ module Sequel
       raise InvalidValue, "Invalid input_timezone: #{input_timezone.inspect}"
     end
     
+    # Convert the given +Time+ to the given input_timezone that is not supported
+    # by default (i.e. one other than +nil+, <tt>:local</tt>, or <tt>:utc</tt>).  Raises an +InvalidValue+ by default.
+    # Can be overridden in extensions.
+    def convert_input_time_other(v, input_timezone)
+      raise InvalidValue, "Invalid input_timezone: #{input_timezone.inspect}"
+    end
+    
     # Converts the object from a +String+, +Array+, +Date+, +DateTime+, or +Time+ into an
     # instance of <tt>Sequel.datetime_class</tt>.  If given an array or a string that doesn't
     # contain an offset, assume that the array/string is already in the given +input_timezone+.
@@ -139,12 +153,17 @@ module Sequel
         else
           # Correct for potentially wrong offset if string doesn't include offset
           if v2.is_a?(DateTime)
-            v2 = convert_input_datetime_no_offset(v2, input_timezone)
+            convert_input_datetime_no_offset(v2, input_timezone)
           else
-            # Time assumes local time if no offset is given
-            v2 = v2.getutc + v2.utc_offset if input_timezone == :utc
+            case input_timezone
+            when nil, :local
+              v2
+            when :utc
+              (v2 + v2.utc_offset).utc
+            else
+              convert_input_time_other((v2 + v2.utc_offset).utc, input_timezone)
+            end
           end
-          v2
         end
       when Array
         y, mo, d, h, mi, s, ns, off = v
@@ -155,8 +174,18 @@ module Sequel
           else
             convert_input_datetime_no_offset(DateTime.civil(y, mo, d, h, mi, s), input_timezone)
           end
+        elsif off
+          s += Rational(ns, 1000000000) if ns
+          Time.new(y, mo, d, h, mi, s, (off*86400).to_i)
         else
-          Time.public_send(input_timezone == :utc ? :utc : :local, y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
+          case input_timezone
+          when nil, :local
+            Time.local(y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
+          when :utc
+            Time.utc(y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
+          else
+            convert_input_time_other(Time.utc(y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0)), input_timezone)
+          end
         end
       when Hash
         ary = [:year, :month, :day, :hour, :minute, :second, :nanos].map{|x| (v[x] || v[x.to_s]).to_i}
@@ -188,23 +217,33 @@ module Sequel
       raise InvalidValue, "Invalid output_timezone: #{output_timezone.inspect}"
     end
     
+    # Convert the given +Time+ to the given output_timezone that is not supported
+    # by default (i.e. one other than +nil+, <tt>:local</tt>, or <tt>:utc</tt>).  Raises an +InvalidValue+ by default.
+    # Can be overridden in extensions.
+    def convert_output_time_other(v, output_timezone)
+      raise InvalidValue, "Invalid output_timezone: #{output_timezone.inspect}"
+    end
+    
     # Convert the timezone setter argument.  Returns argument given by default,
     # exists for easier overriding in extensions.
     def convert_timezone_setter_arg(tz)
       tz
     end
 
-    # Takes a DateTime dt, and returns the correct local offset for that dt, daylight savings included.
+    # Takes a DateTime dt, and returns the correct local offset for that dt, daylight savings included, in fraction of a day.
     def local_offset_for_datetime(dt)
       time_offset_to_datetime_offset Time.local(dt.year, dt.month, dt.day, dt.hour, dt.min, dt.sec).utc_offset
     end
 
     # Caches offset conversions to avoid excess Rational math.
     def time_offset_to_datetime_offset(offset_secs)
-      @local_offsets ||= {}
-      @local_offsets[offset_secs] ||= Rational(offset_secs, 86400)
+      if offset = Sequel.synchronize{@local_offsets[offset_secs]}
+        return offset
+      end
+      Sequel.synchronize{@local_offsets[offset_secs] = Rational(offset_secs, 86400)}
     end
   end
 
+  @local_offsets = {}
   extend Timezones
 end

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 = 19
+  MINOR = 24
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

data/spec/adapters/mssql_spec.rb

@@ -40,6 +40,30 @@ describe "A MSSQL database" do
   end
 end
 
+describe "MSSQL decimal locale handling" do
+  before do
+    @locale = WIN32OLE.locale
+    @decimal = BigDecimal('1234.56')
+  end
+  after do
+    WIN32OLE.locale = @locale
+  end
+
+  it "should work with current locale" do
+    DB.get(Sequel.cast(@decimal, 'decimal(16,4)').as(:v)).must_equal @decimal
+  end
+
+  it "should work with 1031 locale" do
+    WIN32OLE.locale = 1031
+    DB.get(Sequel.cast(@decimal, 'decimal(16,4)').as(:v)).must_equal @decimal
+  end
+
+  it "should work with 1033 locale" do
+    WIN32OLE.locale = 1033
+    DB.get(Sequel.cast(@decimal, 'decimal(16,4)').as(:v)).must_equal @decimal
+  end
+end if DB.adapter_scheme == :ado
+
 describe "MSSQL" do
   before(:all) do
     @db = DB

data/spec/adapters/mysql_spec.rb

@@ -551,11 +551,6 @@ describe "A MySQL database" do
     db = Sequel.connect(DB.opts.merge(:read_timeout=>22342))
     db.test_connection
   end
-
-  it "should accept a connect_timeout option when connecting" do
-    db = Sequel.connect(DB.opts.merge(:connect_timeout=>22342))
-    db.test_connection
-  end
 end
 
 describe "MySQL foreign key support" do

data/spec/adapters/postgres_spec.rb

@@ -104,6 +104,24 @@ describe "PostgreSQL", '#create_table' do
     @db.check_constraints(:tmp_dolls).must_equal(:ic=>{:definition=>"CHECK ((i > 2))", :columns=>[:i]}, :jc=>{:definition=>"CHECK ((j > 2))", :columns=>[:j]}, :ijc=>{:definition=>"CHECK (((i - j) > 2))", :columns=>[:i, :j]})
   end
 
+  it "should have #check_constraints return check constraints where columns are unknown" do
+    begin
+      @db.create_table(:tmp_dolls) do
+        Integer :i
+        Integer :j
+      end
+      @db.run "CREATE OR REPLACE FUNCTION valid_tmp_dolls(t1 tmp_dolls) RETURNS boolean AS 'SELECT false' LANGUAGE SQL;"
+      @db.alter_table(:tmp_dolls) do
+        add_constraint(:valid_tmp_dolls, Sequel.function(:valid_tmp_dolls, :tmp_dolls))
+      end
+
+      @db.check_constraints(:tmp_dolls).must_equal(:valid_tmp_dolls=>{:definition=>"CHECK (valid_tmp_dolls(tmp_dolls.*))", :columns=>[]})
+    ensure
+      @db.run "ALTER TABLE tmp_dolls DROP CONSTRAINT IF EXISTS valid_tmp_dolls"
+      @db.run "DROP FUNCTION IF EXISTS valid_tmp_dolls(tmp_dolls)"
+    end
+  end if DB.server_version >= 90000
+
   it "should not allow to pass both :temp and :unlogged" do
     proc do
       @db.create_table(:temp_unlogged_dolls, :temp => true, :unlogged => true){text :name}
@@ -209,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}
@@ -334,6 +370,26 @@ describe "PostgreSQL", 'INSERT ON CONFLICT' do
   end
 end if DB.server_version >= 90500
 
+describe "A PostgreSQL database" do
+  before do
+    @db = DB
+    @db.create_table!(:cte_test){Integer :id}
+  end
+  after do
+    @db.drop_table?(:cte_test)
+  end
+
+  it "should give correct results for WITH AS [NOT] MATERIALIZED" do
+    @ds = @db[:cte_test]
+    @ds.insert(1)
+    @ds.insert(2)
+    
+    @db[:t].with(:t, @ds, :materialized=>nil).order(:id).map(:id).must_equal [1, 2]
+    @db[:t].with(:t, @ds, :materialized=>true).order(:id).map(:id).must_equal [1, 2]
+    @db[:t].with(:t, @ds, :materialized=>false).order(:id).map(:id).must_equal [1, 2]
+  end
+end if DB.server_version >= 120000
+
 describe "A PostgreSQL database" do
   before(:all) do
     @db = DB
@@ -2926,6 +2982,8 @@ describe 'PostgreSQL json type' do
     @h = {'a'=>'b', '1'=>[3, 4, 5]}
   end
   after do
+    @db.wrap_json_primitives = nil
+    @db.typecast_json_strings = nil
     @db.drop_table?(:items)
   end
 
@@ -2933,9 +2991,12 @@ describe 'PostgreSQL json type' do
   json_types << :jsonb if DB.server_version >= 90400
   json_types.each do |json_type|
     json_array_type = "#{json_type}[]"
-    pg_json = lambda{|v| Sequel.send(:"pg_#{json_type}", v)}
+    pg_json = Sequel.method(:"pg_#{json_type}")
+    pg_json_wrap = Sequel.method(:"pg_#{json_type}_wrap")
     hash_class = json_type == :jsonb ? Sequel::Postgres::JSONBHash : Sequel::Postgres::JSONHash
     array_class = json_type == :jsonb ? Sequel::Postgres::JSONBArray : Sequel::Postgres::JSONArray
+    str_class = json_type == :jsonb ? Sequel::Postgres::JSONBString : Sequel::Postgres::JSONString
+    object_class = json_type == :jsonb ? Sequel::Postgres::JSONBObject : Sequel::Postgres::JSONObject
 
     it 'insert and retrieve json values' do
       @db.create_table!(:items){column :j, json_type}
@@ -2965,6 +3026,44 @@ describe 'PostgreSQL json type' do
       @ds.all.must_equal rs
     end
 
+    it 'insert and retrieve json primitive values' do
+      @db.create_table!(:items){column :j, json_type}
+      ['str', 1, 2.5, nil, true, false].each do |rv|
+        @ds.delete
+        @ds.insert(pg_json_wrap.call(rv))
+        @ds.count.must_equal 1
+        rs = @ds.all
+        v = rs.first[:j]
+        v.class.must_equal(rv.class)
+        if rv.nil?
+          v.must_be_nil
+        else
+          v.must_equal rv
+        end
+      end
+
+      @db.wrap_json_primitives = true
+      ['str', 1, 2.5, nil, true, false].each do |rv|
+        @ds.delete
+        @ds.insert(pg_json_wrap.call(rv))
+        @ds.count.must_equal 1
+        rs = @ds.all
+        v = rs.first[:j]
+        v.class.ancestors.must_include(object_class)
+        v.__getobj__.must_be_kind_of(rv.class)
+        if rv.nil?
+          v.must_be_nil
+          v.__getobj__.must_be_nil
+        else
+          v.must_equal rv
+          v.__getobj__.must_equal rv
+        end
+        @ds.delete
+        @ds.insert(rs.first)
+        @ds.all[0][:j].must_equal rs[0][:j]
+      end
+    end
+
     it 'insert and retrieve json[] values' do
       @db.create_table!(:items){column :j, json_array_type}
       j = Sequel.pg_array([pg_json.call('a'=>1), pg_json.call(['b', 2])])
@@ -2981,16 +3080,122 @@ describe 'PostgreSQL json type' do
       @ds.all.must_equal rs
     end
 
+    it 'insert and retrieve json[] values with json primitives' do
+      @db.create_table!(:items){column :j, json_array_type}
+      raw = ['str', 1, 2.5, nil, true, false]
+      j = Sequel.pg_array(raw.map(&pg_json_wrap), json_type)
+      @ds.insert(j)
+      @ds.count.must_equal 1
+      rs = @ds.all
+      v = rs.first[:j]
+      v.class.must_equal(Sequel::Postgres::PGArray)
+      v.to_a.must_be_kind_of(Array)
+      v.map(&:class).must_equal raw.map(&:class)
+      v.must_equal raw
+      v.to_a.must_equal raw
+
+      @db.wrap_json_primitives = true
+      j = Sequel.pg_array(raw.map(&pg_json_wrap), json_type)
+      @ds.insert(j)
+      rs = @ds.all
+      v = rs.first[:j]
+      v.class.must_equal(Sequel::Postgres::PGArray)
+      v.to_a.must_be_kind_of(Array)
+      v.map(&:class).each{|c| c.ancestors.must_include(object_class)}
+      [v, v.to_a].each do |v0|
+        v0.zip(raw) do |v1, r1|
+          if r1.nil?
+            v1.must_be_nil
+            v1.__getobj__.must_be_nil
+          else
+            v1.must_equal r1
+            v1.__getobj__.must_equal r1
+          end
+        end
+      end
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all[0][:j].zip(rs[0][:j]) do |v1, r1|
+        if v1.__getobj__.nil?
+          v1.must_be_nil
+          v1.__getobj__.must_be_nil
+        else
+          v1.must_equal r1
+          v1.must_equal r1.__getobj__
+          v1.__getobj__.must_equal r1
+          v1.__getobj__.must_equal r1.__getobj__
+        end
+      end
+    end
+
     it 'with models' do
       @db.create_table!(:items) do
         primary_key :id
         column :h, json_type
       end
       c = Class.new(Sequel::Model(@db[:items]))
+      c.create(:h=>@h).h.must_equal @h
+      c.create(:h=>@a).h.must_equal @a
       c.create(:h=>pg_json.call(@h)).h.must_equal @h
       c.create(:h=>pg_json.call(@a)).h.must_equal @a
     end
 
+    it 'with models with json primitives' do
+      @db.create_table!(:items) do
+        primary_key :id
+        column :h, json_type
+      end
+      c = Class.new(Sequel::Model(@db[:items]))
+
+      ['str', 1, 2.5, nil, true, false].each do |v|
+        @db.wrap_json_primitives = nil
+        cv = c[c.insert(:h=>pg_json_wrap.call(v))]
+        cv.h.class.ancestors.wont_include(object_class)
+        if v.nil?
+          cv.h.must_be_nil
+        else
+          cv.h.must_equal v
+        end
+
+        @db.wrap_json_primitives = true
+        cv.refresh
+        cv.h.class.ancestors.must_include(object_class)
+        cv.save
+        cv.refresh
+        cv.h.class
+
+        if v.nil?
+          cv.h.must_be_nil
+        else
+          cv.h.must_equal v
+        end
+
+        c.new(:h=>cv.h).h.class.ancestors.must_include(object_class)
+      end
+
+      v = c.new(:h=>'{}').h
+      v.class.must_equal hash_class
+      v.must_equal({})
+      @db.typecast_json_strings = true
+      v = c.new(:h=>'{}').h
+      v.class.must_equal str_class
+      v.must_equal '{}'
+
+      c.new(:h=>'str').h.class.ancestors.must_include(object_class)
+      c.new(:h=>'str').h.must_equal 'str'
+      c.new(:h=>1).h.class.ancestors.must_include(object_class)
+      c.new(:h=>1).h.must_equal 1
+      c.new(:h=>2.5).h.class.ancestors.must_include(object_class)
+      c.new(:h=>2.5).h.must_equal 2.5
+      c.new(:h=>true).h.class.ancestors.must_include(object_class)
+      c.new(:h=>true).h.must_equal true
+      c.new(:h=>false).h.class.ancestors.must_include(object_class)
+      c.new(:h=>false).h.must_equal false
+
+      c.new(:h=>nil).h.class.ancestors.wont_include(object_class)
+      c.new(:h=>nil).h.must_be_nil
+    end
+
     it 'with empty json default values and defaults_setter plugin' do
       @db.create_table!(:items) do
         column :h, json_type, :default=>hash_class.new({})
@@ -3025,6 +3230,36 @@ describe 'PostgreSQL json type' do
       @ds.get(:i).must_equal j
     end if uses_pg_or_jdbc
 
+    it 'use json primitives in bound variables' do
+      @db.create_table!(:items){column :i, json_type}
+      @db.wrap_json_primitives = true
+      raw = ['str', 1, 2.5, nil, true, false]
+      raw.each do |v|
+        @ds.delete
+        @ds.call(:insert, {:i=>@db.get(pg_json_wrap.call(v))}, {:i=>:$i})
+        rv = @ds.get(:i)
+        rv.class.ancestors.must_include(object_class)
+        if v.nil?
+          rv.must_be_nil
+        else
+          rv.must_equal v
+        end
+      end
+
+      @db.create_table!(:items){column :i, json_array_type}
+      j = Sequel.pg_array(raw.map(&pg_json_wrap), json_type)
+      @ds.call(:insert, {:i=>j}, {:i=>:$i})
+      @ds.all[0][:i].zip(raw) do |v1, r1|
+        if v1.__getobj__.nil?
+          v1.must_be_nil
+          v1.__getobj__.must_be_nil
+        else
+          v1.must_equal r1
+          v1.__getobj__.must_equal r1
+        end
+      end
+    end if uses_pg_or_jdbc
+
     it 'operations/functions with pg_json_ops' do
       Sequel.extension :pg_json_ops
       jo = pg_json.call('a'=>1, 'b'=>{'c'=>2, 'd'=>{'e'=>3}}).op
@@ -3384,6 +3619,30 @@ describe 'PostgreSQL range types' do
     @ds.filter(h).call(:delete, @ra).must_equal 1
   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...')
+  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")
+  end if RUBY_VERSION >= '2.7'
+
+  it 'handle startless ranges' do
+    @db.get(Sequel.cast(eval('nil...nil'), :int4range)).must_be :==, Sequel::Postgres::PGRange.new(nil, nil, :exclude_begin=>true, :exclude_end=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('nil...nil'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, nil, :exclude_begin=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('nil...nil'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, nil, :exclude_end=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('nil...nil'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(1, nil, :exclude_begin=>true, :db_type=>"int4range")
+    @db.get(Sequel.cast(eval('nil...nil'), :int4range)).wont_be :==, Sequel::Postgres::PGRange.new(nil, 1, :exclude_begin=>true, :db_type=>"int4range")
+  end if RUBY_VERSION >= '2.7'
+
   it 'parse default values for schema' do
     @db.create_table!(:items) do
       Integer :j
@@ -3988,6 +4247,10 @@ describe "pg_auto_constraint_validations plugin" do
       constraint :valid_i, Sequel[:i] < 10
       constraint(:valid_i_id, Sequel[:i] + Sequel[:id] < 20)
     end
+    @db.run "CREATE OR REPLACE FUNCTION valid_test1(t1 test1) RETURNS boolean AS 'SELECT t1.i != -100' LANGUAGE SQL;"
+    @db.alter_table(:test1) do
+      add_constraint(:valid_test1, Sequel.function(:valid_test1, :test1))
+    end
     @db.create_table!(:test2) do
       Integer :test2_id, :primary_key=>true
       foreign_key :test1_id, :test1
@@ -4008,6 +4271,8 @@ describe "pg_auto_constraint_validations plugin" do
     @c2.insert(:test2_id=>3, :test1_id=>1)
   end
   after(:all) do
+    @db.run "ALTER TABLE test1 DROP CONSTRAINT IF EXISTS valid_test1"
+    @db.run "DROP FUNCTION IF EXISTS valid_test1(test1)"
     @db.drop_table?(:test2, :test1)
   end
 
@@ -4017,6 +4282,14 @@ describe "pg_auto_constraint_validations plugin" do
     o.errors.must_equal(:i=>['is invalid'])
   end
 
+  it "should handle check constraint failures where the columns are unknown, if columns are explicitly specified" do
+    o = @c1.new(:id=>5, :i=>-100)
+    proc{o.save}.must_raise Sequel::CheckConstraintViolation
+    @c1.pg_auto_constraint_validation_override(:valid_test1, :i, "should not be -100")
+    proc{o.save}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['should not be -100'])
+  end
+
   it "should handle check constraint failures as validation errors when updating" do
     o = @c1.new(:id=>5, :i=>3)
     o.save
@@ -4090,4 +4363,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
+
+  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)