rubydb 0.1.0

data/lib/rubydb/indexes/btree_cursor.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Indexes
+    # B-Tree cursor for sequential access
+    class BTreeCursor
+      attr_reader :btree, :current_key, :current_value, :position
+
+      def initialize(btree)
+        @btree = btree
+        @current_key = nil
+        @current_value = nil
+        @position = 0
+        @stack = []
+        @direction = :forward
+        @started = false
+        @finished = false
+      end
+
+      def first
+        lock.synchronize do
+          reset
+          @direction = :forward
+          move_to_first
+          @started = true
+          @current_key
+        end
+      end
+
+      def last
+        lock.synchronize do
+          reset
+          @direction = :backward
+          move_to_last
+          @started = true
+          @current_key
+        end
+      end
+
+      def next
+        lock.synchronize do
+          return nil if @finished
+          return first if !@started
+          
+          if @direction == :backward
+            @direction = :forward
+          end
+          
+          move_next
+          
+          if @current_key.nil?
+            @finished = true
+            nil
+          else
+            { key: @current_key, value: @current_value }
+          end
+        end
+      end
+
+      def prev
+        lock.synchronize do
+          return nil if @finished
+          return last if !@started
+          
+          if @direction == :forward
+            @direction = :backward
+          end
+          
+          move_prev
+          
+          if @current_key.nil?
+            @finished = true
+            nil
+          else
+            { key: @current_key, value: @current_value }
+          end
+        end
+      end
+
+      def seek(key)
+        lock.synchronize do
+          reset
+          @direction = :forward
+          
+          node = @btree.root
+          find_node(node, key)
+          
+          @started = true
+          @current_key
+        end
+      end
+
+      def reset
+        @current_key = nil
+        @current_value = nil
+        @position = 0
+        @stack.clear
+        @started = false
+        @finished = false
+      end
+
+      private
+
+      def move_to_first
+        node = @btree.root
+        return unless node
+        
+        while !node.is_leaf
+          @stack << { node: node, position: 0 }
+          node = node.children.first
+        end
+        
+        if node.keys.any?
+          @current_key = node.keys.first
+          @current_value = node.values.first
+          @stack << { node: node, position: 0 }
+        end
+      end
+
+      def move_to_last
+        node = @btree.root
+        return unless node
+        
+        while !node.is_leaf
+          @stack << { node: node, position: node.children.size - 1 }
+          node = node.children.last
+        end
+        
+        if node.keys.any?
+          pos = node.keys.size - 1
+          @current_key = node.keys[pos]
+          @current_value = node.values[pos]
+          @stack << { node: node, position: pos }
+        end
+      end
+
+      def move_next
+        if @stack.empty?
+          @current_key = nil
+          @current_value = nil
+          return
+        end
+        
+        current_frame = @stack.last
+        node = current_frame[:node]
+        pos = current_frame[:position]
+        
+        # Move to next key in current node
+        if pos + 1 < node.keys.size
+          current_frame[:position] = pos + 1
+          @current_key = node.keys[pos + 1]
+          @current_value = node.values[pos + 1]
+          return
+        end
+        
+        # Move up the stack
+        while @stack.size > 1
+          @stack.pop
+          parent = @stack.last
+          parent_pos = parent[:position]
+          
+          # Check if parent has next child
+          if parent_pos + 1 < parent[:node].children.size
+            # Go down to next leaf
+            parent[:position] = parent_pos + 1
+            node = parent[:node].children[parent_pos + 1]
+            
+            while !node.is_leaf
+              @stack << { node: node, position: 0 }
+              node = node.children.first
+            end
+            
+            @stack << { node: node, position: 0 }
+            @current_key = node.keys.first
+            @current_value = node.values.first
+            return
+          end
+        end
+        
+        # Reached end
+        @current_key = nil
+        @current_value = nil
+      end
+
+      def move_prev
+        if @stack.empty?
+          @current_key = nil
+          @current_value = nil
+          return
+        end
+        
+        current_frame = @stack.last
+        node = current_frame[:node]
+        pos = current_frame[:position]
+        
+        # Move to previous key in current node
+        if pos - 1 >= 0
+          current_frame[:position] = pos - 1
+          @current_key = node.keys[pos - 1]
+          @current_value = node.values[pos - 1]
+          return
+        end
+        
+        # Move up the stack
+        while @stack.size > 1
+          @stack.pop
+          parent = @stack.last
+          parent_pos = parent[:position]
+          
+          # Check if parent has previous child
+          if parent_pos - 1 >= 0
+            parent[:position] = parent_pos - 1
+            node = parent[:node].children[parent_pos - 1]
+            
+            while !node.is_leaf
+              @stack << { node: node, position: node.children.size - 1 }
+              node = node.children.last
+            end
+            
+            pos = node.keys.size - 1
+            @stack << { node: node, position: pos }
+            @current_key = node.keys[pos]
+            @current_value = node.values[pos]
+            return
+          end
+        end
+        
+        # Reached beginning
+        @current_key = nil
+        @current_value = nil
+      end
+
+      def find_node(node, key)
+        if node.is_leaf
+          pos = node.find_position(key)
+          if pos < node.keys.size && node.keys[pos] == key
+            @current_key = node.keys[pos]
+            @current_value = node.values[pos]
+            @stack << { node: node, position: pos }
+          else
+            # Key not found - position at insertion point
+            @current_key = nil
+            @current_value = nil
+            @finished = true
+          end
+        else
+          pos = node.find_child_position(key)
+          @stack << { node: node, position: pos }
+          find_node(node.children[pos], key)
+        end
+      end
+
+      def lock
+        @btree.instance_variable_get(:@lock)
+      end
+    end
+  end
+end

