slim-attributes 0.1

data/MIT_LICENCE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Stephen Sykes
+
+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

@@ -0,0 +1,47 @@
+SlimAttributes
+==============
+
+This is a small patch to the ActiveRecord Mysql adaptor that stops rails from using the all_hashes / each_hash mechanism - which is what is called when you do a find.
+
+It is faster, and uses less memory.
+
+Measuring with just ActiveRecord code - fetching stuff from the database - we see anything up to a 50% (or more) speed increase, but I suppose it really depends on your system and environment, and what you are doing with the results from the database.  Measure your own system and send me the results!
+
+
+Installation
+============
+
+You're going to need the mysql headers for this to work.
+
+cd vendor/plugins/slim_attributes
+ruby extconf.rb --with-mysql-config
+make
+sudo make install
+
+
+Description
+===========
+
+The reason for overriding all_hashes is threefold:
+
+* making a hash of each and every row returned from the database is slow
+* ruby makes frozen copies of each column name string (for the keys) which results in a great many strings which are not really needed
+* we observe that it's not often that all the fields of rows fetched from the database are actually used
+
+So this is an alternative implementation of all_hashes that returns a 'fake hash' which contains a hash of the column names (the same hash of names is used for every row), and also contains the row data in an area memcpy'd directly from the mysql API.
+
+The field contents are then instantiated into Ruby strings on demand - ruby strings are only made if you need them.  Note that if you always look at all the columns when you fetch data from the database then this won't necessarily be faster that the unpatched mysql adapter.  But it won't be much slower either, and we do expect that most times not all the columns from a result set are accessed.
+
+Note that the 'fake hash' quacks like a hash in many ways, but not all ways.  So @attributes in an ActiveRecord object may not behave as you are expecting it to, and it particularly won't work if you try to add a key to it that is not a column name in the result set.
+
+@attributes["not a column name"] = "something"
+=> RuntimeError: Key was not a column name from the result set
+
+Hash has many methods that are not supported by the fake hash, but I found that the ones I have implemented have been sufficient for use in our Rails app.  It should be fairly easy to implement most of the missing methods if needed, but I did not wish this patch to be larger than necessary.
+
+===========
+
+No warranty - this plugin likely needs some more work if you want it to be foolproof.  However, that said, we are using it in our production environment with good results.
+
+
+Copyright (c) 2008 Stephen Sykes, released under the MIT license

data/ext/extconf.rb

@@ -0,0 +1,26 @@
+# this code is borrowed from Mysql/Ruby, credit to TOMITA Masahiro
+# it works for me under OS X and Fedora, hope it works for you also
+
+require 'mkmf'
+
+if /mswin32/ =~ RUBY_PLATFORM
+  inc, lib = dir_config('mysql')
+  exit 1 unless have_library("libmysql")
+elsif mc = with_config('mysql-config') then
+  mc = 'mysql_config' if mc == true
+  cflags = `#{mc} --cflags`.chomp
+  exit 1 if $? != 0
+  libs = `#{mc} --libs`.chomp
+  exit 1 if $? != 0
+  $CPPFLAGS += ' ' + cflags
+  $libs = libs + " " + $libs
+else
+  inc, lib = dir_config('mysql', '/usr/local')
+  libs = ['m', 'z', 'socket', 'nsl', 'mygcc']
+  while not find_library('mysqlclient', 'mysql_query', lib, "#{lib}/mysql") do
+    exit 1 if libs.empty?
+    have_library(libs.shift)
+  end
+end
+
+create_makefile("slim_attrib_ext")

data/ext/slim_attrib_ext.c

