sequel 5.60.1 → 5.81.0

data/lib/sequel/plugins/concurrent_eager_loading.rb

@@ -50,10 +50,10 @@ module Sequel
     # support concurrent eager loading.  Taking this example from the
     # {Advanced Associations guide}[rdoc-ref:doc/advanced_associations.rdoc]
     #
-    #   Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
+    #   Album.many_to_one :artist, eager_loader: (proc do |eo_opts|
     #     eo_opts[:rows].each{|album| album.associations[:artist] = nil}
     #     id_map = eo_opts[:id_map]
-    #     Artist.where(:id=>id_map.keys).all do |artist|
+    #     Artist.where(id: id_map.keys).all do |artist|
     #       if albums = id_map[artist.id]
     #         albums.each do |album|
     #           album.associations[:artist] = artist
@@ -74,12 +74,12 @@ module Sequel
     # the code that loads the objects, since that will prevent concurrent loading.
     # So after the changes, the custom eager loader would look like this:
     #
-    #   Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
+    #   Album.many_to_one :artist, eager_loader: (proc do |eo_opts|
     #     Sequel.synchronize_with(eo[:mutex]) do
     #       eo_opts[:rows].each{|album| album.associations[:artist] = nil}
     #     end
     #     id_map = eo_opts[:id_map]
-    #     rows = Artist.where(:id=>id_map.keys).all
+    #     rows = Artist.where(id: id_map.keys).all
     #     Sequel.synchronize_with(eo[:mutex]) do
     #       rows.each do |artist|
     #         if albums = id_map[artist.id]

data/lib/sequel/plugins/constraint_validations.rb

@@ -125,14 +125,15 @@ module Sequel
             ds = @dataset.with_quote_identifiers(false)
             table_name = ds.literal(ds.first_source_table)
             reflections = {}
-            @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections)}
+            allow_missing_columns = db_schema.select{|col, sch| sch[:allow_null] == false && nil != sch[:default]}.map(&:first)
+            @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections, allow_missing_columns)}
             @constraint_validation_reflections = reflections
           end
         end
 
         # Given a specific database constraint validation metadata row hash, transform
         # it in an validation method call array suitable for splatting to send.
-        def constraint_validation_array(r, reflections)
+        def constraint_validation_array(r, reflections, allow_missing_columns=EMPTY_ARRAY)
           opts = {}
           opts[:message] = r[:message] if r[:message]
           opts[:allow_nil] = true if db.typecast_value(:boolean, r[:allow_nil])
@@ -191,11 +192,13 @@ module Sequel
             reflection_opts[:argument] = arg
           end 
 
-          a << column
-          unless opts.empty?
-            a << opts
+          opts[:from] = :values
+          if column.is_a?(Symbol) && allow_missing_columns.include?(column)
+            opts[:allow_missing] = true
           end
 
+          a << column << opts
+
           if column.is_a?(Array) && column.length == 1
             column = column.first
           end

data/lib/sequel/plugins/defaults_setter.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require 'delegate'
+
 module Sequel
   module Plugins
     # The defaults_setter plugin makes the column getter methods return the default
@@ -106,6 +108,20 @@ module Sequel
             lambda{Date.today}
           when Sequel::CURRENT_TIMESTAMP
             lambda{dataset.current_datetime}
+          when Hash, Array
+            v = Marshal.dump(v).freeze
+            lambda{Marshal.load(v)}
+          when Delegator
+            # DelegateClass returns an anonymous case, which cannot be marshalled, so marshal the
+            # underlying object and create a new instance of the class with the unmarshalled object.
+            klass = v.class
+            case o = v.__getobj__
+            when Hash, Array
+              v = Marshal.dump(o).freeze
+              lambda{klass.new(Marshal.load(v))}
+            else
+              v
+            end
           else
             v
           end

data/lib/sequel/plugins/dirty.rb

@@ -37,7 +37,7 @@ module Sequel
     #
     # It also saves the previously changed values after an update:
     #
