massive_record 0.2.1 → 0.2.2.rc1

data/lib/massive_record/orm/id_factory.rb

@@ -2,64 +2,22 @@ require 'singleton'
 
 module MassiveRecord
   module ORM
+    module IdFactory
+      extend ActiveSupport::Concern
 
-    #
-    # A factory class for unique IDs for any given tables.
-    #
-    # Usage:
-    #   IdFactory.next_for(:cars) # => 1
-    #   IdFactory.next_for(:cars) # => 2
-    #   IdFactory.next_for(AClassRespondingToTableName)         # => 1
-    #   IdFactory.next_for("a_class_responding_to_table_names") # => 2
-    #
-    #
-    # Storage:
-    #   Stored in id_factories table, under column family named tables.
-    #   Field name equals to tables it has generated ids for, and it's
-    #   values is integers (if the adapter supports it).
-    #
-    class IdFactory < Table
-      include Singleton
-
-      COLUMN_FAMILY_FOR_TABLES = :tables
-      ID = "id_factory"
-
-      column_family COLUMN_FAMILY_FOR_TABLES do
-        autoload_fields
+      included do
+        include Singleton
       end
 
-      #
-      # Returns the factory, singleton class.
-      # It will be a reloaded version each time instance
-      # is retrieved, or else it will fetch self from the
-      # database, or if all other fails return a new of self.
-      #
-      def self.instance
-        if table_exists?
-          begin
-            if @instance
-              @instance.reload # If, for some reason, the record has been removed. Will be rescued and set to nil
-            else
-              @instance = find(ID)
-            end
-          rescue RecordNotFound
-            @instance = nil
-          end
+      module ClassMethods
+        #
+        # Delegates to the instance, just a shout cut.
+        #
+        def next_for(table)
+          instance.next_for(table)
         end
-
-        @instance = new unless @instance
-        @instance
       end
 
-      #
-      # Delegates to the instance, just a shout cut.
-      #
-      def self.next_for(table)
-        instance.next_for(table)
-      end
-
-
-
       #
       # Returns a new and unique id for a given table name
       # Table can a symbol, string or an object responding to table_name
@@ -70,64 +28,23 @@ module MassiveRecord
       end
 
 
-
-      def id
-        ID
-      end
-
       private
 
       #
-      # Method which actually does the increment work for
-      # a given table name as string
+      # Methods which generates next id, will receive at least
+      # :table => 'name' as options
       #
-      def next_id(options = {}) 
-        options.assert_valid_keys(:table)
-        table_name = options.delete :table
-
-        create_field_or_ensure_type_integer_for(table_name)
-        atomic_increment!(table_name)
-      end
-
-
-
-
-      def create_field_or_ensure_type_integer_for(table_name)
-        if has_field_for? table_name
-          ensure_type_integer_for(table_name)
-        else
-          create_field_for(table_name)
-        end
-      end
-
-
-      #
-      # Creates a field for a table name which is new
-      # Feels a bit hackish, hooking in and doing some of what the
-      # autoload-functionality of column_family block above does too.
-      # But at least, we can "dynamicly" assign new attributes to this object.
-      #
-      def create_field_for(table_name)
-        add_field_to_column_family COLUMN_FAMILY_FOR_TABLES, table_name, :integer, :default => 0
-      end
-      
-      #
-      # Just makes sure that definition of a field is set to integer.
-      # This is needed as the autoload functionlaity sets all types to strings.
-      #
-      def ensure_type_integer_for(table_name)
-        column_family_for_tables.field_by_name(table_name).type = :integer
-        self[table_name] = 0 if self[table_name].blank?
-      end
-
-
-      def has_field_for?(table_name)
-        respond_to? table_name
-      end
-
-      def column_family_for_tables
-        @column_family_for_tables ||= column_families.family_by_name(COLUMN_FAMILY_FOR_TABLES)
+      def next_id(options = {})
+        raise "Needs implementation :-)"
       end
     end
   end
 end
