rod 0.6.0 → 0.6.1

data/lib/rod/abstract_model.rb

@@ -0,0 +1,66 @@
+module Rod
+  # A base class for all classes stored in the DataBase
+  # (both user defined and DB defined).
+  class AbstractModel
+    # Empty string.
+    def self.typedef_struct
+      raise RodException.new("#typdef_struct called for AbstractModel")
+    end
+
+    # C-struct name of the model.
+    def self.struct_name
+      raise RodException.new("#typdef_struct called for AbstractModel")
+    end
+
+    # Path to the file storing the model data.
+    def self.path_for_data(path)
+      "#{path}#{self.struct_name}.dat"
+    end
+
+    # Default implementation prints nothing.
+    def self.layout
+    end
+
+    # By default there are no fields.
+    def self.fields
+      []
+    end
+
+    # By default nothing is built.
+    def self.build_structure
+    end
+
+    # Default cache for models.
+    def self.cache
+      @cache ||= Cache.new
+    end
+
+    # There are no indexed properties.
+    def self.indexed_properties
+      []
+    end
+
+    # By default properties are empty.
+    def self.properties
+      []
+    end
+
+    # Returns meta-data (in the form of a hash) for the model.
+    def self.metadata(database)
+      meta = {}
+      meta[:count] = database.count(self)
+      meta[:superclass] = self.superclass.name
+      meta
+    end
+
+    # Checks if the +metadata+ are compatible with the class definition.
+    def self.compatible?(metadata,database)
+      self_metadata = self.metadata(database)
+      other_metadata = metadata.dup
+      self_metadata.delete(:count)
+      other_metadata.delete(:count)
+      self_metadata == other_metadata
+    end
+
+  end
+end

data/lib/rod/cache.rb

@@ -0,0 +1,81 @@
+require 'singleton'
+
+module Rod
+  class Cache
+    class InternalMap
+      include Singleton
+      attr_reader :mutex
+
+      def initialize
+        @mutex = Mutex.new
+        @object_to_caches = Hash.new{|h,v| h[v] = []}
+        @finalizer = lambda do |object_id|
+          @object_to_caches[object_id].each do |cache,key|
+            cache.delete(key)
+          end
+          @object_to_caches.delete(object_id)
+        end
+      end
+
+      def register(value,key,cache)
+        @object_to_caches[value.object_id] << [cache,key]
+        ObjectSpace.define_finalizer(value,@finalizer)
+      end
+    end
+
+    def initialize
+      @map = {}
+      @direct_values_map = {}
+    end
+
+    def [](key)
+      if @direct_values_map[key]
+        return @map[key]
+      else
+        value_id = nil
+        value_id = @map[key]
+        return value_id if value_id.nil?
+        begin
+          return ObjectSpace._id2ref(value_id)
+        rescue RangeError
+          @map.delete(key)
+          return nil
+        end
+      end
+    end
+
+    def []=(key,value)
+      @direct_values_map.delete(key)
+      case value
+      when Fixnum, Symbol, FalseClass, TrueClass, NilClass
+        @map[key] = value
+        @direct_values_map[key] = true
+      else
+        @map[key] = value.object_id
+        InternalMap.instance.register(value,key,@map)
+      end
+    end
+
+    def clear
+      @map.clear
+      @direct_values_map.clear
+    end
+
+    def delete(key)
+      @map.delete(key)
+      @direct_values_map.delete(key)
+    end
+
+    def each
+      if block_given?
+        @map.each do |key,value|
+          begin
+            yield self[key]
+          end
+        end
+      else
+        enum_for(:each)
+      end
+    end
+  end
+end

data/lib/rod/collection_proxy.rb

@@ -9,27 +9,35 @@ module Rod
 
     # Intializes the proxy with +size+ of the collection
     # and +fetch+ block for retrieving the object from the database.
-    def initialize(size,&fetch)
+    def initialize(size,database,offset,klass)
       @size = size
       @original_size = size
-      @fetch = fetch
+      @database = database
+      @klass = klass
+      @offset = offset
       @appended = []
-      raise InvalidArgument.new("Cannot use proxy collection without a block!") unless block_given?
-      @proxy = SimpleWeakHash.new
     end
 
     # Returns an object with given +index+.
     def [](index)
       return nil if index >= @size
