Merge pull request rails#42445 from Shopify/active-record-cattr-2

Get rid of `mattr_accessor` in `ActiveRecord::Core`

Author: byroot

activerecord/lib/active_record.rb

@@ -172,6 +172,144 @@ module Tasks
   singleton_class.attr_accessor :legacy_connection_handling
   self.legacy_connection_handling = true
 
+  ##
+  # :singleton-method:
+  # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
+  # dates and times from the database. This is set to :utc by default.
+  singleton_class.attr_accessor :default_timezone
+  self.default_timezone = :utc
+
+  singleton_class.attr_accessor :writing_role
+  self.writing_role = :writing
+
+  singleton_class.attr_accessor :reading_role
+  self.reading_role = :reading
+
+  # Sets the async_query_executor for an application. By default the thread pool executor
+  # set to +nil+ which will not run queries in the background. Applications must configure
+  # a thread pool executor to use this feature. Options are:
+  #
+  #   * nil - Does not initialize a thread pool executor. Any async calls will be
+  #   run in the foreground.
+  #   * :global_thread_pool - Initializes a single +Concurrent::ThreadPoolExecutor+
+  #   that uses the +async_query_concurrency+ for the +max_threads+ value.
+  #   * :multi_thread_pool - Initializes a +Concurrent::ThreadPoolExecutor+ for each
+  #   database connection. The initializer values are defined in the configuration hash.
+  singleton_class.attr_accessor :async_query_executor
+  self.async_query_executor = nil
+
+  def self.global_thread_pool_async_query_executor # :nodoc:
+    concurrency = global_executor_concurrency || 4
+    @global_thread_pool_async_query_executor ||= Concurrent::ThreadPoolExecutor.new(
+      min_threads: 0,
+      max_threads: concurrency,
+      max_queue: concurrency * 4,
+      fallback_policy: :caller_runs
+    )
+  end
+
+  # Set the +global_executor_concurrency+. This configuration value can only be used
+  # with the global thread pool async query executor.
+  def self.global_executor_concurrency=(global_executor_concurrency)
+    if self.async_query_executor.nil? || self.async_query_executor == :multi_thread_pool
+      raise ArgumentError, "`global_executor_concurrency` cannot be set when using the executor is nil or set to multi_thead_pool. For multiple thread pools, please set the concurrency in your database configuration."
+    end
+
+    @global_executor_concurrency = global_executor_concurrency
+  end
+
+  def self.global_executor_concurrency # :nodoc:
+    @global_executor_concurrency ||= nil
+  end
+
+  ##
+  # :singleton-method:
+  #
+  # Specifies if the methods calling database queries should be logged below
+  # their relevant queries. Defaults to false.
+  singleton_class.attr_accessor :verbose_query_logs
+  self.verbose_query_logs = false
+
+  ##
+  # :singleton-method:
+  #
+  # Specifies the names of the queues used by background jobs.
+  singleton_class.attr_accessor :queues
+  self.queues = {}
+
+  singleton_class.attr_accessor :maintain_test_schema
+  self.maintain_test_schema = nil
+
+  ##
+  # :singleton-method:
+  # 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 :application_record_class
+  self.application_record_class = nil
+
+  ##
+  # :singleton-method:
+  # Set the application to log or raise when an association violates strict loading.
+  # Defaults to :raise.
+  singleton_class.attr_accessor :action_on_strict_loading_violation
+  self.action_on_strict_loading_violation = :raise
+
+  ##
+  # :singleton-method:
+  # Specifies the format to use when dumping the database schema with Rails'
+  # Rakefile. If :sql, the schema is dumped as (potentially database-
+  # 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.
+  singleton_class.attr_accessor :schema_format
+  self.schema_format = :ruby
+
+  ##
+  # :singleton-method:
+  # Specifies if an error should be raised if the query has an order being
+  # ignored when doing batch queries. Useful in applications where the
+  # scope being ignored is error-worthy, rather than a warning.
+  singleton_class.attr_accessor :error_on_ignored_order
+  self.error_on_ignored_order = false
+
+  ##
+  # :singleton-method:
+  # Specify whether or not to use timestamps for migration versions
+  singleton_class.attr_accessor :timestamped_migrations
+  self.timestamped_migrations = true
+
+  ##
+  # :singleton-method:
+  # Specify whether schema dump should happen at the end of the
+  # bin/rails db:migrate command. This is true by default, which is useful for the
+  # development environment. This should ideally be false in the production
+  # environment where dumping schema is rarely needed.
+  singleton_class.attr_accessor :dump_schema_after_migration
+  self.dump_schema_after_migration = true
+
+  ##
+  # :singleton-method:
+  # Specifies which database schemas to dump when calling db:schema:dump.
+  # If the value is :schema_search_path (the default), any schemas listed in
+  # schema_search_path are dumped. Use :all to dump all schemas regardless
+  # of schema_search_path, or a string of comma separated schemas for a
+  # custom list.
+  singleton_class.attr_accessor :dump_schemas
+  self.dump_schemas = :schema_search_path
+
+  ##
+  # :singleton-method:
+  # Show a warning when Rails couldn't parse your database.yml
+  # for multiple databases.
+  singleton_class.attr_accessor :suppress_multiple_database_warning
+  self.suppress_multiple_database_warning = false
+
   def self.eager_load!
     super
     ActiveRecord::Locking.eager_load!

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

