mongoose 0.1.0 → 0.1.1

data/README

@@ -1,4 +1,4 @@
-= Mongoose 0.1.0
+= Mongoose 0.1.1
 
 A database management system written in Ruby.  It has an ActiveRecord-like
 interface, uses Skiplists for its indexing, and Marshal for its data 
@@ -35,6 +35,7 @@ Unpack the file you downloaded.  Execute "ruby setup.rb".
   can greatly reduce startup times.
 * Supports any datatype that Marshal supports.
 * Table relations supported via has_one, has_many.
+* Fast, Fast, Fast!
 
 
 == Documentation
@@ -88,6 +89,9 @@ end
 
 # Delete a record.
 Plane.find(1).destroy
+
+# Close database.
+db.close
 
 == Manifest
 
@@ -134,3 +138,49 @@ jcribbs@netpromi.com
 == Home Page
 
 http://rubyforge.org/projects/mongoose/
+
+
+== Why Did I Develop Mongoose?
+
+Well, I started to look into performance improvements for KirbyBase.  One thing
+I noticed was that Ruby takes a comparatively long time converting strings to 
+native data types like Integer, Time, etc.  Since KirbyBase stores its records 
+as strings, returning a large result set could take a long time.  I found that 
+if I Marshaled records before I wrote them to disk, a subsequent read of those 
+records was significantly faster.
+
+About the same time, I read a paper about skiplists.  A skiplist is a data 
+structure that is relatively simple (compared to say a b-tree) to understand 
+and implement in code.  I was able to take the pseudo-code in the paper and 
+implement a Ruby version in a couple of hours.  Skiplists are pretty fast and 
+since they are pretty easy to understand, I think there is good potential to 
+tweak them.  So, I wanted to try using skiplists for indexing rather than 
+KirbyBase's array-based indexes.
+
+I started to retrofit both the Marshal serialization and Skiplists in KirbyBase,
+but quickly found that it was going to be more work than just starting over from
+scratch with a new design.  Besides, I didn't want to radically change KirbyBase
+and piss off the current user base (both of you know who you are).
+
+So, I started from scratch.  This also gave me the opportunity to make two other
+major changes.  First of all, I wanted to keep the query language as close to 
+KirbyBase's as possible (i.e. Ruby blocks), but I wanted more control over the 
+query expression.  I took the opportunity to borrow a lot of idea's from Ezra's 
+ez_where plugin.  I think this will give me the capability down the road to 
+tweak the query engine, based on the query itself.
+
+The second thing I changed was that I have finally seen the light about 
+ActiveRecord, so I stole pretty much all of Logan's KirbyRecord code to give 
+Mongoose an ActiveRecord-like api.
+
+The end result of all of this (I hope) is a database management system that is 
+small, easy to use, and fast.
+
+
+== What about KirbyBase?
+
+KirbyBase is not going anywhere.  I still plan on supporting it into the 
+foreseeable future.  However, I imagine that most new development will be 
+directed at Mongoose.
+
+

data/changes.txt

@@ -1,2 +1,13 @@
 2006-07-19:: Version 0.1.0
 * Initial release.
+
+2006-07-20:: Version 0.1.1
+* Fixed bug where saving an updated record that was not the same size as the
+  original was not working.
+* Removed in-memory tracking of last_id_used and deleted_records_counter.  Now
+  I just call out to the header file when I need to get a new id number, etc.
+* Added #dump_to_hash and #load_from_hash methods to SkipList class.  This has
+  cut index initialization times in half, increased query speed, and reduced
+  memory usage.
+* Cleaned up the code in SkipList class.
+* Added more unit tests. 

data/example/simple_examples.rb

@@ -5,9 +5,11 @@ rescue LoadError
   require 'mongoose'
 end
 
