activerecord 5.2.8.1 → 6.0.6

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

@@ -10,6 +10,10 @@ module ActiveRecord
             spec[:unsigned] = "true" if column.unsigned?
             spec[:auto_increment] = "true" if column.auto_increment?
 
+            if /\A(?<size>tiny|medium|long)(?:text|blob)/ =~ column.sql_type
+              spec = { size: size.to_sym.inspect }.merge!(spec)
+            end
+
             if @connection.supports_virtual_columns? && column.virtual?
               spec[:as] = extract_expression_for_virtual_column(column)
               spec[:stored] = "true" if /\b(?:STORED|PERSISTENT)\b/.match?(column.extra)
@@ -37,19 +41,23 @@ module ActiveRecord
             case column.sql_type
             when /\Atimestamp\b/
               :timestamp
-            when "tinyblob"
-              :blob
+            when /\A(?:enum|set)\b/
+              column.sql_type
             else
               super
             end
           end
 
+          def schema_limit(column)
+            super unless /\A(?:enum|set|(?:tiny|medium|long)?(?:text|blob))\b/.match?(column.sql_type)
+          end
+
           def schema_precision(column)
             super unless /\A(?:date)?time(?:stamp)?\b/.match?(column.sql_type) && column.precision == 0
           end
 
           def schema_collation(column)
-            if column.collation && table_name = column.table_name
+            if column.collation
               @table_collation_cache ||= {}
               @table_collation_cache[table_name] ||=
                 @connection.exec_query("SHOW TABLE STATUS LIKE #{@connection.quote(table_name)}", "SCHEMA").first["Collation"]
@@ -58,14 +66,14 @@ module ActiveRecord
           end
 
           def extract_expression_for_virtual_column(column)
-            if @connection.mariadb? && @connection.version < "10.2.5"
-              create_table_info = @connection.send(:create_table_info, column.table_name)
+            if @connection.mariadb? && @connection.database_version < "10.2.5"
+              create_table_info = @connection.send(:create_table_info, table_name)
               column_name = @connection.quote_column_name(column.name)
               if %r/#{column_name} #{Regexp.quote(column.sql_type)}(?: COLLATE \w+)? AS \((?<expression>.+?)\) #{column.extra}/ =~ create_table_info
                 $~[:expression].inspect
               end
             else
-              scope = @connection.send(:quoted_scope, column.table_name)
+              scope = @connection.send(:quoted_scope, table_name)
               column_name = @connection.quote(column.name)
               sql = "SELECT generation_expression FROM information_schema.columns" \
                     " WHERE table_schema = #{scope[:schema]}" \

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

@@ -35,25 +35,55 @@ module ActiveRecord
                 ]
               end
 
-              indexes.last[-2] << row[:Column_name]
-              indexes.last[-1][:lengths].merge!(row[:Column_name] => row[:Sub_part].to_i) if row[:Sub_part]
-              indexes.last[-1][:orders].merge!(row[:Column_name] => :desc) if row[:Collation] == "D"
+              if row[:Expression]
+                expression = row[:Expression]
+                expression = +"(#{expression})" unless expression.start_with?("(")
+                indexes.last[-2] << expression
+                indexes.last[-1][:expressions] ||= {}
+                indexes.last[-1][:expressions][expression] = expression
+                indexes.last[-1][:orders][expression] = :desc if row[:Collation] == "D"
+              else
+                indexes.last[-2] << row[:Column_name]
+                indexes.last[-1][:lengths][row[:Column_name]] = row[:Sub_part].to_i if row[:Sub_part]
+                indexes.last[-1][:orders][row[:Column_name]] = :desc if row[:Collation] == "D"
+              end
             end
           end
 
-          indexes.map { |index| IndexDefinition.new(*index) }
+          indexes.map do |index|
+            options = index.pop
+
+            if expressions = options.delete(:expressions)
+              orders = options.delete(:orders)
+              lengths = options.delete(:lengths)
+
+              columns = index[-1].map { |name|
+                [ name.to_sym, expressions[name] || +quote_column_name(name) ]
+              }.to_h
+
+              index[-1] = add_options_for_index_columns(
+                columns, order: orders, length: lengths
+              ).values.join(", ")
+            end
+
+            IndexDefinition.new(*index, **options)
+          end
         end
 
-        def remove_column(table_name, column_name, type = nil, options = {})
+        def remove_column(table_name, column_name, type = nil, **options)
           if foreign_key_exists?(table_name, column: column_name)
             remove_foreign_key(table_name, column: column_name)
           end
           super
         end
 
+        def create_table(table_name, options: default_row_format, **)
+          super
+        end
+
         def internal_string_options_for_primary_key
           super.tap do |options|
