mysql2 0.2.21 → 0.2.22

data/lib/mysql2/error.rb

@@ -1,15 +1,81 @@
+# encoding: UTF-8
+
 module Mysql2
   class Error < StandardError
-    attr_accessor :error_number, :sql_state
+    REPLACEMENT_CHAR = '?'
+    ENCODE_OPTS      = {:undef => :replace, :invalid => :replace, :replace => REPLACEMENT_CHAR}
 
-    def initialize msg
-      super
-      @error_number = nil
-      @sql_state    = nil
-    end
+    attr_accessor :error_number, :sql_state
+    attr_writer   :server_version
 
     # Mysql gem compatibility
     alias_method :errno, :error_number
     alias_method :error, :message
+
+    def initialize(msg, server_version=nil)
+      self.server_version = server_version
+
+      super(clean_message(msg))
+    end
+
+    if "".respond_to? :encode
+      def sql_state=(state)
+        @sql_state = state.encode(ENCODE_OPTS)
+      end
+    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 contetx.
+    #
+    # 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 if !message.respond_to?(:encoding)
+
+      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
+      end
+    end
   end
 end

data/lib/mysql2/version.rb

@@ -1,3 +1,3 @@
 module Mysql2
-  VERSION = "0.2.21"
+  VERSION = "0.2.22"
 end

data/spec/mysql2/client_spec.rb

@@ -7,13 +7,14 @@ describe Mysql2::Client do
 
     it "should not raise an exception for valid defaults group" do
       lambda {
-        @client = Mysql2::Client.new(:default_file => cnf_file, :default_group => "test")
+        opts = DatabaseCredentials['root'].merge(:default_file => cnf_file, :default_group => "test")
+        @client = Mysql2::Client.new(opts)
       }.should_not raise_error(Mysql2::Error)
     end
 
     it "should not raise an exception without default group" do
       lambda {
-        @client = Mysql2::Client.new(:default_file => cnf_file)
+        @client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:default_file => cnf_file))
       }.should_not raise_error(Mysql2::Error)
     end
   end
@@ -78,7 +79,10 @@ describe Mysql2::Client do
   end
 
   it "should be able to connect via SSL options" do
