mysql2 0.3.21 → 0.4.10

data/ext/mysql2/statement.h

@@ -0,0 +1,19 @@
+#ifndef MYSQL2_STATEMENT_H
+#define MYSQL2_STATEMENT_H
+
+extern VALUE cMysql2Statement;
+
+typedef struct {
+  VALUE client;
+  MYSQL_STMT *stmt;
+  int refcount;
+  int closed;
+} mysql_stmt_wrapper;
+
+void init_mysql2_statement(void);
+void decr_mysql2_stmt(mysql_stmt_wrapper *stmt_wrapper);
+
+VALUE rb_mysql_stmt_new(VALUE rb_client, VALUE sql);
+void rb_raise_mysql2_stmt_error(mysql_stmt_wrapper *stmt_wrapper) RB_MYSQL_NORETURN;
+
+#endif

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,
+        :cast => true,
+        :default_file => nil,
+        :default_group => nil,
+      }
+    end
 
     def initialize(opts = {})
-      opts = Mysql2::Util.key_hash_as_symbols( opts )
+      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 = @@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
+      [: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)
         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]
+
+      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.has_key?(k) }
+      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 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?
@@ -70,8 +89,29 @@ module Mysql2
       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
+
+    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
 
     if Thread.respond_to?(:handle_interrupt)
@@ -98,9 +138,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

@@ -17,7 +17,7 @@ module Mysql2
           detach
           begin
             result = @client.async_result
-          rescue Exception => e
+          rescue => e
             @deferable.fail(e)
           else
             @deferable.succeed(result)
@@ -34,17 +34,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))
           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

@@ -2,25 +2,31 @@
 
 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
 
-    attr_accessor :error_number
-    attr_reader   :sql_state
-    attr_writer   :server_version
+    attr_reader :error_number, :sql_state
 
     # Mysql gem compatibility
     alias_method :errno, :error_number
     alias_method :error, :message
 
-    def initialize(msg, server_version=nil)
-      self.server_version = server_version
+    def initialize(msg)
+      @server_version ||= 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)
+      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
@@ -53,27 +59,12 @@ module Mysql2
     #
     # Returns a valid UTF-8 string in Ruby 1.9+, the original string on Ruby 1.8
     def clean_message(message)
-      return message if !message.respond_to?(:encoding)
+      return message unless message.respond_to?(:encode)
 
       if @server_version && @server_version > 50500
         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/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.21"
+  VERSION = "0.4.10"
 end

data/lib/mysql2.rb

@@ -8,16 +8,16 @@ require 'rational' unless RUBY_VERSION >= '1.9.2'
 # 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__)).tr('/', '\\')
+  else
+    # This will use default / system library paths
+    'libmysql.dll'
+  end
 
   require 'Win32API'
   LoadLibrary = Win32API.new('Kernel32', 'LoadLibrary', ['P'], 'I')
@@ -31,6 +31,8 @@ require 'mysql2/error'
 require 'mysql2/mysql2'
 require 'mysql2/result'
 require 'mysql2/client'
+require 'mysql2/field'
+require 'mysql2/statement'
 
 # = Mysql2
 #
@@ -51,32 +53,32 @@ if defined?(ActiveRecord::VERSION::STRING) && ActiveRecord::VERSION::STRING < "3
 end
 
 # For holding utility methods
-module Mysql2::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
+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
+    #
+    # 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

@@ -9,9 +9,3 @@ user:
   username: LOCALUSERNAME
   password:
   database: mysql2_test
-
-numericuser:
-  host: localhost
-  username: LOCALUSERNAME
-  password:
-  database: 12345

data/spec/em/em_spec.rb

@@ -4,7 +4,7 @@ begin
   require 'eventmachine'
   require 'mysql2/em'
 
-  describe Mysql2::EM::Client do
+  RSpec.describe Mysql2::EM::Client do
     it "should support async queries" do
       results = []
       EM.run do
@@ -24,8 +24,8 @@ begin
         end
       end
 
-      results[0].keys.should include("second_query")
-      results[1].keys.should include("first_query")
+      expect(results[0].keys).to include("second_query")
+      expect(results[1].keys).to include("first_query")
     end
 
     it "should support queries in callbacks" do
@@ -44,38 +44,39 @@ begin
         end
       end
 
-      results[0].keys.should include("first_query")
-      results[1].keys.should include("second_query")
+      expect(results[0].keys).to include("first_query")
+      expect(results[1].keys).to include("second_query")
     end
 
     it "should not swallow exceptions raised in callbacks" do
-      lambda {
+      expect {
         EM.run do
           client = Mysql2::EM::Client.new DatabaseCredentials['root']
           defer = client.query "SELECT sleep(0.1) as first_query"
-          defer.callback do |result|
+          defer.callback do
             client.close
-            raise 'some error'
+            fail 'some error'
           end
-          defer.errback do |err|
+          defer.errback do
             # This _shouldn't_ be run, but it needed to prevent the specs from
             # freezing if this test fails.
             EM.stop_event_loop
           end
         end
-      }.should raise_error
+      }.to raise_error('some error')
     end
 
     context 'when an exception is raised by the client' do
       let(:client) { Mysql2::EM::Client.new DatabaseCredentials['root'] }
       let(:error) { StandardError.new('some error') }
-      before { client.stub(:async_result).and_raise(error) }
+      before { allow(client).to receive(:async_result).and_raise(error) }
+      after { client.close }
 
       it "should swallow exceptions raised in by the client" do
         errors = []
         EM.run do
           defer = client.query "SELECT sleep(0.1) as first_query"
-          defer.callback do |result|
+          defer.callback do
             # This _shouldn't_ be run, but it is needed to prevent the specs from
             # freezing if this test fails.
             EM.stop_event_loop
@@ -85,7 +86,7 @@ begin
             EM.stop_event_loop
           end
         end
-        errors.should == [error]
+        expect(errors).to eq([error])
       end
 
       it "should fail the deferrable" do
@@ -93,19 +94,19 @@ begin
         EM.run do
           defer = client.query "SELECT sleep(0.025) as first_query"
           EM.add_timer(0.1) do
-            defer.callback do |result|
+            defer.callback do
               callbacks_run << :callback
               # This _shouldn't_ be run, but it is needed to prevent the specs from
               # freezing if this test fails.
               EM.stop_event_loop
             end
-            defer.errback do |err|
+            defer.errback do
               callbacks_run << :errback
               EM.stop_event_loop
             end
           end
         end
-        callbacks_run.should == [:errback]
+        expect(callbacks_run).to eq([:errback])
       end
     end
 
@@ -114,17 +115,17 @@ begin
       EM.run do
         client = Mysql2::EM::Client.new DatabaseCredentials['root']
         defer = client.query("select sleep(0.025)")
-        defer.callback do |result|
+        defer.callback do
           callbacks_run << :callback
         end
-        defer.errback do |err|
+        defer.errback do
           callbacks_run << :errback
         end
         EM.add_timer(0.1) do
-          callbacks_run.should == [:callback]
-          lambda {
+          expect(callbacks_run).to eq([:callback])
+          expect {
             client.close
-          }.should_not raise_error(/invalid binding to detach/)
+          }.not_to raise_error
           EM.stop_event_loop
         end
       end