mysql2 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+Makefile
+*.dSYM
+*.o
+*.bundle
+*.so
+*.a

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Changelog
+
+## 0.1.0 (April 6th, 2010)
+* initial release

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Brian Lopez - http://github.com/brianmario
+
+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.rdoc

@@ -0,0 +1,93 @@
+= Mysql2 - A modern, simple and very fast Mysql library for Ruby, binding to libmysql
+
+The Mysql2 gem is meant to serve the extremely common use-case of connecting, querying and iterating on results.
+Some database libraries out there serve as direct 1:1 mappings of the already complex C API's available.
+This one is not.
+
+It also forces the use of UTF-8 [or binary] for the connection [and all strings in 1.9] and uses encoding-aware MySQL API calls where it can.
+
+The API consists of two clases:
+
+Mysql2::Client - your connection to the database
+
+Mysql2::Result - returned from issuing a #query on the connection. It includes Enumerable.
+
+== Installing
+
+I plan to release the initial gem version within the next day or so. Just wanted to tweak extconf to help find the libmysql binary easier, and add the ssl options.
+
+== Usage
+
+Connect to a database:
+
+  # this takes a hash of options, almost all of which map directly
+  # to the familiar database.yml in rails
+  # See http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/MysqlAdapter.html
+  client = Mysql2::Client.new(:host => "localhost", :username => "root")
+
+Then query it:
+
+  results = client.query("SELECT * FROM users WHERE group='githubbers'")
+
+Need to escape something first?
+
+  escaped = client.escape("gi'thu\"bbe\0r's")
+  results = client.query("SELECT * FROM users WHERE group='#{escaped}'")
+
+Finally, iterate over the results:
+
+  results.each do |row|
+    # conveniently, row is a hash
+    # the keys are the fields, as you'd expect
+    # the values are pre-built ruby primitives mapped from their corresponding field types in MySQL
+    # Here's an otter: http://farm1.static.flickr.com/130/398077070_b8795d0ef3_b.jpg
+  end
+
+Or, you might just keep it simple:
+
+  client.query("SELECT * FROM users WHERE group='githubbers'").each do |row|
+    # do something with row, it's ready to rock
+  end
+
+How about with symbolized keys?
+
+  # NOTE: the :symbolize_keys and future options will likely move to the #query method soon
+  client.query("SELECT * FROM users WHERE group='githubbers'").each(:symbolize_keys => true) do |row|
+    # do something with row, it's ready to rock
+  end
+
+== Compatibility
+
+The specs pass on my system (SL 10.6.3, x86_64) in these rubies:
+
+* 1.8.7-p249
+* ree-1.8.7-2010.01
+* 1.9.1-p378
+* ruby-trunk
+* rbx-head
+
+== Yeah... but why?
+
+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* is 2-3x slower.
+
+== Benchmarks
+
+Performing a basic "SELECT * FROM" query on a table with 30k rows and fields of nearly every Ruby-representable data type,
+then iterating over every row using an #each like method yielding a block:
+
+  # And remember, the Mysql gem only gives back nil and strings.
+   user       system     total     real
+  Mysql2
+   2.080000   0.790000   2.870000 (  3.418861)
+  Mysql
+   1.210000   0.790000   2.000000 (  4.527824)
+  do_mysql
+   5.450000   0.980000   6.430000 (  7.001563)

data/Rakefile

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "mysql2"
+    gem.summary = "A simple, fast Mysql library for Ruby, binding to libmysql"
+    gem.email = "seniorlopez@gmail.com"
+    gem.homepage = "http://github.com/brianmario/mysql2"
+    gem.authors = ["Brian Lopez"]
+    gem.require_paths = ["lib", "ext"]
+    gem.extra_rdoc_files = `git ls-files *.rdoc`.split("\n")
+    gem.files = `git ls-files`.split("\n")
+    gem.extensions = ["ext/extconf.rb"]
+    gem.files.include %w(lib/jeweler/templates/.document lib/jeweler/templates/.gitignore)
+    # gem.rubyforge_project = "mysql2"
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler -s http://gems.github.com"
+end
+
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('spec:rcov') do |t|
+  t.spec_files = FileList['spec/']
+  t.rcov = true
+  t.rcov_opts = lambda do
+    IO.readlines("spec/rcov.opts").map {|l| l.chomp.split " "}.flatten
+  end
+end
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/']
+  t.spec_opts << '--options' << 'spec/spec.opts'
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/benchmark/escape.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'benchmark'
+require 'mysql'
+require 'mysql2_ext'
+require 'do_mysql'
+
+number_of = 1000
+database = 'nbb_1_production'
+str = "abc'def\"ghi\0jkl%mno"
+
+Benchmark.bmbm do |x|
+  mysql = Mysql.new("localhost", "root")
+  mysql.query "USE #{database}"
+  x.report do
+    puts "Mysql"
+    number_of.times do
+      mysql.quote str
+    end
+  end
+
+  mysql2 = Mysql2::Client.new(:host => "localhost", :username => "root")
+  mysql2.query "USE #{database}"
+  x.report do
+    puts "Mysql2"
+    number_of.times do
+      mysql2.escape str
+    end
+  end
+
+  do_mysql = DataObjects::Connection.new("mysql://localhost/#{database}")
+  x.report do
+    puts "do_mysql"
+    number_of.times do
+      do_mysql.quote_string str
+    end
+  end
+end

