activerecord 6.0.0 → 6.1.4

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

@@ -5,7 +5,7 @@ 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
@@ -19,13 +19,24 @@ 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(
+          :desc, :describe, :set, :show, :use
+        ) # :nodoc:
         private_constant :READ_QUERY
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
         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)
@@ -43,17 +54,17 @@ module ActiveRecord
           if without_prepared_statement?(binds)
             execute_and_free(sql, name) do |result|
               if result
-                ActiveRecord::Result.new(result.fields, result.to_a)
+                build_result(columns: result.fields, rows: result.to_a)
               else
-                ActiveRecord::Result.new([], [])
+                build_result(columns: [], rows: [])
               end
             end
           else
             exec_stmt_and_free(sql, name, binds, cache_stmt: prepare) do |_, result|
               if result
-                ActiveRecord::Result.new(result.fields, result.to_a)
+                build_result(columns: result.fields, rows: result.to_a)
               else
-                ActiveRecord::Result.new([], [])
+                build_result(columns: [], rows: [])
               end
             end
           end
@@ -71,8 +82,10 @@ module ActiveRecord
         alias :exec_update :exec_delete
 
         private
-          def execute_batch(sql, name = nil)
-            super
+          def execute_batch(statements, name = nil)
+            combine_multi_statements(statements).each do |statement|
+              execute(statement, name)
+            end
             @connection.abandon_results!
           end
 
@@ -84,47 +97,27 @@ module ActiveRecord
             @connection.last_id
           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 = @config[:flags]
 
-          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)
-              else
-                @config[:flags] = previous_flags
-                reconnect!
-              end
+            unless multi_statements_was
+              @connection.set_server_option(Mysql2::Client::OPTION_MULTI_STATEMENTS_OFF)
             end
           end
 
