massive_record 0.2.0 → 0.2.1.rc1

data/lib/massive_record/orm/log_subscriber.rb

@@ -0,0 +1,85 @@
+module MassiveRecord
+  module ORM
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def self.runtime=(value)
+        Thread.current["massive_record_query_runtime"] = value
+      end
+
+      def self.runtime
+        Thread.current["massive_record_query_runtime"] ||= 0
+      end
+
+      def self.reset_runtime
+        rt, self.runtime = runtime, 0
+        rt
+      end
+      
+
+
+      def load(event)
+        self.class.runtime += event.duration
+
+        return unless logger.debug?
+
+        payload = event.payload
+        name = '%s (%.1fms)' % [payload[:name], event.duration]
+        description = payload[:description]
+        options = payload[:options]
+
+        if options.present? && options.any?
+          options = "options: #{options}"
+        else
+          options = nil
+        end
+
+        if odd?
+          name = color(name, CYAN, true)
+          description = color(description, nil, true)
+        else
+          name = color(name, MAGENTA, true)
+        end
+
+        debug "  " + [name, description, options].compact.join("  ")
+      end
+
+      def query(event)
+        return unless logger.debug?
+
+        payload = event.payload
+        name = '%s (%.1fms)' % [payload[:name], event.duration]
+        description = payload[:description]
+        options = payload[:options]
+
+        if options.present? && options.any?
+          options = "options: #{options}"
+        else
+          options = nil
+        end
+
+        if odd?
+          name = color(name, CYAN, true)
+          description = color(description, nil, true)
+        else
+          name = color(name, MAGENTA, true)
+        end
+
+        debug "  " + [name, description, options].compact.join("  ")
+      end
+
+
+
+      def logger
+        MassiveRecord::ORM::Base.logger
+      end
+
+
+      private
+
+      def odd?
+        @odd = !@odd
+      end
+    end
+
+    LogSubscriber.attach_to :massive_record
+  end
+end

data/lib/massive_record/orm/persistence.rb

@@ -3,9 +3,10 @@ module MassiveRecord
     module Persistence
       extend ActiveSupport::Concern
 
+
       module ClassMethods
-        def create(attributes = {})
-          new(attributes).tap do |record|
+        def create(*args)
+          new(*args).tap do |record|
             record.save
           end
         end
@@ -13,6 +14,42 @@ module MassiveRecord
         def destroy_all
           all.each { |record| record.destroy }
         end
+        
+
+        #
+        # Iterates over tables and column families and ensure that we
+        # have what we need
+        #
+        def ensure_that_we_have_table_and_column_families! # :nodoc:
+          # 
+          # TODO: Can we skip checking if it exists at all, and instead, rescue it if it does not?
+          #
+          hbase_create_table! unless table.exists?
+          raise ColumnFamiliesMissingError.new(self, calculate_missing_family_names) if calculate_missing_family_names.any?
+        end
+
+
+        private
+
+        #
+        # Creates table for this ORM class
+        #
+        def hbase_create_table!
+          missing_family_names = calculate_missing_family_names
+          table.create_column_families(missing_family_names) unless missing_family_names.empty?
+          table.save
+        end
+
+        #
+        # Calculate which column families are missing in the database in
+        # context of what the schema instructs.
+        #
+        def calculate_missing_family_names
+          existing_family_names = table.fetch_column_families.collect(&:name) rescue []
+          expected_family_names = column_families ? column_families.collect(&:name) : []
+
+          expected_family_names.collect(&:to_s) - existing_family_names.collect(&:to_s)
+        end
       end
 
 
@@ -43,7 +80,7 @@ module MassiveRecord
       end
 
       def update_attribute(attr_name, value)
-        send("#{attr_name}=", value)
+        self[attr_name] = value
         save(:validate => false)
       end
 
@@ -87,12 +124,14 @@ module MassiveRecord
       # is atomic, and as of writing this the Thrift adapter / wrapper does
       # not do this anatomic.
       def atomic_increment!(attr_name, by = 1)
-        ensure_that_we_have_table_and_column_families!
+        self.class.ensure_that_we_have_table_and_column_families!
         attr_name = attr_name.to_s
 
-        row = row_for_record
-        row.values = attributes_to_row_values_hash([attr_name])
-        self[attr_name] = row.atomic_increment(attributes_schema[attr_name].unique_name, by).to_i
+        ensure_proper_binary_integer_representation(attr_name)
+
+        self[attr_name] = row_for_record.atomic_increment(attributes_schema[attr_name].unique_name, by)
+        @new_record = false
+        self[attr_name]
       end
 
       def decrement(attr_name, by = 1)
@@ -116,18 +155,20 @@ module MassiveRecord
       end
 
       def create
-        ensure_that_we_have_table_and_column_families!
+        self.class.ensure_that_we_have_table_and_column_families!
+
+        raise RecordNotUnique if check_record_uniqueness_on_create && self.class.exists?(id)
 
-        if saved = store_record_to_database
+        if saved = store_record_to_database('create')
           @new_record = false
         end
         saved
       end
 
       def update(attribute_names_to_update = attributes.keys)
-        ensure_that_we_have_table_and_column_families!
+        self.class.ensure_that_we_have_table_and_column_families!
 
-        store_record_to_database(attribute_names_to_update)
+        store_record_to_database('update', attribute_names_to_update)
       end
 
 
@@ -137,37 +178,13 @@ module MassiveRecord
       # Takes care of the actual storing of the record to the database
       # Both update and create is using this
       #
-      def store_record_to_database(attribute_names_to_update = [])
+      def store_record_to_database(action, attribute_names_to_update = [])
         row = row_for_record
         row.values = attributes_to_row_values_hash(attribute_names_to_update)
         row.save
       end
 
 
-      #
-      # Iterates over tables and column families and ensure that we
-      # have what we need
-      #
-      def ensure_that_we_have_table_and_column_families!
-        if !self.class.connection.tables.include? self.class.table_name
-          missing_family_names = calculate_missing_family_names
-          self.class.table.create_column_families(missing_family_names) unless missing_family_names.empty?
-          self.class.table.save
-        end
-
-        raise ColumnFamiliesMissingError.new(self.class, calculate_missing_family_names) if !calculate_missing_family_names.empty?
-      end
-      
-      #
-      # Calculate which column families are missing in the database in
-      # context of what the schema instructs.
-      #
-      def calculate_missing_family_names
-        existing_family_names = self.class.table.fetch_column_families.collect(&:name) rescue []
-        expected_family_names = column_families ? column_families.collect(&:name) : []
-
-        expected_family_names.collect(&:to_s) - existing_family_names.collect(&:to_s)
-      end
 
       #
       # Returns a Wrapper::Row class which we can manipulate this
@@ -190,11 +207,39 @@ module MassiveRecord
 
         attributes_schema.each do |attr_name, orm_field|
           next unless only_attr_names.empty? || only_attr_names.include?(attr_name)
-          values[orm_field.column_family.name][orm_field.column] = orm_field.encode(send(attr_name))
+          values[orm_field.column_family.name][orm_field.column] = orm_field.encode(self[attr_name])
         end
 
         values
       end
+
+      #
+      # To cope with the problem which arises when you ask to
+      # do atomic incrementation of an attribute and that attribute
+      # has a string representation of a number, like "1", instead of
+      # the binary representation, like "\x00\x00\x00\x00\x00\x00\x00\x01".
+      #
+      # We then need to re-write that string representation into
+      # hex representation. Now, if you are on a completely new
+      # database and have never used MassiveRecord before we should not
+      # need to do this at all; numbers are now stored as hex, but for
+      # backward compatibility we are doing this.
+      #
+      # Now, there is a risk of doing this; if two calls are made to
+      # atomic_increment! on a record where it's value is a string
+      # representation this operation might be compromised. Therefor
+      # you need to enable this feature.
+      #
+      def ensure_proper_binary_integer_representation(attr_name)
+        return if !backward_compatibility_integers_might_be_persisted_as_strings || new_record?
+
+        field = attributes_schema[attr_name]  
+        raise "Not an integer field" unless field.try(:type) == :integer
+
+        if raw_value = self.class.table.get(id, field.column_family.name, field.name)
+          store_record_to_database('update', [attr_name]) if raw_value =~ /\A\d*\Z/
+        end
+      end
     end
   end
 end

data/lib/massive_record/orm/query_instrumentation.rb

@@ -0,0 +1,64 @@
+module MassiveRecord
+  module ORM
+    module QueryInstrumentation
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        #
+        # do_find is the method which *all* find operations goes
+        # through. For instrumentation on the query only see
+        # hbase_query_all_first /hbase_query_find
+        #
+        def do_find(*args)
+          ActiveSupport::Notifications.instrument("load.massive_record", {
+            :name => [model_name, 'load'].join(' '),
+            :description => "",
+            :options => args
+          }) do
+            super
+          end
+        end
+
+
+
+
+        private
+
+        def hbase_query_all_first(type, *args)
+          ActiveSupport::Notifications.instrument("find_query.massive_record", {
+            :name => [model_name, 'query'].join(' '),
+            :description => type,
+            :options => args
+          }) do
+            super
+          end
+        end
+
+        def hbase_query_find(what_to_find, options)
+          ActiveSupport::Notifications.instrument("find_query.massive_record", {
+            :name => [model_name, 'query'].join(' '),
+            :description => "find id(s): #{what_to_find}",
+            :options => options
+          }) do
+            super
+          end
+        end
+      end
+
+
+      private
+
+      def store_record_to_database(action, attribute_names_to_update = [])
+        description = action + " id: #{id},"
+        description += " attributes: #{attribute_names_to_update.join(', ')}" if attribute_names_to_update.any?
+
+        ActiveSupport::Notifications.instrument("query.massive_record", {
+          :name => [self.class.model_name, 'save'].join(' '),
+          :description => description
+        }) do
+          super
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/relations/interface.rb