-      return @proxy[index] unless @proxy[index].nil?
-      rod_id, klass = id_and_class_for(index)
-      result = rod_id == 0 ? nil : klass.find_by_rod_id(rod_id)
-      @proxy[index] = result
+      rod_id = id_for(index)
+      if rod_id.is_a?(Model)
+        rod_id
+      elsif rod_id == 0
+        nil
+      else
+        class_for(index).find_by_rod_id(rod_id)
+      end
     end
 
     # Appends element to the end of the collection.
-    def <<(rod_id_and_class)
-      @appended << rod_id_and_class
+    def <<(element)
+      if element.rod_id == 0
+        @appended << [element,element.class]
+      else
+        @appended << [element.rod_id,element.class]
+      end
       @size += 1
     end
 
@@ -48,7 +56,12 @@ module Rod
     def each_id
       if block_given?
         @size.times do |index|
-          yield id_and_class_for(index)[0]
+          id = id_for(index)
+          if id.is_a?(Model)
+            raise IdException.new(id)
+          else
+            yield id
+          end
         end
       else
         enum_for(:each_id)
@@ -61,11 +74,27 @@ module Rod
     end
 
     protected
-    def id_and_class_for(index)
+    def id_for(index)
       if index >= @original_size && !@appended[index - @original_size].nil?
-        @appended[index - @original_size]
+        @appended[index - @original_size][0]
       else
-        @fetch.call(index)
+        if @klass.nil?
+          @database.polymorphic_join_index(@offset,index)
+        else
+          @database.join_index(@offset,index)
+        end
+      end
+    end
+
+    def class_for(index)
+      if index >= @original_size && !@appended[index - @original_size].nil?
+        @appended[index - @original_size][1]
+      else
+        if @klass.nil?
+          Model.get_class(@database.polymorphic_join_class(@offset,index))
+        else
+          @klass
+        end
       end
     end
   end

data/lib/rod/constants.rb

@@ -1,5 +1,5 @@
 module Rod
-  VERSION = "0.6.0"
+  VERSION = "0.6.1"
 
   # The name of file containing the data base.
   DATABASE_FILE = "database.yml"
@@ -29,4 +29,11 @@ module Rod
     :ulong => 'ULONG2NUM'
   }
 
+  INLINE_PATTERN_RE = /\h+\.\w+$/
+
+  LEGACY_DATA_SUFFIX = ".old"
+  NEW_DATA_SUFFIX = ".new"
+  LEGACY_MODULE = "Legacy"
+  LEGACY_RE = /^#{LEGACY_MODULE}::/
+
 end

data/lib/rod/database.rb

@@ -146,7 +146,7 @@ module Rod
     # Returns true if the class is one of speciall classes
     # (JoinElement, PolymorphicJoinElement, StringElement).
     def special_class?(klass)
-      self.class.special_classes.include?(klass)
+      self.special_classes.include?(klass)
     end
 
     #########################################################################
@@ -280,14 +280,14 @@ module Rod
           builder.c(str.margin)
 
           str =<<-END