data/benchmark/query.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'benchmark'
+require 'mysql'
+require 'mysql2_ext'
+require 'do_mysql'
+
+number_of = 1
+database = 'test'
+sql = "SELECT * FROM mysql2_test"
+
+Benchmark.bmbm do |x|
+  mysql2 = Mysql2::Client.new(:host => "localhost", :username => "root")
+  mysql2.query "USE #{database}"
+  x.report do
+    puts "Mysql2"
+    number_of.times do
+      mysql2_result = mysql2.query sql
+      mysql2_result.each(:symbolize_keys => true) do |res|
+        # puts res.inspect
+      end
+    end
+  end
+
+  mysql = Mysql.new("localhost", "root")
+  mysql.query "USE #{database}"
+  x.report do
+    puts "Mysql"
+    number_of.times do
+      mysql_result = mysql.query sql
+      mysql_result.each_hash do |res|
+        # puts res.inspect
+      end
+    end
+  end
+
+  do_mysql = DataObjects::Connection.new("mysql://localhost/#{database}")
+  command = DataObjects::Mysql::Command.new do_mysql, sql
+  x.report do
+    puts "do_mysql"
+    number_of.times do
+      do_result = command.execute_reader
+      do_result.each do |res|
+        # puts res.inspect
+      end
+    end
+  end
+end

data/benchmark/setup_db.rb

@@ -0,0 +1,110 @@
+# encoding: UTF-8
+
+# This script is for generating psudo-random data into a single table consisting of nearly every
+# data type MySQL 5.1 supports.
+#
+# It's meant to be used with the query.rb benchmark script (or others in the future)
+
+require 'mysql2_ext'
+require 'rubygems'
+require 'faker'
+
+num = ENV['NUM'] && ENV['NUM'].to_i || 10_000
+
+create_table_sql = %[
+  CREATE TABLE IF NOT EXISTS mysql2_test (
+    null_test VARCHAR(10),
+    bit_test BIT,
+    tiny_int_test TINYINT,
+    small_int_test SMALLINT,
+    medium_int_test MEDIUMINT,
+    int_test INT,
+    big_int_test BIGINT,
+    float_test FLOAT(10,3),
+    double_test DOUBLE(10,3),
+    decimal_test DECIMAL(10,3),
+    date_test DATE,
+    date_time_test DATETIME,
+    timestamp_test TIMESTAMP,
+    time_test TIME,
+    year_test YEAR(4),
+    char_test CHAR(10),
+    varchar_test VARCHAR(10),
+    binary_test BINARY(10),
+    varbinary_test VARBINARY(10),
+    tiny_blob_test TINYBLOB,
+    tiny_text_test TINYTEXT,
+    blob_test BLOB,
+    text_test TEXT,
+    medium_blob_test MEDIUMBLOB,
+    medium_text_test MEDIUMTEXT,
+    long_blob_test LONGBLOB,
+    long_text_test LONGTEXT,
+    enum_test ENUM('val1', 'val2'),
+    set_test SET('val1', 'val2')
+  ) DEFAULT CHARSET=utf8
+]
+
+# connect to localhost by default, pass options as needed
+@client = Mysql2::Client.new :host => "localhost", :username => "root", :database => "test"
+
+@client.query create_table_sql
+
+def insert_record(args)
+  insert_sql = "
+    INSERT INTO mysql2_test (
+      null_test, bit_test, tiny_int_test, small_int_test, medium_int_test, int_test, big_int_test,
+      float_test, double_test, decimal_test, date_test, date_time_test, timestamp_test, time_test,
+      year_test, char_test, varchar_test, binary_test, varbinary_test, tiny_blob_test,
+      tiny_text_test, blob_test, text_test, medium_blob_test, medium_text_test,
+      long_blob_test, long_text_test, enum_test, set_test
+    )
+
+    VALUES (
+      NULL, #{args[:bit_test]}, #{args[:tiny_int_test]}, #{args[:small_int_test]}, #{args[:medium_int_test]}, #{args[:int_test]}, #{args[:big_int_test]},
+      #{args[:float_test]}, #{args[:double_test]}, #{args[:decimal_test]}, '#{args[:date_test]}', '#{args[:date_time_test]}', '#{args[:timestamp_test]}', '#{args[:time_test]}',
+      #{args[:year_test]}, '#{args[:char_test]}', '#{args[:varchar_test]}', '#{args[:binary_test]}', '#{args[:varbinary_test]}', '#{args[:tiny_blob_test]}',
+      '#{args[:tiny_text_test]}', '#{args[:blob_test]}', '#{args[:text_test]}', '#{args[:medium_blob_test]}', '#{args[:medium_text_test]}',
+      '#{args[:long_blob_test]}', '#{args[:long_text_test]}', '#{args[:enum_test]}', '#{args[:set_test]}'
+    )
+  "
+  @client.query insert_sql
+end
+
+puts "Creating #{num} records"
+num.times do |n|
+  insert_record(
+    :bit_test => 1,
+    :tiny_int_test => rand(128),
+    :small_int_test => rand(32767),
+    :medium_int_test => rand(8388607),
+    :int_test => rand(2147483647),
+    :big_int_test => rand(9223372036854775807),
+    :float_test => rand(32767)/1.87,
+    :double_test => rand(8388607)/1.87,
+    :decimal_test => rand(8388607)/1.87,
+    :date_test => '2010-4-4',
+    :date_time_test => '2010-4-4 11:44:00',
+    :timestamp_test => '2010-4-4 11:44:00',
+    :time_test => '11:44:00',
+    :year_test => Time.now.year,
+    :char_test => Faker::Lorem.words(rand(5)),
+    :varchar_test => Faker::Lorem.words(rand(5)),
+    :binary_test => Faker::Lorem.words(rand(5)),
+    :varbinary_test => Faker::Lorem.words(rand(5)),
+    :tiny_blob_test => Faker::Lorem.words(rand(5)),
+    :tiny_text_test => Faker::Lorem.paragraph(rand(5)),
+    :blob_test => Faker::Lorem.paragraphs(rand(25)),
+    :text_test => Faker::Lorem.paragraphs(rand(25)),
+    :medium_blob_test => Faker::Lorem.paragraphs(rand(25)),
+    :medium_text_test => Faker::Lorem.paragraphs(rand(25)),
+    :long_blob_test => Faker::Lorem.paragraphs(rand(25)),
+    :long_text_test => Faker::Lorem.paragraphs(rand(25)),
+    :enum_test => ['val1', 'val2'].rand,
+    :set_test => ['val1', 'val2', 'val1,val2'].rand
+  )
+  $stdout.putc '.'
+  $stdout.flush
+end
+puts
+puts "Done"

