activerecord-redshift-adapter 8.0.0.beta2 → 8.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35bf91b5a6116c1055f34e7bb0fc17805e6e693cec22520fc9014010962f2ee3
-  data.tar.gz: d4c0213bcee62e43faa979d0fdc1080b590f86d511a4b1f53c2ff623622737ce
+  metadata.gz: 338dd0abbf4008aa2bcb146fc2200c1ec640d505b8960d1c606dccea6ecae153
+  data.tar.gz: 1310ecbf60091d6838582ec512de9edff196551a21219336128f432a6146aa8b
 SHA512:
-  metadata.gz: 6075000b038c72d2e516173fa1ee3f29b3c80d2cff8036418f36b919ccc312e8085edfe841394642f906bbe6bf5161ccd6d0c0b42da10af061ce9618425194a1
-  data.tar.gz: f797bb18c2b7b4732ff0652b6f50b1f26cf0688a2d1c0eca5c2a0e310405af715f2ecfd1f9537b08dfbbbfb95e928eda10ffd6f35790db11eff5ff6e915d1430
+  metadata.gz: 77e97c2018f1d33a95cf921174f11569b83e6f1e0dd4b9ef19890b4f1e321e6e56a45385c9ff3db9cf5237bcec95018257c51afbabf17fde57d87be827d0a33f
+  data.tar.gz: ab3c6ff497683b3cf53832e59c97738a4fcd94cceec23e8f5f6d5b77d433c2f9a2848f215d65c0bf8d9ab62163ff0ed10cac2d3782569dadf002637259c99bd0

data/lib/active_record/connection_adapters/redshift_7_0/database_statements.rb

@@ -207,6 +207,11 @@ module ActiveRecord
           end
         end
 
+        # Returns the current ID of a table's sequence.
+        def last_insert_id_result(sequence_name)
+          internal_exec_query("SELECT currval(#{quote(sequence_name)})", "SQL")
+        end
+
         # Begins a transaction.
         def begin_db_transaction
           execute 'BEGIN'

data/lib/active_record/connection_adapters/redshift_7_0/schema_statements.rb

@@ -220,17 +220,17 @@ module ActiveRecord
         end
 
         # Returns the sequence name for a table's primary key or some other specified key.
-        def default_sequence_name(table_name, pk = nil) # :nodoc:
-          result = serial_sequence(table_name, pk || 'id')
+        def default_sequence_name(table_name, pk = "id") # :nodoc:
+          result = serial_sequence(table_name, pk)
           return nil unless result
 
           Utils.extract_schema_qualified_name(result).to_s
         rescue ActiveRecord::StatementInvalid
-          Redshift::Name.new(nil, "#{table_name}_#{pk || 'id'}_seq").to_s
+          Redshift::Name.new(nil, "#{table_name}_#{pk}_seq").to_s
         end
 
         def serial_sequence(table, column)
-          select_value("SELECT pg_get_serial_sequence('#{table}', '#{column}')", 'SCHEMA')
+          select_value("SELECT pg_get_serial_sequence(#{quote(table)}, #{quote(column)})", 'SCHEMA')
         end
 
         def set_pk_sequence!(table, value); end

data/lib/active_record/connection_adapters/redshift_7_0_adapter.rb

@@ -616,10 +616,6 @@ module ActiveRecord
         end
       end
 
-      def last_insert_id_result(sequence_name) # :nodoc:
-        exec_query("SELECT currval('#{sequence_name}')", 'SQL')
-      end
-
       # Returns the list of a table's column names, data types, and default values.
       #
       # The underlying query is roughly:
@@ -651,8 +647,9 @@ module ActiveRecord
       end
 
       def extract_table_ref_from_insert_sql(sql)
-        sql[/into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im]
-        Regexp.last_match(1)&.strip
+        if sql =~ /into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im
+          $1.delete('"').strip
+        end
       end
 
       def arel_visitor

data/lib/active_record/connection_adapters/redshift_7_1/schema_statements.rb

@@ -220,17 +220,17 @@ module ActiveRecord
         end
 
         # Returns the sequence name for a table's primary key or some other specified key.
-        def default_sequence_name(table_name, pk = nil) # :nodoc:
-          result = serial_sequence(table_name, pk || 'id')
+        def default_sequence_name(table_name, pk = 'id') # :nodoc:
+          result = serial_sequence(table_name, pk)
           return nil unless result
 
           Utils.extract_schema_qualified_name(result).to_s
         rescue ActiveRecord::StatementInvalid
