sequel 5.67.0 → 5.74.0

data/lib/sequel/extensions/migration.rb

@@ -159,6 +159,19 @@ module Sequel
       migration.up = block
       migration.down = MigrationReverser.new.reverse(&block)
     end
+
+    # Creates a revert migration.  This is the same as creating
+    # the same block with +down+, but it also calls the block and attempts
+    # to create a +up+ block that will reverse the changes made by
+    # the block.  This is designed to revert the changes in the
+    # provided block.
+    #
+    # There are no guarantees that this will work perfectly
+    # in all cases, but it works for some simple cases.
+    def revert(&block)
+      migration.down = block
+      migration.up = MigrationReverser.new.reverse(&block)
+    end
   end
 
   # Handles the reversing of reversible migrations.  Basically records
@@ -270,6 +283,10 @@ module Sequel
     def rename_column(name, new_name)
       @actions << [:rename_column, new_name, name]
     end
+
+    def set_column_allow_null(name, allow_null=true)
+      @actions << [:set_column_allow_null, name, !allow_null]
+    end
   end
 
   # The preferred method for writing Sequel migrations, using a DSL:
@@ -478,11 +495,7 @@ module Sequel
         @use_transactions
       end
 
-      if use_trans
-        db.transaction(&block)
-      else
-        yield
-      end
+      db.transaction(:skip_transaction=>use_trans == false, &block)
     end
 
     # Load the migration file, raising an exception if the file does not define

data/lib/sequel/extensions/pg_array.rb

@@ -233,6 +233,14 @@ module Sequel
             a
           when String
             bound_variable_array_string(a)
+          when Float
+            if a.infinite?
+              a > 0 ? '"Infinity"' : '"-Infinity"'
+            elsif a.nan?
+              '"NaN"'
+            else
+              literal(a)
+            end
           else
             if (s = bound_variable_arg(a, nil)).is_a?(String)
               bound_variable_array_string(s)
@@ -257,7 +265,7 @@ module Sequel
         end
 
         # Make the column type detection handle registered array types.
