activerecord 7.1.1 → 7.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3595eee8065caff3100f00f5ce54d1b3a34935759766cb16b4d8229a57ebc97e
-  data.tar.gz: 5fbab431bcbc3b56cae5b2d8400c893071c72ccc7feea3eb6d9343418c650ec6
+  metadata.gz: 9f7c51f040979b7650eb209b0dc856a0877bccc968dd99cde06e3cf1776dd638
+  data.tar.gz: b81eca56b185f087c95b6691b307ff1c9c63d0d03ff650b729e943888f053152
 SHA512:
-  metadata.gz: c75c3da922f3b0089112bb07c115787bedc1bb57a6e05aa04df893262554e09bf81e71898ac7ed24b1c80a00071818e14267cbffc2bb2b789755867b85f76d78
-  data.tar.gz: 5f6684e9a76e3a2a7156b687d4ac0701b9ddd840edd9c671f51031c534bdbd1e920b2aad65a479299383cb8555346a585e3167c353f33f95ecf8e05115438205
+  metadata.gz: 6f68dc9e6cdccf23f5467810a68083564760601aa3c82b4c85720cfb2c39500439a86bb63c2ce8fea37337de6fc4f157722300c691cfd239e92732569b5c20f6
+  data.tar.gz: 6f8382df74c2c16b873cab0effeda0a3ef3e578d5087e435d7d2f8c6890dcf0d85e2211f2bc890182af49e836b09e4e345e2b9bc37eb8472814e98bb6636b005

data/CHANGELOG.md

