mysql2 0.3.8 → 0.4.10

data/lib/mysql2/client.rb

@@ -1,242 +1,149 @@
 module Mysql2
   class Client
-    attr_reader :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 it's internal row cache for results
-      :connect_flags => REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION,
-      :cast => true
-    }
+    attr_reader :query_options, :read_timeout
+
+    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,
+        :cast => true,
+        :default_file => nil,
+        :default_group => nil,
+      }
+    end
 
     def initialize(opts = {})
-      @query_options = @@default_query_options.dup
+      fail 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 = self.class.default_query_options.dup
       @query_options.merge! opts
 
-      init_connection
+      initialize_ext
 
-      [:reconnect, :connect_timeout].each do |key|
+      # Set default connect_timeout to avoid unlimited retries from signal interruption
+      opts[:connect_timeout] = 120 unless opts.key?(:connect_timeout)
+
+      # TODO: stricter validation rather than silent massaging
+      [:reconnect, :connect_timeout, :local_infile, :read_timeout, :write_timeout, :default_file, :default_group, :secure_auth, :init_command, :automatic_close, :enable_cleartext_plugin].each do |key|
         next unless opts.key?(key)
-        send(:"#{key}=", opts[key])
+        case 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}=", Integer(opts[key])) unless opts[key].nil?
+        else
+          send(:"#{key}=", opts[key])
+        end
       end
+
       # force the encoding to utf8
       self.charset_name = opts[:encoding] || 'utf8'
 
-      @read_timeout = opts[:read_timeout]
-      if @read_timeout and @read_timeout < 0
-        raise Mysql2::Error, "read_timeout must be a positive integer, you passed #{@read_timeout}"
+      ssl_options = opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslcipher)
+      ssl_set(*ssl_options) if ssl_options.any? || opts.key?(:sslverify)
+      self.ssl_mode = parse_ssl_mode(opts[:ssl_mode]) if opts[:ssl_mode]
+
+      case opts[:flags]
+      when Array
+        flags = parse_flags_array(opts[:flags], @query_options[:connect_flags])
+      when String
+        flags = parse_flags_array(opts[:flags].split(' '), @query_options[:connect_flags])
+      when Integer
+        flags = @query_options[:connect_flags] | opts[:flags]
+      else
+        flags = @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.key?(k) }
+        warn "============= WARNING FROM mysql2 ============="
+        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
 
-      ssl_set(*opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslcipher))
+      user     = opts[:username] || opts[:user]
+      pass     = opts[:password] || opts[:pass]
+      host     = opts[:host] || opts[:hostname]
+      port     = opts[:port]
+      database = opts[:database] || opts[:dbname] || opts[:db]
+      socket   = opts[:socket] || opts[:sock]
 
-      user     = opts[:username]
-      pass     = opts[:password]
-      host     = opts[:host] || 'localhost'
-      port     = opts[:port] || 3306
-      database = opts[:database]
-      socket   = opts[:socket]
-      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?
+      pass = pass.to_s unless pass.nil?
+      host = host.to_s unless host.nil?
+      port = port.to_i unless port.nil?
+      database = database.to_s unless database.nil?
+      socket = socket.to_s unless socket.nil?
 
       connect user, pass, host, port, database, socket, flags
     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
 
