perobs 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a988f009b1b97bc8da2b2bcfeb65399284a07032
-  data.tar.gz: 4346d5cdbec5b4154741f0a41d3f526985803912
+  metadata.gz: 4da7810046e0984b00152ab2205ebb2e2d364b94
+  data.tar.gz: 74c48af35b674713b222d0dff1b7f0c3ef070b45
 SHA512:
-  metadata.gz: 639673c10faa5082c742258ee9848f5e951c6d1ec7fc9f03ec7066260ea5042b6c8b90020df6fa506b8be54cc5fd9793a0939f80ef1da726c27832c8a2eb8c85
-  data.tar.gz: 92e63145a1fc9b6e76dbdf6f4cdebfb5a8935bfcbd93a9634e22c12f874b945b656a17fe93aa03a7a3189a00371d2e2abd8d411862ad0ad51b0c364f7b7dc027
+  metadata.gz: 5746476c388361dee6ac06094e7545e86ecb0569368c089e21429e4e6c3dbf92d8db5e7854249d7214c162f15a629306092dd0ca8bfbceb85eda7c08df95cf90
+  data.tar.gz: a495a6127f26bdc7326f1bd7ea3671ff9add499d0b455a9334c884c23a2960ee963eedb8d2bcb5c3f257af9dde4895bebd458a96e7c079dbd0752028e9200614

data/lib/perobs.rb

@@ -27,3 +27,4 @@
 
 require "perobs/version"
 require 'perobs/Store'
+require 'perobs/ConsoleProgressMeter'

data/lib/perobs/Array.rb

@@ -2,7 +2,7 @@
 #
 # = Array.rb -- Persistent Ruby Object Store
 #
-# Copyright (c) 2015, 2016 by Chris Schlaeger <chris@taskjuggler.org>
+# Copyright (c) 2015, 2016, 2017 by Chris Schlaeger <chris@taskjuggler.org>
 #
 # MIT License
 #
@@ -44,19 +44,27 @@ module PEROBS
 
     attr_reader :data
 
-    # These methods do not mutate the Array. They only perform read
-    # operations.
+    # These methods do not mutate the Array but create a new PEROBS::Array
+    # object. They only perform read operations.
     ([
-      :&, :*, :+, :-, :==, :[], :<=>, :at, :abbrev, :assoc, :bsearch, :collect,
-      :combination, :compact, :count, :cycle, :dclone, :drop, :drop_while,
+      :|, :&, :+, :-, :collect, :compact, :drop, :drop_while,
+      :flatten, :map, :reject, :reverse, :rotate, :select, :shuffle, :slice,
+      :sort, :take, :take_while, :uniq, :values_at
+    ] + Enumerable.instance_methods).uniq.each do |method_sym|
+      define_method(method_sym) do |*args, &block|
+        @store.cache.cache_read(self)
+        @store.new(PEROBS::Array, @data.send(method_sym, *args, &block))
+      end
+    end
+
+    # These methods do not mutate the Array and only perform read operations.
+    # They do not return basic objects types.
+    ([
+      :==, :[], :<=>, :at, :bsearch, :bsearch_index, :count, :cycle,
       :each, :each_index, :empty?, :eql?, :fetch, :find_index, :first,
-      :flatten, :frozen?, :hash, :include?, :index, :join, :last,
-      :length, :map, :pack, :permutation, :pretty_print, :pretty_print_cycle,
-      :product, :rassoc, :reject, :repeated_combination,
-      :repeated_permutation, :reverse, :reverse_each, :rindex, :rotate,
-      :sample, :select, :shelljoin, :shuffle, :size, :slice, :sort, :take,
-      :take_while, :to_a, :to_ary, :to_s, :transpose, :uniq, :values_at, :zip,
-      :|
+      :frozen?, :include?, :index, :join, :last, :length, :pack,
+      :pretty_print, :pretty_print_cycle, :reverse_each, :rindex, :sample,
+      :size, :to_a, :to_ary, :to_s
     ] + Enumerable.instance_methods).uniq.each do |method_sym|
       define_method(method_sym) do |*args, &block|
         @store.cache.cache_read(self)
@@ -64,12 +72,23 @@ module PEROBS
       end
     end
 
+    # These methods mutate the Array and return self.
+    [
+      :<<, :clear, :collect!, :compact!, :concat,
+      :fill, :flatten!, :insert, :keep_if, :map!, :push,
+      :reject!, :replace, :select!, :reverse!, :rotate!, :shuffle!,
+      :slice!, :sort!, :sort_by!, :uniq!
+    ].each do |method_sym|
+      define_method(method_sym) do |*args, &block|
+        @store.cache.cache_write(self)
+        @data.send(method_sym, *args, &block)
+        myself
+      end
+    end
+
     # These methods mutate the Array.
     [
-      :<<, :[]=, :clear, :collect!, :compact!, :concat, :delete, :delete_at,
-      :delete_if, :fill, :flatten!, :insert, :keep_if, :map!, :pop, :push,
-      :reject!, :replace, :select!, :reverse!, :rotate!, :shift, :shuffle!,
-      :slice!, :sort!, :sort_by!, :uniq!, :unshift
+      :delete, :delete_at, :delete_if, :shift, :pop
     ].each do |method_sym|
       define_method(method_sym) do |*args, &block|
         @store.cache.cache_write(self)
