activerecord 7.0.0.alpha2 → 7.0.0

data/lib/active_record/suppressor.rb

@@ -30,32 +30,28 @@ module ActiveRecord
   module Suppressor
     extend ActiveSupport::Concern
 
+    class << self
+      def registry # :nodoc:
+        ActiveSupport::IsolatedExecutionState[:active_record_suppresor_registry] ||= {}
+      end
+    end
+
     module ClassMethods
       def suppress(&block)
-        previous_state = SuppressorRegistry.suppressed[name]
-        SuppressorRegistry.suppressed[name] = true
+        previous_state = Suppressor.registry[name]
+        Suppressor.registry[name] = true
         yield
       ensure
-        SuppressorRegistry.suppressed[name] = previous_state
+        Suppressor.registry[name] = previous_state
       end
     end
 
     def save(**) # :nodoc:
-      SuppressorRegistry.suppressed[self.class.name] ? true : super
+      Suppressor.registry[self.class.name] ? true : super
     end
 
     def save!(**) # :nodoc:
-      SuppressorRegistry.suppressed[self.class.name] ? true : super
-    end
-  end
-
-  class SuppressorRegistry # :nodoc:
-    extend ActiveSupport::PerThreadRegistry
-
-    attr_reader :suppressed
-
-    def initialize
-      @suppressed = {}
+      Suppressor.registry[self.class.name] ? true : super
     end
   end
 end

data/lib/active_record/tasks/database_tasks.rb

@@ -55,8 +55,7 @@ module ActiveRecord
 
       extend self
 
-      attr_writer :current_config, :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
-      deprecate :current_config=
+      attr_writer :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
       attr_accessor :database_configuration
 
       LOCAL_HOSTS = ["127.0.0.1", "localhost"]
@@ -110,11 +109,6 @@ module ActiveRecord
         @env ||= Rails.env
       end
 
-      def spec
-        @spec ||= "primary"
-      end
-      deprecate spec: "please use name instead"
-
       def name
         @name ||= "primary"
       end
@@ -123,18 +117,6 @@ module ActiveRecord
         @seed_loader ||= Rails.application
       end
 
-      def current_config(options = {})
-        if options.has_key?(:config)
-          @current_config = options[:config]
-        else
-          env_name = options[:env] || env
-          name = options[:spec] || "primary"
-
-          @current_config ||= configs_for(env_name: env_name, name: name)&.configuration_hash
-        end
-      end
-      deprecate :current_config
-
       def create(configuration, *arguments)
         db_config = resolve_configuration(configuration)
         database_adapter_for(db_config, *arguments).create
@@ -216,10 +198,9 @@ module ActiveRecord
             dump_schema(db_config, ActiveRecord.schema_format)
           end
         rescue ActiveRecord::NoDatabaseError
-          config_name = db_config.name
-          create_current(db_config.env_name, config_name)
+          create_current(db_config.env_name, db_config.name)
 
