rod 0.7.1 → 0.7.2

data/lib/rod/index/segmented_index.rb

@@ -45,6 +45,9 @@ module Rod
 
       def each
         if block_given?
+          @buckets_count.times do |bucket_number|
+            load_bucket(bucket_number) unless @buckets[bucket_number]
+          end
           @buckets.each do |bucket_number,hash|
             hash.each_key do |key|
               yield key, self[key]

data/lib/rod/model.rb

@@ -70,22 +70,22 @@ module Rod
       end
       # The default values doesn't have to be persisted, since they
       # are returned by default by the accessors.
-      self.changed.each do |property|
-        property = property.to_sym
-        if self.class.field?(property)
+      self.changed.each do |property_name|
+        property = self.class.property(property_name.to_sym)
+        if property.field?
           # store field value
           update_field(property)
-        elsif self.class.singular_association?(property)
+        elsif property.singular?
           # store singular association value
-          update_singular_association(property,send(property))
+          update_singular_association(property,send(property_name))
         else
           # Plural associations are not tracked.
           raise RodException.new("Invalid changed property #{self.class}##{property}'")
         end
       end
       # store plural associations in the DB
-      self.class.plural_associations.each do |property,options|
-        collection = send(property)
+      self.class.plural_associations.each do |property|
+        collection = send(property.name)
         offset = collection.save
         update_count_and_offset(property,collection.size,offset)
       end
@@ -112,9 +112,9 @@ module Rod
 
     # Default implementation of +inspect+.
     def inspect
-      fields = self.class.fields.map{|n,o| "#{n}:#{self.send(n)}"}.join(",")
-      singular = self.class.singular_associations.map{|n,o| "#{n}:#{self.send(n).class}"}.join(",")
-      plural = self.class.plural_associations.map{|n,o| "#{n}:#{self.send(n).size}"}.join(",")
+      fields = self.class.fields.map{|p| "#{p.name}:#{self.send(p.name)}"}.join(",")
+      singular = self.class.singular_associations.map{|p| "#{p.name}:#{self.send(p.name).class}"}.join(",")
+      plural = self.class.plural_associations.map{|p| "#{p.name}:#{self.send(p.name).size}"}.join(",")
       "#{self.class}:<#{fields}><#{singular}><#{plural}>"
     end
 
@@ -127,11 +127,9 @@ module Rod
     # has_one relationships values. This is required by ActiveModel::Dirty.
     def attributes
       result = {}
-      self.class.fields.each do |name,options|
-        result[name.to_s] = self.send(name)
-      end
-      self.class.singular_associations.each do |name,options|
-        result[name.to_s] = self.send(name)
+      self.class.properties.each do |property|
+        next if property.association? && property.plural?
+        result[property.name.to_s] = self.send(property.name)
       end
       result
     end
@@ -161,63 +159,40 @@ module Rod
     # Returns n-th (+index+) object of this class stored in the database.
     # This call is scope-checked.
     def self.[](index)
-      if index >= 0 && index < self.count
+      begin
         get(index+1)
-      else
-        raise IndexError.
-          new("The index #{index} is out of the scope [0...#{self.count}] for #{self}")
+      rescue IndexError
+        nil
       end
     end
 
     protected
     # Sets the default values for fields.
     def initialize_fields
-      self.class.fields.each do |name,options|
-        next if name == "rod_id"
-        value =
-          case options[:type]
-          when :integer
-            0
-          when :ulong
-            0
-          when :float
-            0.0
-          when :string
-            ''
-          when :object
-            nil
-          else
-            raise InvalidArgument.new(options[:type],"field type")
-          end
-        send("#{name}=",value)
+      self.class.fields.each do |field|
+        next if field.name == :rod_id
+        send("#{field.name}=",field.default_value)
       end
     end
 
     # A macro-style function used to indicate that given piece of data
-    # is stored in the database.
-    # Type should be one of:
-    # * +:integer+
-    # * +:ulong+
-    # * +:float+
-    # * +:string+
-    # * +:object+ (value is marshaled durign storage, and unmarshaled during read)
-    # Options:
-    # * +:index+ builds an index for the field and might be:
-    # ** +:flat+ simple hash index (+true+ works as well for backwards compatiblity)
-    # ** +:segmented+ index split for 1001 pieces for shorter load times (only
-    #   one piece is loaded on one look-up)
+    # is stored in the database. See Rod::Property::Field for valid
+    # types and options.
     #
     # Warning!
