activerecord 7.2.3 → 8.0.0.beta1

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -11,9 +11,12 @@ require "active_record/connection_adapters/sqlite3/schema_definitions"
 require "active_record/connection_adapters/sqlite3/schema_dumper"
 require "active_record/connection_adapters/sqlite3/schema_statements"
 
-gem "sqlite3", ">= 1.4"
+gem "sqlite3", ">= 2.1"
 require "sqlite3"
 
+# Suppress the warning that SQLite3 issues when open writable connections are carried across fork()
+SQLite3::ForkSafety.suppress_warnings!
+
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     # = Active Record SQLite3 Adapter
@@ -21,7 +24,7 @@ module ActiveRecord
     # The SQLite3 adapter works with the sqlite3-ruby drivers
     # (available as gem from https://rubygems.org/gems/sqlite3).
     #
-    # ==== Options
+    # Options:
     #
     # * <tt>:database</tt> - Path to the database file.
     class SQLite3Adapter < AbstractAdapter
@@ -45,7 +48,7 @@ module ActiveRecord
           args << "-header" if options[:header]
           args << File.expand_path(config.database, Rails.respond_to?(:root) ? Rails.root : nil)
 
-          find_cmd_and_exec("sqlite3", *args)
+          find_cmd_and_exec(ActiveRecord.database_cli[:sqlite], *args)
         end
       end
 
@@ -119,9 +122,14 @@ module ActiveRecord
           end
         end
 
+        @last_affected_rows = nil
+        @previous_read_uncommitted = nil
         @config[:strict] = ConnectionAdapters::SQLite3Adapter.strict_strings_by_default unless @config.key?(:strict)
-        @connection_parameters = @config.merge(database: @config[:database].to_s, results_as_hash: true)
-        @use_insert_returning = @config.key?(:insert_returning) ? self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
+        @connection_parameters = @config.merge(
+          database: @config[:database].to_s,
+          results_as_hash: true,
+          default_transaction_mode: :immediate,
+        )
       end
 
       def database_exists?
@@ -199,12 +207,7 @@ module ActiveRecord
         !(@raw_connection.nil? || @raw_connection.closed?)
       end
 
-      def active?
-        if connected?
-          verified!
-          true
-        end
-      end
+      alias_method :active?, :connected?
 
       alias :reset! :reconnect!
 
@@ -283,6 +286,38 @@ module ActiveRecord
         exec_query "DROP INDEX #{quote_column_name(index_name)}"
       end
 
+      VIRTUAL_TABLE_REGEX = /USING\s+(\w+)\s*\((.+)\)/i
+
+      # Returns a list of defined virtual tables
+      def virtual_tables
+        query = <<~SQL
+          SELECT name, sql FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL %';
+        SQL
+
+        exec_query(query, "SCHEMA").cast_values.each_with_object({}) do |row, memo|
+          table_name, sql = row[0], row[1]
+          _, module_name, arguments = sql.match(VIRTUAL_TABLE_REGEX).to_a
+          memo[table_name] = [module_name, arguments]
+        end.to_a
+      end
+
+      # Creates a virtual table
+      #
+      # Example:
+      #   create_virtual_table :emails, :fts5, ['sender', 'title',' body']
+      def create_virtual_table(table_name, module_name, values)
+        exec_query "CREATE VIRTUAL TABLE IF NOT EXISTS #{table_name} USING #{module_name} (#{values.join(", ")})"
+      end
+
+      # Drops a virtual table
+      #
+      # Although this command ignores +module_name+ and +values+,
+      # it can be helpful to provide these in a migration's +change+ method so it can be reverted.
+      # In that case, +module_name+, +values+ and +options+ will be used by #create_virtual_table.
+      def drop_virtual_table(table_name, module_name, values, **options)
+        drop_table(table_name)
+      end
+
       # Renames a table.
       #
       # Example:
@@ -372,7 +407,7 @@ module ActiveRecord
       end
       alias :add_belongs_to :add_reference
 
-      FK_REGEX = /.*FOREIGN KEY\s+\("([^"]+)"\)\s+REFERENCES\s+"(\w+)"\s+\("(\w+)"\)/
+      FK_REGEX = /.*FOREIGN KEY\s+\("(\w+)"\)\s+REFERENCES\s+"(\w+)"\s+\("(\w+)"\)/
       DEFERRABLE_REGEX = /DEFERRABLE INITIALLY (\w+)/
       def foreign_keys(table_name)
         # SQLite returns 1 row for each column of composite foreign keys.
