activerecord 5.0.0 → 5.0.1

data/lib/active_record/attribute_methods/primary_key.rb

@@ -95,7 +95,8 @@ module ActiveRecord
             base_name.foreign_key
           else
             if ActiveRecord::Base != self && table_exists?
-              connection.schema_cache.primary_keys(table_name)
+              pk = connection.schema_cache.primary_keys(table_name)
+              suppress_composite_primary_key(pk)
             else
               'id'
             end
@@ -122,6 +123,18 @@ module ActiveRecord
           @quoted_primary_key = nil
           @attributes_builder = nil
         end
+
+        private
+
+        def suppress_composite_primary_key(pk)
+          return pk unless pk.is_a?(Array)
+
+          warn <<-WARNING.strip_heredoc
+            WARNING: Active Record does not support composite primary key.
+
+            #{table_name} has composite primary key. Composite primary key is ignored.
+          WARNING
+        end
       end
     end
   end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -39,7 +39,7 @@ module ActiveRecord
         end
 
         def set_time_zone_without_conversion(value)
-          ::Time.zone.local_to_utc(value).in_time_zone
+          ::Time.zone.local_to_utc(value).in_time_zone if value
         end
 
         def map_avoiding_infinite_recursion(value)

data/lib/active_record/attribute_methods.rb

@@ -279,9 +279,8 @@ module ActiveRecord
     # Returns an <tt>#inspect</tt>-like string for the value of the
     # attribute +attr_name+. String attributes are truncated up to 50
     # characters, Date and Time attributes are returned in the
-    # <tt>:db</tt> format, Array attributes are truncated up to 10 values.
-    # Other attributes return the value of <tt>#inspect</tt> without
-    # modification.
+    # <tt>:db</tt> format. Other attributes return the value of
+    # <tt>#inspect</tt> without modification.
     #
     #   person = Person.create!(name: 'David Heinemeier Hansson ' * 3)
     #
@@ -292,7 +291,7 @@ module ActiveRecord
     #   # => "\"2012-10-22 00:15:07\""
     #
     #   person.attribute_for_inspect(:tag_ids)
-    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...]"
+    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
     def attribute_for_inspect(attr_name)
       value = read_attribute(attr_name)
 
@@ -300,9 +299,6 @@ module ActiveRecord
         "#{value[0, 50]}...".inspect
       elsif value.is_a?(Date) || value.is_a?(Time)
         %("#{value.to_s(:db)}")
-      elsif value.is_a?(Array) && value.size > 10
-        inspected = value.first(10).inspect
-        %(#{inspected[0...-1]}, ...])
       else
         value.inspect
       end

data/lib/active_record/attribute_set/builder.rb

@@ -3,11 +3,12 @@ require 'active_record/attribute'
 module ActiveRecord
   class AttributeSet # :nodoc:
     class Builder # :nodoc:
-      attr_reader :types, :always_initialized
+      attr_reader :types, :always_initialized, :default
 
-      def initialize(types, always_initialized = nil)
+      def initialize(types, always_initialized = nil, &default)
         @types = types
         @always_initialized = always_initialized
+        @default = default
       end
 
       def build_from_database(values = {}, additional_types = {})
@@ -15,21 +16,22 @@ module ActiveRecord
           values[always_initialized] = nil
         end
 
-        attributes = LazyAttributeHash.new(types, values, additional_types)
+        attributes = LazyAttributeHash.new(types, values, additional_types, &default)
         AttributeSet.new(attributes)
       end
     end
   end
 
   class LazyAttributeHash # :nodoc:
-    delegate :transform_values, :each_key, to: :materialize
+    delegate :transform_values, :each_key, :fetch, to: :materialize
 
-    def initialize(types, values, additional_types)
+    def initialize(types, values, additional_types, &default)
       @types = types
       @values = values
       @additional_types = additional_types
       @materialized = false
       @delegate_hash = {}
+      @default = default || proc {}
     end
 
     def key?(key)
@@ -76,9 +78,29 @@ module ActiveRecord
       end
     end
 
+    def marshal_dump
+      materialize
+    end
+
+    def marshal_load(delegate_hash)
+      @delegate_hash = delegate_hash
+      @types = {}
+      @values = {}
+      @additional_types = {}
+      @materialized = true
+    end
+
+    def encode_with(coder)
+      coder["delegate_hash"] = materialize
+    end
+
+    def init_with(coder)
+      marshal_load(coder["delegate_hash"])
+    end
+
     protected
 
-    attr_reader :types, :values, :additional_types, :delegate_hash
+    attr_reader :types, :values, :additional_types, :delegate_hash, :default
 
     def materialize
       unless @materialized
@@ -101,7 +123,7 @@ module ActiveRecord
       if value_present
         delegate_hash[name] = Attribute.from_database(name, value, type)
       elsif types.key?(name)
-        delegate_hash[name] = Attribute.uninitialized(name, type)
+        delegate_hash[name] = default.call(name) || Attribute.uninitialized(name, type)
       end
     end
   end

data/lib/active_record/attribute_set.rb

@@ -2,6 +2,8 @@ require 'active_record/attribute_set/builder'
 
 module ActiveRecord
   class AttributeSet # :nodoc:
+    delegate :fetch, to: :attributes
+
     def initialize(attributes)
       @attributes = attributes
     end

data/lib/active_record/attributes.rb

@@ -34,10 +34,10 @@ module ActiveRecord
       # is not passed, the previous default value (if any) will be used.
       # Otherwise, the default will be +nil+.
       #
-      # +array+ (PG only) specifies that the type should be an array (see the
+      # +array+ (PostgreSQL only) specifies that the type should be an array (see the
       # examples below).
       #
-      # +range+ (PG only) specifies that the type should be a range (see the
+      # +range+ (PostgreSQL only) specifies that the type should be a range (see the
       # examples below).
       #
       # ==== Examples
@@ -253,7 +253,7 @@ module ActiveRecord
             name,
             value,
             type,
-            _default_attributes[name],
+            _default_attributes.fetch(name.to_s) { nil },
           )
         else
           default_attribute = Attribute.from_database(name, value, type)

