sequel 5.21.0 → 5.26.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
 
@@ -1086,11 +1088,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 = 21
+  MINOR = 26
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

data/spec/adapters/postgres_spec.rb

@@ -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,8 +368,36 @@ 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
+  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
@@ -3303,6 +3349,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
@@ -3581,6 +3686,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
@@ -4301,4 +4430,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)