@@ -433,10 +468,6 @@ module ActiveRecord
         @config.fetch(:flags, 0).anybits?(::SQLite3::Constants::Open::SHAREDCACHE)
       end
 
-      def use_insert_returning?
-        @use_insert_returning
-      end
-
       def get_database_version # :nodoc:
         SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)", "SCHEMA"))
       end
@@ -547,8 +578,8 @@ module ActiveRecord
             yield definition if block_given?
           end
 
-          disable_referential_integrity do
-            transaction do
+          transaction do
+            disable_referential_integrity do
               move_table(table_name, altered_table_name, options.merge(temporary: true))
               move_table(altered_table_name, table_name, &caller)
             end
@@ -666,6 +697,8 @@ module ActiveRecord
             InvalidForeignKey.new(message, sql: sql, binds: binds, connection_pool: @pool)
           elsif exception.message.match?(/called on a closed database/i)
             ConnectionNotEstablished.new(exception, connection_pool: @pool)
+          elsif exception.is_a?(::SQLite3::BusyException)
+            StatementTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
           else
             super
           end
@@ -692,6 +725,8 @@ module ActiveRecord
             end
 
             basic_structure.map do |column|
+              column = column.to_h
+
               column_name = column["name"]
 
               if collation_hash.has_key? column_name
@@ -783,12 +818,15 @@ module ActiveRecord
           if @config[:timeout] && @config[:retries]
             raise ArgumentError, "Cannot specify both timeout and retries arguments"
           elsif @config[:timeout]
-            @raw_connection.busy_timeout(self.class.type_cast_config_to_integer(@config[:timeout]))
+            timeout = self.class.type_cast_config_to_integer(@config[:timeout])
+            raise TypeError, "timeout must be integer, not #{timeout}" unless timeout.is_a?(Integer)
+            @raw_connection.busy_handler_timeout = timeout
           elsif @config[:retries]
+            ActiveRecord.deprecator.warn(<<~MSG)
+              The retries option is deprecated and will be removed in Rails 8.1. Use timeout instead.
+            MSG
             retries = self.class.type_cast_config_to_integer(@config[:retries])
-            raw_connection.busy_handler do |count|
-              count <= retries
-            end
+            raw_connection.busy_handler { |count| count <= retries }
           end
 
           super

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

@@ -4,93 +4,63 @@ module ActiveRecord
   module ConnectionAdapters
     module Trilogy
       module DatabaseStatements
-        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false) # :nodoc:
-          sql = transform_query(sql)
-          check_if_write_query(sql)
-          mark_transaction_written_if_write(sql)
-
-          result = raw_execute(sql, name, async: async, allow_retry: allow_retry)
-          ActiveRecord::Result.new(result.fields, result.to_a)
-        end
-
         def exec_insert(sql, name, binds, pk = nil, sequence_name = nil, returning: nil) # :nodoc:
-          sql = transform_query(sql)
-          check_if_write_query(sql)
-          mark_transaction_written_if_write(sql)
-
           sql, _binds = sql_for_insert(sql, pk, binds, returning)
-          raw_execute(sql, name)
-        end
-
-        def exec_delete(sql, name = nil, binds = []) # :nodoc:
-          sql = transform_query(sql)
-          check_if_write_query(sql)
-          mark_transaction_written_if_write(sql)
-
-          result = raw_execute(to_sql(sql, binds), name)
-          result.affected_rows
+          internal_execute(sql, name)
         end
 
-        alias :exec_update :exec_delete # :nodoc:
-
         private
-          def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
-            log(sql, name, async: async) do |notification_payload|
-              with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
-                sync_timezone_changes(conn)
-                result = conn.query(sql)
-                while conn.more_results_exist?
-                  conn.next_result
-                end
-                verified!
-                handle_warnings(sql)
-                notification_payload[:row_count] = result.count
-                result
-              end
+          def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch: false)
+            reset_multi_statement = if batch && !@config[:multi_statement]
+              raw_connection.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_ON)
+              true
             end
-          end
 
-          def last_inserted_id(result)
-            if supports_insert_returning?
-              super
+            # Make sure we carry over any changes to ActiveRecord.default_timezone that have been
+            # made since we established the connection
+            if default_timezone == :local
+              raw_connection.query_flags |= ::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
             else
