mysql2 0.3.20 → 0.5.3

data/lib/mysql2/client.rb

@@ -1,24 +1,28 @@
 module Mysql2
   class Client
     attr_reader :query_options, :read_timeout
-    @@default_query_options = {
-      :as => :hash,                   # the type of object you want each row back as; also supports :array (an array of values)
-      :async => false,                # don't wait for a result after sending the query, you'll have to monitor the socket yourself then eventually call Mysql2::Client#async_result
-      :cast_booleans => false,        # cast tinyint(1) fields as true/false in ruby
-      :symbolize_keys => false,       # return field names as symbols instead of strings
-      :database_timezone => :local,   # timezone Mysql2 will assume datetime objects are stored in
-      :application_timezone => nil,   # timezone Mysql2 will convert to before handing the object back to the caller
-      :cache_rows => true,            # tells Mysql2 to use it's internal row cache for results
-      :connect_flags => REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION,
-      :cast => true,
-      :default_file => nil,
-      :default_group => nil
-    }
+
+    def self.default_query_options
+      @default_query_options ||= {
+        as: :hash,                   # the type of object you want each row back as; also supports :array (an array of values)
+        async: false,                # don't wait for a result after sending the query, you'll have to monitor the socket yourself then eventually call Mysql2::Client#async_result
+        cast_booleans: false,        # cast tinyint(1) fields as true/false in ruby
+        symbolize_keys: false,       # return field names as symbols instead of strings
+        database_timezone: :local,   # timezone Mysql2 will assume datetime objects are stored in
+        application_timezone: nil,   # timezone Mysql2 will convert to before handing the object back to the caller
+        cache_rows: true,            # tells Mysql2 to use its internal row cache for results
+        connect_flags: REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION | CONNECT_ATTRS,
+        cast: true,
+        default_file: nil,
+        default_group: nil,
+      }
+    end
 
     def initialize(opts = {})
-      opts = Mysql2::Util.key_hash_as_symbols( opts )
+      raise Mysql2::Error, "Options parameter must be a Hash" unless opts.is_a? Hash
+      opts = Mysql2::Util.key_hash_as_symbols(opts)
       @read_timeout = nil
-      @query_options = @@default_query_options.dup
+      @query_options = self.class.default_query_options.dup
       @query_options.merge! opts
 
       initialize_ext
@@ -26,13 +30,14 @@ module Mysql2
       # Set default connect_timeout to avoid unlimited retries from signal interruption
       opts[:connect_timeout] = 120 unless opts.key?(:connect_timeout)
 
-      [:reconnect, :connect_timeout, :local_infile, :read_timeout, :write_timeout, :default_file, :default_group, :secure_auth, :init_command].each do |key|
+      # TODO: stricter validation rather than silent massaging
+      %i[reconnect connect_timeout local_infile read_timeout write_timeout default_file default_group secure_auth init_command automatic_close enable_cleartext_plugin default_auth].each do |key|
         next unless opts.key?(key)
         case key
-        when :reconnect, :local_infile, :secure_auth
-          send(:"#{key}=", !!opts[key])
+        when :reconnect, :local_infile, :secure_auth, :automatic_close, :enable_cleartext_plugin
+          send(:"#{key}=", !!opts[key]) # rubocop:disable Style/DoubleNegation
         when :connect_timeout, :read_timeout, :write_timeout
-          send(:"#{key}=", opts[key].to_i)
+          send(:"#{key}=", Integer(opts[key])) unless opts[key].nil?
         else
           send(:"#{key}=", opts[key])
         end
@@ -42,11 +47,26 @@ module Mysql2
       self.charset_name = opts[:encoding] || 'utf8'
 
       ssl_options = opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslcipher)