-    # rod_id is a predefined field
+    # :rod_id is a predefined field
     def self.field(name, type, options={})
-      ensure_valid_name(name)
-      ensure_valid_type(type)
-      self.fields[name] = options.merge({:type => type})
+      if self.property(name)
+        raise InvalidArgument.new(name,"doubled property name")
+      end
+      self.fields << Property::Field.new(self,name,type,options)
+      # clear cached properties
+      @properties = nil
     end
 
     # A macro-style function used to indicate that instances of this
     # class are associated with many instances of some other class. The
-    # name of the class is guessed from the field name, but you can
+    # name of the class is guessed from the property name, but you can
     # change it via options.
     # Options:
     # * +:class_name+ - the name of the class (as String) associated
@@ -225,22 +200,25 @@ module Rod
     # * +:polymorphic+ - if set to +true+ the association is polymorphic (allows to acess
     #   objects of different classes via this association)
     def self.has_many(name, options={})
-      ensure_valid_name(name)
-      self.plural_associations[name] = options
+      if self.property(name)
+        raise InvalidArgument.new(name,"doubled property name")
+      end
+      self.plural_associations << Property::PluralAssociation.new(self,name,options)
+      # clear cached properties
+      @properties = nil
     end
 
     # A macro-style function used to indicate that instances of this
     # class are associated with one instance of some other class. The
-    # name of the class is guessed from the field name, but you can
-    # change it via options.
-    # Options:
-    # * +:class_name+ - the name of the class (as String) associated
-    #   with this class
-    # * +:polymorphic+ - if set to +true+ the association is polymorphic (allows to acess
-    #   objects of different classes via this association)
+    # name of the class is guessed from the property name, but you can
+    # change it via options. See Rod::Property::SingularAssociation for details.
     def self.has_one(name, options={})
-      ensure_valid_name(name)
-      self.singular_associations[name] = options
+      if self.property(name)
+        raise InvalidArgument.new(name,"doubled property name")
+      end
+      self.singular_associations << Property::SingularAssociation.new(self,name,options)
+      # clear cached properties
+      @properties = nil
     end
 
     # A macro-style function used to link the model with specific
@@ -257,13 +235,13 @@ module Rod
     # Rebuild the index for given +property+. If the property
     # doesn't have an index, an exception is raised.
     def self.rebuild_index(property)
-      if properties[property][:index].nil?
-        raise RodException.new("Property '#{property}' doesn't have an index!")
+      if property.options[:index].nil?
+        raise RodException.new("Property '#{property.name}' doesn't have an index!")
       end
-      index = index_for(property,properties[property])
+      index = property.index
       index.destroy
       self.each.with_index do |object,position|
-        index[object.send(property)] << object
+        index[object.send(property.name)] << object
         report_progress(position,self.count) if $ROD_DEBUG
       end
     end
@@ -274,17 +252,17 @@ module Rod
 
     public
     # Update the DB information about the +object+ which
-    # is referenced via singular association with +name+.
+    # is referenced via singular association +property+.
     # If the object is not yet stored, a reference updater
     # is registered to update the DB when it is stored.
-    def update_singular_association(name, object)
+    def update_singular_association(property, object)
       if object.nil?
         rod_id = 0
       else
         if object.new?
           # There is a referenced object, but its rod_id is not set.
           object.reference_updaters << ReferenceUpdater.
-            for_singular(self,name,self.database)
+            for_singular(self,property,self.database)
           return
         else
           rod_id = object.rod_id
@@ -293,39 +271,28 @@ module Rod
         # WARNING: don't use writer, since we don't want this change to be tracked
         #object.instance_variable_set("@#{name}",nil)
       end
-      send("_#{name}=", @rod_id, rod_id)
-      if self.class.singular_associations[name][:polymorphic]
+      send("_#{property.name}=", @rod_id, rod_id)
+      if property.polymorphic?
         class_id = object.nil? ? 0 : object.class.name_hash