-    # NOTE: from ruby-mysql
-    if defined? Encoding
-      CHARSET_MAP = {
-        "armscii8" => nil,
-        "ascii"    => Encoding::US_ASCII,
-        "big5"     => Encoding::Big5,
-        "binary"   => Encoding::ASCII_8BIT,
-        "cp1250"   => Encoding::Windows_1250,
-        "cp1251"   => Encoding::Windows_1251,
-        "cp1256"   => Encoding::Windows_1256,
-        "cp1257"   => Encoding::Windows_1257,
-        "cp850"    => Encoding::CP850,
-        "cp852"    => Encoding::CP852,
-        "cp866"    => Encoding::IBM866,
-        "cp932"    => Encoding::Windows_31J,
-        "dec8"     => nil,
-        "eucjpms"  => Encoding::EucJP_ms,
-        "euckr"    => Encoding::EUC_KR,
-        "gb2312"   => Encoding::EUC_CN,
-        "gbk"      => Encoding::GBK,
-        "geostd8"  => nil,
-        "greek"    => Encoding::ISO_8859_7,
-        "hebrew"   => Encoding::ISO_8859_8,
-        "hp8"      => nil,
-        "keybcs2"  => nil,
-        "koi8r"    => Encoding::KOI8_R,
-        "koi8u"    => Encoding::KOI8_U,
-        "latin1"   => Encoding::ISO_8859_1,
-        "latin2"   => Encoding::ISO_8859_2,
-        "latin5"   => Encoding::ISO_8859_9,
-        "latin7"   => Encoding::ISO_8859_13,
-        "macce"    => Encoding::MacCentEuro,
-        "macroman" => Encoding::MacRoman,
-        "sjis"     => Encoding::SHIFT_JIS,
-        "swe7"     => nil,
-        "tis620"   => Encoding::TIS_620,
-        "ucs2"     => Encoding::UTF_16BE,
-        "ujis"     => Encoding::EucJP_ms,
-        "utf8"     => Encoding::UTF_8,
-      }
-
-      MYSQL_CHARSET_MAP = {
-        1 => {:name => "big5",      :collation => "big5_chinese_ci"},
-        2 => {:name => "latin2",    :collation => "latin2_czech_cs"},
-        3 => {:name => "dec8",      :collation => "dec8_swedish_ci"},
-        4 => {:name => "cp850",     :collation => "cp850_general_ci"},
-        5 => {:name => "latin1",    :collation => "latin1_german1_ci"},
-        6 => {:name => "hp8",       :collation => "hp8_english_ci"},
-        7 => {:name => "koi8r",     :collation => "koi8r_general_ci"},
-        8 => {:name => "latin1",    :collation => "latin1_swedish_ci"},
-        9 => {:name => "latin2",    :collation => "latin2_general_ci"},
-        10 => {:name => "swe7",     :collation => "swe7_swedish_ci"},
-        11 => {:name => "ascii",    :collation => "ascii_general_ci"},
-        12 => {:name => "ujis",     :collation => "ujis_japanese_ci"},
-        13 => {:name => "sjis",     :collation => "sjis_japanese_ci"},
-        14 => {:name => "cp1251",   :collation => "cp1251_bulgarian_ci"},
-        15 => {:name => "latin1",   :collation => "latin1_danish_ci"},
-        16 => {:name => "hebrew",   :collation => "hebrew_general_ci"},
-        17 => {:name => "filename", :collation => "filename"},
-        18 => {:name => "tis620",   :collation => "tis620_thai_ci"},
-        19 => {:name => "euckr",    :collation => "euckr_korean_ci"},
-        20 => {:name => "latin7",   :collation => "latin7_estonian_cs"},
-        21 => {:name => "latin2",   :collation => "latin2_hungarian_ci"},
-        22 => {:name => "koi8u",    :collation => "koi8u_general_ci"},
-        23 => {:name => "cp1251",   :collation => "cp1251_ukrainian_ci"},
-        24 => {:name => "gb2312",   :collation => "gb2312_chinese_ci"},
-        25 => {:name => "greek",    :collation => "greek_general_ci"},
-        26 => {:name => "cp1250",   :collation => "cp1250_general_ci"},
-        27 => {:name => "latin2",   :collation => "latin2_croatian_ci"},
-        28 => {:name => "gbk",      :collation => "gbk_chinese_ci"},
-        29 => {:name => "cp1257",   :collation => "cp1257_lithuanian_ci"},
-        30 => {:name => "latin5",   :collation => "latin5_turkish_ci"},
-        31 => {:name => "latin1",   :collation => "latin1_german2_ci"},
-        32 => {:name => "armscii8", :collation => "armscii8_general_ci"},
-        33 => {:name => "utf8",     :collation => "utf8_general_ci"},
-        34 => {:name => "cp1250",   :collation => "cp1250_czech_cs"},
-        35 => {:name => "ucs2",     :collation => "ucs2_general_ci"},
-        36 => {:name => "cp866",    :collation => "cp866_general_ci"},
-        37 => {:name => "keybcs2",  :collation => "keybcs2_general_ci"},
-        38 => {:name => "macce",    :collation => "macce_general_ci"},
-        39 => {:name => "macroman", :collation => "macroman_general_ci"},
-        40 => {:name => "cp852",    :collation => "cp852_general_ci"},
-        41 => {:name => "latin7",   :collation => "latin7_general_ci"},
-        42 => {:name => "latin7",   :collation => "latin7_general_cs"},
-        43 => {:name => "macce",    :collation => "macce_bin"},
-        44 => {:name => "cp1250",   :collation => "cp1250_croatian_ci"},
-        47 => {:name => "latin1",   :collation => "latin1_bin"},
-        48 => {:name => "latin1",   :collation => "latin1_general_ci"},
-        49 => {:name => "latin1",   :collation => "latin1_general_cs"},
-        50 => {:name => "cp1251",   :collation => "cp1251_bin"},
-        51 => {:name => "cp1251",   :collation => "cp1251_general_ci"},
-        52 => {:name => "cp1251",   :collation => "cp1251_general_cs"},
-        53 => {:name => "macroman", :collation => "macroman_bin"},
-        57 => {:name => "cp1256",   :collation => "cp1256_general_ci"},
-        58 => {:name => "cp1257",   :collation => "cp1257_bin"},
-        59 => {:name => "cp1257",   :collation => "cp1257_general_ci"},
-        63 => {:name => "binary",   :collation => "binary"},
-        64 => {:name => "armscii8", :collation => "armscii8_bin"},
-        65 => {:name => "ascii",    :collation => "ascii_bin"},
-        66 => {:name => "cp1250",   :collation => "cp1250_bin"},
-        67 => {:name => "cp1256",   :collation => "cp1256_bin"},
-        68 => {:name => "cp866",    :collation => "cp866_bin"},
-        69 => {:name => "dec8",     :collation => "dec8_bin"},
-        70 => {:name => "greek",    :collation => "greek_bin"},
-        71 => {:name => "hebrew",   :collation => "hebrew_bin"},
-        72 => {:name => "hp8",      :collation => "hp8_bin"},
-        73 => {:name => "keybcs2",  :collation => "keybcs2_bin"},
-        74 => {:name => "koi8r",    :collation => "koi8r_bin"},
-        75 => {:name => "koi8u",    :collation => "koi8u_bin"},
-        77 => {:name => "latin2",   :collation => "latin2_bin"},
-        78 => {:name => "latin5",   :collation => "latin5_bin"},
-        79 => {:name => "latin7",   :collation => "latin7_bin"},
-        80 => {:name => "cp850",    :collation => "cp850_bin"},
-        81 => {:name => "cp852",    :collation => "cp852_bin"},
-        82 => {:name => "swe7",     :collation => "swe7_bin"},
-        83 => {:name => "utf8",     :collation => "utf8_bin"},
-        84 => {:name => "big5",     :collation => "big5_bin"},
-        85 => {:name => "euckr",    :collation => "euckr_bin"},
-        86 => {:name => "gb2312",   :collation => "gb2312_bin"},
-        87 => {:name => "gbk",      :collation => "gbk_bin"},
-        88 => {:name => "sjis",     :collation => "sjis_bin"},
-        89 => {:name => "tis620",   :collation => "tis620_bin"},
-        90 => {:name => "ucs2",     :collation => "ucs2_bin"},
-        91 => {:name => "ujis",     :collation => "ujis_bin"},
-        92 => {:name => "geostd8",  :collation => "geostd8_general_ci"},
-        93 => {:name => "geostd8",  :collation => "geostd8_bin"},
-        94 => {:name => "latin1",   :collation => "latin1_spanish_ci"},
-        95 => {:name => "cp932",    :collation => "cp932_japanese_ci"},
-        96 => {:name => "cp932",    :collation => "cp932_bin"},
-        97 => {:name => "eucjpms",  :collation => "eucjpms_japanese_ci"},
-        98 => {:name => "eucjpms",  :collation => "eucjpms_bin"},
-        99 => {:name => "cp1250",   :collation => "cp1250_polish_ci"},
-        128 => {:name => "ucs2",    :collation => "ucs2_unicode_ci"},
-        129 => {:name => "ucs2",    :collation => "ucs2_icelandic_ci"},
-        130 => {:name => "ucs2",    :collation => "ucs2_latvian_ci"},
-        131 => {:name => "ucs2",    :collation => "ucs2_romanian_ci"},
-        132 => {:name => "ucs2",    :collation => "ucs2_slovenian_ci"},
-        133 => {:name => "ucs2",    :collation => "ucs2_polish_ci"},
-        134 => {:name => "ucs2",    :collation => "ucs2_estonian_ci"},
-        135 => {:name => "ucs2",    :collation => "ucs2_spanish_ci"},
-        136 => {:name => "ucs2",    :collation => "ucs2_swedish_ci"},
-        137 => {:name => "ucs2",    :collation => "ucs2_turkish_ci"},
-        138 => {:name => "ucs2",    :collation => "ucs2_czech_ci"},
-        139 => {:name => "ucs2",    :collation => "ucs2_danish_ci"},
-        140 => {:name => "ucs2",    :collation => "ucs2_lithuanian_ci"},
-        141 => {:name => "ucs2",    :collation => "ucs2_slovak_ci"},
-        142 => {:name => "ucs2",    :collation => "ucs2_spanish2_ci"},
-        143 => {:name => "ucs2",    :collation => "ucs2_roman_ci"},
-        144 => {:name => "ucs2",    :collation => "ucs2_persian_ci"},
-        145 => {:name => "ucs2",    :collation => "ucs2_esperanto_ci"},
-        146 => {:name => "ucs2",    :collation => "ucs2_hungarian_ci"},
-        192 => {:name => "utf8",    :collation => "utf8_unicode_ci"},
-        193 => {:name => "utf8",    :collation => "utf8_icelandic_ci"},
-        194 => {:name => "utf8",    :collation => "utf8_latvian_ci"},
-        195 => {:name => "utf8",    :collation => "utf8_romanian_ci"},
-        196 => {:name => "utf8",    :collation => "utf8_slovenian_ci"},
-        197 => {:name => "utf8",    :collation => "utf8_polish_ci"},
-        198 => {:name => "utf8",    :collation => "utf8_estonian_ci"},
-        199 => {:name => "utf8",    :collation => "utf8_spanish_ci"},
-        200 => {:name => "utf8",    :collation => "utf8_swedish_ci"},
-        201 => {:name => "utf8",    :collation => "utf8_turkish_ci"},
-        202 => {:name => "utf8",    :collation => "utf8_czech_ci"},
-        203 => {:name => "utf8",    :collation => "utf8_danish_ci"},
-        204 => {:name => "utf8",    :collation => "utf8_lithuanian_ci"},
-        205 => {:name => "utf8",    :collation => "utf8_slovak_ci"},
-        206 => {:name => "utf8",    :collation => "utf8_spanish2_ci"},
-        207 => {:name => "utf8",    :collation => "utf8_roman_ci"},
-        208 => {:name => "utf8",    :collation => "utf8_persian_ci"},
-        209 => {:name => "utf8",    :collation => "utf8_esperanto_ci"},
-        210 => {:name => "utf8",    :collation => "utf8_hungarian_ci"},
-        254 => {:name => "utf8",    :collation => "utf8_general_cs"}
-      }
-
-      def self.encoding_from_charset(charset)
-        CHARSET_MAP[charset.to_s.downcase]
+    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
 
