activerecord 5.2.6 → 6.0.5

data/lib/active_record/result.rb

@@ -21,7 +21,7 @@ module ActiveRecord
   #        ]
   #
   #   # Get an array of hashes representing the result (column => value):
-  #   result.to_hash
+  #   result.to_a
   #   # => [{"id" => 1, "title" => "title_1", "body" => "body_1"},
   #         {"id" => 2, "title" => "title_2", "body" => "body_2"},
   #         ...
@@ -43,6 +43,11 @@ module ActiveRecord
       @column_types = column_types
     end
 
+    # Returns true if this result set includes the column named +name+
+    def includes_column?(name)
+      @columns.include? name
+    end
+
     # Returns the number of elements in the rows array.
     def length
       @rows.length
@@ -60,9 +65,12 @@ module ActiveRecord
       end
     end
 
-    # Returns an array of hashes representing each row record.
     def to_hash
-      hash_rows
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+        `ActiveRecord::Result#to_hash` has been renamed to `to_a`.
+        `to_hash` is deprecated and will be removed in Rails 6.1.
+      MSG
+      to_a
     end
 
     alias :map! :map
@@ -78,6 +86,8 @@ module ActiveRecord
       hash_rows
     end
 
+    alias :to_a :to_ary
+
     def [](idx)
       hash_rows[idx]
     end
@@ -97,12 +107,21 @@ module ActiveRecord
     end
 
     def cast_values(type_overrides = {}) # :nodoc:
-      types = columns.map { |name| column_type(name, type_overrides) }
-      result = rows.map do |values|
-        types.zip(values).map { |type, value| type.deserialize(value) }
-      end
+      if columns.one?
+        # Separated to avoid allocating an array per row
 
-      columns.one? ? result.map!(&:first) : result
+        type = column_type(columns.first, type_overrides)
+
+        rows.map do |(value)|
+          type.deserialize(value)
+        end
+      else
+        types = columns.map { |name| column_type(name, type_overrides) }
+
+        rows.map do |values|
+          Array.new(values.size) { |i| types[i].deserialize(values[i]) }
+        end
+      end
     end
 
     def initialize_copy(other)
@@ -113,7 +132,6 @@ module ActiveRecord
     end
 
     private
-
       def column_type(name, type_overrides = {})
         type_overrides.fetch(name) do
           column_types.fetch(name, Type.default_value)
@@ -125,7 +143,9 @@ module ActiveRecord
           begin
             # We freeze the strings to prevent them getting duped when
             # used as keys in ActiveRecord::Base's @attributes hash