+
+require 'massive_record/orm/id_factory/atomic_incrementation'
+require 'massive_record/orm/id_factory/timestamp'
+
+ActiveSupport.on_load(:massive_record) do
+  MassiveRecord::ORM::Base.id_factory = MassiveRecord::ORM::IdFactory::AtomicIncrementation
+  MassiveRecord::ORM::Embedded.id_factory = MassiveRecord::ORM::IdFactory::Timestamp
+end

data/lib/massive_record/orm/id_factory/atomic_incrementation.rb

@@ -0,0 +1,117 @@
+module MassiveRecord
+  module ORM
+    module IdFactory
+
+      #
+      # A factory class for unique IDs for any given tables.
+      #
+      # Usage:
+      #   AtomicIncrementation.next_for(:cars) # => 1
+      #   AtomicIncrementation.next_for(:cars) # => 2
+      #   AtomicIncrementation.next_for(AClassRespondingToTableName)         # => 1
+      #   AtomicIncrementation.next_for("a_class_responding_to_table_names") # => 2
+      #
+      #
+      # Storage:
+      #   Stored in id_factories table, under column family named tables.
+      #   Field name equals to tables it has generated ids for, and it's
+      #   values is integers (if the adapter supports it).
+      #
+      class AtomicIncrementation < Table
+        include IdFactory
+
+        COLUMN_FAMILY_FOR_TABLES = :tables
+        ID = "id_factory"
+
+        set_table_name "id_factories"
+
+        column_family COLUMN_FAMILY_FOR_TABLES do
+          autoload_fields :type => :integer
+        end
+
+        #
+        # Returns the factory, singleton class.
+        # It will be a reloaded version each time instance
+        # is retrieved, or else it will fetch self from the
+        # database, or if all other fails return a new of self.
+        #
+        def self.instance
+          if table_exists?
+            begin
+              if @instance
+                @instance.reload # If, for some reason, the record has been removed. Will be rescued and set to nil
+              else
+                @instance = find(ID)
+              end
+            rescue RecordNotFound
+              @instance = nil
+            end
+          end
+
+          @instance = new unless @instance
+          @instance
+        end
+
+
+
+        def id
+          ID
+        end
+
+        private
+
+        #
+        # Method which actually does the increment work for
+        # a given table name as string
+        #
+        def next_id(options = {}) 
+          options.assert_valid_keys(:table)
+          table_name = options.delete :table
+
+          create_field_or_ensure_type_integer_for(table_name)
+          atomic_increment!(table_name)
+        end
+
+
+
+
+        def create_field_or_ensure_type_integer_for(table_name)
+          if has_field_for? table_name
+            ensure_type_integer_for(table_name)
+          else
+            create_field_for(table_name)
+          end
+        end
+
+
+        #
+        # Creates a field for a table name which is new
+        # Feels a bit hackish, hooking in and doing some of what the
+        # autoload-functionality of column_family block above does too.
+        # But at least, we can "dynamicly" assign new attributes to this object.
+        #
+        def create_field_for(table_name)
+          add_field_to_column_family COLUMN_FAMILY_FOR_TABLES, table_name, :integer, :default => 0
+        end
+        
+        #
+        # Just makes sure that definition of a field is set to integer.
+        # This is needed as the autoload functionlaity sets all types to strings.
+        #
+        def ensure_type_integer_for(table_name)
+          column_family_for_tables.field_by_name(table_name).type = :integer
+          self[table_name] = 0 if self[table_name].blank?
+        end
+
+
+        def has_field_for?(table_name)
+          respond_to? table_name
+        end
+
+        def column_family_for_tables
+          @column_family_for_tables ||= column_families.family_by_name(COLUMN_FAMILY_FOR_TABLES)
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/id_factory/timestamp.rb