@@ -1,3 +1,176 @@
+## Rails 7.1.3 (January 16, 2024) ##
+
+*   Fix Migrations with versions older than 7.1 validating options given to
+    `add_reference`.
+
+    *Hartley McGuire*
+
+*   Ensure `reload` sets correct owner for each association.
+
+    *Dmytro Savochkin*
+
+*   Fix view runtime for controllers with async queries.
+
+    *fatkodima*
+
+*   Fix `load_async` to work with query cache.
+
+    *fatkodima*
+
+*   Fix polymorphic `belongs_to` to correctly use parent's `query_constraints`.
+
+    *fatkodima*
+
+*   Fix `Preloader` to not generate a query for already loaded association with `query_constraints`.
+
+    *fatkodima*
+
+*   Fix multi-database polymorphic preloading with equivalent table names.
+
+    When preloading polymorphic associations, if two models pointed to two
+    tables with the same name but located in different databases, the
+    preloader would only load one.
+
+    *Ari Summer*
+
+*   Fix `encrypted_attribute?` to take into account context properties passed to `encrypts`.
+
+    *Maxime Réty*
+
+*   Fix `find_by` to work correctly in presence of composite primary keys.
+
+    *fatkodima*
+
+*   Fix async queries sometimes returning a raw result if they hit the query cache.
+
+    `ShipPart.async_count` could return a raw integer rather than a Promise
+    if it found the result in the query cache.
+
+    *fatkodima*
+
+*   Fix `Relation#transaction` to not apply a default scope.
+
+    The method was incorrectly setting a default scope around its block:
+
+    ```ruby
+    Post.where(published: true).transaction do
+      Post.count # SELECT COUNT(*) FROM posts WHERE published = FALSE;
+    end
+    ```
+
+    *Jean Boussier*
+
+*   Fix calling `async_pluck` on a `none` relation.
+
+    `Model.none.async_pluck(:id)` was returning a naked value
+    instead of a promise.
+
+    *Jean Boussier*
+
+*   Fix calling `load_async` on a `none` relation.
+
+    `Model.none.load_async` was returning a broken result.
+
+    *Lucas Mazza*
+
+*   TrilogyAdapter: ignore `host` if `socket` parameter is set.
+
+    This allows to configure a connection on a UNIX socket via DATABASE_URL:
+
+    ```
+    DATABASE_URL=trilogy://does-not-matter/my_db_production?socket=/var/run/mysql.sock
+    ```
+
+    *Jean Boussier*
+
+*   Fix `has_secure_token` calls the setter method on initialize.
+
+    *Abeid Ahmed*
+
+*   Allow using `object_id` as a database column name.
+    It was available before rails 7.1 and may be used as a part of polymorphic relationship to `object` where `object` can be any other database record.
+
+    *Mikhail Doronin*
+
+*   Fix `rails db:create:all` to not touch databases before they are created.
+
+    *fatkodima*
+
+
+## Rails 7.1.2 (November 10, 2023) ##
+
+*   Fix renaming primary key index when renaming a table with a UUID primary key
+    in PostgreSQL.
+
+    *fatkodima*
+
+*   Fix `where(field: values)` queries when `field` is a serialized attribute
+    (for example, when `field` uses `ActiveRecord::Base.serialize` or is a JSON
+    column).
+
+    *João Alves*
+
+*   Prevent marking broken connections as verified.
+
+    *Daniel Colson*
+
+*   Don't mark Float::INFINITY as changed when reassigning it
+
+    When saving a record with a float infinite value, it shouldn't mark as changed
+
+    *Maicol Bentancor*
+
+*   `ActiveRecord::Base.table_name` now returns `nil` instead of raising
+    "undefined method `abstract_class?` for Object:Class".
+
+    *a5-stable*
+
+*   Fix upserting for custom `:on_duplicate` and `:unique_by` consisting of all
+    inserts keys.
+
+    *fatkodima*
+
+*   Fixed an [issue](https://github.com/rails/rails/issues/49809) where saving a
+    record could innappropriately `dup` its attributes.
+
+    *Jonathan Hefner*
+
+*   Dump schema only for a specific db for rollback/up/down tasks for multiple dbs.
+
+    *fatkodima*
+
+*   Fix `NoMethodError` when casting a PostgreSQL `money` value that uses a
+    comma as its radix point and has no leading currency symbol.  For example,
+    when casting `"3,50"`.
+
+    *Andreas Reischuck* and *Jonathan Hefner*
+
+*   Re-enable support for using `enum` with non-column-backed attributes.
+    Non-column-backed attributes must be previously declared with an explicit
+    type. For example:
+
+      ```ruby
+      class Post < ActiveRecord::Base
+        attribute :topic, :string
+        enum topic: %i[science tech engineering math]
+      end
+      ```
+
+    *Jonathan Hefner*
+
+*   Raise on `foreign_key:` being passed as an array in associations
+
+    *Nikita Vasilevsky*
+
+*   Return back maximum allowed PostgreSQL table name to 63 characters.
+
+    *fatkodima*
+
+*   Fix detecting `IDENTITY` columns for PostgreSQL < 10.
+
+    *fatkodima*
+
+
 ## Rails 7.1.1 (October 11, 2023) ##
 
 *   Fix auto populating IDENTITY columns for PostgreSQL.
@@ -165,6 +338,10 @@
 
     *Adam Hess*
 
+*   Deprecate aliasing non-attributes with `alias_attribute`.
+
+    *Ian Candy*
+
 *   Fix unscope is not working in specific case
 
     Before:

data/README.rdoc

@@ -166,6 +166,7 @@ Active Record is an implementation of the object-relational mapping (ORM)
 pattern[https://www.martinfowler.com/eaaCatalog/activeRecord.html] by the same
 name described by Martin Fowler:
 
+>>>
   "An object that wraps a row in a database table or view,
   encapsulates the database access, and adds domain logic on that data."
 

data/lib/active_record/associations/association.rb

@@ -33,7 +33,8 @@ module ActiveRecord
     # <tt>owner</tt>, the collection of its posts as <tt>target</tt>, and
     # the <tt>reflection</tt> object represents a <tt>:has_many</tt> macro.
     class Association # :nodoc:
-      attr_reader :owner, :target, :reflection, :disable_joins
+      attr_accessor :owner
+      attr_reader :target, :reflection, :disable_joins
 
       delegate :options, to: :reflection
 

data/lib/active_record/associations/preloader/association.rb

@@ -17,11 +17,12 @@ module ActiveRecord
           def eql?(other)
             association_key_name == other.association_key_name &&
               scope.table_name == other.scope.table_name &&
+              scope.connection_specification_name == other.scope.connection_specification_name &&
               scope.values_for_queries == other.scope.values_for_queries
           end
 
           def hash
-            [association_key_name, scope.table_name, scope.values_for_queries].hash
+            [association_key_name, scope.table_name, scope.connection_specification_name, scope.values_for_queries].hash
           end
 
           def records_for(loaders)
@@ -38,6 +39,8 @@ module ActiveRecord
           end
 
           def load_records_for_keys(keys, &block)
+            return [] if keys.empty?
+
             if association_key_name.is_a?(Array)
               query_constraints = Hash.new { |hsh, key| hsh[key] = Set.new }
 

data/lib/active_record/associations.rb

@@ -1050,7 +1050,7 @@ module ActiveRecord
       # query per addressable type.
       # For example, if all the addressables are either of class Person or Company, then a total
       # of 3 queries will be executed. The list of addressable types to load is determined on
-      # the back of the addresses loaded. This is not supported if Active Record has to fallback
+      # the back of the addresses loaded. This is not supported if Active Record has to fall back
       # to the previous implementation of eager loading and will raise ActiveRecord::EagerLoadPolymorphicError.
       # The reason is that the parent model's type is a column value so its corresponding table
       # name cannot be put in the +FROM+/+JOIN+ clauses of that query.
@@ -1339,7 +1339,7 @@ module ActiveRecord
         #   Returns a Relation of all of the associated objects, forcing a database read.
         #   An empty Relation is returned if none are found.
         #
-        # === Example
+        # ==== Example
         #
         #   class Firm < ActiveRecord::Base
         #     has_many :clients
@@ -1369,7 +1369,7 @@ module ActiveRecord
         #
         # The declaration can also include an +options+ hash to specialize the behavior of the association.
         #
-        # === Scopes
+        # ==== Scopes
         #
         # You can pass a second argument +scope+ as a callable (i.e. proc or
         # lambda) to retrieve a specific set of records or customize the generated
@@ -1380,7 +1380,7 @@ module ActiveRecord
         #   has_many :employees, -> { joins(:address) }
         #   has_many :posts, ->(blog) { where("max_post_length > ?", blog.max_post_length) }
         #
-        # === Extensions
+        # ==== Extensions
         #
         # The +extension+ argument allows you to pass a block into a has_many
         # association. This is useful for adding new finders, creators, and other
@@ -1394,7 +1394,7 @@ module ActiveRecord
         #     end
         #   end
         #
-        # === Options
+        # ==== Options
         # [+:class_name+]
         #   Specify the class name of the association. Use it only if that name can't be inferred
         #   from the association name. So <tt>has_many :products</tt> will by default be linked
@@ -1556,7 +1556,7 @@ module ActiveRecord
         # [<tt>reset_association</tt>]
         #   Unloads the associated object. The next access will query it from the database.
         #
-        # === Example
+        # ==== Example
         #
         #   class Account < ActiveRecord::Base
         #     has_one :beneficiary
@@ -1575,7 +1575,7 @@ module ActiveRecord
         #   account.reload_beneficiary
         #   account.reset_beneficiary
         #
-        # === Scopes
+        # ==== Scopes
         #
         # You can pass a second argument +scope+ as a callable (i.e. proc or
         # lambda) to retrieve a specific record or customize the generated query
@@ -1586,7 +1586,7 @@ module ActiveRecord
         #   has_one :employer, -> { joins(:company) }
         #   has_one :latest_post, ->(blog) { where("created_at > ?", blog.enabled_at) }
         #
-        # === Options
+        # ==== Options
         #
         # The declaration can also include an +options+ hash to specialize the behavior of the association.
         #
@@ -1745,7 +1745,7 @@ module ActiveRecord
         # [<tt>association_previously_changed?</tt>]
         #   Returns true if the previous save updated the association to reference a new associate object.
         #
-        # === Example
+        # ==== Example
         #
         #   class Post < ActiveRecord::Base
         #     belongs_to :author
@@ -1766,7 +1766,7 @@ module ActiveRecord
         #   post.author_changed?
         #   post.author_previously_changed?
         #
-        # === Scopes
+        # ==== Scopes
         #
         # You can pass a second argument +scope+ as a callable (i.e. proc or
         # lambda) to retrieve a specific record or customize the generated query
@@ -1777,7 +1777,7 @@ module ActiveRecord
         #   belongs_to :user, -> { joins(:friends) }
         #   belongs_to :level, ->(game) { where("game_level > ?", game.current_level) }
         #
-        # === Options
+        # ==== Options
         #
         # The declaration can also include an +options+ hash to specialize the behavior of the association.
         #
@@ -1964,7 +1964,7 @@ module ActiveRecord
         #   Returns a Relation of all of the associated objects, forcing a database read.
         #   An empty Relation is returned if none are found.
         #
-        # === Example
+        # ==== Example
         #
         #   class Developer < ActiveRecord::Base
         #     has_and_belongs_to_many :projects
@@ -1993,7 +1993,7 @@ module ActiveRecord
         #
         # The declaration may include an +options+ hash to specialize the behavior of the association.
         #
-        # === Scopes
+        # ==== Scopes
         #
         # You can pass a second argument +scope+ as a callable (i.e. proc or
         # lambda) to retrieve a specific set of records or customize the generated
@@ -2005,7 +2005,7 @@ module ActiveRecord
         #     where("default_category = ?", post.default_category)
         #   }
         #
-        # === Extensions
+        # ==== Extensions
         #
         # The +extension+ argument allows you to pass a block into a
         # has_and_belongs_to_many association. This is useful for adding new
@@ -2020,7 +2020,7 @@ module ActiveRecord
         #     end
         #   end
         #
-        # === Options
+        # ==== Options
         #
         # [+:class_name+]
         #   Specify the class name of the association. Use it only if that name can't be inferred

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -56,7 +56,7 @@ module ActiveRecord
       # serialization.
       #
       #   class Book < ActiveRecord::Base
-      #     enum status: { draft: 1, published: 2 }
+      #     enum :status, { draft: 1, published: 2 }
       #   end
       #
       #   book = Book.new(status: "published")

data/lib/active_record/attribute_methods/dirty.rb

@@ -14,7 +14,7 @@ module ActiveRecord
     #   class Person < ActiveRecord::Base
     #   end
     #
-    #   person = Person.create(name: "Alisson")
+    #   person = Person.create(name: "Allison")
     #   person.changed? # => false
     #
     # Change the name:
@@ -76,11 +76,13 @@ module ActiveRecord
       #
       # ==== Options
       #
-      # +from+ When passed, this method will return false unless the original
-      # value is equal to the given option
+      # [+from+]
+      #   When specified, this method will return false unless the original
+      #   value is equal to the given value.
       #
-      # +to+ When passed, this method will return false unless the value was
-      # changed to the given value
+      # [+to+]
+      #   When specified, this method will return false unless the value will be
+      #   changed to the given value.
       def saved_change_to_attribute?(attr_name, **options)
         mutations_before_last_save.changed?(attr_name.to_s, **options)
       end
@@ -126,11 +128,13 @@ module ActiveRecord
       #
       # ==== Options
       #
-      # +from+ When passed, this method will return false unless the original
-      # value is equal to the given option
+      # [+from+]
+      #   When specified, this method will return false unless the original
+      #   value is equal to the given value.
       #
-      # +to+ When passed, this method will return false unless the value will be
-      # changed to the given value
+      # [+to+]
+      #   When specified, this method will return false unless the value will be
+      #   changed to the given value.
       def will_save_change_to_attribute?(attr_name, **options)
         mutations_from_database.changed?(attr_name.to_s, **options)
       end

data/lib/active_record/attribute_methods.rb

@@ -34,7 +34,7 @@ module ActiveRecord
           Base.private_instance_methods -
           Base.superclass.instance_methods -
           Base.superclass.private_instance_methods +
-          %i[__id__ dup freeze frozen? hash object_id class clone]
+          %i[__id__ dup freeze frozen? hash class clone]
         ).map { |m| -m.to_s }.to_set.freeze
       end
     end

data/lib/active_record/callbacks.rb

@@ -241,8 +241,8 @@ module ActiveRecord
   #
   #   config.active_record.run_after_transaction_callbacks_in_order_defined = false
   #
-  # If +true+ (the default from \Rails 7.1), callbacks are executed in the order they
-  # are defined, just like the example above. If +false+, the order is reversed, so
+  # When set to +true+ (the default from \Rails 7.1), callbacks are executed in the order they
+  # are defined, just like the example above. When set to +false+, the order is reversed, so
   # +do_something_else+ is executed before +log_children+.
   #
   # == \Transactions

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -58,12 +58,10 @@ module ActiveRecord
     # Connections can be obtained and used from a connection pool in several
     # ways:
     #
-    # 1. Simply use {ActiveRecord::Base.connection}[rdoc-ref:ConnectionHandling.connection]
-    #    as with Active Record 2.1 and
-    #    earlier (pre-connection-pooling). Eventually, when you're done with
-    #    the connection(s) and wish it to be returned to the pool, you call
+    # 1. Simply use {ActiveRecord::Base.connection}[rdoc-ref:ConnectionHandling.connection].
+    #    When you're done with the connection(s) and wish it to be returned to the pool, you call
     #    {ActiveRecord::Base.connection_handler.clear_active_connections!}[rdoc-ref:ConnectionAdapters::ConnectionHandler#clear_active_connections!].
-    #    This will be the default behavior for Active Record when used in conjunction with
+    #    This is the default behavior for Active Record when used in conjunction with
     #    Action Pack's request handling cycle.
     # 2. Manually check out a connection from the pool with
     #    {ActiveRecord::Base.connection_pool.checkout}[rdoc-ref:#checkout]. You are responsible for
@@ -465,8 +463,7 @@ module ActiveRecord
         @available.num_waiting
       end
 
-      # Return connection pool's usage statistic
-      # Example:
+      # Returns the connection pool's usage statistic.
       #
       #    ActiveRecord::Base.connection_pool.stat # => { size: 15, connections: 1, busy: 1, dead: 0, idle: 0, waiting: 0, checkout_timeout: 5 }
       def stat
@@ -658,7 +655,13 @@ module ActiveRecord
             conn
           else
             reap
-            @available.poll(checkout_timeout)
+            # Retry after reaping, which may return an available connection,
+            # remove an inactive connection, or both
+            if conn = @available.poll || try_to_checkout_new_connection
+              conn
+            else
+              @available.poll(checkout_timeout)
+            end
           end
         end
 

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

@@ -189,8 +189,10 @@ module ActiveRecord
       def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [], returning: nil)
         sql, binds = to_sql_and_binds(arel, binds)
         value = exec_insert(sql, name, binds, pk, sequence_name, returning: returning)
