activerecord 7.2.2.1 → 8.1.2

data/lib/active_record/testing/query_assertions.rb

@@ -11,12 +11,18 @@ module ActiveRecord
       #   # Check for any number of queries
       #   assert_queries_count { Post.first }
       #
-      # If the +:include_schema+ option is provided, any queries (including schema related) are counted.
+      # Any unmaterialized transactions will be materialized to ensure only
+      # queries attempted intside the block are counted.
+      #
+      # If the +:include_schema+ option is provided, any queries (including
+      # schema related) are counted. Setting this option also skips leasing a
+      # connection to materialize pending transactions since we want to count
+      # queries executed at connection open (e.g., type map).
       #
       #   assert_queries_count(1, include_schema: true) { Post.columns }
       #
       def assert_queries_count(count = nil, include_schema: false, &block)
-        ActiveRecord::Base.lease_connection.materialize_transactions
+        ActiveRecord::Base.lease_connection.materialize_transactions unless include_schema
 
         counter = SQLCounter.new
         ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do

data/lib/active_record/timestamp.rb

@@ -169,8 +169,10 @@ module ActiveRecord
     # Clear attributes and changed_attributes
     def clear_timestamp_attributes
       all_timestamp_attributes_in_model.each do |attribute_name|
-        self[attribute_name] = nil
-        clear_attribute_change(attribute_name)
+        if self[attribute_name]
+          self[attribute_name] = nil
+          clear_attribute_change(attribute_name)
+        end
       end
     end
   end

data/lib/active_record/token_for.rb

@@ -40,7 +40,7 @@ module ActiveRecord
       # +nil+ if the token is invalid or the record was not found.
       def find_by_token_for(purpose, token)
         raise UnknownPrimaryKey.new(self) unless model.primary_key
-        model.token_definitions.fetch(purpose).resolve_token(token) { |id| find_by(model.primary_key => id) }
+        model.token_definitions.fetch(purpose).resolve_token(token) { |id| find_by(model.primary_key => [id]) }
       end
 
       # Finds a record using a given +token+ for a predefined +purpose+. Raises

data/lib/active_record/transaction.rb

@@ -26,7 +26,7 @@ module ActiveRecord
   #    # We are inside a real and not finalized transaction.
   #  end
   #
-  # Closed transactions are `blank?` too.
+  # Closed transactions are +blank?+ too.
   #
   # == Callbacks
   #
@@ -101,9 +101,6 @@ module ActiveRecord
     #
     # If the entire chain of nested transactions are all successfully committed,
     # the block is never called.
-    #
-    # If the transaction is already finalized, attempting to register a callback
-    # will raise ActiveRecord::ActiveRecordError.
     def after_rollback(&block)
       @internal_transaction&.after_rollback(&block)
     end
@@ -115,7 +112,7 @@ module ActiveRecord
 
     # Returns true if the transaction doesn't exist or is finalized.
     def closed?
-      @internal_transaction.nil? || @internal_transaction.state.finalized?
+      @internal_transaction.nil? || @internal_transaction.closed?
     end
 
     alias_method :blank?, :closed?

data/lib/active_record/transactions.rb

@@ -13,7 +13,7 @@ module ActiveRecord
                        scope: [:kind, :name]
     end
 
-    attr_accessor :_new_record_before_last_commit # :nodoc:
+    attr_accessor :_new_record_before_last_commit, :_last_transaction_return_status # :nodoc:
 
     # = Active Record \Transactions
     #
@@ -219,22 +219,41 @@ module ActiveRecord
     # database error will occur because the savepoint has already been
     # automatically released. The following example demonstrates the problem:
     #
-    #   Model.lease_connection.transaction do                           # BEGIN
-    #     Model.lease_connection.transaction(requires_new: true) do     # CREATE SAVEPOINT active_record_1
-    #       Model.lease_connection.create_table(...)                    # active_record_1 now automatically released
-    #     end                                                     # RELEASE SAVEPOINT active_record_1
-    #                                                             # ^^^^ BOOM! database error!
-    #   end
+    #   Model.transaction do                           # BEGIN
+    #     Model.transaction(requires_new: true) do     # CREATE SAVEPOINT active_record_1
+    #       Model.lease_connection.create_table(...)   # active_record_1 now automatically released
+    #     end                                          # RELEASE SAVEPOINT active_record_1
+    #   end                                            # ^^^^ BOOM! database error!
     #
     # Note that "TRUNCATE" is also a MySQL DDL statement!
     module ClassMethods
       # See the ConnectionAdapters::DatabaseStatements#transaction API docs.
       def transaction(**options, &block)
         with_connection do |connection|
