mysql2 0.1.3 → 0.1.4

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.4 (April 23rd, 2010)
+* optimization: implemented a local cache for rows that are lazily created in ruby during iteration. The MySQL C result is freed as soon as all the results have been cached
+* optimization: implemented a local cache for field names so every row reuses the same objects as field names/keys
+* refactor the Mysql2 connection adapter for ActiveRecord to not extend the Mysql adapter - now being a free-standing connection adapter
+
 ## 0.1.3 (April 15th, 2010)
 * added an EventMachine Deferrable API
 * added an ActiveRecord connection adapter

data/README.rdoc

@@ -130,11 +130,11 @@ Me: Yep, but it's API is considerably more complex *and* is 2-3x slower.
 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
+  # And remember, the Mysql gem only gives back nil and strings for values.
+   user       system     total       real
   Mysql2
-   2.080000   0.790000   2.870000 (  3.418861)
+   0.610000   0.160000   0.770000 (  0.986967)
   Mysql
-   1.210000   0.790000   2.000000 (  4.527824)
+   0.350000   0.220000   0.570000 (  1.457889)
   do_mysql
-   5.450000   0.980000   6.430000 (  7.001563)
+   1.710000   0.180000   1.890000 (  2.124831)

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/benchmark/active_record.rb

@@ -4,9 +4,8 @@ $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
 require 'rubygems'
 require 'benchmark'
 require 'active_record'
-require 'ruby-debug'
 
