activerecord 6.1.7.6 → 7.0.8

data/lib/active_record.rb

@@ -38,25 +38,27 @@ module ActiveRecord
 
   autoload :Base
   autoload :Callbacks
-  autoload :Core
   autoload :ConnectionHandling
+  autoload :Core
   autoload :CounterCache
-  autoload :DynamicMatchers
   autoload :DelegatedType
+  autoload :DestroyAssociationAsyncJob
+  autoload :DynamicMatchers
+  autoload :Encryption
   autoload :Enum
-  autoload :InternalMetadata
   autoload :Explain
   autoload :Inheritance
   autoload :Integration
+  autoload :InternalMetadata
   autoload :Migration
   autoload :Migrator, "active_record/migration"
   autoload :ModelSchema
   autoload :NestedAttributes
   autoload :NoTouching
-  autoload :TouchLater
   autoload :Persistence
   autoload :QueryCache
   autoload :Querying
+  autoload :QueryLogs
   autoload :ReadonlyAttributes
   autoload :RecordInvalid, "active_record/validations"
   autoload :Reflection
@@ -66,32 +68,37 @@ module ActiveRecord
   autoload :SchemaDumper
   autoload :SchemaMigration
   autoload :Scoping
+  autoload :SecureToken
   autoload :Serialization
-  autoload :StatementCache
-  autoload :Store
   autoload :SignedId
+  autoload :Store
   autoload :Suppressor
+  autoload :TestDatabases
+  autoload :TestFixtures, "active_record/fixtures"
   autoload :Timestamp
+  autoload :TouchLater
   autoload :Transactions
   autoload :Translation
   autoload :Validations
-  autoload :SecureToken
-  autoload :DestroyAssociationAsyncJob
 
   eager_autoload do
-    autoload :ConnectionAdapters
-
     autoload :Aggregations
+    autoload :AssociationRelation
     autoload :Associations
+    autoload :AsynchronousQueriesTracker
     autoload :AttributeAssignment
     autoload :AttributeMethods
     autoload :AutosaveAssociation
-
+    autoload :ConnectionAdapters
+    autoload :DisableJoinsAssociationRelation
+    autoload :FutureResult
     autoload :LegacyYamlAdapter
-
-    autoload :Relation
-    autoload :AssociationRelation
     autoload :NullRelation
+    autoload :Relation
+    autoload :Result
+    autoload :StatementCache
+    autoload :TableMetadata
+    autoload :Type
 
     autoload_under "relation" do
       autoload :QueryMethods
@@ -102,15 +109,11 @@ module ActiveRecord
       autoload :Batches
       autoload :Delegation
     end
-
-    autoload :Result
-    autoload :TableMetadata
-    autoload :Type
   end
 
   module Coders
-    autoload :YAMLColumn, "active_record/coders/yaml_column"
     autoload :JSON, "active_record/coders/json"
+    autoload :YAMLColumn, "active_record/coders/yaml_column"
   end
 
   module AttributeMethods
@@ -122,9 +125,9 @@ module ActiveRecord
       autoload :PrimaryKey
       autoload :Query
       autoload :Read
+      autoload :Serialization
       autoload :TimeZoneConversion
       autoload :Write
-      autoload :Serialization
     end
   end
 
@@ -141,29 +144,223 @@ module ActiveRecord
     extend ActiveSupport::Autoload
 
     eager_autoload do
-      autoload :Named
       autoload :Default
+      autoload :Named
     end
   end
 
   module Middleware
     extend ActiveSupport::Autoload
 
-    autoload :DatabaseSelector, "active_record/middleware/database_selector"
+    autoload :DatabaseSelector
+    autoload :ShardSelector
   end
 
   module Tasks
     extend ActiveSupport::Autoload
 
     autoload :DatabaseTasks
-    autoload :SQLiteDatabaseTasks, "active_record/tasks/sqlite_database_tasks"
     autoload :MySQLDatabaseTasks,  "active_record/tasks/mysql_database_tasks"
-    autoload :PostgreSQLDatabaseTasks,
-      "active_record/tasks/postgresql_database_tasks"
+    autoload :PostgreSQLDatabaseTasks, "active_record/tasks/postgresql_database_tasks"
+    autoload :SQLiteDatabaseTasks, "active_record/tasks/sqlite_database_tasks"
   end
 