-        send("_#{name}__class=", @rod_id, class_id)
+        send("_#{property.name}__class=", @rod_id, class_id)
       end
     end
 
-    # Updates in the DB the +count+ and +offset+ of elements for +name+ association.
-    def update_count_and_offset(name,count,offset)
-      send("_#{name}_count=",@rod_id,count)
-      send("_#{name}_offset=",@rod_id,offset)
+    # Updates in the DB the +count+ and +offset+ of elements for +property+ association.
+    def update_count_and_offset(property,count,offset)
+      send("_#{property.name}_count=",@rod_id,count)
+      send("_#{property.name}_offset=",@rod_id,offset)
     end
 
-    # Updates in the DB the field +name+ to the actual value.
-    def update_field(name)
-      if self.class.string_field?(self.class.fields[name][:type])
-        if self.class.fields[name][:type] == :string
-          value = send(name)
-        elsif self.class.fields[name][:type] == :object
-          value = instance_variable_get("@#{name}")
-          value = Marshal.dump(value)
-        else
-          raise RodException.new("Unrecognised field type '#{self.class.fields[name][:type]}'!")
-        end
-        options = {}
-        if self.class.fields[name][:type] == :object
-          options[:skip_encoding] = true
-        end
-        length, offset = database.set_string(value,options)
-        send("_#{name}_length=",@rod_id,length)
-        send("_#{name}_offset=",@rod_id,offset)
+    # Updates in the DB the field +property+ to the actual value.
+    def update_field(property)
+      if property.variable_size?
+        value = property.dump(send(property.name))
+        length, offset = database.set_string(value)
+        send("_#{property.name}_length=",@rod_id,length)
+        send("_#{property.name}_offset=",@rod_id,offset)
       else
-        send("_#{name}=",@rod_id,send(name))
+        send("_#{property.name}=",@rod_id,send(property.name))
       end
     end
 
@@ -344,29 +311,28 @@ module Rod
       cache[object.rod_id] = object
 
       # update class indices
-      indexed_properties.each do |property,options|
+      indexed_properties.each do |property|
         # WARNING: singular and plural associations with nil as value are not indexed!
         # TODO #156 think over this constraint, write specs in persistence.feature
-        if field?(property) || singular_association?(property)
-          if stored_now || object.changes.has_key?(property)
+        if property.field? || property.singular?
+          if stored_now || object.changes.has_key?(property.name.to_s)
             unless stored_now
-              old_value = object.changes[property][0]
-              self.index_for(property,options)[old_value].delete(object)
+              old_value = object.changes[property.name.to_s][0]
+              property.index[old_value].delete(object)
             end
-            new_value = object.send(property)
-            if field?(property) || new_value
-              self.index_for(property,options)[new_value] << object
+            new_value = object.send(property.name)
+            if property.field? || new_value
+              property.index[new_value] << object
             end
           end
-        elsif plural_association?(property)
-          object.send(property).deleted.each do |deleted|
-            self.index_for(property,options)[deleted].delete(object) unless deleted.nil?
+        else
+          # plural
+          object.send(property.name).deleted.each do |deleted|
+            property.index[deleted].delete(object) unless deleted.nil?
           end
-          object.send(property).added.each do |added|
-            self.index_for(property,options)[added] << object unless added.nil?
+          object.send(property.name).added.each do |added|
+            property.index[added] << object unless added.nil?
           end
-        else
-          raise RodException.new("Unknown property type for #{self}##{property}")
         end
       end
     end
@@ -398,51 +364,45 @@ module Rod
     # Returns the fields of this class.
     def self.fields
       if self == Rod::Model
-        @fields ||= {"rod_id" => {:type => :ulong}}
+        @fields ||= [Property::Field.new(self,:rod_id,:ulong)]
       else
-        @fields ||= superclass.fields.dup
+        @fields ||= superclass.fields.map{|p| p.copy(self)}
       end
     end
 
     # Returns singular associations of this class.
     def self.singular_associations
       if self == Rod::Model
-        @singular_associations ||= {}
+        @singular_associations ||= []
       else