-      def self.encoding_from_charset_code(code)
-        if mapping = MYSQL_CHARSET_MAP[code]
-          encoding_from_charset(mapping[:name])
-        else
-          nil
+    if Thread.respond_to?(:handle_interrupt)
+      def query(sql, options = {})
+        Thread.handle_interrupt(::Mysql2::Util::TimeoutError => :never) do
+          _query(sql, @query_options.merge(options))
         end
       end
+    else
+      def query(sql, options = {})
+        _query(sql, @query_options.merge(options))
+      end
+    end
+
+    def query_info
+      info = query_info_string
+      return {} unless info
+      info_hash = {}
+      info.split.each_slice(2) { |s| info_hash[s[0].downcase.delete(':').to_sym] = s[1].to_i }
+      info_hash
     end
 
-    private
-      def self.local_offset
+    def info
+      self.class.info
+    end
+
+    class << self
+      private
+
+      def local_offset
         ::Time.local(2010).utc_offset.to_r / 86400
       end
+    end
   end
 end

data/lib/mysql2/console.rb

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

data/lib/mysql2/em.rb

@@ -10,23 +10,41 @@ module Mysql2
         def initialize(client, deferable)
           @client = client
           @deferable = deferable
+          @is_watching = true
         end
 
         def notify_readable
           detach
           begin
