mysql2 0.1.8 → 0.1.9

data/ext/{mysql2_ext.h → mysql2/mysql2_ext.h}

@@ -1,3 +1,6 @@
+#ifndef MYSQL2_EXT
+#define MYSQL2_EXT
+
 #include <ruby.h>
 #include <fcntl.h>
 
@@ -15,7 +18,6 @@
 
 #ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>
-static int utf8Encoding, binaryEncoding;
 #endif
 
 #if defined(__GNUC__) && (__GNUC__ >= 3)
@@ -24,56 +26,24 @@ static int utf8Encoding, binaryEncoding;
 #define RB_MYSQL_UNUSED
 #endif
 
-static VALUE cBigDecimal, cDate, cDateTime;
-static ID intern_new, intern_utc;
+#include <result.h>
 
-/* Mysql2::Error */
-static VALUE cMysql2Error;
+extern VALUE mMysql2;
 
-/* Mysql2::Client */
-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,
-          sym_symbolize_keys, sym_async;
-static VALUE rb_mysql_client_new(int argc, VALUE * argv, VALUE klass);
-static VALUE rb_mysql_client_init(int argc, VALUE * argv, VALUE self);
-static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self);
-static VALUE rb_mysql_client_escape(VALUE self, VALUE str);
-static VALUE rb_mysql_client_info(VALUE self);
-static VALUE rb_mysql_client_server_info(VALUE self);
-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);
-static void rb_mysql_client_free(void * client);
+/* Mysql2::Error */
+extern VALUE cMysql2Error;
 
 /* Mysql2::Result */
 typedef struct {
     VALUE fields;
     VALUE rows;
-    unsigned long numberOfFields;
+    unsigned int numberOfFields;
     unsigned long numberOfRows;
     unsigned long lastRowProcessed;
-    int resultFreed;
+    short int resultFreed;
     MYSQL_RES *result;
 } mysql2_result_wrapper;
 #define GetMysql2Result(obj, sval) (sval = (mysql2_result_wrapper*)DATA_PTR(obj));
-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);
-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);
-
-/* Mysql2::Error */
-static VALUE rb_raise_mysql2_error(MYSQL *client);
-static VALUE rb_mysql_error_error_number(VALUE obj);
-static VALUE rb_mysql_error_sql_state(VALUE obj);
 
 /*
  * used to pass all arguments to mysql_real_connect while inside
@@ -124,3 +94,5 @@ rb_thread_blocking_region(
 	return rv;
 }
 #endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */
+
+#endif

data/ext/mysql2/result.c

