rubydb 0.1.4 → 0.1.6

data/lib/rubydb/history/timeline.rb

@@ -1,144 +1,144 @@
-# frozen_string_literal: true
-
-require "time"
-
-module RubyDB
-  module History
-    # Timeline - Manages a timeline of changes
-    class Timeline
-      attr_reader :name, :changes, :created_at, :updated_at
-
-      def initialize(name, changes = [])
-        @name = name
-        @changes = changes
-        @created_at = Time.now
-        @updated_at = Time.now
-        @position = changes.size
-        @lock = Mutex.new
-      end
-
-      def add_change(change)
-        @lock.synchronize do
-          @changes << change
-          @position = @changes.size
-          @updated_at = Time.now
-        end
-      end
-
-      def get_change_at(index)
-        @lock.synchronize do
-          @changes[index]
-        end
-      end
-
-      def get_changes_between(start_time, end_time)
-        @lock.synchronize do
-          @changes.select do |c|
-            c.timestamp >= start_time && c.timestamp <= end_time
-          end
-        end
-      end
-
-      def get_changes_for_table(table_name)
-        @lock.synchronize do
-          @changes.select { |c| c.table_name == table_name }
-        end
-      end
-
-      def get_changes_for_row(table_name, row_id)
-        @lock.synchronize do
-          @changes.select { |c| c.table_name == table_name && c.row_id == row_id }
-        end
-      end
-
-      def get_changes_by_operation(operation)
-        @lock.synchronize do
-          @changes.select { |c| c.operation == operation }
-        end
-      end
-
-      def get_changes_by_user(user)
-        @lock.synchronize do
-          @changes.select { |c| c.user == user }
-        end
-      end
-
-      def get_changes_by_branch(branch)
-        @lock.synchronize do
-          @changes.select { |c| c.branch == branch }
-        end
-      end
-
-      def get_changes_by_lsn_range(start_lsn, end_lsn)
-        @lock.synchronize do
-          @changes.select { |c| c.lsn >= start_lsn && c.lsn <= end_lsn }
-        end
-      end
-
-      def rollback_to(index)
-        @lock.synchronize do
-          return false if index < 0 || index >= @changes.size
-
-          # Remove changes after index
-          @changes = @changes[0..index]
-          @position = @changes.size
-          @updated_at = Time.now
-
-          true
-        end
-      end
-
-      def rollback_to_time(time)
-        @lock.synchronize do
-          index = @changes.rindex { |c| c.timestamp <= time }
-          return false unless index
-
-          rollback_to(index)
-        end
-      end
-
-      def size
-        @changes.size
-      end
-
-      def empty?
-        @changes.empty?
-      end
-
-      def last_change
-        @changes.last
-      end
-
-      def first_change
-        @changes.first
-      end
-
-      def to_hash
-        {
-          name: @name,
-          changes: @changes.map(&:to_hash),
-          created_at: @created_at.iso8601,
-          updated_at: @updated_at.iso8601,
-          size: @changes.size
-        }
-      end
-
-      def to_json
-        JSON.generate(to_hash)
-      end
-
-      def self.from_json(json_data)
-        data = JSON.parse(json_data, symbolize_names: true)
-        changes = data[:changes].map { |c| Change.from_json(c.to_json) }
-        timeline = new(data[:name], changes)
-        timeline.instance_variable_set(:@created_at, Time.parse(data[:created_at]))
-        timeline.instance_variable_set(:@updated_at, Time.parse(data[:updated_at]))
-        timeline
-      end
-
-      def inspect
-        "#<Timeline name=#{@name} changes=#{@changes.size}>"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "time"
+
+module RubyDB
+  module History
+    # Timeline - Manages a timeline of changes
+    class Timeline
+      attr_reader :name, :changes, :created_at, :updated_at
+
+      def initialize(name, changes = [])
+        @name = name
+        @changes = changes
+        @created_at = Time.now
+        @updated_at = Time.now
+        @position = changes.size
+        @lock = Mutex.new
+      end
+
+      def add_change(change)
+        @lock.synchronize do
+          @changes << change
+          @position = @changes.size
+          @updated_at = Time.now
+        end
+      end
+
+      def get_change_at(index)
+        @lock.synchronize do
+          @changes[index]
+        end
+      end
+
+      def get_changes_between(start_time, end_time)
+        @lock.synchronize do
+          @changes.select do |c|
+            c.timestamp >= start_time && c.timestamp <= end_time
+          end
+        end
+      end
+
+      def get_changes_for_table(table_name)
+        @lock.synchronize do
+          @changes.select { |c| c.table_name == table_name }
+        end
+      end
+
+      def get_changes_for_row(table_name, row_id)
+        @lock.synchronize do
+          @changes.select { |c| c.table_name == table_name && c.row_id == row_id }
+        end
+      end
+
+      def get_changes_by_operation(operation)
+        @lock.synchronize do
+          @changes.select { |c| c.operation == operation }
+        end
+      end
+
+      def get_changes_by_user(user)
+        @lock.synchronize do
+          @changes.select { |c| c.user == user }
+        end
+      end
+
+      def get_changes_by_branch(branch)
+        @lock.synchronize do
+          @changes.select { |c| c.branch == branch }
+        end
+      end
+
+      def get_changes_by_lsn_range(start_lsn, end_lsn)
+        @lock.synchronize do
+          @changes.select { |c| c.lsn >= start_lsn && c.lsn <= end_lsn }
+        end
+      end
+
+      def rollback_to(index)
+        @lock.synchronize do
+          return false if index < 0 || index >= @changes.size
+
+          # Remove changes after index
+          @changes = @changes[0..index]
+          @position = @changes.size
+          @updated_at = Time.now
+
+          true
+        end
+      end
+
+      def rollback_to_time(time)
+        @lock.synchronize do
+          index = @changes.rindex { |c| c.timestamp <= time }
+          return false unless index
+
+          rollback_to(index)
+        end
+      end
+
+      def size
+        @changes.size
+      end
+
+      def empty?
+        @changes.empty?
+      end
+
+      def last_change
+        @changes.last
+      end
+
+      def first_change
+        @changes.first
+      end
+
+      def to_hash
+        {
+          name: @name,
+          changes: @changes.map(&:to_hash),
+          created_at: @created_at.iso8601,
+          updated_at: @updated_at.iso8601,
+          size: @changes.size
+        }
+      end
+
+      def to_json
+        JSON.generate(to_hash)
+      end
+
+      def self.from_json(json_data)
+        data = JSON.parse(json_data, symbolize_names: true)
+        changes = data[:changes].map { |c| Change.from_json(c.to_json) }
+        timeline = new(data[:name], changes)
+        timeline.instance_variable_set(:@created_at, Time.parse(data[:created_at]))
+        timeline.instance_variable_set(:@updated_at, Time.parse(data[:updated_at]))
+        timeline
+      end
+
+      def inspect
+        "#<Timeline name=#{@name} changes=#{@changes.size}>"
+      end
+    end
+  end
+end

