mysql2 0.1.4 → 0.1.5

data/ext/mysql2_ext.h

@@ -1,5 +1,5 @@
-#include <time.h>
 #include <ruby.h>
+#include <fcntl.h>
 
 #ifdef HAVE_MYSQL_H
 #include <mysql.h>
@@ -15,17 +15,26 @@
 
 #ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>
-int utf8Encoding, binaryEncoding;
+static int utf8Encoding, binaryEncoding;
+#endif
+
+#if defined(__GNUC__) && (__GNUC__ >= 3)
+#define RB_MYSQL_UNUSED __attribute__ ((unused))
+#else
+#define RB_MYSQL_UNUSED
 #endif
 
 static VALUE cBigDecimal, cDate, cDateTime;
-ID intern_new, intern_local;
+static ID intern_new, intern_local;
 
 /* Mysql2::Error */
-VALUE cMysql2Error;
+static VALUE cMysql2Error;
 
 /* Mysql2::Client */
-#define GetMysql2Client(obj, sval) (sval = (MYSQL*)DATA_PTR(obj));
+typedef struct {
+    MYSQL * client;
+} mysql2_client_wrapper;
+#define GetMysql2Client(obj, sval) (sval = ((mysql2_client_wrapper*)(DATA_PTR(obj)))->client);
 static ID sym_socket, sym_host, sym_port, sym_username, sym_password,
           sym_database, sym_reconnect, sym_connect_timeout, sym_id, sym_version,
           sym_sslkey, sym_sslcert, sym_sslca, sym_sslcapath, sym_sslcipher,
@@ -40,7 +49,7 @@ static VALUE rb_mysql_client_socket(VALUE self);
 static VALUE rb_mysql_client_async_result(VALUE self);
 static VALUE rb_mysql_client_last_id(VALUE self);
 static VALUE rb_mysql_client_affected_rows(VALUE self);
-void rb_mysql_client_free(void * client);
+static void rb_mysql_client_free(void * client);
 
 /* Mysql2::Result */
 typedef struct {
@@ -53,9 +62,60 @@ typedef struct {
     MYSQL_RES *result;
 } mysql2_result_wrapper;
 #define GetMysql2Result(obj, sval) (sval = (mysql2_result_wrapper*)DATA_PTR(obj));
-VALUE cMysql2Result;
+static VALUE cMysql2Result;
 static VALUE rb_mysql_result_to_obj(MYSQL_RES * res);
 static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self);
 static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self);
-void rb_mysql_result_free(void * wrapper);
-void rb_mysql_result_mark(void * wrapper);
+static void rb_mysql_result_free(void * wrapper);
+static void rb_mysql_result_mark(void * wrapper);
+static void rb_mysql_result_free_result(mysql2_result_wrapper * wrapper);
+
+/*
+ * used to pass all arguments to mysql_real_connect while inside
+ * rb_thread_blocking_region
+ */
+struct nogvl_connect_args {
+    MYSQL *mysql;
+    const char *host;
+    const char *user;
+    const char *passwd;
+    const char *db;
+    unsigned int port;
+    const char *unix_socket;
+    unsigned long client_flag;
+};
+
+/*
+ * used to pass all arguments to mysql_send_query while inside
+ * rb_thread_blocking_region
+ */
+struct nogvl_send_query_args {
+    MYSQL *mysql;
+    VALUE sql;
+};
+
+/*
+ * partial emulation of the 1.9 rb_thread_blocking_region under 1.8,
+ * this is enough for dealing with blocking I/O functions in the
+ * presence of threads.
+ */
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+#  include <rubysig.h>
+#  define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
+typedef void rb_unblock_function_t(void *);
+typedef VALUE rb_blocking_function_t(void *);
+static VALUE
+rb_thread_blocking_region(
+	rb_blocking_function_t *func, void *data1,
+	RB_MYSQL_UNUSED rb_unblock_function_t *ubf,
+	RB_MYSQL_UNUSED void *data2)
+{
+	VALUE rv;
+
+	TRAP_BEG;
+	rv = func(data1);
+	TRAP_END;
+
+	return rv;
+}
+#endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -13,6 +13,7 @@ module ActiveRecord
 
   module ConnectionAdapters
     class Mysql2Column < Column
