activerecord 5.2.8.1 → 6.1.7.3

data/lib/active_record/connection_adapters/column.rb

@@ -5,7 +5,9 @@ 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
+      include Deduplicable
+
+      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 +17,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 +45,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 +55,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,23 +65,42 @@ 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 ^
+          name.encoding.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]
+      private
+        def deduplicated
+          @name = -name
+          @sql_type_metadata = sql_type_metadata.deduplicate if sql_type_metadata
+          @default = -default if default
+          @default_function = -default_function if default_function
+          @collation = -collation if collation
+          @comment = -comment if comment
+          super
         end
     end
 
     class NullColumn < Column
-      def initialize(name)
+      def initialize(name, **)
         super(name, nil)
       end
     end

data/lib/active_record/connection_adapters/deduplicable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module Deduplicable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def registry
+          @registry ||= {}
+        end
+
+        def new(*, **)
+          super.deduplicate
+        end
+      end
+
+      def deduplicate
+        self.class.registry[self] ||= deduplicated
+      end
+      alias :-@ :deduplicate
+
+      private
+        def deduplicated
+          freeze
+        end
+    end
+  end
+end

data/lib/active_record/connection_adapters/legacy_pool_manager.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class LegacyPoolManager # :nodoc:
+      def initialize
+        @name_to_pool_config = {}
+      end
+
+      def shard_names
+        @name_to_pool_config.keys
+      end
+
+      def pool_configs(_ = nil)
+        @name_to_pool_config.values
+      end
+
+      def remove_pool_config(_, shard)
+        @name_to_pool_config.delete(shard)
+      end
+
+      def get_pool_config(_, shard)
+        @name_to_pool_config[shard]
+      end
+
+      def set_pool_config(role, shard, pool_config)
+        if pool_config
+          @name_to_pool_config[shard] = pool_config
+        else
+          raise ArgumentError, "The `pool_config` for the :#{role} role and :#{shard} shard was `nil`. Please check your configuration. If you want your writing role to be something other than `:writing` set `config.active_record.writing_role` in your application configuration. The same setting should be applied for the `reading_role` if applicable."
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module ActiveRecord
         end
 
         def case_sensitive?
-          collation && !/_ci\z/.match?(collation)
+          collation && !collation.end_with?("_ci")
         end
 
         def auto_increment?

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

@@ -5,13 +5,13 @@ module ActiveRecord
     module MySQL
       module DatabaseStatements
         # Returns an ActiveRecord::Result instance.
-        def select_all(*) # :nodoc:
+        def select_all(*, **) # :nodoc:
           result = if ExplainRegistry.collect? && prepared_statements
             unprepared_statement { super }
           else
             super
           end
-          discard_remaining_results
+          @connection.abandon_results!
           result
         end
 
@@ -19,8 +19,32 @@ module ActiveRecord
           execute(sql, name).to_a
         end
 
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :desc, :describe, :set, :show, :use
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
+        end
+
+        def explain(arel, binds = [])
+          sql     = "EXPLAIN #{to_sql(arel, binds)}"
+          start   = Concurrent.monotonic_time
+          result  = exec_query(sql, "EXPLAIN", binds)
+          elapsed = Concurrent.monotonic_time - start
+
+          MySQL::ExplainPrettyPrinter.new.pp(result, elapsed)
+        end
+
         # Executes the SQL statement in the context of this connection.
         def execute(sql, name = nil)
+          if preventing_writes? && write_query?(sql)
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          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
@@ -31,18 +55,28 @@ module ActiveRecord
         def exec_query(sql, name = "SQL", binds = [], prepare: false)
           if without_prepared_statement?(binds)
             execute_and_free(sql, name) do |result|
-              ActiveRecord::Result.new(result.fields, result.to_a) if result
+              if result
+                build_result(columns: result.fields, rows: result.to_a)
+              else
+                build_result(columns: [], rows: [])
+              end
             end
           else
             exec_stmt_and_free(sql, name, binds, cache_stmt: prepare) do |_, result|
