activerecord 7.2.2.2 → 7.2.3

data/lib/active_record/querying.rb

@@ -46,8 +46,8 @@ module ActiveRecord
     #   Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date]
     #   Post.find_by_sql ["SELECT body FROM comments WHERE author = :user_id OR approved_by = :user_id", { :user_id => user_id }]
     #
-    # Note that building your own SQL query string from user input may expose your application to
-    # injection attacks (https://guides.rubyonrails.org/security.html#sql-injection).
+    # Note that building your own SQL query string from user input {may expose your application to
+    # injection attacks}[https://guides.rubyonrails.org/security.html#sql-injection].
     def find_by_sql(sql, binds = [], preparable: nil, allow_retry: false, &block)
       result = with_connection do |c|
         _query_by_sql(c, sql, binds, preparable: preparable, allow_retry: allow_retry)
@@ -55,7 +55,7 @@ module ActiveRecord
       _load_from_sql(result, &block)
     end
 
-    # Same as <tt>#find_by_sql</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
+    # Same as #find_by_sql but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_find_by_sql(sql, binds = [], preparable: nil, &block)
       result = with_connection do |c|
         _query_by_sql(c, sql, binds, preparable: preparable, async: true)
@@ -112,7 +112,7 @@ module ActiveRecord
       end
     end
 
-    # Same as <tt>#count_by_sql</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
+    # Same as #count_by_sql but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_count_by_sql(sql)
       with_connection do |c|
         c.select_value(sanitize_sql(sql), "#{name} Count", async: true).then(&:to_i)

data/lib/active_record/railtie.rb

@@ -23,8 +23,8 @@ module ActiveRecord
     config.action_dispatch.rescue_responses.merge!(
       "ActiveRecord::RecordNotFound"   => :not_found,
       "ActiveRecord::StaleObjectError" => :conflict,
-      "ActiveRecord::RecordInvalid"    => :unprocessable_entity,
-      "ActiveRecord::RecordNotSaved"   => :unprocessable_entity
+      "ActiveRecord::RecordInvalid"    => ActionDispatch::Constants::UNPROCESSABLE_CONTENT,
+      "ActiveRecord::RecordNotSaved"   => ActionDispatch::Constants::UNPROCESSABLE_CONTENT
     )
 
     config.active_record.use_schema_cache_dump = true

data/lib/active_record/railties/databases.rake

@@ -473,7 +473,8 @@ db_namespace = namespace :db do
 
     desc "Load a database schema file (either db/schema.rb or db/structure.sql, depending on `ENV['SCHEMA_FORMAT']` or `config.active_record.schema_format`) into the database"
     task load: [:load_config, :check_protected_environments] do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(ActiveRecord.schema_format, ENV["SCHEMA"])
+      schema_format = ENV.fetch("SCHEMA_FORMAT", ActiveRecord.schema_format).to_sym
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(schema_format, ENV["SCHEMA"])
     end
 
     namespace :dump do

data/lib/active_record/relation/calculations.rb

@@ -60,37 +60,37 @@ module ActiveRecord
     #   Person.distinct.count(:age)
     #   # => counts the number of different age values
     #
-    # If #count is used with {Relation#group}[rdoc-ref:QueryMethods#group],
+    # If +count+ is used with {Relation#group}[rdoc-ref:QueryMethods#group],
     # it returns a Hash whose keys represent the aggregated column,
     # and the values are the respective amounts:
     #
     #   Person.group(:city).count
     #   # => { 'Rome' => 5, 'Paris' => 3 }
     #
-    # If #count is used with {Relation#group}[rdoc-ref:QueryMethods#group] for multiple columns, it returns a Hash whose
+    # If +count+ is used with {Relation#group}[rdoc-ref:QueryMethods#group] for multiple columns, it returns a Hash whose
     # keys are an array containing the individual values of each column and the value
-    # of each key would be the #count.
+    # of each key would be the count.
     #
     #   Article.group(:status, :category).count
     #   # =>  {["draft", "business"]=>10, ["draft", "technology"]=>4, ["published", "technology"]=>2}
     #
-    # If #count is used with {Relation#select}[rdoc-ref:QueryMethods#select], it will count the selected columns:
+    # If +count+ is used with {Relation#select}[rdoc-ref:QueryMethods#select], it will count the selected columns:
     #
     #   Person.select(:age).count
     #   # => counts the number of different age values
     #