@@ -81,17 +100,45 @@ module PEROBS
     # PEROBS users should never call this method or equivalents of derived
     # methods directly.
     # @param p [PEROBS::Handle] PEROBS handle
-    # @param size [Integer] The requested size of the Array
+    # @param arg1 [Integer or Array] The requested size of the Array or an
+    #        Array to initialize
     # @param default [Any] The default value that is returned when no value is
     #        stored for a specific key.
-    def initialize(p, size = 0, default = nil)
+    def initialize(p, arg1 = 0, default = nil, &block)
       super(p)
-      @data = ::Array.new(size, default)
+      if arg1.is_a?(::Array)
+        arg1.each { |v| _check_assignment_value(v) }
+        @data = arg1.dup
+      elsif block_given?
+        @data = ::Array.new(arg1) do
+          _check_assignment_value(yield)
+        end
+      else
+        @data = ::Array.new(arg1, _check_assignment_value(default))
+      end
 
       # Ensure that the newly created object will be pushed into the database.
       @store.cache.cache_write(self)
     end
 
+    # Proxy for the assignment method.
+    def []=(*args)
+      if (args.length == 2)
+        _check_assignment_value(args[1])
+      else
+        _check_assignment_value(args[2])
+      end
+      @store.cache.cache_write(self)
+      @data.[]=(*args)
+    end
+
+    # Proxy for the unshift method.
+    def unshift(val)
+      _check_assignment_value(val)
+      @store.cache.cache_write(self)
+      @data.unshift(val)
+    end
+
     # Return a list of all object IDs of all persistend objects that this Array
     # is referencing.
     # @return [Array of Integer] IDs of referenced objects

data/lib/perobs/BTree.rb

@@ -2,7 +2,7 @@
 #
 # = BTreeNode.rb -- Persistent Ruby Object Store
 #
-# Copyright (c) 2016, 2017 by Chris Schlaeger <chris@taskjuggler.org>
+# Copyright (c) 2016, 2017, 2018 by Chris Schlaeger <chris@taskjuggler.org>
 #
 # MIT License
 #
@@ -32,7 +32,7 @@ require 'perobs/BTreeNode'
 
 module PEROBS
 
-  # This BTree class is very similar to a classic BTree implementation. It
+  # This BTree class is very similar to a classic B+Tree implementation. It
   # manages a tree that is always balanced. The BTree is stored in the
   # specified directory and partially kept in memory to speed up operations.
   # The order of the tree specifies how many keys each node will be able to
@@ -40,16 +40,19 @@ module PEROBS
   # have N + 1 references to child nodes instead.
   class BTree
 
-    attr_reader :order, :nodes, :node_cache
+    attr_reader :order, :nodes, :node_cache, :first_leaf, :last_leaf, :size
 
     # Create a new BTree object.
     # @param dir [String] Directory to store the tree file
     # @param name [String] Base name of the BTree related files in 'dir'
     # @param order [Integer] The maximum number of keys per node. This number
     #        must be odd and larger than 2 and smaller than 2**16 - 1.
-    def initialize(dir, name, order)
+    # @param progressmeter [ProgressMeter] reference to a ProgressMeter object
+    def initialize(dir, name, order, progressmeter)
       @dir = dir
       @name = name
+      @progressmeter = progressmeter
+
       unless order > 2
         PEROBS.log.fatal "BTree order must be larger than 2, not #{order}"
       end
@@ -62,9 +65,14 @@ module PEROBS
       @order = order
 
       # This EquiBlobsFile contains the nodes of the BTree.