-      ssl_set(*ssl_options) if ssl_options.any?
+      ssl_set(*ssl_options) if ssl_options.any? || opts.key?(:sslverify)
+      self.ssl_mode = parse_ssl_mode(opts[:ssl_mode]) if opts[:ssl_mode]
+
+      flags = case opts[:flags]
+      when Array
+        parse_flags_array(opts[:flags], @query_options[:connect_flags])
+      when String
+        parse_flags_array(opts[:flags].split(' '), @query_options[:connect_flags])
+      when Integer
+        @query_options[:connect_flags] | opts[:flags]
+      else
+        @query_options[:connect_flags]
+      end
+
+      # SSL verify is a connection flag rather than a mysql_ssl_set option
+      flags |= SSL_VERIFY_SERVER_CERT if opts[:sslverify]
 
-      if [:user,:pass,:hostname,:dbname,:db,:sock].any?{|k| @query_options.has_key?(k) }
+      if %i[user pass hostname dbname db sock].any? { |k| @query_options.key?(k) }
         warn "============= WARNING FROM mysql2 ============="
-        warn "The options :user, :pass, :hostname, :dbname, :db, and :sock will be deprecated at some point in the future."
+        warn "The options :user, :pass, :hostname, :dbname, :db, and :sock are deprecated and will be removed at some point in the future."
         warn "Instead, please use :username, :password, :host, :port, :database, :socket, :flags for the options."
         warn "============= END WARNING FROM mysql2 ========="
       end
@@ -57,7 +77,6 @@ module Mysql2
       port     = opts[:port]
       database = opts[:database] || opts[:dbname] || opts[:db]
       socket   = opts[:socket] || opts[:sock]
-      flags    = opts[:flags] ? opts[:flags] | @query_options[:connect_flags] : @query_options[:connect_flags]
 
       # Correct the data types before passing these values down to the C level
       user = user.to_s unless user.nil?
@@ -66,12 +85,51 @@ module Mysql2
       port = port.to_i unless port.nil?
       database = database.to_s unless database.nil?
       socket = socket.to_s unless socket.nil?
+      conn_attrs = parse_connect_attrs(opts[:connect_attrs])
 
-      connect user, pass, host, port, database, socket, flags
+      connect user, pass, host, port, database, socket, flags, conn_attrs
     end
 
-    def self.default_query_options
-      @@default_query_options
+    def parse_ssl_mode(mode)
+      m = mode.to_s.upcase
+      if m.start_with?('SSL_MODE_')
+        return Mysql2::Client.const_get(m) if Mysql2::Client.const_defined?(m)
+      else
+        x = 'SSL_MODE_' + m
+        return Mysql2::Client.const_get(x) if Mysql2::Client.const_defined?(x)
+      end
+      warn "Unknown MySQL ssl_mode flag: #{mode}"
+    end
+
+    def parse_flags_array(flags, initial = 0)
+      flags.reduce(initial) do |memo, f|
+        fneg = f.start_with?('-') ? f[1..-1] : nil
+        if fneg && fneg =~ /^\w+$/ && Mysql2::Client.const_defined?(fneg)
+          memo & ~ Mysql2::Client.const_get(fneg)
+        elsif f && f =~ /^\w+$/ && Mysql2::Client.const_defined?(f)
+          memo | Mysql2::Client.const_get(f)
+        else
+          warn "Unknown MySQL connection flag: '#{f}'"
+          memo
+        end
+      end
+    end
+
+    # Set default program_name in performance_schema.session_connect_attrs
+    # and performance_schema.session_account_connect_attrs
+    def parse_connect_attrs(conn_attrs)
+      return {} if Mysql2::Client::CONNECT_ATTRS.zero?
+      conn_attrs ||= {}
+      conn_attrs[:program_name] ||= $PROGRAM_NAME
+      conn_attrs.each_with_object({}) do |(key, value), hash|
+        hash[key.to_s] = value.to_s
+      end
+    end
+
+    def query(sql, options = {})
+      Thread.handle_interrupt(::Mysql2::Util::TIMEOUT_ERROR_CLASS => :never) do
+        _query(sql, @query_options.merge(options))
+      end
     end
 
     def query_info