-            @deferable.succeed(@client.async_result)
-          rescue Exception => e
+            result = @client.async_result
+          rescue => e
             @deferable.fail(e)
+          else
+            @deferable.succeed(result)
           end
         end
+
+        def watching?
+          @is_watching
+        end
+
+        def unbind
+          @is_watching = false
+        end
+      end
+
+      def close(*args)
+        @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))
           deferable = ::EM::DefaultDeferrable.new
-          ::EM.watch(self.socket, Watcher, self, deferable).notify_readable = true
+          @watch = ::EM.watch(socket, Watcher, self, deferable)
+          @watch.notify_readable = true
           deferable
         else
           super(sql, opts)
@@ -34,4 +52,4 @@ module Mysql2
       end
     end
   end
-end
+end

data/lib/mysql2/error.rb

@@ -1,15 +1,71 @@
+# encoding: UTF-8
+
 module Mysql2
   class Error < StandardError
-    attr_accessor :error_number, :sql_state
+    ENCODE_OPTS = {
+      :undef => :replace,
+      :invalid => :replace,
+      :replace => '?'.freeze,
+    }.freeze
 
-    def initialize msg
-      super
-      @error_number = nil
-      @sql_state    = nil
-    end
+    attr_reader :error_number, :sql_state
 
     # Mysql gem compatibility
     alias_method :errno, :error_number
     alias_method :error, :message