-  autoload :TestDatabases, "active_record/test_databases"
-  autoload :TestFixtures, "active_record/fixtures"
+  # Lazily load the schema cache. This option will load the schema cache
+  # when a connection is established rather than on boot. If set,
+  # +config.active_record.use_schema_cache_dump+ will be set to false.
+  singleton_class.attr_accessor :lazily_load_schema_cache
+  self.lazily_load_schema_cache = false
+
+  # A list of tables or regex's to match tables to ignore when
+  # dumping the schema cache. For example if this is set to +[/^_/]+
+  # the schema cache will not dump tables named with an underscore.
+  singleton_class.attr_accessor :schema_cache_ignored_tables
+  self.schema_cache_ignored_tables = []
+
+  singleton_class.attr_accessor :legacy_connection_handling
+  self.legacy_connection_handling = true
+
+  singleton_class.attr_reader :default_timezone
+
+  # 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.
+  def self.default_timezone=(default_timezone)
+    unless %i(local utc).include?(default_timezone)
+      raise ArgumentError, "default_timezone must be either :utc (default) or :local."
+    end
+
+    @default_timezone = default_timezone
+  end
+
+  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_class.attr_accessor :index_nested_attribute_errors
+  self.index_nested_attribute_errors = false
+
+  ##
+  # :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
+
+  ##
+  # :singleton-method:
+  # If true, Rails will verify all foreign keys in the database after loading fixtures.
+  # An error will be raised if there are any foreign key violations, indicating incorrectly
+  # written fixtures.
+  # Supported by PostgreSQL and SQLite.
+  singleton_class.attr_accessor :verify_foreign_keys_for_fixtures
+  self.verify_foreign_keys_for_fixtures = false
+
+  singleton_class.attr_accessor :query_transformers
+  self.query_transformers = []
+
+  ##
+  # :singleton-method:
+  # Application configurable boolean that instructs the YAML Coder to use
+  # an unsafe load if set to true.
+  singleton_class.attr_accessor :use_yaml_unsafe_load
+  self.use_yaml_unsafe_load = false
+
+  ##
+  # :singleton-method:
+  # Application configurable boolean that denotes whether or not to raise
+  # an exception when the PostgreSQLAdapter is provided with an integer that
+  # is wider than signed 64bit representation
+  singleton_class.attr_accessor :raise_int_wider_than_64bit
+  self.raise_int_wider_than_64bit = true
+
+  ##
+  # :singleton-method:
+  # Application configurable array that provides additional permitted classes
+  # to Psych safe_load in the YAML Coder
+  singleton_class.attr_accessor :yaml_column_permitted_classes
+  self.yaml_column_permitted_classes = [Symbol]
 
   def self.eager_load!
     super
@@ -172,6 +369,7 @@ module ActiveRecord
     ActiveRecord::Associations.eager_load!
     ActiveRecord::AttributeMethods.eager_load!
     ActiveRecord::ConnectionAdapters.eager_load!
+    ActiveRecord::Encryption.eager_load!
   end
 end
 

data/lib/arel/attributes/attribute.rb

@@ -27,14 +27,6 @@ module Arel # :nodoc: all
         relation.able_to_type_cast?
       end
     end
-
-    class String    < Attribute; end
-    class Time      < Attribute; end
-    class Boolean   < Attribute; end
-    class Decimal   < Attribute; end
-    class Float     < Attribute; end
-    class Integer   < Attribute; end
-    class Undefined < Attribute; end
   end
 
   Attribute = Attributes::Attribute

data/lib/arel/crud.rb

@@ -4,23 +4,6 @@ module Arel # :nodoc: all
   ###
   # FIXME hopefully we can remove this
   module Crud
-    def compile_update(values, pk)
-      um = UpdateManager.new
-
-      if Nodes::SqlLiteral === values
-        relation = @ctx.from
-      else
-        relation = values.first.first.relation
-      end
-      um.key = pk
-      um.table relation
-      um.set values
-      um.take @ast.limit.expr if @ast.limit
-      um.order(*@ast.orders)
-      um.wheres = @ctx.wheres
-      um
-    end
-
     def compile_insert(values)
       im = create_insert
       im.insert values
@@ -31,11 +14,34 @@ module Arel # :nodoc: all
       InsertManager.new
     end
 