-      @nodes = EquiBlobsFile.new(@dir, @name,
+      @nodes = EquiBlobsFile.new(@dir, @name, @progressmeter,
                                  BTreeNode::node_bytes(@order))
-      @node_cache = PersistentObjectCache.new(512, BTreeNode, self)
+      @nodes.register_custom_data('first_leaf')
+      @nodes.register_custom_data('last_leaf')
+      @nodes.register_custom_data('btree_size')
+      @node_cache = PersistentObjectCache.new(16384, 5000, BTreeNode, self)
+      @root = @first_leaf = @last_leaf = nil
+      @size = 0
 
       # This BTree implementation uses a write cache to improve write
       # performance of multiple successive read/write operations. This also
@@ -89,23 +97,46 @@ module PEROBS
 
       @node_cache.clear
       @nodes.open
-      node = @nodes.total_entries == 0 ?
-        BTreeNode::create(self) :
-        BTreeNode::load(self, @nodes.first_entry)
+
+      if @nodes.total_entries == 0
+        # We've created a new nodes file
+        node = BTreeNode::create(self)
+      else
+        # We are loading an existing tree.
+        node = BTreeNode::load_and_link(self, @nodes.first_entry)
+        @first_leaf = BTreeNode::load_and_link(
+          self, @nodes.get_custom_data('first_leaf'))
+        @last_leaf = BTreeNode::load_and_link(
+          self, @nodes.get_custom_data('last_leaf'))
+      end
       set_root(node)
+
+      # Get the total number of entries that are stored in the tree.
+      @size = @nodes.get_custom_data('btree_size')
     end
 
     # Close the tree file.
     def close
+
+      def val_perc(value, total)
+        "#{value} (#{(value.to_f / total*100.0).to_i}%)"
+      end
+
       sync
       @nodes.close
       @root = nil
     end
 
+    # @return true if file is currently open
+    def is_open?
+      !@root.nil?
+    end
+
     # Clear all pools and forget any registered spaces.
     def clear
       @node_cache.clear
       @nodes.clear
+      @size = 0
       set_root(BTreeNode::create(self))
     end
 
@@ -114,6 +145,7 @@ module PEROBS
     # all stored data from the BTree.
     def erase
       @nodes.erase
+      @size = 0
       @root = nil
       @dirty_flag.forced_unlock
     end
@@ -121,6 +153,7 @@ module PEROBS
     # Flush all pending modifications into the tree file.
     def sync
       @node_cache.flush(true)
+      @nodes.set_custom_data('btree_size', @size)
       @nodes.sync
       @dirty_flag.unlock if @dirty_flag.is_locked?
     end
@@ -128,21 +161,54 @@ module PEROBS
     # Check if the tree file contains any errors.
     # @return [Boolean] true if no erros were found, false otherwise
     def check(&block)
-      @root.check(&block)
+      sync
+      return false unless @nodes.check
+
+      entries = 0
+      res = true
+      @progressmeter.start('Checking index structure', @size) do |pm|
+        res = @root.check do |k, v|
+          pm.update(entries += 1)
+          block_given? ? yield(k, v) : true
+        end
+      end
+
+      unless entries == @size
+        PEROBS.log.error "The BTree size (#{@size}) and the number of " +
+          "found entries (#{entries}) don't match"
+        return false
+      end
+
+      res
     end
 
     # Register a new node as root node of the tree.
+    # @param node [BTreeNode]
     def set_root(node)
       @root = node
       @nodes.first_entry = node.node_address
     end
 
+    # Set the address of the first leaf node.
+    # @param node [BTreeNode]
+    def set_first_leaf(node)
+      @first_leaf = node
+      @nodes.set_custom_data('first_leaf', node.node_address)
+    end
+
+    # Set the address of the last leaf node.
+    # @param node [BTreeNode]
+    def set_last_leaf(node)
+      @last_leaf = node
+      @nodes.set_custom_data('last_leaf', node.node_address)
+    end
+
     # Insert a new value into the tree using the key as a unique index. If the
     # key already exists the old value will be overwritten.
     # @param key [Integer] Unique key
     # @param value [Integer] value
     def insert(key, value)
-      @root.insert(key, value)
+      @size += 1 if @root.insert(key, value)
       @node_cache.flush
     end
 
@@ -157,7 +223,7 @@ module PEROBS
     # Find and remove the value associated with the given key. If no entry was
     # found, return nil, otherwise the found value.
     def remove(key)
-      removed_value = @root.remove(key)
+      @size -= 1 unless (removed_value = @root.remove(key)).nil?
 
       # Check if the root node only contains one child link after the delete
       # operation. Then we can delete that node and pull the tree one level
@@ -187,6 +253,11 @@ module PEROBS
       @nodes.delete_blob(address)
     end
 
+    # @return [Integer] The number of entries stored in the tree.
+    def entries_count
+      @size
+    end
+
     # @return [String] Human reable form of the tree.
     def to_s
       @root.to_s

data/lib/perobs/BTreeBlob.rb

@@ -33,7 +33,7 @@ require 'perobs/RobustFile'
 module PEROBS
 
   # This class manages the usage of the data blobs in the corresponding
-  # HashedBlobsDB object.
+  # BTreeDB object.
   class BTreeBlob
 
     # Magic number used for index files.

data/lib/perobs/BTreeDB.rb

@@ -2,7 +2,7 @@
 #
 # = BTreeDB.rb -- Persistent Ruby Object Store
 #
-# Copyright (c) 2015, 2016 by Chris Schlaeger <chris@taskjuggler.org>
+# Copyright (c) 2015, 2016, 2018 by Chris Schlaeger <chris@taskjuggler.org>
 #
 # MIT License
 #
@@ -58,7 +58,7 @@ module PEROBS
     #                         nodes. The insert/find/delete time grows
     #                         linearly with the size.
     def initialize(db_name, options = {})
-      super(options[:serializer] || :json)
+      super(options)
 
       @db_dir = db_name
       # Create the database directory if it doesn't exist yet.

data/lib/perobs/BTreeNode.rb

@@ -39,7 +39,8 @@ module PEROBS
   # mark a node as leaf or branch node.
   class BTreeNode
 
-    attr_reader :node_address, :parent, :is_leaf, :keys, :values, :children
+    attr_reader :node_address, :parent, :is_leaf, :next_sibling, :prev_sibling,
+      :keys, :values, :children
 
     # Create a new BTreeNode object for the given tree with the given parent
     # or recreate the node with the given node_address from the backing store.
@@ -48,18 +49,23 @@ module PEROBS
     # restore the node.
     # @param tree [BTree] The tree this node is part of
     # @param parent [BTreeNode] reference to parent node
+    # @param prev_sibling [BTreeNode] reference to previous sibling node
+    # @param next_sibling [BTreeNode] reference to next sibling node
     # @param node_address [Integer] the address of the node to read from the
     #        backing store
     # @param is_leaf [Boolean] true if the node should be a leaf node, false
     #        if not
     def initialize(tree, node_address = nil, parent = nil, is_leaf = true,
+                   prev_sibling = nil, next_sibling = nil,
                    keys = [], values = [], children = [])
       @tree = tree
       if node_address == 0
         PEROBS.log.fatal "Node address may not be 0"
       end
       @node_address = node_address
-      @parent = parent ? BTreeNodeLink.new(tree, parent) : nil
+      @parent = link(parent)
+      @prev_sibling = link(prev_sibling)
+      @next_sibling = link(next_sibling)
       @keys = keys
       if (@is_leaf = is_leaf)
         @values = values
@@ -68,18 +74,6 @@ module PEROBS
         @children = children
         @values = []
       end
-
-      ObjectSpace.define_finalizer(
-        self, BTreeNode._finalize(@tree, @node_address, object_id))
-      @tree.node_cache.insert(self, false)
-    end
-
-    # This method generates the destructor for the objects of this class. It
-    # is done this way to prevent the Proc object hanging on to a reference to
-    # self which would prevent the object from being collected. This internal
-    # method is not intended for users to call.
-    def BTreeNode::_finalize(tree, node_address, ruby_object_id)
-      proc { tree.node_cache._collect(node_address, ruby_object_id) }
     end
 
     # Create a new SpaceTreeNode. This method should be used for the creation
@@ -88,7 +82,10 @@ module PEROBS
     # @param parent [BTreeNode] The parent node
     # @param is_leaf [Boolean] True if the node has no children, false
     #        otherwise
-    def BTreeNode::create(tree, parent = nil, is_leaf = true)
+    # @param prev_sibling [BTreeNode] reference to previous sibling node
+    # @param next_sibling [BTreeNode] reference to next sibling node
+    def BTreeNode::create(tree, parent = nil, is_leaf = true,
+                          prev_sibling = nil, next_sibling = nil)
       unless parent.nil? || parent.is_a?(BTreeNode) ||
              parent.is_a?(BTreeNodeLink)
         PEROBS.log.fatal "Parent node must be a BTreeNode but is of class " +
@@ -96,17 +93,26 @@ module PEROBS
       end
 
       address = tree.nodes.free_address
-      node = BTreeNode.new(tree, address, parent, is_leaf)
+      node = BTreeNode.new(tree, address, parent, is_leaf, prev_sibling,
+                           next_sibling)
       # This is a new node. Make sure the data is written to the file.
       tree.node_cache.insert(node)
 
-      node
+      # Insert the newly created node into the existing node chain.
+      if (node.prev_sibling = prev_sibling)
+        node.prev_sibling.next_sibling = BTreeNodeLink.new(tree, node)
+      end
+      if (node.next_sibling = next_sibling)
+        node.next_sibling.prev_sibling = BTreeNodeLink.new(tree, node)
+      end
+
+      BTreeNodeLink.new(tree, node)
     end
 
     # Restore a node from the backing store at the given address and tree.
     # @param tree [BTree] The tree the node belongs to
-    # @param node_address [Integer] The address in the blob file.
-    def BTreeNode::load(tree, address)
+    # @param address [Integer] The address in the blob file.
+    def BTreeNode::load(tree, address, unused = nil)
       unless address.is_a?(Integer)
         PEROBS.log.fatal "address is not Integer: #{address.class}"
       end
@@ -130,19 +136,21 @@ module PEROBS
       data_count = ary[2]
       # Read the parent node address
       parent = ary[3] == 0 ? nil : BTreeNodeLink.new(tree, ary[3])
+      prev_sibling = ary[4] == 0 ? nil : BTreeNodeLink.new(tree, ary[4])
+      next_sibling = ary[5] == 0 ? nil : BTreeNodeLink.new(tree, ary[5])
       # Read the keys
-      keys = ary[4, key_count]
+      keys = ary[6, key_count]
 
       children = nil
       values = nil
       if is_leaf
         # Read the values
-        values = ary[4 + tree.order, data_count]
+        values = ary[6 + tree.order, data_count]
       else
         # Read the child addresses
         children = []
         data_count.times do |i|
-          child_address = ary[4 + tree.order + i]
+          child_address = ary[6 + tree.order + i]
           unless child_address > 0
             PEROBS.log.fatal "Child address must be larger than 0"
           end
@@ -150,17 +158,28 @@ module PEROBS
         end
       end
 
-      node = BTreeNode.new(tree, address, parent, is_leaf, keys, values,
+      node = BTreeNode.new(tree, address, parent, is_leaf,
+                           prev_sibling, next_sibling, keys, values,
                            children)
       tree.node_cache.insert(node, false)
 
       node
     end
 
+    # This is a wrapper around BTreeNode::load() that returns a BTreeNodeLink
+    # instead of the actual node.
+    # @param tree [BTree] The tree the node belongs to
+    # @param address [Integer] The address in the blob file.
+    # @return [BTreeNodeLink] Link to loaded noded
+    def BTreeNode::load_and_link(tree, address)
+      BTreeNodeLink.new(tree, BTreeNode::load(tree, address))
+    end
+
+
     # @return [String] The format used for String.pack.
     def BTreeNode::node_bytes_format(tree)
       # This does not include the 4 bytes for the CRC32 checksum
-      "CSSQQ#{tree.order}Q#{tree.order + 1}"
+      "CSSQQQQ#{tree.order}Q#{tree.order + 1}"
     end
 
     # @return [Integer] The number of bytes needed to store a node.
@@ -169,6 +188,8 @@ module PEROBS
       2 + # actual key count
       2 + # actual value or children count (aka data count)
       8 + # parent address
+      8 + # previous sibling address
+      8 + # next sibling address
       8 * order + # keys
       8 * (order + 1) + # values or child addresses
       4 # CRC32 checksum
@@ -200,8 +221,7 @@ module PEROBS
 
         # Once we have reached a leaf node we can insert or replace the value.
         if node.is_leaf
-          node.insert_element(key, value)
-          return
+          return node.insert_element(key, value)
         else
           # Descend into the right child node to add the value to.
           node = node.children[node.search_key_index(key)]
@@ -269,18 +289,19 @@ module PEROBS
     def split_node
       unless @parent
         # The node is the root node. We need to create a parent node first.
-        self.parent = BTreeNode::create(@tree, nil, false)
+        self.parent = link(BTreeNode::create(@tree, nil, false))
         @parent.set_child(0, self)
         @tree.set_root(@parent)
       end
 
       # Create the new sibling that will take the 2nd half of the
       # node content.
-      sibling = BTreeNode::create(@tree, @parent, @is_leaf)
+      sibling = BTreeNode::create(@tree, @parent, @is_leaf, link(self),
+                                  @next_sibling)
       # Determine the index of the middle element that gets moved to the
       # parent. The order must be an uneven number, so adding 1 will get us
       # the middle element.
-      mid = @tree.order / 2 + 1
+      mid = @tree.order / 2
       # Insert the middle element key into the parent node
       @parent.insert_element(@keys[mid], sibling)
       copy_elements(mid + (@is_leaf ? 0 : 1), sibling)
@@ -297,6 +318,9 @@ module PEROBS
         insert_element(@parent.keys[parent_index], upper_sibling.children[0])
       end
       upper_sibling.copy_elements(0, self, @keys.size, upper_sibling.keys.size)
+      if (@next_sibling = link(upper_sibling.next_sibling))
+        @next_sibling.prev_sibling = link(self)
+      end
       @tree.delete_node(upper_sibling.node_address)
 
       @parent.remove_element(parent_index)
@@ -307,6 +331,7 @@ module PEROBS
     # @param key [Integer] key to address the value or child
     # @param value_or_child [Integer or BTreeNode] value or BTreeNode
     #        reference
+    # @return true for insert, false for overwrite
     def insert_element(key, value_or_child)
       if @keys.size >= @tree.order
         PEROBS.log.fatal "Cannot insert into a full BTreeNode"
@@ -319,51 +344,48 @@ module PEROBS
         if is_leaf
           @values[i] = value_or_child
         else
-          @children[i + 1] = BTreeNodeLink.new(@tree, value_or_child)
+          @children[i + 1] = link(value_or_child)
         end
+        @tree.node_cache.insert(self)
+
+        return false
       else
         # Create a new entry
         @keys.insert(i, key)
         if is_leaf
           @values.insert(i, value_or_child)
         else
-          @children.insert(i + 1, BTreeNodeLink.new(@tree, value_or_child))
+          @children.insert(i + 1, link(value_or_child))
         end
+        @tree.node_cache.insert(self)
+
+        return true
       end
-      @tree.node_cache.insert(self)
     end
 
     # Remove the element at the given index.
     def remove_element(index)
-      # We need this key to find the link in the parent node.
-      first_key = @keys[0]
-      removed_value = nil
-
       # Delete the key at the specified index.
-      unless @keys.delete_at(index)
-        PEROBS.log.fatal "Could not remove element #{index} from BTreeNode " +
+      unless (key = @keys.delete_at(index))
+        PEROBS.log.fatal "Could not remove element #{index} from BigTreeNode " +
           "@#{@node_address}"
       end
-      if @is_leaf
-        # For leaf nodes, also delete the corresponding value.
-        removed_value = @values.delete_at(index)
-      else
-        # The corresponding child has can be found at 1 index higher.
-        @children.delete_at(index + 1)
-      end
-      @tree.node_cache.insert(self)
+      update_branch_key(key) if index == 0
 
-      # Find the lower and upper siblings and the index of the key for this
-      # node in the parent node.
-      lower_sibling, upper_sibling, parent_index =
-        find_closest_siblings(first_key)
+      # Delete the corresponding value.
+      removed_value = @values.delete_at(index)
+      @tree.node_cache.insert(self)
 
-      if lower_sibling &&
-         lower_sibling.keys.size + @keys.size < @tree.order
-        lower_sibling.merge_node(self, parent_index - 1)
-      elsif upper_sibling &&
-            @keys.size + upper_sibling.keys.size < @tree.order
-        merge_node(upper_sibling, parent_index)
+      if @keys.length < min_keys
+        if @prev_sibling && @prev_sibling.parent == @parent
+          borrow_from_previous_sibling(@prev_sibling) ||
+            @prev_sibling.merge_with_leaf_node(self)
+        elsif @next_sibling && @next_sibling.parent == @parent
+          borrow_from_next_sibling(@next_sibling) ||
+            merge_with_leaf_node(@next_sibling)
+        elsif @parent
+          PEROBS.log.fatal "Cannot not find adjecent leaf siblings"
+        end
       end
 
       # The merge has potentially invalidated this node. After this method has
@@ -371,7 +393,88 @@ module PEROBS
       removed_value
     end
 
+    def remove_child(node)
+      unless (index = search_node_index(node))
+        PEROBS.log.fatal "Cannot remove child #{node.node_address} " +
+          "from node #{@node_address}"
+      end
+
+      @tree.node_cache.insert(self)
+      if index == 0
+        # Removing the first child is a bit more complicated as the
+        # corresponding branch key is in a parent node.
+        key = @keys.shift
+        update_branch_key(key)
+      else
+        # For all other children we can just remove the corresponding key.
+        @keys.delete_at(index - 1)
+      end
+
+      # Remove the child node link.
+      child = @children.delete_at(index)
+      # Unlink the neighbouring siblings from the child
+      child.prev_sibling.next_sibling = child.next_sibling if child.prev_sibling
+      child.next_sibling.prev_sibling = child.prev_sibling if child.next_sibling
+
+      if @keys.length < min_keys
+        # The node has become too small. Try borrowing a node from an adjecent
+        # sibling or merge with an adjecent node.
+        if @prev_sibling && @prev_sibling.parent == @parent
+          borrow_from_previous_sibling(@prev_sibling) ||
+            @prev_sibling.merge_with_branch_node(self)
+        elsif @next_sibling && @next_sibling.parent == @parent
+          borrow_from_next_sibling(@next_sibling) ||
+            merge_with_branch_node(@next_sibling)
+        end
+      end
+
+      if @parent.nil? && @children.length == 1
+        # If the node just below the root only has one child it will become
+        # the new root node.
+        new_root = @children.first
+        new_root.parent = nil
+        @tree.set_root(new_root)
+      end
+    end
+
+    def merge_with_leaf_node(node)
+      if @keys.length + node.keys.length > @tree.order
+        PEROBS.log.fatal "Leaf nodes are too big to merge"
+      end
+
+      @keys += node.keys
+      @values += node.values
+      @tree.node_cache.insert(self)
+
+      node.parent.remove_child(node)
+    end
+
+    def merge_with_branch_node(node)
+      if @keys.length + 1 + node.keys.length > @tree.order
+        PEROBS.log.fatal "Branch nodes are too big to merge"
+      end
+
+      index = @parent.search_node_index(node) - 1
+      @keys << @parent.keys[index]
+      @keys += node.keys
+      node.children.each { |c| c.parent = link(self) }
+      @children += node.children
+      @tree.node_cache.insert(self)
+
+      node.parent.remove_child(node)
+    end
+
+    def search_node_index(node)
+      index = search_key_index(node.keys.first)
+      unless @children[index] == node
+        raise RuntimeError, "Child at index #{index} is not the requested node"
+      end
+
+      index
+    end
+
     def copy_elements(src_idx, dest_node, dst_idx = 0, count = nil)
+      dest_node = dest_node.get_node
       unless count
         count = @tree.order - src_idx
       end
@@ -399,18 +502,47 @@ module PEROBS
     end
 
     def parent=(p)
-      @parent = p ? BTreeNodeLink.new(@tree, p) : nil
+      @parent = p
+      @tree.node_cache.insert(self)
+
+      p
+    end
+
+    def prev_sibling=(node)
+      @prev_sibling = node
+      if node.nil? && @is_leaf
+        # If this node is a leaf node without a previous sibling we need to
+        # register it as the first leaf node.
+        @tree.set_first_leaf(BTreeNodeLink.new(@tree, self))
+      end
+
       @tree.node_cache.insert(self)
+
+      node
+    end
+
+    def next_sibling=(node)
+      @next_sibling = node
+      @tree.node_cache.insert(self)
+      if node.nil? && @is_leaf
+        # If this node is a leaf node without a next sibling we need to
+        # register it as the last leaf node.
+        @tree.set_last_leaf(BTreeNodeLink.new(@tree, self))
+      end
+
+      node
     end
 
     def set_child(index, child)
       if child
-        @children[index] = BTreeNodeLink.new(@tree, child)
-        @children[index].parent = self
+        @children[index] = link(child)
+        @children[index].parent = link(self)
       else
         @children[index] = nil
       end
       @tree.node_cache.insert(self)
+
+      child
     end
 
     def trim(idx)
@@ -511,12 +643,20 @@ module PEROBS
     # @yield [key, value]
     # @return [Boolean] true if tree has no errors
     def check
+      branch_depth = nil
+
       traverse do |node, position, stack|
         if position == 0
-          if node.parent && node.keys.size < 1
-            node.error "BTreeNode must have at least one entry"
-            return false
+          if node.parent
+            # After a split the nodes will only have half the maximum keys.
+            # For branch nodes one of the split nodes will have even 1 key
+            # less as this will become the branch key in a parent node.
+            if node.keys.size < min_keys - (node.is_leaf ? 0 : 1)
+              node.error "BTreeNode #{node.node_address} has too few keys"
+              return false
+            end
           end
+
           if node.keys.size > @tree.order
             node.error "BTreeNode must not have more then #{@tree.order} " +
               "keys, but has #{node.keys.size} keys"
@@ -529,16 +669,43 @@ module PEROBS
                 "#{node.keys.inspect}"
               return false
             end
+            last_key = key
           end
 
           if node.is_leaf
+            if branch_depth
+              unless branch_depth == stack.size
+                node.error "All leaf nodes must have same distance from root "
+                return false
+              end
+            else
+              branch_depth = stack.size
+            end
+            if node.prev_sibling.nil? && @tree.first_leaf != node
+              node.error "Leaf node #{node.node_address} has no previous " +
+                "sibling but is not the first leaf of the tree"
+              return false
+            end
+            if node.next_sibling.nil? && @tree.last_leaf != node
+              node.error "Leaf node #{node.node_address} has no next sibling " +
+                "but is not the last leaf of the tree"
+              return false
+            end
             unless node.keys.size == node.values.size
               node.error "Key count (#{node.keys.size}) and value " +
                 "count (#{node.values.size}) don't match"
                 return false
             end
+            unless node.children.empty?
+              node.error "@children must be nil for a leaf node"
+              return false
+            end
           else
-            unless node.keys.size == node.children.size - 1
+            unless node.values.empty?
+              node.error "@values must be nil for a branch node"
+              return false
+            end
+            unless node.children.size == node.keys.size + 1
               node.error "Key count (#{node.keys.size}) must be one " +
                 "less than children count (#{node.children.size})"
                 return false
@@ -551,10 +718,10 @@ module PEROBS
               end
               unless child.parent.is_a?(BTreeNodeLink)
                 node.error "Parent reference of child #{i} is of class " +
-                  "#{child.class} instead of BTreeNodeLink"
+                  "#{child.parent.class} instead of BTreeNodeLink"
                 return false
               end
-              if child.node_address == node.node_address
+              if child == node
                 node.error "Child #{i} points to self"
                 return false
               end
@@ -567,6 +734,22 @@ module PEROBS
                   "to this node"
                 return false
               end
+              if i > 0
+                unless node.children[i - 1].next_sibling == child
+                  node.error "next_sibling of node " +
+                    "#{node.children[i - 1].node_address} " +
+                    "must point to node #{child.node_address}"
+                  return false
+                end
+              end
+              if i < node.children.length - 1
+                unless child == node.children[i + 1].prev_sibling
+                  node.error "prev_sibling of node " +
+                    "#{node.children[i + 1].node_address} " +
+                    "must point to node #{child.node_address}"
+                  return false
+                end
+              end
             end
           end
         elsif position <= node.keys.size
@@ -580,8 +763,7 @@ module PEROBS
                 "Must be smaller than #{node.keys[index]}."
               return false
             end
-            unless node.children[position].keys.first >=
-                   node.keys[index]
+            unless node.children[position].keys.first >= node.keys[index]
               node.error "Child #{node.children[position].node_address} " +
                 "has too small key #{node.children[position].keys.first}. " +
                 "Must be larger than or equal to #{node.keys[index]}."
@@ -671,13 +853,26 @@ module PEROBS
           s += ' ^@'
         end
       end
+      if @prev_sibling
+        begin
+          s += " <#{@prev_sibling.node_address}"
+        rescue
+          s += ' <@'
+        end
+      end
+      if @next_sibling
+        begin
+          s += " >#{@next_sibling.node_address}"
+        rescue
+          s += ' >@'
+        end
+      end
 
       s
     end
 
     def error(msg)
-      PEROBS.log.error "Error in BTreeNode @#{@node_address}: #{msg}\n" +
-        @tree.to_s
+      PEROBS.log.error "Error in BTreeNode @#{@node_address}: #{msg}"
     end
 
     def write_node
@@ -685,7 +880,9 @@ module PEROBS
         @is_leaf ? 1 : 0,
         @keys.size,
         @is_leaf ? @values.size : @children.size,
-        @parent ? @parent.node_address : 0
+        @parent ? @parent.node_address : 0,
+        @prev_sibling ? @prev_sibling.node_address : 0,
+        @next_sibling ? @next_sibling.node_address : 0
       ] + @keys + ::Array.new(@tree.order - @keys.size, 0)
 
       if @is_leaf
@@ -708,24 +905,107 @@ module PEROBS
 
     private
 
-    def find_closest_siblings(key)
-      # The root node has no siblings.
-      return [ nil, nil, nil ] unless @parent
+    def min_keys
+      @tree.order / 2
+    end
+
+    def link(node)
+      return nil if node.nil?
+
+      if node.is_a?(BTreeNodeLink)
+        return node
+      elsif node.is_a?(BTreeNode) || node.is_a?(Integer)
+        return BTreeNodeLink.new(@tree, node)
+      else
+        PEROBS.log.fatal "Node link must be a BTreeNode, not a #{node.class}"
+      end
+    end
+
+    # Try to borrow an element from the preceding sibling.
+    # @return [True or False] True if an element was borrowed, false
+    #         otherwise.
+    def borrow_from_previous_sibling(prev_node)
+      if prev_node.keys.length - 1 > min_keys
+        index = @parent.search_node_index(self) - 1
+
+        @tree.node_cache.insert(self)
+        @tree.node_cache.insert(prev_node.get_node)
+        @tree.node_cache.insert(@parent.get_node)
+        if @is_leaf
+          # Move the last key of the previous node to the front of this node
+          @keys.unshift(prev_node.keys.pop)
+          # Register the new lead key of this node with its parent
+          @parent.keys[index] = @keys.first
+          # Move the last value of the previous node to the front of this node
+          @values.unshift(prev_node.values.pop)
+        else
+          # For branch nodes the branch key will be the borrowed key.
+          @keys.unshift(@parent.keys[index])
+          # And the last key of the previous key will become the new branch
+          # key for this node.
+          @parent.keys[index] = prev_node.keys.pop
+          # Move the last child of the previous node to the front of this node
+          @children.unshift(node = prev_node.children.pop)
+          node.parent = link(self)
+        end
+
+        return true
+      end
+
+      false
+    end
+
+    # Try to borrow an element from the next sibling.
+    # @return [True or False] True if an element was borrowed, false
+    #         otherwise.
+    def borrow_from_next_sibling(next_node)
+      if next_node.keys.length - 1 > min_keys
+        # The next sibling now has a new lead key that requires the branch key
+        # to be updated in the parent node.
+        index = next_node.parent.search_node_index(next_node) - 1
+
+        @tree.node_cache.insert(self)
+        @tree.node_cache.insert(next_node.get_node)
+        @tree.node_cache.insert(next_node.parent.get_node)
+        if @is_leaf
+          # Move the first key of the next node to the end of the this node
+          @keys << next_node.keys.shift
+          # Register the new lead key of next_node with its parent
+          next_node.parent.keys[index] = next_node.keys.first
+          # Move the first value of the next node to the end of this node
+          @values << next_node.values.shift
+        else
+          # For branch nodes we need to get the lead key from the parent of
+          # next_node.
+          @keys << next_node.parent.keys[index]
+          # The old lead key of next_node becomes the branch key in the parent
+          # of next_node. And the keys of next_node are shifted.
+          next_node.parent.keys[index] = next_node.keys.shift
+          # Move the first child of the next node to the end of this node
+          @children << (node = next_node.children.shift)
+          node.parent = link(self)
+        end
+
+        return true
+      end
+
+      false
+    end
+
+    def update_branch_key(old_key)
+      new_key = @keys.first
+      return unless (node = @parent)
 
-      parent_index = @parent.search_key_index(key)
-      unless @parent.children[parent_index] == self
-        PEROBS.log.fatal "Failed to find self in parent"
+      while node
+        if (index = node.keys.index(old_key))
+          node.keys[index] = new_key
+          @tree.node_cache.insert(node.get_node)
+          return
+        end
+        node = node.parent
       end
-      # The child that corresponds to the key at parent_index has an index of
-      # parent_index + 1! The lower_sibling has an child index of
-      # parent_index and the upper sibling has a child index of parent_index +
-      # 2.
-      lower_sibling = parent_index < 1 ?
-        nil : @parent.children[parent_index - 1]
-      upper_sibling = parent_index >= (@parent.children.size - 1) ?
-        nil : @parent.children[parent_index + 1]
 
-      [ lower_sibling, upper_sibling, parent_index ]
+      # The smallest element has no branch key.
     end
 
   end