activerecord 5.0.0 → 5.0.1

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -61,18 +61,18 @@ module ActiveRecord
     # Most of the methods in the adapter are useful during migrations. Most
     # notably, the instance methods provided by SchemaStatements are very useful.
     class AbstractAdapter
-      ADAPTER_NAME = 'Abstract'.freeze
+      ADAPTER_NAME = "Abstract".freeze
+      include ActiveSupport::Callbacks
+      define_callbacks :checkout, :checkin
+
       include Quoting, DatabaseStatements, SchemaStatements
       include DatabaseLimits
       include QueryCache
-      include ActiveSupport::Callbacks
       include ColumnDumper
       include Savepoints
 
       SIMPLE_INT = /\A\d+\z/
 
-      define_callbacks :checkout, :checkin
-
       attr_accessor :visitor, :pool
       attr_reader :schema_cache, :owner, :logger
       alias :in_use? :owner
@@ -184,7 +184,30 @@ module ActiveRecord
 
       # this method must only be called while holding connection pool's mutex
       def expire
-        @owner = nil
+        if in_use?
+          if @owner != Thread.current
+            raise ActiveRecordError, "Cannot expire connection, " <<
+              "it is owned by a different thread: #{@owner}. " <<
+              "Current thread: #{Thread.current}."
+          end
+
+          @owner = nil
+        else
+          raise ActiveRecordError, 'Cannot expire connection, it is not currently leased.'
+        end
+      end
+
+      # this method must only be called while holding connection pool's mutex (and a desire for segfaults)
+      def steal! # :nodoc:
+        if in_use?
+          if @owner != Thread.current
+            pool.send :remove_connection_from_thread_cache, self, @owner
+
+            @owner = Thread.current
+          end
+        else
+          raise ActiveRecordError, 'Cannot steal connection, it is not currently leased.'
+        end
       end
 
       def unprepared_statement

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -383,11 +383,11 @@ module ActiveRecord
               mysql_index_type = row[:Index_type].downcase.to_sym
               index_type  = INDEX_TYPES.include?(mysql_index_type)  ? mysql_index_type : nil
               index_using = INDEX_USINGS.include?(mysql_index_type) ? mysql_index_type : nil
-              indexes << IndexDefinition.new(row[:Table], row[:Key_name], row[:Non_unique].to_i == 0, [], [], nil, nil, index_type, index_using, row[:Index_comment].presence)
+              indexes << IndexDefinition.new(row[:Table], row[:Key_name], row[:Non_unique].to_i == 0, [], {}, nil, nil, index_type, index_using, row[:Index_comment].presence)
             end
 
             indexes.last.columns << row[:Column_name]
-            indexes.last.lengths << row[:Sub_part]
+            indexes.last.lengths.merge!(row[:Column_name] => row[:Sub_part].to_i) if row[:Sub_part]
           end
         end
 
@@ -409,10 +409,13 @@ module ActiveRecord
       end
 
       def table_comment(table_name) # :nodoc:
+        schema, name = extract_schema_qualified_name(table_name)
+
         select_value(<<-SQL.strip_heredoc, 'SCHEMA')
           SELECT table_comment
           FROM information_schema.tables
-          WHERE table_name=#{quote(table_name)}
+          WHERE table_schema = #{quote(schema)}
+            AND table_name = #{quote(name)}
         SQL
       end
 
@@ -460,7 +463,6 @@ module ActiveRecord
       # it can be helpful to provide these in a migration's +change+ method so it can be reverted.
       # In that case, +options+ and the block will be used by create_table.
       def drop_table(table_name, options = {})
-        create_table_info_cache.delete(table_name) if create_table_info_cache.key?(table_name)
         execute "DROP#{' TEMPORARY' if options[:temporary]} TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
       end
 
@@ -506,7 +508,7 @@ module ActiveRecord
       end
 
       def add_sql_comment!(sql, comment) # :nodoc:
-        sql << " COMMENT #{quote(comment)}" if comment
+        sql << " COMMENT #{quote(comment)}" if comment.present?
         sql
       end
 
@@ -515,19 +517,21 @@ module ActiveRecord
 
         schema, name = extract_schema_qualified_name(table_name)
 
