mysql2 0.2.18 → 0.2.19b1

data/lib/mysql2/em.rb

@@ -15,18 +15,28 @@ module Mysql2
         def notify_readable
           detach
           begin
-            @deferable.succeed(@client.async_result)
+            result = @client.async_result
           rescue Exception => e
             @deferable.fail(e)
+          else
+            @deferable.succeed(result)
           end
         end
       end
 
+      def close(*args)
+        if @watch
+          @watch.detach
+        end
+        super(*args)
+      end
+
       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(self.socket, Watcher, self, deferable)
+          @watch.notify_readable = true
           deferable
         else
           super(sql, opts)
@@ -34,4 +44,4 @@ module Mysql2
       end
     end
   end
-end
+end

data/lib/mysql2/version.rb

@@ -1,3 +1,3 @@
 module Mysql2
-  VERSION = "0.2.18"
+  VERSION = "0.2.19b1"
 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

data/spec/em/em_fiber_spec.rb

@@ -8,7 +8,7 @@ if defined? EventMachine && defined? Fiber
       results = []
       EM.run do
         Fiber.new {
-          client1 = Mysql2::EM::Fiber::Client.new
+          client1 = Mysql2::EM::Fiber::Client.new DatabaseCredentials['root']
           results = client1.query "SELECT sleep(0.1) as first_query"
           EM.stop_event_loop
         }.resume
@@ -19,4 +19,4 @@ if defined? EventMachine && defined? Fiber
   end
 else
   puts "Either EventMachine or Fibers not available. Skipping tests that use them."
-end
+end

data/spec/em/em_spec.rb

@@ -1,20 +1,21 @@
 # encoding: UTF-8
-if defined? EventMachine
-  require 'spec_helper'
+require 'spec_helper'
+begin
+  require 'eventmachine'
   require 'mysql2/em'
 
   describe Mysql2::EM::Client do
     it "should support async queries" do
       results = []
       EM.run do
-        client1 = Mysql2::EM::Client.new
+        client1 = Mysql2::EM::Client.new DatabaseCredentials['root']
         defer1 = client1.query "SELECT sleep(0.1) as first_query"
         defer1.callback do |result|
           results << result.first
           EM.stop_event_loop
         end
 
-        client2 = Mysql2::EM::Client.new
+        client2 = Mysql2::EM::Client.new DatabaseCredentials['root']
         defer2 = client2.query "SELECT sleep(0.025) second_query"
         defer2.callback do |result|
           results << result.first
@@ -28,7 +29,7 @@ if defined? EventMachine
     it "should support queries in callbacks" do
       results = []
       EM.run do
-        client = Mysql2::EM::Client.new
+        client = Mysql2::EM::Client.new DatabaseCredentials['root']
         defer1 = client.query "SELECT sleep(0.025) as first_query"
         defer1.callback do |result|
           results << result.first
@@ -43,7 +44,67 @@ if defined? EventMachine
       results[0].keys.should include("first_query")
       results[1].keys.should include("second_query")
     end
+
+    it "should not swallow exceptions raised in callbacks" do
+      lambda {
+        EM.run do
+          client = Mysql2::EM::Client.new DatabaseCredentials['root']
+          defer = client.query "SELECT sleep(0.1) as first_query"
+          defer.callback do |result|
+            raise 'some error'
+          end
+          defer.errback do |err|
+            # 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
+    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) }
+
+      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|
+            # 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|
+            errors << err
+            EM.stop_event_loop
+          end
+        end
+        errors.should == [error]
+      end
+
+      it "should fail the deferrable" do
+        callbacks_run = []
+        EM.run do
+          defer = client.query "SELECT sleep(0.025) as first_query"
+          EM.add_timer(0.1) do
+            defer.callback do |result|
+              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|
+              callbacks_run << :errback
+              EM.stop_event_loop
+            end
+          end
+        end
+        callbacks_run.should == [:errback]
+      end
+    end
   end
-else
+rescue LoadError
   puts "EventMachine not installed, skipping the specs that use it"