-
-Dir.glob('[plane|pilot|flight]*.mg?').each do |filename|
-  File.delete(filename)
+unless ARGV[0] == 'keep-data'
+  puts 'Deleting old tables!'
+  Dir.glob('[plane|pilot|flight]*.mg?').each do |filename|
+    File.delete(filename)
+  end
 end
 
 class Plane < Mongoose::Table
@@ -18,50 +20,52 @@ end
 db = Mongoose::Database.new
 
 # Create new table.  Notice how you specify whether a column is indexed or not.
-db.create_table(:plane) do |tbl|
-  tbl.add_indexed_column(:plane_name, :string)
-  tbl.add_column(:country, :string)
-  tbl.add_indexed_column(:speed, :integer)
-  tbl.add_column(:range, :integer)
-end
+unless ARGV[0] == 'keep-data'
+  db.create_table(:plane) do |tbl|
+    tbl.add_indexed_column(:plane_name, :string)
+    tbl.add_column(:country, :string)
+    tbl.add_indexed_column(:speed, :integer)
+    tbl.add_column(:range, :integer)
+  end
 
-# Add records.
-rec = Plane.new
-rec.plane_name = 'P-51'
-rec.country = 'USA'
-rec.speed = 402
-rec.range = 1205
-rec.save 
-
-rec2 = Plane.new
-rec2.plane_name = 'Spitfire'
-rec2.country = 'Great Britain'
-rec2.speed = 333
-rec2.range = 454
-rec2.save 
-
-rec3 = Plane.new
-rec3.plane_name = 'ME-109'
-rec3.country = 'Germany'
-rec3.speed = 354
-rec3.range = 501
-rec3.save
-
-rec4 = Plane.new
-rec4.plane_name = 'P-39'
-rec4.country = 'USA'
-rec4.range = 701
-
-# Forgot value for speed, which is a required field.
-begin
+  # Add records.
+  rec = Plane.new
+  rec.plane_name = 'P-51'
+  rec.country = 'USA'
+  rec.speed = 402
+  rec.range = 1205
+  rec.save 
+
+  rec2 = Plane.new
+  rec2.plane_name = 'Spitfire'
+  rec2.country = 'Great Britain'
+  rec2.speed = 333
+  rec2.range = 454
+  rec2.save 
+
+  rec3 = Plane.new
+  rec3.plane_name = 'ME-109'
+  rec3.country = 'Germany'
+  rec3.speed = 354
+  rec3.range = 501
+  rec3.save
+
+  rec4 = Plane.new
+  rec4.plane_name = 'P-39'
+  rec4.country = 'USA'
+  rec4.range = 701
+
+  # Forgot value for speed, which is a required field.
+  begin
+    rec4.save
+  rescue RuntimeError => e
+    puts e
+  end
+
+  rec4.speed = 339
   rec4.save
-rescue RuntimeError => e
-  puts e
 end
 
-rec4.speed = 339
-rec4.save
-
 puts "\n\nFind P-51 record by ID"
 p_51 = Plane.find(1)
 p p_51

data/lib/mongoose.rb

@@ -18,13 +18,11 @@ require 'mongoose/util'
 # Homepage::  http://rubyforge.org/projects/mongoose/
 # Copyright:: Copyright (c) 2006 NetPro Technologies, LLC
 # License::   Distributed under the same terms as Ruby
-# History:
-# 2006-07-19:: Version 0.1.0
-# * Initial release.
 #
 #
 module Mongoose
 
+VERSION = '0.1.1'
 DATA_TYPES = [:string, :integer, :float, :time, :date, :datetime, :boolean]
 TBL_EXT = '.mgt'
 TBL_HDR_EXT = '.mgh'

data/lib/mongoose/column.rb

@@ -50,12 +50,6 @@ class Column < BaseColumn
     @idx = LinearSearch.new(self)
   end
 
-  def store(key, value)
-  end
-
-  def remove(key, value)
-  end
-
   def >(other)
     @tbl_class.query << [@idx, :>, other]
   end