-        return id_value if id_value
-        returning.nil? ? last_inserted_id(value) : returning_column_values(value)
+
+        return returning_column_values(value) unless returning.nil?
+
+        id_value || last_inserted_id(value)
       end
       alias create insert
 

data/lib/active_record/connection_adapters/abstract/query_cache.rb

@@ -106,7 +106,8 @@ module ActiveRecord
           sql, binds, preparable = to_sql_and_binds(arel, binds, preparable)
 
           if async
-            lookup_sql_cache(sql, name, binds) || super(sql, name, binds, preparable: preparable, async: async)
+            result = lookup_sql_cache(sql, name, binds) || super(sql, name, binds, preparable: preparable, async: async)
+            FutureResult::Complete.new(result)
           else
             cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable, async: async) }
           end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -970,7 +970,11 @@ module ActiveRecord
         # If +allow_retry+ is true, a connection-related exception will
         # cause an automatic reconnect and re-run of the block, up to
         # the connection's configured +connection_retries+ setting
-        # and the configured +retry_deadline+ limit.
+        # and the configured +retry_deadline+ limit. (Note that when
+        # +allow_retry+ is true, it's possible to return without having marked
+        # the connection as verified. If the block is guaranteed to exercise the
+        # connection, consider calling `verified!` to avoid needless
+        # verification queries in subsequent calls.)
         #
         # If +materialize_transactions+ is false, the block will be run without
         # ensuring virtual transactions have been materialized in the DB