-              ActiveRecord::Result.new(result.fields, result.to_a) if result
+              if result
+                build_result(columns: result.fields, rows: result.to_a)
+              else
+                build_result(columns: [], rows: [])
+              end
             end
           end
         end
 
         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
@@ -50,55 +84,80 @@ module ActiveRecord
         alias :exec_update :exec_delete
 
         private
+          def execute_batch(statements, name = nil)
+            combine_multi_statements(statements).each do |statement|
+              execute(statement, name)
+            end
+            @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.next_result while @connection.more_results?
-          end
+          def multi_statements_enabled?
+            flags = @config[:flags]
 
-          def supports_set_server_option?
-            @connection.respond_to?(:set_server_option)
-          end
-
-          def multi_statements_enabled?(flags)
             if flags.is_a?(Array)
               flags.include?("MULTI_STATEMENTS")
             else
-              (flags & Mysql2::Client::MULTI_STATEMENTS) != 0
+              flags.anybits?(Mysql2::Client::MULTI_STATEMENTS)
             end
           end
 
           def with_multi_statements
-            previous_flags = @config[:flags]
+            multi_statements_was = multi_statements_enabled?
 
-            unless multi_statements_enabled?(previous_flags)
-              if supports_set_server_option?
-                @connection.set_server_option(Mysql2::Client::OPTION_MULTI_STATEMENTS_ON)
-              else
-                @config[:flags] = Mysql2::Client::MULTI_STATEMENTS
-                reconnect!
-              end
+            unless multi_statements_was
+              @connection.set_server_option(Mysql2::Client::OPTION_MULTI_STATEMENTS_ON)
             end
 
             yield
           ensure
-            unless multi_statements_enabled?(previous_flags)
-              if supports_set_server_option?
-                @connection.set_server_option(Mysql2::Client::OPTION_MULTI_STATEMENTS_OFF)
+            unless multi_statements_was
+              @connection.set_server_option(Mysql2::Client::OPTION_MULTI_STATEMENTS_OFF)
+            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
-                @config[:flags] = previous_flags
-                reconnect!
+                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}"
+            end
+
+            materialize_transactions
+            mark_transaction_written_if_write(sql)
+
             # 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
@@ -107,10 +166,7 @@ module ActiveRecord
 
             log(sql, name, binds, type_casted_binds) do
               if cache_stmt
-                cache = @statements[sql] ||= {
-                  stmt: @connection.prepare(sql)
-                }
-                stmt = cache[:stmt]
+                stmt = @statements[sql] ||= @connection.prepare(sql)
               else
                 stmt = @connection.prepare(sql)
               end

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

@@ -37,7 +37,6 @@ module ActiveRecord
         end
 
         private
-
           def compute_column_widths(result)
             [].tap do |widths|
               result.columns.each_with_index do |column, i|
@@ -57,7 +56,7 @@ module ActiveRecord
             items.each_with_index do |item, i|
               item = "NULL" if item.nil?
               justifier = item.is_a?(Numeric) ? "rjust" : "ljust"
-              cells << item.to_s.send(justifier, widths[i])
+              cells << item.to_s.public_send(justifier, widths[i])
             end
             "| " + cells.join(" | ") + " |"
           end

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

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
+require "active_support/time_with_zone"
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module Quoting # :nodoc:
         def quote_column_name(name)