@@ -110,6 +104,9 @@ class IndexedColumn < BaseColumn
     rebuild_index_file if index_file_out_of_date?
   end 
 
+  #-----------------------------------------------------------------------------
+  # init_index
+  #-----------------------------------------------------------------------------
   def init_index
     if File.exists?(@index_file_name) and not index_file_out_of_date?
       rebuild_index_from_index_file
@@ -149,12 +146,12 @@ end
 #-------------------------------------------------------------------------------
 class SkipListIndexColumn < IndexedColumn
   def initialize(tbl_class, name, col_def)
-    @idx = SkipList.new
+    @idx = SkipList.new(self)
     super
   end
 
   def clear_index
-    @idx = SkipList.new
+    @idx = SkipList.new(self)
   end
 
   def >(other)
@@ -190,9 +187,7 @@ class SkipListIndexColumn < IndexedColumn
   end
 
   def rebuild_index_file
-    with_index_file('w') do |fptr|
-      @idx.each { |k,v| fptr.write(Marshal.dump([k, v])) }
-    end
+    with_index_file('w') { |fptr| fptr.write(Marshal.dump(@idx.dump_to_hash)) }
   end
 
   def rebuild_index_from_table
@@ -206,15 +201,7 @@ class SkipListIndexColumn < IndexedColumn
 
   def rebuild_index_from_index_file
     clear_index
-
-    with_index_file do |fptr|
-      begin
-        while true
-          @idx.load(*Marshal.load(fptr))
-        end
-      rescue EOFError
-      end
-    end
+    with_index_file { |fptr| @idx.load_from_hash(Marshal.load(fptr)) }
   end
 
   def add_index_rec(key, value)
@@ -235,7 +222,6 @@ class IDColumn < IndexedColumn
 
   def_delegator(:@idx, :[], :[])
   def_delegator(:@idx, :keys, :keys)
-#  def_delegator(:@idx, :delete, :remove)
 
   def initialize(tbl_class, name, col_def)
     @idx = {}
@@ -247,31 +233,17 @@ class IDColumn < IndexedColumn
   end
 
   def rebuild_index_file
-    with_index_file('w') do |fptr|
-#      @idx.each_pair { |k,v| fptr.write(Marshal.dump([k, v])) }
-      fptr.write(Marshal.dump(@idx))
-    end
+    with_index_file('w') { |fptr| fptr.write(Marshal.dump(@idx)) }
   end
 
   def rebuild_index_from_table
     clear_index
-    @tbl_class.get_all_recs do |rec, fpos|
-      add_index_rec(rec[0], fpos)
-    end
+    @tbl_class.get_all_recs { |rec, fpos| add_index_rec(rec[0], fpos) }
   end
 
   def rebuild_index_from_index_file
     clear_index
-
-    with_index_file do |fptr|
-#      begin
-#        while true
-#          add_index_rec(*Marshal.load(fptr))
-#        end
-#      rescue EOFError
-#      end
-    @idx = Marshal.load(fptr)
-    end
+    with_index_file { |fptr| @idx = Marshal.load(fptr) }
   end
 
   def add_index_rec(id, fpos)

data/lib/mongoose/database.rb

@@ -37,7 +37,7 @@ class Database
   def create_table(table_name)
     raise "Table already exists!" if table_exists?(table_name)
 
-    class_name = get_class_name_from_table_name(table_name)
+    class_name = Util.us_case_to_class_case(table_name)
 
     tbl_header = {}
     tbl_header[:table_name] = table_name
@@ -64,7 +64,7 @@ class Database
   # drop_table
   #-----------------------------------------------------------------------------
   def drop_table(table_name)
-    class_name = get_class_name_from_table_name(table_name)
+    class_name = Util.us_case_to_class_case(table_name)
 
     @tables[Object.const_get(class_name)][:columns].each do |c|
       if c.indexed?
@@ -92,22 +92,13 @@ class Database
   # init_table
   #-----------------------------------------------------------------------------
   def init_table(table_name)