@@ -86,9 +144,12 @@ module Mysql2
       self.class.info
     end
 
-    private
-      def self.local_offset
+    class << self
+      private
+
+      def local_offset
         ::Time.local(2010).utc_offset.to_r / 86400
       end
+    end
   end
 end

data/lib/mysql2/console.rb

@@ -1,5 +1,5 @@
 # Loaded by script/console. Land helpers here.
 
-Pry.config.prompt = lambda do |context, nesting, pry|
+Pry.config.prompt = lambda do |context, *|
   "[mysql2] #{context}> "
 end

data/lib/mysql2/em.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'eventmachine'
 require 'mysql2'
 
@@ -17,7 +15,7 @@ module Mysql2
           detach
           begin
             result = @client.async_result
-          rescue Exception => e
+          rescue StandardError => e
             @deferable.fail(e)
           else
             @deferable.succeed(result)
@@ -34,17 +32,16 @@ module Mysql2
       end
 
       def close(*args)
-        if @watch
-          @watch.detach if @watch.watching?
-        end
+        @watch.detach if @watch && @watch.watching?
+
         super(*args)
       end
 
-      def query(sql, opts={})
+      def query(sql, opts = {})
         if ::EM.reactor_running?
-          super(sql, opts.merge(:async => true))
+          super(sql, opts.merge(async: true))
           deferable = ::EM::DefaultDeferrable.new
-          @watch = ::EM.watch(self.socket, Watcher, self, deferable)
+          @watch = ::EM.watch(socket, Watcher, self, deferable)
           @watch.notify_readable = true
           deferable
         else

data/lib/mysql2/error.rb

@@ -1,26 +1,65 @@
-# encoding: UTF-8
-
 module Mysql2
   class Error < StandardError
-    REPLACEMENT_CHAR = '?'
-    ENCODE_OPTS      = {:undef => :replace, :invalid => :replace, :replace => REPLACEMENT_CHAR}
+    ENCODE_OPTS = {
+      undef: :replace,
+      invalid: :replace,
+      replace: '?'.freeze,
+    }.freeze
+
+    ConnectionError = Class.new(Error)
+    TimeoutError = Class.new(Error)
+
+    CODES = {
+      1205 => TimeoutError, # ER_LOCK_WAIT_TIMEOUT
+
+      1044 => ConnectionError, # ER_DBACCESS_DENIED_ERROR
+      1045 => ConnectionError, # ER_ACCESS_DENIED_ERROR
+      1152 => ConnectionError, # ER_ABORTING_CONNECTION
+      1153 => ConnectionError, # ER_NET_PACKET_TOO_LARGE
+      1154 => ConnectionError, # ER_NET_READ_ERROR_FROM_PIPE
+      1155 => ConnectionError, # ER_NET_FCNTL_ERROR
+      1156 => ConnectionError, # ER_NET_PACKETS_OUT_OF_ORDER
+      1157 => ConnectionError, # ER_NET_UNCOMPRESS_ERROR
+      1158 => ConnectionError, # ER_NET_READ_ERROR
+      1159 => ConnectionError, # ER_NET_READ_INTERRUPTED
+      1160 => ConnectionError, # ER_NET_ERROR_ON_WRITE
+      1161 => ConnectionError, # ER_NET_WRITE_INTERRUPTED
 
-    attr_accessor :error_number
-    attr_reader   :sql_state
-    attr_writer   :server_version
+      2001 => ConnectionError, # CR_SOCKET_CREATE_ERROR
+      2002 => ConnectionError, # CR_CONNECTION_ERROR
+      2003 => ConnectionError, # CR_CONN_HOST_ERROR
+      2004 => ConnectionError, # CR_IPSOCK_ERROR
+      2005 => ConnectionError, # CR_UNKNOWN_HOST
+      2006 => ConnectionError, # CR_SERVER_GONE_ERROR
+      2007 => ConnectionError, # CR_VERSION_ERROR
+      2009 => ConnectionError, # CR_WRONG_HOST_INFO
+      2012 => ConnectionError, # CR_SERVER_HANDSHAKE_ERR
+      2013 => ConnectionError, # CR_SERVER_LOST
+      2020 => ConnectionError, # CR_NET_PACKET_TOO_LARGE
+      2026 => ConnectionError, # CR_SSL_CONNECTION_ERROR
+      2027 => ConnectionError, # CR_MALFORMED_PACKET
+      2047 => ConnectionError, # CR_CONN_UNKNOW_PROTOCOL
+      2048 => ConnectionError, # CR_INVALID_CONN_HANDLE
+      2049 => ConnectionError, # CR_UNUSED_1
+    }.freeze
+
+    attr_reader :error_number, :sql_state
 
     # Mysql gem compatibility