-          Redshift::Name.new(nil, "#{table_name}_#{pk || 'id'}_seq").to_s
+          Redshift::Name.new(nil, "#{table_name}_#{pk}_seq").to_s
         end
 
         def serial_sequence(table, column)
-          select_value("SELECT pg_get_serial_sequence('#{table}', '#{column}')", 'SCHEMA')
+          select_value("SELECT pg_get_serial_sequence(#{quote(table)}, #{quote(column)})", 'SCHEMA')
         end
 
         def set_pk_sequence!(table, value); end

data/lib/active_record/connection_adapters/redshift_7_1_adapter.rb

@@ -689,11 +689,6 @@ module ActiveRecord
         end
       end
 
-      def last_insert_id_result(sequence_name)
-        # :nodoc:
-        exec_query("SELECT currval('#{sequence_name}')", 'SQL')
-      end
-
       # Returns the list of a table's column names, data types, and default values.
       #
       # The underlying query is roughly:
@@ -725,11 +720,6 @@ module ActiveRecord
         END_SQL
       end
 
-      def extract_table_ref_from_insert_sql(sql)
-        sql[/into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im]
-        Regexp.last_match(1)&.strip
-      end
-
       def arel_visitor
         Arel::Visitors::PostgreSQL.new(self)
       end

data/lib/active_record/connection_adapters/redshift_7_2/schema_statements.rb

@@ -220,17 +220,17 @@ module ActiveRecord
         end
 
         # Returns the sequence name for a table's primary key or some other specified key.
-        def default_sequence_name(table_name, pk = nil) # :nodoc:
-          result = serial_sequence(table_name, pk || 'id')
+        def default_sequence_name(table_name, pk = 'id') # :nodoc:
+          result = serial_sequence(table_name, pk)
           return nil unless result
 
           Utils.extract_schema_qualified_name(result).to_s
         rescue ActiveRecord::StatementInvalid
-          Redshift::Name.new(nil, "#{table_name}_#{pk || 'id'}_seq").to_s
+          Redshift::Name.new(nil, "#{table_name}_#{pk}_seq").to_s
         end
 
         def serial_sequence(table, column)
-          select_value("SELECT pg_get_serial_sequence('#{table}', '#{column}')", 'SCHEMA')
+          select_value("SELECT pg_get_serial_sequence(#{quote(table)}, #{quote(column)})".tap { puts _1 }, 'SCHEMA')
         end
 
         def set_pk_sequence!(table, value); end

data/lib/active_record/connection_adapters/redshift_7_2_adapter.rb

@@ -689,11 +689,6 @@ module ActiveRecord
         end
       end
 
-      def last_insert_id_result(sequence_name)
-        # :nodoc:
-        exec_query("SELECT currval('#{sequence_name}')", 'SQL')
-      end
-
       # Returns the list of a table's column names, data types, and default values.
       #
       # The underlying query is roughly:
@@ -725,11 +720,6 @@ module ActiveRecord
         END_SQL
       end
 
-      def extract_table_ref_from_insert_sql(sql)
-        sql[/into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im]
-        Regexp.last_match(1)&.strip
-      end
-
       def arel_visitor
         Arel::Visitors::PostgreSQL.new(self)
       end

data/lib/active_record/connection_adapters/redshift_8_0/schema_statements.rb

@@ -152,12 +152,13 @@ module ActiveRecord
             default_value = extract_value_from_default(default)
             type_metadata = fetch_type_metadata(column_name, type, oid, fmod)
             default_function = extract_default_function(default_value, default)
-            new_column(column_name, default_value, type_metadata, !notnull, table_name, default_function)
+            cast_type = get_oid_type(oid.to_i, fmod.to_i, column_name, type)
+            new_column(column_name, default_value, type_metadata, !notnull, table_name, default_function, cast_type: cast_type)
           end
         end
 
-        def new_column(name, default, sql_type_metadata = nil, null = true, _table_name = nil, default_function = nil) # :nodoc:
-          RedshiftColumn.new(name, default, sql_type_metadata, null, default_function)
+        def new_column(name, default, sql_type_metadata = nil, null = true, _table_name = nil, default_function = nil, cast_type: nil) # :nodoc:
+          RedshiftColumn.new(name, default, sql_type_metadata, null, default_function, cast_type: cast_type)
         end
 
         # Returns the current database name.
@@ -220,17 +221,17 @@ module ActiveRecord
         end
 
         # Returns the sequence name for a table's primary key or some other specified key.
