activerecord 8.0.2 → 8.1.0.beta1

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.rb

@@ -26,6 +26,7 @@
 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"
@@ -52,6 +53,7 @@ module ActiveRecord
   autoload :Enum
   autoload :Explain
   autoload :FixtureSet, "active_record/fixtures"
+  autoload :FilterAttributeHandler
   autoload :Inheritance
   autoload :Integration
   autoload :InternalMetadata
@@ -62,7 +64,6 @@ module ActiveRecord
   autoload :ModelSchema
   autoload :NestedAttributes
   autoload :NoTouching
-  autoload :Normalization
   autoload :Persistence
   autoload :QueryCache
   autoload :QueryLogs
@@ -87,7 +88,6 @@ module ActiveRecord
   autoload :Timestamp
   autoload :TokenFor
   autoload :TouchLater
-  autoload :Transaction
   autoload :Transactions
   autoload :Translation
   autoload :Validations
@@ -109,6 +109,7 @@ module ActiveRecord
     autoload :Result
     autoload :StatementCache
     autoload :TableMetadata
+    autoload :Transaction
     autoload :Type
 
     autoload_under "relation" do
@@ -174,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
@@ -259,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 = []
 
@@ -286,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,
@@ -351,6 +357,9 @@ module ActiveRecord
   singleton_class.attr_accessor :run_after_transaction_callbacks_in_order_defined
   self.run_after_transaction_callbacks_in_order_defined = 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
 
@@ -368,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
 
@@ -400,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
@@ -460,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
@@ -496,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!
@@ -550,13 +596,30 @@ module ActiveRecord
       if active_connection = pool.active_connection
         current_transaction = active_connection.current_transaction
 
-        if current_transaction.open? && current_transaction.joinable? && !current_transaction.state.invalidated?
+        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/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

data/lib/arel/delete_manager.rb

@@ -28,5 +28,10 @@ module Arel # :nodoc: all
       @ast.havings << expr
       self
     end
+
+    def comment(value)
+      @ast.comment = value
+      self
+    end
   end
 end

data/lib/arel/nodes/count.rb

@@ -3,8 +3,8 @@
 module Arel # :nodoc: all
   module Nodes
     class Count < Arel::Nodes::Function
-      def initialize(expr, distinct = false, aliaz = nil)
-        super(expr, aliaz)
+      def initialize(expr, distinct = false)
+        super(expr)
         @distinct = distinct
       end
     end

data/lib/arel/nodes/delete_statement.rb

@@ -3,7 +3,7 @@
 module Arel # :nodoc: all
   module Nodes
     class DeleteStatement < Arel::Nodes::Node
-      attr_accessor :relation, :wheres, :groups, :havings, :orders, :limit, :offset, :key
+      attr_accessor :relation, :wheres, :groups, :havings, :orders, :limit, :offset, :comment, :key
 
       def initialize(relation = nil, wheres = [])
         super()
@@ -14,6 +14,7 @@ module Arel # :nodoc: all
         @orders = []
         @limit = nil
         @offset = nil
+        @comment = nil
         @key = nil
       end
 
@@ -24,7 +25,7 @@ module Arel # :nodoc: all
       end
 
       def hash
-        [self.class, @relation, @wheres, @orders, @limit, @offset, @key].hash
+        [self.class, @relation, @wheres, @orders, @limit, @offset, @comment, @key].hash
       end
 
       def eql?(other)
@@ -36,6 +37,7 @@ module Arel # :nodoc: all
           self.havings == other.havings &&
           self.limit == other.limit &&
           self.offset == other.offset &&
+          self.comment == other.comment &&
           self.key == other.key
       end
       alias :== :eql?

data/lib/arel/nodes/function.rb

@@ -5,28 +5,22 @@ module Arel # :nodoc: all
     class Function < Arel::Nodes::NodeExpression
       include Arel::WindowPredications
       include Arel::FilterPredications
-      attr_accessor :expressions, :alias, :distinct
 
-      def initialize(expr, aliaz = nil)
+      attr_accessor :expressions, :distinct
+
+      def initialize(expr)
         super()
         @expressions = expr