-            if CHARSETS_OF_4BYTES_MAXLEN.include?(charset) && (mariadb? || version < "8.0.0")
+            if !row_format_dynamic_by_default? && CHARSETS_OF_4BYTES_MAXLEN.include?(charset)
               options[:collation] = collation.sub(/\A[^_]+/, "utf8")
             end
           end
@@ -67,23 +97,76 @@ module ActiveRecord
           MySQL::SchemaDumper.create(self, options)
         end
 
+        # Maps logical Rails types to MySQL-specific data types.
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, size: limit_to_size(limit, type), unsigned: nil, **)
+          sql =
+            case type.to_s
+            when "integer"
+              integer_to_sql(limit)
+            when "text"
+              type_with_size_to_sql("text", size)
+            when "blob"
+              type_with_size_to_sql("blob", size)
+            when "binary"
+              if (0..0xfff) === limit
+                "varbinary(#{limit})"
+              else
+                type_with_size_to_sql("blob", size)
+              end
+            else
+              super
+            end
+
+          sql = "#{sql} unsigned" if unsigned && type != :primary_key
+          sql
+        end
+
+        def table_alias_length
+          256 # https://dev.mysql.com/doc/refman/8.0/en/identifiers.html
+        end
+
         private
           CHARSETS_OF_4BYTES_MAXLEN = ["utf8mb4", "utf16", "utf16le", "utf32"]
 
+          def row_format_dynamic_by_default?
+            if mariadb?
+              database_version >= "10.2.2"
+            else
+              database_version >= "5.7.9"
+            end
+          end
+
+          def default_row_format
+            return if row_format_dynamic_by_default?
+
+            unless defined?(@default_row_format)
+              if query_value("SELECT @@innodb_file_per_table = 1 AND @@innodb_file_format = 'Barracuda'") == 1
+                @default_row_format = "ROW_FORMAT=DYNAMIC"
+              else
+                @default_row_format = nil
+              end
+            end
+
+            @default_row_format
+          end
+
           def schema_creation
             MySQL::SchemaCreation.new(self)
           end
 
-          def create_table_definition(*args)
-            MySQL::TableDefinition.new(*args)
+          def create_table_definition(*args, **options)
+            MySQL::TableDefinition.new(self, *args, **options)
           end
 
           def new_column_from_field(table_name, field)
             type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
-            if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(field[:Default])
-              default, default_function = nil, field[:Default]
-            else
-              default, default_function = field[:Default], nil
+            default, default_function = field[:Default], nil
+
+            if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(default)
+              default, default_function = nil, default
+            elsif type_metadata.extra == "DEFAULT_GENERATED"
+              default = +"(#{default})" unless default.start_with?("(")
+              default, default_function = nil, default
             end
 
             MySQL::Column.new(
@@ -91,9 +174,8 @@ module ActiveRecord
               default,
               type_metadata,
               field[:Null] == "YES",
-              table_name,
               default_function,
-              field[:Collation],
+              collation: field[:Collation],
               comment: field[:Comment].presence
             )
           end
@@ -114,17 +196,21 @@ module ActiveRecord
           end
 
           def add_options_for_index_columns(quoted_columns, **options)
-            quoted_columns = add_index_length(quoted_columns, options)
+            quoted_columns = add_index_length(quoted_columns, **options)
             super
           end
 
           def data_source_sql(name = nil, type: nil)
             scope = quoted_scope(name, type: type)
 
-            sql = "SELECT table_name FROM information_schema.tables".dup
-            sql << " WHERE table_schema = #{scope[:schema]}"
-            sql << " AND table_name = #{scope[:name]}" if scope[:name]
-            sql << " AND table_type = #{scope[:type]}" if scope[:type]
+            sql = +"SELECT table_name FROM (SELECT * FROM information_schema.tables "
+            sql << " WHERE table_schema = #{scope[:schema]}) _subquery"
+            if scope[:type] || scope[:name]
+              conditions = []
+              conditions << "_subquery.table_type = #{scope[:type]}" if scope[:type]
+              conditions << "_subquery.table_name = #{scope[:name]}" if scope[:name]
+              sql << " WHERE #{conditions.join(" AND ")}"
+            end
             sql
           end
 
@@ -142,6 +228,40 @@ module ActiveRecord
             schema, name = nil, schema unless name
             [schema, name]
           end
+
+          def type_with_size_to_sql(type, size)
+            case size&.to_s
+            when nil, "tiny", "medium", "long"
+              "#{size}#{type}"
+            else
+              raise ArgumentError,
+                "#{size.inspect} is invalid :size value. Only :tiny, :medium, and :long are allowed."
+            end
+          end
+
+          def limit_to_size(limit, type)
+            case type.to_s
+            when "text", "blob", "binary"
+              case limit
+              when 0..0xff;               "tiny"
+              when nil, 0x100..0xffff;    nil
+              when 0x10000..0xffffff;     "medium"
+              when 0x1000000..0xffffffff; "long"
+              else raise ArgumentError, "No #{type} type has byte size #{limit}"
+              end
+            end
+          end
+
+          def integer_to_sql(limit)
+            case limit
+            when 1; "tinyint"
+            when 2; "smallint"
+            when 3; "mediumint"
+            when nil, 4; "int"
+            when 5..8; "bigint"
+            else raise ArgumentError, "No integer type has byte size #{limit}. Use a decimal with scale 0 instead."
+            end
+          end
       end
     end
   end

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

