activerecord 6.0.0 → 7.2.3

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

@@ -36,7 +36,7 @@ module ActiveRecord
               end
 
               if row[:Expression]
-                expression = row[:Expression]
+                expression = row[:Expression].gsub("\\'", "'")
                 expression = +"(#{expression})" unless expression.start_with?("(")
                 indexes.last[-2] << expression
                 indexes.last[-1][:expressions] ||= {}
@@ -51,26 +51,32 @@ 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].to_h { |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
+        rescue StatementInvalid => e
+          if e.message.match?(/Table '.+' doesn't exist/)
+            []
+          else
+            raise
           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 +128,11 @@ 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
+
+        def schema_creation # :nodoc:
+          MySQL::SchemaCreation.new(self)
         end
 
         private
@@ -150,22 +160,45 @@ module ActiveRecord
             @default_row_format
           end
 
-          def schema_creation
-            MySQL::SchemaCreation.new(self)
+          def valid_primary_key_options
+            super + [:unsigned, :auto_increment]
           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)
+          def default_type(table_name, field_name)
+            match = create_table_info(table_name)&.match(/`#{field_name}` (.+) DEFAULT ('|\d+|[A-z]+)/)
+            default_pre = match[2] if match
+
+            if default_pre == "'"
+              :string
+            elsif default_pre&.match?(/^\d+$/)
+              :integer
+            elsif default_pre&.match?(/^[A-z]+$/)
+              :function
+            end
+          end
+
+          def new_column_from_field(table_name, field, _definitions)
+            field_name = field.fetch(:Field)
             type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
             default, default_function = field[:Default], nil
 
             if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(default)
+              default = "#{default} ON UPDATE #{default}" if /on update CURRENT_TIMESTAMP/i.match?(field[:Extra])
               default, default_function = nil, default
             elsif type_metadata.extra == "DEFAULT_GENERATED"
               default = +"(#{default})" unless default.start_with?("(")
+              default = default.gsub("\\'", "'")
+              default, default_function = nil, default
+            elsif type_metadata.type == :text && default&.start_with?("'")
+              # strip and unescape quotes
+              default = default[1...-1].gsub("\\'", "'")
+            elsif default&.match?(/\A\d/)
+              # Its a number so we can skip the query to check if it is a function
+            elsif default && default_type(table_name, field_name) == :function
               default, default_function = nil, default
             end
 
@@ -196,7 +229,7 @@ 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
 
@@ -205,7 +238,12 @@ module ActiveRecord
 
             sql = +"SELECT table_name FROM information_schema.tables"
             sql << " WHERE table_schema = #{scope[:schema]}"
-            sql << " AND table_name = #{scope[:name]}" if scope[:name]
+
+            if scope[:name]
+              sql << " AND table_name = #{scope[:name]}"
+              sql << " AND table_name IN (SELECT table_name FROM information_schema.tables WHERE table_schema = #{scope[:schema]})"
+            end
+
             sql << " AND table_type = #{scope[:type]}" if scope[:type]
             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/database_statements.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Mysql2
+      module DatabaseStatements
+        # Returns an ActiveRecord::Result instance.
+        def select_all(*, **) # :nodoc:
+          if ExplainRegistry.collect? && prepared_statements
+            unprepared_statement { super }
+          else
+            super
+          end
+        end
+
+        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false) # :nodoc:
+          if without_prepared_statement?(binds)
+            execute_and_free(sql, name, async: async, allow_retry: allow_retry) do |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, async: async, allow_retry: allow_retry) do |_, 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 = []) # :nodoc:
+          if without_prepared_statement?(binds)
+            with_raw_connection do |conn|
+              @affected_rows_before_warnings = nil
+              execute_and_free(sql, name) { @affected_rows_before_warnings || conn.affected_rows }
+            end
+          else
+            exec_stmt_and_free(sql, name, binds) { |stmt| stmt.affected_rows }
+          end
+        end
+        alias :exec_update :exec_delete
+
+        private
+          def sync_timezone_changes(raw_connection)
+            raw_connection.query_options[:database_timezone] = default_timezone
+          end
+
+          def execute_batch(statements, name = nil)
+            statements = statements.map { |sql| transform_query(sql) }
+            combine_multi_statements(statements).each do |statement|
+              with_raw_connection do |conn|
+                raw_execute(statement, name)
+              end
+            end
+          end
+
+          def last_inserted_id(result)
+            if supports_insert_returning?
+              super
+            else
+              @raw_connection&.last_id
+            end
+          end
+
+          def multi_statements_enabled?
+            flags = @config[:flags]
+
+            if flags.is_a?(Array)
+              flags.include?("MULTI_STATEMENTS")
+            else
+              flags.anybits?(::Mysql2::Client::MULTI_STATEMENTS)
+            end
+          end
+
+          def with_multi_statements
+            if multi_statements_enabled?
+              return yield
+            end
+
+            with_raw_connection do |conn|
+              conn.set_server_option(::Mysql2::Client::OPTION_MULTI_STATEMENTS_ON)
+
+              yield
+            ensure
+              conn.set_server_option(::Mysql2::Client::OPTION_MULTI_STATEMENTS_OFF)
+            end
+          end
+
+          def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+            log(sql, name, async: async) do |notification_payload|
+              with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+                sync_timezone_changes(conn)
+                result = conn.query(sql)
+                conn.abandon_results!
+                verified!
+                handle_warnings(sql)
+                notification_payload[:row_count] = result&.size || 0
+                result
+              end
+            end
+          end
+
+          def exec_stmt_and_free(sql, name, binds, cache_stmt: false, async: false, allow_retry: false)
+            sql = transform_query(sql)
+            check_if_write_query(sql)
+
+            mark_transaction_written_if_write(sql)
+
+            type_casted_binds = type_casted_binds(binds)
+
+            log(sql, name, binds, type_casted_binds, async: async) do |notification_payload|
+              with_raw_connection(allow_retry: allow_retry) do |conn|
+                sync_timezone_changes(conn)
+
+                if cache_stmt
+                  stmt = @statements[sql] ||= conn.prepare(sql)
+                else
+                  stmt = conn.prepare(sql)
+                end
+
+                begin
+                  result = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                    stmt.execute(*type_casted_binds)
+                  end
+                  verified!
+                  result
+                rescue ::Mysql2::Error => e
+                  if cache_stmt
+                    @statements.delete(sql)
+                  else
+                    stmt.close
+                  end
+                  raise e
+                end
+
+                ret = yield stmt, result
+                notification_payload[:row_count] = result&.size || 0
+                result.free if result
+                stmt.close unless cache_stmt
+                ret
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,53 +1,69 @@
 # frozen_string_literal: true
 
 require "active_record/connection_adapters/abstract_mysql_adapter"