-          if File.exist?(dump_filename(config_name))
+          if File.exist?(schema_dump_path(db_config))
             load_schema(
               db_config,
               ActiveRecord.schema_format,
@@ -378,7 +359,7 @@ module ActiveRecord
       end
 
       def load_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
-        file ||= dump_filename(db_config.name, format)
+        file ||= schema_dump_path(db_config, format)
 
         verbose_was, Migration.verbose = Migration.verbose, verbose? && ENV["VERBOSE"]
         check_schema_file(file)
@@ -399,16 +380,10 @@ module ActiveRecord
         Migration.verbose = verbose_was
       end
 
-      def schema_up_to_date?(configuration, format = ActiveRecord.schema_format, file = nil, environment = nil, name = nil)
+      def schema_up_to_date?(configuration, format = ActiveRecord.schema_format, file = nil)
         db_config = resolve_configuration(configuration)
 
-        if environment || name
-          ActiveSupport::Deprecation.warn("`environment` and `name` will be removed as parameters in 7.0.0, you may now pass an ActiveRecord::DatabaseConfigurations::DatabaseConfig as `configuration` instead.")
-        end
-
-        name ||= db_config.name
-
-        file ||= dump_filename(name, format)
+        file ||= schema_dump_path(db_config)
 
         return true unless File.exist?(file)
 
@@ -421,7 +396,7 @@ module ActiveRecord
       end
 
       def reconstruct_from_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
-        file ||= dump_filename(db_config.name, format)
+        file ||= schema_dump_path(db_config, format)
 
         check_schema_file(file)
 
@@ -440,7 +415,7 @@ module ActiveRecord
 
       def dump_schema(db_config, format = ActiveRecord.schema_format) # :nodoc:
         require "active_record/schema_dumper"
-        filename = dump_filename(db_config.name, format)
+        filename = schema_dump_path(db_config, format)
         connection = ActiveRecord::Base.connection
 
         FileUtils.mkdir_p(db_dir)
@@ -460,11 +435,6 @@ module ActiveRecord
         end
       end
 
-      def schema_file(format = ActiveRecord.schema_format)
-        File.join(db_dir, schema_file_type(format))
-      end
-      deprecate :schema_file
-
       def schema_file_type(format = ActiveRecord.schema_format)
         case format
         when :ruby
@@ -473,15 +443,19 @@ module ActiveRecord
           "structure.sql"
         end
       end
+      deprecate :schema_file_type
 
-      def dump_filename(db_config_name, format = ActiveRecord.schema_format)
-        filename = if ActiveRecord::Base.configurations.primary?(db_config_name)
-          schema_file_type(format)
+      def schema_dump_path(db_config, format = ActiveRecord.schema_format)
+        return ENV["SCHEMA"] if ENV["SCHEMA"]
+
+        filename = db_config.schema_dump(format)
+        return unless filename
+
+        if File.dirname(filename) == ActiveRecord::Tasks::DatabaseTasks.db_dir
+          filename
         else
-          "#{db_config_name}_#{schema_file_type(format)}"
+          File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
         end
-
-        ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
       end
 
       def cache_dump_filename(db_config_name, schema_cache_path: nil)

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -57,8 +57,12 @@ module ActiveRecord
             ActiveRecord.dump_schemas
           end
 
-        args = ["--schema-only", "--no-privileges", "--no-owner", "--file", filename]
+        args = ["--schema-only", "--no-privileges", "--no-owner"]
+        args << "--no-comment" if connection.database_version >= 110_000
+        args.concat(["--file", filename])
+
         args.concat(Array(extra_flags)) if extra_flags
+
         unless search_path.blank?
           args += search_path.split(",").map do |part|
             "--schema=#{part.strip}"

data/lib/active_record/validations/uniqueness.rb

@@ -161,7 +161,7 @@ module ActiveRecord
       #   <tt>WHERE</tt> SQL fragment to limit the uniqueness constraint lookup
       #   (e.g. <tt>conditions: -> { where(status: 'active') }</tt>).
       # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by
-      #   non-text columns (+true+ by default).
+      #   non-text columns. The default behavior respects the default database collation.
       # * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the
       #   attribute is +nil+ (default is +false+).
       # * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the

data/lib/active_record.rb

@@ -38,23 +38,23 @@ 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
@@ -68,34 +68,37 @@ module ActiveRecord
   autoload :SchemaDumper
   autoload :SchemaMigration
   autoload :Scoping
+  autoload :SecureToken
   autoload :Serialization
-  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 :StatementCache
-    autoload :ConnectionAdapters
-
     autoload :Aggregations
+    autoload :AssociationRelation
     autoload :Associations
+    autoload :AsynchronousQueriesTracker
     autoload :AttributeAssignment
     autoload :AttributeMethods
     autoload :AutosaveAssociation
-    autoload :AsynchronousQueriesTracker
-
-    autoload :LegacyYamlAdapter
-
-    autoload :Relation
-    autoload :AssociationRelation
+    autoload :ConnectionAdapters
     autoload :DisableJoinsAssociationRelation
+    autoload :FutureResult
+    autoload :LegacyYamlAdapter
     autoload :NullRelation
+    autoload :Relation
+    autoload :Result
+    autoload :StatementCache
+    autoload :TableMetadata
+    autoload :Type
 
     autoload_under "relation" do
       autoload :QueryMethods
@@ -106,16 +109,11 @@ module ActiveRecord
       autoload :Batches
       autoload :Delegation
     end
-
-    autoload :Result
-    autoload :FutureResult
-    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
@@ -127,9 +125,9 @@ module ActiveRecord
       autoload :PrimaryKey
       autoload :Query
       autoload :Read
+      autoload :Serialization
       autoload :TimeZoneConversion
       autoload :Write
-      autoload :Serialization
     end
   end
 
@@ -146,29 +144,32 @@ 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 +[/^_/]+
@@ -179,11 +180,18 @@ module ActiveRecord
   singleton_class.attr_accessor :legacy_connection_handling
   self.legacy_connection_handling = true
 
-  ##
-  # :singleton-method:
+  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.
-  singleton_class.attr_accessor :default_timezone
+  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

data/lib/arel/crud.rb

@@ -14,7 +14,12 @@ module Arel # :nodoc: all
       InsertManager.new
     end
 
-    def compile_update(values, key = nil)
+    def compile_update(
+      values,
+      key = nil,
+      having_clause = nil,
+      group_values_columns = []
+    )
       um = UpdateManager.new(source)
       um.set(values)
       um.take(limit)
@@ -22,16 +27,21 @@ module Arel # :nodoc: all
       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)