-            columns = @columns.map { |c| c.dup.freeze }
+            columns = @columns.map(&:-@)
+            length  = columns.length
+
             @rows.map { |row|
               # In the past we used Hash[columns.zip(row)]
               #  though elegant, the verbose way is much more efficient
@@ -134,8 +154,6 @@ module ActiveRecord
               hash = {}
 
               index = 0
-              length = columns.length
-
               while index < length
                 hash[columns[index]] = row[index]
                 index += 1

data/lib/active_record/sanitization.rb

@@ -61,8 +61,9 @@ module ActiveRecord
       #   # => "id ASC"
       def sanitize_sql_for_order(condition)
         if condition.is_a?(Array) && condition.first.to_s.include?("?")
-          enforce_raw_sql_whitelist([condition.first],
-            whitelist: AttributeMethods::ClassMethods::COLUMN_NAME_ORDER_WHITELIST
+          disallow_raw_sql!(
+            [condition.first],
+            permit: connection.column_name_with_order_matcher
           )
 
           # Ensure we aren't dealing with a subclass of String that might
@@ -133,44 +134,34 @@ module ActiveRecord
         end
       end
 
-      private
-        # Accepts a hash of SQL conditions and replaces those attributes
-        # that correspond to a {#composed_of}[rdoc-ref:Aggregations::ClassMethods#composed_of]
-        # relationship with their expanded aggregate attribute values.
-        #
-        # Given:
-        #
-        #   class Person < ActiveRecord::Base
-        #     composed_of :address, class_name: "Address",
-        #       mapping: [%w(address_street street), %w(address_city city)]
-        #   end
-        #
-        # Then:
-        #
-        #   { address: Address.new("813 abc st.", "chicago") }
-        #   # => { address_street: "813 abc st.", address_city: "chicago" }
-        def expand_hash_conditions_for_aggregates(attrs) # :doc:
-          expanded_attrs = {}
-          attrs.each do |attr, value|
-            if aggregation = reflect_on_aggregation(attr.to_sym)
-              mapping = aggregation.mapping
-              mapping.each do |field_attr, aggregate_attr|
-                expanded_attrs[field_attr] = if value.is_a?(Array)
-                  value.map { |it| it.send(aggregate_attr) }
-                elsif mapping.size == 1 && !value.respond_to?(aggregate_attr)
-                  value
-                else
-                  value.send(aggregate_attr)
-                end
-              end
-            else
-              expanded_attrs[attr] = value
-            end
-          end
-          expanded_attrs
+      def disallow_raw_sql!(args, permit: connection.column_name_matcher) # :nodoc:
+        unexpected = nil
+        args.each do |arg|
+          next if arg.is_a?(Symbol) || Arel.arel_node?(arg) || permit.match?(arg.to_s)
+          (unexpected ||= []) << arg
         end
-        deprecate :expand_hash_conditions_for_aggregates
 
+        return unless unexpected
+
+        if allow_unsafe_raw_sql == :deprecated
+          ActiveSupport::Deprecation.warn(
+            "Dangerous query method (method whose arguments are used as raw " \
+            "SQL) called with non-attribute argument(s): " \
+            "#{unexpected.map(&:inspect).join(", ")}. Non-attribute " \
+            "arguments will be disallowed in Rails 6.1. This method should " \
+            "not be called with user-provided values, such as request " \
+            "parameters or model attributes. Known-safe values can be passed " \
+            "by wrapping them in Arel.sql()."
+          )
+        else
+          raise(ActiveRecord::UnknownAttributeReference,
+            "Query method called with non-attribute argument(s): " +
+            unexpected.map(&:inspect).join(", ")
+          )
+        end
+      end
+
+      private
         def replace_bind_variables(statement, values)
           raise_if_bind_arity_mismatch(statement, statement.count("?"), values.size)
           bound = values.dup
@@ -202,10 +193,11 @@ module ActiveRecord
 
         def quote_bound_value(value, c = connection)
           if value.respond_to?(:map) && !value.acts_like?(:string)
-            if value.respond_to?(:empty?) && value.empty?
+            quoted = value.map { |v| c.quote(v) }
+            if quoted.empty?
               c.quote(nil)
             else
-              value.map { |v| c.quote(v) }.join(",")
+              quoted.join(",")
             end
           else
             c.quote(value)

data/lib/active_record/schema.rb

@@ -50,21 +50,12 @@ module ActiveRecord
       instance_eval(&block)
 
       if info[:version].present?
-        ActiveRecord::SchemaMigration.create_table
-        connection.assume_migrated_upto_version(info[:version], migrations_paths)
+        connection.schema_migration.create_table
+        connection.assume_migrated_upto_version(info[:version])
       end
 
       ActiveRecord::InternalMetadata.create_table
       ActiveRecord::InternalMetadata[:environment] = connection.migration_context.current_environment
     end
-
-    private
-      # Returns the migrations paths.
-      #
-      #   ActiveRecord::Schema.new.migrations_paths
-      #   # => ["db/migrate"] # Rails migration path by default.
-      def migrations_paths
-        ActiveRecord::Migrator.migrations_paths
-      end
   end
 end

data/lib/active_record/schema_dumper.rb

@@ -17,6 +17,12 @@ module ActiveRecord
     # Only strings are accepted if ActiveRecord::Base.schema_format == :sql.
     cattr_accessor :ignore_tables, default: []
 
+    ##
+    # :singleton-method:
+    # Specify a custom regular expression matching foreign keys which name
+    # should not be dumped to db/schema.rb.
+    cattr_accessor :fk_ignore_pattern, default: /^fk_rails_[0-9a-f]{10}$/
+
     class << self
       def dump(connection = ActiveRecord::Base.connection, stream = STDOUT, config = ActiveRecord::Base)
         connection.create_schema_dumper(generate_options(config)).dump(stream)
@@ -41,6 +47,7 @@ module ActiveRecord
     end
 
     private
+      attr_accessor :table_name
 
       def initialize(connection, options = {})
         @connection = connection
@@ -65,11 +72,11 @@ module ActiveRecord
 # of editing this file, please use the migrations feature of Active Record to
 # incrementally modify your database, and then regenerate this schema definition.
 #
-# Note that this schema.rb definition is the authoritative source for your
-# database schema. If you need to create the application database on another
-# system, you should be using db:schema:load, not running all the migrations
-# from scratch. The latter is a flawed and unsustainable approach (the more migrations
-# you'll amass, the slower it'll run and the greater likelihood for issues).
+# This file is the source Rails uses to define your schema when running `rails
+# db:schema:load`. When creating a new database, `rails db:schema:load` tends to
+# be faster and is potentially less error prone than running all of your
+# migrations from scratch. Old migrations may fail to apply correctly if those
+# migrations use external dependencies or application code.
 #
 # It's strongly recommended that you check this file into your version control system.
 
@@ -104,6 +111,8 @@ HEADER
       def table(table, stream)
         columns = @connection.columns(table)
         begin
+          self.table_name = table
+
           tbl = StringIO.new
 
           # first dump primary key column
@@ -137,7 +146,11 @@ HEADER
             raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
             next if column.name == pk
             type, colspec = column_spec(column)
-            tbl.print "    t.#{type} #{column.name.inspect}"
+            if type.is_a?(Symbol)
+              tbl.print "    t.#{type} #{column.name.inspect}"
+            else
+              tbl.print "    t.column #{column.name.inspect}, #{type.inspect}"
+            end
             tbl.print ", #{format_colspec(colspec)}" if colspec.present?
             tbl.puts
           end
@@ -153,6 +166,8 @@ HEADER
           stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
           stream.puts "#   #{e.message}"
           stream.puts
+        ensure
+          self.table_name = nil
         end
       end
 
@@ -210,7 +225,7 @@ HEADER
               parts << "primary_key: #{foreign_key.primary_key.inspect}"
             end
 
-            if foreign_key.name !~ /^fk_rails_[0-9a-f]{10}$/
+            if foreign_key.export_name_on_schema_dump?
               parts << "name: #{foreign_key.name.inspect}"
             end
 

data/lib/active_record/schema_migration.rb

@@ -10,12 +10,16 @@ module ActiveRecord
   # to be executed the next time.
   class SchemaMigration < ActiveRecord::Base # :nodoc:
     class << self
+      def _internal?
+        true
+      end
+
       def primary_key
         "version"
       end
 
       def table_name
-        "#{table_name_prefix}#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
+        "#{table_name_prefix}#{schema_migrations_table_name}#{table_name_suffix}"
       end
 
       def table_exists?
@@ -27,7 +31,7 @@ module ActiveRecord
           version_options = connection.internal_string_options_for_primary_key
 
           connection.create_table(table_name, id: false) do |t|
-            t.string :version, version_options
+            t.string :version, **version_options
           end
         end
       end

data/lib/active_record/scoping/default.rb

@@ -44,7 +44,6 @@ module ActiveRecord
         end
 
         private
-
           # Use this macro in your model to set a default scope for all operations on
           # the model.
           #
@@ -100,7 +99,7 @@ module ActiveRecord
             self.default_scopes += [scope]
           end
 
-          def build_default_scope(base_rel = nil)
+          def build_default_scope(relation = relation())
             return if abstract_class?
 
             if default_scope_override.nil?
@@ -111,15 +110,14 @@ module ActiveRecord
               # The user has defined their own default scope method, so call that
               evaluate_default_scope do
                 if scope = default_scope
-                  (base_rel ||= relation).merge!(scope)
+                  relation.merge!(scope)
                 end
               end
             elsif default_scopes.any?
-              base_rel ||= relation
               evaluate_default_scope do
-                default_scopes.inject(base_rel) do |default_scope, scope|
+                default_scopes.inject(relation) do |default_scope, scope|
                   scope = scope.respond_to?(:to_proc) ? scope : scope.method(:call)
-                  default_scope.merge!(base_rel.instance_exec(&scope))
+                  default_scope.instance_exec(&scope) || default_scope
                 end
               end
             end

data/lib/active_record/scoping/named.rb

@@ -24,13 +24,21 @@ module ActiveRecord
         # You can define a scope that applies to all finders using
         # {default_scope}[rdoc-ref:Scoping::Default::ClassMethods#default_scope].
         def all
-          current_scope = self.current_scope
+          scope = current_scope
+
+          if scope
+            if scope._deprecated_scope_source
+              ActiveSupport::Deprecation.warn(<<~MSG.squish)
+                Class level methods will no longer inherit scoping from `#{scope._deprecated_scope_source}`
+                in Rails 6.1. To continue using the scoped relation, pass it into the block directly.
+                To instead access the full set of models, as Rails 6.1 will, use `#{name}.default_scoped`.
+              MSG
+            end
 
-          if current_scope
-            if self == current_scope.klass
-              current_scope.clone
+            if self == scope.klass
+              scope.clone
             else
-              relation.merge!(current_scope)
+              relation.merge!(scope)
             end
           else
             default_scoped
@@ -38,21 +46,20 @@ module ActiveRecord
         end
 
         def scope_for_association(scope = relation) # :nodoc:
-          current_scope = self.current_scope
-
-          if current_scope && current_scope.empty_scope?
+          if current_scope&.empty_scope?
             scope
           else
             default_scoped(scope)
           end
         end
 
-        def default_scoped(scope = relation) # :nodoc:
+        # Returns a scope for the model with default scopes.
+        def default_scoped(scope = relation)
           build_default_scope(scope) || scope
         end
 
         def default_extensions # :nodoc:
-          if scope = current_scope || build_default_scope
+          if scope = scope_for_association || build_default_scope
             scope.extensions
           else
             []
@@ -181,25 +188,27 @@ module ActiveRecord
           extension = Module.new(&block) if block
 
           if body.respond_to?(:to_proc)
-            singleton_class.send(:define_method, name) do |*args|
-              scope = all
-              scope = scope._exec_scope(*args, &body)
+            singleton_class.define_method(name) do |*args|
+              scope = all._exec_scope(name, *args, &body)
               scope = scope.extending(extension) if extension
               scope
             end
           else
-            singleton_class.send(:define_method, name) do |*args|
-              scope = all
-              scope = scope.scoping { body.call(*args) || scope }
+            singleton_class.define_method(name) do |*args|
+              scope = body.call(*args) || all
               scope = scope.extending(extension) if extension
               scope
             end
           end
+          singleton_class.send(:ruby2_keywords, name) if respond_to?(:ruby2_keywords, true)
 
           generate_relation_method(name)
         end
 
         private
+          def singleton_method_added(name)
+            generate_relation_method(name) if Kernel.respond_to?(name) && !ActiveRecord::Relation.method_defined?(name)
+          end
 
           def valid_scope_name?(name)
             if respond_to?(name, true) && logger

data/lib/active_record/scoping.rb

@@ -12,14 +12,6 @@ module ActiveRecord
     end
 
     module ClassMethods # :nodoc:
-      def current_scope(skip_inherited_scope = false)
-        ScopeRegistry.value_for(:current_scope, self, skip_inherited_scope)
-      end
-
-      def current_scope=(scope)
-        ScopeRegistry.set_value_for(:current_scope, self, scope)
-      end
-
       # Collects attributes from scopes that should be applied when creating
       # an AR instance for the particular class this is called on.
       def scope_attributes
@@ -30,6 +22,14 @@ module ActiveRecord
       def scope_attributes?
         current_scope
       end
+
+      def current_scope(skip_inherited_scope = false)
+        ScopeRegistry.value_for(:current_scope, self, skip_inherited_scope)
+      end
+
+      def current_scope=(scope)
+        ScopeRegistry.set_value_for(:current_scope, self, scope)
+      end
     end
 
     def populate_with_current_scope_attributes # :nodoc:
@@ -95,7 +95,6 @@ module ActiveRecord
       end
 
       private
-
         def raise_invalid_scope_type!(scope_type)
           if !VALID_SCOPE_TYPES.include?(scope_type)
             raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"

data/lib/active_record/statement_cache.rb

@@ -44,7 +44,7 @@ module ActiveRecord
       def initialize(values)
         @values = values
         @indexes = values.each_with_index.find_all { |thing, i|
-          Arel::Nodes::BindParam === thing
+          Substitute === thing
         }.map(&:last)
       end
 
@@ -56,6 +56,28 @@ module ActiveRecord
       end
     end
 
+    class PartialQueryCollector
+      def initialize
+        @parts = []
+        @binds = []
+      end
+
+      def <<(str)
+        @parts << str
+        self
+      end
+
+      def add_bind(obj)
+        @binds << obj
+        @parts << Substitute.new
+        self
+      end
+
+      def value
+        [@parts, @binds]
+      end
+    end
+
     def self.query(sql)
       Query.new(sql)
     end
@@ -64,6 +86,10 @@ module ActiveRecord
       PartialQuery.new(values)
     end
 
+    def self.partial_query_collector
+      PartialQueryCollector.new
+    end
+
     class Params # :nodoc:
       def bind; Substitute.new; end
     end
@@ -106,6 +132,8 @@ module ActiveRecord
       sql = query_builder.sql_for bind_values, connection
 
       klass.find_by_sql(sql, bind_values, preparable: true, &block)
+    rescue ::RangeError
+      nil
     end
 
     def self.unsupported_value?(value)
@@ -114,8 +142,7 @@ module ActiveRecord
       end
     end
 
-    protected
-
+    private
       attr_reader :query_builder, :bind_map, :klass
   end
 end