-require "active_record/connection_adapters/mysql/database_statements"
+require "active_record/connection_adapters/mysql2/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
-      config[:flags] ||= 0
-
-      if config[:flags].kind_of? Array
-        config[:flags].push "FOUND_ROWS"
-      else
-        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
-    end
-  end
-
   module ConnectionAdapters
+    # = Active Record MySQL2 Adapter
     class Mysql2Adapter < AbstractMysqlAdapter
+      ER_BAD_DB_ERROR           = 1049
+      ER_DBACCESS_DENIED_ERROR  = 1044
+      ER_ACCESS_DENIED_ERROR    = 1045
+      ER_CONN_HOST_ERROR        = 2003
+      ER_UNKNOWN_HOST_ERROR     = 2005
+
       ADAPTER_NAME = "Mysql2"
 
-      include MySQL::DatabaseStatements
+      include Mysql2::DatabaseStatements
+
+      class << self
+        def new_client(config)
+          ::Mysql2::Client.new(config)
+        rescue ::Mysql2::Error => error
+          case error.error_number
+          when ER_BAD_DB_ERROR
+            raise ActiveRecord::NoDatabaseError.db_error(config[:database])
+          when ER_DBACCESS_DENIED_ERROR, ER_ACCESS_DENIED_ERROR
+            raise ActiveRecord::DatabaseConnectionError.username_error(config[:username])
+          when ER_CONN_HOST_ERROR, ER_UNKNOWN_HOST_ERROR
+            raise ActiveRecord::DatabaseConnectionError.hostname_error(config[:host])
+          else
+            raise ActiveRecord::ConnectionNotEstablished, error.message
+          end
+        end
+
+        private
+          def initialize_type_map(m)
+            super
 
-      def initialize(connection, logger, connection_options, config)
-        superclass_config = config.reverse_merge(prepared_statements: false)
-        super(connection, logger, connection_options, superclass_config)
-        configure_connection
+            m.register_type(%r(char)i) do |sql_type|
+              limit = extract_limit(sql_type)
+              Type.lookup(:string, adapter: :mysql2, limit: limit)
+            end
+
+            m.register_type %r(^enum)i, Type.lookup(:string, adapter: :mysql2)
+            m.register_type %r(^set)i,  Type.lookup(:string, adapter: :mysql2)
+          end
       end
 
-      def self.database_exists?(config)
-        !!ActiveRecord::Base.mysql2_connection(config)
-      rescue ActiveRecord::NoDatabaseError
-        false
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
+      def initialize(...)
+        super
+
+        @config[:flags] ||= 0
+
+        if @config[:flags].kind_of? Array
+          @config[:flags].push "FOUND_ROWS"
+        else
+          @config[:flags] |= ::Mysql2::Client::FOUND_ROWS
+        end
+
+        @connection_parameters ||= @config
       end
 
       def supports_json?
@@ -66,17 +82,19 @@ module ActiveRecord
         true
       end
 
+      def savepoint_errors_invalidate_transactions?
+        true
+      end
+
       def supports_lazy_transactions?
         true
       end
 
       # HELPER METHODS ===========================================
 
-      def each_hash(result) # :nodoc:
+      def each_hash(result, &block) # :nodoc:
         if block_given?