@@ -10,25 +10,21 @@ module ActiveRecord
 
         def initialize(type_metadata, extra: "")
           super(type_metadata)
-          @type_metadata = type_metadata
           @extra = extra
         end
 
         def ==(other)
-          other.is_a?(MySQL::TypeMetadata) &&
-            attributes_for_hash == other.attributes_for_hash
+          other.is_a?(TypeMetadata) &&
+            __getobj__ == other.__getobj__ &&
+            extra == other.extra
         end
         alias eql? ==
 
         def hash
-          attributes_for_hash.hash
+          TypeMetadata.hash ^
+            __getobj__.hash ^
+            extra.hash
         end
-
-        protected
-
-          def attributes_for_hash
-            [self.class, @type_metadata, extra]
-          end
       end
     end
   end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -3,18 +3,20 @@
 require "active_record/connection_adapters/abstract_mysql_adapter"
 require "active_record/connection_adapters/mysql/database_statements"
 
-gem "mysql2", ">= 0.4.4", "< 0.6.0"
+gem "mysql2", ">= 0.4.4"
 require "mysql2"
 
 module ActiveRecord
   module ConnectionHandling # :nodoc:
+    ER_BAD_DB_ERROR = 1049
+
     # Establishes a connection to the database that's used by all Active Record objects.
     def mysql2_connection(config)
       config = config.symbolize_keys
       config[:flags] ||= 0
 
       if config[:flags].kind_of? Array
-        config[:flags].push "FOUND_ROWS".freeze
+        config[:flags].push "FOUND_ROWS"
       else
         config[:flags] |= Mysql2::Client::FOUND_ROWS
       end
@@ -22,7 +24,7 @@ module ActiveRecord
       client = Mysql2::Client.new(config)
       ConnectionAdapters::Mysql2Adapter.new(client, logger, nil, config)
     rescue Mysql2::Error => error
-      if error.message.include?("Unknown database")
+      if error.error_number == ER_BAD_DB_ERROR
         raise ActiveRecord::NoDatabaseError
       else
         raise
@@ -32,18 +34,24 @@ module ActiveRecord
 
   module ConnectionAdapters
     class Mysql2Adapter < AbstractMysqlAdapter
-      ADAPTER_NAME = "Mysql2".freeze
+      ADAPTER_NAME = "Mysql2"
 
       include MySQL::DatabaseStatements
 
       def initialize(connection, logger, connection_options, config)
-        super
-        @prepared_statements = false unless config.key?(:prepared_statements)
+        superclass_config = config.reverse_merge(prepared_statements: false)
+        super(connection, logger, connection_options, superclass_config)
         configure_connection
       end
 
+      def self.database_exists?(config)
+        !!ActiveRecord::Base.mysql2_connection(config)
+      rescue ActiveRecord::NoDatabaseError
+        false
+      end
+
       def supports_json?
-        !mariadb? && version >= "5.7.8"
+        !mariadb? && database_version >= "5.7.8"
       end
 
       def supports_comments?
@@ -58,6 +66,10 @@ module ActiveRecord
         true
       end
 
+      def supports_lazy_transactions?
+        true
+      end
+
       # HELPER METHODS ===========================================
 
       def each_hash(result) # :nodoc:
@@ -105,24 +117,28 @@ module ActiveRecord
       end
 
       def discard! # :nodoc:
+        super
         @connection.automatic_close = false
         @connection = nil
       end
 
       private
-
         def connect
           @connection = Mysql2::Client.new(@config)
           configure_connection
         end
 
         def configure_connection
-          @connection.query_options.merge!(as: :array)
+          @connection.query_options[:as] = :array
           super
         end
 
         def full_version
-          @full_version ||= @connection.server_info[:version]
+          schema_cache.database_version.full_version_string
+        end
+
+        def get_full_version
+          @connection.server_info[:version]
         end
     end
   end

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

@@ -2,43 +2,29 @@
 
 module ActiveRecord
   module ConnectionAdapters
-    # PostgreSQL-specific extensions to column definitions in a table.
-    class PostgreSQLColumn < Column #:nodoc:
-      delegate :array, :oid, :fmod, to: :sql_type_metadata
-      alias :array? :array
+    module PostgreSQL
+      class Column < ConnectionAdapters::Column # :nodoc:
+        delegate :oid, :fmod, to: :sql_type_metadata
 