-    # Note: not all valid {Relation#select}[rdoc-ref:QueryMethods#select] expressions are valid #count expressions. The specifics differ
+    # Note: not all valid {Relation#select}[rdoc-ref:QueryMethods#select] expressions are valid +count+ expressions. The specifics differ
     # between databases. In invalid cases, an error from the database is thrown.
     #
-    # When given a block, loads all records in the relation, if the relation
-    # hasn't been loaded yet. Calls the block with each record in the relation.
-    # Returns the number of records for which the block returns a truthy value.
+    # When given a block, calls the block with each record in the relation and
+    # returns the number of records for which the block returns a truthy value.
     #
     #   Person.count { |person| person.age > 21 }
     #   # => counts the number of people older that 21
     #
-    # Note: If there are a lot of records in the relation, loading all records
-    # could result in performance issues.
+    # If the relation hasn't been loaded yet, calling +count+ with a block will
+    # load all records in the relation. If there are a lot of records in the
+    # relation, loading all records could result in performance issues.
     def count(column_name = nil)
       if block_given?
         unless column_name.nil?
@@ -159,16 +159,15 @@ module ActiveRecord
     #
     #   Person.sum(:age) # => 4562
     #
-    # When given a block, loads all records in the relation, if the relation
-    # hasn't been loaded yet. Calls the block with each record in the relation.
-    # Returns the sum of +initial_value_or_column+ and the block return
-    # values:
+    # When given a block, calls the block with each record in the relation and
+    # returns the sum of +initial_value_or_column+ plus the block return values:
     #
     #   Person.sum { |person| person.age } # => 4562
     #   Person.sum(1000) { |person| person.age } # => 5562
     #
-    # Note: If there are a lot of records in the relation, loading all records
-    # could result in performance issues.
+    # If the relation hasn't been loaded yet, calling +sum+ with a block will
+    # load all records in the relation. If there are a lot of records in the
+    # relation, loading all records could result in performance issues.
     def sum(initial_value_or_column = 0, &block)
       if block_given?
         map(&block).sum(initial_value_or_column)
@@ -406,6 +405,15 @@ module ActiveRecord
       async.ids
     end
 
+    protected
+      def aggregate_column(column_name)
+        return column_name if Arel::Expressions === column_name
+
+        arel_column(column_name.to_s) do |name|
+          column_name == :all ? Arel.sql("*", retryable: true) : Arel.sql(name)
+        end
+      end
+
     private
       def all_attributes?(column_names)
         (column_names.map(&:to_s) - @klass.attribute_names - @klass.attribute_aliases.keys).empty?
@@ -446,14 +454,6 @@ module ActiveRecord
         column_name.is_a?(::String) && /\bDISTINCT[\s(]/i.match?(column_name)
       end
 
-      def aggregate_column(column_name)
-        return column_name if Arel::Expressions === column_name
-
-        arel_column(column_name.to_s) do |name|
-          column_name == :all ? Arel.sql("*", retryable: true) : Arel.sql(name)
-        end
-      end
-
       def operation_over_aggregate_column(column, operation, distinct)
         operation == "count" ? column.count(distinct) : column.public_send(operation)
       end
@@ -469,7 +469,7 @@ module ActiveRecord
           # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
           relation = unscope(:order).distinct!(false)
 
-          column = aggregate_column(column_name)
+          column = relation.aggregate_column(column_name)
           select_value = operation_over_aggregate_column(column, operation, distinct)
           select_value.distinct = true if operation == "sum" && distinct
 
@@ -479,7 +479,11 @@ module ActiveRecord
         end
 
         query_result = if relation.where_clause.contradiction?
-          ActiveRecord::Result.empty
+          if @async
+            FutureResult.wrap(ActiveRecord::Result.empty)
+          else
+            ActiveRecord::Result.empty
+          end
         else
           skip_query_cache_if_necessary do
             @klass.with_connection do |c|
@@ -508,7 +512,9 @@ module ActiveRecord
           associated   = association && association.belongs_to? # only count belongs_to associations
           group_fields = Array(association.foreign_key) if associated
         end
-        group_fields = arel_columns(group_fields)
+
+        relation = except(:group).distinct!(false)
+        group_fields = relation.arel_columns(group_fields)
 
         @klass.with_connection do |connection|
           column_alias_tracker = ColumnAliasTracker.new(connection)
@@ -519,7 +525,7 @@ module ActiveRecord
           }
           group_columns = group_aliases.zip(group_fields)
 