-          connection.transaction(**options, &block)
+          connection.pool.with_pool_transaction_isolation_level(ActiveRecord.default_transaction_isolation_level, connection.transaction_open?) do
+            connection.transaction(**options, &block)
+          end
         end
       end
 
+      # Makes all transactions the current pool use the isolation level initiated within the block.
+      def with_pool_transaction_isolation_level(isolation_level, &block)
+        if current_transaction.open?
+          raise ActiveRecord::TransactionIsolationError, "cannot set default isolation level while transaction is open"
+        end
+
+        old_level = connection_pool.pool_transaction_isolation_level
+        connection_pool.pool_transaction_isolation_level = isolation_level
+        yield
+      ensure
+        connection_pool.pool_transaction_isolation_level = old_level
+      end
+
+      # Returns the default isolation level for the connection pool, set earlier by #with_pool_transaction_isolation_level.
+      def pool_transaction_isolation_level
+        connection_pool.pool_transaction_isolation_level
+      end
+
       # Returns a representation of the current transaction state,
       # which can be a top level transaction, a savepoint, or the absence of a transaction.
       #
@@ -408,17 +427,20 @@ module ActiveRecord
     # instance.
     def with_transaction_returning_status
       self.class.with_connection do |connection|
-        status = nil
-        ensure_finalize = !connection.transaction_open?
+        connection.pool.with_pool_transaction_isolation_level(ActiveRecord.default_transaction_isolation_level, connection.transaction_open?) do
+          status = nil
+          ensure_finalize = !connection.transaction_open?
 
-        connection.transaction do
-          add_to_transaction(ensure_finalize || has_transactional_callbacks?)
-          remember_transaction_record_state
+          connection.transaction do
+            add_to_transaction(ensure_finalize || has_transactional_callbacks?)
+            remember_transaction_record_state
 
-          status = yield
-          raise ActiveRecord::Rollback unless status
+            status = yield
+            raise ActiveRecord::Rollback unless status
+          end
+          @_last_transaction_return_status = status
+          status
         end
-        status
       end
     end
 
@@ -433,6 +455,7 @@ module ActiveRecord
       def init_internals
         super
         @_start_transaction_state = nil
+        @_last_transaction_return_status = nil
         @_committed_already_called = nil
         @_new_record_before_last_commit = nil
       end

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -26,6 +26,7 @@ module ActiveRecord
         if block
           @mapping[key] = block
         else
+          value.freeze
           @mapping[key] = proc { value }
         end
         @cache.clear
@@ -50,7 +51,7 @@ module ActiveRecord
 
       private
         def perform_fetch(type, *args, &block)
-          @mapping.fetch(type, block).call(type, *args)
+          @mapping.fetch(type, block).call(type, *args).freeze
         end
     end
   end

data/lib/active_record/type/internal/timezone.rb

@@ -16,6 +16,13 @@ module ActiveRecord
         def default_timezone
           @timezone || ActiveRecord.default_timezone
         end
+
+        def ==(other)
+          super(other) && timezone == other.timezone
+        end
+
+        protected
+          attr_reader :timezone
       end
     end
   end

data/lib/active_record/type/json.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/json"
+
 module ActiveRecord
   module Type
     class Json < ActiveModel::Type::Value
@@ -11,11 +13,22 @@ module ActiveRecord
 
       def deserialize(value)
         return value unless value.is_a?(::String)
-        ActiveSupport::JSON.decode(value) rescue nil
+        begin
+          ActiveSupport::JSON.decode(value)
+        rescue JSON::ParserError => e
+          # NOTE: This may hide json with duplicate keys. We don't really want to just ignore it
+          # but it's the best we can do in order to still allow updating columns that somehow already
+          # contain invalid json from some other source.
+          # See https://github.com/rails/rails/pull/55536
+          ActiveSupport.error_reporter.report(e, source: "application.active_record")
+          nil
+        end
       end
 
