mysql2 0.4.1 → 0.4.6

data/ext/mysql2/statement.h

@@ -7,6 +7,7 @@ typedef struct {
   VALUE client;
   MYSQL_STMT *stmt;
   int refcount;
+  int closed;
 } mysql_stmt_wrapper;
 
 void init_mysql2_statement(void);

data/lib/mysql2/client.rb

@@ -10,7 +10,7 @@ module Mysql2
         :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
+        :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,
@@ -19,6 +19,7 @@ module Mysql2
     end
 
     def initialize(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 = self.class.default_query_options.dup
@@ -30,13 +31,13 @@ module Mysql2
       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].each do |key|
+      [:reconnect, :connect_timeout, :local_infile, :read_timeout, :write_timeout, :default_file, :default_group, :secure_auth, :init_command, :automatic_close].each do |key|
         next unless opts.key?(key)
         case key
-        when :reconnect, :local_infile, :secure_auth
+        when :reconnect, :local_infile, :secure_auth, :automatic_close
           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
@@ -47,11 +48,20 @@ module Mysql2
 
       ssl_options = opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslcipher)
       ssl_set(*ssl_options) if ssl_options.any?
+      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 = 0
-      flags |= @query_options[:connect_flags]
-      flags |= opts[:flags] if opts[:flags]
       flags |= SSL_VERIFY_SERVER_CERT if opts[:sslverify] && ssl_options.any?
 
       if [:user, :pass, :hostname, :dbname, :db, :sock].any? { |k| @query_options.key?(k) }
@@ -79,6 +89,31 @@ module Mysql2
       connect user, pass, host, port, database, socket, flags
     end
 
+    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)
       def query(sql, options = {})
         Thread.handle_interrupt(::Mysql2::Util::TimeoutError => :never) do

data/lib/mysql2/version.rb

@@ -1,3 +1,3 @@
 module Mysql2
-  VERSION = "0.4.1"
+  VERSION = "0.4.6"
 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/mysql2/client_spec.rb

@@ -33,6 +33,12 @@ RSpec.describe Mysql2::Client do
     }.to raise_error(Mysql2::Error)
   end
 
+  it "should raise an exception on non-string encodings" do
+    expect {
+      Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => :fake))
+    }.to raise_error(TypeError)
+  end
+
   it "should not raise an exception on create for a valid encoding" do
     expect {
       Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "utf8"))
@@ -43,27 +49,33 @@ RSpec.describe Mysql2::Client do
     }.not_to raise_error
   end
 
-  it "should accept connect flags and pass them to #connect" do
-    klient = Class.new(Mysql2::Client) do
-      attr_reader :connect_args
-      def connect(*args)
-        @connect_args ||= []
-        @connect_args << args
-      end
+  Klient = Class.new(Mysql2::Client) do
+    attr_reader :connect_args
+    def connect(*args)
+      @connect_args ||= []
+      @connect_args << args
     end
-    client = klient.new :flags => Mysql2::Client::FOUND_ROWS
+  end
+
+  it "should accept connect flags and pass them to #connect" do
+    client = Klient.new :flags => Mysql2::Client::FOUND_ROWS
     expect(client.connect_args.last[6] & Mysql2::Client::FOUND_ROWS).to be > 0
   end
 
+  it "should parse flags array" do
+    client = Klient.new :flags => %w( FOUND_ROWS -PROTOCOL_41 )
+    expect(client.connect_args.last[6] & Mysql2::Client::FOUND_ROWS).to eql(Mysql2::Client::FOUND_ROWS)
+    expect(client.connect_args.last[6] & Mysql2::Client::PROTOCOL_41).to eql(0)
+  end
+
+  it "should parse flags string" do
+    client = Klient.new :flags => "FOUND_ROWS -PROTOCOL_41"
+    expect(client.connect_args.last[6] & Mysql2::Client::FOUND_ROWS).to eql(Mysql2::Client::FOUND_ROWS)
+    expect(client.connect_args.last[6] & Mysql2::Client::PROTOCOL_41).to eql(0)
+  end
+
   it "should default flags to (REMEMBER_OPTIONS, LONG_PASSWORD, LONG_FLAG, TRANSACTIONS, PROTOCOL_41, SECURE_CONNECTION)" do
