mysql2 0.2.6-x86-mingw32 → 0.2.16-x86-mingw32

data/lib/active_record/fiber_patches.rb

@@ -24,7 +24,7 @@ module ActiveRecord
             fiber.resume(false)
           end
           @queue << fiber
-          returning Fiber.yield do
+          Fiber.yield.tap do
             x.cancel
           end
         end
@@ -67,16 +67,38 @@ module ActiveRecord
 
         @connections = []
         @checked_out = []
-      end
+        @automatic_reconnect = true
+        @tables = {}
 
-      private
+        @columns     = Hash.new do |h, table_name|
+          h[table_name] = with_connection do |conn|
 
-      def current_connection_id #:nodoc:
-        Fiber.current.object_id
+            # Fetch a list of columns
+            conn.columns(table_name, "#{table_name} Columns").tap do |columns|
+
+              # set primary key information
+              columns.each do |column|
+                column.primary = column.name == primary_keys[table_name]
+              end
+            end
+          end
+        end
+
+        @columns_hash = Hash.new do |h, table_name|
+          h[table_name] = Hash[columns[table_name].map { |col|
+            [col.name, col]
+          }]
+        end
+
+        @primary_keys = Hash.new do |h, table_name|
+          h[table_name] = with_connection do |conn|
+            table_exists?(table_name) ? conn.primary_key(table_name) : 'id'
+          end
+        end
       end
 
-      # Remove stale fibers from the cache.
-      def remove_stale_cached_threads!(cache, &block)
+      def clear_stale_cached_connections!
+        cache = @reserved_connections
         keys = Set.new(cache.keys)
 
         ActiveRecord::ConnectionAdapters.fiber_pools.each do |pool|
@@ -87,11 +109,17 @@ module ActiveRecord
 
         keys.each do |key|
           next unless cache.has_key?(key)
-          block.call(key, cache[key])
+          checkin cache[key]
           cache.delete(key)
         end
       end
 
+      private
+
+      def current_connection_id #:nodoc:
+        Fiber.current.object_id
+      end
+
       def checkout_and_verify(c)
         @checked_out << c
         c.run_callbacks :checkout
@@ -101,4 +129,4 @@ module ActiveRecord
     end
 
   end
-end
+end

data/lib/mysql2.rb

@@ -3,14 +3,19 @@ require 'date'
 require 'bigdecimal'
 require 'rational' unless RUBY_VERSION >= '1.9.2'
 
+require 'mysql2/version' unless defined? Mysql2::VERSION
 require 'mysql2/error'
+require 'mysql2/result'
 require 'mysql2/mysql2'
 require 'mysql2/client'
-require 'mysql2/result'
 
 # = Mysql2
 #
 # A modern, simple and very fast Mysql library for Ruby - binding to libmysql
 module Mysql2
-  VERSION = "0.2.6"
 end
+
+if defined?(ActiveRecord::VERSION::STRING) && ActiveRecord::VERSION::STRING >= "3.1"
+  puts "WARNING: This version of mysql2 (#{Mysql2::VERSION}) isn't compatible with Rails 3.1 as the ActiveRecord adapter was pulled into Rails itself."
+  puts "WARNING: Please use the 0.3.x (or greater) releases if you plan on using it in Rails >= 3.1.x"
+end

data/lib/mysql2/client.rb

@@ -9,11 +9,13 @@ module Mysql2
       :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
+      :connect_flags => REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION,
+      :cast => true
     }
 
     def initialize(opts = {})
       @query_options = @@default_query_options.dup
+      @query_options.merge! opts
 
       init_connection
 
@@ -24,7 +26,12 @@ module Mysql2
       # force the encoding to utf8
       self.charset_name = opts[:encoding] || 'utf8'
 
-      ssl_set(*opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslciper))
+      @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}"
+      end
+
+      ssl_set(*opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslcipher))
 
       user     = opts[:username]
       pass     = opts[:password]

data/lib/mysql2/em.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
-require 'eventmachine' unless defined? EventMachine
-require 'mysql2' unless defined? Mysql2
+require 'eventmachine'
+require 'mysql2'
 
 module Mysql2
   module EM
@@ -23,10 +23,14 @@ module Mysql2
       end
 
       def query(sql, opts={})
-        super(sql, opts.merge(:async => true))
-        deferable = ::EM::DefaultDeferrable.new
-        ::EM.watch(self.socket, Watcher, self, deferable).notify_readable = true
-        deferable
+        if ::EM.reactor_running?
+          super(sql, opts.merge(:async => true))
+          deferable = ::EM::DefaultDeferrable.new
+          ::EM.watch(self.socket, Watcher, self, deferable).notify_readable = true
+          deferable
+        else
+          super(sql, opts)
+        end
       end
     end
   end