+    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

@@ -12,5 +12,21 @@ module Arel # :nodoc: all
       @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
+  module FilterPredications
+    def filter(expr)
+      Nodes::Filter.new(self, expr)
+    end
+  end
+end

data/lib/arel/nodes/delete_statement.rb

@@ -3,12 +3,14 @@
 module Arel # :nodoc: all
   module Nodes
     class DeleteStatement < Arel::Nodes::Node
-      attr_accessor :relation, :wheres, :orders, :limit, :offset, :key
+      attr_accessor :relation, :wheres, :groups, :havings, :orders, :limit, :offset, :key
 
       def initialize(relation = nil, wheres = [])
         super()
         @relation = relation
         @wheres = wheres
+        @groups = []
+        @havings = []
         @orders = []
         @limit = nil
         @offset = nil
@@ -30,6 +32,8 @@ module Arel # :nodoc: all
           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
+  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/update_statement.rb

@@ -3,13 +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)
         super()
         @relation = relation
         @wheres   = []
         @values   = []
+        @groups   = []
+        @havings  = []
         @orders   = []
         @limit    = nil
         @offset   = nil
@@ -31,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
@@ -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

data/lib/arel/update_manager.rb

@@ -28,5 +28,21 @@ module Arel # :nodoc: all
       end
       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/visitors/mysql.rb

@@ -67,7 +67,8 @@ module Arel # :nodoc: all
         # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
         # these, we must use a subquery.
         def prepare_update_statement(o)
-          if o.offset || has_join_sources?(o) && has_limit_or_offset_or_orders?(o)
+          if o.offset || has_group_by_and_having?(o) ||
+            has_join_sources?(o) && has_limit_or_offset_or_orders?(o)
             super
           else
             o

data/lib/arel/visitors/to_sql.rb

@@ -245,6 +245,13 @@ module Arel # :nodoc: all
           collector << ")"
         end
 
+        def visit_Arel_Nodes_Filter(o, collector)
+          visit o.left, collector
+          collector << " FILTER (WHERE "
+          visit o.right, collector
+          collector << ")"
+        end
+
         def visit_Arel_Nodes_Rows(o, collector)
           if o.expr
             collector << "ROWS "
@@ -834,6 +841,10 @@ module Arel # :nodoc: all
           o.limit || o.offset || !o.orders.empty?
         end
 
+        def has_group_by_and_having?(o)
+          !o.groups.empty? && !o.havings.empty?
+        end
+
         # The default strategy for an UPDATE with joins is to use a subquery. This doesn't work
         # on MySQL (even when aliasing the tables), but MySQL allows using JOIN directly in
         # an UPDATE statement, so in the MySQL visitor we redefine this to do that.
@@ -845,6 +856,8 @@ module Arel # :nodoc: all
             stmt.orders = []
             stmt.wheres = [Nodes::In.new(o.key, [build_subselect(o.key, o)])]
             stmt.relation = o.relation.left if has_join_sources?(o)
+            stmt.groups = o.groups unless o.groups.empty?
+            stmt.havings = o.havings unless o.havings.empty?
             stmt
           else
             o
@@ -859,6 +872,8 @@ module Arel # :nodoc: all
           core.froms       = o.relation
           core.wheres      = o.wheres
           core.projections = [key]
+          core.groups      = o.groups unless o.groups.empty?
+          core.havings     = o.havings unless o.havings.empty?
           stmt.limit       = o.limit
           stmt.offset      = o.offset
           stmt.orders      = o.orders

data/lib/arel.rb

@@ -7,6 +7,7 @@ require "arel/factory_methods"
 
 require "arel/expressions"
 require "arel/predications"
+require "arel/filter_predications"
 require "arel/window_predications"
 require "arel/math"
 require "arel/alias_predication"

data/lib/rails/generators/active_record/multi_db/multi_db_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module ActiveRecord
+  module Generators # :nodoc:
+    class MultiDbGenerator < ::Rails::Generators::Base # :nodoc:
+      source_root File.expand_path("templates", __dir__)
+
+      def create_multi_db
+        filename = "multi_db.rb"
+        template filename, "config/initializers/#{filename}"
+      end
+    end
+  end
+end