-        @singular_associations ||= superclass.singular_associations.dup
+        @singular_associations ||= superclass.singular_associations.map{|p| p.copy(self)}
       end
     end
 
     # Returns plural associations of this class.
     def self.plural_associations
       if self == Rod::Model
-        @plural_associations ||= {}
+        @plural_associations ||= []
       else
-        @plural_associations ||= superclass.plural_associations.dup
+        @plural_associations ||= superclass.plural_associations.map{|p| p.copy(self)}
       end
     end
 
     # Metadata for the model class.
     def self.metadata
       meta = super
-      # 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
+      {:fields => :fields,
+       :has_one => :singular_associations,
+       :has_many => :plural_associations}.each do |type,method|
+        # fields
+        metadata = {}
+        self.send(method).each do |property|
+          next if property.field? && property.identifier?
+          metadata[property.name] = property.metadata
+        end
+        unless metadata.empty?
+          meta[type] = metadata
+        end
       end
       meta
     end
@@ -456,12 +416,13 @@ module Rod
       namespace.const_set(class_name.split("::")[-1],klass)
       [:fields,:has_one,:has_many].each do |type|
         (metadata[type] || []).each do |name,options|
+          next if superclass.property(name)
           if type == :fields
-            internal_options = options[:options].dup
+            internal_options = options.dup
             field_type = internal_options.delete(:type)
             klass.send(:field,name,field_type,internal_options)
           else
-            klass.send(type,name,options[:options])
+            klass.send(type,name,options)
           end
         end
       end
@@ -482,9 +443,9 @@ module Rod
         new_path = new_class.path_for_data(database.path)
         puts "Copying #{backup_path} to #{new_path}" if $ROD_DEBUG
         FileUtils.cp(backup_path,new_path)
-        new_class.indexed_properties.each do |name,options|
-          backup_path = self.index_for(name,options).path
-          new_path = new_class.index_for(name,options).path
+        new_class.indexed_properties.each do |property|
+          backup_path = self.property(property.name).index.path
+          new_path = property.index.path
           puts "Copying #{backup_path} to #{new_path}" if $ROD_DEBUG
           FileUtils.cp(backup_path,new_path)
         end
@@ -494,9 +455,9 @@ module Rod
 
       puts "Migrating #{new_class}" if $ROD_DEBUG
       # Check for incompatible properties.
-      self.properties.each do |name,options|
-        next unless new_class.properties.keys.include?(name)
-        difference = options_difference(options,new_class.properties[name])
+      self.properties.each do |name,property|
+        next unless new_class.property(name)
+        difference = property.difference(new_class.properties[name])
         difference.delete(:index)
         # Check if there are some options which we cannot migrate at the
         # moment.
@@ -512,11 +473,13 @@ module Rod
       # initialize prototype objects
       old_object = self.new
       new_object = new_class.new
-      self.properties.each do |name,options|
-        next unless new_class.properties.keys.include?(name)
+      self.properties.each do |property|
+        # optimization
+        name = property.name.to_s
+        next unless new_class.property(name.to_sym)
         print "-  #{name}... " if $ROD_DEBUG
-        if self.field?(name)
-          if self.string_field?(options[:type])
+        if property.field?
+          if property.variable_size?
             self.count.times do |position|
               new_object.send("_#{name}_length=",position+1,
                               old_object.send("_#{name}_length",position+1))
@@ -531,13 +494,13 @@ module Rod
               report_progress(position,self.count) if $ROD_DEBUG
             end
           end
-        elsif self.singular_association?(name)
+        elsif property.singular?
           self.count.times do |position|
             new_object.send("_#{name}=",position + 1,
                             old_object.send("_#{name}",position + 1))
             report_progress(position,self.count) if $ROD_DEBUG
           end
-          if options[:polymorphic]
+          if property.polymorphic?
             self.count.times do |position|
               new_object.send("_#{name}__class=",position + 1,
                               old_object.send("_#{name}__class",position + 1))
@@ -556,48 +519,28 @@ module Rod
         puts " done" if $ROD_DEBUG
       end
       # Migrate the indices.
-      new_class.indexed_properties.each do |name,options|
+      new_class.indexed_properties.each do |property|
         # Migrate to new options.
