mysql2 0.3.18-x64-mingw32

data/ext/mysql2/result.h

@@ -0,0 +1,23 @@
+#ifndef MYSQL2_RESULT_H
+#define MYSQL2_RESULT_H
+
+void init_mysql2_result();
+VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_RES *r);
+
+typedef struct {
+  VALUE fields;
+  VALUE rows;
+  VALUE client;
+  VALUE encoding;
+  unsigned int numberOfFields;
+  unsigned long numberOfRows;
+  unsigned long lastRowProcessed;
+  char streamingComplete;
+  char resultFreed;
+  MYSQL_RES *result;
+  mysql_client_wrapper *client_wrapper;
+} mysql2_result_wrapper;
+
+#define GetMysql2Result(obj, sval) (sval = (mysql2_result_wrapper*)DATA_PTR(obj));
+
+#endif

data/ext/mysql2/wait_for_single_fd.h

@@ -0,0 +1,36 @@
+/*
+ * backwards compatibility for pre-1.9.3 C API
+ *
+ * Ruby 1.9.3 provides this API which allows the use of ppoll() on Linux
+ * to minimize select() and malloc() overhead on high-numbered FDs.
+ */
+#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
+#  include <ruby/io.h>
+#else
+#  define RB_WAITFD_IN  0x001
+#  define RB_WAITFD_PRI 0x002
+#  define RB_WAITFD_OUT 0x004
+
+static int my_wait_for_single_fd(int fd, int events, struct timeval *tvp)
+{
+  fd_set fdset;
+  fd_set *rfds = NULL;
+  fd_set *wfds = NULL;
+  fd_set *efds = NULL;
+
+  FD_ZERO(&fdset);
+  FD_SET(fd, &fdset);
+
+  if (events & RB_WAITFD_IN)
+    rfds = &fdset;
+  if (events & RB_WAITFD_OUT)
+    wfds = &fdset;
+  if (events & RB_WAITFD_PRI)
+    efds = &fdset;
+
+  return rb_thread_select(fd + 1, rfds, wfds, efds, tvp);
+}
+
+#define rb_wait_for_single_fd(fd,events,tvp) \
+        my_wait_for_single_fd((fd),(events),(tvp))
+#endif

data/lib/mysql2.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+require 'date'
+require 'bigdecimal'
+require 'rational' unless RUBY_VERSION >= '1.9.2'
+
+# Load libmysql.dll before requiring mysql2/mysql2.so
+# This gives a chance to be flexible about the load path
+# 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
+
+  require 'Win32API'
+  LoadLibrary = Win32API.new('Kernel32', 'LoadLibrary', ['P'], 'I')
+  if 0 == LoadLibrary.call(dll_path)
+    abort "Failed to load libmysql.dll from #{dll_path}"
+  end
+end
+
+require 'mysql2/version' unless defined? Mysql2::VERSION
+require 'mysql2/error'
+require 'mysql2/mysql2'
+require 'mysql2/result'
+require 'mysql2/client'
+
+# = Mysql2
+#
+# A modern, simple and very fast Mysql library for Ruby - binding to libmysql
+module Mysql2
+end
+
+if defined?(ActiveRecord::VERSION::STRING) && ActiveRecord::VERSION::STRING < "3.1"
+  begin
+    require 'active_record/connection_adapters/mysql2_adapter'
+  rescue LoadError
+    warn "============= WARNING FROM mysql2 ============="
+    warn "This version of mysql2 (#{Mysql2::VERSION}) doesn't ship with the ActiveRecord adapter."
+    warn "In Rails version 3.1.0 and up, the mysql2 ActiveRecord adapter is included with rails."
+    warn "If you want to use the mysql2 gem with Rails <= 3.0.x, please use the latest mysql2 in the 0.2.x series."
+    warn "============= END WARNING FROM mysql2 ============="
+  end
+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
+
+end

data/lib/mysql2/client.rb

