massive_record 0.2.0 → 0.2.1.rc1

data/lib/massive_record/orm/timestamps.rb

@@ -28,7 +28,7 @@ module MassiveRecord
 
 
       def updated_at
-        self['updated_at']
+        self.class.time_zone_aware_attributes ? self['updated_at'].try(:in_time_zone) : self['updated_at']
       end
 
       def write_attribute(attr_name, value)

data/lib/massive_record/orm/validations.rb

@@ -24,8 +24,8 @@ module MassiveRecord
 
 
       module ClassMethods
-        def create!(attributes = {})
-          record = new(attributes)
+        def create!(*args)
+          record = new(*args)
           record.save!
           record
         end

data/lib/massive_record/rails/controller_runtime.rb

@@ -0,0 +1,55 @@
+module MassiveRecord
+  module Rails
+    #
+    # Included into action controller to play nice with 
+    # actionpack/lib/action_controller/metal/instrumentation
+    #
+    # log_process_action is the real heart of this module; injecting
+    # the time it took for database queries to complete.
+    #
+    module ControllerRuntime
+      extend ActiveSupport::Concern
+
+      
+
+      protected
+
+      attr_internal :db_runtime
+
+      def process_action(action, *args)
+        # We also need to reset the runtime before each action
+        # because of queries in middleware or in cases we are streaming
+        # and it won't be cleaned up by the method below.
+        MassiveRecord::ORM::LogSubscriber.reset_runtime
+        super
+      end
+
+
+      def cleanup_view_runtime
+        db_rt_before_render = MassiveRecord::ORM::LogSubscriber.reset_runtime
+        runtime = super
+        db_rt_after_render = MassiveRecord::ORM::LogSubscriber.reset_runtime
+        self.db_runtime = db_rt_before_render + db_rt_after_render
+        runtime - db_rt_after_render
+      end
+      
+
+
+      def append_info_to_payload(payload)
+        super
+        payload[:db_runtime] = db_runtime
+      end
+
+
+
+
+      module ClassMethods
+        def log_process_action(payload)
+          messages, db_runtime = super, payload[:db_runtime]
+          messages << ("MassiveRecord: %.1fms" % db_runtime.to_f) if db_runtime
+          messages
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/rails/railtie.rb

@@ -5,11 +5,27 @@ module MassiveRecord
         MassiveRecord::ORM::Base.logger = ::Rails.logger
       end
 
+      # Make Rails handle RecordNotFound correctly in production
       initializer "massive_record.action_dispatch" do
         ActiveSupport.on_load :action_controller do
           ActionDispatch::ShowExceptions.rescue_responses.update('MassiveRecord::ORM::RecordNotFound' => :not_found)
         end
       end
+
+      # Expose database runtime to controller for logging.
+      initializer "massive_record.log_runtime" do
+        require "massive_record/rails/controller_runtime"
+        ActiveSupport.on_load(:action_controller) do |app|
+          include MassiveRecord::Rails::ControllerRuntime
+        end
+      end
+
+      initializer "massive_record.time_zone_awareness" do
+        ActiveSupport.on_load(:massive_record) do
+          self.time_zone_aware_attributes = true
+          self.default_timezone = :utc
+        end
+      end
     end
   end
 end

data/lib/massive_record/version.rb

@@ -1,3 +1,3 @@
 module MassiveRecord
-  VERSION = "0.2.0"
+  VERSION = "0.2.1.rc1"
 end

data/lib/massive_record/wrapper/cell.rb

@@ -1,21 +1,50 @@
 module MassiveRecord
   module Wrapper
     class Cell
+      SUPPORTED_TYPES = [NilClass, String, Fixnum, Bignum]
+
       attr_reader :value
       attr_accessor :created_at
 
+
+      #
+      # Packs an integer as a 64-bit signed integer, native endian (int64_t)
+      # Reverse it as the byte order in hbase are reversed
+      #
+      def self.integer_to_hex_string(int)
+        [int].pack('q').reverse
+      end
+
+      #
+      # Unpacks an string as a 64-bit signed integer, native endian (int64_t)
+      # Reverse it before unpack as the byte order in hbase are reversed
+      #
+      def self.hex_string_to_integer(string)
+        string.reverse.unpack("q*").first
+      end
+
+
+
       def initialize(opts = {})
         self.value = opts[:value]
         self.created_at = opts[:created_at]
       end
     
       def value=(v)
-        raise "#{v} was a #{v.class}, but it must be a String!" unless v.is_a? String
-        @value = v.dup.force_encoding(Encoding::UTF_8)
+        raise "#{v} was a #{v.class}, but it must be a one of: #{SUPPORTED_TYPES.join(', ')}" unless SUPPORTED_TYPES.include? v.class
+
+        @value = v.duplicable? ? v.dup : v
       end
 
       def value_to_thrift