-    def compile_delete
-      dm = DeleteManager.new
-      dm.take @ast.limit.expr if @ast.limit
-      dm.wheres = @ctx.wheres
-      dm.from @ctx.froms
+    def compile_update(
+      values,
+      key = nil,
+      having_clause = nil,
+      group_values_columns = []
+    )
+      um = UpdateManager.new(source)
+      um.set(values)
+      um.take(limit)
+      um.offset(offset)
+      um.order(*orders)
+      um.wheres = constraints
+      um.key = key
+
+      um.group(group_values_columns) unless group_values_columns.empty?
+      um.having(having_clause) unless having_clause.nil?
+      um
+    end
+
+    def compile_delete(key = nil, having_clause = nil, group_values_columns = [])
+      dm = DeleteManager.new(source)
+      dm.take(limit)
+      dm.offset(offset)
+      dm.order(*orders)
+      dm.wheres = constraints
+      dm.key = key
+      dm.group(group_values_columns) unless group_values_columns.empty?
+      dm.having(having_clause) unless having_clause.nil?
       dm
     end
   end

data/lib/arel/delete_manager.rb

@@ -4,15 +4,29 @@ module Arel # :nodoc: all
   class DeleteManager < Arel::TreeManager
     include TreeManager::StatementMethods
 
-    def initialize
-      super
-      @ast = Nodes::DeleteStatement.new
-      @ctx = @ast
+    def initialize(table = nil)
+      @ast = Nodes::DeleteStatement.new(table)
     end
 
     def from(relation)
       @ast.relation = relation
       self
     end
+
+    def group(columns)
+      columns.each do |column|
+        column = Nodes::SqlLiteral.new(column) if String === column
+        column = Nodes::SqlLiteral.new(column.to_s) if Symbol === column
+
+        @ast.groups.push Nodes::Group.new column
+      end
+
+      self
+    end
+
+    def having(expr)
+      @ast.havings << expr
+      self
+    end
   end
 end

data/lib/arel/filter_predications.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module FilterPredications
+    def filter(expr)
+      Nodes::Filter.new(self, expr)
+    end
+  end
+end

data/lib/arel/insert_manager.rb

@@ -2,9 +2,8 @@
 
 module Arel # :nodoc: all
   class InsertManager < Arel::TreeManager
-    def initialize
-      super
-      @ast = Nodes::InsertStatement.new
+    def initialize(table = nil)
+      @ast = Nodes::InsertStatement.new(table)
     end
 
     def into(table)

data/lib/arel/nodes/and.rb

@@ -18,6 +18,10 @@ module Arel # :nodoc: all
         children[1]
       end
 
+      def fetch_attribute(&block)
+        children.any? && children.all? { |child| child.fetch_attribute(&block) }
+      end
+
       def hash
         children.hash
       end

data/lib/arel/nodes/casted.rb

@@ -47,7 +47,7 @@ module Arel # :nodoc: all
 
     def self.build_quoted(other, attribute = nil)
       case other
-      when Arel::Nodes::Node, Arel::Attributes::Attribute, Arel::Table, Arel::Nodes::BindParam, Arel::SelectManager, Arel::Nodes::Quoted, Arel::Nodes::SqlLiteral
+      when Arel::Nodes::Node, Arel::Attributes::Attribute, Arel::Table, Arel::SelectManager, Arel::Nodes::SqlLiteral, ActiveModel::Attribute
         other
       else
         case attribute

data/lib/arel/nodes/delete_statement.rb

@@ -3,17 +3,14 @@
 module Arel # :nodoc: all
   module Nodes
     class DeleteStatement < Arel::Nodes::Node
-      attr_accessor :left, :right, :orders, :limit, :offset, :key
-
-      alias :relation :left
-      alias :relation= :left=
-      alias :wheres :right
-      alias :wheres= :right=
+      attr_accessor :relation, :wheres, :groups, :havings, :orders, :limit, :offset, :key
 
       def initialize(relation = nil, wheres = [])
         super()
-        @left = relation
-        @right = wheres
+        @relation = relation
+        @wheres = wheres
+        @groups = []
+        @havings = []
         @orders = []
         @limit = nil
         @offset = nil
@@ -22,19 +19,21 @@ module Arel # :nodoc: all
 
       def initialize_copy(other)
         super
-        @left  = @left.clone if @left
-        @right = @right.clone if @right
+        @relation = @relation.clone if @relation
+        @wheres = @wheres.clone if @wheres
       end
 
       def hash
-        [self.class, @left, @right, @orders, @limit, @offset, @key].hash
+        [self.class, @relation, @wheres, @orders, @limit, @offset, @key].hash
       end
 
       def eql?(other)
         self.class == other.class &&
-          self.left == other.left &&
-          self.right == other.right &&
+          self.relation == other.relation &&
+          self.wheres == other.wheres &&
           self.orders == other.orders &&