@@ -0,0 +1,141 @@
+#include "ruby.h"
+
+#include <mysql.h>
+#include <errmsg.h>
+#include <mysqld_error.h>
+
+#define GetMysqlRes(obj) (Check_Type(obj, T_DATA), ((struct mysql_res*)DATA_PTR(obj))->res)
+#define GetLongPtr(obj) (Check_Type(obj, T_DATA), (long*)DATA_PTR(obj))
+#define GetCharPtr(obj) (Check_Type(obj, T_DATA), (char*)DATA_PTR(obj))
+#define GetCharStarPtr(obj) (Check_Type(obj, T_DATA), (char**)DATA_PTR(obj))
+
+VALUE cRowHash, cClass;
+
+// from mysql/ruby
+struct mysql_res {
+  MYSQL_RES* res;
+  char freed;
+};
+
+// row info
+#define SLIM_IS_NULL (char)1
+#define SLIM_IS_SET (char)2
+
+static VALUE all_hashes(VALUE obj) {
+  MYSQL_RES *res = GetMysqlRes(obj);
+  MYSQL_FIELD *fields = mysql_fetch_fields(res);
+  MYSQL_ROW row;
+  VALUE all_hashes_ary, col_names_hsh, row_ary;
+  my_ulonglong nr = mysql_num_rows(res);
+  unsigned int nf = mysql_num_fields(res);
+  unsigned int i, j, s;
+  unsigned long *lengths;
+  char *row_space, *row_info_space, **pointers_space;
+
+  /* hash of column names */
+  col_names_hsh = rb_hash_new();
+  for (i=0; i<nf; i++) {
+    rb_hash_aset(col_names_hsh, rb_str_new2(fields[i].name), INT2FIX(i));
+  }
+
+  /* array of result rows */
+  all_hashes_ary = rb_ary_new2(nr);
+  for (i=0; i<nr; i++) {
+    VALUE frh;
+    frh = rb_class_new_instance(0, NULL, cRowHash);
+    rb_iv_set(frh, "@field_indexes", col_names_hsh);
+    row = mysql_fetch_row(res);         // get the row
+
+    row_ary = rb_ary_new();
+    rb_iv_set(frh, "@row", row_ary);    // ready to hold fetched fields
+
+    lengths = mysql_fetch_lengths(res); // get lengths
+    for (s=j=0; j < nf; j++) s += lengths[j];  // s = total of lengths
+    row_space = malloc(s);
+    pointers_space = malloc((nf + 1) * sizeof(char *));
+    row_info_space = calloc(nf, 1);
+    for (s=j=0; j < nf; j++) {
+      int len = lengths[j];
+      char *p = row_space + s;
+      s += len;
+      pointers_space[j] = p;
+      if (!row[j]) row_info_space[j] = SLIM_IS_NULL;
+      else memcpy(p, row[j], len); // copy row data in
+    }
+    pointers_space[nf] = row_space + s;
+    rb_iv_set(frh, "@pointers", Data_Wrap_Struct(cClass, 0, free, pointers_space));
+    rb_iv_set(frh, "@row_info", Data_Wrap_Struct(cClass, 0, free, row_info_space));
+    rb_iv_set(frh, "@raw_row", Data_Wrap_Struct(cClass, 0, free, row_space));  // @raw_row contains pointer to the the row data
+    rb_ary_store(all_hashes_ary, i, frh);
+  }
+  return all_hashes_ary;
+}
+
+static VALUE fetch_by_index(VALUE obj, VALUE index) {
+  VALUE row_ary, row_ary_contents, contents, row_info_obj;
+  char *raw_row, *row_info, **pointers, *start;
+  long col_number;
+  unsigned int length;
+  
+  col_number = FIX2LONG(index);
+  row_info_obj = rb_iv_get(obj, "@row_info");
+  row_ary = rb_iv_get(obj, "@row");
+  if (NIL_P(row_info_obj)) return rb_ary_entry(row_ary, col_number);  // was marshalled
+  else {
+    row_info = GetCharPtr(row_info_obj);
+    if (row_info[col_number] == SLIM_IS_SET) return rb_ary_entry(row_ary, col_number);  // was set already, return array entry
+  }
+
+  if (row_info[col_number] == SLIM_IS_NULL) {  // return nil if null from db
+    rb_ary_store(row_ary, col_number, Qnil);
+    row_info[col_number] = SLIM_IS_SET;
+    return Qnil;
+  }
+  
+  pointers = GetCharStarPtr(rb_iv_get(obj, "@pointers"));
+  start = pointers[col_number];
+  length = pointers[col_number + 1] - start;
+  contents = rb_tainted_str_new(start, length);
+  rb_ary_store(row_ary, col_number, contents);
+  row_info[col_number] = SLIM_IS_SET;
+  return contents;
+}
+
+static VALUE slim_fetch(VALUE obj, VALUE name) {
+  VALUE real_hash, hash_lookup;
+  real_hash = rb_iv_get(obj, "@real_hash");
+  if (!NIL_P(real_hash)) return rb_hash_aref(real_hash, name);
+  hash_lookup = rb_hash_aref(rb_iv_get(obj, "@field_indexes"), name);
+  if (NIL_P(hash_lookup)) return Qnil;
+  return fetch_by_index(obj, hash_lookup);
+}
+
+static VALUE set_element(VALUE obj, VALUE name, VALUE val) {
+  VALUE real_hash, hash_lookup;
+  VALUE row_ary, row_info_obj;
+  long col_number;
+
+  real_hash = rb_iv_get(obj, "@real_hash");
+  if (!NIL_P(real_hash)) return rb_hash_aset(real_hash, name, val);
+  
+  hash_lookup = rb_hash_aref(rb_iv_get(obj, "@field_indexes"), name);  
+  if (NIL_P(hash_lookup)) return rb_funcall(rb_funcall(obj, rb_intern("to_hash"), 0), rb_intern("[]="), 2, name, val);
+  row_ary = rb_iv_get(obj, "@row");
+  col_number = FIX2LONG(hash_lookup);
+  rb_ary_store(row_ary, col_number, val);
+  row_info_obj = rb_iv_get(obj, "@row_info");
+  if (!NIL_P(row_info_obj)) GetCharPtr(row_info_obj)[col_number] = SLIM_IS_SET;
+  return val;
+}
+
+void Init_slim_attrib_ext() {
+  VALUE c = rb_cObject;
+  c = rb_const_get_at(c, rb_intern("Mysql"));
+  c = rb_const_get_at(c, rb_intern("Result"));
+  rb_define_method(c, "all_hashes", (VALUE(*)(ANYARGS))all_hashes, 0);
+  cRowHash = rb_const_get_at(c, rb_intern("RowHash"));
+  cClass = rb_define_class("CObjects", cRowHash);
+  rb_define_method(cRowHash, "fetch_by_index", (VALUE(*)(ANYARGS))fetch_by_index, 1);
+  rb_define_method(cRowHash, "[]", (VALUE(*)(ANYARGS))slim_fetch, 1);
+  rb_define_method(cRowHash, "[]=", (VALUE(*)(ANYARGS))set_element, 2);
+}