-        def schema_column_type(db_type)
+        def schema_array_type(db_type)
           if (db_type =~ /\A([^(]+)(?:\([^(]+\))?\[\]\z/io) && (type = pg_array_schema_type($1))
             type
           else

data/lib/sequel/extensions/pg_auto_parameterize_in_array.rb

@@ -0,0 +1,110 @@
+# frozen-string-literal: true
+#
+# The pg_auto_parameterize_in_array extension builds on the pg_auto_parameterize
+# extension, adding support for handling additional types when converting from
+# IN to = ANY and NOT IN to != ALL:
+#
+#   DB[:table].where(column: [1.0, 2.0, ...])
+#   # Without extension: column IN ($1::numeric, $2:numeric, ...) # bound variables: 1.0, 2.0, ...
+#   # With extension:    column = ANY($1::numeric[]) # bound variables: [1.0, 2.0, ...]
+#
+# This prevents the use of an unbounded number of bound variables based on the
+# size of the array, as well as using different SQL for different array sizes.
+#
+# The following types are supported when doing the conversions, with the database
+# type used:
+#
+# Float :: if any are infinite or NaN, double precision, otherwise numeric
+# BigDecimal :: numeric
+# Date :: date
+# Time :: timestamp (or timestamptz if pg_timestamptz extension is used)
+# DateTime :: timestamp (or timestamptz if pg_timestamptz extension is used)
+# Sequel::SQLTime :: time
+# Sequel::SQL::Blob :: bytea
+# 
+# String values are also supported using the +text+ type, but only if the 
+# +:treat_string_list_as_text_array+ Database option is used. This is because
+# treating strings as text can break programs, since the type for
+# literal strings in PostgreSQL is +unknown+, not +text+.
+#
+# The conversion is only done for single dimensional arrays that have more
+# than two elements, where all elements are of the same class (other than
+# nil values).
+#
+# Related module: Sequel::Postgres::AutoParameterizeInArray
+
+module Sequel
+  module Postgres
+    # Enable automatically parameterizing queries.
+    module AutoParameterizeInArray
+      # Transform column IN (...) expressions into column = ANY($)
+      # and column NOT IN (...) expressions into column != ALL($)
+      # using an array bound variable for the ANY/ALL argument,
+      # if all values inside the predicate are of the same type and
+      # the type is handled by the extension.
+      # This is the same optimization PostgreSQL performs internally,
+      # but this reduces the number of bound variables.
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :IN, :"NOT IN"
+          l, r = args
+          if auto_param?(sql) && (type = _bound_variable_type_for_array(r))
+            if op == :IN 
+              op = :"="
+              func = :ANY
+            else
+              op = :!=
+              func = :ALL
+            end
+            args = [l, Sequel.function(func, Sequel.pg_array(r, type))]
+          end
+        end
+
+        super
+      end
+
+      private
+
+      # The bound variable type string to use for the bound variable array.
+      # Returns nil if a bound variable should not be used for the array.
+      def _bound_variable_type_for_array(r)
+        return unless Array === r && r.size > 1
+        classes = r.map(&:class)
+        classes.uniq!
+        classes.delete(NilClass)
+        return unless classes.size == 1
+
+        klass = classes[0]
+        if klass == Integer
+          # This branch is not taken on Ruby <2.4, because of the Fixnum/Bignum split.
+          # However, that causes no problems as pg_auto_parameterize handles integer
+          # arrays natively (though the SQL used is different)
+          "int8"
+        elsif klass == String
+          "text" if db.typecast_value(:boolean, db.opts[:treat_string_list_as_text_array])
+        elsif klass == BigDecimal
+          "numeric"
+        elsif klass == Date
+          "date"
+        elsif klass == Time
+          @db.cast_type_literal(Time)
+        elsif klass == Float
+          # PostgreSQL treats literal floats as numeric, not double precision
+          # But older versions of PostgreSQL don't handle Infinity/NaN in numeric
+          r.all?{|v| v.nil? || v.finite?} ? "numeric" : "double precision"
+        elsif klass == Sequel::SQLTime
+          "time"
+        elsif klass == DateTime
+          @db.cast_type_literal(DateTime)
+        elsif klass == Sequel::SQL::Blob
+          "bytea"
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:pg_auto_parameterize_in_array) do |db|
+    db.extension(:pg_array, :pg_auto_parameterize)
+    db.extend_datasets(Postgres::AutoParameterizeInArray)
+  end
+end

data/lib/sequel/extensions/pg_enum.rb

@@ -166,8 +166,7 @@ module Sequel
       def schema_post_process(_)
         super.each do |_, s|
           oid = s[:oid]
-          if values = Sequel.synchronize{@enum_labels[oid]}
-            s[:type] = :enum
+          if s[:type] == :enum && (values = Sequel.synchronize{@enum_labels[oid]})
             s[:enum_values] = values
           end
         end

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -22,7 +22,6 @@
 module Sequel
   module Postgres
     module ExtendedDateSupport
-      DATE_YEAR_1 = Date.new(1)
       DATETIME_YEAR_1 = DateTime.new(1)
       TIME_YEAR_1 = Time.at(-62135596800).utc
       INFINITE_TIMESTAMP_STRINGS = ['infinity'.freeze, '-infinity'.freeze].freeze
@@ -38,6 +37,15 @@ module Sequel
         procs = db.conversion_procs
         procs[1082] = ::Sequel.method(:string_to_date)
         procs[1184] = procs[1114] = db.method(:to_application_timestamp)
+        if ocps = db.instance_variable_get(:@oid_convertor_map)
+          # Clear the oid convertor map entries for timestamps if they
+          # exist, so it will regenerate new ones that use this extension.
+          # This is only taken when using the jdbc adapter.
+          Sequel.synchronize do
+            ocps.delete(1184)
+            ocps.delete(1114)
+          end
+        end
       end
 
       # Handle BC dates and times in bound variables. This is necessary for Date values
@@ -181,7 +189,7 @@ module Sequel
 
         # Handle BC Date objects.
         def literal_date(date)
-          if date < DATE_YEAR_1
+          if date.year < 1
             date <<= ((date.year) * 24 - 12)
             date.strftime("'%Y-%m-%d BC'")
           else

data/lib/sequel/extensions/pg_json_ops.rb

@@ -123,6 +123,15 @@
 #   c = Sequel.pg_jsonb_op(:c)
 #   DB[:t].update(c['key1'] => 1.to_json, c['key2'] => "a".to_json)
 #
+# On PostgreSQL 16+, the <tt>IS [NOT] JSON</tt> operator is supported:
+#
+#   j.is_json                              # j IS JSON
+#   j.is_json(type: :object)               # j IS JSON OBJECT
+#   j.is_json(type: :object, unique: true) # j IS JSON OBJECT WITH UNIQUE
+#   j.is_not_json                          # j IS NOT JSON
+#   j.is_not_json(type: :array)                # j IS NOT JSON ARRAY
+#   j.is_not_json(unique: true)                # j IS NOT JSON WITH UNIQUE
+#
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
 # JSONHash, JSONHarray, JSONBHash, and JSONBArray, allowing you to perform json/jsonb operations
@@ -151,6 +160,18 @@ module Sequel
       GET_PATH = ["(".freeze, " #> ".freeze, ")".freeze].freeze
       GET_PATH_TEXT = ["(".freeze, " #>> ".freeze, ")".freeze].freeze
 
+      IS_JSON = ["(".freeze, " IS JSON".freeze, "".freeze, ")".freeze].freeze
+      IS_NOT_JSON = ["(".freeze, " IS NOT JSON".freeze, "".freeze, ")".freeze].freeze
+      EMPTY_STRING = Sequel::LiteralString.new('').freeze
+      WITH_UNIQUE = Sequel::LiteralString.new(' WITH UNIQUE').freeze
+      IS_JSON_MAP = {
+        nil => EMPTY_STRING,
+        :value => Sequel::LiteralString.new(' VALUE').freeze,
+        :scalar => Sequel::LiteralString.new(' SCALAR').freeze,
+        :object => Sequel::LiteralString.new(' OBJECT').freeze,
+        :array => Sequel::LiteralString.new(' ARRAY').freeze
+      }.freeze
+
       # Get JSON array element or object field as json.  If an array is given,
       # gets the object at the specified path.
       #
@@ -233,6 +254,30 @@ module Sequel
         end
       end
 
+      # Return whether the json object can be parsed as JSON.
+      #
+      # Options:
+      # :type :: Check whether the json object can be parsed as a specific type
+      #          of JSON (:value, :scalar, :object, :array).
+      # :unique :: Check JSON objects for unique keys.
+      #
+      #   json_op.is_json                 # json IS JSON
+      #   json_op.is_json(type: :object)  # json IS JSON OBJECT
+      #   json_op.is_json(unique: true)   # json IS JSON WITH UNIQUE
+      def is_json(opts=OPTS)
+        _is_json(IS_JSON, opts)
+      end
+
+      # Return whether the json object cannot be parsed as JSON. The opposite
+      # of #is_json. See #is_json for options.
+      #
+      #   json_op.is_not_json                 # json IS NOT JSON
+      #   json_op.is_not_json(type: :object)  # json IS NOT JSON OBJECT
+      #   json_op.is_not_json(unique: true)   # json IS NOT JSON WITH UNIQUE
+      def is_not_json(opts=OPTS)
+        _is_json(IS_NOT_JSON, opts)
+      end
+
       # Returns a set of keys AS text in the json object.
       #
       #   json_op.keys # json_object_keys(json)
@@ -286,6 +331,13 @@ module Sequel
 
       private
 
+      # Internals of IS [NOT] JSON support
+      def _is_json(lit_array, opts)
+        raise Error, "invalid is_json :type option: #{opts[:type].inspect}" unless type = IS_JSON_MAP[opts[:type]]
+        unique = opts[:unique] ? WITH_UNIQUE : EMPTY_STRING
+        Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(lit_array, [self, type, unique]))
+      end
+
       # Return a placeholder literal with the given str and args, wrapped
       # in an JSONOp or JSONBOp, used by operators that return json or jsonb.
       def json_op(str, args)