-          result.each(as: :hash, symbolize_keys: true) do |row|
-            yield row
-          end
+          result.each(as: :hash, symbolize_keys: true, &block)
         else
           to_enum(:each_hash, result)
         end
@@ -87,60 +105,106 @@ module ActiveRecord
       end
 
       #--
-      # QUOTING ==================================================
+      # CONNECTION MANAGEMENT ====================================
       #++
 
-      def quote_string(string)
-        @connection.escape(string)
+      def connected?
+        !(@raw_connection.nil? || @raw_connection.closed?)
       end
 
-      #--
-      # CONNECTION MANAGEMENT ====================================
-      #++
-
       def active?
-        @connection.ping
+        if connected?
+          @lock.synchronize do
+            if @raw_connection&.ping
+              verified!
+              true
+            end
+          end
+        end || false
       end
 
-      def reconnect!
-        super
-        disconnect!
-        connect
-      end
       alias :reset! :reconnect!
 
       # Disconnects from the database if already connected.
       # Otherwise, this method does nothing.
       def disconnect!
-        super
-        @connection.close
+        @lock.synchronize do
+          super
+          @raw_connection&.close
+          @raw_connection = nil
+        end
       end
 
       def discard! # :nodoc:
-        super
-        @connection.automatic_close = false
-        @connection = nil
+        @lock.synchronize do
+          super
+          @raw_connection&.automatic_close = false
+          @raw_connection = nil
+        end
       end
 
       private
+        def text_type?(type)
+          TYPE_MAP.lookup(type).is_a?(Type::String) || TYPE_MAP.lookup(type).is_a?(Type::Text)
+        end
 
         def connect
-          @connection = Mysql2::Client.new(@config)
-          configure_connection
+          @raw_connection = self.class.new_client(@connection_parameters)
+        rescue ConnectionNotEstablished => ex
+          raise ex.set_pool(@pool)
+        end
+
+        def reconnect
+          @lock.synchronize do
+            @raw_connection&.close
+            @raw_connection = nil
+            connect
+          end
         end
 
         def configure_connection
-          @connection.query_options[:as] = :array
+          @raw_connection.query_options[:as] = :array
+          @raw_connection.query_options[:database_timezone] = default_timezone
           super
         end
 
         def full_version
-          schema_cache.database_version.full_version_string
+          database_version.full_version_string
         end
 
         def get_full_version
-          @connection.server_info[:version]
+          any_raw_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, connection_pool: @pool)
+          elsif exception.is_a?(::Mysql2::Error::ConnectionError)
+            if exception.message.match?(/MySQL client is not connected/i)
+              ActiveRecord::ConnectionNotEstablished.new(exception, connection_pool: @pool)
+            else
+              ActiveRecord::ConnectionFailed.new(message, sql: sql, binds: binds, connection_pool: @pool)
+            end
+          else
+            super
+          end
+        end
+
+        def default_prepared_statements
+          false
         end
+
+        ActiveRecord::Type.register(:immutable_string, adapter: :mysql2) do |_, **args|
+          Type::ImmutableString.new(true: "1", false: "0", **args)
+        end
+
+        ActiveRecord::Type.register(:string, adapter: :mysql2) do |_, **args|
+          Type::String.new(true: "1", false: "0", **args)
+        end
+
+        ActiveRecord::Type.register(:unsigned_integer, Type::UnsignedInteger, adapter: :mysql2)
     end
+
+    ActiveSupport.run_load_hooks(:active_record_mysql2adapter, Mysql2Adapter)
   end
 end

data/lib/active_record/connection_adapters/pool_config.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PoolConfig # :nodoc:
+      include MonitorMixin
+
+      attr_reader :db_config, :role, :shard
+      attr_writer :schema_reflection, :server_version
+      attr_accessor :connection_class
+
+      def schema_reflection
+        @schema_reflection ||= SchemaReflection.new(db_config.lazy_schema_cache_path)
+      end
+
+      INSTANCES = ObjectSpace::WeakMap.new
+      private_constant :INSTANCES
+
+      class << self
+        def discard_pools!
+          INSTANCES.each_key(&:discard_pool!)
+        end
+
+        def disconnect_all!
+          INSTANCES.each_key { |c| c.disconnect!(automatic_reconnect: true) }
+        end
+      end
+
+      def initialize(connection_class, db_config, role, shard)
+        super()
+        @server_version = nil
+        @connection_class = connection_class
+        @db_config = db_config
+        @role = role
+        @shard = shard
+        @pool = nil
+        INSTANCES[self] = self
+      end
+
+      def server_version(connection)
+        @server_version || synchronize { @server_version ||= connection.get_database_version }
+      end
+
+      def connection_name
+        if connection_class.primary_class?
+          "ActiveRecord::Base"
+        else
+          connection_class.name
+        end
+      end
+
+      def disconnect!(automatic_reconnect: false)
+        return unless @pool
+
+        synchronize do
+          return unless @pool
+
+          @pool.automatic_reconnect = automatic_reconnect
+          @pool.disconnect!
+        end
+
+        nil
+      end
+
+      def pool
+        @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! }