data/lib/rubydb/indexes/btree.rb

@@ -1,186 +1,215 @@
-# frozen_string_literal: true
-
-require "monitor"
-
-module RubyDB
-  module Indexes
-    # B-Tree index implementation
-    class BTree < Index
-      attr_reader :root, :order, :height
-
-      def initialize(name, table_name, columns, options = {})
-        super(name, table_name, columns, options)
-        @order = options[:order] || 4
-        @height = 0
-        @root = nil
-        @node_pages = {}
-        @next_page = 1000
-        @lock = Monitor.new
-        
-        # Initialize root node
-        initialize_root
-      end
-
-      def insert(key, row_id)
-        @lock.synchronize do
-          if @root.nil?
-            initialize_root
-          end
-
-          result = @root.insert(key, row_id)
-          
-          # Handle root split
-          if result.is_a?(Array) && result.size == 3
-            left, right, split_key = result
-            
-            # Create new root
-            new_root = BTreeNode.new(allocate_page, false, @order, method(:allocate_page))
-            new_root.keys = [split_key]
-            new_root.children = [left, right]
-            left.parent = new_root
-            right.parent = new_root
-            
-            @root = new_root
-            @height += 1
-          end
-          
-          @entries_count += 1
-          @modified_at = Time.now
-          true
-        end
-      end
-
-      def delete(key, row_id)
-        @lock.synchronize do
-          return false if @root.nil?
-          
-          result = @root.delete(key)
-          
-          # Handle root underflow
-          if result == :underflow && @root.keys.empty?
-            if @root.is_leaf
-              @root = nil
-              @height = 0
-            else
-              @root = @root.children.first
-              @root.parent = nil
-              @height -= 1
-            end
-          end
-          
-          @entries_count -= 1 if result
-          @modified_at = Time.now
-          result
-        end
-      end
-
-      def search(key)
-        @lock.synchronize do
-          return nil if @root.nil?
-          @root.search(key)
-        end
-      end
-
-      def range_search(start_key, end_key)
-        @lock.synchronize do
-          return [] if @root.nil?
-          @root.range_search(start_key, end_key)
-        end
-      end
-
-      def build(rows)
-        @lock.synchronize do
-          clear
-          
-          rows.each do |row|
-            key = extract_key(row)
-            row_id = row[:_row_id] || row["id"] || row[:id]
-            insert(key, row_id)
-          end
-          
-          @is_built = true
-          @modified_at = Time.now
-          true
-        end
-      end
-
-      def clear
-        @lock.synchronize do
-          @root = nil
-          @node_pages.clear
-          @height = 0
-          @entries_count = 0
-          initialize_root
-          true
-        end
-      end
-
-      def validate
-        return true if @root.nil?
-        
-        # Check B-Tree properties
-        check_node(@root, nil, nil)
-        true
-      end
-
-      def analyze
-        super.merge({
-          order: @order,
-          height: @height,
-          nodes: @node_pages.size,
-          root_page: @root&.page_number,
-          is_built: @is_built
-        })
-      end
-
-      private
-
-      def initialize_root
-        @root = BTreeNode.new(allocate_page, true, @order, method(:allocate_page))
-        @height = 1
-        @is_built = false
-      end
-
-      def allocate_page
-        page = @next_page
-        @next_page += 1
-        @node_pages[page] = true
-        page
-      end
-
-      def extract_key(row)
-        if @columns.size == 1
-          column = @columns.first
-          row.key?(column) ? row[column] : row[column.to_s]
-        else
-          @columns.map { |col| row.key?(col) ? row[col] : row[col.to_s] }
-        end
-      end
-
-      def check_node(node, min_key, max_key)
-        # Check keys are in order
-        (0...node.keys.size - 1).each do |i|
-          raise "B-Tree invariant violated: keys out of order" if node.keys[i] > node.keys[i + 1]
-        end
-        
-        # Check min/max constraints
-        if min_key && node.keys.first < min_key
-          raise "B-Tree invariant violated: key < min"
-        end
-        
-        if max_key && node.keys.last > max_key
-          raise "B-Tree invariant violated: key > max"
-        end
-        
-        # Check children
-        unless node.is_leaf
-          node.children.each_with_index do |child, i|
-            child_min = i == 0 ? min_key : node.keys[i - 1]
-            child_max = i == node.children.size - 1 ? max_key : node.keys[i]
-            check_node(child, child_min, child_max)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "monitor"
+
+module RubyDB
+  module Indexes
+    # B-Tree index implementation
+    class BTree < Index
+      attr_reader :root, :order, :height
+
+      def initialize(name, table_name, columns, options = {})
+        super
+        @order = options[:order] || 4
+        @height = 0
+        @root = nil
+        @node_pages = {}
+        @next_page = 1000
+        @lock = Monitor.new
+
+        # Initialize root node
+        initialize_root
+      end
+
+      def insert(key, row_id)
+        @lock.synchronize do
+          if @root.nil?
+            initialize_root
+          end
+
+          result = @root.insert(key, row_id)
+
+          # Handle root split
+          if result.is_a?(Array) && result.size == 3
+            left, right, split_key = result
+
+            # Create new root
+            new_root = BTreeNode.new(allocate_page, false, @order, method(:allocate_page))
+            new_root.keys = [split_key]
+            new_root.children = [left, right]
+            left.parent = new_root
+            right.parent = new_root
+
+            @root = new_root
+            @height += 1
+          end
+
+          @entries_count += 1
+          @modified_at = Time.now
+          true
+        end
+      end
+
+      def delete(key, row_id)
+        @lock.synchronize do
+          return false if @root.nil?
+
+          result = @root.delete(key)
+
+          # Handle root underflow
+          if result == :underflow && @root.keys.empty?
+            if @root.is_leaf
+              @root = nil
+              @height = 0
+            else
+              @root = @root.children.first
+              @root.parent = nil
+              @height -= 1
+            end
+          end
+
+          @entries_count -= 1 if result
+          @modified_at = Time.now
+          result
+        end
+      end
+
+      def search(key)
+        @lock.synchronize do
+          return nil if @root.nil?
+          @root.search(key)
+        end
+      end
+
+      def range_search(start_key, end_key)
+        @lock.synchronize do
+          return [] if @root.nil?
+          @root.range_search(start_key, end_key)
+        end
+      end
+
+      def build(rows)
+        @lock.synchronize do
+          clear
+
+          rows.each do |row|
+            key = extract_key(row)
+            row_id = row[:_row_id] || row["id"] || row[:id]
+            insert(key, row_id)
+          end
+
+          @is_built = true
+          @modified_at = Time.now
+          true
+        end
+      end
+
+      def clear
+        @lock.synchronize do
+          @root = nil
+          @node_pages.clear
+          @height = 0
+          @entries_count = 0
+          initialize_root
+          true
+        end
+      end
+
+      def validate
+        return true if @root.nil?
+
+        # Check B-Tree properties
+        check_node(@root, nil, nil)
+        true
+      end
+
+      def analyze
+        super.merge({
+          order: @order,
+          height: @height,
+          nodes: @node_pages.size,
+          root_page: @root&.page_number,
+          is_built: @is_built
+        })
+      end
+
+      # Return a stable, ordered copy of the in-memory B-tree entries. Indexes
+      # are rebuilt from metadata on open, so this immutable value is the
+      # correct hand-off to a storage snapshot; it is not a second persisted
+      # index format.
+      def snapshot_entries
+        @lock.synchronize do
+          return [] unless @root
+
+          leaf = @root
+          leaf = leaf.children.first until leaf.is_leaf
+          entries = []
+          while leaf
+            leaf.keys.each_with_index do |key, index|
+              entries << {key: key, value: leaf.values[index]}
+            end
+            leaf = leaf.next_leaf
+          end
+          entries
+        end
+      end
+
+      private
+
+      def initialize_root
+        @root = BTreeNode.new(allocate_page, true, @order, method(:allocate_page))
+        @height = 1
+        @is_built = false
+      end
+
+      def allocate_page
+        page = @next_page
+        @next_page += 1
+        @node_pages[page] = true
+        page
+      end
+
+      def extract_key(row)
+        if @columns.size == 1
+          column = @columns.first
+          return row[column] if row.key?(column)
+          return row[column.to_s] if row.key?(column.to_s)
+
+          row[column.to_sym] if column.respond_to?(:to_sym)
+        else
+          @columns.map do |column|
+            next row[column] if row.key?(column)
+            next row[column.to_s] if row.key?(column.to_s)
+
+            column.respond_to?(:to_sym) ? row[column.to_sym] : nil
+          end
+        end
+      end
+
+      def check_node(node, min_key, max_key)
+        # Check keys are in order
+        (0...node.keys.size - 1).each do |i|
+          raise "B-Tree invariant violated: keys out of order" if node.keys[i] > node.keys[i + 1]
+        end
+
+        # Check min/max constraints
+        if min_key && node.keys.first < min_key
+          raise "B-Tree invariant violated: key < min"
+        end
+
+        if max_key && node.keys.last > max_key
+          raise "B-Tree invariant violated: key > max"
+        end
+
+        # Check children
+        unless node.is_leaf
+          node.children.each_with_index do |child, i|
+            child_min = (i == 0) ? min_key : node.keys[i - 1]
+            child_max = (i == node.children.size - 1) ? max_key : node.keys[i]
+            check_node(child, child_min, child_max)
+          end
+        end
+      end
+    end
+  end
+end