+      BOOL = "tinyint(1)".freeze
       def extract_default(default)
         if sql_type =~ /blob/i || type == :text
           if default.blank?
@@ -39,7 +40,7 @@ module ActiveRecord
           when :float         then Float
           when :decimal       then BigDecimal
           when :datetime      then Time
-          when :date          then Time
+          when :date          then Date
           when :timestamp     then Time
           when :time          then Time
           when :text, :string then String
@@ -49,21 +50,36 @@ module ActiveRecord
       end
 
       def type_cast(value)
-        if type == :boolean
-          self.class.value_to_boolean(value)
-        else
-          value
+        return nil if value.nil?
+        case type
+          when :string    then value
+          when :text      then value
+          when :integer   then value.is_a?(Fixnum) ? value : (value.to_i rescue value ? 1 : 0)
+          when :float     then value.class == Float ? value : value.to_f
+          when :decimal   then value.class == BigDecimal ? value : self.class.value_to_decimal(value)
+          when :datetime  then value.class == Time ? value : self.class.string_to_time(value)
+          when :timestamp then value.class == Time ? value : self.class.string_to_time(value)
+          when :time      then value.class == Time ? value : self.class.string_to_dummy_time(value)
+          when :date      then value.class == Date ? value : self.class.string_to_date(value)
+          when :binary    then value
+          when :boolean   then self.class.value_to_boolean(value)
+          else value
         end
       end
 
       def type_cast_code(var_name)
-        nil
+        case type
+        when :boolean then "#{self.class.name}.value_to_boolean(#{var_name})"
+        else
+          nil
+        end
       end
 
       private
         def simplified_type(field_type)
-          return :boolean if Mysql2Adapter.emulate_booleans && field_type.downcase.index("tinyint(1)")
+          return :boolean if Mysql2Adapter.emulate_booleans && field_type.downcase.index(BOOL)
           return :string  if field_type =~ /enum/i
+          return :integer if field_type =~ /year/i
           super
         end
 
@@ -107,6 +123,7 @@ module ActiveRecord
       self.emulate_booleans = true
 
       ADAPTER_NAME = 'MySQL'.freeze