-number_of = 1
+number_of = 10
 mysql2_opts = {
   :adapter => 'mysql2',
   :database => 'test'

data/benchmark/query.rb

@@ -6,9 +6,9 @@ require 'mysql'
 require 'mysql2_ext'
 require 'do_mysql'
 
-number_of = 1
+number_of = 100
 database = 'test'
-sql = "SELECT * FROM mysql2_test"
+sql = "SELECT * FROM mysql2_test LIMIT 100"
 
 Benchmark.bmbm do |x|
   mysql2 = Mysql2::Client.new(:host => "localhost", :username => "root")

data/ext/mysql2_ext.c

@@ -269,28 +269,43 @@ static VALUE rb_mysql_client_affected_rows(VALUE self) {
 /* 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);
+  mysql2_result_wrapper * wrapper;
+  obj = Data_Make_Struct(cMysql2Result, mysql2_result_wrapper, rb_mysql_result_mark, rb_mysql_result_free, wrapper);
+  wrapper->numberOfFields = 0;
+  wrapper->numberOfRows = 0;
+  wrapper->lastRowProcessed = 0;
+  wrapper->resultFreed = 0;
+  wrapper->result = r;
   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);
+void rb_mysql_result_free(void * wrapper) {
+  mysql2_result_wrapper * w = wrapper;
+  if (w && w->resultFreed != 1) {
+    mysql_free_result(w->result);
+    w->resultFreed = 1;
   }
 }
 
+void rb_mysql_result_mark(void * wrapper) {
+    mysql2_result_wrapper * w = wrapper;
+    if (w) {
+        rb_gc_mark(w->fields);
+        rb_gc_mark(w->rows);
+    }
+}
+
 static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self) {
   VALUE rowHash, opts, block;
-  MYSQL_RES * result;
+  mysql2_result_wrapper * wrapper;
   MYSQL_ROW row;
-  MYSQL_FIELD * fields;
+  MYSQL_FIELD * fields = NULL;
   struct tm parsedTime;
-  unsigned int i = 0, numFields = 0, symbolizeKeys = 0;
+  unsigned int i = 0, symbolizeKeys = 0;
   unsigned long * fieldLengths;
 
-  GetMysql2Result(self, result);
+  GetMysql2Result(self, wrapper);
 
   if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) {
     Check_Type(opts, T_HASH);
@@ -299,29 +314,39 @@ static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self) {
     }
   }
 
-  row = mysql_fetch_row(result);
+  row = mysql_fetch_row(wrapper->result);
   if (row == NULL) {
     return Qnil;
   }
 
-  numFields = mysql_num_fields(result);
-  fieldLengths = mysql_fetch_lengths(result);
-  fields = mysql_fetch_fields(result);
+  if (wrapper->numberOfFields == 0) {
+    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
+    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
+  }
 
   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);
+  fields = mysql_fetch_fields(wrapper->result);
+  fieldLengths = mysql_fetch_lengths(wrapper->result);
+  for (i = 0; i < wrapper->numberOfFields; i++) {
+
+    // lazily create fields, but only once
+    // we'll use cached versions from here on out
+    VALUE field = rb_ary_entry(wrapper->fields, i);
+    if (field == Qnil) {
+      if (symbolizeKeys) {
+        char buf[fields[i].name_length+1];
+        memcpy(buf, fields[i].name, fields[i].name_length);
+        buf[fields[i].name_length] = 0;
+        field = ID2SYM(rb_intern(buf));
+      } else {
+        field = rb_str_new(fields[i].name, fields[i].name_length);
 #ifdef HAVE_RUBY_ENCODING_H
-      rb_enc_associate_index(key, utf8Encoding);
+        rb_enc_associate_index(field, utf8Encoding);
 #endif
+      }
+      rb_ary_store(wrapper->fields, i, field);
     }
+
     if (row[i]) {
       VALUE val;
       switch(fields[i].type) {
@@ -393,54 +418,67 @@ static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self) {
 #endif
           break;
       }
-      rb_hash_aset(rowHash, key, val);
+      rb_hash_aset(rowHash, field, val);
     } else {
-      rb_hash_aset(rowHash, key, Qnil);
+      rb_hash_aset(rowHash, field, 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;
+  VALUE opts, block;
+  mysql2_result_wrapper * wrapper;
+  unsigned long i;
 
-  GetMysql2Result(self, result);
+  GetMysql2Result(self, wrapper);
 
   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;
+  if (wrapper->lastRowProcessed == 0) {
+    wrapper->numberOfRows = mysql_num_rows(wrapper->result);
+    if (wrapper->numberOfRows == 0) {
+      return Qnil;
+    }
+    wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
   }
 
-  // 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);
+  if (wrapper->lastRowProcessed == wrapper->numberOfRows) {
+    // we've already read the entire dataset from the C result into our
+    // internal array. Lets hand that over to the user since it's ready to go
+    for (i = 0; i < wrapper->numberOfRows; i++) {
+      rb_yield(rb_ary_entry(wrapper->rows, i));
     }
   } else {
-    dataset = rb_ary_new2(numRows);
-    for (i = 0; i < numRows; i++) {
-      VALUE row = rb_mysql_result_fetch_row(argc, argv, self);
+    unsigned long rowsProcessed = 0;
+    rowsProcessed = RARRAY_LEN(wrapper->rows);
+    for (i = 0; i < wrapper->numberOfRows; i++) {
+      VALUE row;
+      if (i < rowsProcessed) {
+        row = rb_ary_entry(wrapper->rows, i);
+      } else {
+        row = rb_mysql_result_fetch_row(argc, argv, self);
+        rb_ary_store(wrapper->rows, i, row);
+        wrapper->lastRowProcessed++;
+      }
+
       if (row == Qnil) {
+        // we don't need the mysql C dataset around anymore, peace it
+        rb_mysql_result_free(wrapper->result);
         return Qnil;
       }
-      rb_ary_store(dataset, i, row);
+
+      if (block != Qnil) {
+        rb_yield(row);
+      }
+    }
+    if (wrapper->lastRowProcessed == wrapper->numberOfRows) {
+      // we don't need the mysql C dataset around anymore, peace it
+      rb_mysql_result_free(wrapper);
     }
-    return dataset;
   }
-  return Qnil;
+
+  return wrapper->rows;
 }
 
 /* Ruby Extension initializer */

data/ext/mysql2_ext.h

@@ -43,9 +43,19 @@ static VALUE rb_mysql_client_affected_rows(VALUE self);
 void rb_mysql_client_free(void * client);
 
 /* Mysql2::Result */
-#define GetMysql2Result(obj, sval) (sval = (MYSQL_RES*)DATA_PTR(obj));
+typedef struct {
+    VALUE fields;
+    VALUE rows;
+    unsigned long numberOfFields;
+    unsigned long numberOfRows;
+    unsigned long lastRowProcessed;
+    int resultFreed;
+    MYSQL_RES *result;
+} mysql2_result_wrapper;
+#define GetMysql2Result(obj, sval) (sval = (mysql2_result_wrapper*)DATA_PTR(obj));
 VALUE cMysql2Result;
 static VALUE rb_mysql_result_to_obj(MYSQL_RES * res);
 static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self);
 static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self);
-void rb_mysql_result_free(void * result);
+void rb_mysql_result_free(void * wrapper);
+void rb_mysql_result_mark(void * wrapper);

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 require 'mysql2' unless defined? Mysql2
-require 'active_record/connection_adapters/mysql_adapter'
 
 module ActiveRecord
   class Base
