activerecord 6.0.0.beta1 → 6.0.1.rc1

data/lib/active_record/connection_adapters/column.rb

@@ -5,7 +5,7 @@ module ActiveRecord
   module ConnectionAdapters
     # An abstract definition of a column in a table.
     class Column
-      attr_reader :name, :default, :sql_type_metadata, :null, :table_name, :default_function, :collation, :comment
+      attr_reader :name, :default, :sql_type_metadata, :null, :default_function, :collation, :comment
 
       delegate :precision, :scale, :limit, :type, :sql_type, to: :sql_type_metadata, allow_nil: true
 
@@ -15,9 +15,8 @@ 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, default_function = nil, collation: nil, comment: nil, **)
         @name = name.freeze
-        @table_name = table_name
         @sql_type_metadata = sql_type_metadata
         @null = null
         @default = default
@@ -44,7 +43,6 @@ module ActiveRecord
 
       def init_with(coder)
         @name = coder["name"]
-        @table_name = coder["table_name"]
         @sql_type_metadata = coder["sql_type_metadata"]
         @null = coder["null"]
         @default = coder["default"]
@@ -55,7 +53,6 @@ module ActiveRecord
 
       def encode_with(coder)
         coder["name"] = @name
-        coder["table_name"] = @table_name
         coder["sql_type_metadata"] = @sql_type_metadata
         coder["null"] = @null
         coder["default"] = @default
@@ -66,19 +63,26 @@ module ActiveRecord
 
       def ==(other)
         other.is_a?(Column) &&
-          attributes_for_hash == other.attributes_for_hash
+          name == other.name &&
+          default == other.default &&
+          sql_type_metadata == other.sql_type_metadata &&
+          null == other.null &&
+          default_function == other.default_function &&
+          collation == other.collation &&
+          comment == other.comment
       end
       alias :eql? :==
 
       def hash
-        attributes_for_hash.hash
+        Column.hash ^
+          name.hash ^
+          default.hash ^
+          sql_type_metadata.hash ^
+          null.hash ^
+          default_function.hash ^
+          collation.hash ^
+          comment.hash
       end
-
-      protected
-
-        def attributes_for_hash
-          [self.class, name, default, sql_type_metadata, null, table_name, default_function, collation]
-        end
     end
 
     class NullColumn < Column

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -186,7 +186,7 @@ module ActiveRecord
           adapter_method = "#{spec[:adapter]}_connection"
 
           unless ActiveRecord::Base.respond_to?(adapter_method)
-            raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
+            raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter"
           end
 
           ConnectionSpecification.new(spec.delete(:name) || "primary", spec, adapter_method)
@@ -222,7 +222,7 @@ module ActiveRecord
             when Hash
               resolve_hash_connection config_or_env
             else
-              resolve_connection config_or_env
+              raise TypeError, "Invalid type for configuration. Expected Symbol, String, or Hash. Got #{config_or_env.inspect}"
             end
           end
 

data/lib/active_record/connection_adapters/determine_if_preparable_visitor.rb

@@ -3,9 +3,9 @@
 module ActiveRecord
   module ConnectionAdapters
     module DetermineIfPreparableVisitor
-      attr_reader :preparable
+      attr_accessor :preparable
 
-      def accept(*)
+      def accept(object, collector)
         @preparable = true
         super
       end
@@ -20,7 +20,7 @@ module ActiveRecord
         super
       end
 
-      def visit_Arel_Nodes_SqlLiteral(*)
+      def visit_Arel_Nodes_SqlLiteral(o, collector)
         @preparable = false
         super
       end

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

@@ -11,7 +11,7 @@ module ActiveRecord
           else
             super
           end
-          discard_remaining_results
+          @connection.abandon_results!
           result
         end
 
@@ -19,7 +19,9 @@ module ActiveRecord
           execute(sql, name).to_a
         end
 
-        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback) # :nodoc:
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback, :describe, :desc, :with
+        ) # :nodoc:
         private_constant :READ_QUERY
 
         def write_query?(sql) # :nodoc:
@@ -61,7 +63,9 @@ module ActiveRecord
 
         def exec_delete(sql, name = nil, binds = [])
           if without_prepared_statement?(binds)
-            execute_and_free(sql, name) { @connection.affected_rows }
+            @lock.synchronize do
+              execute_and_free(sql, name) { @connection.affected_rows }
+            end
           else
             exec_stmt_and_free(sql, name, binds) { |stmt| stmt.affected_rows }
           end
@@ -69,22 +73,31 @@ module ActiveRecord
         alias :exec_update :exec_delete
 
         private
+          def execute_batch(sql, name = nil)
+            super
+            @connection.abandon_results!
+          end
+
           def default_insert_value(column)
-            Arel.sql("DEFAULT") unless column.auto_increment?
+            super unless column.auto_increment?
           end
 
           def last_inserted_id(result)
             @connection.last_id
           end
 
-          def discard_remaining_results
-            @connection.abandon_results!
-          end
-
           def supports_set_server_option?
             @connection.respond_to?(:set_server_option)
           end
 
+          def build_truncate_statements(*table_names)
+            if table_names.size == 1
+              super.first
+            else
+              super
+            end
+          end
+
           def multi_statements_enabled?(flags)
             if flags.is_a?(Array)
               flags.include?("MULTI_STATEMENTS")
@@ -117,6 +130,33 @@ module ActiveRecord
             end
           end
 
