rod 0.7.1 → 0.7.2

data/lib/rod/collection_proxy.rb

@@ -43,16 +43,91 @@ module Rod
       end
     end
 
+    # Returns the size of intersection with the other collection proxy.
+    # XXX this method assumes that the elements are sorted according to rod_id,
+    # the collection is not polymorphic and no elements were added nor deleted.
+    def intersection_size(other)
+      @database.fast_intersection_size(self.offset,self.size,other.offset,other.size)
+    end
+
+    # Computes a union with the +other+ collection proxy.
+    def |(other)
+      # So far this optimization works only for monomorphic
+      # collection proxies without added elements.
+      if @klass && @added.empty?
+        my_ids = self.size.times.map do |index|
+          id_for(index)
+        end.sort
+        other_ids = other.size.times.map do |index|
+          other.id_for(index)
+        end.sort
+        ids = []
+        last_id = nil
+        while(!my_ids.empty?) do
+          id = my_ids.shift
+          other_ids.shift if other_ids.first == id
+          ids << id unless last_id == id
+          last_id = id
+        end
+        while(!other_ids.empty?) do
+          id = other_ids.shift
+          ids << id unless last_id == id
+          last_id = id
+        end
+        result = CollectionProxy.new(0,@database,0,@klass)
+        ids.each{|id| result << [id,@klass]}
+      else
+        result = self.to_a | other.to_a
+      end
+      result
+    end
+
+    # Computes an intersection with the +other+ collection proxy.
+    def &(other)
+      # So far this optimization works only for monomorphic
+      # collection proxies without added elements.
+      if @klass && @added.empty?
+        my_ids = self.size.times.map do |index|
+          id_for(index)
+        end.sort
+        other_ids = other.size.times.map do |index|
+          other.id_for(index)
+        end.sort
+        ids = []
+        last_id = nil
+        while(!my_ids.empty?) do
+          if my_ids.first == other_ids.first
+            id = my_ids.shift
+            other_ids.shift
+            ids << id unless last_id == id
+            last_id = id
+          elsif my_ids.first < other_ids.first
+            my_ids.shift
+          else
+            other_ids.shift
+          end
+        end
+        result = CollectionProxy.new(0,@database,0,@klass)
+        ids.each{|id| result << [id,@klass]}
+      else
+        result = self.to_a & other.to_a
+      end
+      result
+    end
+
     # Appends element to the end of the collection.
     def <<(element)
       if element.nil?
         pair = [0,NilClass]
-      else
+      elsif element.is_a?(Model)
         if element.new?
           pair = [element,element.class]
         else
           pair = [element.rod_id,element.class]
         end
+      else
+        # Assume we have an array with direct values of rod_id and class.
+        pair = element
       end
       index = @size
       @map[index] = @added.size

data/lib/rod/constants.rb

@@ -1,5 +1,5 @@
 module Rod
-  VERSION = "0.7.1"
+  VERSION = "0.7.2"
 
   # The name of file containing the data base.
   DATABASE_FILE = "database.yml"
@@ -12,7 +12,8 @@ module Rod
     :integer => 'long',
     :float => 'double',
     :ulong => 'unsigned long',
