activerecord 4.2.11.1 → 5.0.0

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

@@ -0,0 +1,51 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module Quoting # :nodoc:
+        QUOTED_TRUE, QUOTED_FALSE = '1', '0'
+
+        def quote_column_name(name)
+          @quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"
+        end
+
+        def quote_table_name(name)
+          @quoted_table_names[name] ||= super.gsub('.', '`.`')
+        end
+
+        def quoted_true
+          QUOTED_TRUE
+        end
+
+        def unquoted_true
+          1
+        end
+
+        def quoted_false
+          QUOTED_FALSE
+        end
+
+        def unquoted_false
+          0
+        end
+
+        def quoted_date(value)
+          if supports_datetime_with_precision?
+            super
+          else
+            super.sub(/\.\d{6}\z/, '')
+          end
+        end
+
+        private
+
+        def _quote(value)
+          if value.is_a?(Type::Binary::Data)
+            "x'#{value.hex}'"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class SchemaCreation < AbstractAdapter::SchemaCreation
+        delegate :add_sql_comment!, to: :@conn
+        private :add_sql_comment!
+
+        private
+
+        def visit_DropForeignKey(name)
+          "DROP FOREIGN KEY #{name}"
+        end
+
+        def visit_ColumnDefinition(o)
+          o.sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale, o.unsigned)
+          super
+        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)}"
+          add_column_position!(change_column_sql, column_options(o.column))
+        end
+
+        def add_table_options!(create_sql, options)
+          add_sql_comment!(super, options[:comment])
+        end
+
+        def column_options(o)
+          column_options = super
+          column_options[:charset] = o.charset
+          column_options
+        end
+
+        def add_column_options!(sql, options)
+          if charset = options[:charset]
+            sql << " CHARACTER SET #{charset}"
+          end
+
+          if collation = options[:collation]
+            sql << " COLLATE #{collation}"
+          end
+
+          add_sql_comment!(super, options[:comment])
+        end
+
+        def add_column_position!(sql, options)
+          if options[:first]
+            sql << " FIRST"
+          elsif options[:after]
+            sql << " AFTER #{quote_column_name(options[:after])}"
+          end
+
+          sql
+        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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module ColumnMethods
+        def primary_key(name, type = :primary_key, **options)
+          options[:auto_increment] = true if type == :bigint && !options.key?(:default)
+          super
+        end
+
+        def blob(*args, **options)
+          args.each { |name| column(name, :blob, options) }
+        end
+
+        def tinyblob(*args, **options)
+          args.each { |name| column(name, :tinyblob, options) }
+        end
+
+        def mediumblob(*args, **options)
+          args.each { |name| column(name, :mediumblob, options) }
+        end
+
+        def longblob(*args, **options)
+          args.each { |name| column(name, :longblob, options) }
+        end
+
+        def tinytext(*args, **options)
+          args.each { |name| column(name, :tinytext, options) }
+        end
+
+        def mediumtext(*args, **options)
+          args.each { |name| column(name, :mediumtext, options) }
+        end
+
+        def longtext(*args, **options)
+          args.each { |name| column(name, :longtext, options) }
+        end
+
+        def json(*args, **options)
+          args.each { |name| column(name, :json, options) }
+        end
+
+        def unsigned_integer(*args, **options)
+          args.each { |name| column(name, :unsigned_integer, options) }
+        end
+
+        def unsigned_bigint(*args, **options)
+          args.each { |name| column(name, :unsigned_bigint, options) }
+        end
+
+        def unsigned_float(*args, **options)
+          args.each { |name| column(name, :unsigned_float, options) }
+        end
+
+        def unsigned_decimal(*args, **options)
+          args.each { |name| column(name, :unsigned_decimal, options) }
+        end
+      end
+
+      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
+        attr_accessor :charset, :unsigned
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ColumnMethods
+
+        def new_column_definition(name, type, options) # :nodoc:
+          column = super
+          case column.type
+          when :primary_key
+            column.type = :integer
+            column.auto_increment = true
+          when /\Aunsigned_(?<type>.+)\z/
+            column.type = $~[:type].to_sym
+            column.unsigned = true
+          end
+          column.unsigned ||= options[:unsigned]
+          column.charset = options[:charset]
+          column
+        end
+
+        private
+
+        def create_column_definition(name, type)
+          MySQL::ColumnDefinition.new(name, type)
+        end
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module ColumnDumper
+        def column_spec_for_primary_key(column)
+          if column.bigint?
+            spec = { id: :bigint.inspect }
+            spec[:default] = schema_default(column) || 'nil' unless column.auto_increment?
+          else
+            spec = super
+          end
+          spec[:unsigned] = 'true' if column.unsigned?
+          spec
+        end
+
+        def prepare_column_options(column)
+          spec = super
+          spec[:unsigned] = 'true' if column.unsigned?
+          spec
+        end
+
+        def migration_keys
+          super + [:unsigned]
+        end
+
+        private
+
+        def default_primary_key?(column)
+          super && column.auto_increment?
+        end
+
+        def schema_type(column)
+          if column.sql_type == 'tinyblob'
+            :blob
+          else
+            super
+          end
+        end
+
+        def schema_precision(column)
+          super unless /time/ === column.sql_type && column.precision == 0
+        end
+
+        def schema_collation(column)
+          if column.collation && table_name = column.table_name
+            @table_collation_cache ||= {}
+            @table_collation_cache[table_name] ||= select_one("SHOW TABLE STATUS LIKE '#{table_name}'")["Collation"]
+            column.collation.inspect if column.collation != @table_collation_cache[table_name]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class TypeMetadata < DelegateClass(SqlTypeMetadata) # :nodoc:
+        attr_reader :extra, :strict
+
+        def initialize(type_metadata, extra: "", strict: false)
+          super(type_metadata)
+          @type_metadata = type_metadata
+          @extra = extra
+          @strict = strict
+        end
+
+        def ==(other)
+          other.is_a?(MySQL::TypeMetadata) &&
+            attributes_for_hash == other.attributes_for_hash
+        end
+        alias eql? ==
+
+        def hash
+          attributes_for_hash.hash
+        end
+
+        protected
+
+        def attributes_for_hash
+          [self.class, @type_metadata, extra, strict]
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,7 +1,9 @@
 require 'active_record/connection_adapters/abstract_mysql_adapter'
