activerecord 5.0.0 → 5.0.7.2

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -68,7 +68,7 @@ module ActiveRecord
         @statements = StatementPool.new(self.class.type_cast_config_to_integer(config[:statement_limit]))
 
         if version < '5.0.0'
-          raise "Your version of MySQL (#{full_version.match(/^\d+\.\d+\.\d+/)[0]}) is too old. Active Record supports MySQL >= 5.0."
+          raise "Your version of MySQL (#{version_string}) is too old. Active Record supports MySQL >= 5.0."
         end
       end
 
@@ -81,7 +81,7 @@ module ActiveRecord
       end
 
       def version #:nodoc:
-        @version ||= Version.new(full_version.match(/^\d+\.\d+\.\d+/)[0])
+        @version ||= Version.new(version_string)
       end
 
       def mariadb? # :nodoc:
@@ -324,7 +324,7 @@ module ActiveRecord
 
       def data_sources
         sql = "SELECT table_name FROM information_schema.tables "
-        sql << "WHERE table_schema = #{quote(@config[:database])}"
+        sql << "WHERE table_schema = DATABASE()"
 
         select_values(sql, 'SCHEMA')
       end
@@ -350,7 +350,7 @@ module ActiveRecord
         schema, name = extract_schema_qualified_name(table_name)
 
         sql = "SELECT table_name FROM information_schema.tables "
-        sql << "WHERE table_schema = #{quote(schema)} AND table_name = #{quote(name)}"
+        sql << "WHERE table_schema = #{schema} AND table_name = #{name}"
 
         select_values(sql, 'SCHEMA').any?
       end
@@ -365,7 +365,7 @@ module ActiveRecord
         schema, name = extract_schema_qualified_name(view_name)
 
         sql = "SELECT table_name FROM information_schema.tables WHERE table_type = 'VIEW'"
-        sql << " AND table_schema = #{quote(schema)} AND table_name = #{quote(name)}"
+        sql << " AND table_schema = #{schema} AND table_name = #{name}"
 
         select_values(sql, 'SCHEMA').any?
       end
@@ -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
 
@@ -399,8 +399,8 @@ module ActiveRecord
         table_name = table_name.to_s
         column_definitions(table_name).map do |field|
           type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
-          if type_metadata.type == :datetime && field[:Default] == "CURRENT_TIMESTAMP"
-            default, default_function = nil, field[:Default]
+          if type_metadata.type == :datetime && field[:Default] =~ /\ACURRENT_TIMESTAMP(?:\(\))?\z/i
+            default, default_function = nil, "CURRENT_TIMESTAMP"
           else
             default, default_function = field[:Default], nil
           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 = #{schema}
+            AND table_name = #{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,22 @@ 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
-            AND fk.table_schema = #{quote(schema)}
-            AND fk.table_name = #{quote(name)}
+          JOIN information_schema.referential_constraints rc
+          USING (constraint_schema, constraint_name)
+          WHERE fk.referenced_column_name IS NOT NULL
+            AND fk.table_schema = #{schema}
+            AND fk.table_name = #{name}
+            AND rc.table_name = #{name}
         SQL
 
-        create_table_info = create_table_info(table_name)
-
         fk_info.map do |row|
           options = {
             column: row['column'],
@@ -535,14 +540,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 +558,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.
@@ -596,8 +607,8 @@ module ActiveRecord
           SELECT column_name
           FROM information_schema.key_column_usage
           WHERE constraint_name = 'PRIMARY'
-            AND table_schema = #{quote(schema)}
-            AND table_name = #{quote(name)}
+            AND table_schema = #{schema}
+            AND table_name = #{name}
           ORDER BY ordinal_position
         SQL
       end
@@ -682,7 +693,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 +713,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)
@@ -831,9 +836,9 @@ module ActiveRecord
         variables['sql_auto_is_null'] = 0
 
         # Increase timeout so the server doesn't disconnect us.