-          column = aggregate_column(column_name)
+          column = relation.aggregate_column(column_name)
           column_alias = column_alias_tracker.alias_for("#{operation} #{column_name.to_s.downcase}")
           select_value = operation_over_aggregate_column(column, operation, distinct)
           select_value.as(adapter_class.quote_column_name(column_alias))
@@ -536,7 +542,6 @@ module ActiveRecord
             end
           }
 
-          relation = except(:group).distinct!(false)
           relation.group_values  = group_fields
           relation.select_values = select_values
 
@@ -662,7 +667,7 @@ module ActiveRecord
           relation.select_values = [ Arel.sql(FinderMethods::ONE_AS_ONE) ] unless distinct
         else
           column_alias = Arel.sql("count_column")
-          relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
+          relation.select_values = [ relation.aggregate_column(column_name).as(column_alias) ]
         end
 
         subquery_alias = Arel.sql("subquery_for_count", retryable: true)

data/lib/active_record/relation/finder_methods.rb

@@ -24,22 +24,22 @@ module ActiveRecord
     #   TravelRoute.primary_key = [:origin, :destination]
     #
     #   TravelRoute.find(["Ottawa", "London"])
-    #   => #<TravelRoute origin: "Ottawa", destination: "London">
+    #   # => #<TravelRoute origin: "Ottawa", destination: "London">
     #
     #   TravelRoute.find([["Paris", "Montreal"]])
-    #   => [#<TravelRoute origin: "Paris", destination: "Montreal">]
+    #   # => [#<TravelRoute origin: "Paris", destination: "Montreal">]
     #
     #   TravelRoute.find(["New York", "Las Vegas"], ["New York", "Portland"])
-    #   => [
-    #        #<TravelRoute origin: "New York", destination: "Las Vegas">,
-    #        #<TravelRoute origin: "New York", destination: "Portland">
-    #      ]
+    #   # => [
+    #   #      #<TravelRoute origin: "New York", destination: "Las Vegas">,
+    #   #      #<TravelRoute origin: "New York", destination: "Portland">
+    #   #    ]
     #
     #   TravelRoute.find([["Berlin", "London"], ["Barcelona", "Lisbon"]])
-    #   => [
-    #        #<TravelRoute origin: "Berlin", destination: "London">,
-    #        #<TravelRoute origin: "Barcelona", destination: "Lisbon">
-    #      ]
+    #   # => [
+    #   #      #<TravelRoute origin: "Berlin", destination: "London">,
+    #   #      #<TravelRoute origin: "Barcelona", destination: "Lisbon">
+    #   #    ]
     #
     # NOTE: The returned records are in the same order as the ids you provide.
     # If you want the results to be sorted by database, you can use ActiveRecord::QueryMethods#where

data/lib/active_record/relation/predicate_builder/association_query_value.rb

@@ -59,6 +59,8 @@ module ActiveRecord
         def convert_to_id(value)
           if primary_key.is_a?(Array)
             primary_key.map do |attribute|
+              next nil if value.nil?
+
               if attribute == "id"
                 value.id_value
               else

data/lib/active_record/relation/query_attribute.rb

@@ -35,7 +35,7 @@ module ActiveRecord
       def nil?
         unless value_before_type_cast.is_a?(StatementCache::Substitute)
           value_before_type_cast.nil? ||
-            type.respond_to?(:subtype) && serializable? && value_for_database.nil?
+            (type.respond_to?(:subtype) || type.respond_to?(:normalizer)) && serializable? && value_for_database.nil?
         end
       end
 

data/lib/active_record/relation/query_methods.rb

@@ -491,7 +491,8 @@ module ActiveRecord
 
     # Like #with, but modifies relation in place.
     def with!(*args) # :nodoc:
-      self.with_values += args
+      args = process_with_args(args)
+      self.with_values |= args
       self
     end
 
@@ -502,7 +503,7 @@ module ActiveRecord
     #   # WITH post_and_replies AS (
     #   #   (SELECT * FROM posts WHERE id = 42)
     #   #   UNION ALL