data/lib/sequel/extensions/pg_multirange.rb

@@ -221,7 +221,7 @@ module Sequel
         private
 
         # Recognize the registered database multirange types.
-        def schema_column_type(db_type)
+        def schema_multirange_type(db_type)
           @pg_multirange_schema_types[db_type] || super
         end
 

data/lib/sequel/extensions/pg_range.rb

@@ -234,7 +234,7 @@ module Sequel
         private
 
         # Recognize the registered database range types.
-        def schema_column_type(db_type)
+        def schema_range_type(db_type)
           @pg_range_schema_types[db_type] || super
         end
 

data/lib/sequel/extensions/pg_row.rb

@@ -538,12 +538,8 @@ module Sequel
         private
 
         # Make the column type detection handle registered row types.
-        def schema_column_type(db_type)
-          if type = @row_schema_types[db_type]
-            type
-          else
-            super
-          end
+        def schema_composite_type(db_type)
+          @row_schema_types[db_type] || super
         end
       end
     end

data/lib/sequel/extensions/schema_caching.rb

@@ -52,7 +52,7 @@ module Sequel
     # Dump the cached schema to the filename given in Marshal format.
     def dump_schema_cache(file)
       sch = {}
-      @schemas.each do |k,v|
+      @schemas.sort.each do |k,v|
         sch[k] = v.map do |c, h|
           h = Hash[h]
           h.delete(:callable_default)