+require 'active_record/connection_adapters/mysql/database_statements'
 
-gem 'mysql2', '>= 0.3.13', '< 0.6.0'
+gem 'mysql2', '>= 0.3.18', '< 0.5'
 require 'mysql2'
+raise 'mysql2 0.4.3 is not supported. Please upgrade to 0.4.4+' if Mysql2::VERSION == '0.4.3'
 
 module ActiveRecord
   module ConnectionHandling # :nodoc:
@@ -10,17 +12,21 @@ module ActiveRecord
       config = config.symbolize_keys
 
       config[:username] = 'root' if config[:username].nil?
+      config[:flags] ||= 0
 
       if Mysql2::Client.const_defined? :FOUND_ROWS
-        config[:flags] = Mysql2::Client::FOUND_ROWS
+        if config[:flags].kind_of? Array
+          config[:flags].push "FOUND_ROWS".freeze
+        else
+          config[:flags] |= Mysql2::Client::FOUND_ROWS
+        end
       end
 
       client = Mysql2::Client.new(config)
-      options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
-      ConnectionAdapters::Mysql2Adapter.new(client, logger, options, config)
+      ConnectionAdapters::Mysql2Adapter.new(client, logger, nil, config)
     rescue Mysql2::Error => error
       if error.message.include?("Unknown database")
-        raise ActiveRecord::NoDatabaseError.new(error.message, error)
+        raise ActiveRecord::NoDatabaseError
       else
         raise
       end
@@ -31,22 +37,27 @@ module ActiveRecord
     class Mysql2Adapter < AbstractMysqlAdapter
       ADAPTER_NAME = 'Mysql2'.freeze
 
+      include MySQL::DatabaseStatements
+
       def initialize(connection, logger, connection_options, config)
         super
-        @prepared_statements = false
+        @prepared_statements = false unless config.key?(:prepared_statements)
         configure_connection
       end
 
-      MAX_INDEX_LENGTH_FOR_UTF8MB4 = 191
-      def initialize_schema_migrations_table
-        if charset == 'utf8mb4'
-          ActiveRecord::SchemaMigration.create_table(MAX_INDEX_LENGTH_FOR_UTF8MB4)
-        else
-          ActiveRecord::SchemaMigration.create_table
-        end
+      def supports_json?
+        !mariadb? && version >= '5.7.8'
+      end
+
+      def supports_comments?
+        true
       end
 
-      def supports_explain?
+      def supports_comments_in_create?
+        true
+      end
+
+      def supports_savepoints?
         true
       end
 
@@ -79,6 +90,7 @@ module ActiveRecord
       #++
 
       def active?
+        return false unless @connection
         @connection.ping
       end
 
@@ -93,155 +105,10 @@ module ActiveRecord
       # Otherwise, this method does nothing.
       def disconnect!
         super
