hyper_record 0.2.8 → 0.9.3

data/CHANGELOG

@@ -1,3 +1,11 @@
+0.9.3.0 (2010/05/30)
+- updated HyperRecord version numbers to match Hypertable release number
+- now compatible with Hypertable version 0.9.3.0
+  - no longer compatible with earlier Hypertable versions due to a Thrift
+    API change
+- added support for asynchronous writes through new put_cells ThriftBroker API
+- add documentation for running tests
+
 0.2.8 (2010/03/01)
 - support friendly migration-syntax declared using blocks
 - new assemble_row_key_from_attributes that generates row keys in the same 

data/HOW_TO_RUN_TESTS

@@ -0,0 +1,44 @@
+The HyperRecord test suite is spread out across a number of different files
+in the test/ and spec/ directories.
+
+$ ls -l test/
+total 28
+-rw-r--r-- 1 root root   188 May 20 15:36 test_helper.rb
+-rw-r--r-- 1 root root 22281 May 30 13:56 thrift_client_test.rb
+
+$ ls -l spec/
+total 12
+drwxr-xr-x 3 root root 4096 May 20 15:36 fixtures
+drwxr-xr-x 3 root root 4096 May 30 14:08 lib
+-rw-r--r-- 1 root root 4067 May 20 15:36 spec_helper.rb
+
+The test/ directory contains unit tests (using Ruby's standard Test::Unit
+library) that exercise the Thrift client libraries only.  These tests do
+not cover any functionality specific to HyperRecord.
+
+To run the Thrift client unit tests:
+$ rake
+<snip test output>
+
+Failures in the test/ suite may be caused by:
+
+1. A mismatch between the version of Thrift installed on your local machine
+   and the version of Thrift supported in this release on HyperRecord.
+2. Problems communicating with a ThriftBroker process running on the default
+   port (38080) on localhost.  Note: you must be running Hypertable for
+   these tests to pass and, specifically, a ThriftBroker process must be
+   running on localhost.
+
+The spec/ directory contains rspec tests that cover HyperRecord functionality.
+Since HyperRecord extends the base ActiveRecord implementation, these tests 
+can only be run if the HyperRecord gem directory has been unpacked into a
+local Rails tree.  This is typically done by:
+
+$ gem install hyper_record
+$ cd vendor/gems
+$ gem unpack hyper_recrd
+$ gem uninstall hyper_record
+
+To run the HyperRecord rspec tests:
+$ rake spec
+<snip test output>

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 tylerkovacs
+Copyright (c) 2010 tylerkovacs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README

@@ -19,15 +19,11 @@ See:
 INSTALLATION
 ============
 