data/ext/extconf.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+require 'mkmf'
+dir_config('mysql')
+
+have_header('mysql/mysql.h')
+
+$CFLAGS << ' -Wall -Wextra -funroll-loops'
+# $CFLAGS << ' -O0 -ggdb3'
+
+if have_library('mysqlclient')
+  if RUBY_VERSION =~ /1.9/
+    $CFLAGS << ' -DRUBY_19_COMPATIBILITY'
+  end
+
+  create_makefile('mysql2_ext')
+else
+  puts 'libmysql not found, maybe try manually specifying --with-mysql-lib to find it?'
+end

data/ext/mysql2_ext.c

@@ -0,0 +1,461 @@
+#include "mysql2_ext.h"
+
+/* Mysql2::Client */
+static VALUE rb_mysql_client_new(int argc, VALUE * argv, VALUE klass) {
+  MYSQL * client;
+  VALUE obj, opts;
+  VALUE rb_host, rb_socket, rb_port, rb_database,
+        rb_username, rb_password, rb_reconnect,
+        rb_connect_timeout;
+  VALUE rb_ssl_client_key, rb_ssl_client_cert, rb_ssl_ca_cert,
+        rb_ssl_ca_path, rb_ssl_cipher;
+  char *host = "localhost", *socket = NULL, *username = NULL,
+       *password = NULL, *database = NULL;
+  char *ssl_client_key = NULL, *ssl_client_cert = NULL, *ssl_ca_cert = NULL,
+       *ssl_ca_path = NULL, *ssl_cipher = NULL;
+  unsigned int port = 3306, connect_timeout = 0;
+  my_bool reconnect = 0;
+
+  obj = Data_Make_Struct(klass, MYSQL, NULL, rb_mysql_client_free, client);
+
+  if (rb_scan_args(argc, argv, "01", &opts) == 1) {
+    Check_Type(opts, T_HASH);
+
+    if ((rb_host = rb_hash_aref(opts, sym_host)) != Qnil) {
+      Check_Type(rb_host, T_STRING);
+      host = RSTRING_PTR(rb_host);
+    }
+
+    if ((rb_socket = rb_hash_aref(opts, sym_socket)) != Qnil) {
+      Check_Type(rb_socket, T_STRING);
+      socket = RSTRING_PTR(rb_socket);
+    }
+
+    if ((rb_port = rb_hash_aref(opts, sym_port)) != Qnil) {
+      Check_Type(rb_port, T_FIXNUM);
+      port = FIX2INT(rb_port);
+    }
+
+    if ((rb_username = rb_hash_aref(opts, sym_username)) != Qnil) {
+      Check_Type(rb_username, T_STRING);
+      username = RSTRING_PTR(rb_username);
+    }
+
+    if ((rb_password = rb_hash_aref(opts, sym_password)) != Qnil) {
+      Check_Type(rb_password, T_STRING);
+      password = RSTRING_PTR(rb_password);
+    }
+
+    if ((rb_database = rb_hash_aref(opts, sym_database)) != Qnil) {
+      Check_Type(rb_database, T_STRING);
+      database = RSTRING_PTR(rb_database);
+    }
+
+    if ((rb_reconnect = rb_hash_aref(opts, sym_reconnect)) != Qnil) {
+      reconnect = rb_reconnect == Qtrue ? 1 : 0;
+    }
+
+    if ((rb_connect_timeout = rb_hash_aref(opts, sym_connect_timeout)) != Qnil) {
+      Check_Type(rb_connect_timeout, T_FIXNUM);
+      connect_timeout = FIX2INT(rb_connect_timeout);
+    }
+
+    // SSL options
+    if ((rb_ssl_client_key = rb_hash_aref(opts, sym_sslkey)) != Qnil) {
+      Check_Type(rb_ssl_client_key, T_STRING);
+      ssl_client_key = RSTRING_PTR(rb_ssl_client_key);
+    }
+
+    if ((rb_ssl_client_cert = rb_hash_aref(opts, sym_sslcert)) != Qnil) {
+      Check_Type(rb_ssl_client_cert, T_STRING);
+      ssl_client_cert = RSTRING_PTR(rb_ssl_client_cert);
+    }
+
+    if ((rb_ssl_ca_cert = rb_hash_aref(opts, sym_sslca)) != Qnil) {
+      Check_Type(rb_ssl_ca_cert, T_STRING);
+      ssl_ca_cert = RSTRING_PTR(rb_ssl_ca_cert);
+    }
+
+    if ((rb_ssl_ca_path = rb_hash_aref(opts, sym_sslcapath)) != Qnil) {
+      Check_Type(rb_ssl_ca_path, T_STRING);
+      ssl_ca_path = RSTRING_PTR(rb_ssl_ca_path);
+    }
+
+    if ((rb_ssl_cipher = rb_hash_aref(opts, sym_sslcipher)) != Qnil) {
+      Check_Type(rb_ssl_cipher, T_STRING);
+      ssl_cipher = RSTRING_PTR(rb_ssl_cipher);
+    }
+  }
+
+  if (!mysql_init(client)) {
+    // TODO: warning - not enough memory?
+    rb_raise(cMysql2Error, "%s", mysql_error(client));
+    return Qnil;
+  }
+
+  // set default reconnect behavior
+  if (mysql_options(client, MYSQL_OPT_RECONNECT, &reconnect) != 0) {
+    // TODO: warning - unable to set reconnect behavior
+    rb_warn("%s\n", mysql_error(client));
+  }
+
+  // set default connection timeout behavior
+  if (connect_timeout != 0 && mysql_options(client, MYSQL_OPT_CONNECT_TIMEOUT, &connect_timeout) != 0) {
+    // TODO: warning - unable to set connection timeout
+    rb_warn("%s\n", mysql_error(client));
+  }
+
+  // force the encoding to utf8
+  if (mysql_options(client, MYSQL_SET_CHARSET_NAME, "utf8") != 0) {
+    // TODO: warning - unable to set charset
+    rb_warn("%s\n", mysql_error(client));
+  }
+
+  if (ssl_ca_cert != NULL || ssl_client_key != NULL) {
+    mysql_ssl_set(client, ssl_client_key, ssl_client_cert, ssl_ca_cert, ssl_ca_path, ssl_cipher);
+  }
+
+  if (mysql_real_connect(client, host, username, password, database, port, socket, 0) == NULL) {
+    // unable to connect
+    rb_raise(cMysql2Error, "%s", mysql_error(client));
+    return Qnil;
+  }
+
+  rb_obj_call_init(obj, argc, argv);
+  return obj;
+}
+
+static VALUE rb_mysql_client_init(VALUE self, int argc, VALUE * argv) {
+  return self;
+}
+
+void rb_mysql_client_free(void * client) {
+  MYSQL * c = client;
+  if (c) {
+    mysql_close(client);
+  }
+}
+
+static VALUE rb_mysql_client_query(VALUE self, VALUE sql) {
+  MYSQL * client;
+  MYSQL_RES * result;
+  fd_set fdset;
+  int fd, retval;
+  Check_Type(sql, T_STRING);
+
+  GetMysql2Client(self, client);
+  if (mysql_send_query(client, RSTRING_PTR(sql), RSTRING_LEN(sql)) != 0) {
+    rb_raise(cMysql2Error, "%s", mysql_error(client));
+    return Qnil;
+  }
+
+  // the below code is largely from do_mysql
+  // http://github.com/datamapper/do
+  fd = client->net.fd;
+  for(;;) {
+    FD_ZERO(&fdset);
+    FD_SET(fd, &fdset);
+
+    retval = rb_thread_select(fd + 1, &fdset, NULL, NULL, NULL);
+
+    if (retval < 0) {
+        rb_sys_fail(0);
+    }
+
+    if (retval > 0) {
+        break;
+    }
+  }
+
+  if (mysql_read_query_result(client) != 0) {
+    rb_raise(cMysql2Error, "%s", mysql_error(client));
+    return Qnil;
+  }
+
+  result = mysql_store_result(client);
+  if (result == NULL) {
+    if (mysql_field_count(client) != 0) {
+      rb_raise(cMysql2Error, "%s", mysql_error(client));
+    }
+    return Qnil;
+  }
+  return rb_mysql_result_to_obj(result);
+}
+
+static VALUE rb_mysql_client_escape(VALUE self, VALUE str) {
+  MYSQL * client;
+  VALUE newStr;
+  unsigned long newLen, oldLen;
+
+  Check_Type(str, T_STRING);
+  oldLen = RSTRING_LEN(str);
+  char escaped[(oldLen*2)+1];
+
+  GetMysql2Client(self, client);
+
+  newLen = mysql_real_escape_string(client, escaped, RSTRING_PTR(str), RSTRING_LEN(str));
+  if (newLen == oldLen) {
+    // no need to return a new ruby string if nothing changed
+    return str;
+  } else {
+    newStr = rb_str_new(escaped, newLen);
+#ifdef HAVE_RUBY_ENCODING_H
+    rb_enc_associate_index(newStr, utf8Encoding);
+#endif
+    return newStr;
+  }
+}
+
+static VALUE rb_mysql_client_info(VALUE self) {
+  VALUE version = rb_hash_new();
+  rb_hash_aset(version, sym_id, LONG2FIX(mysql_get_client_version()));
+  rb_hash_aset(version, sym_version, rb_str_new2(mysql_get_client_info()));
+  return version;
+}
+
+static VALUE rb_mysql_client_server_info(VALUE self) {
+  MYSQL * client;
+  VALUE version;
+
+  GetMysql2Client(self, client);
+  version = rb_hash_new();
+  rb_hash_aset(version, sym_id, LONG2FIX(mysql_get_server_version(client)));
+  rb_hash_aset(version, sym_version, rb_str_new2(mysql_get_server_info(client)));
+  return version;
+}
+
+static VALUE rb_mysql_client_socket(VALUE self) {
+  MYSQL * client = GetMysql2Client(self, client);;
+  return INT2NUM(client->net.fd);
+}
+
+/* Mysql2::Result */
+static VALUE rb_mysql_result_to_obj(MYSQL_RES * r) {
+  VALUE obj;
+  obj = Data_Wrap_Struct(cMysql2Result, 0, rb_mysql_result_free, r);
+  rb_obj_call_init(obj, 0, NULL);
+  return obj;
+}
+
+void rb_mysql_result_free(void * result) {
+  MYSQL_RES * r = result;
+  if (r) {
+    mysql_free_result(r);
+  }
+}
+
+static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self) {
+  VALUE rowHash, opts, block;
+  MYSQL_RES * result;
+  MYSQL_ROW row;
+  MYSQL_FIELD * fields;
+  struct tm parsedTime;
+  unsigned int i = 0, numFields = 0, symbolizeKeys = 0;
+  unsigned long * fieldLengths;
+
+  GetMysql2Result(self, result);
+
+  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;
+    }
+  }
+
+  row = mysql_fetch_row(result);
+  if (row == NULL) {
+    return Qnil;
+  }
+
+  numFields = mysql_num_fields(result);
+  fieldLengths = mysql_fetch_lengths(result);
+  fields = mysql_fetch_fields(result);
+
+  rowHash = rb_hash_new();
+  for (i = 0; i < numFields; i++) {
+    VALUE key;
+    if (symbolizeKeys) {
+      char buf[fields[i].name_length+1];
+      memcpy(buf, fields[i].name, fields[i].name_length);
+      buf[fields[i].name_length] = 0;
+      key = ID2SYM(rb_intern(buf));
+    } else {
+      key = rb_str_new(fields[i].name, fields[i].name_length);
+#ifdef HAVE_RUBY_ENCODING_H
+      rb_enc_associate_index(key, utf8Encoding);
+#endif
+    }
+    if (row[i]) {
+      VALUE val;
+      switch(fields[i].type) {
+        case MYSQL_TYPE_NULL:       // NULL-type field
+          val = Qnil;
+          break;
+        case MYSQL_TYPE_TINY:       // TINYINT field
+        case MYSQL_TYPE_BIT:        // BIT field (MySQL 5.0.3 and up)
+        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
+          if (memcmp("00:00:00", row[i], 10) == 0) {
+            val = rb_str_new(row[i], fieldLengths[i]);
+          } else {
+            strptime(row[i], "%T", &parsedTime);
+            val = rb_funcall(rb_cTime, intern_local, 6, INT2NUM(1900+parsedTime.tm_year), INT2NUM(parsedTime.tm_mon+1), INT2NUM(parsedTime.tm_mday), INT2NUM(parsedTime.tm_hour), INT2NUM(parsedTime.tm_min), INT2NUM(parsedTime.tm_sec));
+          }
+          break;
+        case MYSQL_TYPE_TIMESTAMP:  // TIMESTAMP field
+        case MYSQL_TYPE_DATETIME:   // DATETIME field
+          if (memcmp("0000-00-00 00:00:00", row[i], 19) == 0) {
+            val = Qnil;
+          } else {
+            strptime(row[i], "%F %T", &parsedTime);
+            val = rb_funcall(rb_cTime, intern_local, 6, INT2NUM(1900+parsedTime.tm_year), INT2NUM(parsedTime.tm_mon+1), INT2NUM(parsedTime.tm_mday), INT2NUM(parsedTime.tm_hour), INT2NUM(parsedTime.tm_min), INT2NUM(parsedTime.tm_sec));
+          }
+          break;
+        case MYSQL_TYPE_DATE:       // DATE field
+        case MYSQL_TYPE_NEWDATE:    // Newer const used > 5.0
+          if (memcmp("0000-00-00", row[i], 10) == 0) {
+            val = Qnil;
+          } else {
+            strptime(row[i], "%F", &parsedTime);
+            val = rb_funcall(rb_cTime, intern_local, 3, INT2NUM(1900+parsedTime.tm_year), INT2NUM(parsedTime.tm_mon+1), INT2NUM(parsedTime.tm_mday));
+          }
+          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
+          // rudimentary check for binary content
+          if ((fields[i].flags & BINARY_FLAG) || fields[i].charsetnr == 63) {
+            rb_enc_associate_index(val, binaryEncoding);
+          } else {
+            rb_enc_associate_index(val, utf8Encoding);
+          }
+#endif
+          break;
+      }
+      rb_hash_aset(rowHash, key, val);
+    } else {
+      rb_hash_aset(rowHash, key, Qnil);
+    }
+  }
+  return rowHash;
+}
+
+static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
+  VALUE dataset, opts, block;
+  MYSQL_RES * result;
+  unsigned long numRows, i;
+
+  GetMysql2Result(self, result);
+
+  rb_scan_args(argc, argv, "01&", &opts, &block);
+
+  // force-start at the beginning of the result set for proper
+  // behavior of #each
+  mysql_data_seek(result, 0);
+
+  numRows = mysql_num_rows(result);
+  if (numRows == 0) {
+    return Qnil;
+  }
+
+  // TODO: allow yielding datasets of configurable size
+  // like find_in_batches from AR...
+  if (block != Qnil) {
+    for (i = 0; i < numRows; i++) {
+      VALUE row = rb_mysql_result_fetch_row(argc, argv, self);
+      if (row == Qnil) {
+        return Qnil;
+      }
+      rb_yield(row);
+    }
+  } else {
+    dataset = rb_ary_new2(numRows);
+    for (i = 0; i < numRows; i++) {
+      VALUE row = rb_mysql_result_fetch_row(argc, argv, self);
+      if (row == Qnil) {
+        return Qnil;
+      }
+      rb_ary_store(dataset, i, row);
+    }
+    return dataset;
+  }
+  return Qnil;
+}
+
+/* Ruby Extension initializer */
+void Init_mysql2_ext() {
+  rb_require("date");
+  rb_require("bigdecimal");
+
+  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"));
+
+  VALUE mMysql2 = rb_define_module("Mysql2");
+
+  VALUE cMysql2Client = rb_define_class_under(mMysql2, "Client", rb_cObject);
+  rb_define_singleton_method(cMysql2Client, "new", rb_mysql_client_new, -1);
+  rb_define_method(cMysql2Client, "initialize", rb_mysql_client_init, -1);
+  rb_define_method(cMysql2Client, "query", rb_mysql_client_query, 1);
+  rb_define_method(cMysql2Client, "escape", rb_mysql_client_escape, 1);
+  rb_define_method(cMysql2Client, "info", rb_mysql_client_info, 0);
+  rb_define_method(cMysql2Client, "server_info", rb_mysql_client_server_info, 0);
+  rb_define_method(cMysql2Client, "socket", rb_mysql_client_socket, 0);
+
+  cMysql2Error = rb_define_class_under(mMysql2, "Error", rb_eStandardError);
+
+  cMysql2Result = rb_define_class_under(mMysql2, "Result", rb_cObject);
+  rb_define_method(cMysql2Result, "each", rb_mysql_result_each, -1);
+
+  VALUE mEnumerable = rb_const_get(rb_cObject, rb_intern("Enumerable"));
+  rb_include_module(cMysql2Result, mEnumerable);
+
+  intern_new = rb_intern("new");
+  intern_local = rb_intern("local");
+
+  sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
+  sym_reconnect = ID2SYM(rb_intern("reconnect"));
+  sym_database = ID2SYM(rb_intern("database"));
+  sym_username = ID2SYM(rb_intern("username"));
+  sym_password = ID2SYM(rb_intern("password"));
+  sym_host = ID2SYM(rb_intern("host"));
+  sym_port = ID2SYM(rb_intern("port"));
+  sym_socket = ID2SYM(rb_intern("socket"));
+  sym_connect_timeout = ID2SYM(rb_intern("connect_timeout"));
+  sym_id = ID2SYM(rb_intern("id"));
+  sym_version = ID2SYM(rb_intern("version"));
+  sym_sslkey = ID2SYM(rb_intern("sslkey"));
+  sym_sslcert = ID2SYM(rb_intern("sslcert"));
+  sym_sslca = ID2SYM(rb_intern("sslca"));
+  sym_sslcapath = ID2SYM(rb_intern("sslcapath"));
+  sym_sslcipher = ID2SYM(rb_intern("sslcipher"));
+
+#ifdef HAVE_RUBY_ENCODING_H
+  utf8Encoding = rb_enc_find_index("UTF-8");
+  binaryEncoding = rb_enc_find_index("binary");
+#endif
+}