-        @connection.close
-      end
-
-      #--
-      # DATABASE STATEMENTS ======================================
-      #++
-
-      def explain(arel, binds = [])
-        sql     = "EXPLAIN #{to_sql(arel, binds.dup)}"
-        start   = Time.now
-        result  = exec_query(sql, 'EXPLAIN', binds)
-        elapsed = Time.now - start
-
-        ExplainPrettyPrinter.new.pp(result, elapsed)
-      end
-
-      class ExplainPrettyPrinter # :nodoc:
-        # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
-        # MySQL shell:
-        #
-        #   +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
-        #   | id | select_type | table | type  | possible_keys | key     | key_len | ref   | rows | Extra       |
-        #   +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
-        #   |  1 | SIMPLE      | users | const | PRIMARY       | PRIMARY | 4       | const |    1 |             |
-        #   |  1 | SIMPLE      | posts | ALL   | NULL          | NULL    | NULL    | NULL  |    1 | Using where |
-        #   +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
-        #   2 rows in set (0.00 sec)
-        #
-        # This is an exercise in Ruby hyperrealism :).
-        def pp(result, elapsed)
-          widths    = compute_column_widths(result)
-          separator = build_separator(widths)
-
-          pp = []
-
-          pp << separator
-          pp << build_cells(result.columns, widths)
-          pp << separator
-
-          result.rows.each do |row|
-            pp << build_cells(row, widths)
-          end
-
-          pp << separator
-          pp << build_footer(result.rows.length, elapsed)
-
-          pp.join("\n") + "\n"
-        end
-
-        private
-
-        def compute_column_widths(result)
-          [].tap do |widths|
-            result.columns.each_with_index do |column, i|
-              cells_in_column = [column] + result.rows.map {|r| r[i].nil? ? 'NULL' : r[i].to_s}
-              widths << cells_in_column.map(&:length).max
-            end
-          end
+        unless @connection.nil?
+          @connection.close
+          @connection = nil
         end
-
-        def build_separator(widths)
-          padding = 1
-          '+' + widths.map {|w| '-' * (w + (padding*2))}.join('+') + '+'
-        end
-
-        def build_cells(items, widths)
-          cells = []
-          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])
-          end
-          '| ' + cells.join(' | ') + ' |'
-        end
-
-        def build_footer(nrows, elapsed)
-          rows_label = nrows == 1 ? 'row' : 'rows'
-          "#{nrows} #{rows_label} in set (%.2f sec)" % elapsed
-        end
-      end
-
-      # FIXME: re-enable the following once a "better" query_cache solution is in core
-      #
-      # The overrides below perform much better than the originals in AbstractAdapter
-      # because we're able to take advantage of mysql2's lazy-loading capabilities
-      #
-      # # Returns a record hash with the column names as keys and column values
-      # # as values.
-      # def select_one(sql, name = nil)
-      #   result = execute(sql, name)
-      #   result.each(as: :hash) do |r|
-      #     return r
-      #   end
-      # end
-      #
-      # # Returns a single value from a record
-      # def select_value(sql, name = nil)
-      #   result = execute(sql, name)
-      #   if first = result.first
-      #     first.first
-      #   end
-      # end
-      #
-      # # Returns an array of the values of the first column in a select:
-      # #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
-      # def select_values(sql, name = nil)
-      #   execute(sql, name).map { |row| row.first }
-      # end
-
-      # Returns an array of arrays containing the field values.
-      # Order is the same as that returned by +columns+.
-      def select_rows(sql, name = nil, binds = [])
-        execute(sql, name).to_a
-      end
-
-      # Executes the SQL statement in the context of this connection.
-      def execute(sql, name = nil)
-        # 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
-
-        super
-      end
-
-      def exec_query(sql, name = 'SQL', binds = [])
-        result = execute(sql, name)
-        ActiveRecord::Result.new(result.fields, result.to_a)
-      end
-
-      alias exec_without_stmt exec_query
-
-      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        super
-        id_value || @connection.last_id
-      end
-      alias :create :insert_sql
-
-      def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
-        execute to_sql(sql, binds), name
-      end
-
-      def exec_delete(sql, name, binds)
-        execute to_sql(sql, binds), name
-        @connection.affected_rows
-      end
-      alias :exec_update :exec_delete
-
-      def last_inserted_id(result)
-        @connection.last_id
       end
 
       private
@@ -259,10 +126,6 @@ module ActiveRecord
       def full_version
         @full_version ||= @connection.server_info[:version]
       end
-
-      def set_field_encoding field_name
-        field_name
-      end
     end
   end
 end