-    pending("DON'T WORRY, THIS TEST PASSES :) - but is machine-specific. You need to have MySQL running with SSL configured and enabled. Then update the paths in this test to your needs and remove the pending state.")
+    ssl = @client.query "SHOW VARIABLES LIKE 'have_%ssl'"
+    ssl_enabled = ssl.any? {|x| x['Value'] == 'ENABLED'}
+    pending("DON'T WORRY, THIS TEST PASSES - but SSL is not enabled in your MySQL daemon.") unless ssl_enabled
+    pending("DON'T WORRY, THIS TEST PASSES - but you must update the SSL cert paths in this test and remove this pending state.")
     ssl_client = nil
     lambda {
       ssl_client = Mysql2::Client.new(
@@ -104,6 +108,24 @@ describe Mysql2::Client do
     ssl_client.close
   end
 
+  it "should not leave dangling connections after garbage collection" do
+    GC.start
+    sleep 0.300 # Let GC do its work
+    client = Mysql2::Client.new(DatabaseCredentials['root'])
+    before_count = client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
+
+    10.times do
+      Mysql2::Client.new(DatabaseCredentials['root']).query('SELECT 1')
+    end
+    after_count = client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
+    after_count.should == before_count + 10
+
+    GC.start
+    sleep 0.300 # Let GC do its work
+    final_count = client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
+    final_count.should == before_count
+  end
+
   it "should be able to connect to database with numeric-only name" do
     lambda {
       creds = DatabaseCredentials['numericuser']
@@ -179,6 +201,49 @@ describe Mysql2::Client do
     end
   end
 
+  context ":local_infile" do
+    before(:all) do
+      @client_i = Mysql2::Client.new DatabaseCredentials['root'].merge(:local_infile => true)
+      local = @client_i.query "SHOW VARIABLES LIKE 'local_infile'"
+      local_enabled = local.any? {|x| x['Value'] == 'ON'}
+      pending("DON'T WORRY, THIS TEST PASSES - but LOCAL INFILE is not enabled in your MySQL daemon.") unless local_enabled
+
+      @client_i.query %[
+        CREATE TABLE IF NOT EXISTS infileTest (
+          id MEDIUMINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
+          foo VARCHAR(10),
+          bar MEDIUMTEXT
+        )
+      ]
+    end
+
+    after(:all) do
+      @client_i.query "DROP TABLE infileTest"
+    end
+
+    it "should raise an error when local_infile is disabled" do
+      client = Mysql2::Client.new DatabaseCredentials['root'].merge(:local_infile => false)
+      lambda {
+        client.query "LOAD DATA LOCAL INFILE 'spec/test_data' INTO TABLE infileTest"
+      }.should raise_error(Mysql2::Error, %r{command is not allowed})
+    end
+
+    it "should raise an error when a non-existent file is loaded" do
+      lambda {
+        @client_i.query "LOAD DATA LOCAL INFILE 'this/file/is/not/here' INTO TABLE infileTest"
+      }.should_not raise_error(Mysql2::Error, %r{file not found: this/file/is/not/here})
+    end
+
+    it "should LOAD DATA LOCAL INFILE" do
+      @client_i.query "LOAD DATA LOCAL INFILE 'spec/test_data' INTO TABLE infileTest"
+      info = @client_i.query_info
+      info.should eql({:records => 1, :deleted => 0, :skipped => 0, :warnings => 0})
+
+      result = @client_i.query "SELECT * FROM infileTest"
+      result.first.should eql({'id' => 1, 'foo' => 'Hello', 'bar' => 'World'})
+    end
+  end
+
   it "should expect connect_timeout to be a positive integer" do
     lambda {
       Mysql2::Client.new(:connect_timeout => -1)
@@ -332,6 +397,7 @@ describe Mysql2::Client do
       end
 
       it "should close the connection when an exception is raised" do
+        pending "Ruby 2.1 has changed Timeout behavior." if RUBY_VERSION =~ /2.1/
         begin
           Timeout.timeout(1) do
             @client.query("SELECT sleep(2)")
@@ -345,6 +411,7 @@ describe Mysql2::Client do
       end
 
       it "should handle Timeouts without leaving the connection hanging if reconnect is true" do
+        pending "Ruby 2.1 has changed Timeout behavior." if RUBY_VERSION =~ /2.1/
         client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:reconnect => true))
         begin
           Timeout.timeout(1) do
@@ -359,6 +426,7 @@ describe Mysql2::Client do
       end
 
       it "should handle Timeouts without leaving the connection hanging if reconnect is set to true after construction true" do
+        pending "Ruby 2.1 has changed Timeout behavior." if RUBY_VERSION =~ /2.1/
         client = Mysql2::Client.new(DatabaseCredentials['root'])
         begin
           Timeout.timeout(1) do
@@ -433,6 +501,15 @@ describe Mysql2::Client do
         @multi_client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:flags => Mysql2::Client::MULTI_STATEMENTS))
       end
 
+      it "should raise an exception when one of multiple statements fails" do
+        result = @multi_client.query("SELECT 1 as 'set_1'; SELECT * FROM invalid_table_name;SELECT 2 as 'set_2';")
+        result.first['set_1'].should be(1)
+        lambda {
+          @multi_client.next_result
+        }.should raise_error(Mysql2::Error)
+        @multi_client.next_result.should be_false
+      end
+
       it "returns multiple result sets" do
         @multi_client.query( "select 1 as 'set_1'; select 2 as 'set_2'").first.should eql({ 'set_1' => 1 })
 
@@ -579,18 +656,22 @@ describe Mysql2::Client do
   if defined? Encoding
     context "strings returned by #info" do
       it "should default to the connection's encoding if Encoding.default_internal is nil" do