-    #   #   (SELECT * FROM posts JOIN posts_and_replies ON posts.in_reply_to_id = posts_and_replies.id)
+    #   #   (SELECT * FROM posts JOIN post_and_replies ON posts.in_reply_to_id = post_and_replies.id)
     #   # )
     #   # SELECT * FROM posts
     #
@@ -514,7 +515,8 @@ module ActiveRecord
 
     # Like #with_recursive but modifies the relation in place.
     def with_recursive!(*args) # :nodoc:
-      self.with_values += args
+      args = process_with_args(args)
+      self.with_values |= args
       @with_is_recursive = true
       self
     end
@@ -1277,13 +1279,13 @@ module ActiveRecord
     #
     #   users = User.readonly
     #   users.first.save
-    #   => ActiveRecord::ReadOnlyRecord: User is marked as readonly
+    #   # => ActiveRecord::ReadOnlyRecord: User is marked as readonly
     #
     # To make a readonly relation writable, pass +false+.
     #
     #   users.readonly(false)
     #   users.first.save
-    #   => true
+    #   # => true
     def readonly(value = true)
       spawn.readonly!(value)
     end
@@ -1298,7 +1300,7 @@ module ActiveRecord
     #
     #   user = User.strict_loading.first
     #   user.comments.to_a
-    #   => ActiveRecord::StrictLoadingViolationError
+    #   # => ActiveRecord::StrictLoadingViolationError
     def strict_loading(value = true)
       spawn.strict_loading!(value)
     end
@@ -1896,8 +1898,6 @@ module ActiveRecord
         return if with_values.empty?
 
         with_statements = with_values.map do |with_value|
-          raise ArgumentError, "Unsupported argument type: #{with_value} #{with_value.class}" unless with_value.is_a?(Hash)
-
           build_with_value_from_hash(with_value)
         end
 
@@ -2096,7 +2096,7 @@ module ActiveRecord
               arg.expr.relation.name
             end
           end
-        end.compact
+        end.filter_map { |ref| Arel.sql(ref, retryable: true) if ref }
       end
 
       def extract_table_name_from(string)
@@ -2208,6 +2208,13 @@ module ActiveRecord
         end
       end
 