data/lib/slim_attributes.rb

@@ -0,0 +1,40 @@
+require 'mysql'
+
+class Mysql::Result
+  class RowHash
+    def marshal_dump
+      to_hash
+    end
+    
+    def marshal_load(hash)
+      @real_hash = hash
+    end
+
+    def has_key?(name)
+      @real_hash ? @real_hash.has_key?(name) : @field_indexes[name]
+    end
+
+    alias_method :include?, :has_key?
+
+    def keys
+      @real_hash ? @real_hash.keys : @field_indexes.keys
+    end
+
+    def to_hash
+      @real_hash ||= begin
+        @field_indexes.each_value {|v| fetch_by_index(v)}
+        @field_indexes.inject({}) {|memo, fi| memo[fi[0]] = @row[fi[1]]; memo}
+      end
+    end
+
+    def to_a
+      to_hash.to_a
+    end
+
+    def method_missing(name, *args, &block)
+      to_hash.send(name, *args, &block)
+    end
+  end
+end
+
+require 'slim_attrib_ext'

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: slim-attributes
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2008-04-06 00:00:00 +03:00
+summary: Slim attributes boosts speed in Rails/Mysql ActiveRecord Models by avoiding instantiating Hashes for each result row, and lazily instantiating attributes as needed
+require_paths: 
+- lib
+email: sdsykes@gmail.com
+homepage: http://slim-attributes.rubyforge.org/
+rubyforge_project: slim-attributes
+description: 
+autorequire: slim
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Stephen Sykes
+files: 
+- lib/slim_attributes.rb
+- ext/extconf.rb
+- ext/slim_attrib_ext.c
+- README
+- MIT_LICENCE
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: 
+- ext/extconf.rb
+requirements: []
+
+dependencies: []
+