-        old_index_type = self.properties[name] && self.properties[name][:index]
+        old_index_type = self.property(property.name) && self.property(property.name).options[:index]
         if old_index_type.nil?
-          print "-  building index #{options[:index]} for '#{name}'... " if $ROD_DEBUG
-          new_class.rebuild_index(name)
+          print "-  building index #{property.options[:index]} for '#{property.name}'... " if $ROD_DEBUG
+          new_class.rebuild_index(property)
           puts " done" if $ROD_DEBUG
-        elsif options[:index] == old_index_type
-          backup_path = self.index_for(name,options).path
-          new_path = new_class.index_for(name,options).path
+        elsif property.options[:index] == old_index_type
+          backup_path = self.property(property.name).index.path
+          new_path = property.index.path
           puts "Copying #{backup_path} to #{new_path}" if $ROD_DEBUG
           FileUtils.cp(backup_path,new_path)
         else
-          print "-  copying index #{options[:index]} for '#{name}'... " if $ROD_DEBUG
-          new_index = new_class.index_for(name,options)
-          old_index = index_for(name,self.properties[name])
+          print "-  copying #{property.options[:index]} index for '#{property.name}'... " if $ROD_DEBUG
+          new_index = property.index
+          old_index = self.property(property.name).index
           new_index.copy(old_index)
           puts " done" if $ROD_DEBUG
         end
       end
     end
 
-    # Returns the difference between +options1+ and +options2+.
-    def self.options_difference(options1,options2)
-      old_options = {}
-      options1.each{|k,v| old_options[k] = v.to_s.sub(LEGACY_RE,"")}
-      new_options = {}
-      options2.each{|k,v| new_options[k] = v.to_s}
-      differences = {}
-      old_options.each do |option,value|
-        if new_options[option] != value
-          differences[option] = [value,new_options[option]]
-        end
-      end
-      new_options.each do |option,value|
-        if old_options[option] != value && !differences.has_key?(option)
-          differences[option] = [old_options[option],value]
-        end
-      end
-      differences
-    end
-
     protected
     # The pointer to the mmaped table of C structs.
     def self.rod_pointer
@@ -667,20 +610,6 @@ module Rod
       self.class.database
     end
 
-    # Checks if the name of the field or association is valid.
-    def self.ensure_valid_name(name)
-      if name.to_s.empty? || INVALID_NAMES.has_key?(name)
-        raise InvalidArgument.new(name,"field/association name")
-      end
-    end
-
-    # Checks if the type of the field is valid.
-    def self.ensure_valid_type(type)
-      unless TYPE_MAPPING.has_key?(type)
-        raise InvalidArgument.new(type,"field type")
-      end
-    end
-
     # Returns the database this class is linked to.
     # The database class is configured with the call to
     # macro-style function +database_class+. This information
@@ -697,7 +626,6 @@ module Rod
     end
 
     # The object cache of this class.
-    # XXX consider moving it to the database.
     def self.cache
       @cache ||= Cache.new
     end
@@ -769,49 +697,12 @@ module Rod
       "#{relative_path}#{model_path}.dat"
     end
 
-    # The name of the file or directory (for given +relative_path+), which the
-    # index of the +field+ of this class is stored in.
-    def self.path_for_index(relative_path,field)
-      "#{relative_path}#{model_path}_#{field}"
-    end
-
-    # Returns true if the type of the filed is string-like (i.e. stored as
-    # StringElement).
-    def self.string_field?(type)
-      string_types.include?(type)
-    end
-
-    # Types which are stored as strings.
-    def self.string_types
-      [:string, :object]
-    end
-
     # The C structure representing this class.
     def self.typedef_struct
       result = <<-END
       |typedef struct {
-      |  \n#{self.fields.map do |field,options|
-        unless string_field?(options[:type])
-          "|  #{TYPE_MAPPING[options[:type]]} #{field};"
-        else
-          <<-SUBEND
-          |  unsigned long #{field}_length;
-          |  unsigned long #{field}_offset;
-          SUBEND
-        end
-      end.join("\n|  \n") }
-      |  #{singular_associations.map do |name, options|
-        result = "unsigned long #{name};"
-        if options[:polymorphic]
-          result += "  unsigned long #{name}__class;"
-        end
-        result
-      end.join("\n|  ")}
-      |  \n#{plural_associations.map do |name, options|
-        result =
-          "|  unsigned long #{name}_offset;\n"+
-          "|  unsigned long #{name}_count;"
-        result
+      |  \n#{self.properties.map do |property|
+        property.to_c_struct
       end.join("\n|  \n")}
       |} #{struct_name()};
       END