-        fk_info = select_all <<-SQL.strip_heredoc
-          SELECT fk.referenced_table_name as 'to_table'
-                ,fk.referenced_column_name as 'primary_key'
-                ,fk.column_name as 'column'
-                ,fk.constraint_name as 'name'
+        fk_info = select_all(<<-SQL.strip_heredoc, 'SCHEMA')
+          SELECT fk.referenced_table_name AS 'to_table',
+                 fk.referenced_column_name AS 'primary_key',
+                 fk.column_name AS 'column',
+                 fk.constraint_name AS 'name',
+                 rc.update_rule AS 'on_update',
+                 rc.delete_rule AS 'on_delete'
           FROM information_schema.key_column_usage fk
-          WHERE fk.referenced_column_name is not null
+          JOIN information_schema.referential_constraints rc
+          USING (constraint_schema, constraint_name)
+          WHERE fk.referenced_column_name IS NOT NULL
             AND fk.table_schema = #{quote(schema)}
             AND fk.table_name = #{quote(name)}
         SQL
 
-        create_table_info = create_table_info(table_name)
-
         fk_info.map do |row|
           options = {
             column: row['column'],
@@ -535,14 +539,16 @@ module ActiveRecord
             primary_key: row['primary_key']
           }
 
-          options[:on_update] = extract_foreign_key_action(create_table_info, row['name'], "UPDATE")
-          options[:on_delete] = extract_foreign_key_action(create_table_info, row['name'], "DELETE")
+          options[:on_update] = extract_foreign_key_action(row['on_update'])
+          options[:on_delete] = extract_foreign_key_action(row['on_delete'])
 
           ForeignKeyDefinition.new(table_name, row['to_table'], options)
         end
       end
 
-      def table_options(table_name)
+      def table_options(table_name) # :nodoc:
+        table_options = {}
+
         create_table_info = create_table_info(table_name)
 
         # strip create_definitions and partition_options
@@ -551,10 +557,14 @@ module ActiveRecord
         # strip AUTO_INCREMENT
         raw_table_options.sub!(/(ENGINE=\w+)(?: AUTO_INCREMENT=\d+)/, '\1')
 
+        table_options[:options] = raw_table_options
+
         # strip COMMENT
-        raw_table_options.sub!(/ COMMENT='.+'/, '')
+        if raw_table_options.sub!(/ COMMENT='.+'/, '')
+          table_options[:comment] = table_comment(table_name)
+        end
 
-        raw_table_options
+        table_options
       end
 
       # Maps logical Rails types to MySQL-specific data types.
@@ -682,7 +692,7 @@ module ActiveRecord
 
       def register_integer_type(mapping, key, options) # :nodoc:
         mapping.register_type(key) do |sql_type|
-          if /\bunsigned\z/ === sql_type
+          if /\bunsigned\b/ === sql_type
             Type::UnsignedInteger.new(options)
           else
             Type::Integer.new(options)
@@ -702,29 +712,23 @@ module ActiveRecord
         MySQL::TypeMetadata.new(super(sql_type), extra: extra, strict: strict_mode?)
       end
 
-      def add_index_length(option_strings, column_names, options = {})
-        if options.is_a?(Hash) && length = options[:length]
+      def add_index_length(quoted_columns, **options)
+        if length = options[:length]
           case length
           when Hash
-            column_names.each {|name| option_strings[name] += "(#{length[name]})" if length.has_key?(name) && length[name].present?}
+            length = length.symbolize_keys
+            quoted_columns.each { |name, column| column << "(#{length[name]})" if length[name].present? }
           when Integer
-            column_names.each {|name| option_strings[name] += "(#{length})"}
+            quoted_columns.each { |name, column| column << "(#{length})" }
           end
         end
 
-        return option_strings
+        quoted_columns
       end
 
-      def quoted_columns_for_index(column_names, options = {})
-        option_strings = Hash[column_names.map {|name| [name, '']}]
-
-        # add index length
-        option_strings = add_index_length(option_strings, column_names, options)
-
-        # add index sort order
-        option_strings = add_index_sort_order(option_strings, column_names, options)
-
-        column_names.map {|name| quote_column_name(name) + option_strings[name]}
+      def add_options_for_index_columns(quoted_columns, **options)
+        quoted_columns = add_index_length(quoted_columns, options)
+        super
       end
 
       def translate_exception(exception, message)