+          def combine_multi_statements(total_sql)
+            total_sql.each_with_object([]) do |sql, total_sql_chunks|
+              previous_packet = total_sql_chunks.last
+              if max_allowed_packet_reached?(sql, previous_packet)
+                total_sql_chunks << +sql
+              else
+                previous_packet << ";\n"
+                previous_packet << sql
+              end
+            end
+          end
+
+          def max_allowed_packet_reached?(current_packet, previous_packet)
+            if current_packet.bytesize > max_allowed_packet
+              raise ActiveRecordError,
+                "Fixtures set is too large #{current_packet.bytesize}. Consider increasing the max_allowed_packet variable."
+            elsif previous_packet.nil?
+              true
+            else
+              (current_packet.bytesize + previous_packet.bytesize + 2) > max_allowed_packet
+            end
+          end
+
+          def max_allowed_packet
+            @max_allowed_packet ||= show_variable("max_allowed_packet")
+          end
+
           def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
             if preventing_writes? && write_query?(sql)
               raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"

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

@@ -5,11 +5,11 @@ module ActiveRecord
     module MySQL
       module Quoting # :nodoc:
         def quote_column_name(name)
-          @quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"
+          self.class.quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"
         end
 
         def quote_table_name(name)
-          @quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
+          self.class.quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
         end
 
         def unquoted_true
@@ -32,12 +32,49 @@ module ActiveRecord
           "x'#{value.hex}'"
         end
 
-        def _type_cast(value)
-          case value
-          when Date, Time then value
-          else super
-          end
+        def column_name_matcher
+          COLUMN_NAME
+        end
+
+        def column_name_with_order_matcher
+          COLUMN_NAME_WITH_ORDER
         end
+
+        COLUMN_NAME = /
+          \A
+          (
+            (?:
+              # `table_name`.`column_name` | function(one or no argument)
+              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`)) | \w+\((?:|\g<2>)\)
+            )
+            (?:\s+AS\s+(?:\w+|`\w+`))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        COLUMN_NAME_WITH_ORDER = /
+          \A
+          (
+            (?:
+              # `table_name`.`column_name` | function(one or no argument)
+              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`)) | \w+\((?:|\g<2>)\)
+            )
+            (?:\s+ASC|\s+DESC)?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
+
+        private
+          def _type_cast(value)
+            case value
+            when Date, Time then value
+            else super
+            end
+          end
       end
     end
   end

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

@@ -4,48 +4,56 @@ module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module ColumnMethods
-        def blob(*args, **options)
-          args.each { |name| column(name, :blob, options) }
-        end
+        extend ActiveSupport::Concern
 
-        def tinyblob(*args, **options)
-          args.each { |name| column(name, :tinyblob, options) }
-        end
+        ##
+        # :method: blob
+        # :call-seq: blob(*names, **options)
 
-        def mediumblob(*args, **options)
-          args.each { |name| column(name, :mediumblob, options) }
-        end
+        ##
+        # :method: tinyblob
+        # :call-seq: tinyblob(*names, **options)
 
-        def longblob(*args, **options)
-          args.each { |name| column(name, :longblob, options) }
-        end
+        ##
+        # :method: mediumblob
+        # :call-seq: mediumblob(*names, **options)
 
-        def tinytext(*args, **options)
-          args.each { |name| column(name, :tinytext, options) }
-        end
+        ##
+        # :method: longblob
+        # :call-seq: longblob(*names, **options)
 
-        def mediumtext(*args, **options)
-          args.each { |name| column(name, :mediumtext, options) }
-        end
+        ##
+        # :method: tinytext
+        # :call-seq: tinytext(*names, **options)
 
-        def longtext(*args, **options)
-          args.each { |name| column(name, :longtext, options) }
-        end
+        ##
+        # :method: mediumtext
+        # :call-seq: mediumtext(*names, **options)
 
-        def unsigned_integer(*args, **options)
-          args.each { |name| column(name, :unsigned_integer, options) }
-        end
+        ##
+        # :method: longtext
+        # :call-seq: longtext(*names, **options)
 
-        def unsigned_bigint(*args, **options)
-          args.each { |name| column(name, :unsigned_bigint, options) }
-        end
+        ##
+        # :method: unsigned_integer
+        # :call-seq: unsigned_integer(*names, **options)
 
-        def unsigned_float(*args, **options)
-          args.each { |name| column(name, :unsigned_float, options) }
-        end
+        ##
+        # :method: unsigned_bigint
+        # :call-seq: unsigned_bigint(*names, **options)
+
+        ##
+        # :method: unsigned_float
+        # :call-seq: unsigned_float(*names, **options)
+
+        ##
+        # :method: unsigned_decimal
+        # :call-seq: unsigned_decimal(*names, **options)
 
-        def unsigned_decimal(*args, **options)
-          args.each { |name| column(name, :unsigned_decimal, options) }
+        included do
+          define_column_methods :blob, :tinyblob, :mediumblob, :longblob,
+            :tinytext, :mediumtext, :longtext, :unsigned_integer, :unsigned_bigint,
+            :unsigned_float, :unsigned_decimal
         end
       end
 

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

@@ -97,14 +97,42 @@ 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?
-              version >= "10.2.2"
+              database_version >= "10.2.2"
             else
-              version >= "5.7.9"
+              database_version >= "5.7.9"
             end
           end
 
@@ -127,7 +155,7 @@ module ActiveRecord
           end
 
           def create_table_definition(*args)
-            MySQL::TableDefinition.new(*args)
+            MySQL::TableDefinition.new(self, *args)
           end
 
           def new_column_from_field(table_name, field)
@@ -146,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
@@ -197,6 +224,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