@@ -820,62 +711,11 @@ module Rod
 
     # Prints the memory layout of the structure.
     def self.layout
-      result = <<-END
-      |  \n#{self.fields.map do |field,options|
-          unless string_field?(options[:type])
-            "|  printf(\"  size of '#{field}': %lu\\n\"," +
-              "(unsigned long)sizeof(#{TYPE_MAPPING[options[:type]]}));"
-          else
-            <<-SUBEND
-            |  printf("  string '#{field}' length: %lu offset: %lu page: %lu\\n",
-            |    (unsigned long)sizeof(unsigned long), (unsigned long)sizeof(unsigned long),
-            |    (unsigned long)sizeof(unsigned long));
-            SUBEND
-          end
-        end.join("\n") }
-        |  \n#{singular_associations.map do |name, options|
-          "  printf(\"  singular assoc '#{name}': %lu\\n\","+
-          "(unsigned long)sizeof(unsigned long));"
-        end.join("\n|  ")}
-        |  \n#{plural_associations.map do |name, options|
-       "|  printf(\"  plural assoc '#{name}' offset: %lu, count %lu\\n\",\n"+
-       "|    (unsigned long)sizeof(unsigned long),(unsigned long)sizeof(unsigned long));"
-        end.join("\n|  \n")}
-      END
-      result.margin
+      self.properties.map do |property|
+        property.layout
+      end.join("\n")
     end
 
-    # Reads the value of a specified field of the C-structure.
-    def self.field_reader(name,result_type,builder)
-      str =<<-END
-      |#{result_type} _#{name}(unsigned long object_rod_id){
-      |  if(object_rod_id == 0){
-      |    rb_raise(rodException(), "Invalid object rod_id (0)");
-      |  }
-      |  VALUE klass = rb_funcall(self,rb_intern("class"),0);
-      |  #{struct_name} * pointer = (#{struct_name} *)
-      |    NUM2ULONG(rb_funcall(klass,rb_intern("rod_pointer"),0));
-      |  return (pointer + object_rod_id - 1)->#{name};
-      |}
-      END
-      builder.c(str.margin)
-    end
-
-    # Writes the value of a specified field of the C-structure.
-    def self.field_writer(name,arg_type,builder)
-      str =<<-END
-      |void _#{name}_equals(unsigned long object_rod_id,#{arg_type} value){
-      |  if(object_rod_id == 0){
-      |    rb_raise(rodException(), "Invalid object rod_id (0)");
-      |  }
-      |  VALUE klass = rb_funcall(self,rb_intern("class"),0);
-      |  #{struct_name} * pointer = (#{struct_name} *)
-      |    NUM2ULONG(rb_funcall(klass,rb_intern("rod_pointer"),0));
-      |  (pointer + object_rod_id - 1)->#{name} = value;
-      |}
-      END
-      builder.c(str.margin)
-    end
 
     #########################################################################
     # Generated methods
@@ -883,14 +723,15 @@ module Rod
 
     # This code intializes the class. It adds C routines and dynamic Ruby accessors.
     def self.build_structure
-      self.fields.each do |name, options|
-        if options[:index]
-          instance_variable_set("@#{name}_index",nil)
-        end
+      self.indexed_properties.each do |property|
+        property.reset_index
       end
       return if @structure_built
 
       inline(:C) do |builder|
+        builder.include '<byteswap.h>'
+        builder.include '<endian.h>'
+        builder.include '<stdint.h>'
         builder.prefix(typedef_struct)
         builder.prefix(Database.rod_exception)
         if Database.development_mode
@@ -899,32 +740,8 @@ module Rod
           builder.c_singleton("void __unused_method_#{rand(1000000)}(){}")
         end
 