-    class_name = get_class_name_from_table_name(table_name)
+    class_name = Util.us_case_to_class_case(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 }
+     :table_name => table_name, :columns => [], :query => [] }
 
     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/skiplist.rb

@@ -1,412 +1,483 @@
-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
+  MAX_LEVEL = 31
+  OPTIMAL_PROBABILITY = 0.25
+
+  attr_reader :size
+
+  #-----------------------------------------------------------------------
+  # initialize
+  #-----------------------------------------------------------------------
+  def initialize(col)
+    @col = col
+    @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
 
-    #-----------------------------------------------------------------------
-    # 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
+    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
+      # Increment the size attribute by one.
+      @size += 1
     end
+  end
 
-    def remove(search_key, value)
-        update = []
+  #-----------------------------------------------------------------------
+  # remove
+  #-----------------------------------------------------------------------
+  def remove(search_key, value)
+    update = []
 
-        x = @header
+    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)
+    @level.downto(0) do |i|
+      while x.forward[i].key < search_key
+        x = x.forward[i]
+      end
+      update[i] = x
+    end
 
-            if x.value.empty?
-                0.upto(@level) do |i|
-                    break unless update[i].forward[i] == x
-                    update[i].forward[i] = x.forward[i]
-                end
+    x = x.forward[0]
 
-                while @level > 0 and @header.forward[@level] == @footer 
-                    @level -= 1
-                end
+    if x.key == search_key
+      x.value.delete(value)
 
-                @size -= 1
-            end
+      if x.value.empty?
+        0.upto(@level) do |i|
+          break unless update[i].forward[i] == x
+          update[i].forward[i] = x.forward[i]
         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
+        while @level > 0 and @header.forward[@level] == @footer 
+          @level -= 1
         end
 
-        x = x.forward[0]
-
-        return x.value if x.key == search_key
+        @size -= 1
+      end
     end
-
-    def one_of(*other)
-        result = []
-        other.each do |o|
-            result.concat(search(o))
-        end
-        return result
+  end
+
+  #-----------------------------------------------------------------------
+  # search
+  #-----------------------------------------------------------------------
+  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
 
-    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
+    x = x.forward[0]
 
-        while x != @footer
-            result.concat(x.value)
-            x = x.forward[0]
-        end
+    return x.value if x.key == search_key
+  end
 
-        return result
+  #-----------------------------------------------------------------------
+  # one_of
+  #-----------------------------------------------------------------------
+  def one_of(*other)
+    result = []
+    other.each do |o|
+      result.concat(search(o))
+    end
+    return result
+  end
+
+  #-----------------------------------------------------------------------
+  # ==
+  #-----------------------------------------------------------------------
+  def ==(other)
+    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
 
-    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]
+    x = x.forward[0] if x.key == search_key
 
-        while x != @footer
-            result.concat(x.value)
-            x = x.forward[0]
-        end
-
-        return result
+    while x != @footer
+      result.concat(x.value)
+      x = x.forward[0]
     end
 
-    def <(search_key)
-        result = []
-        x = @header
-
-        x = x.forward[0]
+    result
+  end
 
-        while x != @footer and x.key < search_key
-            result.concat(x.value)
-            x = x.forward[0]
-        end
+  #-----------------------------------------------------------------------
+  # >=
+  #-----------------------------------------------------------------------
+  def >=(search_key)
+    result = []
+    x = @header
 
-        return result
+    @level.downto(0) do |i|
+      while x.forward[i].key < search_key
+        x = x.forward[i]
+      end
     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
+    x = x.forward[0]
 
-        return result
-    end
-        
-    def [](search_key)
-        return search(search_key)
+    while x != @footer
+      result.concat(x.value)
+      x = x.forward[0]
     end
 
-    def between(search_start, search_end, start_inclusive=false, 
-     end_inclusive=false)
-        result = []
-        x = @header
+    result
+  end
 