-    klient = Class.new(Mysql2::Client) do
-      attr_reader :connect_args
-      def connect(*args)
-        @connect_args ||= []
-        @connect_args << args
-      end
-    end
-    client = klient.new
+    client = Klient.new
     client_flags = Mysql2::Client::REMEMBER_OPTIONS |
                    Mysql2::Client::LONG_PASSWORD |
                    Mysql2::Client::LONG_FLAG |
@@ -139,16 +151,12 @@ RSpec.describe Mysql2::Client do
       # rubocop:enable Style/TrailingComma
     }.not_to raise_error
 
-    results = ssl_client.query("SHOW STATUS WHERE Variable_name = \"Ssl_version\" OR Variable_name = \"Ssl_cipher\"").to_a
-    expect(results[0]['Variable_name']).to eql('Ssl_cipher')
-    expect(results[0]['Value']).not_to be_nil
-    expect(results[0]['Value']).to be_an_instance_of(String)
-    expect(results[0]['Value']).not_to be_empty
+    results = Hash[ssl_client.query('SHOW STATUS WHERE Variable_name LIKE "Ssl_%"').map { |x| x.values_at('Variable_name', 'Value') }]
+    expect(results['Ssl_cipher']).not_to be_empty
+    expect(results['Ssl_version']).not_to be_empty
 
-    expect(results[1]['Variable_name']).to eql('Ssl_version')
-    expect(results[1]['Value']).not_to be_nil
-    expect(results[1]['Value']).to be_an_instance_of(String)
-    expect(results[1]['Value']).not_to be_empty
+    expect(ssl_client.ssl_cipher).not_to be_empty
+    expect(results['Ssl_cipher']).to eql(ssl_client.ssl_cipher)
 
     ssl_client.close
   end
@@ -166,58 +174,107 @@ RSpec.describe Mysql2::Client do
     expect {
       Mysql2::Client.new(DatabaseCredentials['root']).close
     }.to_not change {
-      @client.query("SHOW STATUS LIKE 'Aborted_clients'").first['Value'].to_i
+      @client.query("SHOW STATUS LIKE 'Aborted_%'").to_a +
+        @client.query("SHOW STATUS LIKE 'Threads_connected'").to_a
     }
   end
 
   it "should not leave dangling connections after garbage collection" do
     run_gc
+    expect {
+      expect {
+        10.times do
+          Mysql2::Client.new(DatabaseCredentials['root']).query('SELECT 1')
+        end
+      }.to change {
+        @client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
+      }.by(10)
 
-    client = Mysql2::Client.new(DatabaseCredentials['root'])
-    before_count = client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
+      run_gc
+    }.to_not change {
+      @client.query("SHOW STATUS LIKE 'Aborted_%'").to_a +
+        @client.query("SHOW STATUS LIKE 'Threads_connected'").to_a
+    }
+  end
 
-    10.times do
-      Mysql2::Client.new(DatabaseCredentials['root']).query('SELECT 1')
+  context "#automatic_close" do
+    it "is enabled by default" do
+      client = Mysql2::Client.new(DatabaseCredentials['root'])
+      expect(client.automatic_close?).to be(true)
     end
-    after_count = client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
-    expect(after_count).to eq(before_count + 10)
 
-    run_gc
-    final_count = client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
-    expect(final_count).to eq(before_count)
-  end
+    if RUBY_PLATFORM =~ /mingw|mswin/
+      it "cannot be disabled" do
+        expect do
+          client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:automatic_close => false))
+          expect(client.automatic_close?).to be(true)
+        end.to output(/always closed by garbage collector/).to_stderr
 
-  it "should not close connections when running in a child process" do
-    pending("fork is not available on this platform") unless Process.respond_to?(:fork)
+        expect do
+          client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:automatic_close => true))
+          expect(client.automatic_close?).to be(true)
+        end.to_not output(/always closed by garbage collector/).to_stderr
 
-    run_gc
-    client = Mysql2::Client.new(DatabaseCredentials['root'])
+        expect do
+          client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:automatic_close => true))
+          client.automatic_close = false
+          expect(client.automatic_close?).to be(true)
+        end.to output(/always closed by garbage collector/).to_stderr
+      end
+    else
+      it "can be configured" do
+        client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:automatic_close => false))
+        expect(client.automatic_close?).to be(false)
+      end
 