-    :object => 'char *'
+    :object => 'char *',
+    :json => 'char *'
   }
 
   RUBY_TO_C_MAPPING = {

data/lib/rod/database.rb

@@ -49,7 +49,7 @@ module Rod
       |    strcpy(path,model_p->path);
       |    strcat(path,"#{klass.path_for_data("")}");
       |    model_p->#{klass.struct_name}_lib_file =
-      |      open(path, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+      |      open(path, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
       |    if(model_p->#{klass.struct_name}_lib_file == -1) {
       |      rb_raise(rodException(),"Could not open file for class #{klass} on path %s writing.",path);
       |    }
@@ -92,11 +92,10 @@ module Rod
       |
       |  // exted the file
       |
-      |  // increase the pages count by 1
+      |  // increase the pages count by numer of pages allocated at-once
       |  model_p->#{klass.struct_name}_page_count += ALLOCATED_PAGES;
       |  {
       |    // open the file for writing
-      |    char* #{klass.struct_name}_empty_data;
       |    FILE * #{klass.struct_name}_file =
       |      fdopen(model_p->#{klass.struct_name}_lib_file,"w+");
       |    if(#{klass.struct_name}_file == NULL){
@@ -107,11 +106,11 @@ module Rod
       |      rb_raise(rodException(),"Could not seek to end file for #{klass.struct_name}.");
       |    }
       |    // write empty data at the end
-      |    #{klass.struct_name}_empty_data = calloc(page_size() * ALLOCATED_PAGES,1);
-      |    if(write(model_p->#{klass.struct_name}_lib_file,#{klass.struct_name}_empty_data,
+      |    if(write(model_p->#{klass.struct_name}_lib_file,model_p->empty_data,
       |      page_size() * ALLOCATED_PAGES) == -1){
       |      rb_raise(rodException(),"Could not write to file for #{klass.struct_name}.");
       |    }
+      |
       |    // seek to the beginning
       |    if(fseek(#{klass.struct_name}_file,0,SEEK_SET) == -1){
       |      rb_raise(rodException(),"Could not seek to start file for #{klass.struct_name}.");
@@ -167,6 +166,10 @@ module Rod
           builder.include '<unistd.h>'
           builder.include '<errno.h>'
           builder.include '<sys/mman.h>'
+          builder.include '<sys/stat.h>'
+          builder.include '<byteswap.h>'
+          builder.include '<endian.h>'
+          builder.include '<stdint.h>'
           classes.each do |klass|
             builder.prefix(klass.typedef_struct)
           end
@@ -198,19 +201,51 @@ module Rod
             end.join("\n|\n")}
             |  // the path to the DB
             |  char * path;
+            |  // chunk written to extend file
+            |  char * empty_data;
             |
             |} #{model_struct};
           END
           builder.prefix(str.margin)
 
+          str =<<-END
+          |// Deallocates the model struct.
+          |void model_struct_free(#{model_struct} * model_p){
+          |  if(model_p != NULL){
+          |    if(model_p->path != NULL){
+          |      // TODO causes segfault
+          |      //printf("GC %lu %lu\\n",(unsigned long)model_p,
+          |      // (unsigned long)model_p->path);
+          |      //free(model_p->path);
+          |      model_p->path = NULL;
+          |    }
+          |    if(model_p->empty_data != NULL){
+          |      //free(model_p->empty_data);
+          |      model_p->empty_data = NULL;
+          |    }
+          |  }
+          |  free(model_p);
+          |}
+          END
+          builder.prefix(str.margin)
+
+
           #########################################
           # Join indices
           #########################################
           str =<<-END
           |VALUE _join_element_index(unsigned long element_offset, unsigned long element_index, VALUE handler){
           |  #{model_struct} * model_p;
+          |  unsigned long result;
+          |
           |  Data_Get_Struct(handler,#{model_struct},model_p);
-          |  return ULONG2NUM((model_p->_join_element_table + element_offset + element_index)->offset);
+          |  result = (model_p->_join_element_table + element_offset + element_index)->offset;
+          |#ifdef __BYTE_ORDER
+          |#  if __BYTE_ORDER == __BIG_ENDIAN
+          |  result = bswap_64(result);
+          |#  endif
+          |#endif
+          |  return ULONG2NUM(result);
           |}
           END
           builder.c(str.margin)
@@ -219,9 +254,17 @@ module Rod
           |VALUE _polymorphic_join_element_index(unsigned long element_offset,
           |  unsigned long element_index, VALUE handler){
           |  #{model_struct} * model_p;
+          |  unsigned long result;
+          |
           |  Data_Get_Struct(handler,#{model_struct},model_p);
-          |  return ULONG2NUM((model_p->_polymorphic_join_element_table +
-          |    element_offset + element_index)->offset);
+          |  result = (model_p->_polymorphic_join_element_table +
+          |    element_offset + element_index)->offset;
+          |#ifdef __BYTE_ORDER
+          |#  if __BYTE_ORDER == __BIG_ENDIAN
+          |  result = bswap_64(result);
+          |#  endif
+          |#endif
+          |  return ULONG2NUM(result);
           |}
           END
           builder.c(str.margin)
@@ -230,9 +273,17 @@ module Rod
           |VALUE _polymorphic_join_element_class(unsigned long element_offset,
           |  unsigned long element_index, VALUE handler){
           |  #{model_struct} * model_p;
+          |  unsigned long result;
+          |
           |  Data_Get_Struct(handler,#{model_struct},model_p);
-          |  return ULONG2NUM((model_p->_polymorphic_join_element_table +
-          |    element_offset + element_index)->class);
+          |  result = (model_p->_polymorphic_join_element_table +
+          |    element_offset + element_index)->class;
+          |#ifdef __BYTE_ORDER
+          |#  if __BYTE_ORDER == __BIG_ENDIAN
+          |  result = bswap_64(result);
+          |#  endif
+          |#endif
+          |  return ULONG2NUM(result);
           |}
           END
           builder.c(str.margin)
@@ -243,12 +294,18 @@ module Rod
           |  VALUE handler){
           |  #{model_struct} * model_p;
           |  _join_element * element_p;
+          |
           |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  element_p = model_p->_join_element_table + element_offset + element_index;
           |  if(element_p->index != element_index){
           |      rb_raise(rodException(), "Join element indices are inconsistent: %lu %lu!",
           |        element_index, element_p->index);
           |  }
+          |#ifdef __BYTE_ORDER
+          |#  if __BYTE_ORDER == __BIG_ENDIAN
+          |  offset = bswap_64(offset);
+          |#  endif
+          |#endif
           |  element_p->offset = offset;
           |}
           END
@@ -260,12 +317,19 @@ module Rod
           |  VALUE handler){
           |  #{model_struct} * model_p;
           |  _polymorphic_join_element * element_p;
+          |
           |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  element_p = model_p->_polymorphic_join_element_table + element_offset + element_index;
           |  if(element_p->index != element_index){
           |      rb_raise(rodException(), "Polymorphic join element indices are inconsistent: %lu %lu!",
           |        element_index, element_p->index);
           |  }
+          |#ifdef __BYTE_ORDER
+          |#  if __BYTE_ORDER == __BIG_ENDIAN
+          |  offset = bswap_64(offset);
+          |  class_id = bswap_64(class_id);
+          |#  endif
+          |#endif
           |  element_p->offset = offset;
           |  element_p->class = class_id;
           |}
@@ -278,6 +342,7 @@ module Rod
           |  unsigned long index;
           |  #{model_struct} * model_p;
           |  unsigned long result;
+          |
           |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  result = model_p->_join_element_count;
           |  for(index = 0; index < size; index++){
@@ -301,6 +366,7 @@ module Rod
           |  unsigned long index;
           |  #{model_struct} * model_p;
           |  unsigned long result;
+          |
           |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  result = model_p->_polymorphic_join_element_count;
           |  for(index = 0; index < size; index++){
@@ -321,6 +387,40 @@ module Rod
           END
           builder.c(str.margin)
 
+          str =<<-END
+          |VALUE _fast_intersection_size(unsigned long first_offset,
+          |  unsigned long first_length, unsigned long second_offset,
+          |  unsigned long second_length, VALUE handler){
+          |  unsigned long i,j,count,v1,v2;
+          |  #{model_struct} * model_p;
+          |
+          |  i = 0; j = 0; count = 0;
+          |  Data_Get_Struct(handler,#{model_struct},model_p);
+          |
+          |  while(i < first_length && j < second_length){
+          |    v1 = (model_p->_join_element_table + first_offset + i)->offset;
+          |    v2 = (model_p->_join_element_table + second_offset + j)->offset;
+          |#ifdef __BYTE_ORDER
+          |#  if __BYTE_ORDER == __BIG_ENDIAN
+          |    v1 = bswap_64(v1);
+          |    v2 = bswap_64(v2);
+          |#  endif
+          |#endif
+          |    if(v1 < v2){
+          |      i++;
+          |    } else {
+          |      if(v1 > v2){
+          |        j++;
+          |      } else {
+          |        i++; j++; count++;
+          |      }
+          |    }
+          |  }
+          |  return ULONG2NUM(count);
+          |}
+          END
+          builder.c(str.margin)
+
           #########################################
           # Strings
           #########################################
@@ -328,6 +428,7 @@ module Rod
           |VALUE _read_string(unsigned long length, unsigned long offset, VALUE handler){
           |  #{model_struct} * model_p;
           |  char * str;
+          |
           |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  str = model_p->#{StringElement.struct_name}_table + offset;
           |  return rb_str_new(str, length);
@@ -353,6 +454,7 @@ module Rod
           |  long length_left = length;
           |  // see the routine description above.
           |  VALUE result;
+          |
           |  // get the structure
           |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  // first free byte in current page
@@ -407,9 +509,9 @@ module Rod
             str =<<-END
             |// Store the object in the database.
             |void _store_#{klass.struct_name}(VALUE object, VALUE handler){
-            |
             |  #{model_struct} * model_p;
             |  #{klass.struct_name} * struct_p;
+            |
             |  Data_Get_Struct(handler,#{model_struct},model_p);
             |  if((model_p->#{klass.struct_name}_count+1) * sizeof(#{klass.struct_name}) >=
             |    model_p->#{klass.struct_name}_page_count * page_size()){
@@ -436,17 +538,22 @@ module Rod
           |VALUE _init_handler(char * dir_path){
           |  #{model_struct} * model_p;
           |  VALUE cClass;
-          |  model_p = ALLOC(#{model_struct});
           |
+          |  model_p = ALLOC(#{model_struct});
           |  #{init_structs(classes)}
           |
           |  // set dir path
           |  model_p->path = malloc(sizeof(char)*(strlen(dir_path)+1));
           |  strcpy(model_p->path,dir_path);
           |
+          |  // initialize empty data written when extending file
+          |  model_p->empty_data = calloc(page_size() * ALLOCATED_PAGES,1);
+          |
           |  //create the wrapping object
           |  cClass = rb_define_class("#{model_struct_name(path).camelcase(true)}",
           |    rb_cObject);
+          |  // TODO #225
+          |  //return Data_Wrap_Struct(cClass, 0, model_struct_free, model_p);
           |  return Data_Wrap_Struct(cClass, 0, free, model_p);
           |}
           END
@@ -472,6 +579,7 @@ module Rod
           str =<<-END
           |void _open(VALUE handler){
           |  #{model_struct} * model_p;
+          |
           |  Data_Get_Struct(handler,#{model_struct},model_p);
           |
           |  \n#{classes.map do |klass|
@@ -502,6 +610,7 @@ module Rod
           |// if +classes+ are Qnil, the DB was open in readonly mode.
           |void _close(VALUE handler){
           |  #{model_struct} * model_p;
+          |
           |  Data_Get_Struct(handler,#{model_struct},model_p);
           |
           |  \n#{classes.map do |klass|
@@ -528,13 +637,13 @@ module Rod
           str = <<-END
           |void _print_layout(VALUE handler){
           |  #{model_struct} * model_p;
+          |
           |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  printf("============= Data layout START =============\\n");
           |  \n#{classes.map do |klass|
                str =<<-SUBEND
           |  printf("-- #{klass} --\\n");
           |  printf("Size of #{klass.struct_name} %lu\\n",(unsigned long)sizeof(#{klass.struct_name}));
-          |  \n#{klass.layout}
           |  printf("Page count: %lu, count %lu, pointer: %lx\\n",
           |    model_p->#{klass.struct_name}_page_count,
           |    model_p->#{klass.struct_name}_count,
@@ -580,6 +689,7 @@ module Rod
       str =<<-END
       |#{result_type} _#{name}(VALUE handler){
       |  #{model_struct} * model_p;
+      |
       |  Data_Get_Struct(handler,#{model_struct},model_p);
       |  return model_p->#{name};
       |}
@@ -592,6 +702,7 @@ module Rod
       str =<<-END
       |void _#{name}_equals(VALUE handler,#{arg_type} value){
       |  #{model_struct} * model_p;
+      |
       |  Data_Get_Struct(handler,#{model_struct},model_p);
       |  model_p->#{name} = value;
       |}
@@ -602,7 +713,9 @@ module Rod
     def self.rod_exception
       str =<<-END
       |VALUE rodException(){
-      |  VALUE klass = rb_const_get(rb_cObject, rb_intern("Rod"));
+      |  VALUE klass;
+      |
+      |  klass = rb_const_get(rb_cObject, rb_intern("Rod"));
       |  klass = rb_const_get(klass, rb_intern("DatabaseError"));
       |  return klass;
       |}

data/lib/rod/index/base.rb

@@ -42,9 +42,9 @@ module Rod
           proxy = get(key)
         end
         if proxy.nil?
-          proxy = CollectionProxy.new(0,@klass.database,0,@klass)
+          proxy = empty_collection_proxy(key)
         else
-          unless proxy.is_a?(CollectionProxy)
+          if Array === proxy
             offset, count = proxy
             proxy = CollectionProxy.new(count,@klass.database,offset,@klass)
           end
@@ -61,6 +61,7 @@ module Rod
       # Copies the values from +index+ to this index.
       def copy(index)
         index.each.with_index do |key_value,position|
+          # TODO #206 this doesn't work for hash
           self.set(key_value[0],key_value[1])
           # TODO #182 implement size for index
           # report_progress(position,index.size) if $ROD_DEBUG
@@ -85,6 +86,14 @@ module Rod
         "#{self.class}@#{@path}"
       end
 
+      protected
+
+      # Returns an empty collection proxy. Might be changed
+      # in subclasses to provie index-specific collection proxies.
+      def empty_collection_proxy(key)
+        CollectionProxy.new(0,@klass.database,0,@klass)
+      end
+
       class << self
         # Creats the proper instance of Index or one of its sublcasses.
         # The +path+ is the path were the index is stored, while +index+ is the previous index instance.
@@ -105,7 +114,7 @@ module Rod
               warn("Index type 'true' is deprecated. It will be removed in ROD 0.8.0")
             FlatIndex.new(path,klass,options)
           else
-            raise RodException.new("Invalid index type #{type}")
+            raise RodException.new("Invalid index type '#{type}'")
           end
         end
       end