-        @level.downto(0) do |i|
-            while x.forward[i].key < search_start
-                x = x.forward[i]
-            end
-        end
-
-        x = x.forward[0]
+  #-----------------------------------------------------------------------
+  # <
+  #-----------------------------------------------------------------------
+  def <(search_key)
+    result = []
+    x = @header
 
-        x = x.forward[0] if x.key == search_start and not start_inclusive
+    x = x.forward[0]
 
-        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
+    while x != @footer and x.key < search_key
+      result.concat(x.value)
+      x = x.forward[0]
     end
 
-    def each
-        x = @header.forward[0]
+    result
+  end
         
-        while x != @footer
-            yield x.key, x.value
-            x = x.forward[0]
-        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
 
-    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
+    result
+  end
+        
+  #-----------------------------------------------------------------------
+  # []
+  #-----------------------------------------------------------------------
+  def [](search_key)
+    search(search_key)
+  end
+
+  #-----------------------------------------------------------------------
+  # between
+  #-----------------------------------------------------------------------
+  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
 
-        lvl = random_level
+    x = x.forward[0]
+    x = x.forward[0] if x.key == search_start and not start_inclusive
 
-        # 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
+    while x != @footer and x.key < search_end
+      result.concat(x.value)
+      x = x.forward[0]
+    end
 
-        # Create a new node.
-        x = Node.new(lvl, key, value)
+    result = result.concat(x.value) if x.key == search_end and end_inclusive
+    result
+  end
 
-        # 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
+  #-----------------------------------------------------------------------
+  # each
+  #-----------------------------------------------------------------------
+  def each
+    x = @header.forward[0]
+        
+    while x != @footer
+      yield x.key, x.value
+      x = x.forward[0]
+    end
+  end
+
+  #-----------------------------------------------------------------------
+  # load_from_hash
+  #-----------------------------------------------------------------------
+  def load_from_hash(sl_hash)
+    # Create array to hold last node that was at that level, while working
+    # backwards.
+    levels = []
+    0.upto(MAX_LEVEL) { |i| levels << @footer }
+
+    x = nil
+    lvl = nil
+
+    # Loop through keys in reverse order...
+    sl_hash.keys.sort.reverse.each do |key|
+      lvl, value = sl_hash[key]
+
+      # Update skiplist level to be same as highest level yet found in keys.
+      @level = lvl if lvl > @level
+
+      # Create node with values from hash.
+      x = Node.new(lvl, key, value)
+
+      # Now, for each level of node, point its forward reference to the last
+      # node that occupied that level (remember we are working backwards).
+      0.upto(lvl) do |i|
+        x.forward[i] = levels[i]
+        # Now, we want to make current node the last node that occupied that
+        # level.
+        levels[i] = x
+      end
+        
+      # Now, make sure that, for now, the header node points to this node, 
+      # since it is the lowest node, at least until we read the next hash key.
+      0.upto(lvl) { |i| @header.forward[i] = x }
+    end    
+  end
+
+  #-----------------------------------------------------------------------
+  # dump_to_hash
+  #-----------------------------------------------------------------------
+  def dump_to_hash
+    sl_hash = {}
+
+    x = @header.forward[0]
+        
+    while x != @footer
+      sl_hash[x.key] = [x.lvl, x.value]
+      x = x.forward[0]
     end
 
-    def dump
-        x = @header
-        puts '----------------  Header -----------------------------'
-        puts x
+    sl_hash
+  end
+
+  #-----------------------------------------------------------------------
+  # dump
+  #-----------------------------------------------------------------------
+  def dump
+    File.open(@col.index_file_name + '.dump', 'w') do |fptr|
+      x = @header
+      fptr.write("----------------  Header -----------------------------\n")
+      x.forward.each_with_index do |f,i|
+        fptr.write("**** Forward entry %d ****\n" % i)
+        fptr.write("Key: " + f.key.inspect + "\n")
+        fptr.write("Value: " + f.value.inspect + "\n") unless \
+         f.is_a?(FooterNode)
+      end
+      fptr.write("----------------  End Header -------------------------\n")
+
+      while not x.forward[0].is_a?(FooterNode)
+        x = x.forward[0]
+        fptr.write("---------------- Node -------------------------\n")
+        fptr.write("Key: " + x.key.inspect + "\n") 
+        fptr.write("Value: " + x.value.inspect + "\n")
+        fptr.write("Level: " + x.lvl.inspect + "\n")
         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 ---------------------'