@@ -883,21 +887,15 @@ module ActiveRecord
         end
       end
 
-      def extract_foreign_key_action(structure, name, action) # :nodoc:
-        if structure =~ /CONSTRAINT #{quote_column_name(name)} FOREIGN KEY .* REFERENCES .* ON #{action} (CASCADE|SET NULL|RESTRICT)/
-          case $1
-          when 'CASCADE'; :cascade
-          when 'SET NULL'; :nullify
-          end
+      def extract_foreign_key_action(specifier) # :nodoc:
+        case specifier
+        when 'CASCADE'; :cascade
+        when 'SET NULL'; :nullify
         end
       end
 
-      def create_table_info_cache # :nodoc:
-        @create_table_info_cache ||= {}
-      end
-
       def create_table_info(table_name) # :nodoc:
-        create_table_info_cache[table_name] ||= select_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")["Create Table"]
+        select_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")["Create Table"]
       end
 
       def create_table_definition(*args) # :nodoc:

data/lib/active_record/connection_adapters/mysql/column.rb

@@ -20,7 +20,7 @@ module ActiveRecord
         end
 
         def unsigned?
-          /\bunsigned\z/ === sql_type
+          /\A(?:enum|set)\b/ !~ sql_type && /\bunsigned\b/ === sql_type
         end
 
         def case_sensitive?

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

@@ -13,19 +13,6 @@ module ActiveRecord
           result
         end
 
-        # Returns a record hash with the column names as keys and column values
-        # as values.
-        def select_one(arel, name = nil, binds = [])
-          arel, binds = binds_from_relation(arel, binds)
-          @connection.query_options.merge!(as: :hash)
-          select_result(to_sql(arel, binds), name, binds) do |result|
-            @connection.next_result while @connection.more_results?
-            result.first
-          end
-        ensure
-          @connection.query_options.merge!(as: :array)
-        end
-
         # Returns an array of arrays containing the field values.
         # Order is the same as that returned by +columns+.
         def select_rows(sql, name = nil, binds = [])
@@ -37,11 +24,9 @@ module ActiveRecord
 
         # Executes the SQL statement in the context of this connection.
         def execute(sql, name = nil)
-          if @connection
-            # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
-            # made since we established the connection
-            @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
-          end
+          # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+          # made since we established the connection
+          @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
 
           super
         end
@@ -84,11 +69,9 @@ module ActiveRecord
         end
 
         def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
-          if @connection
-            # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
-            # made since we established the connection
-            @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
-          end
+          # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+          # made since we established the connection
+          @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
 
           type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
 

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

@@ -2,7 +2,7 @@ module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module Quoting # :nodoc:
-        QUOTED_TRUE, QUOTED_FALSE = '1', '0'
+        QUOTED_TRUE, QUOTED_FALSE = '1'.freeze, '0'.freeze
 
         def quote_column_name(name)
           @quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -90,7 +90,6 @@ module ActiveRecord
       #++
 
       def active?
-        return false unless @connection
         @connection.ping
       end
 
@@ -105,10 +104,7 @@ module ActiveRecord
       # Otherwise, this method does nothing.
       def disconnect!
         super
-        unless @connection.nil?
-          @connection.close
-          @connection = nil
-        end
+        @connection.close
       end
 
       private

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

@@ -124,6 +124,8 @@ module ActiveRecord
             pk = primary_key(table_ref) if table_ref
           end
 
+          pk = suppress_composite_primary_key(pk)
+
           if pk && use_insert_returning?
             sql = "#{sql} RETURNING #{quote_column_name(pk)}"
           end
@@ -164,6 +166,12 @@ module ActiveRecord
         def exec_rollback_db_transaction
           execute "ROLLBACK"
         end
+
+        private
+
+        def suppress_composite_primary_key(pk)
+          pk unless pk.is_a?(Array)
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/postgresql/oid/array.rb

@@ -33,7 +33,11 @@ module ActiveRecord
 
           def serialize(value)
             if value.is_a?(::Array)