-              result.last_insert_id
+              raw_connection.query_flags &= ~::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
             end
-          end
 
-          def sync_timezone_changes(conn)
-            # Sync any changes since connection last established.
-            if default_timezone == :local
-              conn.query_flags |= ::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
-            else
-              conn.query_flags &= ~::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
+            result = raw_connection.query(sql)
+            while raw_connection.more_results_exist?
+              raw_connection.next_result
+            end
+            verified!
+            handle_warnings(sql)
+            notification_payload[:row_count] = result.count
+            result
+          ensure
+            if reset_multi_statement && active?
+              raw_connection.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_OFF)
             end
           end
 
-          def execute_batch(statements, name = nil)
-            statements = statements.map { |sql| transform_query(sql) }
-            combine_multi_statements(statements).each do |statement|
-              with_raw_connection do |conn|
-                raw_execute(statement, name)
-              end
+          def cast_result(result)
+            if result.fields.empty?
+              ActiveRecord::Result.empty
+            else
+              ActiveRecord::Result.new(result.fields, result.rows)
             end
           end
 
-          def multi_statements_enabled?
-            !!@config[:multi_statement]
+          def affected_rows(result)
+            result.affected_rows
           end
 
-          def with_multi_statements
-            if multi_statements_enabled?
-              return yield
+          def last_inserted_id(result)
+            if supports_insert_returning?
+              super
+            else
+              result.last_insert_id
             end
+          end
 
-            with_raw_connection do |conn|
-              conn.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_ON)
-
-              yield
-            ensure
-              conn.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_OFF) if active?
+          def execute_batch(statements, name = nil, **kwargs)
+            combine_multi_statements(statements).each do |statement|
+              raw_execute(statement, name, batch: true, **kwargs)
             end
           end
       end

data/lib/active_record/connection_adapters/trilogy_adapter.rb

@@ -121,7 +121,7 @@ module ActiveRecord
       end
 
       def active?
-        connected? && @lock.synchronize { @raw_connection&.ping; verified! } || false
+        connected? && @lock.synchronize { @raw_connection&.ping } || false
       rescue ::Trilogy::Error
         false
       end
@@ -149,23 +149,6 @@ module ActiveRecord
           TYPE_MAP.lookup(type).is_a?(Type::String) || TYPE_MAP.lookup(type).is_a?(Type::Text)
         end
 
-        def each_hash(result)
-          return to_enum(:each_hash, result) unless block_given?
-
-          keys = result.fields.map(&:to_sym)
-          result.rows.each do |row|
-            hash = {}
-            idx = 0
-            row.each do |value|
-              hash[keys[idx]] = value
-              idx += 1
-            end
-            yield hash
-          end
-
-          nil
-        end
-
         def error_number(exception)
           exception.error_code if exception.respond_to?(:error_code)
         end

data/lib/active_record/connection_handling.rb

@@ -87,6 +87,8 @@ module ActiveRecord
 
       connections = []
 
+      @shard_keys = shards.keys
+
       if shards.empty?
         shards[:default] = database
       end
@@ -170,10 +172,20 @@ module ActiveRecord
       prevent_writes = true if role == ActiveRecord.reading_role
 
       append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: classes)
-      begin
-        yield
-      ensure
-        connected_to_stack.pop
+      yield
+    ensure
+      connected_to_stack.pop
+    end
+
+    # Passes the block to +connected_to+ for every +shard+ the
+    # model is configured to connect to (if any), and returns the
+    # results in an array.
+    #
+    # Optionally, +role+ and/or +prevent_writes+ can be passed which
+    # will be forwarded to each +connected_to+ call.
+    def connected_to_all_shards(role: nil, prevent_writes: false, &blk)
+      shard_keys.map do |shard|
+        connected_to(shard: shard, role: role, prevent_writes: prevent_writes, &blk)
       end
     end
 
@@ -361,6 +373,14 @@ module ActiveRecord
       connection_pool.schema_cache.clear!
     end
 
+    def shard_keys
+      connection_class_for_self.instance_variable_get(:@shard_keys) || []
+    end
+
+    def sharded?
+      shard_keys.any?
+    end
+
     private
       def resolve_config_for_connection(config_or_env)
         raise "Anonymous class is not allowed." unless name
