activerecord 5.2.8.1 → 6.1.7.3

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,13 +65,10 @@ module ActiveRecord
       end
     end
 
-    # Returns an array of hashes representing each row record.
-    def to_hash
-      hash_rows
-    end
-
     alias :map! :map
     alias :collect! :map
+    deprecate "map!": :map
+    deprecate "collect!": :map
 
     # Returns true if there are no records, otherwise false.
     def empty?
@@ -78,31 +80,41 @@ module ActiveRecord
       hash_rows
     end
 
+    alias :to_a :to_ary
+
     def [](idx)
       hash_rows[idx]
     end
 
-    # Returns the first record from the rows collection.
-    # If the rows collection is empty, returns +nil+.
-    def first
-      return nil if @rows.empty?
-      Hash[@columns.zip(@rows.first)]
-    end
-
     # Returns the last record from the rows collection.
-    # If the rows collection is empty, returns +nil+.
-    def last
-      return nil if @rows.empty?
-      Hash[@columns.zip(@rows.last)]
+    def last(n = nil)
+      n ? hash_rows.last(n) : hash_rows.last
     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 = if type_overrides.is_a?(Array)
+          type_overrides.first
+        else
+          column_type(columns.first, type_overrides)
+        end
+
+        rows.map do |(value)|
+          type.deserialize(value)
+        end
+      else
+        types = if type_overrides.is_a?(Array)
+          type_overrides
+        else
+          columns.map { |name| column_type(name, type_overrides) }
+        end
+
+        rows.map do |values|
+          Array.new(values.size) { |i| types[i].deserialize(values[i]) }
+        end
+      end
     end
 
     def initialize_copy(other)
@@ -113,7 +125,6 @@ module ActiveRecord
     end
 
     private
-
       def column_type(name, type_overrides = {})
         type_overrides.fetch(name) do
           column_types.fetch(name, Type.default_value)
@@ -125,23 +136,38 @@ 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
+            template = nil
+
             @rows.map { |row|
-              # In the past we used Hash[columns.zip(row)]
-              #  though elegant, the verbose way is much more efficient
-              #  both time and memory wise cause it avoids a big array allocation
-              #  this method is called a lot and needs to be micro optimised
-              hash = {}
-
-              index = 0
-              length = columns.length
-
-              while index < length
-                hash[columns[index]] = row[index]
-                index += 1
+              if template
+                # We use transform_values to build subsequent rows from the
+                # hash of the first row. This is faster because we avoid any
+                # reallocs and in Ruby 2.7+ avoid hashing entirely.
+                index = -1
+                template.transform_values do
+                  row[index += 1]
+                end
+              else
+                # In the past we used Hash[columns.zip(row)]
+                #  though elegant, the verbose way is much more efficient
+                #  both time and memory wise cause it avoids a big array allocation
+                #  this method is called a lot and needs to be micro optimised
+                hash = {}
+
+                index = 0
+                while index < length
+                  hash[columns[index]] = row[index]
+                  index += 1
+                end
+
+                # It's possible to select the same column twice, in which case
+                # we can't use a template
+                template = hash if hash.length == length
+
+                hash
               end
-
-              hash
             }
           end
       end

data/lib/active_record/runtime_registry.rb

@@ -14,9 +14,9 @@ module ActiveRecord
   class RuntimeRegistry # :nodoc:
     extend ActiveSupport::PerThreadRegistry
 
-    attr_accessor :connection_handler, :sql_runtime
+    attr_accessor :sql_runtime
 
