mysql2 0.3.14 → 0.3.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c05c6f7a1476667b0e6f1f8b94288a70e82cad15
-  data.tar.gz: b28cb5dcccf46727e60e0d30971a8e25183c4df2
+  metadata.gz: 1895b2fe6d621bc0608c1c16c7dde5872aff9af9
+  data.tar.gz: 4757365df13127c09c35c3b2cbf84ea35c9ab872
 SHA512:
-  metadata.gz: fa54239e2f7a16ecd4bd3481274f71619c97f61e607245e17aa091e654dc2334cb89b4d604999156aa7d7cb6905f5342aed97c99a5caca1fb32773ca22e7e01d
-  data.tar.gz: 65d9be8d59967b977b09f95321a00e67fbfb0822da39a57a1dfb18164cd109d7a4f966174800fbc0e1d864727b7ba463deee2a123c4f9cbbf2cd05508b93b9e0
+  metadata.gz: 9feaf2446a8f5c72594fb3958d2675b94b64849f1a8aa0054a7d2fd31191ac82566ae5d008d7e3cc84af329bf009461010e3e8617919abefeede90567ea6f571
+  data.tar.gz: 114eb344643a6ec32cf8624e268551334776eb0196105888dfff3a21f42b4889123a00a32f5692015c1ab1638b02b565c7a20a14a6df3d8371f471d9ad0ba702

data/README.md

@@ -66,7 +66,7 @@ files are. For example, if you unzipped the connector to c:\mysql-connector-c-6.
 the gem like this:
 
     gem install mysql2 -- --with-mysql-dir=c:\mysql-connector-c-6.1.1-win32
-    
+
 Finally, you must copy libmysql.dll from the lib subdirectory of your MySQL or MySQL connector directory into
 your ruby\bin directory. In the above example, libmysql.dll would be located at
 c:\mysql-connector-c-6.1.1-win32\lib .
@@ -160,22 +160,67 @@ Mysql2::Client.new(
   :default_group = 'my.cfg section'
   )
 ```
+
+### SSL options
+
+Setting any of the following options will enable an SSL connection, but only if
+your MySQL client library and server have been compiled with SSL support.
+MySQL client library defaults will be used for any parameters that are left out
+or set to nil. Relative paths are allowed, and may be required by managed
+hosting providers such as Heroku.
+
+``` ruby
+Mysql2::Client.new(
+  # ...options as above...,
+  :sslkey => '/path/to/client-key.pem',
+  :sslcert => '/path/to/client-cert.pem',
+  :sslca => '/path/to/ca-cert.pem',
+  :sslcapath => '/path/to/cacerts',
+  :sslcipher => 'DHE-RSA-AES256-SHA'
+  )
+```
+
 ### Multiple result sets
 
-You can also retrieve multiple result sets. For this to work you need to connect with
-flags `Mysql2::Client::MULTI_STATEMENTS`. Using multiple result sets is normally used
-when calling stored procedures that return more than one result set
+You can also retrieve multiple result sets. For this to work you need to
+connect with flags `Mysql2::Client::MULTI_STATEMENTS`. Multiple result sets can
+be used with stored procedures that return more than one result set, and for
+bundling several SQL statements into a single call to `client.query`.
 
 ``` ruby
-client = Mysql2::Client.new(:host => "localhost", :username => "root", :flags => Mysql2::Client::MULTI_STATEMENTS )
-result = client.query( 'CALL sp_customer_list( 25, 10 )')
+client = Mysql2::Client.new(:host => "localhost", :username => "root", :flags => Mysql2::Client::MULTI_STATEMENTS)
+result = client.query('CALL sp_customer_list( 25, 10 )')
 # result now contains the first result set