data/lib/rubydb/indexes/btree_node.rb

@@ -0,0 +1,385 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Indexes
+    # B-Tree node implementation
+    class BTreeNode
+      attr_reader :page_number, :is_leaf, :keys, :values, :children, :parent
+      attr_writer :parent
+      attr_accessor :next_leaf, :prev_leaf
+
+      def initialize(page_number, is_leaf = true, order = 4, page_allocator = nil)
+        @page_number = page_number
+        @is_leaf = is_leaf
+        @order = order
+        @keys = []
+        @values = []
+        @children = []
+        @parent = nil
+        @next_leaf = nil
+        @prev_leaf = nil
+        @min_keys = (order / 2.0).ceil - 1
+        @max_keys = order - 1
+        @dirty = false
+        @page_allocator = page_allocator
+      end
+
+      def insert(key, value)
+        if @is_leaf
+          insert_into_leaf(key, value)
+        else
+          insert_into_internal(key, value)
+        end
+      end
+
+      def insert_into_leaf(key, value)
+        # Find position to insert
+        pos = find_insert_position(key)
+        
+        # Insert key and value
+        @keys.insert(pos, key)
+        @values.insert(pos, value)
+        @dirty = true
+        
+        # Check if node needs to split
+        if @keys.size > @max_keys
+          return split
+        end
+        
+        self
+      end
+
+      def insert_into_internal(key, value)
+        # Find child to insert into
+        pos = find_child_position(key)
+        child = @children[pos]
+        
+        result = child.insert(key, value)
+        
+        # If child was split, handle the split
+        if result.is_a?(Array) && result.size == 3
+          left_child, right_child, split_key = result
+          
+          # Replace child with left child
+          @children[pos] = left_child
+          left_child.parent = self
+          
+          # Insert right child and split key
+          @keys.insert(pos, split_key)
+          @children.insert(pos + 1, right_child)
+          right_child.parent = self
+          @dirty = true
+          
+          # Check if this node needs to split
+          if @keys.size > @max_keys
+            return split
+          end
+        end
+        
+        self
+      end
+
+      def split
+        # Find middle position
+        mid = @keys.size / 2
+        
+        # Create new node
+        new_node = BTreeNode.new(allocate_page, @is_leaf, @order, @page_allocator)
+        
+        # Split keys and values
+        if @is_leaf
+          # Leaf split - keep all keys in both nodes
+          split_key = @keys[mid]
+          
+          # Move half of keys/values to new node
+          new_node.keys = @keys[mid..-1]
+          new_node.values = @values[mid..-1]
+          
+          @keys = @keys[0...mid]
+          @values = @values[0...mid]
+          
+          # Update leaf links
+          new_node.next_leaf = @next_leaf
+          new_node.prev_leaf = self
+          @next_leaf = new_node
+          
+          # Return left, right, and split key
+          [self, new_node, split_key]
+        else
+          # Internal split - promote middle key
+          split_key = @keys[mid]
+          
+          # Right child gets keys after mid
+          new_node.keys = @keys[mid + 1..-1]
+          new_node.children = @children[mid + 1..-1]
+          
+          # Left child keeps keys before mid
+          @keys = @keys[0...mid]
+          @children = @children[0...mid + 1]
+          
+          # Update parent references
+          new_node.children.each { |c| c.parent = new_node }
+          
+          [self, new_node, split_key]
+        end
+      end
+
+      def search(key)
+        if @is_leaf
+          # Linear search in leaf
+          pos = find_position(key)
+          return @values[pos] if pos < @keys.size && @keys[pos] == key
+          nil
+        else
+          # Search in child
+          pos = find_child_position(key)
+          @children[pos].search(key)
+        end
+      end
+
+      def range_search(start_key, end_key)
+        results = []
+        
+        if @is_leaf
+          # Collect keys in range
+          start_pos = find_insert_position(start_key)
+          end_pos = find_insert_position(end_key + 1) rescue @keys.size - 1
+          
+          (start_pos..end_pos).each do |pos|
+            break if pos >= @keys.size
+            break if compare_keys(@keys[pos], end_key).positive?
+            results << { key: @keys[pos], value: @values[pos] }
+          end
+        else
+          # Find the starting leaf and walk the linked leaf chain so ranges
+          # spanning multiple pages return every matching entry.
+          pos = find_child_position(start_key)
+          leaf = @children[pos]
+          until leaf.is_leaf
+            leaf = leaf.children[leaf.find_child_position(start_key)]
+          end
+          while leaf
+            leaf.keys.each_with_index do |key, index|
+              next if compare_keys(key, start_key).negative?
+              return results if compare_keys(key, end_key).positive?
+              results << { key: key, value: leaf.values[index] }
+            end
+            leaf = leaf.next_leaf
+          end
+        end
+        
+        results
+      end
+
+      def delete(key)
+        if @is_leaf
+          delete_from_leaf(key)
+        else
+          delete_from_internal(key)
+        end
+      end
+
+      def delete_from_leaf(key)
+        pos = find_position(key)
+        
+        if pos < @keys.size && @keys[pos] == key
+          @keys.delete_at(pos)
+          @values.delete_at(pos)
+          @dirty = true
+          
+          # Check if node needs rebalancing
+          if @keys.size < @min_keys && @parent
+            return rebalance
+          end
+          
+          self
+        else
+          nil
+        end
+      end
+
+      def delete_from_internal(key)
+        pos = find_child_position(key)
+        child = @children[pos]
+        
+        result = child.delete(key)
+        
+        # Handle rebalancing
+        if result == :underflow
+          rebalance_child(pos)
+        end
+        
+        self
+      end
+
+      def rebalance
+        # Try to borrow from siblings
+        siblings = get_siblings
+        
+        siblings.each do |sibling, position|
+          if sibling && sibling.keys.size > @min_keys
+            # Borrow from sibling
+            if position < 0
+              # Borrow from left sibling
+              @keys.unshift(sibling.keys.last)
+              @values.unshift(sibling.values.last)
+              sibling.keys.pop
+              sibling.values.pop
+              @dirty = true
+            else
+              # Borrow from right sibling
+              @keys.push(sibling.keys.first)
+              @values.push(sibling.values.first)
+              sibling.keys.shift
+              sibling.values.shift
+              @dirty = true
+            end
+            
+            return self
+          end
+        end
+        
+        # Merge with a sibling
+        merge_with_sibling
+        :merged
+      end
+
+      def rebalance_child(pos)
+        child = @children[pos]
+        left_sibling = pos > 0 ? @children[pos - 1] : nil
+        right_sibling = pos < @children.size - 1 ? @children[pos + 1] : nil
+        
+        # Try to borrow from left sibling
+        if left_sibling && left_sibling.keys.size > @min_keys
+          # Borrow from left sibling
+          child.keys.unshift(@keys[pos - 1])
+          @keys[pos - 1] = left_sibling.keys.pop
+          child.values.unshift(left_sibling.values.pop) if child.is_leaf
+          @dirty = true
+          return
+        end
+        
+        # Try to borrow from right sibling
+        if right_sibling && right_sibling.keys.size > @min_keys
+          # Borrow from right sibling
+          child.keys.push(@keys[pos])
+          @keys[pos] = right_sibling.keys.shift
+          child.values.push(right_sibling.values.shift) if child.is_leaf
+          @dirty = true
+          return
+        end
+        
+        # Merge with left sibling
+        if left_sibling
+          merge_nodes(left_sibling, child, pos - 1)
+        elsif right_sibling
+          merge_nodes(child, right_sibling, pos)
+        end
+      end
+
+      def merge_nodes(left, right, parent_pos)
+        # Move parent key down
+        left.keys << @keys[parent_pos]
+        left.values << nil unless left.is_leaf
+        
+        # Merge right node's keys
+        left.keys.concat(right.keys)
+        left.values.concat(right.values) if left.is_leaf
+        left.children.concat(right.children) unless left.is_leaf
+        
+        # Update parent
+        @keys.delete_at(parent_pos)
+        @children.delete_at(parent_pos + 1)
+        @dirty = true
+        
+        # Update leaf links
+        if left.is_leaf
+          left.next_leaf = right.next_leaf
+          right.next_leaf.prev_leaf = left if right.next_leaf
+        end
+        
+        # Check if parent needs rebalancing
+        if @keys.size < @min_keys && @parent
+          rebalance
+        end
+        
+        :underflow
+      end
+
+      def find_position(key)
+        @keys.bsearch_index { |k| compare_keys(k, key) >= 0 } || @keys.size
+      end
+
+      def find_insert_position(key)
+        @keys.bsearch_index { |k| compare_keys(k, key) >= 0 } || @keys.size
+      end
+
+      def find_child_position(key)
+        pos = @keys.bsearch_index { |k| compare_keys(k, key).positive? }
+        pos.nil? ? @children.size - 1 : pos
+      end
+
+      def compare_keys(left, right)
+        if left.is_a?(Array) && right.is_a?(Array)
+          left.zip(right).each do |left_value, right_value|
+            comparison = compare_keys(left_value, right_value)
+            return comparison unless comparison.zero?
+          end
+          return left.length <=> right.length
+        end
+
+        if left.is_a?(TrueClass) || left.is_a?(FalseClass) || right.is_a?(TrueClass) || right.is_a?(FalseClass)
+          return 0 if left == right
+          return left == false ? -1 : 1
+        end
+
+        comparison = left <=> right
+        comparison.nil? ? left.to_s <=> right.to_s : comparison
+      end
+
+      def get_siblings
+        siblings = []
+        
+        if @parent
+          parent_children = @parent.children
+          idx = parent_children.index(self)
+          
+          siblings << [idx > 0 ? parent_children[idx - 1] : nil, -1]
+          siblings << [idx < parent_children.size - 1 ? parent_children[idx + 1] : nil, 1]
+        end
+        
+        siblings
+      end
+
+      def allocate_page
+        raise "B-tree page allocator is not configured" unless @page_allocator.respond_to?(:call)
+        @page_allocator.call
+      end
+
+      def serialize
+        {
+          page_number: @page_number,
+          is_leaf: @is_leaf,
+          keys: @keys,
+          values: @values,
+          children: @children.map(&:page_number),
+          next_leaf: @next_leaf&.page_number,
+          prev_leaf: @prev_leaf&.page_number
+        }
+      end
+
+      def self.deserialize(data)
+        node = new(data[:page_number], data[:is_leaf])
+        node.keys = data[:keys]
+        node.values = data[:values]
+        node
+      end
+
+      def to_s
+        "BTreeNode(page=#{@page_number}, leaf=#{@is_leaf}, keys=#{@keys.size})"
+      end
+
+      attr_writer :keys, :values, :children
+    end
+  end
+end