@@ -0,0 +1,340 @@
+#include <mysql2_ext.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+rb_encoding *binaryEncoding;
+#endif
+
+ID sym_symbolize_keys;
+ID intern_new, intern_utc, intern_encoding_from_charset_code;
+
+VALUE cBigDecimal, cDate, cDateTime;
+VALUE cMysql2Result;
+extern VALUE cMysql2Client;
+
+static void rb_mysql_result_mark(void * wrapper) {
+    mysql2_result_wrapper * w = wrapper;
+    if (w) {
+        rb_gc_mark(w->fields);
+        rb_gc_mark(w->rows);
+    }
+}
+
+/* this may be called manually or during GC */
+static void rb_mysql_result_free_result(mysql2_result_wrapper * wrapper) {
+  if (wrapper && wrapper->resultFreed != 1) {
+    mysql_free_result(wrapper->result);
+    wrapper->resultFreed = 1;
+  }
+}
+
+/* this is called during GC */
+static void rb_mysql_result_free(void * wrapper) {
+  mysql2_result_wrapper * w = wrapper;
+  /* FIXME: this may call flush_use_result, which can hit the socket */
+  rb_mysql_result_free_result(w);
+  xfree(wrapper);
+}
+
+/*
+ * for small results, this won't hit the network, but there's no
+ * reliable way for us to tell this so we'll always release the GVL
+ * to be safe
+ */
+static VALUE nogvl_fetch_row(void *ptr) {
+  MYSQL_RES *result = ptr;
+
+  return (VALUE)mysql_fetch_row(result);
+}
+
+static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, short int symbolize_keys) {
+  mysql2_result_wrapper * wrapper;
+
+  GetMysql2Result(self, wrapper);
+
+  if (wrapper->fields == Qnil) {
+    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
+    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
+  }
+
+  VALUE rb_field = rb_ary_entry(wrapper->fields, idx);
+  if (rb_field == Qnil) {
+    MYSQL_FIELD *field = NULL;
+#ifdef HAVE_RUBY_ENCODING_H
+    rb_encoding *default_internal_enc = rb_default_internal_encoding();
+    rb_encoding *conn_enc = rb_to_encoding(rb_iv_get(self, "@encoding"));
+#endif
+
+    field = mysql_fetch_field_direct(wrapper->result, idx);
+    if (symbolize_keys) {
+      char buf[field->name_length+1];
+      memcpy(buf, field->name, field->name_length);
+      buf[field->name_length] = 0;
+      rb_field = ID2SYM(rb_intern(buf));
+    } else {
+      rb_field = rb_str_new(field->name, field->name_length);
+#ifdef HAVE_RUBY_ENCODING_H
+      rb_enc_associate(rb_field, conn_enc);
+      if (default_internal_enc) {
+        rb_field = rb_str_export_to_enc(rb_field, default_internal_enc);
+      }
+#endif
+    }
+    rb_ary_store(wrapper->fields, idx, rb_field);
+  }
+
+  return rb_field;
+}
+
+static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self) {
+  VALUE rowHash, opts, block;
+  mysql2_result_wrapper * wrapper;
+  MYSQL_ROW row;
+  MYSQL_FIELD * fields = NULL;
+  unsigned int i = 0, symbolizeKeys = 0;
+  unsigned long * fieldLengths;
+  void * ptr;
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *default_internal_enc = rb_default_internal_encoding();
+  rb_encoding *conn_enc = rb_to_encoding(rb_iv_get(self, "@encoding"));
+#endif
+
+  GetMysql2Result(self, wrapper);
+
+  if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) {
+    Check_Type(opts, T_HASH);
+    if (rb_hash_aref(opts, sym_symbolize_keys) == Qtrue) {
+        symbolizeKeys = 1;
+    }
+  }
+
+  ptr = wrapper->result;
+  row = (MYSQL_ROW)rb_thread_blocking_region(nogvl_fetch_row, ptr, RUBY_UBF_IO, 0);
+  if (row == NULL) {
+    return Qnil;
+  }
+
+  rowHash = rb_hash_new();
+  fields = mysql_fetch_fields(wrapper->result);
+  fieldLengths = mysql_fetch_lengths(wrapper->result);
+  if (wrapper->fields == Qnil) {
+    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
+    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
+  }
+
+  for (i = 0; i < wrapper->numberOfFields; i++) {
+    VALUE field = rb_mysql_result_fetch_field(self, i, symbolizeKeys);
+    if (row[i]) {
+      VALUE val;
+      switch(fields[i].type) {
+        case MYSQL_TYPE_NULL:       // NULL-type field
+          val = Qnil;
+          break;
+        case MYSQL_TYPE_BIT:        // BIT field (MySQL 5.0.3 and up)
+          val = rb_str_new(row[i], fieldLengths[i]);
+          break;
+        case MYSQL_TYPE_TINY:       // TINYINT field
+        case MYSQL_TYPE_SHORT:      // SMALLINT field
+        case MYSQL_TYPE_LONG:       // INTEGER field
+        case MYSQL_TYPE_INT24:      // MEDIUMINT field
+        case MYSQL_TYPE_LONGLONG:   // BIGINT field
+        case MYSQL_TYPE_YEAR:       // YEAR field
+          val = rb_cstr2inum(row[i], 10);
+          break;
+        case MYSQL_TYPE_DECIMAL:    // DECIMAL or NUMERIC field
+        case MYSQL_TYPE_NEWDECIMAL: // Precision math DECIMAL or NUMERIC field (MySQL 5.0.3 and up)
+          val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new(row[i], fieldLengths[i]));
+          break;
+        case MYSQL_TYPE_FLOAT:      // FLOAT field
+        case MYSQL_TYPE_DOUBLE:     // DOUBLE or REAL field
+          val = rb_float_new(strtod(row[i], NULL));
+          break;
+        case MYSQL_TYPE_TIME: {     // TIME field
+          int hour, min, sec, tokens;
+          tokens = sscanf(row[i], "%2d:%2d:%2d", &hour, &min, &sec);
+          val = rb_funcall(rb_cTime, intern_utc, 6, INT2NUM(0), INT2NUM(1), INT2NUM(1), INT2NUM(hour), INT2NUM(min), INT2NUM(sec));
+          break;
+        }
+        case MYSQL_TYPE_TIMESTAMP:  // TIMESTAMP field
+        case MYSQL_TYPE_DATETIME: { // DATETIME field
+          int year, month, day, hour, min, sec, tokens;
+          tokens = sscanf(row[i], "%4d-%2d-%2d %2d:%2d:%2d", &year, &month, &day, &hour, &min, &sec);
+          if (year+month+day+hour+min+sec == 0) {
+            val = Qnil;
+          } else {
+            if (month < 1 || day < 1) {
+              rb_raise(cMysql2Error, "Invalid date: %s", row[i]);
+              val = Qnil;
+            } else {
+              val = rb_funcall(rb_cTime, intern_utc, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec));
+            }
+          }
+          break;
+        }
+        case MYSQL_TYPE_DATE:       // DATE field
+        case MYSQL_TYPE_NEWDATE: {  // Newer const used > 5.0
+          int year, month, day, tokens;
+          tokens = sscanf(row[i], "%4d-%2d-%2d", &year, &month, &day);
+          if (year+month+day == 0) {
+            val = Qnil;
+          } else {
+            if (month < 1 || day < 1) {
+              rb_raise(cMysql2Error, "Invalid date: %s", row[i]);
+              val = Qnil;
+            } else {
+              val = rb_funcall(cDate, intern_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
+            }
+          }
+          break;
+        }
+        case MYSQL_TYPE_TINY_BLOB:
+        case MYSQL_TYPE_MEDIUM_BLOB:
+        case MYSQL_TYPE_LONG_BLOB:
+        case MYSQL_TYPE_BLOB:
+        case MYSQL_TYPE_VAR_STRING:
+        case MYSQL_TYPE_VARCHAR:
+        case MYSQL_TYPE_STRING:     // CHAR or BINARY field
+        case MYSQL_TYPE_SET:        // SET field
+        case MYSQL_TYPE_ENUM:       // ENUM field
+        case MYSQL_TYPE_GEOMETRY:   // Spatial fielda
+        default:
+          val = rb_str_new(row[i], fieldLengths[i]);
+#ifdef HAVE_RUBY_ENCODING_H
+          // if binary flag is set, respect it's wishes
+          if (fields[i].flags & BINARY_FLAG) {
+            rb_enc_associate(val, binaryEncoding);
+          } else {
+            // lookup the encoding configured on this field
+            VALUE new_encoding = rb_funcall(cMysql2Client, intern_encoding_from_charset_code, 1, INT2NUM(fields[i].charsetnr));
+            if (new_encoding != Qnil) {
+              // use the field encoding we were able to match
+              rb_encoding *enc = rb_to_encoding(new_encoding);
+              rb_enc_associate(val, enc);
+            } else {
+              // otherwise fall-back to the connection's encoding
+              rb_enc_associate(val, conn_enc);
+            }
+            if (default_internal_enc) {
+              val = rb_str_export_to_enc(val, default_internal_enc);
+            }
+          }
+#endif
+          break;
+      }
+      rb_hash_aset(rowHash, field, val);
+    } else {
+      rb_hash_aset(rowHash, field, Qnil);
+    }
+  }
+  return rowHash;
+}
+
+static VALUE rb_mysql_result_fetch_fields(VALUE self) {
+  mysql2_result_wrapper * wrapper;
+  unsigned int i = 0;
+
+  GetMysql2Result(self, wrapper);
+
+  if (wrapper->fields == Qnil) {
+    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
+    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
+  }
+
+  if (RARRAY_LEN(wrapper->fields) != wrapper->numberOfFields) {
+    for (i=0; i<wrapper->numberOfFields; i++) {
+      rb_mysql_result_fetch_field(self, i, 0);
+    }
+  }
+
+  return wrapper->fields;
+}
+
+static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
+  VALUE opts, block;
+  mysql2_result_wrapper * wrapper;
+  unsigned long i;
+
+  GetMysql2Result(self, wrapper);
+
+  rb_scan_args(argc, argv, "01&", &opts, &block);
+
+  if (wrapper->lastRowProcessed == 0) {
+    wrapper->numberOfRows = mysql_num_rows(wrapper->result);
+    if (wrapper->numberOfRows == 0) {
+      return Qnil;
+    }
+    wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
+  }
+
+  if (wrapper->lastRowProcessed == wrapper->numberOfRows) {
+    // we've already read the entire dataset from the C result into our
+    // internal array. Lets hand that over to the user since it's ready to go
+    for (i = 0; i < wrapper->numberOfRows; i++) {
+      rb_yield(rb_ary_entry(wrapper->rows, i));
+    }
+  } else {
+    unsigned long rowsProcessed = 0;
+    rowsProcessed = RARRAY_LEN(wrapper->rows);
+    for (i = 0; i < wrapper->numberOfRows; i++) {
+      VALUE row;
+      if (i < rowsProcessed) {
+        row = rb_ary_entry(wrapper->rows, i);
+      } else {
+        row = rb_mysql_result_fetch_row(argc, argv, self);
+        rb_ary_store(wrapper->rows, i, row);
+        wrapper->lastRowProcessed++;
+      }
+
+      if (row == Qnil) {
+        // we don't need the mysql C dataset around anymore, peace it
+        rb_mysql_result_free_result(wrapper);
+        return Qnil;
+      }
+
+      if (block != Qnil) {
+        rb_yield(row);
+      }
+    }
+    if (wrapper->lastRowProcessed == wrapper->numberOfRows) {
+      // we don't need the mysql C dataset around anymore, peace it
+      rb_mysql_result_free_result(wrapper);
+    }
+  }
+
+  return wrapper->rows;
+}
+
+/* Mysql2::Result */
+VALUE rb_mysql_result_to_obj(MYSQL_RES * r) {
+  VALUE obj;
+  mysql2_result_wrapper * wrapper;
+  obj = Data_Make_Struct(cMysql2Result, mysql2_result_wrapper, rb_mysql_result_mark, rb_mysql_result_free, wrapper);
+  wrapper->numberOfFields = 0;
+  wrapper->numberOfRows = 0;
+  wrapper->lastRowProcessed = 0;
+  wrapper->resultFreed = 0;
+  wrapper->result = r;
+  wrapper->fields = Qnil;
+  wrapper->rows = Qnil;
+  rb_obj_call_init(obj, 0, NULL);
+  return obj;
+}
+
+void init_mysql2_result()
+{
+  cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+  cDate = rb_const_get(rb_cObject, rb_intern("Date"));
+  cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
+
+  cMysql2Result = rb_define_class_under(mMysql2, "Result", rb_cObject);
+  rb_define_method(cMysql2Result, "each", rb_mysql_result_each, -1);
+  rb_define_method(cMysql2Result, "fields", rb_mysql_result_fetch_fields, 0);
+
+  sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
+  intern_new = rb_intern("new");
+  intern_utc = rb_intern("utc");
+  intern_encoding_from_charset_code = rb_intern("encoding_from_charset_code");
+
+#ifdef HAVE_RUBY_ENCODING_H
+  binaryEncoding = rb_enc_find("binary");
+#endif
+}

