activerecord 5.0.0.1 → 5.0.1.rc1

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,34 @@ 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)}
+              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 +1214,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] } }
 

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,22 @@ 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?}
+            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 +886,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: