ruby-mysql 2.9.12 → 2.11.0

data/lib/mysql/protocol.rb

@@ -1,11 +1,11 @@
 # coding: ascii-8bit
-# Copyright (C) 2008-2012 TOMITA Masahiro
+# Copyright (C) 2008 TOMITA Masahiro
 # mailto:tommy@tmtm.org
 
 require "socket"
-require "timeout"
-require "digest/sha1"
 require "stringio"
+require "openssl"
+require_relative 'authenticator.rb'
 
 class Mysql
   # MySQL network protocol
@@ -23,7 +23,7 @@ class Mysql
     # Object :: converted value.
     def self.net2value(pkt, type, unsigned)
       case type
-      when Field::TYPE_STRING, Field::TYPE_VAR_STRING, Field::TYPE_NEWDECIMAL, Field::TYPE_BLOB
+      when Field::TYPE_STRING, Field::TYPE_VAR_STRING, Field::TYPE_NEWDECIMAL, Field::TYPE_BLOB, Field::TYPE_JSON
         return pkt.lcs
       when Field::TYPE_TINY
         v = pkt.utiny
@@ -112,12 +112,14 @@ class Mysql
     attr_reader :server_info
     attr_reader :server_version
     attr_reader :thread_id
+    attr_reader :client_flags
     attr_reader :sqlstate
     attr_reader :affected_rows
     attr_reader :insert_id
     attr_reader :server_status
     attr_reader :warning_count
     attr_reader :message
+    attr_reader :get_server_public_key
     attr_accessor :charset
 
     # @state variable keep state for connection.
@@ -127,39 +129,38 @@ class Mysql
     # :RESULT :: After retr_fields(), retr_all_records() or stmt_retr_all_records() is needed.
 
     # make socket connection to server.
-    # === Argument
-    # host :: [String] if "localhost" or "" nil then use UNIXSocket. Otherwise use TCPSocket
-    # port :: [Integer] port number using by TCPSocket
-    # socket :: [String] socket file name using by UNIXSocket
-    # conn_timeout :: [Integer] connect timeout (sec).
-    # read_timeout :: [Integer] read timeout (sec).
-    # write_timeout :: [Integer] write timeout (sec).
-    # === Exception
-    # [ClientError] :: connection timeout
-    def initialize(host, port, socket, conn_timeout, read_timeout, write_timeout)
+    # @param host [String] if "localhost" or "" or nil then use UNIX socket. Otherwise use TCP socket
+    # @param port [Integer] port number using by TCP socket
+    # @param socket [String] socket file name using by UNIX socket
+    # @param [Hash] opts
+    # @option opts :conn_timeout [Integer] connect timeout (sec).
+    # @option opts :read_timeout [Integer] read timeout (sec).
+    # @option opts :write_timeout [Integer] write timeout (sec).
+    # @option opts :local_infile [String] local infile path
+    # @option opts :get_server_public_key [Boolean]
+    # @raise [ClientError] connection timeout
+    def initialize(host, port, socket, opts)
+      @opts = opts
       @insert_id = 0
       @warning_count = 0
       @gc_stmt_queue = []   # stmt id list which GC destroy.
       set_state :INIT
-      @read_timeout = read_timeout
-      @write_timeout = write_timeout
+      @get_server_public_key = @opts[:get_server_public_key]
       begin
-        Timeout.timeout conn_timeout do
-          if host.nil? or host.empty? or host == "localhost"
-            socket ||= ENV["MYSQL_UNIX_PORT"] || MYSQL_UNIX_PORT
-            @sock = UNIXSocket.new socket
-          else
-            port ||= ENV["MYSQL_TCP_PORT"] || (Socket.getservbyname("mysql","tcp") rescue MYSQL_TCP_PORT)
-            @sock = TCPSocket.new host, port
-          end
+        if host.nil? or host.empty? or host == "localhost"
+          socket ||= ENV["MYSQL_UNIX_PORT"] || MYSQL_UNIX_PORT
+          @socket = Socket.unix(socket)
+        else
+          port ||= ENV["MYSQL_TCP_PORT"] || (Socket.getservbyname("mysql","tcp") rescue MYSQL_TCP_PORT)
+          @socket = Socket.tcp(host, port, connect_timeout: @opts[:connect_timeout])
         end
-      rescue Timeout::Error
+      rescue Errno::ETIMEDOUT
         raise ClientError, "connection timeout"
       end
     end
 
     def close
-      @sock.close
+      @socket.close
     end
 
     # initial negotiate and authenticate.
@@ -178,21 +179,49 @@ class Mysql
       init_packet = InitialPacket.parse read
       @server_info = init_packet.server_version
       @server_version = init_packet.server_version.split(/\D/)[0,3].inject{|a,b|a.to_i*100+b.to_i}
+      @server_capabilities = init_packet.server_capabilities
       @thread_id = init_packet.thread_id
-      client_flags = CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_TRANSACTIONS | CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION
-      client_flags |= CLIENT_CONNECT_WITH_DB if db
-      client_flags |= flag
+      @client_flags = CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_TRANSACTIONS | CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION | CLIENT_PLUGIN_AUTH
+      @client_flags |= CLIENT_LOCAL_FILES if @opts[:local_infile]
+      @client_flags |= CLIENT_CONNECT_WITH_DB if db
+      @client_flags |= flag
       @charset = charset
       unless @charset
         @charset = Charset.by_number(init_packet.server_charset)
         @charset.encoding       # raise error if unsupported charset
       end
-      netpw = encrypt_password passwd, init_packet.scramble_buff
-      write AuthenticationPacket.serialize(client_flags, 1024**3, @charset.number, user, netpw, db)
-      raise ProtocolError, 'The old style password is not supported' if read.to_s == "\xfe"
+      enable_ssl
+      Authenticator.new(self).authenticate(user, passwd, db, init_packet.scramble_buff, init_packet.auth_plugin)
       set_state :READY
     end
 
+    def enable_ssl
+      case @opts[:ssl_mode]
+      when SSL_MODE_DISABLED
+        return
+      when SSL_MODE_PREFERRED
+        return if @socket.local_address.unix?
+        return if @server_capabilities & CLIENT_SSL == 0
+      when SSL_MODE_REQUIRED
+        if @server_capabilities & CLIENT_SSL == 0
+          raise ClientError::SslConnectionError, "SSL is required but the server doesn't support it"
+        end
+      else
+        raise ClientError, "ssl_mode #{@opts[:ssl_mode]} is not supported"
+      end
+      begin
+        @client_flags |= CLIENT_SSL
+        write Protocol::TlsAuthenticationPacket.serialize(@client_flags, 1024**3, @charset.number)
+        @socket = OpenSSL::SSL::SSLSocket.new(@socket)
+        @socket.sync_close = true
+        @socket.connect
+      rescue => e
+        @client_flags &= ~CLIENT_SSL
+        return if @opts[:ssl_mode] == SSL_MODE_PREFERRED
+        raise e
+      end
+    end
+
     # Quit command
     def quit_command
       synchronize do
@@ -230,10 +259,7 @@ class Mysql
           return res_packet.field_count
         end
         if res_packet.field_count.nil?      # LOAD DATA LOCAL INFILE
-          filename = res_packet.message
-          File.open(filename){|f| write f}
-          write nil  # EOF mark
-          read
+          send_local_file(res_packet.message)
         end
         @affected_rows, @insert_id, @server_status, @warning_count, @message =
           res_packet.affected_rows, res_packet.insert_id, res_packet.server_status, res_packet.warning_count, res_packet.message
@@ -245,6 +271,19 @@ class Mysql
       end
     end
 
+    # send local file to server
+    def send_local_file(filename)
+      filename = File.absolute_path(filename)
+      if filename.start_with? @opts[:local_infile]
+        File.open(filename){|f| write f}
+      else
+        raise ClientError::LoadDataLocalInfileRejected, 'LOAD DATA LOCAL INFILE file request rejected due to restrictions on access.'
+      end
+    ensure
+      write nil # EOF mark
+      read
+    end
+
     # Retrieve n fields
     # === Argument
     # n :: [Integer] number of fields
@@ -429,15 +468,13 @@ class Mysql
       @gc_stmt_queue.push stmt_id
     end
 
-    private
-
     def check_state(st)
       raise 'command out of sync' unless @state == st
     end
 
     def set_state(st)
       @state = st
-      if st == :READY
+      if st == :READY && !@gc_stmt_queue.empty?
         gc_disabled = GC.disable
         begin
           while st = @gc_stmt_queue.shift
@@ -473,20 +510,18 @@ class Mysql
       data = ''
       len = nil
       begin
-        Timeout.timeout @read_timeout do
-          header = @sock.read(4)
-          raise EOFError unless header && header.length == 4
-          len1, len2, seq = header.unpack("CvC")
-          len = (len2 << 8) + len1
-          raise ProtocolError, "invalid packet: sequence number mismatch(#{seq} != #{@seq}(expected))" if @seq != seq
-          @seq = (@seq + 1) % 256
-          ret = @sock.read(len)
-          raise EOFError unless ret && ret.length == len
-          data.concat ret
-        end
+        header = read_timeout(4, @opts[:read_timeout])
+        raise EOFError unless header && header.length == 4
+        len1, len2, seq = header.unpack("CvC")
+        len = (len2 << 8) + len1
+        raise ProtocolError, "invalid packet: sequence number mismatch(#{seq} != #{@seq}(expected))" if @seq != seq
+        @seq = (@seq + 1) % 256
+        ret = read_timeout(len, @opts[:read_timeout])
+        raise EOFError unless ret && ret.length == len
+        data.concat ret
       rescue EOFError
         raise ClientError::ServerGoneError, 'MySQL server has gone away'
-      rescue Timeout::Error
+      rescue Errno::ETIMEDOUT
         raise ClientError, "read timeout"
       end while len == MAX_PACKET_LENGTH
 
@@ -494,52 +529,87 @@ class Mysql
 
       # Error packet
       if data[0] == ?\xff
-        f, errno, marker, @sqlstate, message = data.unpack("Cvaa5a*")
+        _, errno, marker, @sqlstate, message = data.unpack("Cvaa5a*")
         unless marker == "#"
-          f, errno, message = data.unpack("Cva*")    # Version 4.0 Error
+          _, errno, message = data.unpack("Cva*")    # Version 4.0 Error
           @sqlstate = ""
         end
         message.force_encoding(@charset.encoding)
         if Mysql::ServerError::ERROR_MAP.key? errno
           raise Mysql::ServerError::ERROR_MAP[errno].new(message, @sqlstate)
         end
-        raise Mysql::ServerError.new(message, @sqlstate)
+        raise Mysql::ServerError.new(message, @sqlstate, errno)
       end
       Packet.new(data)
     end
 
+    def read_timeout(len, timeout)
+      return @socket.read(len) if timeout.nil? || timeout == 0
+      result = ''
+      e = ::Time.now + timeout
+      while result.size < len
+        now = ::Time.now
+        raise Errno::ETIMEDOUT if now > e
+        r = @socket.read_nonblock(len - result.size, exception: false)
+        case r
+        when :wait_readable
+          IO.select([@socket], nil, nil, e - now)
+          next
+        when :wait_writable
+          IO.select(nil, [@socket], nil, e - now)
+          next
+        else
+          result << r
+        end
+      end
+      return result
+    end
+
     # Write one packet data
     # === Argument
     # data :: [String / IO] packet data. If data is nil, write empty packet.
     def write(data)
       begin
-        @sock.sync = false
+        @socket.sync = false
         if data.nil?
-          Timeout.timeout @write_timeout do
-            @sock.write [0, 0, @seq].pack("CvC")
-          end
+          write_timeout([0, 0, @seq].pack("CvC"), @opts[:write_timeout])
           @seq = (@seq + 1) % 256
         else
           data = StringIO.new data if data.is_a? String
           while d = data.read(MAX_PACKET_LENGTH)
-            Timeout.timeout @write_timeout do
-              @sock.write [d.length%256, d.length/256, @seq].pack("CvC")
-              @sock.write d
-            end
+            write_timeout([d.length%256, d.length/256, @seq].pack("CvC")+d, @opts[:write_timeout])
             @seq = (@seq + 1) % 256
           end
         end
-        @sock.sync = true
-        Timeout.timeout @write_timeout do
-          @sock.flush
-        end
+        @socket.sync = true
+        @socket.flush
       rescue Errno::EPIPE
         raise ClientError::ServerGoneError, 'MySQL server has gone away'
-      rescue Timeout::Error
+      rescue Errno::ETIMEDOUT
         raise ClientError, "write timeout"
       end
     end
 
+    def write_timeout(data, timeout)
+      return @socket.write(data) if timeout.nil? || timeout == 0
+      len = 0
+      e = ::Time.now + timeout
+      while len < data.size
+        now = ::Time.now
+        raise Errno::ETIMEDOUT if now > e
+        l = @socket.write_nonblock(data[len..-1], exception: false)
+        case l
+        when :wait_readable
+          IO.select([@socket], nil, nil, e - now)
+        when :wait_writable
+          IO.select(nil, [@socket], nil, e - now)
+        else
+          len += l
+        end
+      end
+      return len
+    end
+
     # Read EOF packet
     # === Exception
     # [ProtocolError] packet is not EOF
@@ -560,19 +630,6 @@ class Mysql
       end
     end
 
-    # Encrypt password
-    # === Argument
-    # plain    :: [String] plain password.
-    # scramble :: [String] scramble code from initial packet.
-    # === Return
-    # [String] encrypted password
-    def encrypt_password(plain, scramble)
-      return "" if plain.nil? or plain.empty?
-      hash_stage1 = Digest::SHA1.digest plain
-      hash_stage2 = Digest::SHA1.digest hash_stage1
-      return hash_stage1.unpack("C*").zip(Digest::SHA1.digest(scramble+hash_stage2).unpack("C*")).map{|a,b| a^b}.pack("C*")
-    end
-
     # Initial packet
     class InitialPacket
       def self.parse(pkt)
@@ -584,18 +641,26 @@ class Mysql
         server_capabilities = pkt.ushort
         server_charset = pkt.utiny
         server_status = pkt.ushort
-        f1 = pkt.read(13)
+        server_capabilities2 = pkt.ushort
+        scramble_length = pkt.utiny
+        _f1 = pkt.read(10)
         rest_scramble_buff = pkt.string
+        auth_plugin = pkt.string
+
+        server_capabilities |= server_capabilities2 << 16
+        scramble_buff.concat rest_scramble_buff
+
         raise ProtocolError, "unsupported version: #{protocol_version}" unless protocol_version == VERSION
         raise ProtocolError, "invalid packet: f0=#{f0}" unless f0 == 0
-        scramble_buff.concat rest_scramble_buff
-        self.new protocol_version, server_version, thread_id, server_capabilities, server_charset, server_status, scramble_buff
+        raise ProtocolError, "invalid packet: scramble_length(#{scramble_length}) != length of scramble(#{scramble_buff.size + 1})" unless scramble_length == scramble_buff.size + 1
+
+        self.new protocol_version, server_version, thread_id, server_capabilities, server_charset, server_status, scramble_buff, auth_plugin
       end
 
-      attr_reader :protocol_version, :server_version, :thread_id, :server_capabilities, :server_charset, :server_status, :scramble_buff
+      attr_reader :protocol_version, :server_version, :thread_id, :server_capabilities, :server_charset, :server_status, :scramble_buff, :auth_plugin
 
       def initialize(*args)
-        @protocol_version, @server_version, @thread_id, @server_capabilities, @server_charset, @server_status, @scramble_buff = args
+        @protocol_version, @server_version, @thread_id, @server_capabilities, @server_charset, @server_status, @scramble_buff, @auth_plugin = args
       end
     end
 
@@ -627,13 +692,13 @@ class Mysql
     # Field packet
     class FieldPacket
       def self.parse(pkt)
-        first = pkt.lcs
+        _first = pkt.lcs
         db = pkt.lcs
         table = pkt.lcs
         org_table = pkt.lcs
         name = pkt.lcs
         org_name = pkt.lcs
-        f0 = pkt.utiny
+        _f0 = pkt.utiny
         charsetnr = pkt.ushort
         length = pkt.ulong
         type = pkt.utiny
@@ -675,16 +740,35 @@ class Mysql
 
     # Authentication packet
     class AuthenticationPacket
-      def self.serialize(client_flags, max_packet_size, charset_number, username, scrambled_password, databasename)
-        [
+      def self.serialize(client_flags, max_packet_size, charset_number, username, scrambled_password, databasename, auth_plugin)
+        data = [
           client_flags,
           max_packet_size,
-          Packet.lcb(charset_number),
+          charset_number,
           "",                   # always 0x00 * 23
           username,
           Packet.lcs(scrambled_password),
-          databasename
-        ].pack("VVa*a23Z*A*Z*")
+        ]
+        pack = "VVCa23Z*A*"
+        if databasename
+          data.push databasename
+          pack.concat "Z*"
+        end
+        data.push auth_plugin
+        pack.concat "Z*"
+        data.pack(pack)
+      end
+    end
+
+    # TLS Authentication packet
+    class TlsAuthenticationPacket
+      def self.serialize(client_flags, max_packet_size, charset_number)
+        [
+          client_flags,
+          max_packet_size,
+          charset_number,
+          "",                   # always 0x00 * 23
+        ].pack("VVCa23")
       end
     end
 
@@ -712,6 +796,21 @@ class Mysql
       end
 
     end
+
+    class AuthenticationResultPacket
+      def self.parse(pkt)
+        result = pkt.utiny
+        auth_plugin = pkt.string
+        scramble = pkt.string
+        self.new(result, auth_plugin, scramble)
+      end
+
+      attr_reader :result, :auth_plugin, :scramble
+
+      def initialize(*args)
+        @result, @auth_plugin, @scramble = args
+      end
+    end
   end
 
   class RawRecord

data/lib/mysql.rb

@@ -1,5 +1,5 @@
 # coding: ascii-8bit
-# Copyright (C) 2008-2012 TOMITA Masahiro
+# Copyright (C) 2008 TOMITA Masahiro
 # mailto:tommy@tmtm.org
 
 # MySQL connection class.
@@ -16,12 +16,8 @@ class Mysql
   require "mysql/charset"
   require "mysql/protocol"
   require "mysql/packet.rb"
-  begin
-    require "mysql/ext.so"
-  rescue LoadError
-  end
 
-  VERSION            = 20912               # Version number of this library
+  VERSION            = 21100               # Version number of this library
   MYSQL_UNIX_PORT    = "/tmp/mysql.sock"   # UNIX domain socket filename
   MYSQL_TCP_PORT     = 3306                # TCP socket port number
 
@@ -86,16 +82,20 @@ class Mysql
     @fields = nil
     @protocol = nil
     @charset = nil
-    @connect_timeout = nil
-    @read_timeout = nil
-    @write_timeout = nil
     @init_command = nil
     @sqlstate = "00000"
     @query_with_result = true
     @host_info = nil
     @last_error = nil
     @result_exist = false
-    @local_infile = nil
+    @opts = {
+      connect_timeout: nil,
+      read_timeout: nil,
+      write_timeout: nil,
+      local_infile: nil,
+      ssl_mode: SSL_MODE_PREFERRED,
+      get_server_public_key: false,
+    }
   end
 
   # Connect to mysqld.
@@ -112,8 +112,8 @@ class Mysql
       warn 'unsupported flag: CLIENT_COMPRESS' if $VERBOSE
       flag &= ~CLIENT_COMPRESS
     end
-    @protocol = Protocol.new host, port, socket, @connect_timeout, @read_timeout, @write_timeout
-    @protocol.authenticate user, passwd, db, (@local_infile ? CLIENT_LOCAL_FILES : 0) | flag, @charset
+    @protocol = Protocol.new(host, port, socket, @opts)
+    @protocol.authenticate user, passwd, db, flag, @charset
     @charset ||= @protocol.charset
     @host_info = (host.nil? || host == "localhost") ? 'Localhost via UNIX socket' : "#{host} via TCP/IP"
     query @init_command if @init_command
@@ -144,36 +144,64 @@ class Mysql
   # Set option for connection.
   #
   # Available options:
-  #   Mysql::INIT_COMMAND, Mysql::OPT_CONNECT_TIMEOUT, Mysql::OPT_READ_TIMEOUT,
-  #   Mysql::OPT_WRITE_TIMEOUT, Mysql::SET_CHARSET_NAME
+  #   Mysql::INIT_COMMAND, Mysql::OPT_CONNECT_TIMEOUT, Mysql::OPT_GET_SERVER_PUBLIC_KEY,
+  #   Mysql::OPT_LOAD_DATA_LOCAL_DIR, Mysql::OPT_LOCAL_INFILE, Mysql::OPT_READ_TIMEOUT,
+  #   Mysql::OPT_SSL_MODE, Mysql::OPT_WRITE_TIMEOUT, Mysql::SET_CHARSET_NAME
   # @param [Integer] opt option
   # @param [Integer] value option value that is depend on opt
   # @return [Mysql] self
   def options(opt, value=nil)
     case opt
+#    when Mysql::DEFAULT_AUTH
+#    when Mysql::ENABLE_CLEARTEXT_PLUGIN
     when Mysql::INIT_COMMAND
       @init_command = value.to_s
+#    when Mysql::OPT_BIND
+#    when Mysql::OPT_CAN_HANDLE_EXPIRED_PASSWORDS
 #    when Mysql::OPT_COMPRESS
+#    when Mysql::OPT_COMPRESSION_ALGORITHMS
+#    when Mysql::OPT_CONNECT_ATTR_ADD
+#    when Mysql::OPT_CONNECT_ATTR_DELETE
+#    when Mysql::OPT_CONNECT_ATTR_RESET
     when Mysql::OPT_CONNECT_TIMEOUT
-      @connect_timeout = value
-#    when Mysql::GUESS_CONNECTION
+      @opts[:connect_timeout] = value
+    when Mysql::OPT_GET_SERVER_PUBLIC_KEY
+      @opts[:get_server_public_key] = value
+    when Mysql::OPT_LOAD_DATA_LOCAL_DIR
+      @opts[:local_infile] = value
     when Mysql::OPT_LOCAL_INFILE
-      @local_infile = value
+      @opts[:local_infile] = value ? '' : nil
+#    when Mysql::OPT_MAX_ALLOWED_PACKET
 #    when Mysql::OPT_NAMED_PIPE
+#    when Mysql::OPT_NET_BUFFER_LENGTH
+#    when Mysql::OPT_OPTIONAL_RESULTSET_METADATA
 #    when Mysql::OPT_PROTOCOL
     when Mysql::OPT_READ_TIMEOUT
-      @read_timeout = value.to_i
+      @opts[:read_timeout] = value
 #    when Mysql::OPT_RECONNECT
+#    when Mysql::OPT_RETRY_COUNT
 #    when Mysql::SET_CLIENT_IP
-#    when Mysql::OPT_SSL_VERIFY_SERVER_CERT
-#    when Mysql::OPT_USE_EMBEDDED_CONNECTION
-#    when Mysql::OPT_USE_REMOTE_CONNECTION
+#    when Mysql::OPT_SSL_CA
+#    when Mysql::OPT_SSL_CAPATH
+#    when Mysql::OPT_SSL_CERT
+#    when Mysql::OPT_SSL_CIPHER
+#    when Mysql::OPT_SSL_CRL
+#    when Mysql::OPT_SSL_CRLPATH
+#    when Mysql::OPT_SSL_FIPS_MODE
+#    when Mysql::OPT_SSL_KEY
+    when Mysql::OPT_SSL_MODE
+      @opts[:ssl_mode] = value
+#    when Mysql::OPT_TLS_CIPHERSUITES
+#    when Mysql::OPT_TLS_VERSION
+#    when Mysql::OPT_USE_RESULT
     when Mysql::OPT_WRITE_TIMEOUT
-      @write_timeout = value.to_i
+      @opts[:write_timeout] = value
+#    when Mysql::OPT_ZSTD_COMPRESSION_LEVEL
+#    when Mysql::PLUGIN_DIR
 #    when Mysql::READ_DEFAULT_FILE
 #    when Mysql::READ_DEFAULT_GROUP
 #    when Mysql::REPORT_DATA_TRUNCATION
-#    when Mysql::SECURE_AUTH
+#    when Mysql::SERVER_PUBLIC_KEY
 #    when Mysql::SET_CHARSET_DIR
     when Mysql::SET_CHARSET_NAME
       @charset = Charset.by_name value.to_s
@@ -186,14 +214,9 @@ class Mysql
 
   # Escape special character in MySQL.
   #
-  # In Ruby 1.8, this is not safe for multibyte charset such as 'SJIS'.
-  # You should use place-holder in prepared-statement.
   # @param [String] str
   # return [String]
   def escape_string(str)
-    if not defined? Encoding and @charset.unsafe
-      raise ClientError, 'Mysql#escape_string is called for unsafe multibyte charset'
-    end
     self.class.escape_string str
   end
   alias quote escape_string
@@ -439,7 +462,6 @@ class Mysql
     store_result
   end
 
-  # @note for Ruby 1.8: This is not multi-byte safe. Don't use for multi-byte charset such as cp932.
   # @param [String] table database name that may contain wild card.
   # @return [Array<String>] list of table name.
   def list_tables(table=nil)
@@ -731,8 +753,8 @@ class Mysql
       max_length = Array.new(@fields.size, 0)
       @records.each_with_index do |rec, i|
         rec = @records[i] = rec.to_a if rec.is_a? RawRecord
-        max_length.each_index do |i|
-          max_length[i] = rec[i].length if rec[i] && rec[i].length > max_length[i]
+        max_length.each_index do |j|
+          max_length[j] = rec[j].length if rec[j] && rec[j].length > max_length[j]
         end
       end
       max_length.each_with_index do |len, i|
@@ -900,7 +922,7 @@ class Mysql
       row.zip(@bind_result).map do |col, type|
         if col.nil?
           nil
-        elsif [Numeric, Integer, Fixnum].include? type
+        elsif [Numeric, Integer].include? type
           col.to_i
         elsif type == String
           col.to_s
@@ -953,7 +975,7 @@ class Mysql
         raise ClientError, "bind_result: result value count(#{@fields.length}) != number of argument(#{args.length})"
       end
       args.each do |a|
-        raise TypeError unless [Numeric, Fixnum, Integer, Float, String, Mysql::Time, nil].include? a
+        raise TypeError unless [Numeric, Integer, Float, String, Mysql::Time, nil].include? a
       end
       @bind_result = args
       self