activerecord 6.0.0

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
+        private
+          def prepare_column_options(column)
+            spec = super
+            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)
+              spec = { type: schema_type(column).inspect }.merge!(spec)
+            end
+
+            spec
+          end
+
+          def column_spec_for_primary_key(column)
+            spec = super
+            spec.delete(:auto_increment) if column.type == :integer && column.auto_increment?
+            spec
+          end
+
+          def default_primary_key?(column)
+            super && column.auto_increment? && !column.unsigned?
+          end
+
+          def explicit_primary_key_default?(column)
+            column.type == :integer && !column.auto_increment?
+          end
+
+          def schema_type(column)
+            case column.sql_type
+            when /\Atimestamp\b/
+              :timestamp
+            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_collation_cache ||= {}
+              @table_collation_cache[table_name] ||=
+                @connection.exec_query("SHOW TABLE STATUS LIKE #{@connection.quote(table_name)}", "SCHEMA").first["Collation"]
+              column.collation.inspect if column.collation != @table_collation_cache[table_name]
+            end
+          end
+
+          def extract_expression_for_virtual_column(column)
+            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, table_name)
+              column_name = @connection.quote(column.name)
+              sql = "SELECT generation_expression FROM information_schema.columns" \
+                    " WHERE table_schema = #{scope[:schema]}" \
+                    "   AND table_name = #{scope[:name]}" \
+                    "   AND column_name = #{column_name}"
+              @connection.query_value(sql, "SCHEMA").inspect
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module SchemaStatements # :nodoc:
+        # Returns an array of indexes for the given table.
+        def indexes(table_name)
+          indexes = []
+          current_index = nil
+          execute_and_free("SHOW KEYS FROM #{quote_table_name(table_name)}", "SCHEMA") do |result|
+            each_hash(result) do |row|
+              if current_index != row[:Key_name]
+                next if row[:Key_name] == "PRIMARY" # skip the primary key
+                current_index = row[:Key_name]
+
+                mysql_index_type = row[:Index_type].downcase.to_sym
+                case mysql_index_type
+                when :fulltext, :spatial
+                  index_type = mysql_index_type
+                when :btree, :hash
+                  index_using = mysql_index_type
+                end
+
+                indexes << [
+                  row[:Table],
+                  row[:Key_name],
+                  row[:Non_unique].to_i == 0,
+                  [],
+                  lengths: {},
+                  orders: {},
+                  type: index_type,
+                  using: index_using,
+                  comment: row[:Index_comment].presence
+                ]
+              end
+
+              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 do |index|
+            options = index.last
+
+            if expressions = options.delete(:expressions)
+              orders = options.delete(:orders)
+              lengths = options.delete(:lengths)
+
+              columns = index[-2].map { |name|
+                [ name.to_sym, expressions[name] || +quote_column_name(name) ]
+              }.to_h
+
+              index[-2] = add_options_for_index_columns(
+                columns, order: orders, length: lengths
+              ).values.join(", ")
+            end
+
+            IndexDefinition.new(*index)
+          end
+        end
+
+        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 !row_format_dynamic_by_default? && CHARSETS_OF_4BYTES_MAXLEN.include?(charset)
+              options[:collation] = collation.sub(/\A[^_]+/, "utf8")
+            end
+          end
+        end
+
+        def update_table_definition(table_name, base)
+          MySQL::Table.new(table_name, base)
+        end
+
+        def create_schema_dumper(options)
+          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(self, *args)
+          end
+
+          def new_column_from_field(table_name, 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_function = nil, default
+            elsif type_metadata.extra == "DEFAULT_GENERATED"
+              default = +"(#{default})" unless default.start_with?("(")
+              default, default_function = nil, default
+            end
+
+            MySQL::Column.new(
+              field[:Field],
+              default,
+              type_metadata,
+              field[:Null] == "YES",
+              default_function,
+              collation: field[:Collation],
+              comment: field[:Comment].presence
+            )
+          end
+
+          def fetch_type_metadata(sql_type, extra = "")
+            MySQL::TypeMetadata.new(super(sql_type), extra: extra)
+          end
+
+          def extract_foreign_key_action(specifier)
+            super unless specifier == "RESTRICT"
+          end
+
+          def add_index_length(quoted_columns, **options)
+            lengths = options_for_index_columns(options[:length])
+            quoted_columns.each do |name, column|
+              column << "(#{lengths[name]})" if lengths[name].present?
+            end
+          end
+
+          def add_options_for_index_columns(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
+          end
+
+          def quoted_scope(name = nil, type: nil)
+            schema, name = extract_schema_qualified_name(name)
+            scope = {}
+            scope[:schema] = schema ? quote(schema) : "database()"
+            scope[:name] = quote(name) if name
+            scope[:type] = quote(type) if type
+            scope
+          end
+
+          def extract_schema_qualified_name(string)
+            schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
+            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
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class TypeMetadata < DelegateClass(SqlTypeMetadata) # :nodoc:
+        undef to_yaml if method_defined?(:to_yaml)
+
+        attr_reader :extra
+
+        def initialize(type_metadata, extra: "")
+          super(type_metadata)
+          @extra = extra
+        end
+
+        def ==(other)
+          other.is_a?(TypeMetadata) &&
+            __getobj__ == other.__getobj__ &&
+            extra == other.extra
+        end
+        alias eql? ==
+
+        def hash
+          TypeMetadata.hash ^
+            __getobj__.hash ^
+            extra.hash
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/abstract_mysql_adapter"
+require "active_record/connection_adapters/mysql/database_statements"
+
+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"
+      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
+    class Mysql2Adapter < AbstractMysqlAdapter
+      ADAPTER_NAME = "Mysql2"
+
+      include MySQL::DatabaseStatements
+
+      def initialize(connection, logger, connection_options, config)
+        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? && database_version >= "5.7.8"
+      end
+
+      def supports_comments?
+        true
+      end
+
+      def supports_comments_in_create?
+        true
+      end
+
+      def supports_savepoints?
+        true
+      end
+
+      def supports_lazy_transactions?
+        true
+      end
+
+      # HELPER METHODS ===========================================
+
+      def each_hash(result) # :nodoc:
+        if block_given?
+          result.each(as: :hash, symbolize_keys: true) do |row|
+            yield row
+          end
+        else
+          to_enum(:each_hash, result)
+        end
+      end
+
+      def error_number(exception)
+        exception.error_number if exception.respond_to?(:error_number)
+      end
+
+      #--
+      # QUOTING ==================================================
+      #++
+
+      def quote_string(string)
+        @connection.escape(string)
+      end
+
+      #--
+      # CONNECTION MANAGEMENT ====================================
+      #++
+
+      def active?
+        @connection.ping
+      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
+      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[:as] = :array
+          super
+        end
+
+        def full_version
+          schema_cache.database_version.full_version_string
+        end
+
+        def get_full_version
+          @connection.server_info[:version]
+        end
+    end
+  end
+end