-        value.force_encoding(Encoding::BINARY)
+        case value
+        when String
+          value.force_encoding(Encoding::BINARY)
+        when Fixnum, Bignum
+          self.class.integer_to_hex_string(value)
+        when NilClass
+          value
+        end
       end
     end
   end

data/massive_record.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
   s.add_dependency "thrift", ">= 0.5.0"
   s.add_dependency "activesupport"
   s.add_dependency "activemodel"
+  s.add_dependency "tzinfo"
 
   s.add_development_dependency "rspec", ">= 2.1.0"
 

data/spec/adapter/thrift/atomic_increment_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe MassiveRecord::Wrapper::Row do
+  before :all do
+    @connection = MassiveRecord::Wrapper::Connection.new(:host => MR_CONFIG['host'], :port => MR_CONFIG['port'])
+    @connection.open
+    @table = MassiveRecord::Wrapper::Table.new(@connection, MR_CONFIG['table']).tap do |table|
+      table.column_families.create(:misc)
+      table.save
+    end
+  end
+
+  after do
+    @table.all.each &:destroy
+  end
+  
+  after :all do
+    @table.destroy
+    @connection.close
+  end
+
+  
+  let(:atomic_inc_attr_name) { 'misc:atomic' }
+  subject do
+    MassiveRecord::Wrapper::Row.new.tap do |row|
+      row.id = "ID1"
+      row.table = @table
+      row.save
+    end
+  end
+
+
+
+
+  describe "#atomic_increment" do
+    it "increments to 1 when called on a new value" do
+      subject.atomic_increment(atomic_inc_attr_name).should eq 1
+    end
+
+    it "increments by 2 when asked to do so" do
+      subject.atomic_increment(atomic_inc_attr_name, 2).should eq 2
+    end
+  end
+
+  describe "#read_atomic_integer_value" do
+    it "returns 0 if no atomic increment operation has been performed" do
+      subject.read_atomic_integer_value(atomic_inc_attr_name).should eq 0
+    end
+
+    it "returns 1 after one incrementation of 1" do
+      subject.atomic_increment(atomic_inc_attr_name)
+      subject.read_atomic_integer_value(atomic_inc_attr_name).should eq 1
+    end
+  end
+end

data/spec/{wrapper/cases → adapter/thrift}/connection_spec.rb

@@ -43,14 +43,4 @@ describe "A connection" do
     @connection.open
     @connection.tables.should be_a_kind_of(MassiveRecord::Wrapper::TablesCollection)
   end
-  
-  it "should reconnect on IOError" do
-    @connection.open
-    @connection.transport.open?.should be_true
-    @connection.getTableNames().should be_a_kind_of(Array)
-    
-    @connection.close
-    @connection.transport.open?.should be_false
-    @connection.getTableNames().should be_a_kind_of(Array)
-  end
 end

data/spec/adapter/thrift/table_find_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe MassiveRecord::Adapters::Thrift::Table do
+  let(:connection) do
+    MassiveRecord::Wrapper::Connection.new(:host => MR_CONFIG['host'], :port => MR_CONFIG['port']).tap do |connection|
+      connection.open
+    end
+  end
+
+  subject do
+    MassiveRecord::Wrapper::Table.new(@connection, MR_CONFIG['table'])
+  end
+
+
+  before :all do
+    subject.column_families.create(:base)
+    subject.save
+  end
+  
+  after :all do
+    subject.destroy
+  end
+
+  
+
+  before do
+    2.times do |index|
+      MassiveRecord::Wrapper::Row.new.tap do |row|
+        row.id = index.to_s
+        row.values = {:base => {:first_name => "John-#{index}", :last_name => "Doe-#{index}" }}
+        row.table = subject
+        row.save
+      end
+    end
+  end
+
+  after do
+    subject.all.each &:destroy
+  end
+end

data/spec/{wrapper/cases → adapter/thrift}/table_spec.rb

@@ -18,6 +18,10 @@ describe "A table" do
       it "should not exists is the database" do
         @connection.tables.should_not include(MR_CONFIG['table'])
       end
+
+      it "should not exists in the database" do
+        @table.exists?.should be_false
+      end
     
       it "should not have any column families" do
         @table.column_families.should be_empty