-        self.fields.each do |name, options|
-          unless string_field?(options[:type])
-            field_reader(name,TYPE_MAPPING[options[:type]],builder)
-            field_writer(name,TYPE_MAPPING[options[:type]],builder)
-          else
-            field_reader("#{name}_length","unsigned long",builder)
-            field_reader("#{name}_offset","unsigned long",builder)
-            field_writer("#{name}_length","unsigned long",builder)
-            field_writer("#{name}_offset","unsigned long",builder)
-          end
-        end
-
-        singular_associations.each do |name, options|
-          field_reader(name,"unsigned long",builder)
-          field_writer(name,"unsigned long",builder)
-          if options[:polymorphic]
-            field_reader("#{name}__class","unsigned long",builder)
-            field_writer("#{name}__class","unsigned long",builder)
-          end
-        end
-
-        plural_associations.each do |name, options|
-          field_reader("#{name}_count","unsigned long",builder)
-          field_reader("#{name}_offset","unsigned long",builder)
-          field_writer("#{name}_count","unsigned long",builder)
-          field_writer("#{name}_offset","unsigned long",builder)
+        self.properties.each do |property|
+          property.define_c_accessors(builder)
         end
 
         str=<<-END
@@ -946,246 +763,52 @@ module Rod
 
       attribute_methods = []
       ## accessors for fields, plural and singular relationships follow
-      self.fields.each do |field, options|
-        attribute_methods << field
-        # optimization
-        field = field.to_s
-        # adding new private fields visible from Ruby
-        # they are lazily initialized based on the C representation
-        unless string_field?(options[:type])
-          private "_#{field}", "_#{field}="
-        else
-          private "_#{field}_length", "_#{field}_offset"
-        end
-
-        unless string_field?(options[:type])
-          # getter
-          define_method(field) do
-            value = instance_variable_get("@#{field}")
-            if value.nil?
-              if self.new?
-                value = nil
-              else
-                value = send("_#{field}",@rod_id)
-              end
-              instance_variable_set("@#{field}",value)
-            end
-            value
-          end
-
-          # setter
-          define_method("#{field}=") do |value|
-            old_value = send(field)
-            send("#{field}_will_change!") unless old_value == value
-            instance_variable_set("@#{field}",value)
-            value
-          end
-        else
-          # string-type fields
-          # getter
-          define_method(field) do
-            value = instance_variable_get("@#{field}")
-            if value.nil? # first call
-              if self.new?
-                return (options[:type] == :object ? nil : "")
-              else
-                length = send("_#{field}_length", @rod_id)
-                if length == 0
-                  return (options[:type] == :object ? nil : "")
-                end
-                offset = send("_#{field}_offset", @rod_id)
-                read_options = {}
-                if options[:type] == :object
-                  read_options[:skip_encoding] = true
-                end
-                value = database.read_string(length, offset, options)
-                if options[:type] == :object
-                  value = Marshal.load(value) rescue nil
-                end
-                # caching Ruby representation
-                # don't use writer - avoid change tracking
-                instance_variable_set("@#{field}",value)
-              end
-            end
-            value
-          end
-
-          # setter
-          define_method("#{field}=") do |value|
-            old_value = send(field)
-            send("#{field}_will_change!") unless old_value == value
-            instance_variable_set("@#{field}",value)
-          end
-        end
-
-      end
-
-      singular_associations.each do |name, options|
-        attribute_methods << name
-        # optimization
-        name = name.to_s
-        private "_#{name}", "_#{name}="
-        class_name =
-          if options[:class_name]
-            options[:class_name]
-          else
-            "#{self.scope_name}::#{name.camelcase}"
-          end
-
-        #getter
-        define_method(name) do
-          value = instance_variable_get("@#{name}")
-          if value.nil?
-            return nil if self.new?
-            rod_id = send("_#{name}",@rod_id)
-            # the indices are shifted by 1, to leave 0 for nil
-            if rod_id == 0
-              value = nil
-            else
-              if options[:polymorphic]
-                klass = Model.get_class(send("_#{name}__class",@rod_id))
-                value = klass.find_by_rod_id(rod_id)
-              else
-                value = class_name.constantize.find_by_rod_id(rod_id)
-              end
-            end
-            # avoid change tracking
-            instance_variable_set("@#{name}",value)
-          end
-          value
-        end
-
-        #setter
-        define_method("#{name}=") do |value|
-          old_value = send(name)
-          send("#{name}_will_change!") unless old_value == value
-          instance_variable_set("@#{name}", value)
-        end
-      end
-
-      plural_associations.each do |name, options|
-        # optimization
-        name = name.to_s
-        class_name =
-          if options[:class_name]
-            options[:class_name]
-          else
-            "#{self.scope_name}::#{::English::Inflect.singular(name).camelcase}"
-          end
-        klass = options[:polymorphic] ? nil : class_name.constantize
-
-        # getter
-        define_method("#{name}") do
-          proxy = instance_variable_get("@#{name}")
-          if proxy.nil?
-            if self.new?
-              count = 0
-              offset = 0
-            else
-              count = self.send("_#{name}_count",@rod_id)
-              offset = self.send("_#{name}_offset",@rod_id)
-            end
-            proxy = CollectionProxy.new(count,database,offset,klass)
-            instance_variable_set("@#{name}", proxy)
-          end
-          proxy
-        end
-
-        # count getter
-        define_method("#{name}_count") do
-          if (instance_variable_get("@#{name}") != nil)
-            return instance_variable_get("@#{name}").count
-          else
-            if self.new?
-              return 0
-            else
-              return send("_#{name}_count",@rod_id)
-            end
-          end
-        end
-
-        # setter
-        define_method("#{name}=") do |value|
-          proxy = send(name)
-          proxy.clear
-          value.each do |object|
-            proxy << object
-          end
-          proxy
+      properties.each do |property|
+        if property.field? || property.singular?
+          attribute_methods << property.name
         end