@@ -1021,9 +1025,7 @@ module ActiveRecord
             end
 
             begin
-              result = yield @raw_connection
-              @verified = true
-              result
+              yield @raw_connection
             rescue => original_exception
               translated_exception = translate_exception_class(original_exception, nil, nil)
               invalidate_transaction(translated_exception)
@@ -1058,6 +1060,13 @@ module ActiveRecord
           end
         end
 
+        # Mark the connection as verified. Call this inside a
+        # `with_raw_connection` block only when the block is guaranteed to
+        # exercise the raw connection.
+        def verified!
+          @verified = true
+        end
+
         def retryable_connection_error?(exception)
           exception.is_a?(ConnectionNotEstablished) || exception.is_a?(ConnectionFailed)
         end

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

@@ -98,6 +98,7 @@ module ActiveRecord
               with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
                 sync_timezone_changes(conn)
                 result = conn.query(sql)
+                verified!
                 handle_warnings(sql)
                 result
               end
@@ -126,6 +127,8 @@ module ActiveRecord
                   result = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
                     stmt.execute(*type_casted_binds)
                   end
+                  verified!
+                  result
                 rescue ::Mysql2::Error => e
                   if cache_stmt
                     @statements.delete(sql)

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

@@ -16,7 +16,9 @@ module ActiveRecord
 
           log(sql, name) do
             with_raw_connection do |conn|