-      def initialize(*, max_identifier_length: 63, **)
-        super
-        @max_identifier_length = max_identifier_length
-      end
-
-      def serial?
-        return unless default_function
-
-        if %r{\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z} =~ default_function
-          sequence_name_from_parts(table_name, name, suffix) == sequence_name
+        def initialize(*, serial: nil, **)
+          super
+          @serial = serial
         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
+        def serial?
+          @serial
+        end
 
-          if over_length > 0
-            table_name = table_name[0, table_name.length - over_length]
-          end
+        def array
+          sql_type_metadata.sql_type.end_with?("[]")
+        end
+        alias :array? :array
 
-          "#{table_name}_#{column_name}_#{suffix}"
+        def sql_type
+          super.sub(/\[\]\z/, "")
         end
+      end
     end
+    PostgreSQLColumn = PostgreSQL::Column # :nodoc:
   end
 end

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

@@ -58,6 +58,8 @@ module ActiveRecord
 
         # Queries the database and returns the results in an Array-like object
         def query(sql, name = nil) #:nodoc:
+          materialize_transactions
+
           log(sql, name) do
             ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
               result_as_array @connection.async_exec(sql)
@@ -65,11 +67,26 @@ module ActiveRecord
           end
         end
 
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :close, :declare, :fetch, :move, :set, :show
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        end
+
         # Executes an SQL statement, returning a PG::Result object on success
         # or raising a PG::Error exception otherwise.
         # Note: the PG::Result object is manually memory managed; if you don't
         # need it specifically, you may want consider the <tt>exec_query</tt> wrapper.
         def execute(sql, name = nil)
+          if preventing_writes? && write_query?(sql)
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          end
+
+          materialize_transactions
+
           log(sql, name) do
             ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
               @connection.async_exec(sql)
@@ -95,7 +112,7 @@ module ActiveRecord
         end
         alias :exec_update :exec_delete
 
-        def sql_for_insert(sql, pk, id_value, sequence_name, binds) # :nodoc:
+        def sql_for_insert(sql, pk, binds) # :nodoc:
           if pk.nil?
             # Extract the table from the insert sql. Yuck.
             table_ref = extract_table_ref_from_insert_sql(sql)
@@ -149,6 +166,14 @@ module ActiveRecord
         end
 
         private
+          def execute_batch(statements, name = nil)
+            execute(combine_multi_statements(statements))
+          end
+
+          def build_truncate_statements(table_names)
+            ["TRUNCATE TABLE #{table_names.map(&method(:quote_table_name)).join(", ")}"]
+          end
+
           # Returns the current ID of a table's sequence.
           def last_insert_id_result(sequence_name)
             exec_query("SELECT currval(#{quote(sequence_name)})", "SQL")

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

@@ -5,7 +5,7 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         class Array < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
           Data = Struct.new(:encoder, :values) # :nodoc:
 
@@ -77,7 +77,6 @@ module ActiveRecord
           end
 
           private
-
             def type_cast_array(value, method)
               if value.is_a?(::Array)
                 value.map { |item| type_cast_array(item, method) }

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

@@ -43,10 +43,7 @@ module ActiveRecord
               /\A[0-9A-F]*\Z/i.match?(value)
             end
 
-            # TODO Change this to private once we've dropped Ruby 2.2 support.
-            # Workaround for Ruby 2.2 "private attribute?" warning.
-            protected
-
+            private
               attr_reader :value
           end
         end

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

@@ -16,6 +16,14 @@ module ActiveRecord
               super
             end
           end
+
+          def type_cast_for_schema(value)
+            case value
+            when ::Float::INFINITY then "::Float::INFINITY"
+            when -::Float::INFINITY then "-::Float::INFINITY"
+            else super
+            end
+          end
         end
       end
     end

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

@@ -10,7 +10,6 @@ module ActiveRecord
           end
 
           private
-
             def cast_value(value)
               value.to_s
             end

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

@@ -5,7 +5,7 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         class Hstore < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
           def type
             :hstore
@@ -46,7 +46,6 @@ module ActiveRecord
           end
 
           private
-
             HstorePair = begin
               quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
               unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/

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

@@ -5,7 +5,7 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         class LegacyPoint < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
           def type
             :point
@@ -34,7 +34,6 @@ module ActiveRecord
           end
 
           private
-
             def number_for_point(number)
               number.to_s.gsub(/\.0$/, "")
             end

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

@@ -4,7 +4,7 @@ module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
-        class Oid < Type::Integer # :nodoc:
+        class Oid < Type::UnsignedInteger # :nodoc:
           def type
             :oid
           end

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

@@ -7,7 +7,7 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         class Point < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
           def type
             :point
@@ -50,7 +50,6 @@ module ActiveRecord
           end
 
           private
-
             def number_for_point(number)
               number.to_s.gsub(/\.0$/, "")
             end