-    alias_method :errno, :error_number
-    alias_method :error, :message
+    alias errno error_number
+    alias error message
 
-    def initialize(msg, server_version=nil)
-      self.server_version = server_version
+    def initialize(msg, server_version = nil, error_number = nil, sql_state = nil)
+      @server_version = server_version
+      @error_number = error_number
+      @sql_state = sql_state ? sql_state.encode(**ENCODE_OPTS) : nil
 
       super(clean_message(msg))
     end
 
-    def sql_state=(state)
-      @sql_state = ''.respond_to?(:encode) ? state.encode(ENCODE_OPTS) : state
+    def self.new_with_args(msg, server_version, error_number, sql_state)
+      error_class = CODES.fetch(error_number, self)
+      error_class.new(msg, server_version, error_number, sql_state)
     end
 
     private
@@ -49,31 +88,12 @@ module Mysql2
     # encoding, we'll assume UTF-8 and clean the string of anything that's not a
     # valid UTF-8 character.
     #
-    # Except for if we're on 1.8, where we'll do nothing ;)
-    #
-    # Returns a valid UTF-8 string in Ruby 1.9+, the original string on Ruby 1.8
+    # Returns a valid UTF-8 string.
     def clean_message(message)
-      return message if !message.respond_to?(:encoding)
-
       if @server_version && @server_version > 50500
-        message.encode(ENCODE_OPTS)
+        message.encode(**ENCODE_OPTS)
       else
-        if message.respond_to? :scrub
-          message.scrub(REPLACEMENT_CHAR).encode(ENCODE_OPTS)
-        else
-          # This is ugly as hell but Ruby 1.9 doesn't provide a way to clean a string
-          # and retain it's valid UTF-8 characters, that I know of.
-
-          new_message = "".force_encoding(Encoding::UTF_8)
-          message.chars.each do |char|
-            if char.valid_encoding?
-              new_message << char
-            else
-              new_message << REPLACEMENT_CHAR
-            end
-          end
-          new_message.encode(ENCODE_OPTS)
-        end
+        message.encode(Encoding::UTF_8, **ENCODE_OPTS)
       end
     end
   end

data/lib/mysql2/field.rb

@@ -0,0 +1,3 @@
+module Mysql2
+  Field = Struct.new(:name, :type)
+end

data/lib/mysql2/result.rb

@@ -1,5 +1,7 @@
 module Mysql2
   class Result
+    attr_reader :server_flags
+
     include Enumerable
   end
 end

data/lib/mysql2/statement.rb

@@ -0,0 +1,11 @@
+module Mysql2
+  class Statement
+    include Enumerable
+
+    def execute(*args, **kwargs)
+      Thread.handle_interrupt(::Mysql2::Util::TIMEOUT_ERROR_CLASS => :never) do
+        _execute(*args, **kwargs)
+      end
+    end
+  end
+end

data/lib/mysql2/version.rb

@@ -1,3 +1,3 @@
 module Mysql2