@@ -0,0 +1,90 @@
+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 initialize(opts = {})
+      opts = Mysql2::Util.key_hash_as_symbols( opts )
+      @read_timeout = nil
+      @query_options = @@default_query_options.dup
+      @query_options.merge! opts
+
+      initialize_ext
+
+      # 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|
+        next unless opts.key?(key)
+        case key
+        when :reconnect, :local_infile, :secure_auth
+          send(:"#{key}=", !!opts[key])
+        when :connect_timeout, :read_timeout, :write_timeout
+          send(:"#{key}=", opts[key].to_i)
+        else
+          send(:"#{key}=", opts[key])
+        end
+      end
+
+      # force the encoding to utf8
+      self.charset_name = opts[:encoding] || 'utf8'
+
+      ssl_options = opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslcipher)
+      ssl_set(*ssl_options) if ssl_options.any?
+
+      if [:user,:pass,:hostname,:dbname,:db,:sock].any?{|k| @query_options.has_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 "Instead, please use :username, :password, :host, :port, :database, :socket, :flags for the options."
+        warn "============= END WARNING FROM mysql2 ========="
+      end
+
+      user     = opts[:username] || opts[:user]
+      pass     = opts[:password] || opts[:pass]
+      host     = opts[:host] || opts[:hostname]
+      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?
+      pass = pass.to_s unless pass.nil?
+      host = host.to_s unless host.nil?
+      port = port.to_i unless port.nil?
+      database = database.to_s unless database.nil?
+      socket = socket.to_s unless socket.nil?
+
+      connect user, pass, host, port, database, socket, flags
+    end
+
+    def self.default_query_options
+      @@default_query_options
+    end
+
+    def query_info
+      info = query_info_string
+      return {} unless info
+      info_hash = {}
+      info.split.each_slice(2) { |s| info_hash[s[0].downcase.delete(':').to_sym] = s[1].to_i }
+      info_hash
+    end
+
+    private
+      def self.local_offset
+        ::Time.local(2010).utc_offset.to_r / 86400
+      end
+  end
+end

data/lib/mysql2/console.rb

@@ -0,0 +1,5 @@
+# Loaded by script/console. Land helpers here.
+
+Pry.config.prompt = lambda do |context, nesting, pry|
+  "[mysql2] #{context}> "
+end

data/lib/mysql2/em.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'eventmachine'
+require 'mysql2'
+
+module Mysql2
+  module EM
+    class Client < ::Mysql2::Client
+      module Watcher
+        def initialize(client, deferable)
+          @client = client
+          @deferable = deferable
+          @is_watching = true
+        end
+
+        def notify_readable
+          detach
+          begin
+            result = @client.async_result
+          rescue Exception => e
+            @deferable.fail(e)
+          else
+            @deferable.succeed(result)
+          end
+        end
+
+        def watching?
+          @is_watching
+        end
+
+        def unbind
+          @is_watching = false
+        end
+      end
+
+      def close(*args)
+        if @watch
+          @watch.detach if @watch.watching?
+        end
+        super(*args)
+      end
+
+      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.notify_readable = true
+          deferable
+        else
+          super(sql, opts)
+        end
+      end
+    end
+  end
+end

data/lib/mysql2/error.rb

@@ -0,0 +1,80 @@
+# encoding: UTF-8
+
+module Mysql2
+  class Error < StandardError
+    REPLACEMENT_CHAR = '?'
+    ENCODE_OPTS      = {:undef => :replace, :invalid => :replace, :replace => REPLACEMENT_CHAR}
+
+    attr_accessor :error_number
+    attr_reader   :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
+
+    def sql_state=(state)
+      @sql_state = ''.respond_to?(:encode) ? state.encode(ENCODE_OPTS) : state
+    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/mysql2.rb

@@ -0,0 +1,2 @@
+RUBY_VERSION =~ /(\d+.\d+)/
+require "mysql2/#{$1}/mysql2"

data/lib/mysql2/result.rb

@@ -0,0 +1,5 @@
+module Mysql2
+  class Result
+    include Enumerable
+  end
+end

data/lib/mysql2/version.rb

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

data/spec/configuration.yml.example

@@ -0,0 +1,17 @@
+root:
+  host: localhost
+  username: root
+  password:
+  database: test
+
+user:
+  host: localhost
+  username: LOCALUSERNAME
+  password:
+  database: mysql2_test
+
+numericuser:
+  host: localhost
+  username: LOCALUSERNAME
+  password:
+  database: 12345

data/spec/em/em_spec.rb

@@ -0,0 +1,135 @@
+# encoding: UTF-8
+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 DatabaseCredentials['root']
+        defer1 = client1.query "SELECT sleep(0.1) as first_query"
+        defer1.callback do |result|
+          results << result.first
+          client1.close
+          EM.stop_event_loop
+        end
+
+        client2 = Mysql2::EM::Client.new DatabaseCredentials['root']
+        defer2 = client2.query "SELECT sleep(0.025) second_query"
+        defer2.callback do |result|
+          results << result.first
+          client2.close
+        end
+      end
+
+      results[0].keys.should include("second_query")
+      results[1].keys.should include("first_query")
+    end
+
+    it "should support queries in callbacks" do
+      results = []
+      EM.run do
+        client = Mysql2::EM::Client.new DatabaseCredentials['root']
+        defer1 = client.query "SELECT sleep(0.025) as first_query"
+        defer1.callback do |result|
+          results << result.first
+          defer2 = client.query "SELECT sleep(0.025) as second_query"
+          defer2.callback do |r|
+            results << r.first
+            client.close
+            EM.stop_event_loop
+          end
+        end
+      end
+
+      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|
+            client.close
+            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
+
+    it "should not raise error when closing client with no query running" do
+      callbacks_run = []
+      EM.run do
+        client = Mysql2::EM::Client.new DatabaseCredentials['root']
+        defer = client.query("select sleep(0.025)")
+        defer.callback do |result|
+          callbacks_run << :callback
+        end
+        defer.errback do |err|
+          callbacks_run << :errback
+        end
+        EM.add_timer(0.1) do
+          callbacks_run.should == [:callback]
+          lambda {
+            client.close
+          }.should_not raise_error(/invalid binding to detach/)
+          EM.stop_event_loop
+        end
+      end
+    end
+  end
+rescue LoadError
+  puts "EventMachine not installed, skipping the specs that use it"
+end