data/lib/active_record/autosave_association.rb

@@ -329,26 +329,20 @@ module ActiveRecord
         return true if record.destroyed? || (reflection.options[:autosave] && record.marked_for_destruction?)
 
         validation_context = self.validation_context unless [:create, :update].include?(self.validation_context)
+
         unless valid = record.valid?(validation_context)
           if reflection.options[:autosave]
             indexed_attribute = !index.nil? && (reflection.options[:index_errors] || ActiveRecord::Base.index_nested_attribute_errors)
 
             record.errors.each do |attribute, message|
-              if indexed_attribute
-                attribute = "#{reflection.name}[#{index}].#{attribute}"
-              else
-                attribute = "#{reflection.name}.#{attribute}"
-              end
+              attribute = normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
               errors[attribute] << message
               errors[attribute].uniq!
             end
 
             record.errors.details.each_key do |attribute|
-              if indexed_attribute
-                reflection_attribute = "#{reflection.name}[#{index}].#{attribute}"
-              else
-                reflection_attribute = "#{reflection.name}.#{attribute}"
-              end
+              reflection_attribute =
+                normalize_reflection_attribute(indexed_attribute, reflection, index, attribute).to_sym
 
               record.errors.details[attribute].each do |error|
                 errors.details[reflection_attribute] << error
@@ -362,6 +356,14 @@ module ActiveRecord
         valid
       end
 
+      def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
+        if indexed_attribute
+          "#{reflection.name}[#{index}].#{attribute}"
+        else
+          "#{reflection.name}.#{attribute}"
+        end
+      end
+
       # Is used as a before_save callback to check while saving a collection
       # association whether or not the parent was a new record before saving.
       def before_save_collection_association
@@ -457,7 +459,9 @@ module ActiveRecord
       # In addition, it will destroy the association if it was marked for destruction.
       def save_belongs_to_association(reflection)
         association = association_instance_get(reflection.name)
-        record      = association && association.load_target
+        return unless association && association.loaded? && !association.stale_target?
+
+        record = association.load_target
         if record && !record.destroyed?
           autosave = reflection.options[:autosave]
 

data/lib/active_record/base.rb

@@ -312,8 +312,8 @@ module ActiveRecord #:nodoc:
     include NestedAttributes
     include Aggregations
     include Transactions
-    include NoTouching
     include TouchLater
+    include NoTouching
     include Reflection
     include Serialization
     include Store

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -307,6 +307,7 @@ module ActiveRecord
       end
 
       include MonitorMixin
+      include QueryCache::ConnectionPoolConfiguration
 
       attr_accessor :automatic_reconnect, :checkout_timeout, :schema_cache
       attr_reader :spec, :connections, :size, :reaper
@@ -349,8 +350,7 @@ module ActiveRecord
         # currently in the process of independently establishing connections to the DB.
         @now_connecting = 0
 