@@ -375,13 +395,11 @@ module ActiveRecord
         prevent_writes = true if role == ActiveRecord.reading_role
 
         append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self])
-        begin
-          return_value = yield
-          return_value.load if return_value.is_a? ActiveRecord::Relation
-          return_value
-        ensure
-          self.connected_to_stack.pop
-        end
+        return_value = yield
+        return_value.load if return_value.is_a? ActiveRecord::Relation
+        return_value
+      ensure
+        self.connected_to_stack.pop
       end
 
       def append_to_connected_to_stack(entry)

data/lib/active_record/core.rb

@@ -89,6 +89,7 @@ module ActiveRecord
       class_attribute :belongs_to_required_by_default, instance_accessor: false
 
       class_attribute :strict_loading_by_default, instance_accessor: false, default: false
+      class_attribute :strict_loading_mode, instance_accessor: false, default: :all
 
       class_attribute :has_many_inversing, instance_accessor: false, default: false
 
@@ -102,19 +103,7 @@ module ActiveRecord
 
       class_attribute :shard_selector, instance_accessor: false, default: nil
 
-      ##
-      # :singleton-method:
-      #
-      # Specifies the attributes that will be included in the output of the
-      # #inspect method:
-      #
-      #   Post.attributes_for_inspect = [:id, :title]
-      #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!">"
-      #
-      # When set to `:all` inspect will list all the record's attributes:
-      #
-      #   Post.attributes_for_inspect = :all
-      #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+      # Specifies the attributes that will be included in the output of the #inspect method
       class_attribute :attributes_for_inspect, instance_accessor: false, default: :all
 
       def self.application_record_class? # :nodoc:
@@ -265,7 +254,7 @@ module ActiveRecord
         return super if StatementCache.unsupported_value?(id)
 
         cached_find_by([primary_key], [id]) ||
-          raise(RecordNotFound.new("Couldn't find #{name} with '#{primary_key}'=#{id.inspect}", name, primary_key, id))
+          raise(RecordNotFound.new("Couldn't find #{name} with '#{primary_key}'=#{id}", name, primary_key, id))
       end
 
       def find_by(*args) # :nodoc:
@@ -443,8 +432,8 @@ module ActiveRecord
               where(wheres).limit(1)
             }
 
-            begin
-              statement.execute(values.flatten, connection, allow_retry: true).first
+            statement.execute(values.flatten, connection, allow_retry: true).then do |r|
+              r.first
             rescue TypeError
               raise ActiveRecord::StatementInvalid
             end
@@ -585,7 +574,7 @@ module ActiveRecord
     #
     #   topic = Topic.new(title: "Budget", author_name: "Jason")
     #   topic.slice(:title, :author_name)
-    #   # => { "title" => "Budget", "author_name" => "Jason" }
+    #   => { "title" => "Budget", "author_name" => "Jason" }
     #
     #--
     # Implemented by ActiveModel::Access#slice.
@@ -599,7 +588,7 @@ module ActiveRecord
     #
     #   topic = Topic.new(title: "Budget", author_name: "Jason")
     #   topic.values_at(:title, :author_name)
-    #   # => ["Budget", "Jason"]
+    #   => ["Budget", "Jason"]
     #
     #--
     # Implemented by ActiveModel::Access#values_at.
@@ -676,14 +665,12 @@ module ActiveRecord
     # Sets the record to strict_loading mode. This will raise an error
     # if the record tries to lazily load an association.
     #
-    # NOTE: Strict loading is disabled during validation in order to let the record validate its association.
-    #
     #   user = User.first
     #   user.strict_loading! # => true
     #   user.address.city
-    #   # => ActiveRecord::StrictLoadingViolationError
+    #   => ActiveRecord::StrictLoadingViolationError
     #   user.comments.to_a
-    #   # => ActiveRecord::StrictLoadingViolationError
+    #   => ActiveRecord::StrictLoadingViolationError
     #
     # ==== Parameters
     #
@@ -703,7 +690,7 @@ module ActiveRecord
     #   user.address.city # => "Tatooine"
     #   user.comments.to_a # => [#<Comment:0x00...]
     #   user.comments.first.ratings.to_a
-    #   # => ActiveRecord::StrictLoadingViolationError
+    #   => ActiveRecord::StrictLoadingViolationError
     def strict_loading!(value = true, mode: :all)
       unless [:all, :n_plus_one_only].include?(mode)
         raise ArgumentError, "The :mode option must be one of [:all, :n_plus_one_only] but #{mode.inspect} was provided."