-while ( client.next_result)
-    result = client.store_result
-    # result now contains the next result set
+while client.next_result
+  result = client.store_result
+  # result now contains the next result set
 end
 ```
 
+Repeated calls to `client.next_result` will return true, false, or raise an
+exception if the respective query erred. When `client.next_result` returns true,
+call `client.store_result` to retrieve a result object. Exceptions are not
+raised until `client.next_result` is called to find the status of the respective
+query. Subsequent queries are not executed if an earlier query raised an
+exception. Subsequent calls to `client.next_result` will return false.
+
+``` ruby
+result = client.query('SELECT 1; SELECT 2; SELECT A; SELECT 3')
+p result.first
+
+while client.next_result
+  result = client.store_result
+  p result.first
+end
+```
+
+Yields:
+```
+{"1"=>1}
+{"2"=>2}
+next_result: Unknown column 'A' in 'field list' (Mysql2::Error)
+```
+
 See https://gist.github.com/1367987 for using MULTI_STATEMENTS with Active Record.
 
 ### Secure auth
@@ -186,7 +231,7 @@ The MySQL 5.6.5 client library may also refuse to attempt a connection if provid
 To bypass this restriction in the client, pass the option :secure_auth => false to Mysql2::Client.new().
 If using ActiveRecord, your database.yml might look something like this:
 
-```
+``` yaml
 development:
   adapter: mysql2
   encoding: utf8
@@ -199,11 +244,12 @@ development:
 ```
 
 ### Reading a MySQL config file
+
 You may read configuration options from a MySQL configuration file by passing
 the `:default_file` and `:default_group` paramters. For example:
 