-        # A boolean toggle that allows/disallows new connections.
-        @new_cons_enabled = true
+        @threads_blocking_new_connections = 0
 
         @available = ConnectionLeasingQueue.new self
       end
@@ -415,7 +415,10 @@ module ActiveRecord
         with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do
           synchronize do
             @connections.each do |conn|
-              checkin conn
+              if conn.in_use?
+                conn.steal!
+                checkin conn
+              end
               conn.disconnect!
             end
             @connections = []
@@ -442,33 +445,19 @@ module ActiveRecord
       #   connections in the pool within a timeout interval (default duration is
       #   <tt>spec.config[:checkout_timeout] * 2</tt> seconds).
       def clear_reloadable_connections(raise_on_acquisition_timeout = true)
-        num_new_conns_required = 0
-
         with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do
           synchronize do
             @connections.each do |conn|
-              checkin conn
+              if conn.in_use?
+                conn.steal!
+                checkin conn
+              end
               conn.disconnect! if conn.requires_reloading?
             end
             @connections.delete_if(&:requires_reloading?)
-
             @available.clear
-
-            if @connections.size < @size
-              # because of the pruning done by this method, we might be running
-              # low on connections, while threads stuck in queue are helpless
-              # (not being able to establish new connections for themselves),
-              # see also more detailed explanation in +remove+
-              num_new_conns_required = num_waiting_in_queue - @connections.size
-            end
-
-            @connections.each do |conn|
-              @available.add conn
-            end
           end
         end
-
-        bulk_make_new_connections(num_new_conns_required) if num_new_conns_required > 0
       end
 
       # Clears the cache which maps classes and re-connects connections that
@@ -556,17 +545,17 @@ module ActiveRecord
         stale_connections = synchronize do
           @connections.select do |conn|
             conn.in_use? && !conn.owner.alive?
+          end.each do |conn|
+            conn.steal!
           end
         end
 
         stale_connections.each do |conn|
-          synchronize do
-            if conn.active?
-              conn.reset!
-              checkin conn
-            else
-              remove conn
-            end
+          if conn.active?
+            conn.reset!
+            checkin conn
+          else
+            remove conn
           end
         end
       end
@@ -675,13 +664,32 @@ module ActiveRecord
       end
 
       def with_new_connections_blocked
-        previous_value = nil
         synchronize do
-          previous_value, @new_cons_enabled = @new_cons_enabled, false
+          @threads_blocking_new_connections += 1
         end
+
         yield
       ensure
-        synchronize { @new_cons_enabled = previous_value }
+        num_new_conns_required = 0
+
+        synchronize do
+          @threads_blocking_new_connections -= 1
+
+          if @threads_blocking_new_connections.zero?
+            @available.clear
+
+            num_new_conns_required = num_waiting_in_queue
+
+            @connections.each do |conn|
+              next if conn.in_use?
+
+              @available.add conn
+              num_new_conns_required -= 1
+            end
+          end
+        end
+
+        bulk_make_new_connections(num_new_conns_required) if num_new_conns_required > 0
       end
 
       # Acquire a connection by one of 1) immediately removing one
@@ -733,7 +741,7 @@ module ActiveRecord
         # and increment @now_connecting, to prevent overstepping this pool's @size
         # constraint
         do_checkout = synchronize do
-          if @new_cons_enabled && (@connections.size + @now_connecting) < @size
+          if @threads_blocking_new_connections.zero? && (@connections.size + @now_connecting) < @size
             @now_connecting += 1
           end
         end

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -244,7 +244,7 @@ module ActiveRecord
       end
 
       def reset_transaction #:nodoc:
-        @transaction_manager = TransactionManager.new(self)
+        @transaction_manager = ConnectionAdapters::TransactionManager.new(self)
       end
 
       # Register a record with the current transaction so that its after_commit and after_rollback callbacks

data/lib/active_record/connection_adapters/abstract/query_cache.rb

@@ -4,6 +4,9 @@ module ActiveRecord
       class << self
         def included(base) #:nodoc:
           dirties_query_cache base, :insert, :update, :delete, :rollback_to_savepoint, :rollback_db_transaction
+
+          base.set_callback :checkout, :after, :configure_query_cache!
+          base.set_callback :checkin, :after, :disable_query_cache!
         end
 
         def dirties_query_cache(base, *method_names)
@@ -18,6 +21,27 @@ module ActiveRecord
         end
       end
 