+      def process_with_args(args)
+        args.flat_map do |arg|
+          raise ArgumentError, "Unsupported argument type: #{arg} #{arg.class}" unless arg.is_a?(Hash)
+          arg.map { |k, v| { k => v } }
+        end
+      end
+
       STRUCTURAL_VALUE_METHODS = (
         Relation::VALUE_METHODS -
         [:extending, :where, :having, :unscope, :references, :annotate, :optimizer_hints]

data/lib/active_record/relation/where_clause.rb

@@ -135,10 +135,14 @@ module ActiveRecord
 
         def extract_attribute(node)
           attr_node = nil
-          Arel.fetch_attribute(node) do |attr|
-            return if attr_node&.!= attr # all attr nodes should be the same
+
+          valid_attrs = Arel.fetch_attribute(node) do |attr|
+            !attr_node || attr_node == attr # all attr nodes should be the same
+          ensure
             attr_node = attr
           end
+          return unless valid_attrs # all nested nodes should yield an attribute
+
           attr_node
         end
 
@@ -172,6 +176,8 @@ module ActiveRecord
         end
 
         def except_predicates(columns)
+          return predicates if columns.empty?
+
           attrs = columns.extract! { |node| node.is_a?(Arel::Attribute) }
           non_attrs = columns.extract! { |node| node.is_a?(Arel::Predications) }
 

data/lib/active_record/relation.rb

@@ -265,7 +265,12 @@ module ActiveRecord
     # such situation.
     def create_or_find_by(attributes, &block)
       with_connection do |connection|
-        transaction(requires_new: true) { create(attributes, &block) }
+        record = nil
+        transaction(requires_new: true) do
+          record = create(attributes, &block)
+          record._last_transaction_return_status || raise(ActiveRecord::Rollback)
+        end
+        record
       rescue ActiveRecord::RecordNotUnique
         if connection.transaction_open?
           where(attributes).lock.find_by!(attributes)
@@ -280,7 +285,12 @@ module ActiveRecord
     # is raised if the created record is invalid.
     def create_or_find_by!(attributes, &block)
       with_connection do |connection|
-        transaction(requires_new: true) { create!(attributes, &block) }
+        record = nil
+        transaction(requires_new: true) do
+          record = create!(attributes, &block)
+          record._last_transaction_return_status || raise(ActiveRecord::Rollback)
+        end
+        record
       rescue ActiveRecord::RecordNotUnique
         if connection.transaction_open?
           where(attributes).lock.find_by!(attributes)
@@ -290,7 +300,7 @@ module ActiveRecord
       end
     end
 
-    # Like #find_or_create_by, but calls {new}[rdoc-ref:Core#new]
+    # Like #find_or_create_by, but calls {new}[rdoc-ref:Core.new]
     # instead of {create}[rdoc-ref:Persistence::ClassMethods#create].
     def find_or_initialize_by(attributes, &block)
       find_by(attributes) || new(attributes, &block)
@@ -813,7 +823,7 @@ module ActiveRecord
     #
     # [:returning]
     #   (PostgreSQL, SQLite3, and MariaDB only) An array of attributes to return for all successfully
-    #   inserted records, which by default is the primary key.
+    #   upserted records, which by default is the primary key.
     #   Pass <tt>returning: %w[ id name ]</tt> for both id and name
     #   or <tt>returning: false</tt> to omit the underlying <tt>RETURNING</tt> SQL
     #   clause entirely.
@@ -942,7 +952,7 @@ module ActiveRecord
     # If attribute names are passed, they are updated along with +updated_at+/+updated_on+ attributes.
     # If no time argument is passed, the current time is used as default.
     #
-    # === Examples
+    # ==== Examples
     #
     #   # Touch all records
     #   Person.all.touch_all

data/lib/active_record/schema_dumper.rb

@@ -202,12 +202,17 @@ module ActiveRecord
           end
 
           indexes_in_create(table, tbl)
-          check_constraints_in_create(table, tbl) if @connection.supports_check_constraints?
+          remaining = check_constraints_in_create(table, tbl) if @connection.supports_check_constraints?
           exclusion_constraints_in_create(table, tbl) if @connection.supports_exclusion_constraints?
           unique_constraints_in_create(table, tbl) if @connection.supports_unique_constraints?
 
           tbl.puts "  end"
 
+          if remaining
+            tbl.puts
+            tbl.print remaining.string
+          end
+
           stream.print tbl.string
         rescue => e
           stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
@@ -272,24 +277,37 @@ module ActiveRecord
 
       def check_constraints_in_create(table, stream)
         if (check_constraints = @connection.check_constraints(table)).any?
-          add_check_constraint_statements = check_constraints.map do |check_constraint|
-            parts = [
-              "t.check_constraint #{check_constraint.expression.inspect}"
-            ]
+          check_valid, check_invalid = check_constraints.partition { |chk| chk.validate? }
 
-            if check_constraint.export_name_on_schema_dump?
-              parts << "name: #{check_constraint.name.inspect}"
+          unless check_valid.empty?
+            check_constraint_statements = check_valid.map do |check|
+              "    t.check_constraint #{check_parts(check).join(', ')}"
             end
 
-            parts << "validate: #{check_constraint.validate?.inspect}" unless check_constraint.validate?
-
-            "    #{parts.join(', ')}"
+            stream.puts check_constraint_statements.sort.join("\n")
           end
 
-          stream.puts add_check_constraint_statements.sort.join("\n")
+          unless check_invalid.empty?
+            remaining = StringIO.new
+            table_name = remove_prefix_and_suffix(table).inspect
+
+            add_check_constraint_statements = check_invalid.map do |check|
+              "  add_check_constraint #{([table_name] + check_parts(check)).join(', ')}"
+            end
+
+            remaining.puts add_check_constraint_statements.sort.join("\n")
+            remaining
+          end
         end
       end
 
+      def check_parts(check)
+        check_parts = [ check.expression.inspect ]
+        check_parts << "name: #{check.name.inspect}" if check.export_name_on_schema_dump?
+        check_parts << "validate: #{check.validate?.inspect}" unless check.validate?
+        check_parts
+      end
+
       def foreign_keys(table, stream)
         if (foreign_keys = @connection.foreign_keys(table)).any?
           add_foreign_key_statements = foreign_keys.map do |foreign_key|

data/lib/active_record/secure_token.rb

@@ -30,13 +30,13 @@ module ActiveRecord
       # {validates_uniqueness_of}[rdoc-ref:Validations::ClassMethods#validates_uniqueness_of] can.
       # You're encouraged to add a unique index in the database to deal with this even more unlikely scenario.
       #
-      # === Options
+      # ==== Options
       #
-      # [:length]
+      # [+:length+]
       #   Length of the Secure Random, with a minimum of 24 characters. It will
       #   default to 24.
       #
-      # [:on]
+      # [+:on+]
       #   The callback when the value is generated. When called with <tt>on:
       #   :initialize</tt>, the value is generated in an
       #   <tt>after_initialize</tt> callback, otherwise the value will be used

data/lib/active_record/signed_id.rb

@@ -57,12 +57,12 @@ module ActiveRecord
         end
       end
 
-      # Works like find_signed, but will raise an +ActiveSupport::MessageVerifier::InvalidSignature+
+      # Works like find_signed, but will raise an ActiveSupport::MessageVerifier::InvalidSignature
       # exception if the +signed_id+ has either expired, has a purpose mismatch, is for another record,
-      # or has been tampered with. It will also raise an +ActiveRecord::RecordNotFound+ exception if
+      # or has been tampered with. It will also raise an ActiveRecord::RecordNotFound exception if
       # the valid signed id can't find a record.
       #
-      # === Examples
+      # ==== Examples
       #
       #   User.find_signed! "bad data" # => ActiveSupport::MessageVerifier::InvalidSignature
       #
@@ -76,8 +76,9 @@ module ActiveRecord
       end
 
       # The verifier instance that all signed ids are generated and verified from. By default, it'll be initialized
-      # with the class-level +signed_id_verifier_secret+, which within \Rails comes from the
-      # Rails.application.key_generator. By default, it's SHA256 for the digest and JSON for the serialization.
+      # with the class-level +signed_id_verifier_secret+, which within Rails comes from
+      # {Rails.application.key_generator}[rdoc-ref:Rails::Application#key_generator].
+      # By default, it's SHA256 for the digest and JSON for the serialization.
       def signed_id_verifier
         @signed_id_verifier ||= begin
           secret = signed_id_verifier_secret
@@ -93,7 +94,7 @@ module ActiveRecord
 
       # Allows you to pass in a custom verifier used for the signed ids. This also allows you to use different
       # verifiers for different classes. This is also helpful if you need to rotate keys, as you can prepare
-      # your custom verifier for that in advance. See +ActiveSupport::MessageVerifier+ for details.
+      # your custom verifier for that in advance. See ActiveSupport::MessageVerifier for details.
       def signed_id_verifier=(verifier)
         @signed_id_verifier = verifier
       end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -132,6 +132,13 @@ module ActiveRecord
           tempfile = Tempfile.open("uncommented_structure.sql")
           begin
             File.foreach(filename) do |line|
+              next if line.start_with?("\\restrict ")
+
+              if line.start_with?("\\unrestrict ")
+                removing_comments = true
+                next
+              end
+
               unless removing_comments && (line.start_with?(SQL_COMMENT_BEGIN) || line.blank?)
                 tempfile << line
                 removing_comments = false

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
     #
@@ -418,6 +418,7 @@ module ActiveRecord
           status = yield
           raise ActiveRecord::Rollback unless status
         end
+        @_last_transaction_return_status = status
         status
       end
     end
@@ -433,6 +434,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.rb

@@ -86,7 +86,6 @@ module ActiveRecord
   autoload :Timestamp
   autoload :TokenFor
   autoload :TouchLater
-  autoload :Transaction
   autoload :Transactions
   autoload :Translation
   autoload :Validations
@@ -108,6 +107,7 @@ module ActiveRecord
     autoload :Result
     autoload :StatementCache
     autoload :TableMetadata
+    autoload :Transaction
     autoload :Type
 
     autoload_under "relation" do

data/lib/arel/collectors/bind.rb

@@ -13,7 +13,7 @@ module Arel # :nodoc: all
         self
       end
 
-      def add_bind(bind)
+      def add_bind(bind, &block)
         @binds << bind
         self
       end

data/lib/arel/crud.rb

@@ -26,6 +26,7 @@ module Arel # :nodoc: all
       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?
@@ -39,6 +40,7 @@ module Arel # :nodoc: all
       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?

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