@@ -725,29 +712,11 @@ module ActiveRecord
       @strict_loading_mode == :all
     end
 
-    # Prevents records from being written to the database:
-    #
-    #   customer = Customer.new
-    #   customer.readonly!
-    #   customer.save # raises ActiveRecord::ReadOnlyRecord
-    #
-    #   customer = Customer.first
-    #   customer.readonly!
-    #   customer.update(name: 'New Name') # raises ActiveRecord::ReadOnlyRecord
-    #
-    # Read-only records cannot be deleted from the database either:
+    # Marks this record as read only.
     #
     #   customer = Customer.first
     #   customer.readonly!
-    #   customer.destroy # raises ActiveRecord::ReadOnlyRecord
-    #
-    # Please, note that the objects themselves are still mutable in memory:
-    #
-    #   customer = Customer.new
-    #   customer.readonly!
-    #   customer.name = 'New Name' # OK
-    #
-    # but you won't be able to persist the changes.
+    #   customer.save # Raises an ActiveRecord::ReadOnlyRecord
     def readonly!
       @readonly = true
     end
@@ -756,26 +725,12 @@ module ActiveRecord
       self.class.connection_handler
     end
 
-    # Returns the attributes of the record as a nicely formatted string.
-    #
-    #   Post.first.inspect
-    #   #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
-    #
-    # The attributes can be limited by setting <tt>.attributes_for_inspect</tt>.
-    #
-    #   Post.attributes_for_inspect = [:id, :title]
-    #   Post.first.inspect
-    #   #=> "#<Post id: 1, title: "Hello, World!">"
+    # Returns the attributes specified by <tt>.attributes_for_inspect</tt> as a nicely formatted string.
     def inspect
       inspect_with_attributes(attributes_for_inspect)
     end
 
-    # Returns all attributes of the record as a nicely formatted string,
-    # ignoring <tt>.attributes_for_inspect</tt>.
-    #
-    #   Post.first.full_inspect
-    #   #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
-    #
+    # Returns the full contents of the record as a nicely formatted string.
     def full_inspect
       inspect_with_attributes(all_attributes_for_inspect)
     end
@@ -830,7 +785,7 @@ module ActiveRecord
 
         @primary_key         = klass.primary_key
         @strict_loading      = klass.strict_loading_by_default
-        @strict_loading_mode = :all
+        @strict_loading_mode = klass.strict_loading_mode
 
         klass.define_attribute_methods
       end

data/lib/active_record/counter_cache.rb

@@ -28,7 +28,7 @@ module ActiveRecord
       #   # For the Post with id #1, reset the comments_count
       #   Post.reset_counters(1, :comments)
       #
-      #   # Like above, but also touch the updated_at and/or updated_on
+      #   # Like above, but also touch the +updated_at+ and/or +updated_on+
       #   # attributes.
       #   Post.reset_counters(1, :comments, touch: true)
       def reset_counters(id, *counters, touch: nil)

data/lib/active_record/database_configurations/connection_url_resolver.rb

@@ -81,9 +81,7 @@ module ActiveRecord
 
         def resolved_adapter
           adapter = uri.scheme && @uri.scheme.tr("-", "_")
-          if adapter && ActiveRecord.protocol_adapters[adapter]
-            adapter = ActiveRecord.protocol_adapters[adapter]
-          end
+          adapter = ActiveRecord.protocol_adapters[adapter] || adapter
           adapter
         end
 

data/lib/active_record/delegated_type.rb

@@ -181,16 +181,16 @@ module ActiveRecord
     #     delegated_type :entryable, types: %w[ Message Comment ], dependent: :destroy
     #   end
     #