-    #   artist.update(:name=>'Bar')
+    #   artist.update(name: 'Bar')
     #   artist.column_changes        # => {}
     #   artist.previous_changes      # => {:name=>['Foo', 'Bar']}
     #

data/lib/sequel/plugins/finder.rb

@@ -97,7 +97,9 @@ module Sequel
         #   Artist.first_by_name(nil)
         #   # WHERE (name IS NULL)
         #
-        # See Dataset::PlaceholderLiteralizer for additional caveats.
+        # See Dataset::PlaceholderLiteralizer for additional caveats. Note that if the model's
+        # dataset does not support placeholder literalizers, you will not be able to use this
+        # method.
         def finder(meth=OPTS, opts=OPTS, &block)
           if block
             raise Error, "cannot pass both a method name argument and a block of Model.finder" unless meth.is_a?(Hash)
@@ -149,7 +151,7 @@ module Sequel
                 ds
               end
 
-              Sequel::Dataset::PlaceholderLiteralizer.loader(model, &block) 
+              model.dataset.placeholder_literalizer_class.loader(model, &block) 
             end
           end
 

data/lib/sequel/plugins/input_transformer.rb

@@ -24,7 +24,7 @@ module Sequel
     #   # Make the Album class support input transformers 
     #   Album.plugin :input_transformer
     module InputTransformer
-      def self.apply(model, *)
+      def self.apply(model, *, &_)
         model.instance_exec do
           @input_transformers = {}
           @skip_input_transformer_columns = {}

data/lib/sequel/plugins/list.rb

@@ -185,10 +185,13 @@ module Sequel
         end
 
         # Set the value of the position_field to the maximum value plus 1 unless the
-        # position field already has a value.
+        # position field already has a value. If the list is empty, the position will
+        # be set to the model's +top_of_list+ value.
         def before_validation
           unless get_column_value(position_field)
-            set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
+            current_max = list_dataset.max(position_field)
+            value = current_max.nil? ? model.top_of_list : current_max.to_i + 1
+            set_column_value("#{position_field}=", value)
           end
           super
         end

data/lib/sequel/plugins/many_through_many.rb

@@ -385,7 +385,7 @@ module Sequel
                 iq = nil
               end
               fe = opts.final_edge