@@ -161,6 +154,7 @@ module ActiveRecord
             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

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,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/time_with_zone"
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
@@ -47,7 +49,7 @@ module ActiveRecord
               # `table_name`.`column_name` | function(one or no argument)
               ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`)) | \w+\((?:|\g<2>)\)
             )
-            (?:\s+AS\s+(?:\w+|`\w+`))?
+            (?:(?:\s+AS)?\s+(?:\w+|`\w+`))?
           )
           (?:\s*,\s*\g<1>)*
           \z
@@ -69,10 +71,23 @@ module ActiveRecord
         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 Date, Time then value
-            else super
+            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

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

@@ -3,15 +3,18 @@
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
-      class SchemaCreation < AbstractAdapter::SchemaCreation # :nodoc:
+      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
@@ -21,15 +24,37 @@ module ActiveRecord
             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
@@ -63,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})"), 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

@@ -60,6 +60,14 @@ module ActiveRecord
       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

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

@@ -49,7 +49,7 @@ module ActiveRecord
           end
 
           def schema_limit(column)
-            super unless /\A(?:enum|set|(?:tiny|medium|long)?(?:text|blob))\b/.match?(column.sql_type)
+            super unless /\A(?:tiny|medium|long)?(?:text|blob)\b/.match?(column.sql_type)
           end
 
           def schema_precision(column)
@@ -79,7 +79,10 @@ module ActiveRecord
                     " WHERE table_schema = #{scope[:schema]}" \
                     "   AND table_name = #{scope[:name]}" \
                     "   AND column_name = #{column_name}"
-              @connection.query_value(sql, "SCHEMA").inspect
+              # Calling .inspect leads into issues with the query result
+              # which already returns escaped quotes.
+              # We remove the escape sequence from the result in order to deal with double escaping issues.
+              @connection.query_value(sql, "SCHEMA").gsub("\\'", "'").inspect
             end
           end
       end

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

@@ -51,26 +51,26 @@ module ActiveRecord
           end
 
           indexes.map do |index|
-            options = index.last
+            options = index.pop
 
             if expressions = options.delete(:expressions)
               orders = options.delete(:orders)
               lengths = options.delete(:lengths)
 
-              columns = index[-2].map { |name|
+              columns = index[-1].map { |name|
                 [ name.to_sym, expressions[name] || +quote_column_name(name) ]
               }.to_h
 
-              index[-2] = add_options_for_index_columns(
+              index[-1] = add_options_for_index_columns(
                 columns, order: orders, length: lengths
               ).values.join(", ")
             end
 
-            IndexDefinition.new(*index)
+            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
@@ -122,7 +122,7 @@ module ActiveRecord
         end
 
         def table_alias_length
-          256 # https://dev.mysql.com/doc/refman/8.0/en/identifiers.html
+          256 # https://dev.mysql.com/doc/refman/en/identifiers.html
         end
 
         private
@@ -154,8 +154,8 @@ module ActiveRecord
             MySQL::SchemaCreation.new(self)
           end
 
-          def create_table_definition(*args)
-            MySQL::TableDefinition.new(self, *args)
+          def create_table_definition(name, **options)
+            MySQL::TableDefinition.new(self, name, **options)
           end
 
           def new_column_from_field(table_name, field)
@@ -196,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"
-            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
 

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

@@ -6,9 +6,11 @@ module ActiveRecord
       class TypeMetadata < DelegateClass(SqlTypeMetadata) # :nodoc:
         undef to_yaml if method_defined?(:to_yaml)
 
+        include Deduplicable
+
         attr_reader :extra
 
-        def initialize(type_metadata, extra: "")
+        def initialize(type_metadata, extra: nil)
           super(type_metadata)
           @extra = extra
         end
@@ -25,6 +27,13 @@ module ActiveRecord
             __getobj__.hash ^
             extra.hash
         end
+
+        private
+          def deduplicated
+            __setobj__(__getobj__.deduplicate)
+            @extra = -extra if extra
+            super
+          end
       end
     end
   end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -3,13 +3,11 @@
 require "active_record/connection_adapters/abstract_mysql_adapter"
 require "active_record/connection_adapters/mysql/database_statements"
 
-gem "mysql2", ">= 0.4.4"
+gem "mysql2", "~> 0.5"
 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
@@ -21,23 +19,34 @@ module ActiveRecord
         config[:flags] |= Mysql2::Client::FOUND_ROWS
       end
 
-      client = Mysql2::Client.new(config)
-      ConnectionAdapters::Mysql2Adapter.new(client, logger, nil, config)
-    rescue Mysql2::Error => error
-      if error.error_number == ER_BAD_DB_ERROR
-        raise ActiveRecord::NoDatabaseError
-      else
-        raise
-      end
+      ConnectionAdapters::Mysql2Adapter.new(
+        ConnectionAdapters::Mysql2Adapter.new_client(config),
+        logger,
+        nil,
+        config,
+      )
     end
   end
 
   module ConnectionAdapters
     class Mysql2Adapter < AbstractMysqlAdapter
+      ER_BAD_DB_ERROR = 1049
       ADAPTER_NAME = "Mysql2"
 
       include MySQL::DatabaseStatements
 
+      class << self
+        def new_client(config)
+          Mysql2::Client.new(config)
+        rescue Mysql2::Error => error
+          if error.error_number == ConnectionAdapters::Mysql2Adapter::ER_BAD_DB_ERROR
+            raise ActiveRecord::NoDatabaseError
+          else
+            raise ActiveRecord::ConnectionNotEstablished, error.message
+          end
+        end
+      end
+
       def initialize(connection, logger, connection_options, config)
         superclass_config = config.reverse_merge(prepared_statements: false)
         super(connection, logger, connection_options, superclass_config)
@@ -92,6 +101,8 @@ module ActiveRecord
 
       def quote_string(string)
         @connection.escape(string)
+      rescue Mysql2::Error => error
+        raise translate_exception(error, message: error.message, sql: "<escape>", binds: [])
       end
 
       #--
@@ -123,9 +134,8 @@ module ActiveRecord
       end
 
       private
-
         def connect
-          @connection = Mysql2::Client.new(@config)
+          @connection = self.class.new_client(@config)
           configure_connection
         end
 
@@ -141,6 +151,14 @@ module ActiveRecord
         def get_full_version
           @connection.server_info[:version]
         end
+
+        def translate_exception(exception, message:, sql:, binds:)
+          if exception.is_a?(Mysql2::Error::TimeoutError) && !exception.error_number
+            ActiveRecord::AdapterTimeout.new(message, sql: sql, binds: binds)
+          else
+            super
+          end
+        end
     end
   end
 end

data/lib/active_record/connection_adapters/pool_config.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PoolConfig # :nodoc:
+      include Mutex_m
+
+      attr_reader :db_config, :connection_klass
+      attr_accessor :schema_cache
+
+      INSTANCES = ObjectSpace::WeakMap.new
+      private_constant :INSTANCES
+
+      class << self
+        def discard_pools!
+          INSTANCES.each_key(&:discard_pool!)
+        end
+      end
+
+      def initialize(connection_klass, db_config)
+        super()
+        @connection_klass = connection_klass
+        @db_config = db_config
+        @pool = nil
+        INSTANCES[self] = self
+      end
+
+      def connection_specification_name
+        if connection_klass.is_a?(String)
+          connection_klass
+        elsif connection_klass.primary_class?
+          "ActiveRecord::Base"
+        else
+          connection_klass.name
+        end
+      end
+
+      def disconnect!
+        ActiveSupport::ForkTracker.check!
+
+        return unless @pool
+
+        synchronize do
+          return unless @pool
+
+          @pool.automatic_reconnect = false
+          @pool.disconnect!
+        end
+
+        nil
+      end
+
+      def pool
+        ActiveSupport::ForkTracker.check!
+
+        @pool || synchronize { @pool ||= ConnectionAdapters::ConnectionPool.new(self) }
+      end
+
+      def discard_pool!
+        return unless @pool
+
+        synchronize do
+          return unless @pool
+
+          @pool.discard!
+          @pool = nil
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport::ForkTracker.after_fork { ActiveRecord::ConnectionAdapters::PoolConfig.discard_pools! }

data/lib/active_record/connection_adapters/pool_manager.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PoolManager # :nodoc:
+      def initialize
+        @name_to_role_mapping = Hash.new { |h, k| h[k] = {} }
+      end
+
+      def shard_names
+        @name_to_role_mapping.values.flat_map { |shard_map| shard_map.keys }
+      end
+
+      def role_names
+        @name_to_role_mapping.keys
+      end
+
+      def pool_configs(role = nil)
+        if role
+          @name_to_role_mapping[role].values
+        else
+          @name_to_role_mapping.flat_map { |_, shard_map| shard_map.values }
+        end
+      end
+
+      def remove_role(role)
+        @name_to_role_mapping.delete(role)
+      end
+
+      def remove_pool_config(role, shard)
+        @name_to_role_mapping[role].delete(shard)
+      end
+
+      def get_pool_config(role, shard)
+        @name_to_role_mapping[role][shard]
+      end
+
+      def set_pool_config(role, shard, pool_config)
+        if pool_config
+          @name_to_role_mapping[role][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/postgresql/column.rb

@@ -21,7 +21,30 @@ module ActiveRecord
         alias :array? :array
 
         def sql_type
-          super.sub(/\[\]\z/, "")
+          super.delete_suffix("[]")
+        end
+
+        def init_with(coder)
+          @serial = coder["serial"]
+          super
+        end
+
+        def encode_with(coder)
+          coder["serial"] = @serial
+          super
+        end
+
+        def ==(other)
+          other.is_a?(Column) &&
+            super &&
+            serial? == other.serial?
+        end
+        alias :eql? :==
+
+        def hash
+          Column.hash ^
+            super.hash ^
+            serial?.hash
         end
       end
     end