rdo-mysql 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.so
+*.bundle

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+services: mysql
+before_script:
+  - mysql -u root -e "CREATE DATABASE rdo;"
+  - mysql -u root -e "GRANT ALL ON rdo.* TO rdo@localhost IDENTIFIED BY 'rdo';"
+script: "bundle exec rake spec"
+rvm:
+  - 1.9.2
+  - 1.9.3
+notifications:
+  email: chris@w3style.co.uk

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+# allow a local version of RDO to be used during dev
+if ENV["RDO_PATH"]
+  gem 'rdo', path: ENV["RDO_PATH"]
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 d11wtq
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# RDO MySQL Driver
+
+This is the MySQL driver for [RDO—Ruby Data Objects](https://github.com/d11wtq/rdo).
+
+[![Build Status](https://secure.travis-ci.org/d11wtq/rdo-mysql.png)](http://travis-ci.org/d11wtq/rdo-mysql)
+
+Refer to the RDO project [README](https://github.com/d11wtq/rdo) for full usage information.
+
+## Installation
+
+Via rubygems:
+
+    $ gem install rdo-mysql
+
+Or add this line to your application's Gemfile:
+
+    gem "rdo-mysql"
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+``` ruby
+require "rdo-mysql"
+
+conn = RDO.connect("mysql://user:pass@localhost/db_name?encoding=utf-8")
+```
+
+## Prepared statements
+
+MySQL, in theory supports prepared statements. But really you would not want
+to use them. There are still a number of known limitations with MySQL prepared
+statements, as outlined here:
+
+  - http://dev.mysql.com/doc/refman/5.0/en/c-api-prepared-statement-problems.html
+  - http://dev.mysql.com/doc/refman/5.1/en/c-api-prepared-statement-problems.html
+  - http://dev.mysql.com/doc/refman/5.5/en/c-api-prepared-statement-problems.html
+
+rdo-mysql uses RDO's emulated prepared statement support instead. If people
+shout loud enough that they'd prefer to use MySQL's problematic prepared
+statements anyway, I'll implement them.
+
+## Contributing
+
+If you find any bugs, please send a pull request if you think you can
+fix it, or file in an issue in the issue tracker.
+
+When sending pull requests, please use topic branches—don't send a pull
+request from the master branch of your fork, as that may change
+unintentionally.
+
+Contributors will be credited in this README.
+
+## Copyright & Licensing
+
+Written by Chris Corbyn.
+
+Licensed under the MIT license. See the LICENSE file for full details.

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new('rdo_mysql') do |ext|
+  ext.lib_dir = File.join('lib', 'rdo_mysql')
+end
+
+desc "Run the full RSpec suite"
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.pattern     = 'spec/'
+end
+
+Rake::Task['spec'].prerequisites << :compile

data/ext/rdo_mysql/driver.c

@@ -0,0 +1,179 @@
+/*
+ * RDO MySQL Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include "driver.h"
+#include <stdio.h>
+#include "tuples.h"
+#include "macros.h"
+#include <ruby/encoding.h>
+
+/** Struct wrapped by RDO::MySQL::Driver */
+typedef struct {
+  MYSQL * conn;
+  int     is_open;
+  int     encoding;
+} RDOMySQLDriver;
+
+/** Free memory associated with connection during GC */
+static void rdo_mysql_driver_free(RDOMySQLDriver * driver) {
+  mysql_close(driver->conn);
+  free(driver);
+}
+
+/** Extract result information from the given result */
+static VALUE rdo_mysql_result_info_new(MYSQL * conn, MYSQL_RES * res) {
+  unsigned long long count = (res == NULL) ? 0 : mysql_num_rows(res);
+
+  VALUE info = rb_hash_new();
+  rb_hash_aset(info, ID2SYM(rb_intern("count")), LL2NUM(count));
+  rb_hash_aset(info, ID2SYM(rb_intern("insert_id")),
+      LL2NUM(mysql_insert_id(conn)));
+  rb_hash_aset(info, ID2SYM(rb_intern("affected_rows")),
+      LL2NUM(mysql_affected_rows(conn)));
+
+  return info;
+}
+
+/** Allocate memory, wrapping RDOMySQLDriver */
+static VALUE rdo_mysql_driver_allocate(VALUE klass) {
+  RDOMySQLDriver * driver = malloc(sizeof(RDOMySQLDriver));
+  driver->conn     = NULL;
+  driver->is_open  = 0;
+  driver->encoding = -1;
+
+  return Data_Wrap_Struct(klass, 0, rdo_mysql_driver_free, driver);
+}
+
+/** Open a connection to MySQL */
+static VALUE rdo_mysql_driver_open(VALUE self) {
+  RDOMySQLDriver * driver;
+  Data_Get_Struct(self, RDOMySQLDriver, driver);
+
+  if (driver->is_open) {
+    return Qtrue;
+  }
+
+  if (!(driver->conn = mysql_init(NULL))) {
+    RDO_ERROR("Failed to connect to MySQL. Could not allocate memory.");
+  }
+
+  VALUE host = rb_funcall(self, rb_intern("host"), 0);
+  VALUE port = rb_funcall(self, rb_intern("port"), 0);
+  VALUE user = rb_funcall(self, rb_intern("user"), 0);
+  VALUE pass = rb_funcall(self, rb_intern("password"), 0);
+  VALUE db   = rb_funcall(self, rb_intern("database"), 0);
+
+  Check_Type(host, T_STRING);
+  Check_Type(port, T_FIXNUM);
+  Check_Type(user, T_STRING);
+  Check_Type(pass, T_STRING);
+  Check_Type(db,   T_STRING);
+
+  if (!mysql_real_connect(driver->conn,
+        RSTRING_PTR(host),
+        RSTRING_PTR(user),
+        RSTRING_PTR(pass),
+        RSTRING_PTR(db),
+        NUM2INT(port),
+        NULL, // UNIX socket
+        0)) {
+    RDO_ERROR("MySQL connection failed: %s", mysql_error(driver->conn));
+  } else {
+    driver->is_open  = 1;
+    driver->encoding = rb_enc_find_index(
+        RSTRING_PTR(rb_funcall(self, rb_intern("encoding"), 0)));
+    rb_funcall(self, rb_intern("after_open"), 0);
+  }
+
+  return Qtrue;
+}
+
+/** Return true if the connection is open */
+static VALUE rdo_mysql_driver_open_p(VALUE self) {
+  RDOMySQLDriver * driver;
+  Data_Get_Struct(self, RDOMySQLDriver, driver);
+
+  return driver->is_open ? Qtrue : Qfalse;
+}
+
+/** Close the connection to MySQL */
+static VALUE rdo_mysql_driver_close(VALUE self) {
+  RDOMySQLDriver * driver;
+  Data_Get_Struct(self, RDOMySQLDriver, driver);
+
+  mysql_close(driver->conn);
+  driver->conn     = NULL;
+  driver->is_open  = 0;
+  driver->encoding = -1;
+
+  return Qtrue;
+}
+
+/** Quote values for safe insertion into a statement */
+static VALUE rdo_mysql_driver_quote(VALUE self, VALUE obj) {
+  if (TYPE(obj) != T_STRING) {
+    obj = RDO_OBJ_TO_S(obj);
+  }
+
+  RDOMySQLDriver * driver;
+  Data_Get_Struct(self, RDOMySQLDriver, driver);
+
+  if (!(driver->is_open)) {
+    RDO_ERROR("Unable to quote value: connection is closed");
+  }
+
+  char quoted[RSTRING_LEN(obj) * 2 + 1];
+
+  mysql_real_escape_string(driver->conn,
+      quoted, RSTRING_PTR(obj), RSTRING_LEN(obj));
+
+  return rb_str_new2(quoted);
+}
+
+/** Execute a statement with possible bind parameters */
+static VALUE rdo_mysql_driver_execute(int argc, VALUE * args, VALUE self) {
+  if (argc < 1) {
+    rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
+  }
+
+  RDOMySQLDriver * driver;
+  Data_Get_Struct(self, RDOMySQLDriver, driver);
+
+  if (!(driver->is_open)) {
+    RDO_ERROR("Cannot execute query: connection is not open");
+  }
+
+  VALUE stmt = RDO_INTERPOLATE(self, args, argc);
+
+  if (mysql_real_query(driver->conn,
+        RSTRING_PTR(stmt),
+        RSTRING_LEN(stmt)) != 0) {
+    RDO_ERROR("Failed to execute query: %s", mysql_error(driver->conn));
+  }
+
+  MYSQL_RES * res = mysql_store_result(driver->conn);
+
+  return RDO_RESULT(rdo_mysql_tuple_list_new(res, driver->encoding),
+      rdo_mysql_result_info_new(driver->conn, res));
+}
+
+/** Initializer driver during extension initialization */
+void Init_rdo_mysql_driver(void) {
+  rb_require("rdo/mysql/driver");
+
+  VALUE cMySQL = rb_path2class("RDO::MySQL::Driver");
+
+  rb_define_alloc_func(cMySQL, rdo_mysql_driver_allocate);
+
+  rb_define_method(cMySQL, "open", rdo_mysql_driver_open, 0);
+  rb_define_method(cMySQL, "open?", rdo_mysql_driver_open_p, 0);
+  rb_define_method(cMySQL, "close", rdo_mysql_driver_close, 0);
+  rb_define_method(cMySQL, "quote", rdo_mysql_driver_quote, 1);
+  rb_define_method(cMySQL, "execute", rdo_mysql_driver_execute, -1);
+
+  Init_rdo_mysql_tuples();
+}

data/ext/rdo_mysql/driver.h

@@ -0,0 +1,12 @@
+/*
+ * RDO MySQL Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <ruby.h>
+#include <mysql.h>
+
+/** Initializer driver during extension initialization */
+void Init_rdo_mysql_driver(void);

data/ext/rdo_mysql/extconf.rb

@@ -0,0 +1,34 @@
+require "mkmf"
+
+if ENV["CC"]
+  RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"]
+end
+
+def config_value(type, flag)
+  IO.popen("mysql_config --#{type}").
+    readline.chomp.
+    split(/\s+/).select{|s| s =~ /^#{flag}/}.
+    map{|s| s.sub(/^#{flag}/, "")}.uniq
+rescue
+  Array[]
+end
+
+def have_build_env
+  [
+    have_header("mysql.h"),
+    config_value("libs", "-l").all?{|lib| have_library(lib)}
+  ].all?
+end
+
+dir_config(
+  "mysqlclient",
+  config_value("include", "-I"),
+  config_value("libs", "-L")
+)
+
+unless have_build_env
+  puts "Unable to find mysqlclient libraries and headers. Not building."
+  exit(1)
+end
+
+create_makefile("rdo_mysql/rdo_mysql")

data/ext/rdo_mysql/macros.h

@@ -0,0 +1,212 @@
+/*
+ * RDO—Ruby Data Objects.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+/** -------------------------------------------------------------------------
+ * These macros are for use by RDO driver developers.
+ *
+ * They simplify the logic needed when converting types provided by the RDBMS
+ * into their equivalent Ruby types.
+ *
+ * All of these macros take a C string and return a Ruby VALUE.
+ *
+ * The actual logic for many of the conversions is handled in RDO::Util, which
+ * is written in Ruby.
+ * --------------------------------------------------------------------------
+ */
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+/**
+ * Convenience to call #to_s on any Ruby object.
+ */
+#define RDO_OBJ_TO_S(obj) (rb_funcall(obj, rb_intern("to_s"), 0))
+
+/**
+ * Raise an RDO::Exception with the given msg format and any number of parameters.
+ *
+ * @param (char *) msg
+ *   a format string passed to rb_raise()
+ *
+ * @param (void *) ...
+ *   args used to interpolate the error message
+ */
+#define RDO_ERROR(...) (rb_raise(rb_path2class("RDO::Exception"), __VA_ARGS__))
+
+/**
+ * Calls Driver#interpolate for args.
+ *
+ * @param VALUE (RDO::Driver)
+ *   the Driver to use #quote from
+ *
+ * @param (VALUE *) args
+ *   a C array where the first element is the SQL and the remainder are the bind params
+ *
+ * @param int argc
+ *   the number of elements in args
+ *
+ * @return VALUE (String)
+ *   a Ruby String with the SQL including the interpolated params
+ */
+#define RDO_INTERPOLATE(driver, args, argc) \
+  (rb_funcall(driver, rb_intern("interpolate"), 2, \
+              args[0], rb_ary_new4(argc - 1, &args[1])))
+
+/**
+ * Factory to return a new RDO::Result for an Enumerable object of tuples.
+ *
+ * @param VALUE (Enumerable) tuples
+ *   an object that knows how to iterate all tuples
+ *
+ * @param VALUE (Hash)
+ *   an optional hash of query info.
+ *
+ * @return VALUE (RDO::Result)
+ *   a new Result object
+ */
+#define RDO_RESULT(tuples, info) \
+  (rb_funcall(rb_path2class("RDO::Result"), rb_intern("new"), 2, tuples, info))
+
+/**
+ * Wrap the given StatementExecutor in a RDO::Statement.
+ *
+ * @param VALUE
+ *   any object that responds to #command and #execute
+ *
+ * @return VALUE
+ *   an RDO::Statement
+ */
+#define RDO_STATEMENT(executor) \
+  (rb_funcall(rb_path2class("RDO::Statement"), rb_intern("new"), 1, executor))
+
+/**
+ * Convert a C string to a ruby String.
+ *
+ * @param (char *) s
+ *   a C string that is valid in the default encoding
+ *
+ * @param (size_t) len
+ *   the length of the string
+ *
+ * @return VALUE (String)
+ *   a Ruby String
+ */
+#define RDO_STRING(s, len, enc) \
+  (rb_enc_associate_index(rb_str_new(s, len), enc > 0 ? enc : 0))
+
+/**
+ * Convert a C string to a ruby String, assuming possible NULL bytes.
+ *
+ * @param (char *) s
+ *   a C string, possibly containing nulls
+ *
+ * @param (size_t) len
+ *   the length of the string
+ *
+ * @return VALUE (String)
+ *   a Ruby String
+ */
+#define RDO_BINARY_STRING(s, len) (rb_str_new(s, len))
+
+/**
+ * Convert a C string to a Fixnum.
+ */
+#define RDO_FIXNUM(s) (rb_cstr2inum(s, 10))
+
+/**
+ * Convert a C string to a Float.
+ *
+ * This supports Infinity and NaN.
+ *
+ * @param (char *) s
+ *   a C string representing a float (e.g. "1.234")
+ *
+ * @return VALUE (Float)
+ *   a ruby Float
+ */
+#define RDO_FLOAT(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("float"), 1, rb_str_new2(s)))
+
+/**
+ * Convert a C string representing a precision decimal into a BigDecimal.
+ *
+ * @param (char *) s
+ *   a C string representing a decimal ("1.245")
+ *
+ * @return VALUE (BigDecimal)
+ *   a BigDecimal representation of this string
+ *
+ * @example
+ *   RDO_DECIMAL("1.234")
+ *   => #<BigDecimal:7feb42b2b6e8,'0.1234E1',18(18)>
+ */
+#define RDO_DECIMAL(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("decimal"), 1, rb_str_new2(s)))
+
+/**
+ * Convert a C string representing a date into a Date.
+ *
+ * @param (char *) s
+ *   the C string with a parseable date
+ *
+ * @return VALUE (Date)
+ *   a Date, exactly as was specified in the input
+ *
+ * @example
+ *   RDO_DATE("431-09-22 BC")
+ *   #<Date: -0430-09-22 ((1564265j,0s,0n),+0s,2299161j)>
+ */
+#define RDO_DATE(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("date"), 1, rb_str_new2(s)))
+
+/**
+ * Convert a C string representing a date & time with no time zone into a DateTime.
+ *
+ * @param (char *) s
+ *   the C string with the date & time provided
+ *
+ * @return VALUE (DateTime)
+ *   a DateTime, assuming the system time zone
+ *
+ * @example
+ *   RDO_DATE_TIME_WITHOUT_ZONE("2012-09-22 04:36:12")
+ *   #<DateTime: 2012-09-22T04:36:12+10:00 ((2456192j,66972s,0n),+36000s,2299161j)>
+ */
+#define RDO_DATE_TIME_WITHOUT_ZONE(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("date_time_without_zone"), 1, rb_str_new2(s)))
+
+/**
+ * Convert a C string representing a date & time that includes a time zone into a DateTime.
+ *
+ * @param (char *) s
+ *   the C string with the date & time provided, including the time zone
+ *
+ * @return VALUE (DateTime)
+ *   a DateTime, exactly as was specified in the input
+ *
+ * @example
+ *   RDO_DATE_TIME_WITHOUT_ZONE("2012-09-22 04:36:12+10:00")
+ *   #<DateTime: 2012-09-22T04:36:12+10:00 ((2456192j,66972s,0n),+36000s,2299161j)>
+ */
+#define RDO_DATE_TIME_WITH_ZONE(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("date_time_with_zone"), 1, rb_str_new2(s)))
+
+/**
+ * Convert a boolean string to TrueClass/FalseClass.
+ *
+ * @param (char *) s
+ *   a C string that is either 't', 'true', 'f' or 'false'
+ *
+ * @return VALUE (TrueClass, FalseClass)
+ *   the boolean representation
+ */
+#define RDO_BOOL(s) ((s[0] == 't') ? Qtrue : Qfalse)

data/ext/rdo_mysql/rdo_mysql.c

@@ -0,0 +1,15 @@
+/*
+ * RDO MySQL Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <ruby.h>
+#include "driver.h"
+
+/** Extension initializer, called when .so is loaded */
+void Init_rdo_mysql(void) {
+  rb_require("rdo");
+  Init_rdo_mysql_driver();
+}

data/ext/rdo_mysql/tuples.c

@@ -0,0 +1,130 @@
+/*
+ * RDO MySQL Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include "tuples.h"
+#include <stdio.h>
+#include "macros.h"
+
+/* I hate magic numbers */
+#define RDO_MYSQL_BINARY_ENC 63
+
+/** RDO::MySQL::TupleList class */
+static VALUE rdo_mysql_cTupleList;
+
+/** Struct wrapped by TupleList class */
+typedef struct {
+  MYSQL_RES * res;
+  int         encoding;
+} RDOMySQLTupleList;
+
+/** Free memory allocated to list during GC */
+static void rdo_mysql_tuple_list_free(RDOMySQLTupleList * list) {
+  mysql_free_result(list->res);
+  free(list);
+}
+
+/** Constructor to create a new TupleList for the given result */
+VALUE rdo_mysql_tuple_list_new(MYSQL_RES * res, int encoding) {
+  RDOMySQLTupleList * list = malloc(sizeof(RDOMySQLTupleList));
+  list->res      = res;
+  list->encoding = encoding;
+
+  VALUE obj = Data_Wrap_Struct(rdo_mysql_cTupleList,
+      0, rdo_mysql_tuple_list_free, list);
+
+  rb_obj_call_init(obj, 0, NULL);
+
+  return obj;
+}
+
+/** Cast the given value to a Ruby type */
+static VALUE rdo_mysql_cast_value(char * v, unsigned long len, MYSQL_FIELD f, int enc) {
+  switch (f.type) {
+    case MYSQL_TYPE_NULL:
+      return Qnil;
+
+    case MYSQL_TYPE_TINY:
+    case MYSQL_TYPE_SHORT:
+    case MYSQL_TYPE_LONG:
+    case MYSQL_TYPE_INT24:
+    case MYSQL_TYPE_LONGLONG:
+      return RDO_FIXNUM(v);
+
+    case MYSQL_TYPE_STRING:
+    case MYSQL_TYPE_VAR_STRING:
+    case MYSQL_TYPE_BLOB:
+      if (f.charsetnr == RDO_MYSQL_BINARY_ENC)
+        return RDO_BINARY_STRING(v, len);
+      else
+        return RDO_STRING(v, len, enc);
+
+    case MYSQL_TYPE_DECIMAL:
+    case MYSQL_TYPE_NEWDECIMAL:
+      return RDO_DECIMAL(v);
+
+    case MYSQL_TYPE_FLOAT:
+    case MYSQL_TYPE_DOUBLE:
+      return RDO_FLOAT(v);
+
+    case MYSQL_TYPE_DATE:
+      return RDO_DATE(v);
+
+    case MYSQL_TYPE_TIMESTAMP:
+    case MYSQL_TYPE_DATETIME:
+      return RDO_DATE_TIME_WITHOUT_ZONE(v);
+
+    default:
+      return RDO_BINARY_STRING(v, len);
+  }
+}
+
+/** Iterate over all tuples in the list */
+static VALUE rdo_mysql_tuple_list_each(VALUE self) {
+  RDOMySQLTupleList * list;
+  Data_Get_Struct(self, RDOMySQLTupleList, list);
+
+  if (!rb_block_given_p() || list->res == NULL) {
+    return self;
+  }
+
+  mysql_data_seek(list->res, 0);
+
+  unsigned int    nfields = mysql_num_fields(list->res);
+  MYSQL_FIELD   * fields  = mysql_fetch_fields(list->res);
+  MYSQL_ROW       row;
+
+  while ((row = mysql_fetch_row(list->res))) {
+    unsigned long * lengths = mysql_fetch_lengths(list->res);
+    VALUE           hash    = rb_hash_new();
+    unsigned int    i       = 0;
+
+    for (; i < nfields; ++i) {
+      rb_hash_aset(hash,
+          ID2SYM(rb_intern(fields[i].name)),
+          rdo_mysql_cast_value(row[i], lengths[i], fields[i], list->encoding));
+    }
+
+    rb_yield(hash);
+  }
+
+  return self;
+}
+
+/** Initializer for the TupleList class */
+void Init_rdo_mysql_tuples(void) {
+  rb_require("rdo/mysql");
+
+  VALUE mMySQL = rb_path2class("RDO::MySQL");
+
+  rdo_mysql_cTupleList = rb_define_class_under(mMySQL,
+      "TupleList", rb_cObject);
+
+  rb_define_method(rdo_mysql_cTupleList,
+      "each", rdo_mysql_tuple_list_each, 0);
+
+  rb_include_module(rdo_mysql_cTupleList, rb_mEnumerable);
+}

data/ext/rdo_mysql/tuples.h

@@ -0,0 +1,15 @@
+/*
+ * RDO MySQL Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <ruby.h>
+#include <mysql.h>
+
+/** Constructor to return a new TupleList wrapping res */
+VALUE rdo_mysql_tuple_list_new(MYSQL_RES * res, int encoding);
+
+/** Called during extension initialization to create the TupleList class */
+void Init_rdo_mysql_tuples(void);

data/lib/rdo-mysql.rb

@@ -0,0 +1 @@
+require "rdo/mysql"

data/lib/rdo/mysql.rb

@@ -0,0 +1,15 @@
+##
+# RDO MySQL driver.
+# Copyright © 2012 Chris Corbyn.
+#
+# See LICENSE file for details.
+##
+
+require "rdo"
+require "rdo/mysql/version"
+require "rdo/mysql/driver"
+
+# c extension
+require "rdo_mysql/rdo_mysql"
+
+RDO::Connection.register_driver(:mysql, RDO::MySQL::Driver)

data/lib/rdo/mysql/driver.rb

@@ -0,0 +1,57 @@
+##
+# RDO MySQL driver.
+# Copyright © 2012 Chris Corbyn.
+#
+# See LICENSE file for details.
+##
+
+module RDO
+  module MySQL
+    # Principal RDO driver class for MySQL.
+    class Driver < RDO::Driver
+      # implementation defined by ext/rdo_mysql/driver.c
+
+      private
+
+      %w[host user password database].each do |key|
+        define_method(key) { options[key.intern].to_s }
+      end
+
+      def port
+        options[:port].to_i
+      end
+
+      def after_open
+        set_time_zone
+        set_encoding
+      end
+
+      def set_time_zone
+        execute(
+          "SET time_zone = ?",
+          options.fetch(:time_zone, RDO::Util.system_time_zone)
+        )
+      end
+
+      def set_encoding
+        execute("SET NAMES ?", charset_name(encoding))
+      end
+
+      def encoding
+        options.fetch(:encoding, 'utf8')
+      end
+
+      # mysql uses a restrictive syntax for setting the encoding
+      def charset_name(name)
+        case name.to_s.downcase
+        when "utf-8"
+          "utf8"
+        when /^iso-8859-[0-9]+$/
+          name.to_s.gsub(/^.*?-([0-9]+)$/, "latin\\1")
+        else
+          name
+        end
+      end
+    end
+  end
+end

data/lib/rdo/mysql/version.rb

@@ -0,0 +1,12 @@
+##
+# RDO MySQL driver.
+# Copyright © 2012 Chris Corbyn.
+#
+# See LICENSE file for details.
+##
+
+module RDO
+  module MySQL
+    VERSION = "0.0.1"
+  end
+end

data/rdo-mysql.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rdo/mysql/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["d11wtq"]
+  gem.email         = ["chris@w3style.co.uk"]
+  gem.description   = "Provides access to MySQL using the RDO interface"
+  gem.summary       = "MySQL Driver for RDO"
+  gem.homepage      = "https://github.com/d11wtq/rdo-mysql"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rdo-mysql"
+  gem.require_paths = ["lib"]
+  gem.version       = RDO::MySQL::VERSION
+  gem.extensions    = ["ext/rdo_mysql/extconf.rb"]
+
+  gem.add_runtime_dependency "rdo", ">= 0.0.8"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rake-compiler"
+end

data/spec/mysql/driver_spec.rb

@@ -0,0 +1,155 @@
+require "spec_helper"
+require "uri"
+
+describe RDO::MySQL::Driver do
+  let(:options)    { connection_uri }
+  let(:connection) { RDO::Connection.new(options) }
+
+  after(:each) { connection.close rescue nil }
+
+  describe "#initialize" do
+    context "with valid settings" do
+      it "opens a connection to the server" do
+        connection.should be_open
+      end
+    end
+
+    context "with invalid settings" do
+      let(:options) { URI.parse(connection_uri).tap{|u| u.user = "bad_user"}.to_s }
+
+      it "raises an RDO::Exception" do
+        expect { connection }.to raise_error(RDO::Exception)
+      end
+
+      it "provides a meaningful error" do
+        begin
+          connection && fail("RDO::Exception should be raised")
+        rescue RDO::Exception => e
+          e.message.should =~ /mysql.*?bad_user/i
+        end
+      end
+    end
+  end
+
+  describe "#close" do
+    it "closes the connection to the server" do
+      connection.close
+      connection.should_not be_open
+    end
+
+    it "returns true" do
+      connection.close.should == true
+    end
+
+    context "called multiple times" do
+      it "has no negative side-effects" do
+        5.times { connection.close }
+        connection.should_not be_open
+      end
+    end
+  end
+
+  describe "#open" do
+    it "opens a connection to the server" do
+      connection.close && connection.open
+      connection.should be_open
+    end
+
+    it "returns true" do
+      connection.close
+      connection.open.should == true
+    end
+
+    context "called multiple times" do
+      before(:each) { connection.close }
+
+      it "has no negative side-effects" do
+        5.times { connection.open }
+        connection.should be_open
+      end
+    end
+  end
+
+  describe "#quote" do
+    it "escapes values for safe insertion into a query" do
+      connection.quote("that's life!").should == "that\\'s life!"
+    end
+  end
+
+  describe "#execute" do
+    before(:each) do
+      connection.execute("DROP TABLE IF EXISTS test")
+      connection.execute <<-SQL
+      CREATE TABLE test (
+        id   INT PRIMARY KEY AUTO_INCREMENT,
+        name VARCHAR(255),
+        age  INT
+      ) ENGINE=InnoDB CHARSET=utf8
+      SQL
+    end
+
+    after(:each) do
+      connection.execute("DROP TABLE IF EXISTS test")
+    end
+
+    context "with an insert" do
+      let(:result) do
+        connection.execute("INSERT INTO test (name) VALUES (?)", "jimmy")
+      end
+
+      it "returns a RDO::Result" do
+        result.should be_a_kind_of(RDO::Result)
+      end
+
+      it "provides the #insert_id" do
+        result.insert_id.should == 1
+      end
+    end
+
+    context "with a select" do
+      before(:each) do
+        connection.execute("INSERT INTO test (name, age) VALUES (?, ?)", "jimmy", 22)
+        connection.execute("INSERT INTO test (name, age) VALUES (?, ?)", "harry", 28)
+        connection.execute("INSERT INTO test (name, age) VALUES (?, ?)", "kat", 31)
+      end
+
+      let(:result) do
+        connection.execute("SELECT * FROM test WHERE age > ?", 25)
+      end
+
+      it "returns a RDO::Result" do
+        result.should be_a_kind_of(RDO::Result)
+      end
+
+      it "provides the #count" do
+        result.count.should == 2
+      end
+
+      it "allows enumeration of the rows" do
+        rows = []
+        result.each {|row| rows << row}
+        rows.should == [{id: 2, name: "harry", age: 28}, {id: 3, name: "kat", age: 31}]
+      end
+    end
+
+    context "with an update" do
+      before(:each) do
+        connection.execute("INSERT INTO test (name, age) VALUES (?, ?)", "jimmy", 22)
+        connection.execute("INSERT INTO test (name, age) VALUES (?, ?)", "harry", 28)
+        connection.execute("INSERT INTO test (name, age) VALUES (?, ?)", "kat", 31)
+      end
+
+      let(:result) do
+        connection.execute("UPDATE test SET age = age + 3 WHERE age > ?", 25)
+      end
+
+      it "returns a RDO::Result" do
+        result.should be_a_kind_of(RDO::Result)
+      end
+
+      it "provides the #affected_rows" do
+        result.affected_rows.should == 2
+      end
+    end
+  end
+end

data/spec/mysql/type_cast_spec.rb

@@ -0,0 +1,212 @@
+require "spec_helper"
+require "bigdecimal"
+require "date"
+require "uri"
+
+describe RDO::MySQL::Driver, "type casting" do
+  let(:options)    { connection_uri }
+  let(:connection) { RDO.connect(options) }
+  let(:value)      { connection.execute(sql).first_value }
+
+  describe "null cast" do
+    let(:sql) { "SELECT NULL" }
+
+    it "returns nil" do
+      value.should be_nil
+    end
+  end
+
+  describe "varchar cast" do
+    before(:each) do
+      connection.execute("CREATE TEMPORARY TABLE test (v VARCHAR(16))")
+      connection.execute("INSERT INTO test (v) VALUES ('bob')")
+    end
+
+    let(:sql) { "SELECT v FROM test" }
+
+    it "returns a String" do
+      value.should == "bob"
+    end
+
+    context "with utf-8 encoding" do
+      let(:options) { URI.parse(connection_uri).tap{|u| u.query = "encoding=utf-8"}.to_s }
+
+      it "has the correct encoding" do
+        value.encoding.should == Encoding.find("utf-8")
+      end
+    end
+
+    context "with iso-8859-1 encoding" do
+      let(:options) { URI.parse(connection_uri).tap{|u| u.query = "encoding=iso-8859-1"}.to_s }
+
+      it "has the correct encoding" do
+        value.encoding.should == Encoding.find("iso-8859-1")
+      end
+    end
+  end
+
+  describe "char cast" do
+    before(:each) do
+      connection.execute("CREATE TEMPORARY TABLE test (v CHAR(4))")
+      connection.execute("INSERT INTO test (v) VALUES ('dave')")
+    end
+
+    let(:sql) { "SELECT v FROM test" }
+
+    it "returns a String" do
+      value.should == "dave"
+    end
+
+    context "with utf-8 encoding" do
+      let(:options) { URI.parse(connection_uri).tap{|u| u.query = "encoding=utf-8"}.to_s }
+
+      it "has the correct encoding" do
+        value.encoding.should == Encoding.find("utf-8")
+      end
+    end
+
+    context "with iso-8859-1 encoding" do
+      let(:options) { URI.parse(connection_uri).tap{|u| u.query = "encoding=iso-8859-1"}.to_s }
+
+      it "has the correct encoding" do
+        value.encoding.should == Encoding.find("iso-8859-1")
+      end
+    end
+  end
+
+  describe "text cast" do
+    before(:each) do
+      connection.execute("CREATE TEMPORARY TABLE test (v TEXT)")
+      connection.execute("INSERT INTO test (v) VALUES ('bobby')")
+    end
+
+    let(:sql) { "SELECT v FROM test" }
+
+    it "returns a String" do
+      value.should == "bobby"
+    end
+
+    context "with utf-8 encoding" do
+      let(:options) { URI.parse(connection_uri).tap{|u| u.query = "encoding=utf-8"}.to_s }
+
+      it "has the correct encoding" do
+        value.encoding.should == Encoding.find("utf-8")
+      end
+    end
+
+    context "with iso-8859-1 encoding" do
+      let(:options) { URI.parse(connection_uri).tap{|u| u.query = "encoding=iso-8859-1"}.to_s }
+
+      it "has the correct encoding" do
+        value.encoding.should == Encoding.find("iso-8859-1")
+      end
+    end
+  end
+
+  describe "binary cast" do
+    before(:each) do
+      connection.execute("CREATE TEMPORARY TABLE test (v BINARY(3))")
+      connection.execute("INSERT INTO test (v) VALUES (?)", "\x00\x11\x22")
+    end
+
+    let(:sql) { "SELECT v FROM test" }
+
+    it "returns a String" do
+      value.should == "\x00\x11\x22"
+    end
+
+    it "has binary encoding" do
+      value.encoding.should == Encoding.find("binary")
+    end
+  end
+
+  describe "blob cast" do
+    before(:each) do
+      connection.execute("CREATE TEMPORARY TABLE test (v BLOB)")
+      connection.execute("INSERT INTO test (v) VALUES (?)", "\x00\x11\x22\x33\x44")
+    end
+
+    let(:sql) { "SELECT v FROM test" }
+
+    it "returns a String" do
+      value.should == "\x00\x11\x22\x33\x44"
+    end
+
+    it "has binary encoding" do
+      value.encoding.should == Encoding.find("binary")
+    end
+  end
+
+  describe "integer cast" do
+    let(:sql) { "SELECT 1234" }
+
+    it "returns a Fixnum" do
+      value.should == 1234
+    end
+  end
+
+  describe "float cast" do
+    before(:each) do
+      connection.execute("CREATE TEMPORARY TABLE test (n FLOAT)")
+      connection.execute("INSERT INTO test (n) VALUES (12.34)")
+    end
+
+    let(:sql) { "SELECT n FROM test" }
+
+    it "returns a Float" do
+      value.should == 12.34
+    end
+  end
+
+  describe "decimal cast" do
+    before(:each) do
+      connection.execute("CREATE TEMPORARY TABLE test (n DECIMAL(6,2))")
+      connection.execute("INSERT INTO test (n) VALUES ('1234.56')")
+    end
+
+    let(:sql) { "SELECT n FROM test" }
+
+    it "returns a BigDecimal" do
+      value.should == BigDecimal("1234.56")
+    end
+  end
+
+  describe "date cast" do
+    before(:each) do
+      connection.execute("CREATE TEMPORARY TABLE test (d DATE)")
+      connection.execute("INSERT INTO test (d) VALUES ('2012-09-30')")
+    end
+
+    let(:sql) { "SELECT d FROM test" }
+
+    it "returns a Date" do
+      value.should == Date.new(2012, 9, 30)
+    end
+  end
+
+  describe "datetime cast" do
+    before(:each) do
+      connection.execute("CREATE TEMPORARY TABLE test (d DATETIME)")
+      connection.execute("INSERT INTO test (d) VALUES ('2012-09-30 19:04:36')")
+    end
+
+    let(:sql) { "SELECT d FROM test" }
+
+    it "returns a DateTime in the system time zone" do
+      value.should == DateTime.new(2012, 9, 30, 19, 4, 36, DateTime.now.zone)
+    end
+  end
+
+  describe "timestamp cast" do
+    before(:each) do
+      connection.execute("CREATE TEMPORARY TABLE test (d TIMESTAMP)")
+      connection.execute("INSERT INTO test (d) VALUES ('2012-09-30 19:04:36')")
+    end
+
+    let(:sql) { "SELECT d FROM test" }
+
+    it "returns a DateTime in the system time zone" do
+      value.should == DateTime.new(2012, 9, 30, 19, 4, 36, DateTime.now.zone)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require "rdo"
+require "rdo/mysql"
+
+ENV["CONNECTION"] ||= "mysql://rdo:rdo@localhost/rdo?encoding=utf-8"
+
+RSpec.configure do |config|
+  def connection_uri
+    ENV["CONNECTION"]
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: rdo-mysql
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- d11wtq
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides access to MySQL using the RDO interface
+email:
+- chris@w3style.co.uk
+executables: []
+extensions:
+- ext/rdo_mysql/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- ext/rdo_mysql/driver.c
+- ext/rdo_mysql/driver.h
+- ext/rdo_mysql/extconf.rb
+- ext/rdo_mysql/macros.h
+- ext/rdo_mysql/rdo_mysql.c
+- ext/rdo_mysql/tuples.c
+- ext/rdo_mysql/tuples.h
+- lib/rdo-mysql.rb
+- lib/rdo/mysql.rb
+- lib/rdo/mysql/driver.rb
+- lib/rdo/mysql/version.rb
+- rdo-mysql.gemspec
+- spec/mysql/driver_spec.rb
+- spec/mysql/type_cast_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/d11wtq/rdo-mysql
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: MySQL Driver for RDO
+test_files:
+- spec/mysql/driver_spec.rb
+- spec/mysql/type_cast_spec.rb
+- spec/spec_helper.rb