+      module ConnectionPoolConfiguration
+        def initialize(*)
+          super
+          @query_cache_enabled = Concurrent::Map.new { false }
+        end
+
+        def enable_query_cache!
+          @query_cache_enabled[connection_cache_key(Thread.current)] = true
+          connection.enable_query_cache! if active_connection?
+        end
+
+        def disable_query_cache!
+          @query_cache_enabled.delete connection_cache_key(Thread.current)
+          connection.disable_query_cache! if active_connection?
+        end
+
+        def query_cache_enabled
+          @query_cache_enabled[connection_cache_key(Thread.current)]
+        end
+      end
+
       attr_reader :query_cache, :query_cache_enabled
 
       def initialize(*)
@@ -41,6 +65,7 @@ module ActiveRecord
 
       def disable_query_cache!
         @query_cache_enabled = false
+        clear_query_cache
       end
 
       # Disable the query cache within the block.
@@ -90,6 +115,10 @@ module ActiveRecord
       def locked?(arel)
         arel.respond_to?(:locked) && arel.locked
       end
+
+      def configure_query_cache!
+        enable_query_cache! if pool.query_cache_enabled
+      end
     end
   end
 end

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -112,19 +112,19 @@ module ActiveRecord
       end
 
       def quoted_true
-        "'t'"
+        "'t'".freeze
       end
 
       def unquoted_true
-        't'
+        't'.freeze
       end
 
       def quoted_false
-        "'f'"
+        "'f'".freeze
       end
 
       def unquoted_false
-        'f'
+        'f'.freeze
       end
 
       # Quote date/time values for use in SQL input. Includes microseconds

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -51,11 +51,12 @@ module ActiveRecord
         options[:primary_key] != default_primary_key
       end
 
-      def defined_for?(options_or_to_table = {})
-        if options_or_to_table.is_a?(Hash)
-          options_or_to_table.all? {|key, value| options[key].to_s == value.to_s }
+      def defined_for?(to_table_ord = nil, to_table: nil, **options)
+        if to_table_ord
+          self.to_table == to_table_ord.to_s
         else
-          to_table == options_or_to_table.to_s
+          (to_table.nil? || to_table.to_s == self.to_table) &&
+            options.all? { |k, v| self.options[k].to_s == v.to_s }
         end
       end
 
@@ -211,7 +212,7 @@ module ActiveRecord
 
       def initialize(name, temporary = false, options = nil, as = nil, comment: nil)
         @columns_hash = {}
-        @indexes = {}
+        @indexes = []
         @foreign_keys = []
         @primary_keys = nil
         @temporary = temporary
@@ -303,7 +304,7 @@ module ActiveRecord
       #   end
       def column(name, type, options = {})
         name = name.to_s
-        type = type.to_sym
+        type = type.to_sym if type
         options = options.dup
 
         if @columns_hash[name] && @columns_hash[name].primary_key?
@@ -327,7 +328,7 @@ module ActiveRecord
       #
       #   index(:account_id, name: 'index_projects_on_account_id')
       def index(column_name, options = {})
-        indexes[column_name] = options
+        indexes << [column_name, options]
       end
 
       def foreign_key(table_name, options = {}) # :nodoc:

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -129,14 +129,9 @@ module ActiveRecord
 
       # Returns just a table's primary key
       def primary_key(table_name)
-        pks = primary_keys(table_name)
-        warn <<-WARNING.strip_heredoc if pks.count > 1
-          WARNING: Rails does not support composite primary key.
-
-          #{table_name} has composite primary key. Composite primary key is ignored.
-        WARNING
-
-        pks.first if pks.one?
+        pk = primary_keys(table_name)
+        pk = pk.first unless pk.size > 1
+        pk
       end
 
       # Creates a new table with the name +table_name+. +table_name+ may either
@@ -283,16 +278,16 @@ module ActiveRecord
         result = execute schema_creation.accept td
 
         unless supports_indexes_in_create?
-          td.indexes.each_pair do |column_name, index_options|
+          td.indexes.each do |column_name, index_options|
             add_index(table_name, column_name, index_options)
           end
         end
 
         if supports_comments? && !supports_comments_in_create?
-          change_table_comment(table_name, comment) if comment
+          change_table_comment(table_name, comment) if comment.present?
 
           td.columns.each do |column|
-            change_column_comment(table_name, column.name, column.comment) if column.comment
+            change_column_comment(table_name, column.name, column.comment) if column.comment.present?
           end
         end
 