+          self.groups == other.groups &&
+          self.havings == other.havings &&
           self.limit == other.limit &&
           self.offset == other.offset &&
           self.key == other.key

data/lib/arel/nodes/filter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Filter < Binary
+      include Arel::WindowPredications
+      include Arel::AliasPredication
+    end
+  end
+end

data/lib/arel/nodes/function.rb

@@ -4,6 +4,7 @@ module Arel # :nodoc: all
   module Nodes
     class Function < Arel::Nodes::NodeExpression
       include Arel::WindowPredications
+      include Arel::FilterPredications
       attr_accessor :expressions, :alias, :distinct
 
       def initialize(expr, aliaz = nil)

data/lib/arel/nodes/insert_statement.rb

@@ -5,9 +5,9 @@ module Arel # :nodoc: all
     class InsertStatement < Arel::Nodes::Node
       attr_accessor :relation, :columns, :values, :select
 
-      def initialize
+      def initialize(relation = nil)
         super()
-        @relation = nil
+        @relation = relation
         @columns  = []
         @values   = nil
         @select   = nil

data/lib/arel/nodes/select_core.rb

@@ -6,9 +6,9 @@ module Arel # :nodoc: all
       attr_accessor :projections, :wheres, :groups, :windows, :comment
       attr_accessor :havings, :source, :set_quantifier, :optimizer_hints
 
-      def initialize
+      def initialize(relation = nil)
         super()
-        @source = JoinSource.new nil
+        @source = JoinSource.new(relation)
 
         # https://ronsavage.github.io/SQL/sql-92.bnf.html#set%20quantifier
         @set_quantifier  = nil

data/lib/arel/nodes/select_statement.rb

@@ -6,9 +6,9 @@ module Arel # :nodoc: all
       attr_reader :cores
       attr_accessor :limit, :orders, :lock, :offset, :with
 
-      def initialize(cores = [SelectCore.new])
+      def initialize(relation = nil)
         super()
-        @cores          = cores
+        @cores          = [SelectCore.new(relation)]
         @orders         = []
         @limit          = nil
         @lock           = nil

data/lib/arel/nodes/update_statement.rb

@@ -3,12 +3,15 @@
 module Arel # :nodoc: all
   module Nodes
     class UpdateStatement < Arel::Nodes::Node
-      attr_accessor :relation, :wheres, :values, :orders, :limit, :offset, :key
+      attr_accessor :relation, :wheres, :values, :groups, :havings, :orders, :limit, :offset, :key
 
-      def initialize
-        @relation = nil
+      def initialize(relation = nil)
+        super()
+        @relation = relation
         @wheres   = []
         @values   = []
+        @groups   = []
+        @havings  = []
         @orders   = []
         @limit    = nil
         @offset   = nil
@@ -30,6 +33,8 @@ module Arel # :nodoc: all
           self.relation == other.relation &&
           self.wheres == other.wheres &&
           self.values == other.values &&
+          self.groups == other.groups &&
+          self.havings == other.havings &&
           self.orders == other.orders &&
           self.limit == other.limit &&
           self.offset == other.offset &&

data/lib/arel/nodes.rb

@@ -28,6 +28,7 @@ require "arel/nodes/with"
 # binary
 require "arel/nodes/binary"
 require "arel/nodes/equality"
+require "arel/nodes/filter"
 require "arel/nodes/in"
 require "arel/nodes/join_source"
 require "arel/nodes/delete_statement"

data/lib/arel/predications.rb

@@ -39,7 +39,11 @@ module Arel # :nodoc: all
         self.in([])
       elsif open_ended?(other.begin)
         if open_ended?(other.end)
-          not_in([])
+          if infinity?(other.begin) == 1 || infinity?(other.end) == -1
+            self.in([])
+          else
+            not_in([])
+          end
         elsif other.exclude_end?
           lt(other.end)
         else
@@ -52,7 +56,7 @@ module Arel # :nodoc: all
       else
         left = quoted_node(other.begin)
         right = quoted_node(other.end)
-        Nodes::Between.new(self, left.and(right))
+        Nodes::Between.new(self, Nodes::And.new([left, right]))
       end
     end
 
@@ -80,7 +84,11 @@ module Arel # :nodoc: all
         not_in([])
       elsif open_ended?(other.begin)
         if open_ended?(other.end)
-          self.in([])
+          if infinity?(other.begin) == 1 || infinity?(other.end) == -1
+            not_in([])
+          else
+            self.in([])
+          end
         elsif other.exclude_end?
           gteq(other.end)
         else