@@ -0,0 +1,60 @@
+module MassiveRecord
+  module ORM
+    module IdFactory
+
+      #
+      # Factory class for ids based on time stamps. It does not guarantee uniqueness
+      # on ids, but if you use microseconds as precision you should be at least a bit
+      # better of then using seconds..
+      #
+      # This factory is mostly intended to generate ids for embedded records, and was
+      # written as a result of Companybook not wanting to id the AtomicIncrementation
+      # id factory for every embedded record. It might be, in the future, an idea to
+      # take a second look at this one to make it guarantee it's uniqueness of ids.
+      #
+      class Timestamp
+        include IdFactory
+
+        cattr_accessor :precision, :reverse_time, :instance_writer => false
+        self.precision = :microseconds
+        self.reverse_time = true
+
+
+        private
+
+        def next_id(options = {})
+          options.assert_valid_keys(:table)
+          table_name = options.delete :table
+
+          time_to_id Time.now
+        end
+
+
+        def time_to_id(time)
+          floated_time = time.getutc.to_f
+
+          case precision
+          when :s, :seconds
+            if reverse_time
+              (10**10 - 1 - (floated_time).to_i).to_s
+            else
+              (floated_time).to_i.to_s
+            end
+          when :ms, :milliseconds
+            if reverse_time
+              (10**13 - 1 - (floated_time * 1000).to_i).to_s
+            else
+              (floated_time * 1000).to_i.to_s
+            end
+          when :us, :microseconds
+            if reverse_time
+              (10**16 - 1 - (floated_time * 1000000).to_i).to_s
+            else
+              (floated_time * 1000000).to_i.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/identity_map.rb