data/ext/mysql2/result.h

@@ -0,0 +1,7 @@
+#ifndef MYSQL2_RESULT_H
+#define MYSQL2_RESULT_H
+
+void init_mysql2_result();
+VALUE rb_mysql_result_to_obj(MYSQL_RES * r);
+
+#endif

data/lib/active_record/connection_adapters/em_mysql2_adapter.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+# AR adapter for using a fibered mysql2 connection with EM
+# This adapter should be used within Thin or Unicorn with the rack-fiber_pool middleware.
+# Just update your database.yml's adapter to be 'em_mysql2'
+
+module ActiveRecord
+  class Base
+    def self.em_mysql2_connection(config)
+      client = ::Mysql2::Fibered::Client.new(config.symbolize_keys)
+      options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
+      ConnectionAdapters::Mysql2Adapter.new(client, logger, options, config)
+    end
+  end
+end
+
+require 'fiber'
+require 'eventmachine' unless defined? EventMachine
+require 'mysql2' unless defined? Mysql2
+require 'active_record/connection_adapters/mysql2_adapter'
+require 'active_record/fiber_patches'
+
+module Mysql2
+  module Fibered
+    class Client < ::Mysql2::Client
+      module Watcher
+        def initialize(client, deferable)
+          @client = client
+          @deferable = deferable
+        end
+
+        def notify_readable
+          begin
+            detach
+            results = @client.async_result
+            @deferable.succeed(results)
+          rescue Exception => e
+            puts e.backtrace.join("\n\t")
+            @deferable.fail(e)
+          end
+        end
+      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
+        fiber = Fiber.current
+        deferable.callback do |result|
+          fiber.resume(result)
+        end
+        deferable.errback do |err|
+          fiber.resume(err)
+        end
+        Fiber.yield
+      end
+    end
+  end
+end