-        wait_timeout = @config[:wait_timeout]
+        wait_timeout = self.class.type_cast_config_to_integer(@config[:wait_timeout])
         wait_timeout = 2147483 unless wait_timeout.is_a?(Integer)
-        variables['wait_timeout'] = self.class.type_cast_config_to_integer(wait_timeout)
+        variables["wait_timeout"] = wait_timeout
 
         defaults = [':default', :default].to_set
 
@@ -883,21 +888,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:
@@ -905,8 +904,8 @@ module ActiveRecord
       end
 
       def extract_schema_qualified_name(string) # :nodoc:
-        schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
-        schema, name = @config[:database], schema unless name
+        schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/).map { |s| quote(s) }
+        schema, name = "DATABASE()", schema unless name
         [schema, name]
       end
 
@@ -941,6 +940,10 @@ module ActiveRecord
         end
       end
 
+      def version_string
+        full_version.match(/^(?:5\.5\.5-)?(\d+\.\d+\.\d+)/)[1]
+      end
+
       class MysqlJson < Type::Internal::AbstractJson # :nodoc:
         def changed_in_place?(raw_old_value, new_value)
           # Normalization is required because MySQL JSON data format includes

data/lib/active_record/connection_adapters/column.rb

@@ -13,7 +13,7 @@ module ActiveRecord
       # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
       # +sql_type_metadata+ is various information about the type of the column
       # +null+ determines if this column allows +NULL+ values.
-      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil)
+      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil, **)
         @name = name.freeze
         @table_name = table_name
         @sql_type_metadata = sql_type_metadata

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,15 +69,13 @@ 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) }
+          type_casted_binds = type_casted_binds(binds)
 