@@ -54,27 +58,32 @@ describe "A table" do
         row.id = "ID1"
         row.values = { 
           :info => { :first_name => "John", :last_name => "Doe", :email => "john@base.com" },
-          :misc => { 
+          :misc => {
+            :integer => 1234567,
+            :null_test => "some-value",
             :like => ["Eating", "Sleeping", "Coding"].to_json, 
             :dislike => {
               "Washing" => "Boring 6/10",
               "Ironing" => "Boring 8/10"
             }.to_json,
-            :empty => {}.to_json,
-            :value_to_increment => "1"
+            :empty => {}.to_json
           }
         }
         row.table = @table
         row.save
       end
               
-      it "should list 5 column names" do
-        @table.column_names.size.should == 7
+      it "should list all column names" do
+        @table.column_names.size.should == 8
       end
       
       it "should only load one column" do
         @table.get("ID1", :info, :first_name).should == "John"
       end
+
+      it "should return nil if column does not exist" do
+        @table.get("ID1", :info, :unkown_column).should be_nil
+      end
       
       it "should only load one column family" do
         @table.first(:select => ["info"]).column_families.should == ["info"]
@@ -82,6 +91,10 @@ describe "A table" do
         @table.find("ID1", :select => ["info"]).column_families.should == ["info"]
       end
 
+      it "should return nil if id is not found" do
+        @table.find("not_exist_FOO").should be_nil
+      end
+
       it "should update row values" do
         row = @table.first
         row.values["info:first_name"].should eql("John")
@@ -92,6 +105,11 @@ describe "A table" do
         row.update_column(:info, :email, "bob@base.com")
         row.values["info:email"].should eql("bob@base.com")
       end
+
+      it "should persist integer values as binary" do
+        row = @table.first
+        row.values["misc:integer"].should eq [1234567].pack('q').reverse
+      end
       
       it "should save row changes" do
         row = @table.first
@@ -140,7 +158,7 @@ describe "A table" do
         row = @table.first
         row.update_columns({ :misc => { :super_power => "Eating"} })
         row.columns.collect{|k, v| k if k.include?("misc:")}.delete_if{|v| v.nil?}.sort.should(
-          eql(["misc:value_to_increment", "misc:like", "misc:empty", "misc:dislike", "misc:super_power"].sort)
+          eql(["misc:null_test", "misc:integer", "misc:like", "misc:empty", "misc:dislike", "misc:super_power"].sort)
         )
       end
       
@@ -161,21 +179,37 @@ describe "A table" do
         row.values["misc:genre"].should == "M"
       end
 
-      it "should be able to do atomic increment call on values" do
+      it "should be able to do atomic increment call on new cell" do
         row = @table.first
-        row.values["misc:value_to_increment"].should == "1"
 
         result = row.atomic_increment("misc:value_to_increment")
-        result.should == "2"
+        result.should == 1
       end
 
-      it "should be able to pass inn what to incremet by" do
+      it "should be able to pass in what to incremet the new cell by" do
         row = @table.first
-        row.values["misc:value_to_increment"].should == "2"
-        row.atomic_increment("misc:value_to_increment", 2)
+        result = row.atomic_increment("misc:value_to_increment", 2)
 
+        result.should == 3
+      end
+
+      it "should be able to do atomic increment on existing values" do
         row = @table.first
-        row.values["misc:value_to_increment"].should == "4"
+
+        result = row.atomic_increment("misc:integer")
+        result.should == 1234568
+      end
+
+      it "should be settable to nil" do
+        row = @table.first
+
+        row.values["misc:null_test"].should_not be_nil
+
+        row.update_column(:misc, :null_test, nil)
+        row.save
+
+        row = @table.first
+        row.values["misc:null_test"].should be_nil
       end
       
       it "should delete a row" do
@@ -189,6 +223,14 @@ describe "A table" do
       it "should exists in the database" do
         @table.exists?.should be_true
       end
+
+      it "should only check for existance once" do
+        connection = mock(Object)
+        connection.should_receive(:tables).and_return [MR_CONFIG['table']] 
+        @table.should_receive(:connection).and_return(connection)
+
+        2.times { @table.exists? }
+      end
   
       it "should destroy the test table" do
         @table.destroy.should be_true

data/spec/orm/cases/attribute_methods_spec.rb

@@ -3,7 +3,7 @@ require 'orm/models/person'
 
 describe "attribute methods" do
   before do
-    @model = Person.new :id => 5, :name => "John", :age => "15"
+    @model = Person.new "5", :name => "John", :age => "15"
   end
 
   it "should define reader method" do
@@ -27,6 +27,11 @@ describe "attribute methods" do
   it "should return casted value when read" do
     @model.read_attribute(:age).should == 15
   end
+
+  it "should read from a method if it has been defined" do
+    @model.should_receive(:_name).and_return("my name is")
+    @model.read_attribute(:name).should eq "my name is"
+  end
   
   describe "#attributes" do
     it "should contain the id" do