-end
+end

data/spec/mysql2/client_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 describe Mysql2::Client do
   before(:each) do
-    @client = Mysql2::Client.new
+    @client = Mysql2::Client.new DatabaseCredentials['root']
   end
 
   if defined? Encoding
@@ -92,6 +92,22 @@ describe Mysql2::Client do
   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 {}
+
+      expect {
+        @client.query("SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false)
+      }.to_not raise_exception(Mysql2::Error)
+    end
+
+    it "should not let you query again if iterating is not finished when streaming" do
+      @client.query("SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false).first
+
+      expect {
+        @client.query("SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false)
+      }.to raise_exception(Mysql2::Error)
+    end
+
     it "should only accept strings as the query parameter" do
       lambda {
         @client.query ["SELECT 'not right'"]
@@ -131,8 +147,21 @@ describe Mysql2::Client do
         }.should raise_error(Mysql2::Error)
       end
 
+      it "should describe the thread holding the active query" do
+        thr = Thread.new { @client.query("SELECT 1", :async => true) }
+
+        thr.join
+        begin
+          @client.query("SELECT 1")
+        rescue Mysql2::Error => e
+          message = e.message
+        end
+        re = Regexp.escape(thr.inspect)
+        message.should match(Regexp.new(re))
+      end
+
       it "should timeout if we wait longer than :read_timeout" do
-        client = Mysql2::Client.new(:read_timeout => 1)
+        client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:read_timeout => 1))
         lambda {
           client.query("SELECT sleep(2)")
         }.should raise_error(Mysql2::Error)
@@ -184,14 +213,14 @@ describe Mysql2::Client do
           end
         rescue Timeout::Error
         end
-        
+
         lambda {
           @client.query("SELECT 1")
         }.should raise_error(Mysql2::Error, 'closed MySQL connection')
       end
 
       it "should handle Timeouts without leaving the connection hanging if reconnect is true" do
-        client = Mysql2::Client.new(:reconnect => true)
+        client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:reconnect => true))
         begin
           Timeout.timeout(1) do
             client.query("SELECT sleep(2)")
@@ -206,7 +235,9 @@ describe Mysql2::Client do
 
       it "threaded queries should be supported" do
         threads, results = [], {}
-        connect = lambda{ Mysql2::Client.new(:host => "localhost", :username => "root") }
+        connect = lambda{
+          Mysql2::Client.new(DatabaseCredentials['root'])
+        }
         Timeout.timeout(0.7) do
           5.times {
             threads << Thread.new do
@@ -238,6 +269,38 @@ describe Mysql2::Client do
         result = @client.async_result
         result.class.should eql(Mysql2::Result)
       end
+
+      it "should not allow options to be set on an open connection" do
+        lambda {
+          @client.escape ""
+          @client.query("SELECT 1")
+          @client.options(0, 0)
+        }.should raise_error(Mysql2::Error)
+      end
+    end
+
+    context "Multiple results sets" do
+      before(:each) do
+        @multi_client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:flags => Mysql2::Client::MULTI_STATEMENTS))
+      end
+
+      it "returns multiple result sets" do
+        @multi_client.query( "select 1 as 'set_1'; select 2 as 'set_2'").first.should == { 'set_1' => 1 }
+
+        @multi_client.next_result.should == true
+        @multi_client.store_result.first.should == { 'set_2' => 2 }
+
+        @multi_client.next_result.should == false
+      end
+
+      it "does not interfere with other statements" do
+        @multi_client.query( "select 1 as 'set_1'; select 2 as 'set_2'")
+        while( @multi_client.next_result )
+          @multi_client.store_result
+        end
+
+        @multi_client.query( "select 3 as 'next'").first.should == { 'next' => 3 }
+      end
     end
   end
 
@@ -345,7 +408,7 @@ describe Mysql2::Client do
         Encoding.default_internal = nil
         @client.info[:version].encoding.should eql(Encoding.find('utf-8'))
 
