mongoose 0.1.0

data/lib/mongoose/database.rb

@@ -0,0 +1,113 @@
+module Mongoose
+
+#-------------------------------------------------------------------------------
+# Database class
+#-------------------------------------------------------------------------------
+class Database
+  attr_reader :path, :tables
+
+  #-----------------------------------------------------------------------------
+  # initialize
+  #-----------------------------------------------------------------------------
+  def initialize(params={})
+    @path = params[:path] || './'  
+
+    Table.db = self
+
+    @tables = {}
+
+    Dir.foreach(@path) do |filename|
+      next unless File.extname(filename) == TBL_HDR_EXT
+
+      table_name = File.basename(filename, ".*").to_sym
+      init_table(table_name)
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # close
+  #-----------------------------------------------------------------------------
+  def close
+    @tables.each_key { |tbl_class| tbl_class.close }
+  end
+
+  #-----------------------------------------------------------------------------
+  # create_table
+  #-----------------------------------------------------------------------------
+  def create_table(table_name)
+    raise "Table already exists!" if table_exists?(table_name)
+
+    class_name = get_class_name_from_table_name(table_name)
+
+    tbl_header = {}
+    tbl_header[:table_name] = table_name
+    tbl_header[:class_name] = class_name
+    tbl_header[:last_id_used] = 0
+    tbl_header[:deleted_recs_counter] = 0
+    tbl_header[:columns] = []
+    tbl_header[:columns] << { :name => :id, :data_type => :integer, 
+                          :class => IDColumn.to_s }
+
+    File.open(File.join(@path, table_name.to_s + TBL_HDR_EXT), 'w') do |f|
+      YAML.dump(tbl_header, f)
+    end
+
+    fptr = File.open(File.join(@path, table_name.to_s + TBL_EXT), 'w')
+    fptr.close
+
+    init_table(table_name)
+
+    yield Object.const_get(class_name) if block_given?
+  end
+
+  #-----------------------------------------------------------------------------
+  # drop_table
+  #-----------------------------------------------------------------------------
+  def drop_table(table_name)
+    class_name = get_class_name_from_table_name(table_name)
+
+    @tables[Object.const_get(class_name)][:columns].each do |c|
+      if c.indexed?
+        File.delete(c.index_file_name) if File.exists?(c.index_file_name)
+      end
+    end
+
+    File.delete(File.join(@path, table_name.to_s + TBL_HDR_EXT))
+    File.delete(File.join(@path, table_name.to_s + TBL_EXT)) if \
+     File.exists?(File.join(@path, table_name.to_s + TBL_EXT))
+    
+    @tables.delete(Object.const_get(class_name))
+  end
+
+  #-----------------------------------------------------------------------------
+  # table_exists?
+  #-----------------------------------------------------------------------------
+  def table_exists?(table_name)
+    return File.exists?(File.join(@path, table_name.to_s + TBL_HDR_EXT))
+  end
+
+  private
+
+  #-----------------------------------------------------------------------------
+  # init_table
+  #-----------------------------------------------------------------------------
+  def init_table(table_name)
+    class_name = get_class_name_from_table_name(table_name)
+
+    @tables[Object.full_const_get(class_name)] = { :class_name => class_name, 
+     :table_name => table_name, :columns => [], :query => [], 
+     :last_id_used => nil, :deleted_recs_counter => nil }
+
+    Object.full_const_get(class_name).init_table
+  end
+
+  #-----------------------------------------------------------------------------
+  # get_class_name_from_table_name
+  #-----------------------------------------------------------------------------
+  def get_class_name_from_table_name(table_name)
+    return table_name.to_s.split('_').inject('') { |full_name, word|
+     full_name + word.capitalize }
+  end
+end
+
+end

data/lib/mongoose/linear_search.rb