+      JSON_ENCODER = ActiveSupport::JSON::Encoding.json_encoder.new(escape: false)
+
       def serialize(value)
-        ActiveSupport::JSON.encode(value) unless value.nil?
+        JSON_ENCODER.encode(value) unless value.nil?
       end
 
       def changed_in_place?(raw_old_value, new_value)

data/lib/active_record/type/serialized.rb

@@ -9,9 +9,10 @@ module ActiveRecord
 
       attr_reader :subtype, :coder
 
-      def initialize(subtype, coder)
+      def initialize(subtype, coder, comparable: false)
         @subtype = subtype
         @coder = coder
+        @comparable = comparable
         super(subtype)
       end
 
@@ -34,9 +35,15 @@ module ActiveRecord
 
       def changed_in_place?(raw_old_value, value)
         return false if value.nil?
-        raw_new_value = encoded(value)
-        raw_old_value.nil? != raw_new_value.nil? ||
-          subtype.changed_in_place?(raw_old_value, raw_new_value)
+
+        if @comparable
+          old_value = deserialize(raw_old_value)
+          old_value != value
+        else
+          raw_new_value = encoded(value)
+          raw_old_value.nil? != raw_new_value.nil? ||
+            subtype.changed_in_place?(raw_old_value, raw_new_value)
+        end
       end
 
       def accessor

data/lib/active_record/type/type_map.rb

@@ -46,7 +46,7 @@ module ActiveRecord
           end
 
           if matching_pair
-            matching_pair.last.call(lookup_key)
+            matching_pair.last.call(lookup_key).freeze
           elsif @parent
             @parent.perform_fetch(lookup_key, &block)
           else

data/lib/active_record/type_caster/connection.rb

@@ -19,7 +19,8 @@ module ActiveRecord
         if schema_cache.data_source_exists?(table_name)
           column = schema_cache.columns_hash(table_name)[attr_name.to_s]
           if column
-            type = @klass.with_connection { |connection| connection.lookup_cast_type_from_column(column) }
+            # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+            type = column.fetch_cast_type(@klass.lease_connection)
           end
         end
 

data/lib/active_record/validations/associated.rb

@@ -7,7 +7,7 @@ module ActiveRecord
         context = record_validation_context_for_association(record)
 
         if Array(value).reject { |association| valid_object?(association, context) }.any?
-          record.errors.add(attribute, :invalid, **options.merge(value: value))
+          record.errors.add(attribute, :invalid, **options, value: value)
         end
       end
 

data/lib/active_record/validations/uniqueness.rb

@@ -54,17 +54,17 @@ module ActiveRecord
     private
       # The check for an existing value should be run from a class that
       # isn't abstract. This means working down from the current class
-      # (self), to the first non-abstract class. Since classes don't know
-      # their subclasses, we have to build the hierarchy between self and
-      # the record's class.
+      # (self), to the first non-abstract class.
       def find_finder_class_for(record)
-        class_hierarchy = [record.class]
-
-        while class_hierarchy.first != @klass
-          class_hierarchy.unshift(class_hierarchy.first.superclass)
+        current_class = record.class
+        found_class = nil
+        loop do
+          found_class = current_class unless current_class.abstract_class?
+          break if current_class == @klass
+          current_class = current_class.superclass
         end
 
-        class_hierarchy.detect { |klass| !klass.abstract_class? }
+        found_class
       end
 
       def validation_needed?(klass, record, attribute)

data/lib/active_record.rb

@@ -26,9 +26,11 @@
 require "active_support"
 require "active_support/rails"
 require "active_support/ordered_options"
+require "active_support/core_ext/array/conversions"
 require "active_model"
 require "arel"
 require "yaml"
+require "zlib"
 
 require "active_record/version"
 require "active_record/deprecator"
@@ -51,6 +53,7 @@ module ActiveRecord
   autoload :Enum
   autoload :Explain
   autoload :FixtureSet, "active_record/fixtures"
+  autoload :FilterAttributeHandler
   autoload :Inheritance
   autoload :Integration
   autoload :InternalMetadata
@@ -61,7 +64,6 @@ module ActiveRecord
   autoload :ModelSchema
   autoload :NestedAttributes
   autoload :NoTouching