-        @alias       = aliaz && SqlLiteral.new(aliaz)
         @distinct    = false
       end
 
-      def as(aliaz)
-        self.alias = SqlLiteral.new(aliaz)
-        self
-      end
-
       def hash
-        [@expressions, @alias, @distinct].hash
+        [@expressions, @distinct].hash
       end
 
       def eql?(other)
         self.class == other.class &&
           self.expressions == other.expressions &&
-          self.alias == other.alias &&
           self.distinct == other.distinct
       end
       alias :== :eql?

data/lib/arel/nodes/named_function.rb

@@ -5,8 +5,8 @@ module Arel # :nodoc: all
     class NamedFunction < Arel::Nodes::Function
       attr_accessor :name
 
-      def initialize(name, expr, aliaz = nil)
-        super(expr, aliaz)
+      def initialize(name, expr)
+        super(expr)
         @name = name
       end
 

data/lib/arel/nodes/node.rb

@@ -6,7 +6,7 @@ module Arel # :nodoc: all
     #
     # Active Record uses Arel to compose SQL statements. Instead of building SQL strings directly, it's building an
     # abstract syntax tree (AST) of the statement using various types of Arel::Nodes::Node. Each node represents a
-    # fragment of a SQL statement.
+    # fragment of an SQL statement.
     #
     # The intermediate representation allows Arel to compile the statement into the database's specific SQL dialect
     # only before sending it without having to care about the nuances of each database when building the statement.

data/lib/arel/nodes/update_statement.rb

@@ -3,7 +3,7 @@
 module Arel # :nodoc: all
   module Nodes
     class UpdateStatement < Arel::Nodes::Node
-      attr_accessor :relation, :wheres, :values, :groups, :havings, :orders, :limit, :offset, :key
+      attr_accessor :relation, :wheres, :values, :groups, :havings, :orders, :limit, :offset, :comment, :key
 
       def initialize(relation = nil)
         super()
@@ -15,6 +15,7 @@ module Arel # :nodoc: all
         @orders   = []
         @limit    = nil
         @offset   = nil
+        @comment  = nil
         @key      = nil
       end
 
@@ -25,7 +26,7 @@ module Arel # :nodoc: all
       end
 
       def hash
-        [@relation, @wheres, @values, @orders, @limit, @offset, @key].hash
+        [@relation, @wheres, @values, @orders, @limit, @offset, @comment, @key].hash
       end
 
       def eql?(other)
@@ -38,6 +39,7 @@ module Arel # :nodoc: all
           self.orders == other.orders &&
           self.limit == other.limit &&
           self.offset == other.offset &&
+          self.comment == other.comment &&
           self.key == other.key
       end
       alias :== :eql?

data/lib/arel/nodes.rb

@@ -45,8 +45,6 @@ require "arel/nodes/cte"
 require "arel/nodes/nary"
 
 # function
-# FIXME: Function + Alias can be rewritten as a Function and Alias node.
-# We should make Function a Unary node and deprecate the use of "aliaz"
 require "arel/nodes/function"
 require "arel/nodes/count"
 require "arel/nodes/extract"

data/lib/arel/select_manager.rb

@@ -74,8 +74,13 @@ module Arel # :nodoc: all
     def group(*columns)
       columns.each do |column|
         # FIXME: backwards compat
-        column = Nodes::SqlLiteral.new(column) if String === column
-        column = Nodes::SqlLiteral.new(column.to_s) if Symbol === column
+        case column
+        when Nodes::SqlLiteral
+        when String
+          column = Nodes::SqlLiteral.new(column)
+        when Symbol
+          column = Nodes::SqlLiteral.new(column.name)
+        end
 
         @ctx.groups.push Nodes::Group.new column
       end
@@ -250,8 +255,12 @@ module Arel # :nodoc: all
     end
 
     def comment(*values)
-      @ctx.comment = Nodes::Comment.new(values)
-      self
+      if values.any?
+        @ctx.comment = Nodes::Comment.new(values)
+        self
+      else
+        @ctx.comment
+      end
     end
 
     private

data/lib/arel/update_manager.rb

@@ -45,5 +45,10 @@ module Arel # :nodoc: all
       @ast.havings << expr
       self
     end