+      PRIMARY = "PRIMARY".freeze
 
       LOST_CONNECTION_ERROR_MESSAGES = [
         "Server shutdown in progress",
@@ -479,7 +496,7 @@ module ActiveRecord
 
       def show_variable(name)
         variables = select_all("SHOW VARIABLES LIKE '#{name}'")
-        variables.first[:Value] unless variables.empty?
+        variables.first['Value'] unless variables.empty?
       end
 
       def pk_and_sequence_for(table)

data/lib/mysql2.rb

@@ -5,5 +5,5 @@ require 'mysql2_ext'
 #
 # A modern, simple and very fast Mysql library for Ruby - binding to libmysql
 module Mysql2
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/sequel/adapters/mysql2.rb

@@ -0,0 +1,238 @@
+require 'mysql2' unless defined? Mysql2
+
+Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
+
+module Sequel
+  # Module for holding all MySQL-related classes and modules for Sequel.
+  module Mysql2
+    # Mapping of type numbers to conversion procs
+    MYSQL_TYPES = {}
+
+    MYSQL2_LITERAL_PROC = lambda{|v| v}
+
+    # Use only a single proc for each type to save on memory
+    MYSQL_TYPE_PROCS = {
+      [0, 246]  => MYSQL2_LITERAL_PROC,                               # decimal
+      [1]  => lambda{|v| convert_tinyint_to_bool ? v != 0 : v},       # tinyint
+      [2, 3, 8, 9, 13, 247, 248]  => MYSQL2_LITERAL_PROC,             # integer
+      [4, 5]  => MYSQL2_LITERAL_PROC,                                 # float
+      [10, 14]  => MYSQL2_LITERAL_PROC,                               # date
+      [7, 12] => MYSQL2_LITERAL_PROC,                                # datetime
+      [11]  => MYSQL2_LITERAL_PROC,                                   # time
+      [249, 250, 251, 252]  => lambda{|v| Sequel::SQL::Blob.new(v)}   # blob
+    }
+    MYSQL_TYPE_PROCS.each do |k,v|
+      k.each{|n| MYSQL_TYPES[n] = v}
+    end
+
+    @convert_invalid_date_time = false
+    @convert_tinyint_to_bool = true
+
+    class << self
+      # By default, Sequel raises an exception if in invalid date or time is used.
+      # However, if this is set to nil or :nil, the adapter treats dates
+      # like 0000-00-00 and times like 838:00:00 as nil values.  If set to :string,
+      # it returns the strings as is.
+      attr_accessor :convert_invalid_date_time
+
+      # Sequel converts the column type tinyint(1) to a boolean by default when
+      # using the native MySQL adapter.  You can turn off the conversion by setting
+      # this to false.
+      attr_accessor :convert_tinyint_to_bool
+    end
+
+    # Database class for MySQL databases used with Sequel.
+    class Database < Sequel::Database
+      include Sequel::MySQL::DatabaseMethods
+
+      # Mysql::Error messages that indicate the current connection should be disconnected
+      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away)/
+
+      set_adapter_scheme :mysql2
+
+      # Support stored procedures on MySQL
+      def call_sproc(name, opts={}, &block)
+        args = opts[:args] || []
+        execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
+      end
+
+      # Connect to the database.  In addition to the usual database options,
+      # the following options have effect:
+      #
+      # * :auto_is_null - Set to true to use MySQL default behavior of having
+      #   a filter for an autoincrement column equals NULL to return the last
+      #   inserted row.
+      # * :charset - Same as :encoding (:encoding takes precendence)
+      # * :compress - Set to false to not compress results from the server
+      # * :config_default_group - The default group to read from the in
+      #   the MySQL config file.
+      # * :config_local_infile - If provided, sets the Mysql::OPT_LOCAL_INFILE
+      #   option on the connection with the given value.
+      # * :encoding - Set all the related character sets for this
+      #   connection (connection, client, database, server, and results).
+      # * :socket - Use a unix socket file instead of connecting via TCP/IP.
+      # * :timeout - Set the timeout in seconds before the server will
+      #   disconnect this connection.
+      def connect(server)
+        opts = server_opts(server)
+        conn = ::Mysql2::Client.new({
+          :host => opts[:host] || 'localhost',
+          :username => opts[:user],
+          :password => opts[:password],
+          :database => opts[:database],
+          :port => opts[:port],
+          :socket => opts[:socket]
+        })
+
+        # increase timeout so mysql server doesn't disconnect us
+        conn.query("set @@wait_timeout = #{opts[:timeout] || 2592000}")
+
+        # By default, MySQL 'where id is null' selects the last inserted id
+        conn.query("set SQL_AUTO_IS_NULL=0") unless opts[:auto_is_null]
+
+        conn
+      end
+
+      # Returns instance of Sequel::MySQL::Dataset with the given options.
+      def dataset(opts = nil)
+        Mysql2::Dataset.new(self, opts)
+      end
+
+      # Executes the given SQL using an available connection, yielding the
+      # connection if the block is given.
+      def execute(sql, opts={}, &block)
+        if opts[:sproc]
+          call_sproc(sql, opts, &block)
+        else
+          synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
+        end
+      end
+
+      # Return the version of the MySQL server two which we are connecting.
+      def server_version(server=nil)
+        @server_version ||= (synchronize(server){|conn| conn.info[:id]})
+      end
+
+      private
+
+      # Execute the given SQL on the given connection.  If the :type
+      # option is :select, yield the result of the query, otherwise
+      # yield the connection if a block is given.
+      def _execute(conn, sql, opts)
+        begin
+          # r = log_yield(sql){conn.query(sql)}
+          r = conn.query(sql)
+          if opts[:type] == :select
+            yield r if r
+          elsif block_given?
+            yield conn
+          end
+        rescue ::Mysql2::Error => e
+          raise_error(e, :disconnect=>MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
+        end
+      end
+
+      # MySQL connections use the query method to execute SQL without a result
+      def connection_execute_method
+        :query
+      end
+
+      # The MySQL adapter main error class is Mysql::Error
+      def database_error_classes
+        [::Mysql2::Error]
+      end
+
+      # The database name when using the native adapter is always stored in
+      # the :database option.
+      def database_name
+        @opts[:database]
+      end
+
+      # Closes given database connection.
+      def disconnect_connection(c)
+        c = nil
+      end
+
+      # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
+      def schema_column_type(db_type)
+        Sequel::MySQL.convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
+      end
+    end
+
+    # Dataset class for MySQL datasets accessed via the native driver.
+    class Dataset < Sequel::Dataset
+      include Sequel::MySQL::DatasetMethods
+      include StoredProcedures
+
+      # Methods for MySQL stored procedures using the native driver.
+      module StoredProcedureMethods
+        include Sequel::Dataset::StoredProcedureMethods
+
+        private
+
+        # Execute the database stored procedure with the stored arguments.
+        def execute(sql, opts={}, &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
+        end
+
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_dui(sql, opts={}, &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
+        end
+      end
+
+      # Delete rows matching this dataset
+      def delete
+        execute_dui(delete_sql){|c| return c.affected_rows}
+      end
+
+      # Yield all rows matching this dataset.  If the dataset is set to
+      # split multiple statements, yield arrays of hashes one per statement
+      # instead of yielding results for all statements as hashes.
+      def fetch_rows(sql, &block)
+        execute(sql) do |r|
+          r.each &block
+        end
+        self
+      end
+
+      # Don't allow graphing a dataset that splits multiple statements
+      def graph(*)
+        raise(Error, "Can't graph a dataset that splits multiple result sets") if opts[:split_multiple_result_sets]
+        super
+      end
+
+      # Insert a new value into this dataset
+      def insert(*values)
+        execute_dui(insert_sql(*values)){|c| return c.insert_id}
+      end
+
+      # Replace (update or insert) the matching row.
+      def replace(*args)
+        execute_dui(replace_sql(*args)){|c| return c.insert_id}
+      end
+
+      # Update the matching rows.
+      def update(values={})
+        execute_dui(update_sql(values)){|c| return c.affected_rows}
+      end
+
+      private
+
+      # Set the :type option to :select if it hasn't been set.
+      def execute(sql, opts={}, &block)
+        super(sql, {:type=>:select}.merge(opts), &block)
+      end
+
+      # Set the :type option to :dui if it hasn't been set.
+      def execute_dui(sql, opts={}, &block)
+        super(sql, {:type=>:dui}.merge(opts), &block)
+      end
+
+      # Handle correct quoting of strings using ::MySQL.quote.
+      def literal_string(v)
+        db.synchronize{|c| "'#{c.quote(v)}'"}
+      end
+    end
+  end
+end

data/mysql2.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{mysql2}
-  s.version = "0.1.4"
+  s.version = "0.1.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian Lopez"]
-  s.date = %q{2010-04-23}
+  s.date = %q{2010-05-12}
   s.email = %q{seniorlopez@gmail.com}
   s.extensions = ["ext/extconf.rb"]
   s.extra_rdoc_files = [
@@ -24,7 +24,9 @@ Gem::Specification.new do |s|
      "VERSION",
      "benchmark/active_record.rb",
      "benchmark/escape.rb",
-     "benchmark/query.rb",
+     "benchmark/query_with_mysql_casting.rb",
+     "benchmark/query_without_mysql_casting.rb",
+     "benchmark/sequel.rb",
      "benchmark/setup_db.rb",
      "examples/eventmachine.rb",
      "ext/extconf.rb",
@@ -34,6 +36,7 @@ Gem::Specification.new do |s|
      "lib/arel/engines/sql/compilers/mysql2_compiler.rb",
      "lib/mysql2.rb",
      "lib/mysql2/em.rb",
+     "lib/sequel/adapters/mysql2.rb",
      "mysql2.gemspec",
      "spec/active_record/active_record_spec.rb",
      "spec/em/em_spec.rb",