data/lib/mysql2/em_fiber.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'mysql2/em'
+require 'fiber'
+
+module Mysql2
+  module EM
+    module Fiber
+      class Client < ::Mysql2::EM::Client
+        def query(sql, opts={})
+          if ::EM.reactor_running?
+            deferable = super(sql, opts)
+
+            fiber = ::Fiber.current
+            deferable.callback do |result|
+              fiber.resume(result)
+            end
+            deferable.errback do |err|
+              fiber.resume(err)
+            end
+            ::Fiber.yield.tap do |result|
+              raise result if result.is_a?(::Exception)
+            end
+          else
+            super(sql, opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mysql2/version.rb

@@ -0,0 +1,3 @@
+module Mysql2
+  VERSION = "0.2.16"
+end

data/mysql2.gemspec

@@ -1,89 +1,29 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/mysql2/version', __FILE__)
 
 Gem::Specification.new do |s|
   s.name = %q{mysql2}
-  s.version = "0.2.6"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.version = Mysql2::VERSION
   s.authors = ["Brian Lopez"]
-  s.date = %q{2010-10-19}
+  s.date = Time.now.utc.strftime("%Y-%m-%d")
   s.email = %q{seniorlopez@gmail.com}
   s.extensions = ["ext/mysql2/extconf.rb"]
-  s.extra_rdoc_files = [
-    "README.rdoc"
-  ]
-  s.files = [
-    ".gitignore",
-     ".rspec",
-     "CHANGELOG.md",
-     "MIT-LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "benchmark/active_record.rb",
-     "benchmark/allocations.rb",
-     "benchmark/escape.rb",
-     "benchmark/query_with_mysql_casting.rb",
-     "benchmark/query_without_mysql_casting.rb",
-     "benchmark/sequel.rb",
-     "benchmark/setup_db.rb",
-     "examples/eventmachine.rb",
-     "examples/threaded.rb",
-     "ext/mysql2/client.c",
-     "ext/mysql2/client.h",
-     "ext/mysql2/extconf.rb",
-     "ext/mysql2/mysql2_ext.c",
-     "ext/mysql2/mysql2_ext.h",
-     "ext/mysql2/result.c",
-     "ext/mysql2/result.h",
-     "lib/active_record/connection_adapters/em_mysql2_adapter.rb",
-     "lib/active_record/connection_adapters/mysql2_adapter.rb",
-     "lib/active_record/fiber_patches.rb",
-     "lib/arel/engines/sql/compilers/mysql2_compiler.rb",
-     "lib/mysql2.rb",
-     "lib/mysql2/client.rb",
-     "lib/mysql2/em.rb",
-     "lib/mysql2/error.rb",
-     "lib/mysql2/result.rb",
-     "mysql2.gemspec",
-     "spec/em/em_spec.rb",
-     "spec/mysql2/client_spec.rb",
-     "spec/mysql2/error_spec.rb",
-     "spec/mysql2/result_spec.rb",
-     "spec/rcov.opts",
-     "spec/spec_helper.rb",
-     "tasks/benchmarks.rake",
-     "tasks/compile.rake",
-     "tasks/jeweler.rake",
-     "tasks/rspec.rake",
-     "tasks/vendor_mysql.rake"
-  ]
+  s.files = `git ls-files`.split("\n")
   s.homepage = %q{http://github.com/brianmario/mysql2}
   s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib", "ext"]
-  s.rubygems_version = %q{1.3.7}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.4.2}
   s.summary = %q{A simple, fast Mysql library for Ruby, binding to libmysql}
-  s.test_files = [
-    "spec/em/em_spec.rb",
-     "spec/mysql2/client_spec.rb",
-     "spec/mysql2/error_spec.rb",
-     "spec/mysql2/result_spec.rb",
-     "spec/spec_helper.rb",
-     "examples/eventmachine.rb",
-     "examples/threaded.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  s.test_files = `git ls-files spec examples`.split("\n")
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
+  # tests
+  s.add_development_dependency 'eventmachine'
+  s.add_development_dependency 'rake-compiler', "~> 0.7.7"
+  s.add_development_dependency 'rake', '0.8.7' # NB: 0.8.7 required by rake-compiler 0.7.9
+  s.add_development_dependency 'rspec'
+  # benchmarks
+  s.add_development_dependency 'activerecord'
+  s.add_development_dependency 'mysql'
+  s.add_development_dependency 'do_mysql'
+  s.add_development_dependency 'sequel'
+  s.add_development_dependency 'faker'
 end
-

data/spec/em/em_fiber_spec.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+if defined? EventMachine && defined? Fiber
+  require 'spec_helper'
+  require 'mysql2/em_fiber'
+
+  describe Mysql2::EM::Fiber::Client do
+    it 'should support queries' do
+      results = []
+      EM.run do
+        Fiber.new {
+          client1 = Mysql2::EM::Fiber::Client.new
+          results = client1.query "SELECT sleep(0.1) as first_query"
+          EM.stop_event_loop
+        }.resume
+      end
+
+      results.first.keys.should include("first_query")
+    end
+  end
+else
+  puts "Either EventMachine or Fibers not available. Skipping tests that use them."
+end

data/spec/mysql2/client_spec.rb

@@ -85,7 +85,19 @@ describe Mysql2::Client do
     @client.should respond_to(:query)
   end
 
+  it "should expect read_timeout to be a positive integer" do
+    lambda {
+      Mysql2::Client.new(:read_timeout => -1)
+    }.should raise_error(Mysql2::Error)
+  end
+
   context "#query" do
+    it "should only accept strings as the query parameter" do
+      lambda {
+        @client.query ["SELECT 'not right'"]
+      }.should raise_error(TypeError)
+    end
+
     it "should accept an options hash that inherits from Mysql2::Client.default_query_options" do
       @client.query "SELECT 1", :something => :else
       @client.query_options.should eql(@client.query_options.merge(:something => :else))
@@ -104,13 +116,6 @@ describe Mysql2::Client do
       @client.query("SELECT 1", :symbolize_keys => true).first.keys[0].class.should eql(Symbol)
     end
 
-    it "should not allow another query to be sent without fetching a result first" do
-      @client.query("SELECT 1", :async => true)
-      lambda {
-        @client.query("SELECT 1")
-      }.should raise_error(Mysql2::Error)
-    end
-
     it "should require an open connection" do
       @client.close
       lambda {
@@ -118,9 +123,23 @@ describe Mysql2::Client do
       }.should raise_error(Mysql2::Error)
     end
 
-    # XXX this test is not deterministic (because Unix signal handling is not)
-    # and may fail on a loaded system
     if RUBY_PLATFORM !~ /mingw|mswin/
+      it "should not allow another query to be sent without fetching a result first" do
+        @client.query("SELECT 1", :async => true)
+        lambda {
+          @client.query("SELECT 1")
+        }.should raise_error(Mysql2::Error)
+      end
+
+      it "should timeout if we wait longer than :read_timeout" do
+        client = Mysql2::Client.new(:read_timeout => 1)
+        lambda {
+          client.query("SELECT sleep(2)")
+        }.should raise_error(Mysql2::Error)
+      end
+
+      # XXX this test is not deterministic (because Unix signal handling is not)
+      # and may fail on a loaded system
       it "should run signal handlers while waiting for a response" do
         mark = {}
         trap(:USR1) { mark[:USR1] = Time.now }
@@ -145,6 +164,131 @@ describe Mysql2::Client do
           trap(:USR1, 'DEFAULT')
         end
       end
+
+      it "#socket should return a Fixnum (file descriptor from C)" do
+        @client.socket.class.should eql(Fixnum)
+        @client.socket.should_not eql(0)
+      end
+
+      it "#socket should require an open connection" do
+        @client.close
+        lambda {
+          @client.socket
+        }.should raise_error(Mysql2::Error)
+      end
+
+      it "should close the connection when an exception is raised" do
+        begin
+          Timeout.timeout(1) do
+            @client.query("SELECT sleep(2)")
+          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)
+        begin
+          Timeout.timeout(1) do
+            client.query("SELECT sleep(2)")
+          end
+        rescue Timeout::Error
+        end
+
+        lambda {
+          client.query("SELECT 1")
+        }.should_not raise_error(Mysql2::Error)
+      end
+
+      it "threaded queries should be supported" do
+        threads, results = [], {}
+        connect = lambda{ Mysql2::Client.new(:host => "localhost", :username => "root") }
+        Timeout.timeout(0.7) do
+          5.times {
+            threads << Thread.new do
+              results[Thread.current.object_id] = connect.call.query("SELECT sleep(0.5) as result")
+            end
+          }
+        end
+        threads.each{|t| t.join }
+        results.keys.sort.should eql(threads.map{|t| t.object_id }.sort)
+      end
+
+      it "evented async queries should be supported" do
+        # should immediately return nil
+        @client.query("SELECT sleep(0.1)", :async => true).should eql(nil)
+
+        io_wrapper = IO.for_fd(@client.socket)
+        loops = 0
+        loop do
+          if IO.select([io_wrapper], nil, nil, 0.05)
+            break
+          else
+            loops += 1
+          end
+        end
+
+        # make sure we waited some period of time
+        (loops >= 1).should be_true
+
+        result = @client.async_result
+        result.class.should eql(Mysql2::Result)
+      end
+    end
+  end
+
+  it "should respond to #socket" do
+    @client.should respond_to(:socket)
+  end
+
+  if RUBY_PLATFORM =~ /mingw|mswin/
+    it "#socket should raise as it's not supported" do
+      lambda {
+        @client.socket
+      }.should raise_error(Mysql2::Error)
+    end
+  end
+
+  it "should respond to escape" do
+    Mysql2::Client.should respond_to(:escape)
+  end
+
+  context "escape" do
+    it "should return a new SQL-escape version of the passed string" do
+      Mysql2::Client.escape("abc'def\"ghi\0jkl%mno").should eql("abc\\'def\\\"ghi\\0jkl%mno")
+    end
+
+    it "should return the passed string if nothing was escaped" do
+      str = "plain"
+      Mysql2::Client.escape(str).object_id.should eql(str.object_id)
+    end
+
+    it "should not overflow the thread stack" do
+      lambda {
+        Thread.new { Mysql2::Client.escape("'" * 256 * 1024) }.join
+      }.should_not raise_error(SystemStackError)
+    end
+
+    it "should not overflow the process stack" do
+      lambda {
+        Thread.new { Mysql2::Client.escape("'" * 1024 * 1024 * 4) }.join
+      }.should_not raise_error(SystemStackError)
+    end
+
+    if RUBY_VERSION =~ /1.9/
+      it "should carry over the original string's encoding" do
+        str = "abc'def\"ghi\0jkl%mno"
+        escaped = Mysql2::Client.escape(str)
+        escaped.encoding.should eql(str.encoding)
+
+        str.encode!('us-ascii')
+        escaped = Mysql2::Client.escape(str)
+        escaped.encoding.should eql(str.encoding)
+      end
     end
   end
 
@@ -253,25 +397,9 @@ describe Mysql2::Client do
     end
   end
 
-  it "should respond to #socket" do
-    @client.should respond_to(:socket)
-  end
-
-  it "#socket should return a Fixnum (file descriptor from C)" do
-    @client.socket.class.should eql(Fixnum)
-    @client.socket.should_not eql(0)
-  end
-
-  it "#socket should require an open connection" do
-    @client.close
-    lambda {
-      @client.socket
-    }.should raise_error(Mysql2::Error)
-  end
-
   it "should raise a Mysql2::Error exception upon connection failure" do
     lambda {
-      bad_client = Mysql2::Client.new :host => "dfjhdi9wrhw", :username => 'asdfasdf8d2h'
+      bad_client = Mysql2::Client.new :host => "localhost", :username => 'asdfasdf8d2h', :password => 'asdfasdfw42'
     }.should raise_error(Mysql2::Error)
 
     lambda {
@@ -279,45 +407,10 @@ describe Mysql2::Client do
     }.should_not raise_error(Mysql2::Error)
   end
 
-  it "threaded queries should be supported" do
-    threads, results = [], {}
-    connect = lambda{ Mysql2::Client.new(:host => "localhost", :username => "root") }
-    Timeout.timeout(0.7) do
-      5.times {
-        threads << Thread.new do
-          results[Thread.current.object_id] = connect.call.query("SELECT sleep(0.5) as result")
-        end
-      }
-    end
-    threads.each{|t| t.join }
-    results.keys.sort.should eql(threads.map{|t| t.object_id }.sort)
-  end
-
-  it "evented async queries should be supported" do
-    # should immediately return nil
-    @client.query("SELECT sleep(0.1)", :async => true).should eql(nil)
-
-    io_wrapper = IO.for_fd(@client.socket)
-    loops = 0
-    loop do
-      if IO.select([io_wrapper], nil, nil, 0.05)
-        break
-      else
-        loops += 1
-      end
-    end
-
-    # make sure we waited some period of time
-    (loops >= 1).should be_true
-
-    result = @client.async_result
-    result.class.should eql(Mysql2::Result)
-  end
-
   context 'write operations api' do
     before(:each) do
       @client.query "USE test"
-      @client.query "CREATE TABLE lastIdTest (`id` int(11) NOT NULL AUTO_INCREMENT, blah INT(11), PRIMARY KEY (`id`))"
+      @client.query "CREATE TABLE IF NOT EXISTS lastIdTest (`id` int(11) NOT NULL AUTO_INCREMENT, blah INT(11), PRIMARY KEY (`id`))"
     end
 
     after(:each) do
@@ -345,4 +438,28 @@ describe Mysql2::Client do
       @client.affected_rows.should eql(1)
     end
   end
+
+  it "should respond to #thread_id" do
+    @client.should respond_to(:thread_id)
+  end
+
+  it "#thread_id should be a Fixnum" do
+    @client.thread_id.class.should eql(Fixnum)
+  end
+
+  it "should respond to #ping" do
+    @client.should respond_to(:ping)
+  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)
+  end
+end
 end