-    # this empty `fork` call fixes this tests on RBX; without it, the next
-    # `fork` call hangs forever. WTF?
-    fork {}
+      it "can be assigned" do
+        client = Mysql2::Client.new(DatabaseCredentials['root'])
+        client.automatic_close = false
+        expect(client.automatic_close?).to be(false)
 
-    fork do
-      client.query('SELECT 1')
-      client = nil
-      run_gc
-    end
+        client.automatic_close = true
+        expect(client.automatic_close?).to be(true)
+
+        client.automatic_close = nil
+        expect(client.automatic_close?).to be(false)
+
+        client.automatic_close = 9
+        expect(client.automatic_close?).to be(true)
+      end
+
+      it "should not close connections when running in a child process" do
+        run_gc
+        client = Mysql2::Client.new(DatabaseCredentials['root'])
+        client.automatic_close = false
+
+        # this empty `fork` call fixes this tests on RBX; without it, the next
+        # `fork` call hangs forever. WTF?
+        fork {}
 
-    Process.wait
+        fork do
+          client.query('SELECT 1')
+          client = nil
+          run_gc
+        end
+
+        Process.wait
 
-    # this will throw an error if the underlying socket was shutdown by the
-    # child's GC
-    expect { client.query('SELECT 1') }.to_not raise_exception
+        # this will throw an error if the underlying socket was shutdown by the
+        # child's GC
+        expect { client.query('SELECT 1') }.to_not raise_exception
+      end
+    end
   end
 
   it "should be able to connect to database with numeric-only name" do
-    creds = DatabaseCredentials['numericuser']
-    @client.query "CREATE DATABASE IF NOT EXISTS `#{creds['database']}`"
-    @client.query "GRANT ALL ON `#{creds['database']}`.* TO #{creds['username']}@`#{creds['host']}`"
+    database = 1235
+    @client.query "CREATE DATABASE IF NOT EXISTS `#{database}`"
 
-    expect { Mysql2::Client.new(creds) }.not_to raise_error
+    expect {
+      Mysql2::Client.new(DatabaseCredentials['root'].merge('database' => database))
+    }.not_to raise_error
 
-    @client.query "DROP DATABASE IF EXISTS `#{creds['database']}`"
+    @client.query "DROP DATABASE IF EXISTS `#{database}`"
   end
 
   it "should respond to #close" do
@@ -330,22 +387,28 @@ RSpec.describe Mysql2::Client do
 
   it "should expect connect_timeout to be a positive integer" do
     expect {
-      Mysql2::Client.new(:connect_timeout => -1)
+      Mysql2::Client.new(DatabaseCredentials['root'].merge(:connect_timeout => -1))
     }.to raise_error(Mysql2::Error)
   end
 
   it "should expect read_timeout to be a positive integer" do
     expect {
-      Mysql2::Client.new(:read_timeout => -1)
+      Mysql2::Client.new(DatabaseCredentials['root'].merge(:read_timeout => -1))
     }.to raise_error(Mysql2::Error)
   end
 
   it "should expect write_timeout to be a positive integer" do
     expect {
-      Mysql2::Client.new(:write_timeout => -1)
+      Mysql2::Client.new(DatabaseCredentials['root'].merge(:write_timeout => -1))
     }.to raise_error(Mysql2::Error)
   end
 
+  it "should allow nil read_timeout" do
+    client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:read_timeout => nil))
+
+    expect(client.read_timeout).to be_nil
+  end
+
   context "#query" do
     it "should let you query again if iterating is finished when streaming" do
       @client.query("SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false).each.to_a
@@ -475,15 +538,6 @@ RSpec.describe Mysql2::Client do
         }.to raise_error(Mysql2::Error)
       end
 