-1. Add github as a gem source (if you haven't already)
+1. Install HyperRecord gem (http://rubygems.org/gems/hyper_record)
 
-  gem sources -a http://gems.github.com
+  gem install hyper_record
 
-2. Install HyperRecord gem
-
-  gem install tylerkovacs-hyper_record
-
-3. Configure Hypertable Adapter by adding an entry to config/database.yml
+2. Configure Hypertable Adapter by adding an entry to config/database.yml
    that points to an instance of the Hypertable Thrift Broker (uses port
    38080 by default).
 
@@ -38,7 +34,7 @@ INSTALLATION
 
    NOTE: HyperRecord requires Thrift SVN revision 765279 or later.
 
-4. Add the following to the bottom of config/environment.rb:
+3. Add the following to the bottom of config/environment.rb:
 
   require 'hyper_record'
 
@@ -46,4 +42,4 @@ INSTALLATION
 COPYRIGHT
 =========
 
-Copyright (c) 2008 tylerkovacs. See LICENSE for details.
+Copyright (c) 2010 tylerkovacs. See LICENSE for details.

data/Rakefile

@@ -14,8 +14,6 @@ begin
     s.description = "See README"
     s.authors = ["tylerkovacs"]
   end
-
-  Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
 end
@@ -40,4 +38,13 @@ Rcov::RcovTask.new do |t|
   t.verbose = true
 end
 
-task :default => :rcov
+task :noop do
+end
+
+Rake::TestTask.new(:spec => :noop) do |t|
+  t.libs << 'spec'
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
-:minor: 2
-:patch: 8
+:minor: 9
+:patch: 3

data/hyper_record.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hyper_record}
-  s.version = "0.2.8"
+  s.version = "0.9.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["tylerkovacs"]
-  s.date = %q{2010-03-01}
+  s.date = %q{2010-05-30}
   s.description = %q{See README}
   s.email = %q{tyler.kovacs@gmail.com}
   s.extra_rdoc_files = [
@@ -21,6 +21,7 @@ Gem::Specification.new do |s|
      "CHANGELOG",
      "LICENSE",
      "README",
+     "HOW_TO_RUN_TESTS",
      "Rakefile",
      "VERSION.yml",
      "benchmark/save.rb",
@@ -40,7 +41,6 @@ Gem::Specification.new do |s|
      "lib/hypertable/gen-rb/hql_types.rb",
      "lib/hypertable/thrift_client.rb",
      "lib/hypertable/thrift_transport_monkey_patch.rb",
-     "pkg/hyper_record-0.2.8.gem",
      "spec/fixtures/pages.yml",
      "spec/fixtures/qualified_pages.yml",
      "spec/lib/associations_spec.rb",

data/lib/active_record/connection_adapters/hypertable_adapter.rb

@@ -82,8 +82,11 @@ module ActiveRecord
       end
 
       def raw_thrift_client(&block)
-        Hypertable.with_thrift_client(@config[:host], @config[:port], 
+        t1 = Time.now
+        results = Hypertable.with_thrift_client(@config[:host], @config[:port], 
           @config[:timeout], &block)
+        @@read_latency += Time.now - t1
+        results 
       end
 
       # Return the current set of performance statistics.  The application
@@ -330,7 +333,8 @@ module ActiveRecord
         for cf in column_families
           # Columns are lazily-deleted in Hypertable so still may show up
           # in describe table output.  Ignore.
-          deleted = cf.elements['deleted'].text
+          del = cf.elements['deleted']
+          deleted = del ? del.text : 'false'
           next if deleted == 'true'
 
           column_name = cf.elements['Name'].text
@@ -526,16 +530,28 @@ module ActiveRecord
       # mutator as argument.  Mutators can be created with the open_mutator
       # method.  In the near future (Summer 2009), Hypertable will provide
       # a periodic mutator that automatically flushes at specific intervals.
-      def write_cells(table_name, cells, mutator=nil, flags=nil, flush_interval=nil)
+      def write_cells(table_name, cells, options={})
         return if cells.blank?
 
+        mutator = options[:mutator]
+        flags = options[:flags]
+        flush_interval = options[:flush_interval]
+
         retry_on_connection_error {
           local_mutator_created = !mutator
 
           begin
             t1 = Time.now
             mutator ||= open_mutator(table_name, flags, flush_interval)
-            @connection.set_cells_as_arrays(mutator, cells)
+            if options[:asynchronous_write]
+              mutate_spec = Hypertable::ThriftGen::MutateSpec.new
+              mutate_spec.appname = 'hyper_record'
+              mutate_spec.flush_interval = 1000
+              mutate_spec.flags = 2
+              @connection.put_cells_as_arrays(table_name, mutate_spec, cells)
+            else
+              @connection.set_cells_as_arrays(mutator, cells)
+            end
           ensure
             if local_mutator_created && mutator
               close_mutator(mutator)
@@ -552,11 +568,12 @@ module ActiveRecord
       # on write - used by special operations (e.g,. delete )
       def thrift_cell_from_native_array(array)
         cell = Hypertable::ThriftGen::Cell.new
-        cell.row_key = array[0]
-        cell.column_family = array[1]
-        cell.column_qualifier = array[2] if !array[2].blank?
+        cell.key = Hypertable::ThriftGen::Key.new
+        cell.key.row = array[0]
+        cell.key.column_family = array[1]
+        cell.key.column_qualifier = array[2] if !array[2].blank?
         cell.value = array[3] if array[3]
-        cell.timestamp = array[4] if array[4]
+        cell.key.timestamp = array[4] if array[4]
         cell
       end
 
@@ -584,7 +601,7 @@ module ActiveRecord
           @connection.with_mutator(table_name) do |mutator|
             thrift_cells = cells.map{|c|
               cell = thrift_cell_from_native_array(c)
-              cell.flag = Hypertable::ThriftGen::CellFlag::DELETE_CELL
+              cell.key.flag = Hypertable::ThriftGen::CellFlag::DELETE_CELL
               cell
             }
             @connection.set_cells(mutator, thrift_cells)
@@ -599,8 +616,9 @@ module ActiveRecord
         t1 = Time.now
         cells = row_keys.map do |row_key|
           cell = Hypertable::ThriftGen::Cell.new
-          cell.row_key = row_key
-          cell.flag = Hypertable::ThriftGen::CellFlag::DELETE_ROW
+          cell.key = Hypertable::ThriftGen::Key.new
+          cell.key.row = row_key
+          cell.key.flag = Hypertable::ThriftGen::CellFlag::DELETE_ROW
           cell
         end
 

data/lib/hyper_record.rb

@@ -157,6 +157,7 @@ module ActiveRecord
     def quoted_attributes_to_cells(quoted_attrs, table=self.class.table_name)
       cells = []
       pk = self.attributes[self.class.primary_key]
+
       quoted_attrs.keys.each{|key|
         name, qualifier = connection.hypertable_column_name(key, table).split(':', 2)
         cells << connection.cell_native_array(pk, name, qualifier, quoted_attrs[key])
@@ -179,7 +180,12 @@ module ActiveRecord
         # puts msg
       end
 
-      connection.write_cells(table, cells, mutator, self.class.mutator_flags, self.class.mutator_flush_interval)
+      connection.write_cells(table, cells, {
+        :mutator => mutator, 
+        :flags => self.class.mutator_flags, 
+        :flush_interval => self.class.mutator_flush_interval,
+        :asynchronous_write => self.class.asynchronous_write
+      })
     end
 
     # Delete an array of cells from Hypertable
@@ -421,7 +427,8 @@ module ActiveRecord
       def find_by_hql(hql)
         hql_result = connection.execute(hql)
         cells_in_native_array_format = hql_result.cells.map do |c| 
-          connection.cell_native_array(c.row_key, c.column_family, c.column_qualifier, c.value)
+          connection.cell_native_array(c.key.row, c.key.column_family, 
+            c.key.column_qualifier, c.value)
         end
         convert_cells_to_instantiated_rows(cells_in_native_array_format)
       end
@@ -571,11 +578,15 @@ module ActiveRecord
         end
       end
 
-      attr_accessor :mutator, :mutator_flags, :mutator_flush_interval
+      attr_accessor :mutator, :mutator_flags, :mutator_flush_interval,
+        :asynchronous_write
+
       def mutator_options(*attrs)
         symbolized_attrs = attrs.first.symbolize_keys
         @mutator_flags = symbolized_attrs[:flags].to_i
         @mutator_flush_interval = symbolized_attrs[:flush_interval].to_i
+        @asynchronous_write = symbolized_attrs[:asynchronous_write]
+
         if symbolized_attrs[:persistent]
           @mutator = self.open_mutator(@mutator_flags, @mutator_flush_interval)
         end

data/lib/hypertable/gen-rb/client_service.rb

@@ -203,6 +203,66 @@ require 'client_types'
                   raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_cells_as_arrays failed: unknown result')
                 end
 
+                def put_cells(tablename, mutate_spec, cells)
+                  send_put_cells(tablename, mutate_spec, cells)
+                  recv_put_cells()
+                end
+
+                def send_put_cells(tablename, mutate_spec, cells)
+                  send_message('put_cells', Put_cells_args, :tablename => tablename, :mutate_spec => mutate_spec, :cells => cells)
+                end
+
+                def recv_put_cells()
+                  result = receive_message(Put_cells_result)
+                  raise result.e unless result.e.nil?
+                  return
+                end
+
+                def put_cells_as_arrays(tablename, mutate_spec, cells)
+                  send_put_cells_as_arrays(tablename, mutate_spec, cells)
+                  recv_put_cells_as_arrays()
+                end
+
+                def send_put_cells_as_arrays(tablename, mutate_spec, cells)
+                  send_message('put_cells_as_arrays', Put_cells_as_arrays_args, :tablename => tablename, :mutate_spec => mutate_spec, :cells => cells)
+                end
+
+                def recv_put_cells_as_arrays()
+                  result = receive_message(Put_cells_as_arrays_result)
+                  raise result.e unless result.e.nil?
+                  return
+                end
+
+                def put_cell(tablename, mutate_spec, cell)
+                  send_put_cell(tablename, mutate_spec, cell)
+                  recv_put_cell()
+                end
+
+                def send_put_cell(tablename, mutate_spec, cell)
+                  send_message('put_cell', Put_cell_args, :tablename => tablename, :mutate_spec => mutate_spec, :cell => cell)
+                end
+
+                def recv_put_cell()
+                  result = receive_message(Put_cell_result)
+                  raise result.e unless result.e.nil?
+                  return
+                end
+
+                def put_cell_as_array(tablename, mutate_spec, cell)
+                  send_put_cell_as_array(tablename, mutate_spec, cell)
+                  recv_put_cell_as_array()
+                end
+
+                def send_put_cell_as_array(tablename, mutate_spec, cell)
+                  send_message('put_cell_as_array', Put_cell_as_array_args, :tablename => tablename, :mutate_spec => mutate_spec, :cell => cell)
+                end
+
+                def recv_put_cell_as_array()
+                  result = receive_message(Put_cell_as_array_result)
+                  raise result.e unless result.e.nil?
+                  return
+                end
+
                 def open_mutator(name, flags, flush_interval)
                   send_open_mutator(name, flags, flush_interval)
                   return recv_open_mutator()
@@ -309,6 +369,22 @@ require 'client_types'
                   return
                 end
 
+                def exists_table(name)
+                  send_exists_table(name)
+                  return recv_exists_table()
+                end
+
+                def send_exists_table(name)
+                  send_message('exists_table', Exists_table_args, :name => name)
+                end
+
+                def recv_exists_table()
+                  result = receive_message(Exists_table_result)
+                  return result.success unless result.success.nil?
+                  raise result.e unless result.e.nil?
+                  raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'exists_table failed: unknown result')
+                end
+
                 def get_table_id(name)
                   send_get_table_id(name)
                   return recv_get_table_id()
@@ -357,6 +433,22 @@ require 'client_types'
                   raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_tables failed: unknown result')
                 end
 
+                def get_table_splits(name)
+                  send_get_table_splits(name)
+                  return recv_get_table_splits()
+                end
+
+                def send_get_table_splits(name)
+                  send_message('get_table_splits', Get_table_splits_args, :name => name)
+                end
+
+                def recv_get_table_splits()
+                  result = receive_message(Get_table_splits_result)
+                  return result.success unless result.success.nil?
+                  raise result.e unless result.e.nil?
+                  raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_table_splits failed: unknown result')
+                end
+
                 def drop_table(name, if_exists)
                   send_drop_table(name, if_exists)
                   recv_drop_table()
@@ -509,6 +601,50 @@ require 'client_types'
                   write_result(result, oprot, 'get_cells_as_arrays', seqid)
                 end
 
+                def process_put_cells(seqid, iprot, oprot)
+                  args = read_args(iprot, Put_cells_args)
+                  result = Put_cells_result.new()
+                  begin
+                    @handler.put_cells(args.tablename, args.mutate_spec, args.cells)
+                  rescue Hypertable::ThriftGen::ClientException => e
+                    result.e = e
+                  end
+                  write_result(result, oprot, 'put_cells', seqid)
+                end
+
+                def process_put_cells_as_arrays(seqid, iprot, oprot)
+                  args = read_args(iprot, Put_cells_as_arrays_args)
+                  result = Put_cells_as_arrays_result.new()
+                  begin
+                    @handler.put_cells_as_arrays(args.tablename, args.mutate_spec, args.cells)
+                  rescue Hypertable::ThriftGen::ClientException => e
+                    result.e = e
+                  end
+                  write_result(result, oprot, 'put_cells_as_arrays', seqid)
+                end
+
+                def process_put_cell(seqid, iprot, oprot)
+                  args = read_args(iprot, Put_cell_args)
+                  result = Put_cell_result.new()
+                  begin
+                    @handler.put_cell(args.tablename, args.mutate_spec, args.cell)
+                  rescue Hypertable::ThriftGen::ClientException => e
+                    result.e = e
+                  end
+                  write_result(result, oprot, 'put_cell', seqid)
+                end
+
+                def process_put_cell_as_array(seqid, iprot, oprot)
+                  args = read_args(iprot, Put_cell_as_array_args)
+                  result = Put_cell_as_array_result.new()
+                  begin
+                    @handler.put_cell_as_array(args.tablename, args.mutate_spec, args.cell)
+                  rescue Hypertable::ThriftGen::ClientException => e
+                    result.e = e
+                  end
+                  write_result(result, oprot, 'put_cell_as_array', seqid)
+                end
+
                 def process_open_mutator(seqid, iprot, oprot)
                   args = read_args(iprot, Open_mutator_args)
                   result = Open_mutator_result.new()
@@ -586,6 +722,17 @@ require 'client_types'
                   write_result(result, oprot, 'flush_mutator', seqid)
                 end
 
+                def process_exists_table(seqid, iprot, oprot)
+                  args = read_args(iprot, Exists_table_args)
+                  result = Exists_table_result.new()
+                  begin
+                    result.success = @handler.exists_table(args.name)
+                  rescue Hypertable::ThriftGen::ClientException => e
+                    result.e = e
+                  end
+                  write_result(result, oprot, 'exists_table', seqid)
+                end
+
                 def process_get_table_id(seqid, iprot, oprot)
                   args = read_args(iprot, Get_table_id_args)
                   result = Get_table_id_result.new()
@@ -619,6 +766,17 @@ require 'client_types'
                   write_result(result, oprot, 'get_tables', seqid)
                 end
 
+                def process_get_table_splits(seqid, iprot, oprot)
+                  args = read_args(iprot, Get_table_splits_args)
+                  result = Get_table_splits_result.new()
+                  begin
+                    result.success = @handler.get_table_splits(args.name)
+                  rescue Hypertable::ThriftGen::ClientException => e
+                    result.e = e
+                  end
+                  write_result(result, oprot, 'get_table_splits', seqid)
+                end
+
                 def process_drop_table(seqid, iprot, oprot)
                   args = read_args(iprot, Drop_table_args)
                   result = Drop_table_result.new()
@@ -1056,6 +1214,150 @@ require 'client_types'
 
               end
 
+              class Put_cells_args
+                include ::Thrift::Struct
+                TABLENAME = 1
+                MUTATE_SPEC = 2
+                CELLS = 3
+
+                ::Thrift::Struct.field_accessor self, :tablename, :mutate_spec, :cells
+                FIELDS = {
+                  TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tablename'},
+                  MUTATE_SPEC => {:type => ::Thrift::Types::STRUCT, :name => 'mutate_spec', :class => Hypertable::ThriftGen::MutateSpec},
+                  CELLS => {:type => ::Thrift::Types::LIST, :name => 'cells', :element => {:type => ::Thrift::Types::STRUCT, :class => Hypertable::ThriftGen::Cell}}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
+              class Put_cells_result
+                include ::Thrift::Struct
+                E = 1
+
+                ::Thrift::Struct.field_accessor self, :e
+                FIELDS = {
+                  E => {:type => ::Thrift::Types::STRUCT, :name => 'e', :class => Hypertable::ThriftGen::ClientException}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
+              class Put_cells_as_arrays_args
+                include ::Thrift::Struct
+                TABLENAME = 1
+                MUTATE_SPEC = 2
+                CELLS = 3
+
+                ::Thrift::Struct.field_accessor self, :tablename, :mutate_spec, :cells
+                FIELDS = {
+                  TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tablename'},
+                  MUTATE_SPEC => {:type => ::Thrift::Types::STRUCT, :name => 'mutate_spec', :class => Hypertable::ThriftGen::MutateSpec},
+                  CELLS => {:type => ::Thrift::Types::LIST, :name => 'cells', :element => {:type => ::Thrift::Types::LIST, :element => {:type => ::Thrift::Types::STRING}}}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
+              class Put_cells_as_arrays_result
+                include ::Thrift::Struct
+                E = 1
+
+                ::Thrift::Struct.field_accessor self, :e
+                FIELDS = {
+                  E => {:type => ::Thrift::Types::STRUCT, :name => 'e', :class => Hypertable::ThriftGen::ClientException}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
+              class Put_cell_args
+                include ::Thrift::Struct
+                TABLENAME = 1
+                MUTATE_SPEC = 2
+                CELL = 3
+
+                ::Thrift::Struct.field_accessor self, :tablename, :mutate_spec, :cell
+                FIELDS = {
+                  TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tablename'},
+                  MUTATE_SPEC => {:type => ::Thrift::Types::STRUCT, :name => 'mutate_spec', :class => Hypertable::ThriftGen::MutateSpec},
+                  CELL => {:type => ::Thrift::Types::STRUCT, :name => 'cell', :class => Hypertable::ThriftGen::Cell}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
+              class Put_cell_result
+                include ::Thrift::Struct
+                E = 1
+
+                ::Thrift::Struct.field_accessor self, :e
+                FIELDS = {
+                  E => {:type => ::Thrift::Types::STRUCT, :name => 'e', :class => Hypertable::ThriftGen::ClientException}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
+              class Put_cell_as_array_args
+                include ::Thrift::Struct
+                TABLENAME = 1
+                MUTATE_SPEC = 2
+                CELL = 3
+
+                ::Thrift::Struct.field_accessor self, :tablename, :mutate_spec, :cell
+                FIELDS = {
+                  TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tablename'},
+                  MUTATE_SPEC => {:type => ::Thrift::Types::STRUCT, :name => 'mutate_spec', :class => Hypertable::ThriftGen::MutateSpec},
+                  CELL => {:type => ::Thrift::Types::LIST, :name => 'cell', :element => {:type => ::Thrift::Types::STRING}}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
+              class Put_cell_as_array_result
+                include ::Thrift::Struct
+                E = 1
+
+                ::Thrift::Struct.field_accessor self, :e
+                FIELDS = {
+                  E => {:type => ::Thrift::Types::STRUCT, :name => 'e', :class => Hypertable::ThriftGen::ClientException}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
               class Open_mutator_args
                 include ::Thrift::Struct
                 NAME = 1
@@ -1296,6 +1598,40 @@ require 'client_types'
 
               end
 
+              class Exists_table_args
+                include ::Thrift::Struct
+                NAME = 1
+
+                ::Thrift::Struct.field_accessor self, :name
+                FIELDS = {
+                  NAME => {:type => ::Thrift::Types::STRING, :name => 'name'}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
+              class Exists_table_result
+                include ::Thrift::Struct
+                SUCCESS = 0
+                E = 1
+
+                ::Thrift::Struct.field_accessor self, :success, :e
+                FIELDS = {
+                  SUCCESS => {:type => ::Thrift::Types::BOOL, :name => 'success'},
+                  E => {:type => ::Thrift::Types::STRUCT, :name => 'e', :class => Hypertable::ThriftGen::ClientException}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
               class Get_table_id_args
                 include ::Thrift::Struct
                 NAME = 1
@@ -1396,6 +1732,40 @@ require 'client_types'
 
               end
 
+              class Get_table_splits_args
+                include ::Thrift::Struct
+                NAME = 1
+
+                ::Thrift::Struct.field_accessor self, :name
+                FIELDS = {
+                  NAME => {:type => ::Thrift::Types::STRING, :name => 'name'}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
+              class Get_table_splits_result
+                include ::Thrift::Struct
+                SUCCESS = 0
+                E = 1
+
+                ::Thrift::Struct.field_accessor self, :success, :e
+                FIELDS = {
+                  SUCCESS => {:type => ::Thrift::Types::LIST, :name => 'success', :element => {:type => ::Thrift::Types::STRUCT, :class => Hypertable::ThriftGen::TableSplit}},
+                  E => {:type => ::Thrift::Types::STRUCT, :name => 'e', :class => Hypertable::ThriftGen::ClientException}
+                }
+
+                def struct_fields; FIELDS; end
+
+                def validate
+                end
+
+              end
+
               class Drop_table_args
                 include ::Thrift::Struct
                 NAME = 1

data/lib/hypertable/gen-rb/client_types.rb

@@ -18,8 +18,9 @@ module Hypertable
 
         module MutatorFlag
           NO_LOG_SYNC = 1
-          VALUE_MAP = {1 => "NO_LOG_SYNC"}
-          VALID_VALUES = Set.new([NO_LOG_SYNC]).freeze
+          IGNORE_UNKNOWN_CFS = 2
+          VALUE_MAP = {1 => "NO_LOG_SYNC", 2 => "IGNORE_UNKNOWN_CFS"}
+          VALID_VALUES = Set.new([NO_LOG_SYNC, IGNORE_UNKNOWN_CFS]).freeze
         end
 
         # Specifies a range of rows
@@ -148,8 +149,9 @@ module Hypertable
           START_TIME = 6
           END_TIME = 7
           COLUMNS = 8
+          KEYS_ONLY = 9
 
-          ::Thrift::Struct.field_accessor self, :row_intervals, :cell_intervals, :return_deletes, :revs, :row_limit, :start_time, :end_time, :columns
+          ::Thrift::Struct.field_accessor self, :row_intervals, :cell_intervals, :return_deletes, :revs, :row_limit, :start_time, :end_time, :columns, :keys_only
           FIELDS = {
             ROW_INTERVALS => {:type => ::Thrift::Types::LIST, :name => 'row_intervals', :element => {:type => ::Thrift::Types::STRUCT, :class => Hypertable::ThriftGen::RowInterval}, :optional => true},
             CELL_INTERVALS => {:type => ::Thrift::Types::LIST, :name => 'cell_intervals', :element => {:type => ::Thrift::Types::STRUCT, :class => Hypertable::ThriftGen::CellInterval}, :optional => true},
@@ -158,7 +160,8 @@ module Hypertable
             ROW_LIMIT => {:type => ::Thrift::Types::I32, :name => 'row_limit', :default => 0, :optional => true},
             START_TIME => {:type => ::Thrift::Types::I64, :name => 'start_time', :optional => true},
             END_TIME => {:type => ::Thrift::Types::I64, :name => 'end_time', :optional => true},
-            COLUMNS => {:type => ::Thrift::Types::LIST, :name => 'columns', :element => {:type => ::Thrift::Types::STRING}, :optional => true}
+            COLUMNS => {:type => ::Thrift::Types::LIST, :name => 'columns', :element => {:type => ::Thrift::Types::STRING}, :optional => true},
+            KEYS_ONLY => {:type => ::Thrift::Types::BOOL, :name => 'keys_only', :default => false, :optional => true}
           }
 
           def struct_fields; FIELDS; end
@@ -168,10 +171,10 @@ module Hypertable
 
         end
 
-        # Defines a table cell
+        # Defines a cell key
         # 
         # <dl>
-        #   <dt>row_key</dt>
+        #   <dt>row</dt>
         #   <dd>Specifies the row key. Note, it cannot contain null characters.
         #   If a row key is not specified in a return cell, it's assumed to
         #   be the same as the previous cell</dd>
@@ -182,9 +185,6 @@ module Hypertable
         #   <dt>column_qualifier</dt>
         #   <dd>Specifies the column qualifier. A column family must be specified.</dd>
         # 
-        #   <dt>value</dt>
-        #   <dd>Value of a cell. Currently a sequence of uninterpreted bytes.</dd>
-        # 
         #   <dt>timestamp</dt>
         #   <dd>Nanoseconds since epoch for the cell<dd>
         # 
@@ -194,25 +194,122 @@ module Hypertable
         #   <dt>flag</dt>
         #   <dd>A 16-bit integer indicating the state of the cell</dd>
         # </dl>
-        class Cell
+        class Key
           include ::Thrift::Struct
-          ROW_KEY = 1
+          ROW = 1
           COLUMN_FAMILY = 2
           COLUMN_QUALIFIER = 3
-          VALUE = 4
-          TIMESTAMP = 5
-          REVISION = 6
-          FLAG = 7
+          TIMESTAMP = 4
+          REVISION = 5
+          FLAG = 6
 
-          ::Thrift::Struct.field_accessor self, :row_key, :column_family, :column_qualifier, :value, :timestamp, :revision, :flag
+          ::Thrift::Struct.field_accessor self, :row, :column_family, :column_qualifier, :timestamp, :revision, :flag
           FIELDS = {
-            ROW_KEY => {:type => ::Thrift::Types::STRING, :name => 'row_key', :optional => true},
-            COLUMN_FAMILY => {:type => ::Thrift::Types::STRING, :name => 'column_family', :optional => true},
-            COLUMN_QUALIFIER => {:type => ::Thrift::Types::STRING, :name => 'column_qualifier', :optional => true},
-            VALUE => {:type => ::Thrift::Types::STRING, :name => 'value', :optional => true},
+            ROW => {:type => ::Thrift::Types::STRING, :name => 'row'},
+            COLUMN_FAMILY => {:type => ::Thrift::Types::STRING, :name => 'column_family'},
+            COLUMN_QUALIFIER => {:type => ::Thrift::Types::STRING, :name => 'column_qualifier'},
             TIMESTAMP => {:type => ::Thrift::Types::I64, :name => 'timestamp', :optional => true},
             REVISION => {:type => ::Thrift::Types::I64, :name => 'revision', :optional => true},
-            FLAG => {:type => ::Thrift::Types::I16, :name => 'flag', :default => 255, :optional => true}
+            FLAG => {:type => ::Thrift::Types::I16, :name => 'flag', :default => 255}
+          }
+
+          def struct_fields; FIELDS; end
+
+          def validate
+          end
+
+        end
+
+        # Specifies options for a shared periodic mutator
+        # 
+        # <dl>
+        #   <dt>appname</dt>
+        #   <dd>String key used to share/retrieve mutator, eg: "my_ht_app"</dd>
+        # 
+        #   <dt>flush_interval</dt>
+        #   <dd>Time interval between flushes</dd>
+        # 
+        #   <dt>flags</dt>
+        #   <dd>Mutator flags</dt>
+        # </dl>
+        class MutateSpec
+          include ::Thrift::Struct
+          APPNAME = 1
+          FLUSH_INTERVAL = 2
+          FLAGS = 3
+
+          ::Thrift::Struct.field_accessor self, :appname, :flush_interval, :flags
+          FIELDS = {
+            APPNAME => {:type => ::Thrift::Types::STRING, :name => 'appname', :default => %q""},
+            FLUSH_INTERVAL => {:type => ::Thrift::Types::I32, :name => 'flush_interval', :default => 1000},
+            FLAGS => {:type => ::Thrift::Types::I32, :name => 'flags', :default => 2}
+          }
+
+          def struct_fields; FIELDS; end
+
+          def validate
+            raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field appname is unset!') unless @appname
+            raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field flush_interval is unset!') unless @flush_interval
+            raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field flags is unset!') unless @flags
+          end
+
+        end
+
+        # Defines a table cell
+        # 
+        # <dl>
+        #   <dt>key</dt>
+        #   <dd>Specifies the cell key</dd>
+        # 
+        #   <dt>value</dt>
+        #   <dd>Value of a cell. Currently a sequence of uninterpreted bytes.</dd>
+        # </dl>
+        class Cell
+          include ::Thrift::Struct
+          KEY = 1
+          VALUE = 2
+
+          ::Thrift::Struct.field_accessor self, :key, :value
+          FIELDS = {
+            KEY => {:type => ::Thrift::Types::STRUCT, :name => 'key', :class => Hypertable::ThriftGen::Key},
+            VALUE => {:type => ::Thrift::Types::STRING, :name => 'value', :optional => true}
+          }
+
+          def struct_fields; FIELDS; end
+
+          def validate
+          end
+
+        end
+
+        # Defines a table split
+        # 
+        # <dl>
+        #   <dt>start_row</dt>
+        #   <dd>Starting row of the split.</dd>
+        # 
+        #   <dt>end_row</dt>
+        #   <dd>Ending row of the split.</dd>
+        # 
+        #   <dt>location</dt>
+        #   <dd>Location (proxy name) of the split.</dd>
+        # 
+        #   <dt>ip_address</dt>
+        #   <dd>The IP address of the split.</dd>
+        # </dl>
+        class TableSplit
+          include ::Thrift::Struct
+          START_ROW = 1
+          END_ROW = 2
+          LOCATION = 3
+          IP_ADDRESS = 4
+
+          ::Thrift::Struct.field_accessor self, :start_row, :end_row, :location, :ip_address
+          FIELDS = {
+            START_ROW => {:type => ::Thrift::Types::STRING, :name => 'start_row', :optional => true},
+            END_ROW => {:type => ::Thrift::Types::STRING, :name => 'end_row', :optional => true},
+            LOCATION => {:type => ::Thrift::Types::STRING, :name => 'location', :optional => true},
+            IP_ADDRESS => {:type => ::Thrift::Types::STRING, :name => 'ip_address', :optional => true}
           }
 
           def struct_fields; FIELDS; end

data/spec/lib/hyper_record_spec.rb

@@ -842,6 +842,59 @@ module ActiveRecord
       it "should support native each_row_as_arrays scanner method"
     end
 
+    describe HyperBase, '.mutator_options' do
+      it 'should default to set_cells method' do
+        class Temp < ActiveRecord::HyperBase
+          def self.create_table
+            hql = "CREATE TABLE #{table_name} (
+              'name',
+              'url'
+            )"
+            connection.execute(hql)
+          end
+        end
+
+        Temp.drop_table
+        Temp.create_table
+        Temp.connection.instance_eval("@connection").should_receive(:set_cells_as_arrays).and_return(nil)
+        t = Temp.new({:ROW => 'test', :name => 'test'})
+        t.save!
+        Temp.drop_table
+      end
+
+      describe 'asynchronous_write' do
+        before(:each) do
+          class Temp < ActiveRecord::HyperBase
+            mutator_options :asynchronous_write => true
+
+            def self.create_table
+              hql = "CREATE TABLE #{table_name} (
+                'name',
+                'url'
+              )"
+              connection.execute(hql)
+            end
+
+            Temp.drop_table
+            Temp.create_table
+          end
+        end
+
+        it 'should use put_cells method when asynchronous_write enabled' do
+          Temp.connection.instance_eval("@connection").should_receive(:put_cells_as_arrays).and_return(nil)
+          t = Temp.new({:ROW => 'test', :name => 'test'})
+          t.save!
+        end
+
+        it 'should still result in cells being written to hypertable' do
+          t = Temp.new({:ROW => 'test', :name => 'test'})
+          t.save!
+          sleep 3
+          Temp.find('test').should == t
+        end
+      end
+    end
+
     describe HyperBase, '.row_key_attributes' do
       it "should assemble a row key in the order that matches row key attributes" do
         Page.class_eval do

data/test/thrift_client_test.rb

@@ -212,8 +212,8 @@ class ThriftClientTest < Test::Unit::TestCase
 
         query = client.hql_query("SELECT * FROM thrift_test")
         assert_equal 1, query.cells.length
-        assert_equal 'k1', query.cells[0].row_key
-        assert_equal 'col', query.cells[0].column_family
+        assert_equal 'k1', query.cells[0].key.row
+        assert_equal 'col', query.cells[0].key.column_family
         assert_equal 'v1', query.cells[0].value
       end
     end
@@ -222,16 +222,17 @@ class ThriftClientTest < Test::Unit::TestCase
       Hypertable.with_thrift_client("localhost", 38080) do |client|
         mutator = client.open_mutator('thrift_test', 0, 0)
         cell1 = Hypertable::ThriftGen::Cell.new
-        cell1.row_key = 'k1'
-        cell1.column_family = 'col'
+        cell1.key = Hypertable::ThriftGen::Key.new
+        cell1.key.row = 'k1'
+        cell1.key.column_family = 'col'
         cell1.value = 'v1'
         client.set_cell(mutator, cell1)
         client.close_mutator(mutator, true)
 
         query = client.hql_query("SELECT * FROM thrift_test")
         assert_equal 1, query.cells.length
-        assert_equal 'k1', query.cells[0].row_key
-        assert_equal 'col', query.cells[0].column_family
+        assert_equal 'k1', query.cells[0].key.row
+        assert_equal 'col', query.cells[0].key.column_family
         assert_equal 'v1', query.cells[0].value
       end
     end
@@ -240,8 +241,9 @@ class ThriftClientTest < Test::Unit::TestCase
       Hypertable.with_thrift_client("localhost", 38080) do |client|
         mutator = client.open_mutator('thrift_test', 0, 500)
         cell1 = Hypertable::ThriftGen::Cell.new
-        cell1.row_key = 'k1'
-        cell1.column_family = 'col'
+        cell1.key = Hypertable::ThriftGen::Key.new
+        cell1.key.row = 'k1'
+        cell1.key.column_family = 'col'
         cell1.value = 'v1'
         client.set_cell(mutator, cell1)
 
@@ -252,8 +254,8 @@ class ThriftClientTest < Test::Unit::TestCase
 
         query = client.hql_query("SELECT * FROM thrift_test")
         assert_equal 1, query.cells.length
-        assert_equal 'k1', query.cells[0].row_key
-        assert_equal 'col', query.cells[0].column_family
+        assert_equal 'k1', query.cells[0].key.row
+        assert_equal 'col', query.cells[0].key.column_family
         assert_equal 'v1', query.cells[0].value
       end
     end
@@ -276,16 +278,16 @@ class ThriftClientTest < Test::Unit::TestCase
 
         query = client.hql_query("SELECT * FROM thrift_test")
         assert_equal 3, query.cells.length
-        assert_equal 'k1', query.cells[0].row_key
-        assert_equal 'col', query.cells[0].column_family
+        assert_equal 'k1', query.cells[0].key.row
+        assert_equal 'col', query.cells[0].key.column_family
         assert_equal 'v1', query.cells[0].value
 
-        assert_equal 'k2', query.cells[1].row_key
-        assert_equal 'col', query.cells[1].column_family
+        assert_equal 'k2', query.cells[1].key.row
+        assert_equal 'col', query.cells[1].key.column_family
         assert_equal 'v2', query.cells[1].value
 
-        assert_equal 'k3', query.cells[2].row_key
-        assert_equal 'col', query.cells[2].column_family
+        assert_equal 'k3', query.cells[2].key.row
+        assert_equal 'col', query.cells[2].key.column_family
         assert_equal 'v3', query.cells[2].value
       end
     end
@@ -294,18 +296,21 @@ class ThriftClientTest < Test::Unit::TestCase
       Hypertable.with_thrift_client("localhost", 38080) do |client|
         mutator = client.open_mutator('thrift_test', 0, 0)
         cell1 = Hypertable::ThriftGen::Cell.new
-        cell1.row_key = 'k1'
-        cell1.column_family = 'col'
+        cell1.key = Hypertable::ThriftGen::Key.new
+        cell1.key.row = 'k1'
+        cell1.key.column_family = 'col'
         cell1.value = 'v1'
 
         cell2 = Hypertable::ThriftGen::Cell.new
-        cell2.row_key = 'k2'
-        cell2.column_family = 'col'
+        cell2.key = Hypertable::ThriftGen::Key.new
+        cell2.key.row = 'k2'
+        cell2.key.column_family = 'col'
         cell2.value = 'v2'
 
         cell3 = Hypertable::ThriftGen::Cell.new
-        cell3.row_key = 'k3'
-        cell3.column_family = 'col'
+        cell3.key = Hypertable::ThriftGen::Key.new
+        cell3.key.row = 'k3'
+        cell3.key.column_family = 'col'
         cell3.value = 'v3'
 
         client.set_cells(mutator, [cell1, cell2, cell3])
@@ -313,16 +318,16 @@ class ThriftClientTest < Test::Unit::TestCase
 
         query = client.hql_query("SELECT * FROM thrift_test")
         assert_equal 3, query.cells.length
-        assert_equal 'k1', query.cells[0].row_key
-        assert_equal 'col', query.cells[0].column_family
+        assert_equal 'k1', query.cells[0].key.row
+        assert_equal 'col', query.cells[0].key.column_family
         assert_equal 'v1', query.cells[0].value
 
-        assert_equal 'k2', query.cells[1].row_key
-        assert_equal 'col', query.cells[1].column_family
+        assert_equal 'k2', query.cells[1].key.row
+        assert_equal 'col', query.cells[1].key.column_family
         assert_equal 'v2', query.cells[1].value
 
-        assert_equal 'k3', query.cells[2].row_key
-        assert_equal 'col', query.cells[2].column_family
+        assert_equal 'k3', query.cells[2].key.row
+        assert_equal 'col', query.cells[2].key.column_family
         assert_equal 'v3', query.cells[2].value
       end
     end
@@ -343,16 +348,17 @@ class ThriftClientTest < Test::Unit::TestCase
 
         client.with_mutator('thrift_test') do |mutator|
           cell1 = Hypertable::ThriftGen::Cell.new
-          cell1.row_key = 'k1'
-          cell1.column_family = 'col'
+          cell1.key = Hypertable::ThriftGen::Key.new
+          cell1.key.row = 'k1'
+          cell1.key.column_family = 'col'
           cell1.value = 'v1'
           client.set_cells(mutator, [cell1])
         end
 
         query = client.hql_query("SELECT * FROM thrift_test")
         assert_equal 1, query.cells.length
-        assert_equal 'k1', query.cells[0].row_key
-        assert_equal 'col', query.cells[0].column_family
+        assert_equal 'k1', query.cells[0].key.row
+        assert_equal 'col', query.cells[0].key.column_family
         assert_equal 'v1', query.cells[0].value
       end
     end
@@ -374,8 +380,8 @@ class ThriftClientTest < Test::Unit::TestCase
       Hypertable.with_thrift_client("localhost", 38080) do |client|
         query = client.hql_query("SELECT * FROM thrift_test WHERE CELL = 'k1','col'")
         assert_equal 1, query.cells.length
-        assert_equal 'k1', query.cells[0].row_key
-        assert_equal 'col', query.cells[0].column_family
+        assert_equal 'k1', query.cells[0].key.row
+        assert_equal 'col', query.cells[0].key.column_family
         assert_equal 'v1', query.cells[0].value
       end
     end
@@ -404,8 +410,8 @@ class ThriftClientTest < Test::Unit::TestCase
       Hypertable.with_thrift_client("localhost", 38080) do |client|
         query = client.hql_query("SELECT * FROM thrift_test WHERE ROW = 'k1'")
         assert_equal 1, query.cells.length
-        assert_equal 'k1', query.cells[0].row_key
-        assert_equal 'col', query.cells[0].column_family
+        assert_equal 'k1', query.cells[0].key.row
+        assert_equal 'col', query.cells[0].key.column_family
         assert_equal 'v1', query.cells[0].value
       end
     end
@@ -414,8 +420,8 @@ class ThriftClientTest < Test::Unit::TestCase
       Hypertable.with_thrift_client("localhost", 38080) do |client|
         cells = client.get_row("thrift_test", 'k1')
         assert_equal 1, cells.length
-        assert_equal 'k1', cells[0].row_key
-        assert_equal 'col', cells[0].column_family
+        assert_equal 'k1', cells[0].key.row
+        assert_equal 'col', cells[0].key.column_family
         assert_equal 'v1', cells[0].value
       end
     end
@@ -437,16 +443,16 @@ class ThriftClientTest < Test::Unit::TestCase
       Hypertable.with_thrift_client("localhost", 38080) do |client|
         query = client.hql_query("SELECT * FROM thrift_test")
         assert_equal 3, query.cells.length
-        assert_equal 'k1', query.cells[0].row_key
-        assert_equal 'col', query.cells[0].column_family
+        assert_equal 'k1', query.cells[0].key.row
+        assert_equal 'col', query.cells[0].key.column_family
         assert_equal 'v1', query.cells[0].value
 
-        assert_equal 'k2', query.cells[1].row_key
-        assert_equal 'col', query.cells[1].column_family
+        assert_equal 'k2', query.cells[1].key.row
+        assert_equal 'col', query.cells[1].key.column_family
         assert_equal 'v2', query.cells[1].value
 
-        assert_equal 'k3', query.cells[2].row_key
-        assert_equal 'col', query.cells[2].column_family
+        assert_equal 'k3', query.cells[2].key.row
+        assert_equal 'col', query.cells[2].key.column_family
         assert_equal 'v3', query.cells[2].value
       end
     end
@@ -457,16 +463,16 @@ class ThriftClientTest < Test::Unit::TestCase
         cells = client.get_cells("thrift_test", scan_spec)
 
         assert_equal 3, cells.length
-        assert_equal 'k1', cells[0].row_key
-        assert_equal 'col', cells[0].column_family
+        assert_equal 'k1', cells[0].key.row
+        assert_equal 'col', cells[0].key.column_family
         assert_equal 'v1', cells[0].value
 
-        assert_equal 'k2', cells[1].row_key
-        assert_equal 'col', cells[1].column_family
+        assert_equal 'k2', cells[1].key.row
+        assert_equal 'col', cells[1].key.column_family
         assert_equal 'v2', cells[1].value
 
-        assert_equal 'k3', cells[2].row_key
-        assert_equal 'col', cells[2].column_family
+        assert_equal 'k3', cells[2].key.row
+        assert_equal 'col', cells[2].key.column_family
         assert_equal 'v3', cells[2].value
       end
     end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 8
-  version: 0.2.8
+  - 9
+  - 3
+  version: 0.9.3
 platform: ruby
 authors: 
 - tylerkovacs
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-01 00:00:00 -08:00
+date: 2010-05-30 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -32,6 +32,7 @@ files:
 - CHANGELOG
 - LICENSE
 - README
+- HOW_TO_RUN_TESTS
 - Rakefile
 - VERSION.yml
 - benchmark/save.rb
@@ -51,7 +52,6 @@ files:
 - lib/hypertable/gen-rb/hql_types.rb
 - lib/hypertable/thrift_client.rb
 - lib/hypertable/thrift_transport_monkey_patch.rb
-- pkg/hyper_record-0.2.8.gem
 - spec/fixtures/pages.yml
 - spec/fixtures/qualified_pages.yml
 - spec/lib/associations_spec.rb