-        client2 = Mysql2::Client.new :encoding => 'ascii'
+        client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
         client2.info[:version].encoding.should eql(Encoding.find('us-ascii'))
       end
 
@@ -384,7 +447,7 @@ describe Mysql2::Client do
         Encoding.default_internal = nil
         @client.server_info[:version].encoding.should eql(Encoding.find('utf-8'))
 
-        client2 = Mysql2::Client.new :encoding => 'ascii'
+        client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
         client2.server_info[:version].encoding.should eql(Encoding.find('us-ascii'))
       end
 
@@ -403,7 +466,7 @@ describe Mysql2::Client do
     }.should raise_error(Mysql2::Error)
 
     lambda {
-      good_client = Mysql2::Client.new
+      good_client = Mysql2::Client.new DatabaseCredentials['root']
     }.should_not raise_error(Mysql2::Error)
   end
 
@@ -451,15 +514,54 @@ describe Mysql2::Client do
     @client.should respond_to(:ping)
   end
 
+  context "select_db" do
+    before(:each) do
+      2.times do |i|
+        @client.query("CREATE DATABASE test_selectdb_#{i}")
+        @client.query("USE test_selectdb_#{i}")
+        @client.query("CREATE TABLE test#{i} (`id` int NOT NULL PRIMARY KEY)")
+      end
+    end
+
+    after(:each) do
+      2.times do |i|
+        @client.query("DROP DATABASE test_selectdb_#{i}")
+      end
+    end
+
+    it "should respond to #select_db" do
+      @client.should respond_to(:select_db)
+    end
+
+    it "should switch databases" do
+      @client.select_db("test_selectdb_0")
+      @client.query("SHOW TABLES").first.values.first.should eql("test0")
+      @client.select_db("test_selectdb_1")
+      @client.query("SHOW TABLES").first.values.first.should eql("test1")
+      @client.select_db("test_selectdb_0")
+      @client.query("SHOW TABLES").first.values.first.should eql("test0")
+    end
+
+    it "should raise a Mysql2::Error when the database doesn't exist" do
+      lambda {
+        @client.select_db("nopenothere")
+      }.should raise_error(Mysql2::Error)
+    end
+
+    it "should return the database switched to" do
+      @client.select_db("test_selectdb_1").should eq("test_selectdb_1")
+    end
+  end
+
   it "#thread_id should return a boolean" do
     @client.ping.should eql(true)
     @client.close
     @client.ping.should eql(false)
   end
 
-if RUBY_VERSION =~ /1.9/
-  it "should respond to #encoding" do
-    @client.should respond_to(:encoding)
+  if RUBY_VERSION =~ /1.9/
+    it "should respond to #encoding" do
+      @client.should respond_to(:encoding)
+    end
   end
 end
-end

data/spec/mysql2/error_spec.rb

@@ -3,14 +3,14 @@ require 'spec_helper'
 
 describe Mysql2::Error do
   before(:each) do
-    @client = Mysql2::Client.new :encoding => "utf8"
+    @client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "utf8"))
     begin
       @client.query("HAHAHA")
     rescue Mysql2::Error => e
       @error = e
     end
 
-    @client2 = Mysql2::Client.new :encoding => "big5"
+    @client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "big5"))
     begin
       @client2.query("HAHAHA")
     rescue Mysql2::Error => e

data/spec/mysql2/result_spec.rb

@@ -3,13 +3,42 @@ require 'spec_helper'
 
 describe Mysql2::Result do
   before(:each) do
-    @client = Mysql2::Client.new :host => "localhost", :username => "root", :database => 'test'
+    @client = Mysql2::Client.new DatabaseCredentials['root']
   end
 
   before(:each) do
     @result = @client.query "SELECT 1"
   end
 