-          |unsigned long _allocate_join_elements(VALUE size, VALUE handler){
+          |unsigned long _allocate_join_elements(unsigned long size, VALUE handler){
           |  _join_element * element;
           |  unsigned long index;
           |  #{model_struct} * model_p;
           |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  unsigned long result = model_p->_join_element_count;
           |  for(index = 0; index < size; index++){
-          |    if(model_p->_join_element_count * sizeof(_join_element) >=
+          |    if((model_p->_join_element_count + 1) * sizeof(_join_element) >=
           |      page_size() * model_p->_join_element_page_count){
           |      \n#{mmap_class(JoinElement)}
           |    }
@@ -302,14 +302,14 @@ module Rod
           builder.c(str.margin)
 
           str =<<-END
-          |unsigned long _allocate_polymorphic_join_elements(VALUE size, VALUE handler){
+          |unsigned long _allocate_polymorphic_join_elements(unsigned long size, VALUE handler){
           |  _polymorphic_join_element * element;
           |  unsigned long index;
           |  #{model_struct} * model_p;
           |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  unsigned long result = model_p->_polymorphic_join_element_count;
           |  for(index = 0; index < size; index++){
-          |    if(model_p->_polymorphic_join_element_count *
+          |    if((model_p->_polymorphic_join_element_count + 1) *
           |      sizeof(_polymorphic_join_element) >=
           |      page_size() * model_p->_polymorphic_join_element_page_count){
           |      \n#{mmap_class(PolymorphicJoinElement)}
@@ -476,7 +476,6 @@ module Rod
           |  \n#{classes.map do |klass|
              <<-SUBEND
              |  model_p->#{klass.struct_name}_lib_file = -1;
-             |
              |  if(model_p->#{klass.struct_name}_page_count > 0){
              |    \n#{open_class_file(klass)}
              |    if((model_p->#{klass.struct_name}_table = mmap(NULL,
@@ -487,7 +486,7 @@ module Rod
              |    }
              |  #{update_pointer(klass) unless special_class?(klass)}
              |  } else {
-             |    model_p->#{klass.struct_name}_table = NULL;
+             |    #{mmap_class(klass)}
              |  }
              SUBEND
           end.join("\n")}
@@ -566,6 +565,15 @@ module Rod
             # it is rebuild on the basis of methods' signatures change.
             builder.c_singleton("void __unused_method_#{rand(1000)}(){}")
           end
+
+          # This has to be at the very end of builder definition!
+          self.instance_variable_set("@inline_library",builder.so_name)
+
+          # Ruby inline generated shared library.
+          def self.inline_library
+            @inline_library
+          end
+
         end
         @code_generated = true
       end

data/lib/rod/exception.rb

@@ -53,4 +53,24 @@ module Rod
       "The value '#@value' of the #@type is invalid!"
     end
   end
+
+  # This exception is throw when an objects id is needed, but it is not
+  # yet stored in the database. The object might be accessed via +object+
+  # attribute of the exception.
+  class IdException < RodException
+    attr_reader :object
+
+    def initialize(message,object)
+      super("The object has not been stored in the DB and its rod_id == 0")
+      @object = object
+    end
+  end
+
+  # This exception is thrown if the database is not compatible with
+  # the library or the runtime definition of classes.
+  class IncompatibleVersion < RodException
+    def initialize(message)
+      super(message)
+    end
+  end
 end

data/lib/rod/join_element.rb

@@ -1,5 +1,7 @@
+require 'rod/abstract_model'
+
 module Rod
-  class JoinElement
+  class JoinElement < AbstractModel
     def self.typedef_struct
       str = <<-END
       |typedef struct {
@@ -17,26 +19,6 @@ module Rod
     def self.struct_name
       "_join_element"
     end
-
-    def self.path_for_data(path)
-      "#{path}#{self.struct_name}.dat"
-    end
-
-    def self.page_offsets
-      @page_offsets ||= []
-    end
-
-    def self.fields
-      []
-    end
-
-    def self.build_structure
-      # does nothing, the structure is not needed
-    end
-
-    def self.cache
-      @cache ||= SimpleWeakHash.new
-    end
   end
 
   class PolymorphicJoinElement < JoinElement

data/lib/rod/model.rb

@@ -1,10 +1,11 @@
 require 'rod/constants'
 require 'rod/collection_proxy'
+require 'rod/abstract_model'
 
 module Rod
 
   # Abstract class representing a model entity. Each storable class has to derieve from +Model+.
-  class Model
+  class Model < AbstractModel
     include ActiveModel::Validations
     extend Enumerable
 
@@ -245,43 +246,49 @@ module Rod
       unless object.is_a?(self)
         raise RodException.new("Incompatible object class #{object.class}.")
       end
-      unless object.rod_id == 0
-        raise RodException.new("The object #{object} is allready stored!")
-      end
+      new_object = (object.rod_id == 0)
       database.store(self,object)
+      cache[object.rod_id] = object
+
+      referenced_objects ||= database.referenced_objects
 
       # update indices
-      properties.each do |property,options|
-        if options[:index]
-          keys =
+      indexed_properties.each do |property,options|
+        # singular and plural associations with nil as value are not indexed
+        keys =
+          if new_object
             if field?(property)
               [object.send(property)]
             elsif singular_association?(property)
-              [object.send(property).rod_id]
+              [object.send(property)].compact
             else
-              object.send(property).map{|o| o.rod_id}
+              object.send(property).to_a.compact
             end
-          keys.each do |key|
-            proxy = self.index_for(property,options,key)
-            if proxy.nil?
-              proxy = self.set_values_for(property,options,key,0) do |index|
-                raise RodException.new("Calling fetch block for an empty proxy!")
-              end
-            else
-              unless proxy.is_a?(CollectionProxy)
-                offset, count = proxy
-                proxy = self.set_values_for(property,options,key,count) do |index|
-                  [database.join_index(offset,index), self]
-                end
-              end
+          elsif plural_association?(property)
+            object.send(property).to_a.compact
+          end
+        next if keys.nil?
+        keys.each.with_index do |key_or_object,key_index|
+          key = (key_or_object.is_a?(Model) ? key_or_object.rod_id : key_or_object)
+          proxy = self.index_for(property,options,key)
+          if proxy.nil?
+            proxy = self.set_values_for(property,options,key,0,database,nil)
+          else
+            unless proxy.is_a?(CollectionProxy)
+              offset, count = proxy
+              proxy = self.set_values_for(property,options,key,count,database,offset)
+            end
+          end
+          if new_object || plural_association?(property) && proxy[key_index].nil?
+            if plural_association?(property) && key == 0
+              # TODO #94 devise method for reference rebuilding
             end
-            proxy << [object.rod_id,object.class]
+            proxy << object
           end
         end
       end
 
       # update object that references the stored object
-      referenced_objects ||= database.referenced_objects
       # ... via singular associations
       singular_associations.each do |name, options|
         referenced = object.send(name)
@@ -323,7 +330,7 @@ module Rod
       unless reverse_references.blank?
         reverse_references.each do |referee_rod_id, method_name, class_id, index|
           referee = Model.get_class(class_id).find_by_rod_id(referee_rod_id)
-          self.cache.send(:__get_hash__).delete(referee_rod_id)
+          self.cache.delete(referee_rod_id)
           if index.nil?
             # singular association
             referee.update_singular_association(method_name, object)
@@ -337,7 +344,7 @@ module Rod
     # The name of the C struct for this class.
     def self.struct_name
       return @struct_name unless @struct_name.nil?
-      name = self.to_s.underscore.gsub(/\//,"__")
+      name = struct_name_for(self.to_s)
       unless name =~ /^\#/
         # not an anonymous class
         @struct_name = name
@@ -345,6 +352,11 @@ module Rod
       name
     end
 
+    # Returns the struct name for the class +name+.
+    def self.struct_name_for(name)
+      name.underscore.gsub(/\//,"__")
+    end
+
     # Finder for rod_id.
     def self.find_by_rod_id(rod_id)
       if rod_id <= 0 || rod_id > self.count
@@ -380,6 +392,109 @@ module Rod
       end
     end
 
+    # Metadata for the model class.
+    def self.metadata(database)
+      meta = super(database)
+      # fields
+      fields = meta[:fields] = {} unless self.fields.size == 1
+      self.fields.each do |field,options|
+        next if field == "rod_id"
+        fields[field] = {}
+        fields[field][:options] = options
+      end
+      # singular_associations
+      has_one = meta[:has_one] = {} unless self.singular_associations.empty?
+      self.singular_associations.each do |name,options|
+        has_one[name] = {}
+        has_one[name][:options] = options
+      end
+      # plural_associations
+      has_many = meta[:has_many] = {} unless self.plural_associations.empty?
+      self.plural_associations.each do |name,options|
+        has_many[name] = {}
+        has_many[name][:options] = options
+      end
+      meta
+    end
+
+    # Generates the model class based on the metadata and places
+    # it in the +module_instance+ or Object (default scope) if module is nil.
+    def self.generate_class(class_name,metadata)
+      superclass = metadata[:superclass].constantize
+      namespace = define_context(class_name)
+      klass = Class.new(superclass)
+      namespace.const_set(class_name.split("::")[-1],klass)
+      [:fields,:has_one,:has_many].each do |type|
+        (metadata[type] || []).each do |name,options|
+          if type == :fields
+            internal_options = options[:options].dup
+            field_type = internal_options.delete(:type)
+            klass.send(:field,name,field_type,internal_options)
+          else
+            klass.send(type,name,options[:options])
+          end
+        end
+      end
+      klass
+    end
+
+    # Migrates the class to the new model, i.e. it copies all the
+    # values of properties that both belong to the class in the old
+    # and the new model.
+    def self.migrate
+      new_class = self.name.sub(LEGACY_RE,"").constantize
+      old_object = self.new
+      new_object = new_class.new
+      puts "Migrating #{new_class}" if $ROD_DEBUG
+      self.properties.each do |name,options|
+        next unless new_class.properties.keys.include?(name)
+        print "-  #{name}... " if $ROD_DEBUG
+        if options.map{|k,v| [k,v.to_s.sub(LEGACY_RE,"")]} !=
+          new_class.properties[name].map{|k,v| [k,v.to_s]}
+          raise IncompatibleVersion.
+            new("Incompatible definition of property '#{name}'\n" +
+                "Definition is different in the old and "+
+                "the new schema for '#{new_class}':\n" +
+                "  #{options} \n" +
+                "  #{new_class.properties[name]}")
+        end
+        if self.field?(name)
+          if self.string_field?(options[:type])
+            self.count.times do |position|
+              new_object.send("_#{name}_length=",position+1,
+                              old_object.send("_#{name}_length",position+1))
+              new_object.send("_#{name}_offset=",position+1,
+                              old_object.send("_#{name}_offset",position+1))
+            end
+          else
+            self.count.times do |position|
+              new_object.send("_#{name}=",position + 1,
+                              old_object.send("_#{name}",position + 1))
+            end
+          end
+        elsif self.singular_association?(name)
+          self.count.times do |position|
+            new_object.send("_#{name}=",position + 1,
+                            old_object.send("_#{name}",position + 1))
+          end
+          if options[:polymorphic]
+            self.count.times do |position|
+              new_object.send("_#{name}__class=",position + 1,
+                              old_object.send("_#{name}__class",position + 1))
+            end
+          end
+        else
+          self.count.times do |position|
+            new_object.send("_#{name}_count=",position + 1,
+                            old_object.send("_#{name}_count",position + 1))
+            new_object.send("_#{name}_offset=",position + 1,
+                            old_object.send("_#{name}_offset",position + 1))
+          end
+        end
+        puts "done" if $ROD_DEBUG
+      end
+    end
+
     protected
     # The pointer to the mmaped table of C structs.
     def self.rod_pointer
@@ -480,7 +595,7 @@ module Rod
     # The object cache of this class.
     # XXX consider moving it to the database.
     def self.cache
-      @cache ||= SimpleWeakHash.new
+      @cache ||= Cache.new
     end
 
     # The module context of the class.
@@ -498,6 +613,22 @@ module Rod
       end
     end
 
+    # Defines the namespace (contex) for given +class_name+ - if the constants
+    # (modules and classes) are defined, they are just digged into,
+    # if not - they are defined as modules.
+    def self.define_context(class_name)
+      class_name.split("::")[0..-2].inject(Object) do |mod,segment|
+        begin
+          mod.const_get(segment,false)
+        rescue NameError
+          new_mod = Module.new
+          mod.const_set(segment,new_mod)
+          new_mod
+        end
+      end
+    end
+
+
     #########################################################################
     # DB-oriented API
     #########################################################################
@@ -515,10 +646,23 @@ module Rod
         to_s.to_i(16) % 2 ** 32
     end
 
+    # Allows for setting arbitrary name for the model path, i.e.
+    # the model-specific fragment of the path to the model files.
+    # By default it is the same as Model.struct_name
+    def self.model_path=(path)
+      @model_path = path
+    end
+
+    # Returns the model path, i.e. the model-specific fragment of
+    # the path to the model files (data, indices, etc.).
+    def self.model_path
+      @model_path || self.struct_name
+    end
+
     # The name of the file (for given +relative_path+), which the data of this class
     # is stored in.
     def self.path_for_data(relative_path)
-      "#{relative_path}#{self.struct_name}.dat"
+      "#{relative_path}#{model_path}.dat"
     end
 
     # The name of the file or directory (for given +relative_path+), which the
@@ -526,9 +670,9 @@ module Rod
     def self.path_for_index(relative_path,field,options)
       case options[:index]
       when :flat,true
-        "#{relative_path}#{self.struct_name}_#{field}.idx"
+        "#{relative_path}#{model_path}_#{field}.idx"
       when :segmented
-        "#{relative_path}#{self.struct_name}_#{field}_idx/"
+        "#{relative_path}#{model_path}_#{field}_idx/"
       else
         raise RodException.new("Invalid index type #{type}")
       end
@@ -675,6 +819,22 @@ module Rod
           field_writer("#{name}_count","unsigned long",builder)
           field_writer("#{name}_offset","unsigned long",builder)
         end
+
+        str=<<-END
+        |unsigned int struct_size(){
+        |  return sizeof(#{self.struct_name});
+        |}
+        END
+
+        builder.c_singleton(str.margin)
+
+        # This has to be the last position in the builder!
+        self.instance_variable_set("@inline_library",builder.so_name)
+
+        # Ruby inline generated shared library.
+        def self.inline_library
+          @inline_library
+        end
       end
 
       ## accessors for fields, plural and singular relationships follow
@@ -789,7 +949,7 @@ module Rod
           else
             "#{self.scope_name}::#{::English::Inflect.singular(name).camelcase}"
           end
-        klass = class_name.constantize unless options[:polymorphic]
+        klass = options[:polymorphic] ? nil : class_name.constantize
 
         # getter
         define_method("#{name}") do
@@ -802,17 +962,7 @@ module Rod
             end
             return instance_variable_set("@#{name}",[]) if count == 0
             offset = self.send("_#{name}_offset",@rod_id)
-            unless options[:polymorphic]
-              proxy = CollectionProxy.new(count) do |index|
-                [database.join_index(offset,index), klass]
-              end
-            else
-              proxy = CollectionProxy.new(count) do |index|
-                rod_id = database.polymorphic_join_index(offset,index)
-                class_id = database.polymorphic_join_class(offset,index)
-                [rod_id, rod_id == 0 ? 0 : Model.get_class(class_id)]
-              end
-            end
+            proxy = CollectionProxy.new(count,database,offset,klass)
             instance_variable_set("@#{name}", proxy)
           end
           proxy
@@ -834,24 +984,31 @@ module Rod
       end
 
       # indices
-      properties.each do |property,options|
+      indexed_properties.each do |property,options|
         # optimization
         property = property.to_s
-        if options[:index]
-          (class << self; self; end).class_eval do
-            # Find all objects with given +value+ of the +property+.
-            define_method("find_all_by_#{property}") do |value|
-              value = value.rod_id if value.is_a?(Model)
-              offset,count = index_for(property,options,value)
+        (class << self; self; end).class_eval do
+          # Find all objects with given +value+ of the +property+.
+          define_method("find_all_by_#{property}") do |value|
+            value = value.rod_id if value.is_a?(Model)
+            proxy = index_for(property,options,value)
+            if proxy.is_a?(CollectionProxy)
+              proxy
+            else
+              offset,count = proxy
               return [] if offset.nil?
-              CollectionProxy.new(count) do |index|
-                [database.join_index(offset,index),self]
-              end
+              CollectionProxy.new(count,database,offset,self)
             end
+          end
 
-            # Find first object with given +value+ of the +property+.
-            define_method("find_by_#{property}") do |value|
-              offset,count = index_for(property,options)[value]
+          # Find first object with given +value+ of the +property+.
+          define_method("find_by_#{property}") do |value|
+            value = value.rod_id if value.is_a?(Model)
+            proxy = index_for(property,options)[value]
+            if proxy.is_a?(CollectionProxy)
+              proxy[0]
+            else
+              offset,count = proxy
               if offset.nil?
                 nil
               else
@@ -870,6 +1027,11 @@ module Rod
         self.fields.merge(self.singular_associations.merge(self.plural_associations))
       end
 
+      # Returns (and caches) only properties which are indexed.
+      def indexed_properties
+        @indexed_properties ||= self.properties.select{|p,o| o[:index]}
+      end
+
       # Returns true if the +name+ (as symbol) is a name of a field.
       def field?(name)
         self.fields.keys.include?(name)
@@ -905,8 +1067,8 @@ module Rod
       # the particular +key+. Method expects +fetch+ block and
       # creates a CollectionProxy based on that block.
       # The size of the collection is given as +count+.
-      def set_values_for(property,options,key,count,&fetch)
-        index_for(property,options)[key] = CollectionProxy.new(count,&fetch)
+      def set_values_for(property,options,key,count,database,offset)
+        index_for(property,options)[key] = CollectionProxy.new(count,database,offset,self)
       end
 
       private