+
+    def comment(value)
+      @ast.comment = value
+      self
+    end
   end
 end

data/lib/arel/visitors/dot.rb

@@ -34,7 +34,6 @@ module Arel # :nodoc: all
         def visit_Arel_Nodes_Function(o)
           visit_edge o, "expressions"
           visit_edge o, "distinct"
-          visit_edge o, "alias"
         end
 
         def visit_Arel_Nodes_Unary(o)
@@ -108,14 +107,12 @@ module Arel # :nodoc: all
 
         def visit_Arel_Nodes_Extract(o)
           visit_edge o, "expressions"
-          visit_edge o, "alias"
         end
 
         def visit_Arel_Nodes_NamedFunction(o)
           visit_edge o, "name"
           visit_edge o, "expressions"
           visit_edge o, "distinct"
-          visit_edge o, "alias"
         end
 
         def visit_Arel_Nodes_InsertStatement(o)
@@ -153,6 +150,7 @@ module Arel # :nodoc: all
           visit_edge o, "orders"
           visit_edge o, "limit"
           visit_edge o, "offset"
+          visit_edge o, "comment"
           visit_edge o, "key"
         end
 
@@ -162,6 +160,7 @@ module Arel # :nodoc: all
           visit_edge o, "orders"
           visit_edge o, "limit"
           visit_edge o, "offset"
+          visit_edge o, "comment"
           visit_edge o, "key"
         end
 

data/lib/arel/visitors/postgresql.rb

@@ -4,6 +4,55 @@ module Arel # :nodoc: all
   module Visitors
     class PostgreSQL < Arel::Visitors::ToSql
       private
+        def visit_Arel_Nodes_UpdateStatement(o, collector)
+          collector.retryable = false
+          o = prepare_update_statement(o)
+
+          collector << "UPDATE "
+
+          # UPDATE with JOIN is in the form of:
+          #
+          #   UPDATE t1 AS __active_record_update_alias
+          #   SET ..
+          #   FROM t1 JOIN t2 ON t2.join_id = t1.join_id ..
+          #   WHERE t1.id = __active_record_update_alias.id AND ..
+          if has_join_sources?(o)
+            collector = visit o.relation.left, collector
+            collect_nodes_for o.values, collector, " SET "
+            collector << " FROM "
+            collector = inject_join o.relation.right, collector, " "
+          else
+            collector = visit o.relation, collector
+            collect_nodes_for o.values, collector, " SET "
+          end
+
+          collect_nodes_for o.wheres, collector, " WHERE ", " AND "
+          collect_nodes_for o.orders, collector, " ORDER BY "
+          maybe_visit o.limit, collector
+          maybe_visit o.comment, collector
+        end
+
+        # In the simple case, PostgreSQL allows us to place FROM or JOINs directly into the UPDATE
+        # 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.key && has_join_sources?(o) && !has_group_by_and_having?(o) && !has_limit_or_offset_or_orders?(o)
+            # Join clauses cannot reference the target table, so alias the
+            # updated table, place the entire relation in the FROM clause, and
+            # add a self-join (which requires the primary key)
+            stmt = o.clone
+            stmt.relation, stmt.wheres = o.relation.clone, o.wheres.clone
+            stmt.relation.right = [stmt.relation.left, *stmt.relation.right]
+            stmt.relation.left = stmt.relation.left.alias("__active_record_update_alias")
+            Array.wrap(o.key).each do |key|
+              stmt.wheres << key.eq(stmt.relation.left[key.name])
+            end
+            stmt
+          else
+            super
+          end
+        end
+
         def visit_Arel_Nodes_Matches(o, collector)
           op = o.case_sensitive ? " LIKE " : " ILIKE "
           collector = infix_value o, collector, op
@@ -66,6 +115,12 @@ module Arel # :nodoc: all
           grouping_parentheses o.expr, collector
         end
 
+        def visit_Arel_Nodes_InnerJoin(o, collector)
+          return super if o.right
+          collector << "CROSS JOIN "
+          visit o.left, collector
+        end
+
         def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
           collector = visit o.left, collector
           collector << " IS NOT DISTINCT FROM "