+  it "should maintain a count while streaming" do
+    result = @client.query('SELECT 1')
+
+    result.count.should eql(1)
+    result.each { |r| }
+    result.count.should eql(1)
+  end
+
+  it "should set the actual count of rows after streaming" do
+      @client.query "USE test"
+      result = @client.query("SELECT * FROM mysql2_test", :stream => true, :cache_rows => false)
+      result.count.should eql(0)
+      result.each {|r|  }
+      result.count.should eql(1)
+  end
+
+  it "should not yield nil at the end of streaming" do
+    result = @client.query('SELECT * FROM mysql2_test', :stream => true)
+    result.each { |r| r.should_not be_nil}
+  end
+
+  it "#count should be zero for rows after streaming when there were no results " do
+      @client.query "USE test"
+      result = @client.query("SELECT * FROM mysql2_test WHERE null_test IS NOT NULL", :stream => true, :cache_rows => false)
+      result.count.should eql(0)
+      result.each {|r|  }
+      result.count.should eql(0)
+  end
+
   it "should have included Enumerable" do
     Mysql2::Result.ancestors.include?(Enumerable).should be_true
   end
@@ -73,6 +102,25 @@ describe Mysql2::Result do
       result = @client.query "SELECT 1", :cache_rows => false
       result.first.object_id.should_not eql(result.first.object_id)
     end
+
+    it "should yield different value for #first if streaming" do
+      result = @client.query "SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false
+      result.first.should_not eql(result.first)
+    end
+
+    it "should yield the same value for #first if streaming is disabled" do
+      result = @client.query "SELECT 1 UNION SELECT 2", :stream => false
+      result.first.should eql(result.first)
+    end
+
+    it "should throw an exception if we try to iterate twice when streaming is enabled" do
+      result = @client.query "SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false
+
+      expect {
+        result.each {}
+        result.each {}
+      }.to raise_exception(Mysql2::Error)
+    end
   end
 
   context "#fields" do
@@ -127,13 +175,17 @@ describe Mysql2::Result do
       id1 = @client.last_id
       @client.query 'INSERT INTO mysql2_test (bool_cast_test) VALUES (0)'
       id2 = @client.last_id
+      @client.query 'INSERT INTO mysql2_test (bool_cast_test) VALUES (-1)'
+      id3 = @client.last_id
 
       result1 = @client.query 'SELECT bool_cast_test FROM mysql2_test WHERE bool_cast_test = 1 LIMIT 1', :cast_booleans => true
       result2 = @client.query 'SELECT bool_cast_test FROM mysql2_test WHERE bool_cast_test = 0 LIMIT 1', :cast_booleans => true
+      result3 = @client.query 'SELECT bool_cast_test FROM mysql2_test WHERE bool_cast_test = -1 LIMIT 1', :cast_booleans => true
       result1.first['bool_cast_test'].should be_true
       result2.first['bool_cast_test'].should be_false
+      result3.first['bool_cast_test'].should be_true
 
-      @client.query "DELETE from mysql2_test WHERE id IN(#{id1},#{id2})"
+      @client.query "DELETE from mysql2_test WHERE id IN(#{id1},#{id2},#{id3})"
     end
 
     it "should return Fixnum for a SMALLINT value" do
@@ -255,7 +307,7 @@ describe Mysql2::Result do
           result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
           result['enum_test'].encoding.should eql(Encoding.find('utf-8'))
 
-          client2 = Mysql2::Client.new :encoding => 'ascii'
+          client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
           client2.query "USE test"
           result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
           result['enum_test'].encoding.should eql(Encoding.find('us-ascii'))
@@ -284,7 +336,7 @@ describe Mysql2::Result do
           result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
           result['set_test'].encoding.should eql(Encoding.find('utf-8'))
 
-          client2 = Mysql2::Client.new :encoding => 'ascii'
+          client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
           client2.query "USE test"
           result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
           result['set_test'].encoding.should eql(Encoding.find('us-ascii'))
@@ -366,7 +418,7 @@ describe Mysql2::Result do
               result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
               result[field].encoding.should eql(Encoding.find('utf-8'))
 
-              client2 = Mysql2::Client.new :encoding => 'ascii'
+              client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
               client2.query "USE test"
               result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
               result[field].encoding.should eql(Encoding.find('us-ascii'))