-              @pg_encoder.encode(type_cast_array(value, :serialize))
+              result = @pg_encoder.encode(type_cast_array(value, :serialize))
+              if encoding = determine_encoding_of_strings(value)
+                result.force_encoding(encoding)
+              end
+              result
             else
               super
             end
@@ -63,6 +67,13 @@ module ActiveRecord
               @subtype.public_send(method, value)
             end
           end
+
+          def determine_encoding_of_strings(value)
+            case value
+            when ::Array then determine_encoding_of_strings(value.first)
+            when ::String then value.encoding
+            end
+          end
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql/oid/bit.rb

@@ -7,7 +7,7 @@ module ActiveRecord
             :bit
           end
 
-          def cast(value)
+          def cast_value(value)
             if ::String === value
               case value
               when /^0x/i
@@ -16,7 +16,7 @@ module ActiveRecord
                 value                    # Bit-string notation
               end
             else
-              value
+              value.to_s
             end
           end
 

data/lib/active_record/connection_adapters/postgresql/oid/hstore.rb

@@ -24,6 +24,8 @@ module ActiveRecord
           def serialize(value)
             if value.is_a?(::Hash)
               value.map { |k, v| "#{escape_hstore(k)}=>#{escape_hstore(v)}" }.join(', ')
+            elsif value.respond_to?(:to_unsafe_h)
+              serialize(value.to_unsafe_h)
             else
               value
             end

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

@@ -238,6 +238,12 @@ module ActiveRecord
           PostgreSQLColumn.new(*args)
         end
 
+        def table_options(table_name) # :nodoc:
+          if comment = table_comment(table_name)
+            { comment: comment }
+          end
+        end
+
         # Returns a comment stored in database for given table
         def table_comment(table_name) # :nodoc:
           name = Utils.extract_schema_qualified_name(table_name.to_s)
@@ -579,7 +585,7 @@ module ActiveRecord
         end
 
         def foreign_keys(table_name)