@@ -13,7 +12,26 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    class Mysql2Column < MysqlColumn
+    class Mysql2Column < Column
+      def extract_default(default)
+        if sql_type =~ /blob/i || type == :text
+          if default.blank?
+            return null ? nil : ''
+          else
+            raise ArgumentError, "#{type} columns cannot have a default value: #{default.inspect}"
+          end
+        elsif missing_default_forged_as_empty_string?(default)
+          nil
+        else
+          super
+        end
+      end
+
+      def has_default?
+        return false if sql_type =~ /blob/i || type == :text #mysql forbids defaults on blob and text columns
+        super
+      end
+
       # Returns the Ruby class that corresponds to the abstract data type.
       def klass
         case type
@@ -37,25 +55,154 @@ module ActiveRecord
           value
         end
       end
-      
+
       def type_cast_code(var_name)
         nil
       end
+
+      private
+        def simplified_type(field_type)
+          return :boolean if Mysql2Adapter.emulate_booleans && field_type.downcase.index("tinyint(1)")
+          return :string  if field_type =~ /enum/i
+          super
+        end
+
+        def extract_limit(sql_type)
+          case sql_type
+          when /blob|text/i
+            case sql_type
+            when /tiny/i
+              255
+            when /medium/i
+              16777215
+            when /long/i
+              2147483647 # mysql only allows 2^31-1, not 2^32-1, somewhat inconsistently with the tiny/medium/normal cases
+            else
+              super # we could return 65535 here, but we leave it undecorated by default
+            end
+          when /^bigint/i;    8
+          when /^int/i;       4
+          when /^mediumint/i; 3
+          when /^smallint/i;  2
+          when /^tinyint/i;   1
+          else
+            super
+          end
+        end
+
+        # MySQL misreports NOT NULL column default when none is given.
+        # We can't detect this for columns which may have a legitimate ''
+        # default (string) but we can for others (integer, datetime, boolean,
+        # and the rest).
+        #
+        # Test whether the column has default '', is not null, and is not
+        # a type allowing default ''.
+        def missing_default_forged_as_empty_string?(default)
+          type != :string && !null && default == ''
+        end
     end
 
-    class Mysql2Adapter < MysqlAdapter
-      PRIMARY = "PRIMARY".freeze
-      ADAPTER_NAME = "Mysql2".freeze
+    class Mysql2Adapter < AbstractAdapter
+      cattr_accessor :emulate_booleans
+      self.emulate_booleans = true
+
+      ADAPTER_NAME = 'MySQL'.freeze
+
+      LOST_CONNECTION_ERROR_MESSAGES = [
+        "Server shutdown in progress",
+        "Broken pipe",
+        "Lost connection to MySQL server during query",
+        "MySQL server has gone away" ]
+
+      QUOTED_TRUE, QUOTED_FALSE = '1'.freeze, '0'.freeze
+
+      NATIVE_DATABASE_TYPES = {
+        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY".freeze,
+        :string      => { :name => "varchar", :limit => 255 },
+        :text        => { :name => "text" },
+        :integer     => { :name => "int", :limit => 4 },
+        :float       => { :name => "float" },
+        :decimal     => { :name => "decimal" },
+        :datetime    => { :name => "datetime" },
+        :timestamp   => { :name => "datetime" },
+        :time        => { :name => "time" },
+        :date        => { :name => "date" },
+        :binary      => { :name => "blob" },
+        :boolean     => { :name => "tinyint", :limit => 1 }
+      }
+
+      def initialize(connection, logger, connection_options, config)
+        super(connection, logger)
+        @connection_options, @config = connection_options, config
+        @quoted_column_names, @quoted_table_names = {}, {}
+      end
 
       def adapter_name
         ADAPTER_NAME
       end
 
+      def supports_migrations?
+        true
+      end
+
+      def supports_primary_key?
+        true
+      end
+
+      def supports_savepoints?
+        true
+      end
+
+      def native_database_types
+        NATIVE_DATABASE_TYPES
+      end
+
       # QUOTING ==================================================
+
+      def quote(value, column = nil)
+        if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+          s = column.class.string_to_binary(value).unpack("H*")[0]
+          "x'#{s}'"
+        elsif value.kind_of?(BigDecimal)
+          value.to_s("F")
+        else
+          super
+        end
+      end
+
+      def quote_column_name(name) #:nodoc:
+        @quoted_column_names[name] ||= "`#{name}`"
+      end
+
+      def quote_table_name(name) #:nodoc:
+        @quoted_table_names[name] ||= quote_column_name(name).gsub('.', '`.`')
+      end
+
       def quote_string(string)
         @connection.escape(string)
       end
 