data/ext/mysql2_ext.h

@@ -0,0 +1,41 @@
+#include <time.h>
+#include <ruby.h>
+
+#include <mysql/mysql.h>
+#include <mysql/mysql_com.h>
+#include <mysql/errmsg.h>
+#include <mysql/mysqld_error.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+int utf8Encoding, binaryEncoding;
+#endif
+
+static VALUE cBigDecimal, cDate, cDateTime;
+ID intern_new, intern_local;
+
+/* Mysql2::Error */
+VALUE cMysql2Error;
+
+/* Mysql2::Client */
+#define GetMysql2Client(obj, sval) (sval = (MYSQL*)DATA_PTR(obj));
+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;
+static VALUE rb_mysql_client_new(int argc, VALUE * argv, VALUE klass);
+static VALUE rb_mysql_client_init(VALUE self, int argc, VALUE * argv);
+static VALUE rb_mysql_client_query(VALUE self, VALUE query);
+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);
+void rb_mysql_client_free(void * client);
+
+/* Mysql2::Result */
+#define GetMysql2Result(obj, sval) (sval = (MYSQL_RES*)DATA_PTR(obj));
+VALUE cMysql2Result;
+static ID sym_symbolize_keys;
+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 * result);

data/lib/mysql2.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+require 'mysql2_ext'
+
+# = Mysql2
+#
+# A modern MySQL client library for Ruby, binding to libmysql
+module Mysql2
+  VERSION = "0.1.0"
+end