data/lib/sequel/extensions/server_block.rb

@@ -69,7 +69,8 @@ module Sequel
     # Also defines the with_server method on the receiver for easy use.
     def self.extended(db)
       pool = db.pool
-      if defined?(ShardedThreadedConnectionPool) && pool.is_a?(ShardedThreadedConnectionPool)
+      case pool.pool_type
+      when :sharded_threaded, :sharded_timed_queue
         pool.extend(ThreadedServerBlock)
         pool.instance_variable_set(:@default_servers, {})
       else

data/lib/sequel/model/base.rb

@@ -1945,8 +1945,10 @@ module Sequel
       end
       
       # If transactions should be used, wrap the yield in a transaction block.
-      def checked_transaction(opts=OPTS)
-        use_transaction?(opts) ? db.transaction({:server=>this_server}.merge!(opts)){yield} : yield
+      def checked_transaction(opts=OPTS, &block)
+        h = {:server=>this_server}.merge!(opts)
+        h[:skip_transaction] = true unless use_transaction?(opts)
+        db.transaction(h, &block)
       end
 
       # Change the value of the column to given value, recording the change.
@@ -2031,19 +2033,20 @@ module Sequel
         meths = setter_methods(type)
         strict = strict_param_setting
         hash.each do |k,v|
+          k = k.to_s
           m = "#{k}="
           if meths.include?(m)
             set_column_value(m, v)
           elsif strict
             # Avoid using respond_to? or creating symbols from user input
             if public_methods.map(&:to_s).include?(m)
-              if Array(model.primary_key).map(&:to_s).member?(k.to_s) && model.restrict_primary_key?
-                raise MassAssignmentRestriction, "#{k} is a restricted primary key"
+              if Array(model.primary_key).map(&:to_s).member?(k) && model.restrict_primary_key?
+                raise MassAssignmentRestriction.create("#{k} is a restricted primary key", self, k)
               else
-                raise MassAssignmentRestriction, "#{k} is a restricted column"
+                raise MassAssignmentRestriction.create("#{k} is a restricted column", self, k)
               end
             else
-              raise MassAssignmentRestriction, "method #{m} doesn't exist"
+              raise MassAssignmentRestriction.create("method #{m} doesn't exist", self, k)
             end
           end
         end
@@ -2147,8 +2150,9 @@ module Sequel
       #   # DELETE FROM artists WHERE (id = 2)
       #   # ...
       def destroy
-        pr = proc{all(&:destroy).length}
-        model.use_transactions ? @db.transaction(:server=>opts[:server], &pr) : pr.call
+        @db.transaction(:server=>opts[:server], :skip_transaction=>model.use_transactions == false) do
+          all(&:destroy).length
+        end
       end
 
       # If there is no order already defined on this dataset, order it by
@@ -2228,11 +2232,17 @@ module Sequel
 
       private
 
+      # Return the dataset ordered by the model's primary key.  This should not
+      # be used if the model does not have a primary key.
+      def _force_primary_key_order
+        cached_dataset(:_pk_order_ds){order(*model.primary_key)}
+      end
+
       # If the dataset is not already ordered, and the model has a primary key,
       # return a clone ordered by the primary key.
       def _primary_key_order