-        Encoding.default_internal = nil
-        @client.info[:version].encoding.should eql(Encoding.find('utf-8'))
+        with_internal_encoding nil do
+          @client.info[:version].encoding.should eql(Encoding.find('utf-8'))
 
-        client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
-        client2.info[:version].encoding.should eql(Encoding.find('us-ascii'))
+          client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
+          client2.info[:version].encoding.should eql(Encoding.find('us-ascii'))
+        end
       end
 
       it "should use Encoding.default_internal" do
-        Encoding.default_internal = Encoding.find('utf-8')
-        @client.info[:version].encoding.should eql(Encoding.default_internal)
-        Encoding.default_internal = Encoding.find('us-ascii')
-        @client.info[:version].encoding.should eql(Encoding.default_internal)
+        with_internal_encoding 'utf-8' do
+          @client.info[:version].encoding.should eql(Encoding.default_internal)
+        end
+
+        with_internal_encoding 'us-ascii' do
+          @client.info[:version].encoding.should eql(Encoding.default_internal)
+        end
       end
     end
   end
@@ -618,18 +699,22 @@ describe Mysql2::Client do
   if defined? Encoding
     context "strings returned by #server_info" do
       it "should default to the connection's encoding if Encoding.default_internal is nil" do
-        Encoding.default_internal = nil
-        @client.server_info[:version].encoding.should eql(Encoding.find('utf-8'))
+        with_internal_encoding nil do
+          @client.server_info[:version].encoding.should eql(Encoding.find('utf-8'))
 
-        client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
-        client2.server_info[:version].encoding.should eql(Encoding.find('us-ascii'))
+          client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
+          client2.server_info[:version].encoding.should eql(Encoding.find('us-ascii'))
+        end
       end
 
       it "should use Encoding.default_internal" do
-        Encoding.default_internal = Encoding.find('utf-8')
-        @client.server_info[:version].encoding.should eql(Encoding.default_internal)
-        Encoding.default_internal = Encoding.find('us-ascii')
-        @client.server_info[:version].encoding.should eql(Encoding.default_internal)
+        with_internal_encoding 'utf-8' do
+          @client.server_info[:version].encoding.should eql(Encoding.default_internal)
+        end
+
+        with_internal_encoding 'us-ascii' do
+          @client.server_info[:version].encoding.should eql(Encoding.default_internal)
+        end
       end
     end
   end
@@ -647,7 +732,7 @@ describe Mysql2::Client do
   context 'write operations api' do
     before(:each) do
       @client.query "USE test"
-      @client.query "CREATE TABLE IF NOT EXISTS lastIdTest (`id` int(11) NOT NULL AUTO_INCREMENT, blah INT(11), PRIMARY KEY (`id`))"
+      @client.query "CREATE TABLE IF NOT EXISTS lastIdTest (`id` BIGINT NOT NULL AUTO_INCREMENT, blah INT(11), PRIMARY KEY (`id`))"
     end
 
     after(:each) do
@@ -674,6 +759,15 @@ describe Mysql2::Client do
       @client.query "UPDATE lastIdTest SET blah=4321 WHERE id=1"
       @client.affected_rows.should eql(1)
     end
+
+    it "#last_id should handle BIGINT auto-increment ids above 32 bits" do
+      # The id column type must be BIGINT. Surprise: INT(x) is limited to 32-bits for all values of x.
+      # Insert a row with a given ID, this should raise the auto-increment state
+      @client.query "INSERT INTO lastIdTest (id, blah) VALUES (5000000000, 5000)"
+      @client.last_id.should eql(5000000000)
+      @client.query "INSERT INTO lastIdTest (blah) VALUES (5001)"
+      @client.last_id.should eql(5000000001)
+    end
   end
 
   it "should respond to #thread_id" do

data/spec/mysql2/error_spec.rb

@@ -1,72 +1,82 @@
 # encoding: UTF-8
+
 require 'spec_helper'
 
 describe Mysql2::Error do