+      def quoted_true
+        QUOTED_TRUE
+      end
+
+      def quoted_false
+        QUOTED_FALSE
+      end
+
+      # REFERENTIAL INTEGRITY ====================================
+
+      def disable_referential_integrity(&block) #:nodoc:
+        old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
+
+        begin
+          update("SET FOREIGN_KEY_CHECKS = 0")
+          yield
+        ensure
+          update("SET FOREIGN_KEY_CHECKS = #{old}")
+        end
+      end
+
       # CONNECTION MANAGEMENT ====================================
 
       def active?
@@ -88,14 +235,127 @@ module ActiveRecord
         select(sql, name)
       end
 
+      # Executes a SQL query and returns a MySQL::Result object. Note that you have to free the Result object after you're done using it.
+      def execute(sql, name = nil)
+        if name == :skip_logging
+          @connection.query(sql)
+        else
+          log(sql, name) { @connection.query(sql) }
+        end
+      rescue ActiveRecord::StatementInvalid => exception
+        if exception.message.split(":").first =~ /Packets out of order/
+          raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information.  If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
+        else
+          raise
+        end
+      end
+
       def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
         super sql, name
         id_value || @connection.last_id
       end
       alias :create :insert_sql
 
+      def update_sql(sql, name = nil)
+        super
+        @connection.affected_rows
+      end
+
+      def begin_db_transaction
+        execute "BEGIN"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def commit_db_transaction
+        execute "COMMIT"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def rollback_db_transaction
+        execute "ROLLBACK"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def create_savepoint
+        execute("SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def rollback_to_savepoint
+        execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def release_savepoint
+        execute("RELEASE SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def add_limit_offset!(sql, options)
+        limit, offset = options[:limit], options[:offset]
+        if limit && offset
+          sql << " LIMIT #{offset.to_i}, #{sanitize_limit(limit)}"
+        elsif limit
+          sql << " LIMIT #{sanitize_limit(limit)}"
+        elsif offset
+          sql << " OFFSET #{offset.to_i}"
+        end
+        sql
+      end
+
       # SCHEMA STATEMENTS ========================================
 
+      def structure_dump
+        if supports_views?
+          sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
+        else
+          sql = "SHOW TABLES"
+        end
+
+        select_all(sql).inject("") do |structure, table|
+          table.delete('Table_type')
+          structure += select_one("SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}")["Create Table"] + ";\n\n"
+        end
+      end
+
+      def recreate_database(name, options = {})
+        drop_database(name)
+        create_database(name, options)
+      end
+
+      # Create a new MySQL database with optional <tt>:charset</tt> and <tt>:collation</tt>.
+      # Charset defaults to utf8.
+      #
+      # Example:
+      #   create_database 'charset_test', :charset => 'latin1', :collation => 'latin1_bin'
+      #   create_database 'matt_development'
+      #   create_database 'matt_development', :charset => :big5
+      def create_database(name, options = {})
+        if options[:collation]
+          execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"
+        else
+          execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}`"
+        end
+      end
+
+      def drop_database(name) #:nodoc:
+        execute "DROP DATABASE IF EXISTS `#{name}`"
+      end
+
+      def current_database
+        select_value 'SELECT DATABASE() as db'
+      end
+
+      # Returns the database character set.
+      def charset
+        show_variable 'character_set_database'
+      end
+
+      # Returns the database collation strategy.
+      def collation
+        show_variable 'collation_database'
+      end
+
       def tables(name = nil)
         tables = []
         execute("SHOW TABLES", name).each(:symbolize_keys => true) do |field|
@@ -104,6 +364,10 @@ module ActiveRecord
         tables
       end
 
+      def drop_table(table_name, options = {})
+        super(table_name, options)
+      end
+
       def indexes(table_name, name = nil)
         indexes = []
         current_index = nil
@@ -130,6 +394,89 @@ module ActiveRecord
         columns
       end
 
+      def create_table(table_name, options = {})
+        super(table_name, options.reverse_merge(:options => "ENGINE=InnoDB"))
+      end
+
+      def rename_table(table_name, new_name)
+        execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
+      end
+
+      def add_column(table_name, column_name, type, options = {})
+        add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        add_column_options!(add_column_sql, options)
+        add_column_position!(add_column_sql, options)
+        execute(add_column_sql)
+      end
+
+      def change_column_default(table_name, column_name, default)
+        column = column_for(table_name, column_name)
+        change_column table_name, column_name, column.sql_type, :default => default
+      end
+
+      def change_column_null(table_name, column_name, null, default = nil)
+        column = column_for(table_name, column_name)
+
+        unless null || default.nil?
+          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+        end
+
+        change_column table_name, column_name, column.sql_type, :null => null
+      end
+
+      def change_column(table_name, column_name, type, options = {})
+        column = column_for(table_name, column_name)
+
+        unless options_include_default?(options)
+          options[:default] = column.default
+        end
+
+        unless options.has_key?(:null)
+          options[:null] = column.null
+        end
+
+        change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        add_column_options!(change_column_sql, options)
+        add_column_position!(change_column_sql, options)
+        execute(change_column_sql)
+      end
+
+      def rename_column(table_name, column_name, new_column_name)
+        options = {}
+        if column = columns(table_name).find { |c| c.name == column_name.to_s }
+          options[:default] = column.default
+          options[:null] = column.null
+        else
+          raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
+        end
+        current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
+        rename_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
+        add_column_options!(rename_column_sql, options)
+        execute(rename_column_sql)
+      end
+
+      # Maps logical Rails types to MySQL-specific data types.
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+        return super unless type.to_s == 'integer'
+
+        case limit
+        when 1; 'tinyint'
+        when 2; 'smallint'
+        when 3; 'mediumint'
+        when nil, 4, 11; 'int(11)'  # compatibility with MySQL default
+        when 5..8; 'bigint'
+        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
+        end
+      end
+
+      def add_column_position!(sql, options)
+        if options[:first]
+          sql << " FIRST"
+        elsif options[:after]
+          sql << " AFTER #{quote_column_name(options[:after])}"
+        end
+      end
+
       def show_variable(name)
         variables = select_all("SHOW VARIABLES LIKE '#{name}'")
         variables.first[:Value] unless variables.empty?
@@ -138,17 +485,55 @@ module ActiveRecord
       def pk_and_sequence_for(table)
         keys = []
         result = execute("describe #{quote_table_name(table)}")
-        result.each(:symbolize_keys) do |row|
+        result.each(:symbolize_keys => true) do |row|
           keys << row[:Field] if row[:Key] == "PRI"
         end
         keys.length == 1 ? [keys.first, nil] : nil
       end
 
+      # Returns just a table's primary key
+      def primary_key(table)
+        pk_and_sequence = pk_and_sequence_for(table)
+        pk_and_sequence && pk_and_sequence.first
+      end
+
+      def case_sensitive_equality_operator
+        "= BINARY"
+      end
+
+      def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
+        where_sql
+      end
+
+      protected
+        # TODO: implement error_number method on Mysql2::Exception
+        def translate_exception(exception, message)
+          return super unless exception.respond_to?(:error_number)
+
+          case exception.error_number
+          when 1062
+            RecordNotUnique.new(message, exception)
+          when 1452
+            InvalidForeignKey.new(message, exception)
+          else
+            super
+          end
+        end
+
       private
         def connect
           # no-op
         end
 
+        def configure_connection
+          encoding = @config[:encoding]
+          execute("SET NAMES '#{encoding}'", :skip_logging) if encoding
+
+          # By default, MySQL 'where id is null' selects the last inserted id.
+          # Turn this off. http://dev.rubyonrails.org/ticket/6778
+          execute("SET SQL_AUTO_IS_NULL=0", :skip_logging)
+        end
+
         def select(sql, name = nil)
           execute(sql, name).to_a
         end
@@ -160,6 +545,13 @@ module ActiveRecord
         def version
           @version ||= @connection.info[:version].scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
         end
+
+        def column_for(table_name, column_name)
+          unless column = columns(table_name).find { |c| c.name == column_name.to_s }
+            raise "No such column: #{table_name}.#{column_name}"
+          end
+          column
+        end
     end
   end
 end

data/lib/mysql2.rb

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

data/mysql2.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{mysql2}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian Lopez"]
-  s.date = %q{2010-04-15}
+  s.date = %q{2010-04-23}
   s.email = %q{seniorlopez@gmail.com}
   s.extensions = ["ext/extconf.rb"]
   s.extra_rdoc_files = [

data/spec/mysql2/result_spec.rb

@@ -41,6 +41,10 @@ describe Mysql2::Result do
         row.keys.first.class.should eql(Symbol)
       end
     end
+
+    it "should cache previously yielded results" do
+      @result.first.should eql(@result.first)
+    end
   end
 
   context "row data type mapping" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Brian Lopez
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-15 00:00:00 -07:00
+date: 2010-04-23 00:00:00 -07:00
 default_executable: 
 dependencies: []