-          log(sql, name, binds) do
+          log(sql, name, binds, type_casted_binds) do
             if cache_stmt
               cache = @statements[sql] ||= {
                 stmt: @connection.prepare(sql)

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

@@ -1,7 +1,7 @@
 require 'active_record/connection_adapters/abstract_mysql_adapter'
 require 'active_record/connection_adapters/mysql/database_statements'
 
-gem 'mysql2', '>= 0.3.18', '< 0.5'
+gem 'mysql2', '>= 0.3.18', '< 0.6.0'
 require 'mysql2'
 raise 'mysql2 0.4.3 is not supported. Please upgrade to 0.4.4+' if Mysql2::VERSION == '0.4.3'
 
@@ -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/column.rb

@@ -5,11 +5,38 @@ module ActiveRecord
       delegate :array, :oid, :fmod, to: :sql_type_metadata
       alias :array? :array
 
+      def initialize(*, max_identifier_length: 63, **)
+        super
+        @max_identifier_length = max_identifier_length
+      end
+
       def serial?
         return unless default_function
 
-        %r{\Anextval\('"?#{table_name}_#{name}_seq"?'::regclass\)\z} === default_function
+        if %r{\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z} =~ default_function
+          sequence_name_from_parts(table_name, name, suffix) == sequence_name
+        end
       end
+
+      protected
+        attr_reader :max_identifier_length
+
+      private
+        def sequence_name_from_parts(table_name, column_name, suffix)
+          over_length = [table_name, column_name, suffix].map(&:length).sum + 2 - max_identifier_length
+
+          if over_length > 0
+            column_name_length = [(max_identifier_length - suffix.length - 2) / 2, column_name.length].min
+            over_length -= column_name.length - column_name_length
+            column_name = column_name[0, column_name_length - [over_length, 0].min]
+          end
+
+          if over_length > 0
+            table_name = table_name[0, table_name.length - over_length]
+          end
+
+          "#{table_name}_#{column_name}_#{suffix}"
+        end
     end
   end
 end

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

@@ -5,6 +5,8 @@ module ActiveRecord
         class Array < Type::Value # :nodoc:
           include Type::Helpers::Mutable
 
+          Data = Struct.new(:encoder, :values) # :nodoc:
+
           attr_reader :subtype, :delimiter
           delegate :type, :user_input_in_time_zone, :limit, to: :subtype
 
@@ -17,8 +19,11 @@ module ActiveRecord
           end
 
           def deserialize(value)
-            if value.is_a?(::String)
+            case value
+            when ::String
               type_cast_array(@pg_decoder.decode(value), :deserialize)
+            when Data
+              type_cast_array(value.values, :deserialize)
             else
               super
             end
@@ -33,7 +38,8 @@ module ActiveRecord
 
           def serialize(value)
             if value.is_a?(::Array)
-              @pg_encoder.encode(type_cast_array(value, :serialize))
+              casted_values = type_cast_array(value, :serialize)
+              Data.new(@pg_encoder, casted_values)
             else
               super
             end
@@ -54,6 +60,10 @@ module ActiveRecord
             value.map(&block)
           end
 
+          def changed_in_place?(raw_old_value, new_value)
+            deserialize(raw_old_value) != new_value
+          end
+
           private
 
           def type_cast_array(value, method)

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/bytea.rb

@@ -6,7 +6,7 @@ module ActiveRecord
           def deserialize(value)
             return if value.nil?
             return value.to_s if value.is_a?(Type::Binary::Data)
-            PGconn.unescape_bytea(super)
+            PG::Connection.unescape_bytea(super)
           end
         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
@@ -33,6 +35,14 @@ module ActiveRecord
             ActiveRecord::Store::StringKeyedHashAccessor
           end
 
+          # Will compare the Hash equivalents of +raw_old_value+ and +new_value+.
+          # By comparing hashes, this avoids an edge case where the order of
+          # the keys change between the two hashes, and they would not be marked
+          # as equal.
+          def changed_in_place?(raw_old_value, new_value)
+            deserialize(raw_old_value) != new_value
+          end
+
           private
 
           HstorePair = begin

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

@@ -33,7 +33,7 @@ module ActiveRecord
 
         # Quotes schema names for use in SQL queries.
         def quote_schema_name(name)
-          PGconn.quote_ident(name)
+          PG::Connection.quote_ident(name)
         end
 
         def quote_table_name_for_assignment(table, attr)
@@ -42,7 +42,7 @@ module ActiveRecord
 
         # Quotes column names for use in SQL queries.
         def quote_column_name(name) # :nodoc:
-          @quoted_column_names[name] ||= PGconn.quote_ident(super)
+          @quoted_column_names[name] ||= PG::Connection.quote_ident(super)
         end
 
         # Quote date/time values for use in SQL input.
@@ -92,6 +92,8 @@ module ActiveRecord
             else
               super
             end
+            when OID::Array::Data
+              _quote(encode_array(value))
           else
             super
           end
@@ -101,15 +103,42 @@ module ActiveRecord
           case value
           when Type::Binary::Data
             # Return a bind param hash with format as binary.
-            # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
+            # See https://deveiate.org/code/pg/PG/Connection.html#method-i-exec_prepared-doc
             # for more information
             { value: value.to_s, format: 1 }
           when OID::Xml::Data, OID::Bit::Data
             value.to_s
+            when OID::Array::Data
+              encode_array(value)
           else
             super
           end
         end
+
+          def encode_array(array_data)
+            encoder = array_data.encoder
+            values = type_cast_array(array_data.values)
+
+            result = encoder.encode(values)
+            if encoding = determine_encoding_of_strings_in_array(values)
+              result.force_encoding(encoding)
+            end
+            result
+          end
+
+          def determine_encoding_of_strings_in_array(value)
+            case value
+            when ::Array then determine_encoding_of_strings_in_array(value.first)
+            when ::String then value.encoding
+            end
+          end
+
+          def type_cast_array(values)
+            case values
+            when ::Array then values.map { |item| type_cast_array(item) }
+            else _type_cast(values)
+            end
+          end
       end
     end
   end