-          @quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`".freeze
+          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 +34,62 @@ 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
+          # Override +_type_cast+ we pass to mysql2 Date and Time objects instead
+          # of Strings since mysql2 is able to handle those classes more efficiently.
+          def _type_cast(value)
+            case value
+            when ActiveSupport::TimeWithZone
+              # We need to check explicitly for ActiveSupport::TimeWithZone because
+              # we need to transform it to Time objects but we don't want to
+              # transform Time objects to themselves.
+              if ActiveRecord::Base.default_timezone == :utc
+                value.getutc
+              else
+                value.getlocal
+              end
+            when Date, Time
+              value
+            else
+              super
+            end
+          end
       end
     end
   end

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

@@ -3,34 +3,58 @@
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
-      class SchemaCreation < AbstractAdapter::SchemaCreation # :nodoc:
-        delegate :add_sql_comment!, :mariadb?, to: :@conn
-        private :add_sql_comment!, :mariadb?
+      class SchemaCreation < SchemaCreation # :nodoc:
+        delegate :add_sql_comment!, :mariadb?, to: :@conn, private: true
 
         private
-
           def visit_DropForeignKey(name)
             "DROP FOREIGN KEY #{name}"
           end
 
+          def visit_DropCheckConstraint(name)
+            "DROP #{mariadb? ? 'CONSTRAINT' : 'CHECK'} #{name}"
+          end
+
           def visit_AddColumnDefinition(o)
             add_column_position!(super, column_options(o.column))
           end
 
           def visit_ChangeColumnDefinition(o)
-            change_column_sql = "CHANGE #{quote_column_name(o.name)} #{accept(o.column)}".dup
+            change_column_sql = +"CHANGE #{quote_column_name(o.name)} #{accept(o.column)}"
             add_column_position!(change_column_sql, column_options(o.column))
           end
 
-          def add_table_options!(create_sql, options)
-            add_sql_comment!(super, options[:comment])
+          def visit_CreateIndexDefinition(o)
+            sql = visit_IndexDefinition(o.index, true)
+            sql << " #{o.algorithm}" if o.algorithm
+            sql
+          end
+
+          def visit_IndexDefinition(o, create = false)
+            index_type = o.type&.to_s&.upcase || o.unique && "UNIQUE"
+
+            sql = create ? ["CREATE"] : []
+            sql << index_type if index_type
+            sql << "INDEX"
+            sql << quote_column_name(o.name)
+            sql << "USING #{o.using}" if o.using
+            sql << "ON #{quote_table_name(o.table)}" if create
+            sql << "(#{quoted_columns(o)})"
+
+            add_sql_comment!(sql.join(" "), o.comment)
+          end
+
+          def add_table_options!(create_sql, o)
+            create_sql << " DEFAULT CHARSET=#{o.charset}" if o.charset
+            create_sql << " COLLATE=#{o.collation}" if o.collation
+            add_sql_comment!(super, o.comment)
           end
 
           def add_column_options!(sql, options)
             # By default, TIMESTAMP columns are NOT NULL, cannot contain NULL values,
             # and assigning NULL assigns the current timestamp. To permit a TIMESTAMP
             # column to contain NULL, explicitly declare it with the NULL attribute.
-            # See https://dev.mysql.com/doc/refman/5.7/en/timestamp-initialization.html
+            # See https://dev.mysql.com/doc/refman/en/timestamp-initialization.html
             if /\Atimestamp\b/.match?(options[:column].sql_type) && !options[:primary_key]
               sql << " NULL" unless options[:null] == false || options_include_default?(options)
             end
@@ -64,8 +88,8 @@ module ActiveRecord
           end
 
           def index_in_create(table_name, column_name, options)
-            index_name, index_type, index_columns, _, _, index_using, comment = @conn.add_index_options(table_name, column_name, options)
-            add_sql_comment!("#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})".dup, comment)
+            index, _ = @conn.add_index_options(table_name, column_name, **options)
+            accept(index)
           end
       end
     end

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

@@ -4,54 +4,70 @@ 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
 
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
+        attr_reader :charset, :collation
+
+        def initialize(conn, name, charset: nil, collation: nil, **)
+          super
+          @charset = charset
+          @collation = collation
+        end
+
         def new_column_definition(name, type, **options) # :nodoc:
           case type
           when :virtual