-              conn.async_exec(sql).map_types!(@type_map_for_results).values
+              result = conn.async_exec(sql).map_types!(@type_map_for_results).values
+              verified!
+              result
             end
           end
         end
@@ -51,6 +53,7 @@ module ActiveRecord
           log(sql, name, 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

data/lib/active_record/connection_adapters/postgresql/oid/money.rb

@@ -27,9 +27,10 @@ module ActiveRecord
             value = value.sub(/^\((.+)\)$/, '-\1') # (4)
             case value
             when /^-?\D*+[\d,]+\.\d{2}$/  # (1)
-              value.gsub!(/[^-\d.]/, "")
+              value.delete!("^-0-9.")
             when /^-?\D*+[\d.]+,\d{2}$/  # (2)
-              value.gsub!(/[^-\d,]/, "").sub!(/,/, ".")
+              value.delete!("^-0-9,")
+              value.tr!(",", ".")
             end
 
             super(value)

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

@@ -341,7 +341,7 @@ module ActiveRecord
               JOIN pg_namespace   nsp  ON (t.relnamespace = nsp.oid)
               WHERE t.oid = #{quote(quote_table_name(table))}::regclass
                 AND cons.contype = 'p'
-                AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate'
+                AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate|gen_random_uuid'
             SQL
           end
 
@@ -385,11 +385,18 @@ module ActiveRecord
           execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
           pk, seq = pk_and_sequence_for(new_name)
           if pk
-            idx = "#{table_name}_pkey"
-            new_idx = "#{new_name}_pkey"
+            # PostgreSQL automatically creates an index for PRIMARY KEY with name consisting of
+            # truncated table name and "_pkey" suffix fitting into max_identifier_length number of characters.
+            max_pkey_prefix = max_identifier_length - "_pkey".size
+            idx = "#{table_name[0, max_pkey_prefix]}_pkey"
+            new_idx = "#{new_name[0, max_pkey_prefix]}_pkey"
             execute "ALTER INDEX #{quote_table_name(idx)} RENAME TO #{quote_table_name(new_idx)}"
-            if seq && seq.identifier == "#{table_name}_#{pk}_seq"
-              new_seq = "#{new_name}_#{pk}_seq"
+
+            # PostgreSQL automatically creates a sequence for PRIMARY KEY with name consisting of
+            # truncated table name and "#{primary_key}_seq" suffix fitting into max_identifier_length number of characters.
+            max_seq_prefix = max_identifier_length - "_#{pk}_seq".size
+            if seq && seq.identifier == "#{table_name[0, max_seq_prefix]}_#{pk}_seq"
+              new_seq = "#{new_name[0, max_seq_prefix]}_#{pk}_seq"
               execute "ALTER TABLE #{seq.quoted} RENAME TO #{quote_table_name(new_seq)}"
             end
           end