-```
-  client = Mysql2::Client.new(:default_file => '/user/.my.cnf', :default_group => 'client')
+``` ruby
+Mysql2::Client.new(:default_file => '/user/.my.cnf', :default_group => 'client')
 ```
 
 
@@ -254,11 +300,6 @@ Pass the `:as => :array` option to any of the above methods of configuration
 
 The default result type is set to :hash, but you can override a previous setting to something else with :as => :hash
 
-### Others...
-
-I may add support for `:as => :csv` or even `:as => :json` to allow for *much* more efficient generation of those data types from result sets.
-If you'd like to see either of these (or others), open an issue and start bugging me about it ;)
-
 ### Timezones
 
 Mysql2 now supports two timezone options:
@@ -405,15 +446,15 @@ As for field values themselves, I'm workin on it - but expect that soon.
 
 ## Compatibility
 
-The specs pass on my system (SL 10.6.3, x86_64) in these rubies:
+This gem is regularly tested against the following Ruby versions on Linux and Mac OS X:
 
-* 1.8.7-p249
-* ree-1.8.7-2010.01
-* 1.9.1-p378
-* ruby-trunk
-* rbx-head - broken at the moment, working with the rbx team for a solution
+ * Ruby MRI 1.8.7, 1.9.2, 1.9.3, 2.0.0 (ongoing patch releases).
+ * Ruby Enterprise Edition (based on MRI 1.8.7).
+ * Rubinius 2.0 in compatibility modes 1.8, 1.9, 2.0.
 
-The Active Record driver should work on 2.3.5 and 3.0
+The mysql2 gem 0.2.x series includes an Active Record driver that works with AR
+2.3.x and 3.0.x. Starting in Active Record 3.1, a mysql2 driver is included in
+the Active Record codebase and no longer provided in mysql2 gem 0.3 and above.
 
 ## Yeah... but why?
 
@@ -422,7 +463,6 @@ Someone: Dude, the Mysql gem works fiiiiiine.
 Me: It sure does, but it only hands you nil and strings for field values. Leaving you to convert
 them into proper Ruby types in Ruby-land - which is slow as balls.
 
-
 Someone: OK fine, but do_mysql can already give me back values with Ruby objects mapped to MySQL types.
 
 Me: Yep, but it's API is considerably more complex *and* can be ~2x slower.

data/ext/mysql2/client.c

@@ -1,5 +1,5 @@
 #include <mysql2_ext.h>
-#include <client.h>
+
 #include <errno.h>
 #ifndef _WIN32
 #include <sys/socket.h>
@@ -12,7 +12,7 @@
 VALUE cMysql2Client;
 extern VALUE mMysql2, cMysql2Error;
 static VALUE sym_id, sym_version, sym_async, sym_symbolize_keys, sym_as, sym_array, sym_stream;
-static ID intern_merge, intern_merge_bang, intern_error_number_eql, intern_sql_state_eql;
+static ID intern_merge, intern_merge_bang, intern_error_number_eql, intern_sql_state_eql, intern_server_version;
 
 #ifndef HAVE_RB_HASH_DUP
 static VALUE rb_hash_dup(VALUE other) {
@@ -125,19 +125,13 @@ static VALUE rb_raise_mysql2_error(mysql_client_wrapper *wrapper) {
   VALUE rb_error_msg = rb_str_new2(mysql_error(wrapper->client));
   VALUE rb_sql_state = rb_tainted_str_new2(mysql_sqlstate(wrapper->client));
   VALUE e;
-#ifdef HAVE_RUBY_ENCODING_H
-  rb_encoding *default_internal_enc = rb_default_internal_encoding();
-  rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
 
-  rb_enc_associate(rb_error_msg, conn_enc);
-  rb_enc_associate(rb_sql_state, conn_enc);
-  if (default_internal_enc) {
-    rb_error_msg = rb_str_export_to_enc(rb_error_msg, default_internal_enc);
-    rb_sql_state = rb_str_export_to_enc(rb_sql_state, default_internal_enc);
-  }
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_enc_associate(rb_error_msg, rb_utf8_encoding());
+  rb_enc_associate(rb_sql_state, rb_usascii_encoding());
 #endif
 
-  e = rb_exc_new3(cMysql2Error, rb_error_msg);
+  e = rb_funcall(cMysql2Error, rb_intern("new"), 2, rb_error_msg, LONG2FIX(wrapper->server_version));
   rb_funcall(e, intern_error_number_eql, 1, UINT2NUM(mysql_errno(wrapper->client)));
   rb_funcall(e, intern_sql_state_eql, 1, rb_sql_state);
   rb_exc_raise(e);
@@ -146,9 +140,13 @@ static VALUE rb_raise_mysql2_error(mysql_client_wrapper *wrapper) {
 
 static void *nogvl_init(void *ptr) {
   MYSQL *client;
+  mysql_client_wrapper *wrapper = (mysql_client_wrapper *)ptr;
 
   /* may initialize embedded server and read /etc/services off disk */
-  client = mysql_init((MYSQL *)ptr);
+  client = mysql_init(wrapper->client);
+
+  if (client) mysql2_set_local_infile(client, wrapper);
+
   return (void*)(client ? Qtrue : Qfalse);
 }
 
@@ -196,7 +194,11 @@ static void *nogvl_close(void *ptr) {
 
 static void rb_mysql_client_free(void *ptr) {
   mysql_client_wrapper *wrapper = (mysql_client_wrapper *)ptr;
+  decr_mysql2_client(wrapper);
+}
 
+void decr_mysql2_client(mysql_client_wrapper *wrapper)
+{
   wrapper->refcount--;
   if (wrapper->refcount == 0) {
     nogvl_close(wrapper);
@@ -211,6 +213,7 @@ static VALUE allocate(VALUE klass) {
   obj = Data_Make_Struct(klass, mysql_client_wrapper, rb_mysql_client_mark, rb_mysql_client_free, wrapper);
   wrapper->encoding = Qnil;
   wrapper->active_thread = Qnil;
+  wrapper->server_version = 0;
   wrapper->reconnect_enabled = 0;
   wrapper->connected = 0; /* means that a database connection is open */
   wrapper->initialized = 0; /* means that that the wrapper is initialized */
@@ -303,6 +306,7 @@ static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE po
       return rb_raise_mysql2_error(wrapper);
   }
 
+  wrapper->server_version = mysql_get_server_version(wrapper->client);
   wrapper->connected = 1;
   return self;
 }
@@ -1120,7 +1124,7 @@ static VALUE set_read_default_group(VALUE self, VALUE value) {
 static VALUE initialize_ext(VALUE self) {
   GET_CLIENT(self);
 
-  if ((VALUE)rb_thread_call_without_gvl(nogvl_init, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
+  if ((VALUE)rb_thread_call_without_gvl(nogvl_init, wrapper, RUBY_UBF_IO, 0) == Qfalse) {
     /* TODO: warning - not enough memory? */
     return rb_raise_mysql2_error(wrapper);
   }
@@ -1135,7 +1139,7 @@ void init_mysql2_client() {
   int i;
   int dots = 0;
   const char *lib = mysql_get_client_info();
-  
+
   for (i = 0; lib[i] != 0 && MYSQL_LINK_VERSION[i] != 0; i++) {
     if (lib[i] == '.') {
       dots++;
@@ -1204,6 +1208,7 @@ void init_mysql2_client() {
   intern_merge_bang = rb_intern("merge!");
   intern_error_number_eql = rb_intern("error_number=");
   intern_sql_state_eql = rb_intern("sql_state=");
+  intern_server_version = rb_intern("server_version=");
 
 #ifdef CLIENT_LONG_PASSWORD
   rb_const_set(cMysql2Client, rb_intern("LONG_PASSWORD"),

data/ext/mysql2/client.h

@@ -36,11 +36,10 @@ rb_thread_call_without_gvl(
 #endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */
 #endif /* ! HAVE_RB_THREAD_CALL_WITHOUT_GVL */
 
-void init_mysql2_client();
-
 typedef struct {
   VALUE encoding;
   VALUE active_thread; /* rb_thread_current() or Qnil */
+  long server_version;
   int reconnect_enabled;
   int active;
   int connected;
@@ -50,4 +49,7 @@ typedef struct {
   MYSQL *client;
 } mysql_client_wrapper;
 
+void init_mysql2_client();
+void decr_mysql2_client(mysql_client_wrapper *wrapper);
+
 #endif

data/ext/mysql2/infile.c

@@ -0,0 +1,119 @@
+#include <mysql2_ext.h>
+
+#include <errno.h>
+#include <unistd.h>
+
+#define ERROR_LEN 1024
+typedef struct
+{
+  int fd;
+  char *filename;
+  char error[ERROR_LEN];
+  mysql_client_wrapper *wrapper;
+} mysql2_local_infile_data;
+
+/* MySQL calls this function when a user begins a LOAD DATA LOCAL INFILE query.
+ *
+ * Allocate a data struct and pass it back through the data pointer.
+ *
+ * Returns:
+ * 0 on success
+ * 1 on error
+ */
+static int
+mysql2_local_infile_init(void **ptr, const char *filename, void *userdata)
+{
+  mysql2_local_infile_data *data = malloc(sizeof(mysql2_local_infile_data));
+  if (!data) return 1;
+
+  *ptr = data;
+  data->error[0] = 0;
+  data->wrapper = userdata;
+
+  data->filename = strdup(filename);
+  if (!data->filename) {
+    snprintf(data->error, ERROR_LEN, "%s: %s", strerror(errno), filename);
+    return 1;
+  }
+
+  data->fd = open(filename, O_RDONLY);
+  if (data->fd < 0) {
+    snprintf(data->error, ERROR_LEN, "%s: %s", strerror(errno), filename);
+    return 1;
+  }
+
+  return 0;
+}
+
+/* MySQL calls this function to read data from the local file.
+ *
+ * Returns:
+ * > 0   number of bytes read
+ * == 0  end of file
+ * < 0   error
+ */
+static int
+mysql2_local_infile_read(void *ptr, char *buf, uint buf_len)
+{
+  int count;
+  mysql2_local_infile_data *data = (mysql2_local_infile_data *)ptr;
+
+  count = (int)read(data->fd, buf, buf_len);
+  if (count < 0) {
+    snprintf(data->error, ERROR_LEN, "%s: %s", strerror(errno), data->filename);
+  }
+
+  return count;
+}
+
+/* MySQL calls this function when we're done with the LOCAL INFILE query.
+ *
+ * ptr will be null if the init function failed.
+ */
+static void
+mysql2_local_infile_end(void *ptr)
+{
+  mysql2_local_infile_data *data = (mysql2_local_infile_data *)ptr;
+  if (data) {
+    if (data->fd >= 0)
+      close(data->fd);
+    if (data->filename)
+      free(data->filename);
+    free(data);
+  }
+}
+
+/* MySQL calls this function if any of the functions above returned an error.
+ *
+ * This function is called even if init failed, with whatever ptr value
+ * init has set, regardless of the return value of the init function.
+ *
+ * Returns:
+ * Error message number (see http://dev.mysql.com/doc/refman/5.0/en/error-messages-client.html)
+ */
+static int
+mysql2_local_infile_error(void *ptr, char *error_msg, uint error_msg_len)
+{
+  mysql2_local_infile_data *data = (mysql2_local_infile_data *) ptr;
+
+  if (data) {
+    snprintf(error_msg, error_msg_len, "%s", data->error);
+    return CR_UNKNOWN_ERROR;
+  }
+
+  snprintf(error_msg, error_msg_len, "Out of memory");
+  return CR_OUT_OF_MEMORY;
+}
+
+/* Tell MySQL Client to use our own local_infile functions.
+ * This is both due to bugginess in the default handlers,
+ * and to improve the Rubyness of the handlers here.
+ */
+void mysql2_set_local_infile(MYSQL *mysql, void *userdata)
+{
+  mysql_set_local_infile_handler(mysql,
+                                 mysql2_local_infile_init,
+                                 mysql2_local_infile_read,
+                                 mysql2_local_infile_end,
+                                 mysql2_local_infile_error, userdata);
+}

data/ext/mysql2/infile.h

@@ -0,0 +1 @@
+void mysql2_set_local_infile(MYSQL *mysql, void *userdata);

data/ext/mysql2/mysql2_ext.h

@@ -41,5 +41,6 @@ typedef unsigned int    uint;
 
 #include <client.h>
 #include <result.h>
+#include <infile.h>
 
 #endif

data/ext/mysql2/result.c

@@ -1,4 +1,5 @@
 #include <mysql2_ext.h>
+
 #include <stdint.h>
 
 #include "mysql_enc_to_ruby.h"
@@ -84,11 +85,7 @@ static void rb_mysql_result_free(void *ptr) {
 
   // If the GC gets to client first it will be nil
   if (wrapper->client != Qnil) {
-    wrapper->client_wrapper->refcount--;
-    if (wrapper->client_wrapper->refcount == 0) {
-      xfree(wrapper->client_wrapper->client);
-      xfree(wrapper->client_wrapper);
-    }
+    decr_mysql2_client(wrapper->client_wrapper);
   }
 
   xfree(wrapper);
@@ -125,16 +122,12 @@ static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, short int
 
     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;
-
 #ifdef HAVE_RB_INTERN3
-      rb_field = rb_intern3(buf, field->name_length, rb_utf8_encoding());
+      rb_field = rb_intern3(field->name, field->name_length, rb_utf8_encoding());
       rb_field = ID2SYM(rb_field);
 #else
       VALUE colStr;
-      colStr = rb_str_new2(buf);
+      colStr = rb_str_new(field->name, field->name_length);
       rb_field = ID2SYM(rb_to_id(colStr));
 #endif
     } else {
@@ -433,6 +426,7 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
   ID db_timezone, app_timezone, dbTz, appTz;
   mysql2_result_wrapper * wrapper;
   unsigned long i;
+  const char * errstr;
   int symbolizeKeys = 0, asArray = 0, castBool = 0, cacheRows = 1, cast = 1, streaming = 0;
   MYSQL_FIELD * fields = NULL;
 
@@ -496,7 +490,7 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
   }
 
   if (wrapper->lastRowProcessed == 0) {
-    if(streaming) {
+    if (streaming) {
       /* We can't get number of rows if we're streaming, */
       /* until we've finished fetching all rows */
       wrapper->numberOfRows = 0;
@@ -512,7 +506,7 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
   }
 
   if (streaming) {
-    if(!wrapper->streamingComplete) {
+    if (!wrapper->streamingComplete) {
       VALUE row;
 
       fields = mysql_fetch_fields(wrapper->result);
@@ -530,6 +524,13 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
 
       wrapper->numberOfRows = wrapper->lastRowProcessed;
       wrapper->streamingComplete = 1;
+
+      // Check for errors, the connection might have gone out from under us
+      // mysql_error returns an empty string if there is no error
+      errstr = mysql_error(wrapper->client_wrapper->client);
+      if (errstr[0]) {
+        rb_raise(cMysql2Error, "%s", errstr);
+      }
     } else {
       rb_raise(cMysql2Error, "You have already fetched all the rows for this query and streaming is true. (to reiterate you must requery).");
     }