+
+    def initialize(msg)
+      @server_version ||= nil
+
+      super(clean_message(msg))
+    end
+
+    def self.new_with_args(msg, server_version, error_number, sql_state)
+      err = allocate
+      err.instance_variable_set('@server_version', server_version)
+      err.instance_variable_set('@error_number', error_number)
+      err.instance_variable_set('@sql_state', sql_state.respond_to?(:encode) ? sql_state.encode(ENCODE_OPTS) : sql_state)
+      err.send(:initialize, msg)
+      err
+    end
+
+    private
+
+    # In MySQL 5.5+ error messages are always constructed server-side as UTF-8
+    # then returned in the encoding set by the `character_set_results` system
+    # variable.
+    #
+    # See http://dev.mysql.com/doc/refman/5.5/en/charset-errors.html for
+    # more context.
+    #
+    # Before MySQL 5.5 error message template strings are in whatever encoding
+    # is associated with the error message language.
+    # See http://dev.mysql.com/doc/refman/5.1/en/error-message-language.html
+    # for more information.
+    #
+    # The issue is that the user-data inserted in the message could potentially
+    # be in any encoding MySQL supports and is insert into the latin1, euckr or
+    # koi8r string raw. Meaning there's a high probability the string will be
+    # corrupt encoding-wise.
+    #
+    # See http://dev.mysql.com/doc/refman/5.1/en/charset-errors.html for
+    # more information.
+    #
+    # So in an attempt to make sure the error message string is always in a valid
+    # 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
+    def clean_message(message)
+      return message unless message.respond_to?(:encode)
+
+      if @server_version && @server_version > 50500
+        message.encode(ENCODE_OPTS)
+      else
+        message.encode(Encoding::UTF_8, ENCODE_OPTS)
+      end
+    end
   end
 end