@@ -0,0 +1,256 @@
+module MassiveRecord
+  module ORM
+
+    #
+    # The goal of the IdentiyMap is to make sure that the same object is not loaded twice
+    # from the database, but uses the same object if you do 2.times { AClass.find(1) }.
+    #
+    # To get a quick introduction on IdentityMap see: http://www.martinfowler.com/eaaCatalog/identityMap.html
+    #
+    # You can enable / disable Identity map by doing:
+    # MassiveRecord::ORM::IdentityMap.enabled = flag
+    #
+    module IdentityMap
+      extend ActiveSupport::Concern
+
+      #
+      # Error is raised internally of the identity map to signal that
+      # you tried to get a record from a parent class, but you looked
+      # it up via it's sub class. For instance A is a super class of B.
+      # IdentityMap.get(B, "id-belonging-to-an-A-class") will raise the
+      # error.
+      #
+      # This error will however not "leak" outside of the identity map's
+      # code. It should be handled internally, and the goal for it is just
+      # not to hit the database more than we need to if we know that the
+      # database will return nil as well.
+      #
+      class RecordIsSuperClassOfQueriedClass < MassiveRecordError; end
+
+      class << self
+        #
+        # Switch to either turn on or off the identity map
+        #
+        def enabled=(boolean)
+          Thread.current[:identity_map_enabled] = boolean
+        end
+
+        def enabled
+          !!Thread.current[:identity_map_enabled]
+        end
+        alias enabled? enabled
+
+
+        #
+        # Call this with a block to ensure that IdentityMap is enabled
+        # for that block and reset to it's origianl setting thereafter
+        #
+        def use
+          original_value, self.enabled = enabled, true
+          yield
+        ensure
+          self.enabled = original_value
+        end
+
+        #
+        # Call this with a block to ensure that IdentityMap is disabled
+        # for that block and reset to it's origianl setting thereafter
+        #
+        def without
+          original_value, self.enabled = enabled, false
+          yield
+        ensure
+          self.enabled = original_value
+        end
+
+
+
+        def get(klass, *ids)
+          get_many = ids.first.is_a?(Array)
+
+          ids.flatten!
+
+          result =  case ids.length
+                    when 0
+                      raise ArgumentError.new("Must have at least one ID!")
+                    when 1
+                      result = get_one(klass, ids.first)
+                      get_many ? [result].compact : result
+                    else
+                      get_some(klass, ids)
+                    end
+
+          if records = Array(result).compact and records.any?
+            ActiveSupport::Notifications.instrument("identity_map.massive_record", {
+              :name => [klass, 'loaded from identity map'].join(' '),
+              :records => records
+            }) do
+              result
+            end
+          end
+
+          result
+        end
+
+        def add(record)
+          return if record.nil?
+
+          repository[record_class_to_repository_key(record)][record.id] = record
+        end
+
+        def remove(record)
+          remove_by_id record.class, record.id
+        end
+
+        def remove_by_id(klass, id)
+          repository[class_to_repository_key(klass)].delete id
+        end
+
+        delegate :clear, :to => :repository
+
+
+
+        private
+
+        def get_one(klass, id)
+          if record = repository[class_to_repository_key(klass)][id]
+            if klass == record.class || klass.descendants.include?(record.class)
+              record
+            else
+              raise RecordIsSuperClassOfQueriedClass.new("#{record.class} is a super class of #{klass}. Please look your #{klass}-record up by do a #{klass}.find(#{record.id.inspect})")
+            end
+          end
+        end
+
+        def get_some(klass, ids)
+          ids.collect do |id|
+            begin
+              get_one(klass, id)
+            rescue RecordIsSuperClassOfQueriedClass
+              nil
+            end
+          end.compact
+        end
+
+        def repository
+          Thread.current[:identity_map_repository] ||= Hash.new { |hash, key| hash[key] = {} }
+        end
+
+        def record_class_to_repository_key(record)
+          class_to_repository_key record.class
+        end
+
+        def class_to_repository_key(klass)
+          klass.base_class
+        end
+      end
+
+
+
+
+
+      module ClassMethods
+        private
+
+
+        def find_one(id, options)
+          return super unless IdentityMap.enabled? && can_use_identity_map_with?(options)
+
+          IdentityMap.get(self, id) || IdentityMap.add(super)
+        rescue RecordIsSuperClassOfQueriedClass
+          nil
+        end
+
+        def find_some(ids, options)
+          return super unless IdentityMap.enabled? && can_use_identity_map_with?(options)
+
+          records_from_database = []
+          records_from_identity_map = IdentityMap.get(self, ids)
+
+          missing_ids = ids - records_from_identity_map.collect(&:id)
+
+          if missing_ids.any?
+            records_from_database = super(missing_ids, options)
+            records_from_database.each { |record| IdentityMap.add(record) }
+          end
+
+          records_from_identity_map | records_from_database
+        end
+
+
+
+        def can_use_identity_map_with?(finder_options)
+          !finder_options.has_key?(:select)
+        end
+      end
+
+
+
+      module InstanceMethods
+        def reload
+          IdentityMap.remove(self) if IdentityMap.enabled?
+          super
+        end
+
+        def destroy
+          return super unless IdentityMap.enabled?
+
+          super.tap { IdentityMap.remove(self) }
+        end
+        alias_method :delete, :destroy
+
+        def change_id!(new_id)
+          IdentityMap.remove(self)
+          super
+        end
+
+        private
+
+
+        def create
+          return super unless IdentityMap.enabled?
+
+          super.tap { IdentityMap.add(self) }
+        end
+      end
+
+
+
+
+      class Middleware
+        class BodyProxy
+          def initialize(target, original_identity_map_state)
+            @target = target
+            @original_identity_map_state = original_identity_map_state
+          end
+
+          def each(&block)
+            @target.each(&block)
+          end
+
+          def close
+            @target.close if @target.respond_to?(:close)
+          ensure
+            IdentityMap.enabled = @original_identity_map_state
+            IdentityMap.clear
+          end
+          
+        end
+
+
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          original_identity_map_state = IdentityMap.enabled?
+          IdentityMap.enabled = true
+
+          status, headers, body = @app.call(env)
+          [status, headers, BodyProxy.new(body, original_identity_map_state)]
+        end
+      end
+    end
+  end
+end