-      it 'should be impervious to connection-corrupting timeouts in #query' do
-        pending('`Thread.handle_interrupt` is not defined') unless Thread.respond_to?(:handle_interrupt)
-        # attempt to break the connection
-        expect { Timeout.timeout(0.1) { @client.query('SELECT SLEEP(0.2)') } }.to raise_error(Timeout::Error)
-
-        # expect the connection to not be broken
-        expect { @client.query('SELECT 1') }.to_not raise_error
-      end
-
       it 'should be impervious to connection-corrupting timeouts in #execute' do
         # the statement handle gets corrupted and will segfault the tests if interrupted,
         # so we can't even use pending on this test, really have to skip it on older Rubies.
@@ -501,7 +555,7 @@ RSpec.describe Mysql2::Client do
       context 'when a non-standard exception class is raised' do
         it "should close the connection when an exception is raised" do
           expect { Timeout.timeout(0.1, ArgumentError) { @client.query('SELECT SLEEP(1)') } }.to raise_error(ArgumentError)
-          expect { @client.query('SELECT 1') }.to raise_error(Mysql2::Error, 'closed MySQL connection')
+          expect { @client.query('SELECT 1') }.to raise_error(Mysql2::Error, 'MySQL client is not connected')
         end
 
         it "should handle Timeouts without leaving the connection hanging if reconnect is true" do

data/spec/mysql2/error_spec.rb

@@ -34,7 +34,7 @@ RSpec.describe Mysql2::Error do
       end
     end
 
-    let(:invalid_utf8) { "\xE5\xC6\x7D\x1F" }
+    let(:invalid_utf8) { ["e5c67d1f"].pack('H*').force_encoding(Encoding::UTF_8) }
     let(:bad_err) do
       begin
         client.query(invalid_utf8)

data/spec/mysql2/result_spec.rb

@@ -22,6 +22,10 @@ RSpec.describe Mysql2::Result do
     expect(@result).to respond_to(:each)
   end
 
+  it "should respond to #free" do
+    expect(@result).to respond_to(:free)
+  end
+
   it "should raise a Mysql2::Error exception upon a bad query" do
     expect {
       @client.query "bad sql"
@@ -78,6 +82,11 @@ RSpec.describe Mysql2::Result do
       expect(result.first.object_id).not_to eql(result.first.object_id)
     end
 
+    it "should be able to iterate a second time even if cache_rows is disabled" do
+      result = @client.query "SELECT 1 UNION SELECT 2", :cache_rows => false
+      expect(result.to_a).to eql(result.to_a)
+    end
+
     it "should yield different value for #first if streaming" do
       result = @client.query "SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false
       expect(result.first).not_to eql(result.first)

data/spec/mysql2/statement_spec.rb

@@ -6,11 +6,13 @@ RSpec.describe Mysql2::Statement do
     @client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "utf8"))
   end
 
+  def stmt_count
+    @client.query("SHOW STATUS LIKE 'Prepared_stmt_count'").first['Value'].to_i
+  end
+
   it "should create a statement" do
     statement = nil
-    expect { statement = @client.prepare 'SELECT 1' }.to change {
-      @client.query("SHOW STATUS LIKE 'Prepared_stmt_count'").first['Value'].to_i
-    }.by(1)
+    expect { statement = @client.prepare 'SELECT 1' }.to change(&method(:stmt_count)).by(1)
     expect(statement).to be_an_instance_of(Mysql2::Statement)
   end
 
@@ -59,6 +61,26 @@ RSpec.describe Mysql2::Statement do
     expect(rows).to eq([{ "1" => 1 }])
   end
 
+  it "should handle bignum but in int64_t" do
+    stmt = @client.prepare('SELECT ? AS max, ? AS min')
+    int64_max = (1 << 63) - 1
+    int64_min = -(1 << 63)
+    result = stmt.execute(int64_max, int64_min)
+    expect(result.to_a).to eq(['max' => int64_max, 'min' => int64_min])
+  end
+
+  it "should handle bignum but beyond int64_t" do
+    stmt = @client.prepare('SELECT ? AS max1, ? AS max2, ? AS max3, ? AS min1, ? AS min2, ? AS min3')
+    int64_max1 = (1 << 63)
+    int64_max2 = (1 << 64) - 1
+    int64_max3 = 1 << 64
+    int64_min1 = -(1 << 63) - 1
+    int64_min2 = -(1 << 64) + 1
+    int64_min3 = -0xC000000000000000
+    result = stmt.execute(int64_max1, int64_max2, int64_max3, int64_min1, int64_min2, int64_min3)
+    expect(result.to_a).to eq(['max1' => int64_max1, 'max2' => int64_max2, 'max3' => int64_max3, 'min1' => int64_min1, 'min2' => int64_min2, 'min3' => int64_min3])
+  end
+
   it "should keep its result after other query" do
     @client.query 'USE test'
     @client.query 'CREATE TABLE IF NOT EXISTS mysql2_stmt_q(a int)'