-  autoload :Normalization
   autoload :Persistence
   autoload :QueryCache
   autoload :QueryLogs
@@ -86,7 +88,6 @@ module ActiveRecord
   autoload :Timestamp
   autoload :TokenFor
   autoload :TouchLater
-  autoload :Transaction
   autoload :Transactions
   autoload :Translation
   autoload :Validations
@@ -108,6 +109,7 @@ module ActiveRecord
     autoload :Result
     autoload :StatementCache
     autoload :TableMetadata
+    autoload :Transaction
     autoload :Type
 
     autoload_under "relation" do
@@ -173,7 +175,8 @@ module ActiveRecord
     extend ActiveSupport::Autoload
 
     autoload :DatabaseTasks
-    autoload :MySQLDatabaseTasks,  "active_record/tasks/mysql_database_tasks"
+    autoload :AbstractTasks, "active_record/tasks/abstract_tasks"
+    autoload :MySQLDatabaseTasks, "active_record/tasks/mysql_database_tasks"
     autoload :PostgreSQLDatabaseTasks, "active_record/tasks/postgresql_database_tasks"
     autoload :SQLiteDatabaseTasks, "active_record/tasks/sqlite_database_tasks"
   end
@@ -196,6 +199,20 @@ module ActiveRecord
   singleton_class.attr_accessor :schema_cache_ignored_tables
   self.schema_cache_ignored_tables = []
 
+  # Checks to see if the +table_name+ is ignored by checking
+  # against the +schema_cache_ignored_tables+ option.
+  #
+  #   ActiveRecord.schema_cache_ignored_table?(:developers)
+  #
+  def self.schema_cache_ignored_table?(table_name)
+    ActiveRecord.schema_cache_ignored_tables.any? do |ignored|
+      ignored === table_name
+    end
+  end
+
+  singleton_class.attr_accessor :database_cli
+  self.database_cli = { postgresql: "psql", mysql: %w[mysql mysql5], sqlite: "sqlite3" }
+
   singleton_class.attr_reader :default_timezone
 
   # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
@@ -244,6 +261,9 @@ module ActiveRecord
   ##
   # :singleton-method: db_warnings_ignore
   # Specify allowlist of database warnings.
+  # Can be a string, regular expression, or an error code from the database.
+  #
+  #   ActiveRecord::Base.db_warnings_ignore = [/`SHOW WARNINGS` did not return the warnings/, "01000"]
   singleton_class.attr_accessor :db_warnings_ignore
   self.db_warnings_ignore = []
 
@@ -253,14 +273,6 @@ module ActiveRecord
   singleton_class.attr_accessor :reading_role
   self.reading_role = :reading
 
-  def self.legacy_connection_handling=(_)
-    raise ArgumentError, <<~MSG.squish
-      The `legacy_connection_handling` setter was deprecated in 7.0 and removed in 7.1,
-      but is still defined in your configuration. Please remove this call as it no longer
-      has any effect."
-    MSG
-  end
-
   ##
   # :singleton-method: async_query_executor
   # Sets the async_query_executor for an application. By default the thread pool executor