-              ds.graph(opts.associated_class.dataset, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
+              ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
             end
           end
         end

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -26,57 +26,27 @@ module Sequel
     module MssqlOptimisticLocking
       # Load the instance_filters plugin into the model.
       def self.apply(model, opts=OPTS)
-        model.plugin :instance_filters
+        model.plugin(:optimistic_locking_base)
       end
 
-      # Set the lock_column to the :lock_column option (default: :timestamp)
+      # Set the lock column
       def self.configure(model, opts=OPTS)
-        model.lock_column = opts[:lock_column] || :timestamp
+        model.lock_column = opts[:lock_column] || model.lock_column || :timestamp
       end
-
-      module ClassMethods
-        # The timestamp/rowversion column containing the version for the current row.
-        attr_accessor :lock_column
-
-        Plugins.inherited_instance_variables(self, :@lock_column=>nil)
-      end
-
+      
       module InstanceMethods
-        # Add the lock column instance filter to the object before destroying it.
-        def before_destroy
-          lock_column_instance_filter
-          super
-        end
-        
-        # Add the lock column instance filter to the object before updating it.
-        def before_update
-          lock_column_instance_filter
-          super
-        end
-        
         private
         
-        # Add the lock column instance filter to the object.
-        def lock_column_instance_filter
-          lc = model.lock_column
-          instance_filter(lc=>Sequel.blob(get_column_value(lc)))
-        end
-
-        # Clear the instance filters when refreshing, so that attempting to
-        # refresh after a failed save removes the previous lock column filter
-        # (the new one will be added before updating).
-        def _refresh(ds)
-          clear_instance_filters
-          super
+        # Make the instance filter value a blob.
+        def lock_column_instance_filter_value
+          Sequel.blob(super)
         end
 
         # Remove the lock column from the columns to update.
         # SQL Server automatically updates the lock column value, and does not like
         # it to be assigned.
         def _save_update_all_columns_hash
-          v = @values.dup
-          cc = changed_columns
-          Array(primary_key).each{|x| v.delete(x) unless cc.include?(x)}
+          v = super
           v.delete(model.lock_column)
           v
         end

data/lib/sequel/plugins/nested_attributes.rb

@@ -33,7 +33,7 @@ module Sequel
     # objects.  You just need to make sure that the primary key field is filled in for the
     # associated object:
     #
-    #   a.update(:albums_attributes => [{id: 1, name: 'T'}])
+    #   a.update(albums_attributes: [{id: 1, name: 'T'}])
     #
     # Since the primary key field is filled in, the plugin will update the album with id 1 instead
     # of creating a new album.
@@ -42,14 +42,14 @@ module Sequel
     # entry to the hash, and also pass the :destroy option when calling +nested_attributes+:
     #
     #   Artist.nested_attributes :albums, destroy: true
-    #   a.update(:albums_attributes => [{id: 1, _delete: true}])
+    #   a.update(albums_attributes: [{id: 1, _delete: true}])
     #
     # This will delete the related associated object from the database.  If you want to leave the
     # associated object in the database, but just remove it from the association, add a _remove
     # entry in the hash, and also pass the :remove option when calling +nested_attributes+:
     #
     #   Artist.nested_attributes :albums, remove: true
-    #   a.update(:albums_attributes => [{id: 1, _remove: true}])
+    #   a.update(albums_attributes: [{id: 1, _remove: true}])
     #
     # The above example was for a one_to_many association, but the plugin also works similarly
     # for other association types.  For one_to_one and many_to_one associations, you need to
@@ -84,7 +84,7 @@ module Sequel
     # nested attributes options for that association.  This is useful for per-call filtering
     # of the allowed fields:
     #
-    #   a.set_nested_attributes(:albums, params['artist'], :fields=>%w'name')
+    #   a.set_nested_attributes(:albums, params['artist'], fields: %w'name')
     module NestedAttributes
       # Depend on the validate_associated plugin.
       def self.apply(model)

data/lib/sequel/plugins/optimistic_locking.rb

@@ -12,64 +12,31 @@ module Sequel
     #   p1 = Person[1]
     #   p2 = Person[1]
     #   p1.update(name: 'Jim') # works
-    #   p2.update(name: 'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
+    #   p2.update(name: 'Bob') # raises Sequel::NoExistingObject
     #
     # In order for this plugin to work, you need to make sure that the database
-    # table has a +lock_version+ column (or other column you name via the lock_column
-    # class level accessor) that defaults to 0.
+    # table has a +lock_version+ column that defaults to 0. To change the column
+    # used, provide a +:lock_column+ option when loading the plugin:
+    #
+    #     plugin :optimistic_locking, lock_column: :version
     #
     # This plugin relies on the instance_filters plugin.
     module OptimisticLocking
       # Exception class raised when trying to update or destroy a stale object.
       Error = Sequel::NoExistingObject
       
-      # Load the instance_filters plugin into the model.
       def self.apply(model, opts=OPTS)
-        model.plugin :instance_filters
+        model.plugin(:optimistic_locking_base)
       end
 
-      # Set the lock_column to the :lock_column option, or :lock_version if
-      # that option is not given.
+      # Set the lock column
       def self.configure(model, opts=OPTS)
-        model.lock_column = opts[:lock_column] || :lock_version
+        model.lock_column = opts[:lock_column] || model.lock_column || :lock_version
       end
-      
-      module ClassMethods
-        # The column holding the version of the lock
-        attr_accessor :lock_column
-        
-        Plugins.inherited_instance_variables(self, :@lock_column=>nil)
-      end
-    
+
       module InstanceMethods
-        # Add the lock column instance filter to the object before destroying it.
-        def before_destroy
-          lock_column_instance_filter
-          super
-        end
-        
-        # Add the lock column instance filter to the object before updating it.
-        def before_update
-          lock_column_instance_filter
-          super
-        end
-        
         private
         
-        # Add the lock column instance filter to the object.
-        def lock_column_instance_filter
-          lc = model.lock_column
-          instance_filter(lc=>get_column_value(lc))
-        end
-
-        # Clear the instance filters when refreshing, so that attempting to
-        # refresh after a failed save removes the previous lock column filter
-        # (the new one will be added before updating).
-        def _refresh(ds)
-          clear_instance_filters
-          super
-        end
-        
         # Only update the row if it has the same lock version, and increment the
         # lock version.
         def _update_columns(columns)

data/lib/sequel/plugins/optimistic_locking_base.rb

@@ -0,0 +1,55 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # Base for other optimistic locking plugins
+    module OptimisticLockingBase
+      # Load the instance_filters plugin into the model.
+      def self.apply(model)
+        model.plugin :instance_filters
+      end
+
+      module ClassMethods
+        # The column holding the version of the lock
+        attr_accessor :lock_column
+        
+        Plugins.inherited_instance_variables(self, :@lock_column=>nil)
+      end
+    
+      module InstanceMethods
+        # Add the lock column instance filter to the object before destroying it.
+        def before_destroy
+          lock_column_instance_filter
+          super
+        end
+        
+        # Add the lock column instance filter to the object before updating it.
+        def before_update
+          lock_column_instance_filter
+          super
+        end
+        
+        private
+        
+        # Add the lock column instance filter to the object.
+        def lock_column_instance_filter
+          instance_filter(model.lock_column=>lock_column_instance_filter_value)
+        end
+
+        # Use the current value of the lock column
+        def lock_column_instance_filter_value
+          public_send(model.lock_column)
+        end
+
+        # Clear the instance filters when refreshing, so that attempting to
+        # refresh after a failed save removes the previous lock column filter
+        # (the new one will be added before updating).
+        def _refresh(ds)
+          clear_instance_filters
+          super
+        end
+      end
+    end
+  end
+end
+

data/lib/sequel/plugins/paged_operations.rb

@@ -0,0 +1,181 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The paged_operations plugin adds +paged_update+ and
+    # +paged_delete+ dataset methods.  These behave similarly to
+    # the default +update+ and +delete+ dataset methods, except
+    # that the update or deletion is done in potentially multiple
+    # queries (by default, affecting 1000 rows per query).
+    # For a large table, this prevents the change from
+    # locking the table for a long period of time.
+    #
+    # Because the point of this is to prevent locking tables for
+    # long periods of time, the separate queries are not contained
+    # in a transaction, which means if a later query fails,
+    # earlier queries will still be committed.  You could prevent
+    # this by using a transaction manually, but that defeats the
+    # purpose of using these methods.
+    #
+    # Examples:
+    #
+    #   Album.where{name <= 'M'}.paged_update(updated_at: Sequel::CURRENT_TIMESTAMP)
+    #   # SELECT id FROM albums WHERE (name <= 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    #   # UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE ((name <= 'M') AND ("id" < 1002))
+    #   # SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 1002)) ORDER BY id LIMIT 1 OFFSET 1000
+    #   # UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE ((name <= 'M') AND ("id" < 2002) AND (id >= 1002))
+    #   # ...
+    #   # SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 10002)) ORDER BY id LIMIT 1 OFFSET 1000
+    #   # UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE ((name <= 'M') AND (id >= 10002))
+    #
+    #   Album.where{name > 'M'}.paged_delete
+    #   # SELECT id FROM albums WHERE (name > 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    #   # DELETE FROM albums WHERE ((name > 'M') AND (id < 1002))
+    #   # SELECT id FROM albums WHERE (name > 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    #   # DELETE FROM albums WHERE ((name > 'M') AND (id < 2002))
+    #   # ...
+    #   # SELECT id FROM albums WHERE (name > 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    #   # DELETE FROM albums WHERE (name > 'M')
+    #
+    # The plugin also adds a +paged_datasets+ method that will yield
+    # separate datasets limited in size that in total handle all
+    # rows in the receiver:
+    #
+    #   Album.where{name > 'M'}.paged_datasets{|ds| puts ds.sql}
+    #   # Runs: SELECT id FROM albums WHERE (name <= 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    #   # Prints: SELECT * FROM albums WHERE ((name <= 'M') AND ("id" < 1002))
+    #   # Runs: SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 1002)) ORDER BY id LIMIT 1 OFFSET 1000
+    #   # Prints: SELECT * FROM albums WHERE ((name <= 'M') AND ("id" < 2002) AND (id >= 1002))
+    #   # ...
+    #   # Runs: SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 10002)) ORDER BY id LIMIT 1 OFFSET 1000
+    #   # Prints: SELECT * FROM albums WHERE ((name <= 'M') AND (id >= 10002))
+    #
+    # To set the number of rows per page, pass a :rows_per_page option:
+    #
+    #   Album.where{name <= 'M'}.paged_update({x: Sequel[:x] + 1}, rows_per_page: 4)
+    #   # SELECT id FROM albums WHERE (name <= 'M') ORDER BY id LIMIT 1 OFFSET 4
+    #   # UPDATE albums SET x = x + 1 WHERE ((name <= 'M') AND ("id" < 5))
+    #   # SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 5)) ORDER BY id LIMIT 1 OFFSET 4
+    #   # UPDATE albums SET x = x + 1 WHERE ((name <= 'M') AND ("id" < 9) AND (id >= 5))
+    #   # ...
+    #   # SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 12345)) ORDER BY id LIMIT 1 OFFSET 4
+    #   # UPDATE albums SET x = x + 1 WHERE ((name <= 'M') AND (id >= 12345))
+    # 
+    # You should avoid using +paged_update+ or +paged_datasets+
+    # with updates that modify the primary key, as such usage is
+    # not supported by this plugin.
+    #
+    # This plugin only supports models with scalar primary keys.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support paged update/delete/datasets
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :paged_operations
+    #
+    #   # Make the Album class support paged update/delete/datasets
+    #   Album.plugin :paged_operations
+    module PagedOperations
+      module ClassMethods
+        Plugins.def_dataset_methods(self, [:paged_datasets, :paged_delete, :paged_update])
+      end
+
+      module DatasetMethods
+        # Yield datasets for subsets of the receiver that are limited
+        # to no more than 1000 rows (you can configure the number of
+        # rows using +:rows_per_page+).
+        #
+        # Options:
+        # :rows_per_page :: The maximum number of rows in each yielded dataset
+        #                   (unless concurrent modifications are made to the table).
+        def paged_datasets(opts=OPTS)
+          unless defined?(yield)
+            return enum_for(:paged_datasets, opts)
+          end
+
+          pk = _paged_operations_pk(:paged_update)
+          base_offset_ds = offset_ds = _paged_operations_offset_ds(opts)
+          first = nil
+
+          while last = offset_ds.get(pk)
+            ds = where(pk < last)
+            ds = ds.where(pk >= first) if first
+            yield ds
+            first = last
+            offset_ds = base_offset_ds.where(pk >= first)
+          end
+
+          ds = self
+          ds = ds.where(pk >= first) if first
+          yield ds
+          nil
+        end
+
+        # Delete all rows of the dataset using using multiple queries so that
+        # no more than 1000 rows are deleted at a time (you can configure the
+        # number of rows using +:rows_per_page+).
+        #
+        # Options:
+        # :rows_per_page :: The maximum number of rows affected by each DELETE query
+        #                   (unless concurrent modifications are made to the table).
+        def paged_delete(opts=OPTS)
+          if (db.database_type == :oracle && !supports_fetch_next_rows?) || (db.database_type == :mssql && !is_2012_or_later?)
+            raise Error, "paged_delete is not supported on MSSQL/Oracle when using emulated offsets"
+          end
+          pk = _paged_operations_pk(:paged_delete)
+          rows_deleted = 0
+          offset_ds = _paged_operations_offset_ds(opts)
+          while last = offset_ds.get(pk)
+            rows_deleted += where(pk < last).delete
+          end
+          rows_deleted + delete
+        end
+
+        # Update all rows of the dataset using using multiple queries so that
+        # no more than 1000 rows are updated at a time (you can configure the
+        # number of rows using +:rows_per_page+). All arguments are
+        # passed to Dataset#update.
+        #
+        # Options:
+        # :rows_per_page :: The maximum number of rows affected by each UPDATE query
+        #                   (unless concurrent modifications are made to the table).
+        def paged_update(values, opts=OPTS)
+          rows_updated = 0
+          paged_datasets(opts) do |ds|
+            rows_updated += ds.update(values)
+          end
+          rows_updated
+        end
+
+        private
+
+        # Run some basic checks common to paged_{datasets,delete,update}
+        # and return the primary key to operate on as a Sequel::Identifier.
+        def _paged_operations_pk(meth)
+          raise Error, "cannot use #{meth} if dataset has a limit or offset" if @opts[:limit] || @opts[:offset]
+          if db.database_type == :db2 && db.offset_strategy == :emulate
+            raise Error, "the paged_operations plugin is not supported on DB2 when using emulated offsets, set the :offset_strategy Database option to 'limit_offset' or 'offset_fetch'"
+          end
+
+          case pk = model.primary_key
+          when Symbol
+            Sequel.identifier(pk)
+          when Array
+            raise Error, "cannot use #{meth} on a model with a composite primary key"
+          else
+            raise Error, "cannot use #{meth} on a model without a primary key"
+          end
+        end
+
+        # The dataset that will be used by paged_{datasets,delete,update}
+        # to get the upper limit for the next query.
+        def _paged_operations_offset_ds(opts)
+          if rows_per_page = opts[:rows_per_page]
+            raise Error, ":rows_per_page option must be at least 1" unless rows_per_page >= 1
+          end
+          _force_primary_key_order.offset(rows_per_page || 1000)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -28,11 +28,13 @@ module Sequel
     #
     # This plugin only works on the postgres adapter when using the pg 0.16+ driver,
     # PostgreSQL 9.3+ server, and PostgreSQL 9.3+ client library (libpq). In other cases
-    # it will be a no-op.
+    # it will be a no-op. Additionally, the plugin only handles models that select
+    # from tables.  It does not handle models that select from subqueries, such as
+    # subclasses of models using the class_table_inheritance plugin.
     #
     # Example:
     #
-    #   album = Album.new(:artist_id=>1) # Assume no such artist exists
+    #   album = Album.new(artist_id: 1) # Assume no such artist exists
     #   begin
     #     album.save
     #   rescue Sequel::ValidationFailed
@@ -131,7 +133,11 @@ module Sequel
         # Dump the in-memory cached metadata to the cache file.
         def dump_pg_auto_constraint_validations_cache
           raise Error, "No pg_auto_constraint_validations setup" unless file = @pg_auto_constraint_validations_cache_file
-          File.open(file, 'wb'){|f| f.write(Marshal.dump(@pg_auto_constraint_validations_cache))}
+          pg_auto_constraint_validations_cache = {}
+          @pg_auto_constraint_validations_cache.sort.each do |k, v|
+            pg_auto_constraint_validations_cache[k] = v
+          end
+          File.open(file, 'wb'){|f| f.write(Marshal.dump(pg_auto_constraint_validations_cache))}
           nil
         end