-        if @opts[:order].nil? && model && (pk = model.primary_key)
-          cached_dataset(:_pk_order_ds){order(*pk)}
+        if @opts[:order].nil? && model && model.primary_key
+          _force_primary_key_order
         end
       end
 

data/lib/sequel/model/dataset_module.rb

@@ -8,6 +8,9 @@ module Sequel
     # automatically creates class methods for public dataset
     # methods.
     class DatasetModule < Dataset::DatasetModule
+      # The model class related to this dataset module.
+      attr_reader :model
+
       # Store the model related to this dataset module.
       def initialize(model)
         @model = model

data/lib/sequel/model/exceptions.rb

@@ -24,11 +24,23 @@ module Sequel
   UndefinedAssociation = Class.new(Error)
   ).name
 
-  (
   # Raised when a mass assignment method is called in strict mode with either a restricted column
   # or a column without a setter method.
-  MassAssignmentRestriction = Class.new(Error)
-  ).name
+  class MassAssignmentRestriction < Error
+    # The Sequel::Model object related to this exception.
+    attr_reader :model
+
+    # The column related to this exception, as a string.
+    attr_reader :column
+
+    # Create an instance of this class with the model and column set.
+    def self.create(msg, model, column)
+      e = new("#{msg} for class #{model.class.inspect}")
+      e.instance_variable_set(:@model, model)
+      e.instance_variable_set(:@column, column)
+      e
+    end
+  end
   
   # Exception class raised when +raise_on_save_failure+ is set and validation fails
   class ValidationFailed < Error

data/lib/sequel/plugins/column_encryption.rb

@@ -31,7 +31,6 @@ rescue RuntimeError, OpenSSL::Cipher::CipherError
   # :nocov:
 end
 
-require 'base64'
 require 'securerandom'
 
 module Sequel
@@ -375,7 +374,7 @@ module Sequel
         # Decrypt using any supported format and any available key.
         def decrypt(data)
           begin
-            data = Base64.urlsafe_decode64(data)
+            data = urlsafe_decode64(data)
           rescue ArgumentError
             raise Error, "Unable to decode encrypted column: invalid base64"
           end
@@ -448,7 +447,7 @@ module Sequel
         # The prefix string of columns for the given search type and the first configured encryption key.
         # Used to find values that do not use this prefix in order to perform reencryption.
         def current_key_prefix(search_type)
-          Base64.urlsafe_encode64("#{search_type.chr}\0#{@key_id.chr}")
+          urlsafe_encode64("#{search_type.chr}\0#{@key_id.chr}")
         end
 
         # The prefix values to search for the given data (an array of strings), assuming the column uses
@@ -472,11 +471,33 @@ module Sequel
 
         private
 
+        if RUBY_VERSION >= '2.4'
+          def decode64(str)
+            str.unpack1("m0")
+          end
+        # :nocov:
+        else
+          def decode64(str)
+            str.unpack("m0")[0]
+          end
+        # :nocov:
+        end
+
+        def urlsafe_encode64(bin)
+          str = [bin].pack("m0")
+          str.tr!("+/", "-_")
+          str
+        end
+
+        def urlsafe_decode64(str)
+          decode64(str.tr("-_", "+/"))
+        end
+
         # An array of strings, one for each configured encryption key, to find encypted values matching
         # the given data and search format.
         def _search_prefixes(data, search_type)
           @key_map.map do |key_id, (key, _)|
-            Base64.urlsafe_encode64(_search_prefix(data, search_type, key_id, key))
+            urlsafe_encode64(_search_prefix(data, search_type, key_id, key))
           end
         end
 
@@ -509,7 +530,7 @@ module Sequel
           cipher_text << cipher.update(data) if data_size > 0
           cipher_text << cipher.final
 
-          Base64.urlsafe_encode64("#{prefix}#{random_data}#{cipher_iv}#{cipher.auth_tag}#{cipher_text}")
+          urlsafe_encode64("#{prefix}#{random_data}#{cipher_iv}#{cipher.auth_tag}#{cipher_text}")
         end
       end
 

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/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