+        property.seal_c_accessors
+        property.define_getter
+        property.define_setter
+        property.define_finders
       end
 
       # dirty tracking
       define_attribute_methods(attribute_methods)
 
-      # indices
-      indexed_properties.each do |property,options|
-        # optimization
-        property = property.to_s
-        (class << self; self; end).class_eval do
-          # Find all objects with given +value+ of the +property+.
-          define_method("find_all_by_#{property}") do |value|
-            index_for(property,options)[value]
-          end
-
-          # Find first object with given +value+ of the +property+.
-          define_method("find_by_#{property}") do |value|
-            index_for(property,options)[value][0]
-          end
-        end
-      end
       @structure_built = true
     end
 
     class << self
       # Fields, singular and plural associations.
       def properties
-        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)
+        @properties ||= self.fields + self.singular_associations + self.plural_associations
       end
 
-      # Returns true if the +name+ (as symbol) is a name of a singular association.
-      def singular_association?(name)
-        self.singular_associations.keys.include?(name)
+      # Returns the property with given +name+ or nil if it doesn't exist.
+      def property(name)
+        properties.find{|p| p.name == name}
       end
 
-      # Returns true if the +name+ (as symbol) is a name of a plural association.
-      def plural_association?(name)
-        self.plural_associations.keys.include?(name)
-      end
-
-      # Read index for the +property+ with +options+ from the database.
-      def index_for(property,options)
-        index = instance_variable_get("@#{property}_index")
-        if index.nil?
-          path = path_for_index(database.path,property)
-          index = Index::Base.create(path,self,options)
-          instance_variable_set("@#{property}_index",index)
-        end
-        index
+      # Returns (and caches) only properties which are indexed.
+      def indexed_properties
+        @indexed_properties ||= self.properties.select{|p| p.options[:index]}
       end
 
       private
       # Returns object of this class stored in the DB with given +rod_id+.
-      # Warning! If wrong rod_id is specified it might cause segmentation fault exception!
+      # Warning! If wrong rod_id is specified it might cause segmentation fault error!
       def get(rod_id)
         object = cache[rod_id]
         if object.nil?
+          if rod_id <= 0 || rod_id > self.count
+            raise IndexError.new("Invalid rod_id #{rod_id} for #{self}")
+          end
           object = self.new(rod_id)
           cache[rod_id] = object
         end
         object
       end
-
     end
   end
 end