-    [:connection_handler, :sql_runtime].each do |val|
+    [:sql_runtime].each do |val|
       class_eval %{ def self.#{val}; instance.#{val}; end }, __FILE__, __LINE__
       class_eval %{ def self.#{val}=(x); instance.#{val}=x; end }, __FILE__, __LINE__
     end

data/lib/active_record/sanitization.rb

@@ -61,12 +61,13 @@ 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
-          # override methods we use (eg. Arel::Nodes::SqlLiteral).
+          # override methods we use (e.g. Arel::Nodes::SqlLiteral).
           if condition.first.kind_of?(String) && !condition.first.instance_of?(String)
             condition = [String.new(condition.first), *condition[1..-1]]
           end
@@ -133,44 +134,22 @@ 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
 
+        if unexpected
+          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,12 +181,14 @@ 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?
+            values = value.map { |v| v.respond_to?(:id_for_database) ? v.id_for_database : v }
+            if values.empty?
               c.quote(nil)
             else
-              value.map { |v| c.quote(v) }.join(",")
+              values.map! { |v| c.quote(v) }.join(",")
             end
           else
+            value = value.id_for_database if value.respond_to?(:id_for_database)
             c.quote(value)
           end
         end

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,18 @@ 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}$/
+
+    ##
+    # :singleton-method:
+    # Specify a custom regular expression matching check constraints which name
+    # should not be dumped to db/schema.rb.
+    cattr_accessor :chk_ignore_pattern, default: /^chk_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 +53,7 @@ module ActiveRecord
     end
 
     private
+      attr_accessor :table_name
 
       def initialize(connection, options = {})
         @connection = connection
@@ -65,11 +78,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 `bin/rails
+# db:schema:load`. When creating a new database, `bin/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 +117,8 @@ HEADER
       def table(table, stream)
         columns = @connection.columns(table)
         begin
+          self.table_name = table
+
           tbl = StringIO.new
 
           # first dump primary key column
@@ -116,7 +131,10 @@ HEADER
             tbl.print ", primary_key: #{pk.inspect}" unless pk == "id"
             pkcol = columns.detect { |c| c.name == pk }
             pkcolspec = column_spec_for_primary_key(pkcol)
-            if pkcolspec.present?
+            unless pkcolspec.empty?
+              if pkcolspec != pkcolspec.slice(:id, :default)
+                pkcolspec = { id: { type: pkcolspec.delete(:id), **pkcolspec }.compact }
+              end
               tbl.print ", #{format_colspec(pkcolspec)}"
             end
           when Array
@@ -137,12 +155,17 @@ 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
 
           indexes_in_create(table, tbl)
+          check_constraints_in_create(table, tbl) if @connection.supports_check_constraints?
 
           tbl.puts "  end"
           tbl.puts
@@ -153,6 +176,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
 
@@ -194,6 +219,24 @@ HEADER
         index_parts
       end
 
+      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}"
+            ]
+
+            if check_constraint.export_name_on_schema_dump?
+              parts << "name: #{check_constraint.name.inspect}"
+            end
+
+            "    #{parts.join(', ')}"
+          end
+
+          stream.puts add_check_constraint_statements.sort.join("\n")
+        end
+      end
+
       def foreign_keys(table, stream)
         if (foreign_keys = @connection.foreign_keys(table)).any?
           add_foreign_key_statements = foreign_keys.map do |foreign_key|
@@ -210,7 +253,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
 
@@ -225,7 +268,9 @@ HEADER
       end
 
       def format_colspec(colspec)
-        colspec.map { |key, value| "#{key}: #{value}" }.join(", ")
+        colspec.map do |key, value|
+          "#{key}: #{ value.is_a?(Hash) ? "{ #{format_colspec(value)} }" : value }"
+        end.join(", ")
       end
 
       def format_options(options)

data/lib/active_record/schema_migration.rb

@@ -10,24 +10,22 @@ 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}"
-      end
-
-      def table_exists?
-        connection.table_exists?(table_name)
+        "#{table_name_prefix}#{schema_migrations_table_name}#{table_name_suffix}"
       end
 
       def create_table
-        unless table_exists?
-          version_options = connection.internal_string_options_for_primary_key
-
+        unless connection.table_exists?(table_name)
           connection.create_table(table_name, id: false) do |t|
-            t.string :version, version_options
+            t.string :version, **connection.internal_string_options_for_primary_key
           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?
@@ -110,16 +109,13 @@ module ActiveRecord
             if default_scope_override
               # 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)
-                end
+                relation.scoping { default_scope }
               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

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/array"
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/kernel/singleton_class"
-
 module ActiveRecord
   # = Active Record \Named \Scopes
   module Scoping
@@ -24,13 +20,13 @@ 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 current_scope
-            if self == current_scope.klass
-              current_scope.clone
+          if scope
+            if self == scope.klass
+              scope.clone
             else
-              relation.merge!(current_scope)
+              relation.merge!(scope)
             end
           else
             default_scoped
@@ -38,21 +34,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
             []
@@ -77,10 +72,6 @@ module ActiveRecord
         # <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>, in effect,
         # represents the query <tt>Shirt.where(color: 'red')</tt>.
         #
-        # You should always pass a callable object to the scopes defined
-        # with #scope. This ensures that the scope is re-evaluated each
-        # time it is called.
-        #
         # Note that this is simply 'syntactic sugar' for defining an actual
         # class method:
         #
@@ -181,25 +172,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(*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"