@@ -108,6 +130,35 @@ RSpec.describe Mysql2::Statement do
     expect(result.first.first[1]).to be_an_instance_of(Time)
   end
 
+  it "should prepare Date values" do
+    now = Date.today
+    statement = @client.prepare('SELECT ? AS a')
+    result = statement.execute(now)
+    expect(result.first['a'].to_s).to eql(now.strftime('%F'))
+  end
+
+  it "should prepare Time values with microseconds" do
+    now = Time.now
+    statement = @client.prepare('SELECT ? AS a')
+    result = statement.execute(now)
+    if RUBY_VERSION =~ /1.8/
+      expect(result.first['a'].strftime('%F %T %z')).to eql(now.strftime('%F %T %z'))
+    else
+      expect(result.first['a'].strftime('%F %T.%6N %z')).to eql(now.strftime('%F %T.%6N %z'))
+    end
+  end
+
+  it "should prepare DateTime values with microseconds" do
+    now = DateTime.now
+    statement = @client.prepare('SELECT ? AS a')
+    result = statement.execute(now)
+    if RUBY_VERSION =~ /1.8/
+      expect(result.first['a'].strftime('%F %T %z')).to eql(now.strftime('%F %T %z'))
+    else
+      expect(result.first['a'].strftime('%F %T.%6N %z')).to eql(now.strftime('%F %T.%6N %z'))
+    end
+  end
+
   it "should tell us about the fields" do
     statement = @client.prepare 'SELECT 1 as foo, 2'
     statement.execute
@@ -117,6 +168,32 @@ RSpec.describe Mysql2::Statement do
     expect(list[1]).to eq('2')
   end
 
+  it "should handle as a decimal binding a BigDecimal" do
+    stmt = @client.prepare('SELECT ? AS decimal_test')
+    test_result = stmt.execute(BigDecimal.new("123.45")).first
+    expect(test_result['decimal_test']).to be_an_instance_of(BigDecimal)
+    expect(test_result['decimal_test']).to eql(123.45)
+  end
+
+  it "should update a DECIMAL value passing a BigDecimal" do
+    @client.query 'USE test'
+    @client.query 'DROP TABLE IF EXISTS mysql2_stmt_decimal_test'
+    @client.query 'CREATE TABLE mysql2_stmt_decimal_test (decimal_test DECIMAL(10,3))'
+
+    @client.prepare("INSERT INTO mysql2_stmt_decimal_test VALUES (?)").execute(BigDecimal.new("123.45"))
+
+    test_result = @client.query("SELECT * FROM mysql2_stmt_decimal_test").first
+    expect(test_result['decimal_test']).to eql(123.45)
+  end
+
+  it "should warn but still work if cache_rows is set to false" do
+    @client.query_options.merge!(:cache_rows => false)
+    statement = @client.prepare 'SELECT 1'
+    result = nil
+    expect { result = statement.execute.to_a }.to output(/:cache_rows is forced for prepared statements/).to_stderr
+    expect(result.length).to eq(1)
+  end
+
   context "utf8_db" do
     before(:each) do
       @client.query("DROP DATABASE IF EXISTS test_mysql2_stmt_utf8")
@@ -670,9 +747,7 @@ RSpec.describe Mysql2::Statement do
   context 'close' do
     it 'should free server resources' do
       stmt = @client.prepare 'SELECT 1'
-      expect { stmt.close }.to change {
-        @client.query("SHOW STATUS LIKE 'Prepared_stmt_count'").first['Value'].to_i
-      }.by(-1)
+      expect { stmt.close }.to change(&method(:stmt_count)).by(-1)
     end
 
     it 'should raise an error on subsequent execution' do