-        def default_sequence_name(table_name, pk = nil) # :nodoc:
-          result = serial_sequence(table_name, pk || 'id')
+        def default_sequence_name(table_name, pk = 'id') # :nodoc:
+          result = serial_sequence(table_name, pk)
           return nil unless result
 
           Utils.extract_schema_qualified_name(result).to_s
         rescue ActiveRecord::StatementInvalid
-          Redshift::Name.new(nil, "#{table_name}_#{pk || 'id'}_seq").to_s
+          Redshift::Name.new(nil, "#{table_name}_#{pk}_seq").to_s
         end
 
         def serial_sequence(table, column)
-          select_value("SELECT pg_get_serial_sequence('#{table}', '#{column}')", 'SCHEMA')
+          select_value("SELECT pg_get_serial_sequence(#{quote(table)}, #{quote(column)})".tap { puts _1 }, 'SCHEMA')
         end
 
         def set_pk_sequence!(table, value); end

data/lib/active_record/connection_adapters/redshift_8_0_adapter.rb

@@ -90,6 +90,13 @@ module ActiveRecord
       include Redshift::SchemaStatements
       include Redshift::DatabaseStatements
 
+      # Compatibility: in_transaction? is defined in PostgreSQLAdapter but not in AbstractAdapter.
+      # Since RedshiftAdapter inherits from AbstractAdapter (not PostgreSQLAdapter),
+      # we need to provide this method. It's used for prepared statement cache handling.
+      def in_transaction? # :nodoc:
+        open_transactions > 0
+      end
+
       def schema_creation # :nodoc:
         Redshift::SchemaCreation.new self
       end
@@ -360,6 +367,16 @@ module ActiveRecord
         end
       end
 
+      # Rails 8.1 deprecated AbstractAdapter#check_if_write_query
+      # Implement it here for compatibility if it doesn't exist in the parent class
+      unless AbstractAdapter.method_defined?(:check_if_write_query)
+        def check_if_write_query(sql)
+          return unless preventing_writes? && write_query?(sql)
+
+          raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+        end
+      end
+
       class << self
         def initialize_type_map(m)
           # :nodoc:
@@ -688,11 +705,6 @@ module ActiveRecord
         end
       end
 
-      def last_insert_id_result(sequence_name)
-        # :nodoc:
-        exec_query("SELECT currval('#{sequence_name}')", 'SQL')
-      end
-
       # Returns the list of a table's column names, data types, and default values.
       #
       # The underlying query is roughly:
@@ -724,11 +736,6 @@ module ActiveRecord
         END_SQL
       end
 
-      def extract_table_ref_from_insert_sql(sql)
-        sql[/into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im]
-        Regexp.last_match(1)&.strip
-      end
-
       def arel_visitor
         Arel::Visitors::PostgreSQL.new(self)
       end