-    #   @entry.entryable_class # => Message or Comment
-    #   @entry.entryable_name  # => "message" or "comment"
-    #   Entry.messages         # => Entry.where(entryable_type: "Message")
-    #   @entry.message?        # => true when entryable_type == "Message"
-    #   @entry.message         # => returns the message record, when entryable_type == "Message", otherwise nil
-    #   @entry.message_id      # => returns entryable_id, when entryable_type == "Message", otherwise nil
-    #   Entry.comments         # => Entry.where(entryable_type: "Comment")
-    #   @entry.comment?        # => true when entryable_type == "Comment"
-    #   @entry.comment         # => returns the comment record, when entryable_type == "Comment", otherwise nil
-    #   @entry.comment_id      # => returns entryable_id, when entryable_type == "Comment", otherwise nil
+    #   Entry#entryable_class # => +Message+ or +Comment+
+    #   Entry#entryable_name  # => "message" or "comment"
+    #   Entry.messages        # => Entry.where(entryable_type: "Message")
+    #   Entry#message?        # => true when entryable_type == "Message"
+    #   Entry#message         # => returns the message record, when entryable_type == "Message", otherwise nil
+    #   Entry#message_id      # => returns entryable_id, when entryable_type == "Message", otherwise nil
+    #   Entry.comments        # => Entry.where(entryable_type: "Comment")
+    #   Entry#comment?        # => true when entryable_type == "Comment"
+    #   Entry#comment         # => returns the comment record, when entryable_type == "Comment", otherwise nil
+    #   Entry#comment_id      # => returns entryable_id, when entryable_type == "Comment", otherwise nil
     #
     # You can also declare namespaced types:
     #
@@ -199,25 +199,25 @@ module ActiveRecord
     #   end
     #
     #   Entry.access_notice_messages
-    #   @entry.access_notice_message
-    #   @entry.access_notice_message?
+    #   entry.access_notice_message
+    #   entry.access_notice_message?
     #
-    # ==== Options
+    # === Options
     #
     # The +options+ are passed directly to the +belongs_to+ call, so this is where you declare +dependent+ etc.
     # The following options can be included to specialize the behavior of the delegated type convenience methods.
     #
-    # [+:foreign_key+]
+    # [:foreign_key]
     #   Specify the foreign key used for the convenience methods. By default this is guessed to be the passed
     #   +role+ with an "_id" suffix. So a class that defines a
     #   <tt>delegated_type :entryable, types: %w[ Message Comment ]</tt> association will use "entryable_id" as
     #   the default <tt>:foreign_key</tt>.
-    # [+:foreign_type+]
+    # [:foreign_type]
     #   Specify the column used to store the associated object's type. By default this is inferred to be the passed
     #   +role+ with a "_type" suffix. A class that defines a
     #   <tt>delegated_type :entryable, types: %w[ Message Comment ]</tt> association will use "entryable_type" as
     #   the default <tt>:foreign_type</tt>.
-    # [+:primary_key+]
+    # [:primary_key]
     #   Specify the method that returns the primary key of associated object used for the convenience methods.
     #   By default this is +id+.
     #
@@ -226,8 +226,8 @@ module ActiveRecord
     #     delegated_type :entryable, types: %w[ Message Comment ], primary_key: :uuid, foreign_key: :entryable_uuid
     #   end
     #
-    #   @entry.message_uuid # => returns entryable_uuid, when entryable_type == "Message", otherwise nil
-    #   @entry.comment_uuid # => returns entryable_uuid, when entryable_type == "Comment", otherwise nil
+    #   Entry#message_uuid      # => returns entryable_uuid, when entryable_type == "Message", otherwise nil
+    #   Entry#comment_uuid      # => returns entryable_uuid, when entryable_type == "Comment", otherwise nil
     def delegated_type(role, types:, **options)
       belongs_to role, options.delete(:scope), **options.merge(polymorphic: true)
       define_delegated_type_methods role, types: types, options: options

data/lib/active_record/encryption/config.rb

@@ -8,7 +8,8 @@ module ActiveRecord
     class Config
       attr_accessor :primary_key, :deterministic_key, :store_key_references, :key_derivation_salt, :hash_digest_class,
                     :support_unencrypted_data, :encrypt_fixtures, :validate_column_size, :add_to_filter_parameters,
-                    :excluded_from_filter_parameters, :extend_queries, :previous_schemes, :forced_encoding_for_deterministic_encryption
+                    :excluded_from_filter_parameters, :extend_queries, :previous_schemes, :forced_encoding_for_deterministic_encryption,
+                    :compressor
 
       def initialize
         set_defaults
@@ -55,6 +56,7 @@ module ActiveRecord
           self.previous_schemes = []
           self.forced_encoding_for_deterministic_encryption = Encoding::UTF_8
           self.hash_digest_class = OpenSSL::Digest::SHA1
+          self.compressor = Zlib
 
           # TODO: Setting to false for now as the implementation is a bit experimental
           self.extend_queries = false