data/mysql2.gemspec

@@ -0,0 +1,60 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mysql2}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brian Lopez"]
+  s.date = %q{2010-04-06}
+  s.email = %q{seniorlopez@gmail.com}
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG.md",
+     "MIT-LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "benchmark/escape.rb",
+     "benchmark/query.rb",
+     "benchmark/setup_db.rb",
+     "ext/extconf.rb",
+     "ext/mysql2_ext.c",
+     "ext/mysql2_ext.h",
+     "lib/mysql2.rb",
+     "mysql2.gemspec",
+     "spec/mysql2/client_spec.rb",
+     "spec/mysql2/result_spec.rb",
+     "spec/rcov.opts",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/brianmario/mysql2}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib", "ext"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A simple, fast Mysql library for Ruby, binding to libmysql}
+  s.test_files = [
+    "spec/mysql2/client_spec.rb",
+     "spec/mysql2/result_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/spec/mysql2/client_spec.rb

@@ -0,0 +1,93 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+describe Mysql2::Client do
+  before(:each) do
+    @client = Mysql2::Client.new
+  end
+
+  it "should be able to connect via SSL options" do
+    pending("DON'T WORRY, THIS TEST PASSES :) - but is machine-specific. You need to have MySQL running with SSL configured and enabled. Then update the paths in this test to your needs and remove the pending state.")
+    ssl_client = nil
+    lambda {
+      ssl_client = Mysql2::Client.new(
+        :sslkey => '/path/to/client-key.pem',
+        :sslcert => '/path/to/client-cert.pem',
+        :sslca => '/path/to/ca-cert.pem',
+        :sslcapath => '/path/to/newcerts/',
+        :sslcipher => 'DHE-RSA-AES256-SHA'
+      )
+    }.should_not raise_error(Mysql2::Error)
+
+    results = ssl_client.query("SHOW STATUS WHERE Variable_name = \"Ssl_version\" OR Variable_name = \"Ssl_cipher\"").to_a
+    results[0]['Variable_name'].should eql('Ssl_cipher')
+    results[0]['Value'].should_not be_nil
+    results[0]['Value'].class.should eql(String)
+
+    results[1]['Variable_name'].should eql('Ssl_version')
+    results[1]['Value'].should_not be_nil
+    results[1]['Value'].class.should eql(String)
+  end
+
+  it "should respond to #query" do
+    @client.should respond_to :query
+  end
+
+  it "should respond to #escape" do
+    @client.should respond_to :escape
+  end
+
+  it "#escape should return a new SQL-escape version of the passed string" do
+    @client.escape("abc'def\"ghi\0jkl%mno").should eql("abc\\'def\\\"ghi\\0jkl%mno")
+  end
+
+  it "#escape should return the passed string if nothing was escaped" do
+    str = "plain"
+    @client.escape(str).object_id.should eql(str.object_id)
+  end
+
+  it "should respond to #info" do
+    @client.should respond_to :info
+  end
+
+  it "#info should return a hash containing the client version ID and String" do
+    info = @client.info
+    info.class.should eql(Hash)
+    info.should have_key(:id)
+    info[:id].class.should eql(Fixnum)
+    info.should have_key(:version)
+    info[:version].class.should eql(String)
+  end
+
+  it "should respond to #server_info" do
+    @client.should respond_to :server_info
+  end
+
+  it "#server_info should return a hash containing the client version ID and String" do
+    server_info = @client.server_info
+    server_info.class.should eql(Hash)
+    server_info.should have_key(:id)
+    server_info[:id].class.should eql(Fixnum)
+    server_info.should have_key(:version)
+    server_info[:version].class.should eql(String)
+  end
+
+  it "should respond to #socket" do
+    @client.should respond_to :socket
+  end
+
+  it "#socket should return a Fixnum (file descriptor from C)" do
+    @client.socket.class.should eql(Fixnum)
+    @client.socket.should_not eql(0)
+  end
+
+  it "should raise a Mysql2::Error exception upon connection failure" do
+    lambda {
+      bad_client = Mysql2::Client.new :host => "dfjhdi9wrhw", :username => 'asdfasdf8d2h'
+    }.should raise_error(Mysql2::Error)
+
+    lambda {
+      good_client = Mysql2::Client.new
+    }.should_not raise_error(Mysql2::Error)
+  end
+end

data/spec/mysql2/result_spec.rb

@@ -0,0 +1,170 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+describe Mysql2::Result do
+  before(:all) do
+    @client = Mysql2::Client.new :host => "localhost", :username => "root"
+  end
+
+  before(:each) do
+    @result = @client.query "SELECT 1"
+  end
+
+  it "should have included Enumerable" do
+    Mysql2::Result.ancestors.include?(Enumerable).should be_true
+  end
+
+  it "should respond to #each" do
+    @result.should respond_to :each
+  end
+
+  it "should raise a Mysql2::Error exception upon a bad query" do
+    lambda {
+      @client.query "bad sql"
+    }.should raise_error(Mysql2::Error)
+
+    lambda {
+      @client.query "SELECT 1"
+    }.should_not raise_error(Mysql2::Error)
+  end
+
+  context "#each" do
+    it "should yield rows as hash's" do
+      @result.each do |row|
+        row.class.should eql(Hash)
+      end
+    end
+
+    it "should yield rows as hash's with symbol keys if :symbolize_keys was set to true" do
+      @result.each(:symbolize_keys => true) do |row|
+        row.class.should eql(Hash)
+        row.keys.first.class.should eql(Symbol)
+      end
+    end
+  end
+
+  context "row data type mapping" do
+    before(:all) do
+      @client.query "USE test"
+      @client.query %[
+        CREATE TABLE IF NOT EXISTS mysql2_test (
+          null_test VARCHAR(10),
+          bit_test BIT,
+          tiny_int_test TINYINT,
+          small_int_test SMALLINT,
+          medium_int_test MEDIUMINT,
+          int_test INT,
+          big_int_test BIGINT,
+          float_test FLOAT(10,3),
+          double_test DOUBLE(10,3),
+          decimal_test DECIMAL(10,3),
+          date_test DATE,
+          date_time_test DATETIME,
+          timestamp_test TIMESTAMP,
+          time_test TIME,
+          year_test YEAR(4),
+          char_test CHAR(10),
+          varchar_test VARCHAR(10),
+          binary_test BINARY(10),
+          varbinary_test VARBINARY(10),
+          tiny_blob_test TINYBLOB,
+          tiny_text_test TINYTEXT,
+          blob_test BLOB,
+          text_test TEXT,
+          medium_blob_test MEDIUMBLOB,
+          medium_text_test MEDIUMTEXT,
+          long_blob_test LONGBLOB,
+          long_text_test LONGTEXT,
+          enum_test ENUM('val1', 'val2'),
+          set_test SET('val1', 'val2')
+        )
+      ]
+      @client.query %[
+        INSERT INTO mysql2_test (
+          null_test, bit_test, tiny_int_test, small_int_test, medium_int_test, int_test, big_int_test,
+          float_test, double_test, decimal_test, date_test, date_time_test, timestamp_test, time_test,
+          year_test, char_test, varchar_test, binary_test, varbinary_test, tiny_blob_test,
+          tiny_text_test, blob_test, text_test, medium_blob_test, medium_text_test,
+          long_blob_test, long_text_test, enum_test, set_test
+        )
+
+        VALUES (
+          NULL, 1, 1, 10, 10, 10, 10,
+          10.3, 10.3, 10.3, '2010-4-4', '2010-4-4 11:44:00', '2010-4-4 11:44:00', '11:44:00',
+          2009, "test", "test", "test", "test", "test",
+          "test", "test", "test", "test", "test",
+          "test", "test", 'val1', 'val1,val2'
+        )
+      ]
+      @test_result = @client.query("SELECT * FROM mysql2_test LIMIT 1").first
+    end
+
+    it "should return nil for a NULL value" do
+      @test_result['null_test'].class.should eql(NilClass)
+      @test_result['null_test'].should eql(nil)
+    end
+
+    {
+      'bit_test' => 'BIT',
+      'tiny_int_test' => 'TINYINT',
+      'small_int_test' => 'SMALLINT',
+      'medium_int_test' => 'MEDIUMINT',
+      'int_test' => 'INT',
+      'big_int_test' => 'BIGINT',
+      'year_test' => 'YEAR'
+    }.each do |field, type|
+      it "should return a Fixnum for #{type}" do
+        [Fixnum, Bignum].should include(@test_result[field].class)
+      end
+    end
+
+    {
+      'decimal_test' => 'DECIMAL'
+    }.each do |field, type|
+      it "should return a Fixnum for #{type}" do
+        @test_result[field].class.should eql(BigDecimal)
+      end
+    end
+
+    {
+      'float_test' => 'FLOAT',
+      'double_test' => 'DOUBLE'
+    }.each do |field, type|
+      it "should return a Float for #{type}" do
+        @test_result[field].class.should eql(Float)
+      end
+    end
+
+    {
+      'date_test' => 'DATE',
+      'date_time_test' => 'DATETIME',
+      'timestamp_test' => 'TIMESTAMP',
+      'time_test' => 'TIME'
+    }.each do |field, type|
+      it "should return a Time for #{type}" do
+        @test_result[field].class.should eql(Time)
+      end
+    end
+
+    {
+      'char_test' => 'CHAR',
+      'varchar_test' => 'VARCHAR',
+      'binary_test' => 'BINARY',
+      'varbinary_test' => 'VARBINARY',
+      'tiny_blob_test' => 'TINYBLOB',
+      'tiny_text_test' => 'TINYTEXT',
+      'blob_test' => 'BLOB',
+      'text_test' => 'TEXT',
+      'medium_blob_test' => 'MEDIUMBLOB',
+      'medium_text_test' => 'MEDIUMTEXT',
+      'long_blob_test' => 'LONGBLOB',
+      'long_text_test' => 'LONGTEXT',
+      'enum_test' => 'ENUM',
+      'set_test' => 'SET'
+    }.each do |field, type|
+      it "should return a String for #{type}" do
+        @test_result[field].class.should eql(String)
+      end
+    end
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,3 @@
+--exclude spec,gem
+--text-summary
+--sort coverage --sort-reverse

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--format specdoc
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'mysql2'

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: mysql2
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Brian Lopez
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-06 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: seniorlopez@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- CHANGELOG.md
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- benchmark/escape.rb
+- benchmark/query.rb
+- benchmark/setup_db.rb
+- ext/extconf.rb
+- ext/mysql2_ext.c
+- ext/mysql2_ext.h
+- lib/mysql2.rb
+- mysql2.gemspec
+- spec/mysql2/client_spec.rb
+- spec/mysql2/result_spec.rb
+- spec/rcov.opts
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/brianmario/mysql2
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A simple, fast Mysql library for Ruby, binding to libmysql
+test_files: 
+- spec/mysql2/client_spec.rb
+- spec/mysql2/result_spec.rb
+- spec/spec_helper.rb