data/lib/active_record/connection_adapters/redshift_8_1/array_parser.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module ArrayParser # :nodoc:
+        DOUBLE_QUOTE = '"'
+        BACKSLASH = '\\'
+        COMMA = ','
+        BRACKET_OPEN = '{'
+        BRACKET_CLOSE = '}'
+
+        def parse_pg_array(string) # :nodoc:
+          local_index = 0
+          array = []
+          while local_index < string.length
+            case string[local_index]
+            when BRACKET_OPEN
+              local_index, array = parse_array_contents(array, string, local_index + 1)
+            when BRACKET_CLOSE
+              return array
+            end
+            local_index += 1
+          end
+
+          array
+        end
+
+        private
+
+        def parse_array_contents(array, string, index)
+          is_escaping  = false
+          is_quoted    = false
+          was_quoted   = false
+          current_item = ''
+
+          local_index = index
+          while local_index
+            token = string[local_index]
+            if is_escaping
+              current_item << token
+              is_escaping = false
+            elsif is_quoted
+              case token
+              when DOUBLE_QUOTE
+                is_quoted = false
+                was_quoted = true
+              when BACKSLASH
+                is_escaping = true
+              else
+                current_item << token
+              end
+            else
+              case token
+              when BACKSLASH
+                is_escaping = true
+              when COMMA
+                add_item_to_array(array, current_item, was_quoted)
+                current_item = ''
+                was_quoted = false
+              when DOUBLE_QUOTE
+                is_quoted = true
+              when BRACKET_OPEN
+                internal_items = []
+                local_index, internal_items = parse_array_contents(internal_items, string, local_index + 1)
+                array.push(internal_items)
+              when BRACKET_CLOSE
+                add_item_to_array(array, current_item, was_quoted)
+                return local_index, array
+              else
+                current_item << token
+              end
+            end
+
+            local_index += 1
+          end
+          [local_index, array]
+        end
+
+        def add_item_to_array(array, current_item, quoted)
+          return if !quoted && current_item.empty?
+
+          if !quoted && current_item == 'NULL'
+            array.push nil
+          else
+            array.push current_item
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_8_1/column.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class RedshiftColumn < Column # :nodoc:
+      delegate :oid, :fmod, to: :sql_type_metadata
+
+      # Required for Rails 6.1, see https://github.com/rails/rails/pull/41756
+      mattr_reader :array, default: false
+      alias array? array
+
+      # Rails 8.1 changed Column#initialize signature to require cast_type as second argument:
+      #   initialize(name, cast_type, default, sql_type_metadata, null, ...)
+      def initialize(name, default, sql_type_metadata, null = true, default_function = nil, cast_type: nil, **)
+        cast_type ||= ActiveRecord::Type::Value.new
+        super(name, cast_type, default, sql_type_metadata, null, default_function)
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_8_1/database_statements.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module DatabaseStatements
+        def explain(arel, binds = [], options = [])
+          sql    = build_explain_clause(options) + " " + to_sql(arel, binds)
+          result = internal_exec_query(sql, "EXPLAIN", binds)
+          PostgreSQL::ExplainPrettyPrinter.new.pp(result)
+        end
+
+        # Queries the database and returns the results in an Array-like object
+        def query(sql, name = nil) # :nodoc:
+          mark_transaction_written_if_write(sql)
+
+          log(sql, name) do
+            with_raw_connection do |conn|
+              result = conn.async_exec(sql).map_types!(@type_map_for_results).values
+              verified!
+              result
+            end
+          end
+        end
+
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :close, :declare, :fetch, :move, :set, :show
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
+        end
+
+        # Executes an SQL statement, returning a PG::Result object on success
+        # or raising a PG::Error exception otherwise.
+        #
+        # Setting +allow_retry+ to true causes the db to reconnect and retry
+        # executing the SQL statement in case of a connection-related exception.
+        # This option should only be enabled for known idempotent queries.
+        #
+        # Note: the PG::Result object is manually memory managed; if you don't
+        # need it specifically, you may want consider the <tt>exec_query</tt> wrapper.
+        def execute(...) # :nodoc:
+          super
+        ensure
+          @notice_receiver_sql_warnings = []
+        end
+
+        def raw_execute(sql, name, binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true)
+          type_casted_binds = type_casted_binds(binds)
+          log(sql, name, binds, type_casted_binds, async: async) do
+            with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+              result = conn.async_exec(sql)
+              verified!
+              handle_warnings(result)
+              result
+            end
+          end
+        end
+
+        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true) # :nodoc:
+          execute_and_clear(sql, name, binds, prepare: prepare, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |result|
+            types = {}
+            fields = result.fields
+            fields.each_with_index do |fname, i|
+              ftype = result.ftype i
+              fmod  = result.fmod i
+              types[fname] = types[i] = get_oid_type(ftype, fmod, fname)
+            end
+            build_result(columns: fields, rows: result.values, column_types: types)
+          end
+        end
+
+        def exec_delete(sql, name = nil, binds = []) # :nodoc:
+          execute_and_clear(sql, name, binds) { |result| result.cmd_tuples }
+        end
+        alias :exec_update :exec_delete
+
+        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil) # :nodoc:
+          if use_insert_returning? || pk == false
+            super
+          else
+            result = internal_exec_query(sql, name, binds)
+            unless sequence_name
+              table_ref = extract_table_ref_from_insert_sql(sql)
+              if table_ref
+                pk = primary_key(table_ref) if pk.nil?
+                pk = suppress_composite_primary_key(pk)
+                sequence_name = default_sequence_name(table_ref, pk)
+              end
+              return result unless sequence_name
+            end
+            last_insert_id_result(sequence_name)
+          end
+        end
+
+        # Begins a transaction.
+        def begin_db_transaction
+          internal_execute('BEGIN', allow_retry: true, materialize_transactions: false)
+        end
+
+        def begin_isolated_db_transaction(isolation)
+          begin_db_transaction
+          internal_execute("SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", allow_retry: true, materialize_transactions: false)
+        end
+
+        # Commits a transaction.
+        def commit_db_transaction
+          internal_execute('COMMIT', allow_retry: false, materialize_transactions: true)
+        end
+
+        # Aborts a transaction.
+        def exec_rollback_db_transaction
+          internal_execute('ROLLBACK', allow_retry: false, materialize_transactions: true)
+        end
+
+        def exec_restart_db_transaction # :nodoc:
+          cancel_any_running_query
+          exec_rollback_db_transaction
+          begin_db_transaction
+        end
+
+        # From https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-CURRENT
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP").freeze # :nodoc:
+        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+
+        def high_precision_current_timestamp
+          HIGH_PRECISION_CURRENT_TIMESTAMP
+        end
+
+        def build_explain_clause(options = [])
+          return "EXPLAIN" if options.empty?
+
+          "EXPLAIN (#{options.join(", ").upcase})"
+        end
+
+        private
+
+        IDLE_TRANSACTION_STATUSES = [PG::PQTRANS_IDLE, PG::PQTRANS_INTRANS, PG::PQTRANS_INERROR]
+        private_constant :IDLE_TRANSACTION_STATUSES
+
+        def cancel_any_running_query
+          return if @raw_connection.nil? || IDLE_TRANSACTION_STATUSES.include?(@raw_connection.transaction_status)
+
+          @raw_connection.cancel
+          @raw_connection.block
+        rescue PG::Error
+        end
+
+        # Returns the current ID of a table's sequence.
+        def last_insert_id_result(sequence_name)
+          internal_exec_query("SELECT currval(#{quote(sequence_name)})", "SQL")
+        end
+
+        def returning_column_values(result)
+          result.rows.first
+        end
+
+        def suppress_composite_primary_key(pk)
+          pk unless pk.is_a?(Array)
+        end
+
+        def handle_warnings(sql)
+          @notice_receiver_sql_warnings.each do |warning|
+            next if warning_ignored?(warning)
+
+            warning.sql = sql
+            ActiveRecord.db_warnings_action.call(warning)
+          end
+        end
+
+        def warning_ignored?(warning)
+          ["WARNING", "ERROR", "FATAL", "PANIC"].exclude?(warning.level) || super
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_8_1/oid/date_time.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module OID # :nodoc:
+        class DateTime < Type::DateTime # :nodoc:
+          def type_cast_for_database(value)
+            if has_precision? && value.acts_like?(:time) && value.year <= 0
+              bce_year = format('%04d', -value.year + 1)
+              "#{super.sub(/^-?\d+/, bce_year)} BC"
+            else
+              super
+            end
+          end
+
+          def cast_value(value)
+            if value.is_a?(::String)
+              case value
+              when 'infinity' then ::Float::INFINITY
+              when '-infinity' then -::Float::INFINITY
+              when / BC$/
+                astronomical_year = format('%04d', -value[/^\d+/].to_i + 1)
+                super(value.sub(/ BC$/, '').sub(/^\d+/, astronomical_year))
+              else
+                super
+              end
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_8_1/oid/decimal.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module OID # :nodoc:
+        class Decimal < Type::Decimal # :nodoc:
+          def infinity(options = {})
+            BigDecimal('Infinity') * (options[:negative] ? -1 : 1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_8_1/oid/json.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module OID # :nodoc:
+        class Json < Type::Value # :nodoc:
+          include ActiveModel::Type::Helpers::Mutable
+
+          def type
+            :json
+          end
+
+          def type_cast_from_database(value)
+            if value.is_a?(::String)
+              begin
+                ::ActiveSupport::JSON.decode(value)
+              rescue StandardError
+                nil
+              end
+            else
+              super
+            end
+          end
+
+          def type_cast_for_database(value)
+            if value.is_a?(::Array) || value.is_a?(::Hash)
+              ::ActiveSupport::JSON.encode(value)
+            else
+              super
+            end
+          end
+
+          def accessor
+            ActiveRecord::Store::StringKeyedHashAccessor
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_8_1/oid/jsonb.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module OID # :nodoc:
+        class Jsonb < Json # :nodoc:
+          def type
+            :jsonb
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            # Postgres does not preserve insignificant whitespaces when
+            # roundtripping jsonb columns. This causes some false positives for
+            # the comparison here. Therefore, we need to parse and re-dump the
+            # raw value here to ensure the insignificant whitespaces are
+            # consistent with our encoder's output.
+            raw_old_value = type_cast_for_database(type_cast_from_database(raw_old_value))
+            super(raw_old_value, new_value)
+          end
+        end
+      end
+    end
+  end
+end