data/lib/mysql2/field.rb

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

data/lib/mysql2/statement.rb

@@ -0,0 +1,17 @@
+module Mysql2
+  class Statement
+    include Enumerable
+
+    if Thread.respond_to?(:handle_interrupt)
+      def execute(*args)
+        Thread.handle_interrupt(::Mysql2::Util::TimeoutError => :never) do
+          _execute(*args)
+        end
+      end
+    else
+      def execute(*args)
+        _execute(*args)
+      end
+    end
+  end
+end

data/lib/mysql2/version.rb

@@ -1,3 +1,3 @@
 module Mysql2
-  VERSION = "0.3.8"
+  VERSION = "0.4.10"
 end

data/lib/mysql2.rb

@@ -3,11 +3,36 @@ 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']
+  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__)).tr('/', '\\')
+  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}"
+  end
+end
+
 require 'mysql2/version' unless defined? Mysql2::VERSION
 require 'mysql2/error'
-require 'mysql2/result'
 require 'mysql2/mysql2'
+require 'mysql2/result'
 require 'mysql2/client'
+require 'mysql2/field'
+require 'mysql2/statement'
 
 # = Mysql2
 #
@@ -16,6 +41,44 @@ module Mysql2
 end
 
 if defined?(ActiveRecord::VERSION::STRING) && ActiveRecord::VERSION::STRING < "3.1"
-  puts "WARNING: This version of mysql2 (#{Mysql2::VERSION}) doesn't ship with the ActiveRecord adapter bundled anymore as it's now part of Rails 3.1"
-  puts "WARNING: Please use the 0.2.x releases if you plan on using it in Rails <= 3.0.x"
+  begin
+    require 'active_record/connection_adapters/mysql2_adapter'
+  rescue LoadError
+    warn "============= WARNING FROM mysql2 ============="
+    warn "This version of mysql2 (#{Mysql2::VERSION}) doesn't ship with the ActiveRecord adapter."
+    warn "In Rails version 3.1.0 and up, the mysql2 ActiveRecord adapter is included with rails."
+    warn "If you want to use the mysql2 gem with Rails <= 3.0.x, please use the latest mysql2 in the 0.2.x series."
+    warn "============= END WARNING FROM mysql2 ============="
+  end
+end
+
+# For holding utility methods
+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
+
+    #
+    # 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.
+    #
+    if Thread.respond_to?(:handle_interrupt)
+      require 'timeout'
+      # rubocop:disable Style/ConstantName
+      TimeoutError = if defined?(::Timeout::ExitException)
+        ::Timeout::ExitException
+      else
+        ::Timeout::Error
+      end
+    end
+  end
 end

data/spec/configuration.yml.example

@@ -0,0 +1,11 @@
+root:
+  host: localhost
+  username: root
+  password:
+  database: test
+
+user:
+  host: localhost
+  username: LOCALUSERNAME
+  password:
+  database: mysql2_test