@@ -460,7 +460,7 @@ def schedule_query(future_result) # :nodoc:
 
       private
         def build_async_executor
-          case Base.async_query_executor
+          case ActiveRecord.async_query_executor
           when :multi_thread_pool
             if @db_config.max_threads > 0
               Concurrent::ThreadPoolExecutor.new(
@@ -471,7 +471,7 @@ def build_async_executor
               )
             end
           when :global_thread_pool
-            Base.global_thread_pool_async_query_executor
+            ActiveRecord.global_thread_pool_async_query_executor
           end
         end
 

activerecord/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -113,7 +113,7 @@ def unquoted_false
       # if the value is a Time responding to usec.
       def quoted_date(value)
         if value.acts_like?(:time)
-          if ActiveRecord::Base.default_timezone == :utc
+          if ActiveRecord.default_timezone == :utc
             value = value.getutc if !value.utc?
           else
             value = value.getlocal

activerecord/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -443,7 +443,7 @@ def supports_concurrent_connections?
 
       def async_enabled? # :nodoc:
         supports_concurrent_connections? &&
-          !Base.async_query_executor.nil? && !pool.async_executor.nil?
+          !ActiveRecord.async_query_executor.nil? && !pool.async_executor.nil?
       end
 
       # This is meant to be implemented by the adapters that support extensions

activerecord/lib/active_record/connection_adapters/mysql/database_statements.rb

@@ -41,9 +41,9 @@ def explain(arel, binds = [])
         def execute(sql, name = nil, async: false)
           check_if_write_query(sql)
 
-          # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+          # make sure we carry over any changes to ActiveRecord.default_timezone that have been
           # made since we established the connection
-          @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+          @connection.query_options[:database_timezone] = ActiveRecord.default_timezone
 
           super
         end
@@ -152,9 +152,9 @@ def exec_stmt_and_free(sql, name, binds, cache_stmt: false, async: false)
             materialize_transactions
             mark_transaction_written_if_write(sql)
 
-            # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+            # make sure we carry over any changes to ActiveRecord.default_timezone that have been
             # made since we established the connection
-            @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+            @connection.query_options[:database_timezone] = ActiveRecord.default_timezone
 
             type_casted_binds = type_casted_binds(binds)
 

activerecord/lib/active_record/connection_adapters/mysql/quoting.rb

@@ -79,7 +79,7 @@ def _type_cast(value)
               # We need to check explicitly for ActiveSupport::TimeWithZone because
               # we need to transform it to Time objects but we don't want to
               # transform Time objects to themselves.
-              if ActiveRecord::Base.default_timezone == :utc
+              if ActiveRecord.default_timezone == :utc
                 value.getutc
               else
                 value.getlocal

activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -696,7 +696,7 @@ def exec_no_cache(sql, name, binds, async: false)
           materialize_transactions
           mark_transaction_written_if_write(sql)
 
-          # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+          # make sure we carry over any changes to ActiveRecord.default_timezone that have been
           # made since we established the connection
           update_typemap_for_default_timezone
 
@@ -810,7 +810,7 @@ def configure_connection
           # If using Active Record's time zone support configure the connection to return
           # TIMESTAMP WITH ZONE types in UTC.
           unless variables["timezone"]
-            if ActiveRecord::Base.default_timezone == :utc
+            if ActiveRecord.default_timezone == :utc
               variables["timezone"] = "UTC"
             elsif @local_tz
               variables["timezone"] = @local_tz

activerecord/lib/active_record/connection_handling.rb

@@ -184,7 +184,7 @@ def connected_to_many(*classes, role:, shard: nil, prevent_writes: false)
         raise NotImplementedError, "connected_to_many can only be called on ActiveRecord::Base."
       end
 
-      prevent_writes = true if role == reading_role
+      prevent_writes = true if role == ActiveRecord.reading_role
 
       connected_to_stack << { role: role, shard: shard, prevent_writes: prevent_writes, klasses: classes }
       yield
@@ -204,7 +204,7 @@ def connecting_to(role: default_role, shard: default_shard, prevent_writes: fals
         raise NotImplementedError, "`connecting_to` is not available with `legacy_connection_handling`."
       end
 
-      prevent_writes = true if role == reading_role
+      prevent_writes = true if role == ActiveRecord.reading_role
 
       self.connected_to_stack << { role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self] }
     end
@@ -240,7 +240,7 @@ def connected_to?(role:, shard: ActiveRecord::Base.default_shard)
 
     def lookup_connection_handler(handler_key) # :nodoc:
       if ActiveRecord.legacy_connection_handling
-        handler_key ||= ActiveRecord::Base.writing_role
+        handler_key ||= ActiveRecord.writing_role
         connection_handlers[handler_key] ||= ActiveRecord::ConnectionAdapters::ConnectionHandler.new
       else
         ActiveRecord::Base.connection_handler
@@ -356,7 +356,7 @@ def with_handler(handler_key, &blk)
       end
 
       def with_role_and_shard(role, shard, prevent_writes)
-        prevent_writes = true if role == reading_role
+        prevent_writes = true if role == ActiveRecord.reading_role
 
         if ActiveRecord.legacy_connection_handling
           with_handler(role.to_sym) do