@@ -0,0 +1,114 @@
+module Mongoose
+
+class LinearSearch
+  def initialize(col)
+    @col = col
+  end
+
+  def search_table(&search)
+    col_index = nil
+    @col.tbl_class.columns.each_with_index do |c,i| 
+      if c.name == @col.name
+        col_index = i
+        break
+      end
+    end 
+
+    result = []
+
+    @col.tbl_class.with_table do |fptr|
+      begin
+        while true
+          fpos = fptr.tell
+          
+          rec_arr = Marshal.load(fptr)
+
+          next if rec_arr[0]
+
+          value = rec_arr[col_index+1]
+
+          if search.call(value)
+            result << rec_arr[1]
+          end
+        end
+      rescue EOFError
+      end
+      return result
+    end
+  end
+
+  def >(other)
+    return search_table do |table_value|
+      if table_value.nil? 
+        false
+      else
+        table_value > other 
+      end
+    end
+  end
+
+  def >=(other)
+    return search_table do |table_value|
+      if table_value.nil? 
+        false
+      else
+        table_value >= other 
+      end
+    end
+  end
+
+  def <(other)
+    return search_table do |table_value|
+      if table_value.nil? 
+        false
+      else
+        table_value < other 
+      end
+    end
+  end
+
+  def <=(other)
+    return search_table do |table_value|
+      if table_value.nil? 
+        false
+      else
+        table_value <= other 
+      end
+    end
+  end
+
+  def ==(other)
+    return search_table do |table_value|
+      if table_value.nil? 
+        false
+      else
+        table_value == other 
+      end
+    end
+  end
+
+  def one_of(*other)
+    return search_table do |table_value|
+      other.include?(table_value)
+    end
+  end
+
+  def between(search_start, search_end, start_inclusive=false, 
+   end_inclusive=false)
+    return search_table do |table_value|
+      if table_value < search_start
+        false
+      elsif table_value == search_start and not start_inclusive
+        false
+      elsif table_value == search_end and not end_inclusive
+        false
+      elsif table_value > search_end
+        false
+      else
+        true
+      end
+    end
+  end
+end
+
+end

data/lib/mongoose/skiplist.rb