-          fk_info = select_all <<-SQL.strip_heredoc
+          fk_info = select_all(<<-SQL.strip_heredoc, 'SCHEMA')
             SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
             FROM pg_constraint c
             JOIN pg_class t1 ON c.conrelid = t1.oid

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -764,11 +764,15 @@ module ActiveRecord
           @case_insensitive_cache[column.sql_type] ||= begin
             sql = <<-end_sql
               SELECT exists(
+                SELECT * FROM pg_proc
+                WHERE proname = 'lower'
+                  AND proargtypes = ARRAY[#{quote column.sql_type}::regtype]::oidvector
+              ) OR exists(
                 SELECT * FROM pg_proc
                 INNER JOIN pg_cast
-                  ON casttarget::text::oidvector = proargtypes
+                  ON ARRAY[casttarget]::oidvector = proargtypes
                 WHERE proname = 'lower'
-                  AND castsource = '#{column.sql_type}'::regtype::oid
+                  AND castsource = #{quote column.sql_type}::regtype
               )
             end_sql
             execute_and_clear(sql, "SCHEMA", []) do |result|

data/lib/active_record/core.rb

@@ -310,8 +310,8 @@ module ActiveRecord
     #   # Instantiates a single new object
     #   User.new(first_name: 'Jamie')
     def initialize(attributes = nil)
-      @attributes = self.class._default_attributes.deep_dup
       self.class.define_attribute_methods
+      @attributes = self.class._default_attributes.deep_dup
 
       init_internals
       initialize_internals_callback
@@ -346,6 +346,8 @@ module ActiveRecord
 
       self.class.define_attribute_methods
 
+      yield self if block_given?
+
       _run_find_callbacks
       _run_initialize_callbacks
 

data/lib/active_record/enum.rb

@@ -159,8 +159,9 @@ module ActiveRecord
         detect_enum_conflict!(name, name)
         detect_enum_conflict!(name, "#{name}=")
 
-        decorate_attribute_type(name, :enum) do |subtype|
-          EnumType.new(name, enum_values, subtype)
+        attr = attribute_alias?(name) ? attribute_alias(name) : name
+        decorate_attribute_type(attr, :enum) do |subtype|
+          EnumType.new(attr, enum_values, subtype)
         end
 
         _enum_methods_module.module_eval do
@@ -182,15 +183,15 @@ module ActiveRecord
 
             # def active?() status == 0 end
             klass.send(:detect_enum_conflict!, name, "#{value_method_name}?")
-            define_method("#{value_method_name}?") { self[name] == value.to_s }
+            define_method("#{value_method_name}?") { self[attr] == value.to_s }
 
             # def active!() update! status: :active end
             klass.send(:detect_enum_conflict!, name, "#{value_method_name}!")
-            define_method("#{value_method_name}!") { update! name => value }
+            define_method("#{value_method_name}!") { update!(attr => value) }
 
             # scope :active, -> { where status: 0 }
             klass.send(:detect_enum_conflict!, name, value_method_name, true)
-            klass.scope value_method_name, -> { where(name => value) }
+            klass.scope value_method_name, -> { where(attr => value) }
           end
         end
         defined_enums[name.to_s] = enum_values

data/lib/active_record/gem_version.rb

@@ -7,7 +7,7 @@ module ActiveRecord
   module VERSION
     MAJOR = 5
     MINOR = 0
-    TINY  = 0
+    TINY  = 1
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/active_record/integration.rb

@@ -53,18 +53,21 @@ module ActiveRecord
     #
     #   Person.find(5).cache_key(:updated_at, :last_reviewed_at)
     def cache_key(*timestamp_names)
-      case
-      when new_record?
+      if new_record?
         "#{model_name.cache_key}/new"
-      when timestamp_names.any?
-        timestamp = max_updated_column_timestamp(timestamp_names)
-        timestamp = timestamp.utc.to_s(cache_timestamp_format)
-        "#{model_name.cache_key}/#{id}-#{timestamp}"
-      when timestamp = max_updated_column_timestamp
-        timestamp = timestamp.utc.to_s(cache_timestamp_format)
-        "#{model_name.cache_key}/#{id}-#{timestamp}"
       else
-        "#{model_name.cache_key}/#{id}"
+        timestamp = if timestamp_names.any?
+          max_updated_column_timestamp(timestamp_names)
+        else
+          max_updated_column_timestamp
+        end
+
+        if timestamp
+          timestamp = timestamp.utc.to_s(cache_timestamp_format)
+          "#{model_name.cache_key}/#{id}-#{timestamp}"
+        else
+          "#{model_name.cache_key}/#{id}"
+        end
       end
     end
 

data/lib/active_record/migration.rb

@@ -1,5 +1,6 @@
+require "set"
+require "zlib"
 require "active_support/core_ext/module/attribute_accessors"
-require 'set'
 
 module ActiveRecord
   class MigrationError < ActiveRecordError#:nodoc:
@@ -126,9 +127,9 @@ module ActiveRecord
   class PendingMigrationError < MigrationError#:nodoc:
     def initialize(message = nil)
       if !message && defined?(Rails.env)
-        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rails db:migrate RAILS_ENV=#{::Rails.env}")
+        super("Migrations are pending. To resolve this issue, run:\n\n        bin/rails db:migrate RAILS_ENV=#{::Rails.env}")
       elsif !message
-        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rails db:migrate")
+        super("Migrations are pending. To resolve this issue, run:\n\n        bin/rails db:migrate")
       else
         super
       end
@@ -145,7 +146,7 @@ module ActiveRecord
 
   class NoEnvironmentInSchemaError < MigrationError #:nodoc:
     def initialize
-      msg = "Environment data not found in the schema. To resolve this issue, run: \n\n\tbin/rails db:environment:set"
+      msg = "Environment data not found in the schema. To resolve this issue, run: \n\n        bin/rails db:environment:set"
       if defined?(Rails.env)
         super("#{msg} RAILS_ENV=#{::Rails.env}")
       else
@@ -168,7 +169,7 @@ module ActiveRecord
       msg =  "You are attempting to modify a database that was last run in `#{ stored }` environment.\n"
       msg << "You are running in `#{ current }` environment. "
       msg << "If you are sure you want to continue, first set the environment using:\n\n"
-      msg << "\tbin/rails db:environment:set"
+      msg << "        bin/rails db:environment:set"
       if defined?(Rails.env)
         super("#{msg} RAILS_ENV=#{::Rails.env}\n\n")
       else