+          fptr.write("**** Forward entry %d ****\n" % i)
+          fptr.write("Key: " + f.key.inspect + "\n") 
+          fptr.write("Value: " + f.value.inspect + "\n") unless \
+           f.is_a?(FooterNode)
         end
-
-        puts '--------------------- Footer ---------------------'
-        pp x.forward[0]
-        puts '--------------------- End Footer -----------------'
+        fptr.write("---------------- End Node ---------------------\n")
+      end
+
+      fptr.write("--------------------- Footer ---------------------\n")
+      fptr.write(x.forward[0].inspect + "\n")
+      fptr.write("--------------------- End Footer -----------------\n")
+    end     
+  end
+
+  #-----------------------------------------------------------------------
+  # PRIVATE METHODS
+  #-----------------------------------------------------------------------
+  private
+
+  #-----------------------------------------------------------------------
+  # random_level
+  #-----------------------------------------------------------------------
+  def random_level
+    lvl = 0
+    while rand < OPTIMAL_PROBABILITY and lvl < MAX_LEVEL
+      lvl += 1
     end
+    lvl
+  end
+end
 
-    private
 
-    def random_level
-        lvl = 0
+#---------------------------------------------------------------------------
+# HeaderNode Class
+#---------------------------------------------------------------------------
+class HeaderNode
+  attr_accessor :forward
+  attr_reader :key
 
-        while rand < OPTIMAL_PROBABILITY and lvl < MAX_LEVEL
-            lvl += 1
-        end
+  def initialize
+    @forward = []
+    @key = HeaderKey.new
+  end
 
-        return lvl
-    end
+  def inspect
+    self.class.to_s
+  end
 end
 
-class HeaderNode
-    attr_accessor :forward
-    attr_reader :key
-
-    def initialize
-        @forward = []
-        @key = HeaderKey.new
-    end
-end
 
+#---------------------------------------------------------------------------
+# HeaderKey Class
+#---------------------------------------------------------------------------
 class HeaderKey
-    def ==(other)
-        false
-    end
+  def ==(other)
+    false
+  end
 end
 
+
+#---------------------------------------------------------------------------
+# FooterNode Class
+#---------------------------------------------------------------------------
 class FooterNode
-    attr_reader :key
+  attr_reader :key
 
-    def initialize
-        @key = FooterKey.new
-    end
+  def initialize
+    @key = FooterKey.new
+  end
+
+  def inspect
+    self.class.to_s
+  end
 end
 
+
+#---------------------------------------------------------------------------
+# FooterKey Class
+#---------------------------------------------------------------------------
 class FooterKey
-    def <(other)
-        return false
-    end
+  def inspect
+    self.class.to_s
+  end
+
+  def <(other)
+    false
+  end
 end
 
 
+#---------------------------------------------------------------------------
+# Node Class
+#---------------------------------------------------------------------------
 class Node
-    attr_accessor :forward, :value
-    attr_reader :forward, :key, :lvl
-
-    def initialize(lvl, key, value)
-        @lvl = lvl
-        @forward = []
-        @key = key
-        @value = value
-    end
+  attr_accessor :forward, :value
+  attr_reader :key, :lvl
+
+  def initialize(lvl, key, value)
+    @lvl = lvl
+    @forward = []
+    @key = key
+    @value = value
+  end
+
+  def inspect
+    self.class.to_s
+  end
 end
 
 end