@@ -0,0 +1,412 @@
+require 'pp'
+
+module Mongoose
+
+#---------------------------------------------------------------------------
+# SkipList Class
+#---------------------------------------------------------------------------
+class SkipList
+    VERSION = "0.1"
+    MAX_LEVEL = 31
+    OPTIMAL_PROBABILITY = 0.25
+
+    attr_reader :size
+
+    #-----------------------------------------------------------------------
+    # initialize
+    #-----------------------------------------------------------------------
+    #++
+    # Create a new skip list instance.
+    #
+    def initialize
+        @size = 0
+
+        # Create header and footer nodes.
+        @footer = FooterNode.new
+        @header = HeaderNode.new
+
+        # Point all header.forward references to footer node.
+        0.upto(MAX_LEVEL) { |i| @header.forward[i] = @footer }
+
+        # This attribute will hold the actual level of the skip list.
+        @level = 0
+    end
+
+    #-----------------------------------------------------------------------
+    # store
+    #-----------------------------------------------------------------------
+    #++
+    # If key not found, will insert new record, otherwise will update value
+    # of existing record.
+    #
+    def store(search_key, new_value)
+        # This array will be used to determine which records need their
+        # forward array re-adjusted after a new node is created.
+        update = []
+
+        # Start off at the header node.
+        x = @header
+
+        # Starting at the current highest level of the skip list, walk from
+        # left to right at that level, until you see that the next node's
+        # key is greater than the key you are searching for.  When this
+        # happend, you want to add the current node you are on to the list
+        # of nodes that need to have their forward arrays updated.  Next,
+        # you want to drop down a level on the current node and start
+        # walking forward again, until you again see that the next node's
+        # key is bigger than the search key.  In this way, you are walking
+        # through the skip list, constantly moving to the right and moving
+        # down, until you reach level 0 and are on the node whose key is
+        # either equal to the search key (in which case an update will take
+        # place), or the highest key in the list that is still lower than
+        # the search key (in which case, you have found the place to do an
+        # insert).
+        @level.downto(0) do |i|
+            while x.forward[i].key < search_key
+                x = x.forward[i]
+            end
+            update[i] = x
+        end
+
+        x = x.forward[0]
+
+        # If the search key was found, simply update the value of the node.
+        if x.key == search_key
+            x.value << new_value unless x.value.include?(new_value)
+        # If this is an insert, determine the number of levels it will have
+        # using a random number.  This is what keeps the skip list balanced.
+        else
+            lvl = random_level
+
+            # If the new level is higher than the actual current level, we
+            # need to make sure that the header node gets updated at these
+            # levels.  Then, we set the actual current level equal to the
+            # new level.
+            if lvl > @level
+                (@level + 1).upto(lvl) { |i| update[i] = @header }
+                @level = lvl
+            end
+
+            # Create a new node.
+            x = Node.new(lvl, search_key, [new_value])
+
+            # Now, we need to update all of the nodes that will be affected
+            # by the insertion of the new node.  These are nodes whose
+            # forward array either will point to the new node and the new
+            # node itself.
+            0.upto(lvl) do |i|
+                x.forward[i] = update[i].forward[i]
+                update[i].forward[i] = x
+            end
+            
+            # Increment the size attribute by one.
+            @size += 1
+        end
+    end
+
+    def remove(search_key, value)
+        update = []
+
+        x = @header
+
+        @level.downto(0) do |i|
+            while x.forward[i].key < search_key
+                x = x.forward[i]
+            end
+            update[i] = x
+        end
+
+        x = x.forward[0]
+
+        if x.key == search_key
+            x.value.delete(value)
+
+            if x.value.empty?
+                0.upto(@level) do |i|
+                    break unless update[i].forward[i] == x
+                    update[i].forward[i] = x.forward[i]
+                end
+
+                while @level > 0 and @header.forward[@level] == @footer 
+                    @level -= 1
+                end
+
+                @size -= 1
+            end
+        end
+    end
+
+    def search(search_key)
+        result = []
+        x = @header
+
+        @level.downto(0) do |i|
+            while x.forward[i].key < search_key
+                x = x.forward[i]
+            end
+        end
+
+        x = x.forward[0]
+
+        return x.value if x.key == search_key
+    end
+
+    def one_of(*other)
+        result = []
+        other.each do |o|
+            result.concat(search(o))
+        end
+        return result
+    end
+
+    def ==(other)
+        return search(other)
+    end
+
+    def >(search_key)
+        result = []
+        x = @header
+
+        @level.downto(0) do |i|
+            while x.forward[i].key < search_key
+                x = x.forward[i]
+            end
+        end
+
+        x = x.forward[0]
+
+        x = x.forward[0] if x.key == search_key
+
+        while x != @footer
+            result.concat(x.value)
+            x = x.forward[0]
+        end
+
+        return result
+    end
+
+    def >=(search_key)
+        result = []
+        x = @header
+
+        @level.downto(0) do |i|
+            while x.forward[i].key < search_key
+                x = x.forward[i]
+            end
+        end
+
+        x = x.forward[0]
+
+        while x != @footer
+            result.concat(x.value)
+            x = x.forward[0]
+        end
+
+        return result
+    end
+
+    def <(search_key)
+        result = []
+        x = @header
+
+        x = x.forward[0]
+
+        while x != @footer and x.key < search_key
+            result.concat(x.value)
+            x = x.forward[0]
+        end
+
+        return result
+    end
+        
+    def <=(search_key)
+        result = []
+        x = @header
+
+        x = x.forward[0]
+
+        while x != @footer and x.key <= search_key
+            result.concat(x.value)
+            x = x.forward[0]
+        end
+
+        return result
+    end
+        
+    def [](search_key)
+        return search(search_key)
+    end
+
+    def between(search_start, search_end, start_inclusive=false, 
+     end_inclusive=false)
+        result = []
+        x = @header
+
+        @level.downto(0) do |i|
+            while x.forward[i].key < search_start
+                x = x.forward[i]
+            end
+        end
+
+        x = x.forward[0]
+
+        x = x.forward[0] if x.key == search_start and not start_inclusive
+
+        while x != @footer and x.key < search_end
+            result.concat(x.value)
+            x = x.forward[0]
+        end
+
+        result = result.concat(x.value) if x.key == search_end and end_inclusive
+        return result
+    end
+
+    def each
+        x = @header.forward[0]
+        
+        while x != @footer
+            yield x.key, x.value
+            x = x.forward[0]
+        end
+    end
+
+    def load(key, value)
+        # This array will be used to determine which records need their
+        # forward array re-adjusted after a new node is created.
+        update = []
+
+        # Start off at the header node.
+        x = @header
+
+        # Starting at the current highest level of the skip list, walk from
+        # left to right at that level, until you reach the footer node.  When
+        # this happens, you want to add the current node you are on to the list
+        # of nodes that need to have their forward arrays updated.  Next,
+        # you want to drop down a level on the current node and start
+        # walking forward again, until you again see that the next node is the
+        # footer node.  In this way, you are walking through the skip list, 
+        # constantly moving to the right and moving down, until you reach level 
+        # 0 and are on the node whose key is the highest key in the list (in 
+        # which case, you have found the place to do an insert).
+        @level.downto(0) do |i|
+            while x.forward[i] != @footer
+                x = x.forward[i]
+            end
+            update[i] = x
+        end
+
+        lvl = random_level
+
+        # If the new level is higher than the actual current level, we
+        # need to make sure that the header node gets updated at these
+        # levels.  Then, we set the actual current level equal to the
+        # new level.
+        if lvl > @level
+            (@level + 1).upto(lvl) { |i| update[i] = @header }
+            @level = lvl
+        end
+
+        # Create a new node.
+        x = Node.new(lvl, key, value)
+
+        # Now, we need to update all of the nodes that will be affected
+        # by the insertion of the new node.  These are nodes whose
+        # forward array either will point to the new node and the new
+        # node itself.
+        0.upto(lvl) do |i|
+            x.forward[i] = update[i].forward[i]
+            update[i].forward[i] = x
+        end
+            
+        # Increment the size attribute by one.
+        @size += 1
+    end
+
+    def dump
+        x = @header
+        puts '----------------  Header -----------------------------'
+        puts x
+        x.forward.each_with_index do |f,i|
+            puts '**** Forward entry %d ****' % i
+            puts f.key
+            puts f.value unless f.is_a?(FooterNode)
+        end
+        puts '----------------  End Header -------------------------'
+
+        while not x.forward[0].is_a?(FooterNode)
+            x = x.forward[0]
+            puts '---------------- Node -------------------------'
+            puts x
+            puts x.key
+            puts x.value
+            puts x.lvl
+            x.forward.each_with_index do |f,i|
+                puts '**** Forward entry %d ****' % i
+                puts f.key
+                puts f.value unless f.is_a?(FooterNode)
+            end
+            puts '---------------- End Node ---------------------'
+        end
+
+        puts '--------------------- Footer ---------------------'
+        pp x.forward[0]
+        puts '--------------------- End Footer -----------------'
+    end
+
+    private
+
+    def random_level
+        lvl = 0
+
+        while rand < OPTIMAL_PROBABILITY and lvl < MAX_LEVEL
+            lvl += 1
+        end
+
+        return lvl
+    end
+end
+
+class HeaderNode
+    attr_accessor :forward
+    attr_reader :key
+
+    def initialize
+        @forward = []
+        @key = HeaderKey.new
+    end
+end
+
+class HeaderKey
+    def ==(other)
+        false
+    end
+end
+
+class FooterNode
+    attr_reader :key
+
+    def initialize
+        @key = FooterKey.new
+    end
+end
+
+class FooterKey
+    def <(other)
+        return false
+    end
+end
+
+
+class Node
+    attr_accessor :forward, :value
+    attr_reader :forward, :key, :lvl
+
+    def initialize(lvl, key, value)
+        @lvl = lvl
+        @forward = []
+        @key = key
+        @value = value
+    end
+end
+
+end