-  VERSION = "0.3.20"
+  VERSION = "0.5.3".freeze
 end

data/lib/mysql2.rb

@@ -1,28 +1,33 @@
-# encoding: UTF-8
 require 'date'
 require 'bigdecimal'
-require 'rational' unless RUBY_VERSION >= '1.9.2'
 
 # Load libmysql.dll before requiring mysql2/mysql2.so
 # This gives a chance to be flexible about the load path
 # Or to bomb out with a clear error message instead of a linker crash
 if RUBY_PLATFORM =~ /mswin|mingw/
   dll_path = if ENV['RUBY_MYSQL2_LIBMYSQL_DLL']
-               # If this environment variable is set, it overrides any other paths
-               # The user is advised to use backslashes not forward slashes
-               ENV['RUBY_MYSQL2_LIBMYSQL_DLL'].dup
-             elsif File.exist?(File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__)))
-               # Use vendor/libmysql.dll if it exists, convert slashes for Win32 LoadLibrary
-               File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__)).gsub('/', '\\')
-             else
-               # This will use default / system library paths
-               'libmysql.dll'
-             end
+    # If this environment variable is set, it overrides any other paths
+    # The user is advised to use backslashes not forward slashes
+    ENV['RUBY_MYSQL2_LIBMYSQL_DLL']
+  elsif File.exist?(File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__)))
+    # Use vendor/libmysql.dll if it exists, convert slashes for Win32 LoadLibrary
+    File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__))
+  elsif defined?(RubyInstaller)
+    # RubyInstaller-2.4+ native build doesn't need DLL preloading
+  else
+    # This will use default / system library paths
+    'libmysql.dll'
+  end
 
-  require 'Win32API'
-  LoadLibrary = Win32API.new('Kernel32', 'LoadLibrary', ['P'], 'I')
-  if 0 == LoadLibrary.call(dll_path)
-    abort "Failed to load libmysql.dll from #{dll_path}"
+  if dll_path
+    require 'fiddle'
+    kernel32 = Fiddle.dlopen 'kernel32'
+    load_library = Fiddle::Function.new(
+      kernel32['LoadLibraryW'], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT,
+    )
+    if load_library.call(dll_path.encode('utf-16le')).zero?
+      abort "Failed to load libmysql.dll from #{dll_path}"
+    end
   end
 end
 
@@ -31,6 +36,8 @@ require 'mysql2/error'
 require 'mysql2/mysql2'
 require 'mysql2/result'
 require 'mysql2/client'
+require 'mysql2/field'
+require 'mysql2/statement'
 
 # = Mysql2
 #
@@ -51,14 +58,29 @@ if defined?(ActiveRecord::VERSION::STRING) && ActiveRecord::VERSION::STRING < "3
 end
 
 # For holding utility methods
-module Mysql2::Util
+module Mysql2
+  module Util
+    #
+    # Rekey a string-keyed hash with equivalent symbols.
+    #
+    def self.key_hash_as_symbols(hash)
+      return nil unless hash
+      Hash[hash.map { |k, v| [k.to_sym, v] }]
+    end
 
-  #
-  # Rekey a string-keyed hash with equivalent symbols.
-  #
-  def self.key_hash_as_symbols(hash)
-    return nil unless hash
-    Hash[hash.map { |k,v| [k.to_sym, v] }]
+    #
+    # In Mysql2::Client#query and Mysql2::Statement#execute,
+    # Thread#handle_interrupt is used to prevent Timeout#timeout
+    # from interrupting query execution.
+    #
+    # Timeout::ExitException was removed in Ruby 2.3.0, 2.2.3, and 2.1.8,
+    # but is present in earlier 2.1.x and 2.2.x, so we provide a shim.
+    #
+    require 'timeout'
+    TIMEOUT_ERROR_CLASS = if defined?(::Timeout::ExitException)
+      ::Timeout::ExitException
+    else
+      ::Timeout::Error
+    end
   end
-
 end