@@ -279,6 +291,7 @@ module ActiveRecord
   def self.global_thread_pool_async_query_executor # :nodoc:
     concurrency = global_executor_concurrency || 4
     @global_thread_pool_async_query_executor ||= Concurrent::ThreadPoolExecutor.new(
+      name: "ActiveRecord-global-async-query-executor",
       min_threads: 0,
       max_threads: concurrency,
       max_queue: concurrency * 4,
@@ -344,28 +357,8 @@ module ActiveRecord
   singleton_class.attr_accessor :run_after_transaction_callbacks_in_order_defined
   self.run_after_transaction_callbacks_in_order_defined = false
 
-  def self.commit_transaction_on_non_local_return
-    ActiveRecord.deprecator.warn <<-WARNING.squish
-      `Rails.application.config.active_record.commit_transaction_on_non_local_return`
-      is deprecated and will be removed in Rails 8.0.
-    WARNING
-  end
-
-  def self.commit_transaction_on_non_local_return=(value)
-    ActiveRecord.deprecator.warn <<-WARNING.squish
-      `Rails.application.config.active_record.commit_transaction_on_non_local_return`
-      is deprecated and will be removed in Rails 8.0.
-    WARNING
-  end
-
-  ##
-  # :singleton-method: warn_on_records_fetched_greater_than
-  # Specify a threshold for the size of query result sets. If the number of
-  # records in the set exceeds the threshold, a warning is logged. This can
-  # be used to identify queries which load thousands of records and
-  # potentially cause memory bloat.
-  singleton_class.attr_accessor :warn_on_records_fetched_greater_than
-  self.warn_on_records_fetched_greater_than = false
+  singleton_class.attr_accessor :raise_on_missing_required_finder_order_columns
+  self.run_after_transaction_callbacks_in_order_defined = false
 
   singleton_class.attr_accessor :application_record_class
   self.application_record_class = nil
@@ -384,7 +377,8 @@ module ActiveRecord
   # specific) SQL statements. If :ruby, the schema is dumped as an
   # ActiveRecord::Schema file which can be loaded into any database that
   # supports migrations. Use :ruby if you want to have different database
-  # adapters for, e.g., your development and test environments.
+  # adapters for, e.g., your development and test environments. This can be
+  # overridden per-database in the database configuration.
   singleton_class.attr_accessor :schema_format
   self.schema_format = :ruby
 
@@ -416,6 +410,12 @@ module ActiveRecord
   singleton_class.attr_accessor :migration_strategy
   self.migration_strategy = Migration::DefaultStrategy
 
+  ##
+  # :singleton-method: schema_versions_formatter
+  # Specify the formatter used by schema dumper to format versions information.
+  singleton_class.attr_accessor :schema_versions_formatter
+  self.schema_versions_formatter = Migration::DefaultSchemaVersionsFormatter
+
   ##
   # :singleton-method: dump_schema_after_migration
   # Specify whether schema dump should happen at the end of the
@@ -444,20 +444,6 @@ module ActiveRecord
   singleton_class.attr_accessor :verify_foreign_keys_for_fixtures
   self.verify_foreign_keys_for_fixtures = false
 
-  def self.allow_deprecated_singular_associations_name
-    ActiveRecord.deprecator.warn <<-WARNING.squish
-      `Rails.application.config.active_record.allow_deprecated_singular_associations_name`
-      is deprecated and will be removed in Rails 8.0.
-    WARNING
-  end
-
-  def self.allow_deprecated_singular_associations_name=(value)
-    ActiveRecord.deprecator.warn <<-WARNING.squish
-      `Rails.application.config.active_record.allow_deprecated_singular_associations_name`
-      is deprecated and will be removed in Rails 8.0.
-    WARNING
-  end
-
   singleton_class.attr_accessor :query_transformers
   self.query_transformers = []
 
@@ -490,6 +476,29 @@ module ActiveRecord
   singleton_class.attr_accessor :generate_secure_token_on
   self.generate_secure_token_on = :create
 
+  def self.deprecated_associations_options=(options)
+    raise ArgumentError, "deprecated_associations_options must be a hash" unless options.is_a?(Hash)
+
+    valid_keys = [:mode, :backtrace]
+
+    invalid_keys = options.keys - valid_keys
+    unless invalid_keys.empty?
+      inflected_key = invalid_keys.size == 1 ? "key" : "keys"
+      raise ArgumentError, "invalid deprecated_associations_options #{inflected_key} #{invalid_keys.map(&:inspect).to_sentence} (valid keys are #{valid_keys.map(&:inspect).to_sentence})"
+    end
+
+    options.each do |key, value|
+      ActiveRecord::Associations::Deprecation.send("#{key}=", value)
+    end
+  end
+
+  def self.deprecated_associations_options
+    {
+      mode: ActiveRecord::Associations::Deprecation.mode,
+      backtrace: ActiveRecord::Associations::Deprecation.backtrace
+    }
+  end
+
   def self.marshalling_format_version
     Marshalling.format_version
   end
@@ -526,6 +535,13 @@ module ActiveRecord
     }
   )
 
+  ##
+  # :singleton-method: message_verifiers
+  #
+  # ActiveSupport::MessageVerifiers instance for Active Record. If you are using
+  # Rails, this will be set to +Rails.application.message_verifiers+.
+  singleton_class.attr_accessor :message_verifiers
+
   def self.eager_load!
     super
     ActiveRecord::Locking.eager_load!