-  before(:each) do
-    begin
-      @err_client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "utf8"))
-      @err_client.query("HAHAHA")
-    rescue Mysql2::Error => e
-      @error = e
-    ensure
-      @err_client.close
-    end
+  let(:client) { Mysql2::Client.new(DatabaseCredentials['root']) }
 
+  let :error do
     begin
-      @err_client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "big5"))
-      @err_client2.query("HAHAHA")
+      client.query("HAHAHA")
     rescue Mysql2::Error => e
-      @error2 = e
+      error = e
     ensure
-      @err_client2.close
+      client.close
     end
-  end
 
-  it "should respond to #error_number" do
-    @error.should respond_to(:error_number)
+    error
   end
 
-  it "should respond to #sql_state" do
-    @error.should respond_to(:sql_state)
-  end
+  it "responds to error_number and sql_state, with aliases" do
+    error.should respond_to(:error_number)
+    error.should respond_to(:sql_state)
 
-  # Mysql gem compatibility
-  it "should alias #error_number to #errno" do
-    @error.should respond_to(:errno)
+    # Mysql gem compatibility
+    error.should respond_to(:errno)
+    error.should respond_to(:error)
   end
 
-  it "should alias #message to #error" do
-    @error.should respond_to(:error)
-  end
+  if "".respond_to? :encoding
+    let :error do
+      client = Mysql2::Client.new(DatabaseCredentials['root'])
+      begin
+        client.query("\xE9\x80\xA0\xE5\xAD\x97")
+      rescue Mysql2::Error => e
+        error = e
+      ensure
+        client.close
+      end
 
-  unless RUBY_VERSION =~ /1.8/
-    it "#message encoding should match the connection's encoding, or Encoding.default_internal if set" do
-      if Encoding.default_internal.nil?
-        @error.message.encoding.should eql(@err_client.encoding)
-        @error2.message.encoding.should eql(@err_client2.encoding)
-      else
-        @error.message.encoding.should eql(Encoding.default_internal)
-        @error2.message.encoding.should eql(Encoding.default_internal)
+      error
+    end
+
+    let :bad_err do
+      client = Mysql2::Client.new(DatabaseCredentials['root'])
+      begin
+        client.query("\xE5\xC6\x7D\x1F")
+      rescue Mysql2::Error => e
+        error = e
+      ensure
+        client.close
       end
+
+      error
     end
 
-    it "#error encoding should match the connection's encoding, or Encoding.default_internal if set" do
-      if Encoding.default_internal.nil?
-        @error.error.encoding.should eql(@err_client.encoding)
-        @error2.error.encoding.should eql(@err_client2.encoding)
-      else
-        @error.error.encoding.should eql(Encoding.default_internal)
-        @error2.error.encoding.should eql(Encoding.default_internal)
+    it "returns error messages as UTF-8 by default" do
+      with_internal_encoding nil do
+        error.message.encoding.should eql(Encoding::UTF_8)
+        error.message.valid_encoding?
+
+        bad_err.message.encoding.should eql(Encoding::UTF_8)
+        bad_err.message.valid_encoding?
+
+        bad_err.message.should include("??}\u001F")
       end
     end
 
-    it "#sql_state encoding should match the connection's encoding, or Encoding.default_internal if set" do
-      if Encoding.default_internal.nil?
-        @error.sql_state.encoding.should eql(@err_client.encoding)
-        @error2.sql_state.encoding.should eql(@err_client2.encoding)
-      else
-        @error.sql_state.encoding.should eql(Encoding.default_internal)
-        @error2.sql_state.encoding.should eql(Encoding.default_internal)
+    it "returns sql state as ASCII" do
+      error.sql_state.encoding.should eql(Encoding::US_ASCII)
+      error.sql_state.valid_encoding?
+    end
+
+    it "returns error messages and sql state in Encoding.default_internal if set" do
+      with_internal_encoding 'UTF-16LE' do
+        error.message.encoding.should eql(Encoding.default_internal)
+        error.message.valid_encoding?
+
+        bad_err.message.encoding.should eql(Encoding.default_internal)
+        bad_err.message.valid_encoding?
       end
     end
   end