@@ -146,6 +146,12 @@ module MassiveRecord
 
 
 
+        def reload
+          reset_relation_proxies
+          super
+        end
+
+
         private
 
         def relation_proxy(name)
@@ -168,6 +174,10 @@ module MassiveRecord
         def relation_proxy_set(name, proxy)
           @relation_proxy_cache[name.to_s] = proxy
         end
+
+        def reset_relation_proxies
+          @relation_proxy_cache.values.each(&:reset)
+        end
       end
     end
   end

data/lib/massive_record/orm/relations/metadata.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/array/extract_options'
+
 module MassiveRecord
   module ORM
     module Relations

data/lib/massive_record/orm/relations/proxy/references_one_polymorphic.rb

@@ -4,7 +4,7 @@ module MassiveRecord
       class Proxy
         class ReferencesOnePolymorphic < Proxy
           def proxy_target=(proxy_target)
-            set_foreign_key_and_type_in_proxy_owner(proxy_target.id, proxy_target.class.to_s.underscore) if proxy_target
+            set_foreign_key_and_type_in_proxy_owner(proxy_target.id, proxy_target.class.to_s) if proxy_target
             super(proxy_target)
           end
 

data/lib/massive_record/orm/schema/field.rb

@@ -13,9 +13,9 @@ module MassiveRecord
           :hash => {},
           :date => lambda { Date.today },
           :time => lambda { Time.now }
-        }
+        }.freeze
 
-        TYPES = TYPES_DEFAULTS_TO.keys
+        TYPES = TYPES_DEFAULTS_TO.keys.freeze
 
         attr_writer :default
         attr_accessor :name, :column, :type, :fields, :coder, :allow_nil
@@ -109,11 +109,13 @@ module MassiveRecord
 
 
         def decode(value)
+          value = value.force_encoding(Encoding::UTF_8) if utf_8_encoded? && !value.frozen? && value.respond_to?(:force_encoding) 
+
           return value if value.nil? || value_is_already_decoded?(value)
           
           value = case type
                   when :boolean
-                    value.blank? ? nil : !value.to_s.match(/^(true|1)$/i).nil?
+                    value.blank? || value == @@encoded_nil_value ? nil : !value.to_s.match(/^(true|1)$/i).nil?
                   when :date
                     value.blank? || value.to_s == "0" ? nil : (Date.parse(value) rescue nil)
                   when :time
@@ -123,7 +125,13 @@ module MassiveRecord
                       value = value.to_s if value.is_a? Symbol
                       coder.load(value)
                     end
-                  when :integer, :float, :array, :hash
+                  when :integer
+                    if value =~ /\A\d*\Z/
+                      coder.load(value) if value.present?
+                    else
+                      hex_string_to_integer(value)
+                    end
+                  when :float, :array, :hash
                     coder.load(value) if value.present?
                   else
                     raise "Unable to decode #{value}, class: #{value}"
@@ -135,10 +143,11 @@ module MassiveRecord
         end
 
         def encode(value)
-          if type == :string && !(value.nil? || value == @@encoded_nil_value)
+          if value.nil? || should_not_be_encoded?
             value
           else
-            coder.dump(value)
+            value = value.try(:utc) if Base.time_zone_aware_attributes && field_affected_by_time_zone_awareness?
+            coder.dump(value).to_s
           end
         end
 
@@ -169,6 +178,8 @@ module MassiveRecord
         def value_is_already_decoded?(value)
           if type == :string
             value.is_a?(String) && !(value == @@encoded_null_string || value == @@encoded_nil_value)
+          elsif value.acts_like?(type)
+            true
           else
             classes.include?(value.class)
           end
@@ -177,6 +188,22 @@ module MassiveRecord
         def loaded_value_is_of_valid_class?(value)
           value.nil? || value.is_a?(String) && value == @@encoded_nil_value || value_is_already_decoded?(value)
         end
+
+        def field_affected_by_time_zone_awareness?
+          type == :time
+        end
+
+        def hex_string_to_integer(string)
+          Wrapper::Cell.hex_string_to_integer(string)
+        end
+
+        def utf_8_encoded?
+          type != :integer
+        end
+
+        def should_not_be_encoded?
+          [:string, :integer].include?(type)
+        end
       end
     end
   end