@@ -790,7 +785,7 @@ module ActiveRecord
       # [<tt>:type</tt>]
       #   The reference column type. Defaults to +:integer+.
       # [<tt>:index</tt>]
-      #   Add an appropriate index. Defaults to false.  
+      #   Add an appropriate index. Defaults to true.
       #   See #add_index for usage of this option.
       # [<tt>:foreign_key</tt>]
       #   Add an appropriate foreign key constraint. Defaults to false.
@@ -847,14 +842,19 @@ module ActiveRecord
       #
       #   remove_reference(:products, :user, index: true, foreign_key: true)
       #
-      def remove_reference(table_name, ref_name, options = {})
-        if options[:foreign_key]
+      def remove_reference(table_name, ref_name, foreign_key: false, polymorphic: false, **options)
+        if foreign_key
           reference_name = Base.pluralize_table_names ? ref_name.to_s.pluralize : ref_name
-          remove_foreign_key(table_name, reference_name)
+          if foreign_key.is_a?(Hash)
+            foreign_key_options = foreign_key
+          else
+            foreign_key_options = { to_table: reference_name }
+          end
+          remove_foreign_key(table_name, **foreign_key_options)
         end
 
         remove_column(table_name, "#{ref_name}_id")
-        remove_column(table_name, "#{ref_name}_type") if options[:polymorphic]
+        remove_column(table_name, "#{ref_name}_type") if polymorphic
       end
       alias :remove_belongs_to :remove_reference
 
@@ -993,8 +993,8 @@ module ActiveRecord
         sm_table = ActiveRecord::Migrator.schema_migrations_table_name
 
         if supports_multi_insert?
-          sql = "INSERT INTO #{sm_table} (version) VALUES "
-          sql << versions.map {|v| "('#{v}')" }.join(', ')
+          sql = "INSERT INTO #{sm_table} (version) VALUES\n"
+          sql << versions.map {|v| "('#{v}')" }.join(",\n")
           sql << ";\n\n"
           sql
         else
@@ -1043,7 +1043,8 @@ module ActiveRecord
       end
 
       def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
-        if native = native_database_types[type.to_sym]
+        type = type.to_sym if type
+        if native = native_database_types[type]
           column_type_sql = (native.is_a?(Hash) ? native[:name] : native).dup
 
           if type == :decimal # ignore limit, use precision and scale
@@ -1163,31 +1164,35 @@ module ActiveRecord
       end
 
       protected
-        def add_index_sort_order(option_strings, column_names, options = {})
-          if options.is_a?(Hash) && order = options[:order]
+
+        def add_index_sort_order(quoted_columns, **options)
+          if order = options[:order]
             case order
             when Hash
-              column_names.each {|name| option_strings[name] += " #{order[name].upcase}" if order.has_key?(name)}
+              order = order.symbolize_keys
+              quoted_columns.each { |name, column| column << " #{order[name].upcase}" if order[name].present? }
             when String
-              column_names.each {|name| option_strings[name] += " #{order.upcase}"}
+              quoted_columns.each { |name, column| column << " #{order.upcase}" if order.present? }
             end
           end
 
-          return option_strings
+          quoted_columns
         end
 
         # Overridden by the MySQL adapter for supporting index lengths
-        def quoted_columns_for_index(column_names, options = {})
-          return [column_names] if column_names.is_a?(String)
-
-          option_strings = Hash[column_names.map {|name| [name, '']}]
-
-          # add index sort order if supported
+        def add_options_for_index_columns(quoted_columns, **options)
           if supports_index_sort_order?
-            option_strings = add_index_sort_order(option_strings, column_names, options)
+            quoted_columns = add_index_sort_order(quoted_columns, options)
           end
 
-          column_names.map {|name| quote_column_name(name) + option_strings[name]}
+          quoted_columns
+        end
+
+        def quoted_columns_for_index(column_names, **options)
+          return [column_names] if column_names.is_a?(String)
+
+          quoted_columns = Hash[column_names.map { |name| [name.to_sym, quote_column_name(name).dup] }]
+          add_options_for_index_columns(quoted_columns, options).values
         end
 
         def index_name_for_remove(table_name, options = {})
@@ -1210,7 +1215,7 @@ module ActiveRecord
             checks << lambda { |i| i.columns.join('_and_') == column_names.join('_and_') }
           end
 
-          raise ArgumentError "No name or columns specified" if checks.none?
+          raise ArgumentError, "No name or columns specified" if checks.none?
 
           matching_indexes = indexes(table_name).select { |i| checks.all? { |check| check[i] } }