@@ -578,13 +594,32 @@ module ActiveRecord
     open_transactions = []
     Base.connection_handler.each_connection_pool do |pool|
       if active_connection = pool.active_connection
-        if active_connection.current_transaction.open? && active_connection.current_transaction.joinable?
-          open_transactions << active_connection.current_transaction
+        current_transaction = active_connection.current_transaction
+
+        if current_transaction.open? && current_transaction.joinable?
+          open_transactions << current_transaction
         end
       end
     end
     open_transactions
   end
+
+  def self.default_transaction_isolation_level=(isolation_level) # :nodoc:
+    ActiveSupport::IsolatedExecutionState[:active_record_transaction_isolation] = isolation_level
+  end
+
+  def self.default_transaction_isolation_level # :nodoc:
+    ActiveSupport::IsolatedExecutionState[:active_record_transaction_isolation]
+  end
+
+  # Sets a transaction isolation level for all connection pools within the block.
+  def self.with_transaction_isolation_level(isolation_level, &block)
+    original_level = self.default_transaction_isolation_level
+    self.default_transaction_isolation_level = isolation_level
+    yield
+  ensure
+    self.default_transaction_isolation_level = original_level
+  end
 end
 
 ActiveSupport.on_load(:active_record) do

data/lib/arel/alias_predication.rb

@@ -3,6 +3,8 @@
 module Arel # :nodoc: all
   module AliasPredication
     def as(other)
+      other = other.name if other.is_a?(Symbol)
+
       Nodes::As.new self, Nodes::SqlLiteral.new(other, retryable: true)
     end
   end

data/lib/arel/collectors/bind.rb

@@ -13,12 +13,12 @@ module Arel # :nodoc: all
         self
       end
 
-      def add_bind(bind)
+      def add_bind(bind, &)
         @binds << bind
         self
       end
 
-      def add_binds(binds, proc_for_binds = nil)
+      def add_binds(binds, proc_for_binds = nil, &)
         @binds.concat proc_for_binds ? binds.map(&proc_for_binds) : binds
         self
       end

data/lib/arel/collectors/sql_string.rb

@@ -12,7 +12,7 @@ module Arel # :nodoc: all
         @bind_index = 1
       end
 
-      def add_bind(bind)
+      def add_bind(bind, &)
         self << yield(@bind_index)
         @bind_index += 1
         self

data/lib/arel/collectors/substitute_binds.rb

@@ -15,12 +15,12 @@ module Arel # :nodoc: all
         self
       end
 
-      def add_bind(bind)
+      def add_bind(bind, &)
         bind = bind.value_for_database if bind.respond_to?(:value_for_database)
         self << quoter.quote(bind)
       end
 
-      def add_binds(binds, proc_for_binds = nil)
+      def add_binds(binds, proc_for_binds = nil, &)
         self << binds.map { |bind| quoter.quote(bind) }.join(", ")
       end
 

data/lib/arel/crud.rb

@@ -14,34 +14,31 @@ module Arel # :nodoc: all
       InsertManager.new
     end
 
-    def compile_update(
-      values,
-      key = nil,
-      having_clause = nil,
-      group_values_columns = []
-    )
+    def compile_update(values, key = nil)
       um = UpdateManager.new(source)
       um.set(values)
       um.take(limit)
       um.offset(offset)
       um.order(*orders)
       um.wheres = constraints
+      um.comment(comment)
       um.key = key
 
-      um.group(group_values_columns) unless group_values_columns.empty?
-      um.having(having_clause) unless having_clause.nil?
+      um.ast.groups = @ctx.groups
+      @ctx.havings.each { |h| um.having(h) }
       um
     end
 
-    def compile_delete(key = nil, having_clause = nil, group_values_columns = [])
+    def compile_delete(key = nil)
       dm = DeleteManager.new(source)
       dm.take(limit)
       dm.offset(offset)
       dm.order(*orders)
       dm.wheres = constraints
+      dm.comment(comment)
       dm.key = key
-      dm.group(group_values_columns) unless group_values_columns.empty?
-      dm.having(having_clause) unless having_clause.nil?
+      dm.ast.groups = @ctx.groups
+      @ctx.havings.each { |h| dm.having(h) }
       dm
     end
   end