rubydb 0.1.0

data/lib/rubydb/history/temporal_query.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module RubyDB
+  module History
+    # TemporalQuery - Executes temporal queries against history
+    class TemporalQuery
+      attr_reader :stats
+
+      def initialize(engine, history_manager, config = {})
+        @engine = engine
+        @history_manager = history_manager
+        @config = config
+        @stats = {
+          queries: 0,
+          temporal_queries: 0,
+          as_of_queries: 0,
+          between_queries: 0,
+          query_time_ms: 0,
+          avg_query_time_ms: 0
+        }
+        @lock = Monitor.new
+        @result_cache = {}
+        @cache_size = config[:cache_size] || 1000
+      end
+
+      def query_as_of(table_name, time, columns = nil)
+        @lock.synchronize do
+          started_at = Time.now
+          @stats[:queries] += 1
+          @stats[:as_of_queries] += 1
+
+          cache_key = "as_of_#{table_name}_#{time.to_i}_#{columns&.join('_')}"
+          if @result_cache.key?(cache_key)
+            return @result_cache[cache_key]
+          end
+
+          # Get history for the table
+          changes = @history_manager.get_changes_for_table(table_name, time)
+
+          # Reconstruct state at time
+          result = reconstruct_state(changes, time, columns)
+
+          # Cache result
+          if @result_cache.size < @cache_size
+            @result_cache[cache_key] = result
+          end
+
+          elapsed_ms = (Time.now - started_at) * 1000
+          @stats[:query_time_ms] += elapsed_ms
+          @stats[:avg_query_time_ms] = @stats[:query_time_ms] / @stats[:queries]
+
+          result
+        end
+      end
+
+      def query_between(table_name, start_time, end_time, columns = nil)
+        @lock.synchronize do
+          started_at = Time.now
+          @stats[:queries] += 1
+          @stats[:between_queries] += 1
+
+          # Get changes between times
+          changes = @history_manager.get_changes_between(table_name, start_time, end_time)
+
+          # Apply changes and return results
+          results = apply_changes(changes, start_time, end_time, columns)
+
+          elapsed_ms = (Time.now - started_at) * 1000
+          @stats[:query_time_ms] += elapsed_ms
+          @stats[:avg_query_time_ms] = @stats[:query_time_ms] / @stats[:queries]
+
+          results
+        end
+      end
+
+      def query_temporal(table_name, time, columns = nil)
+        query_as_of(table_name, time, columns)
+      end
+
+      def query_version(table_name, row_id, version_time)
+        @lock.synchronize do
+          started_at = Time.now
+          @stats[:queries] += 1
+          @stats[:temporal_queries] += 1
+
+          changes = @history_manager.get_changes_for_row(table_name, row_id)
+
+          # Find version at time
+          version = find_version_at_time(changes, row_id, version_time)
+
+          elapsed_ms = (Time.now - started_at) * 1000
+          @stats[:query_time_ms] += elapsed_ms
+          @stats[:avg_query_time_ms] = @stats[:query_time_ms] / @stats[:queries]
+
+          version
+        end
+      end
+
+      def query_history(table_name, row_id)
+        @lock.synchronize do
+          @stats[:queries] += 1
+
+          changes = @history_manager.get_changes_for_row(table_name, row_id)
+
+          {
+            row_id: row_id,
+            table: table_name,
+            history: changes.map(&:to_hash)
+          }
+        end
+      end
+
+      def clear_cache
+        @lock.synchronize do
+          @result_cache.clear
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            cache_size: @result_cache.size,
+            max_cache_size: @cache_size
+          })
+        end
+      end
+
+      private
+
+      def reconstruct_state(changes, time, columns)
+        # Reconstruct the state at a point in time
+        rows = {}
+        changes.each do |change|
+          case change.operation
+          when Change::OP_INSERT
+            rows[change.row_id] = change.new_values
+          when Change::OP_UPDATE
+            if rows.key?(change.row_id)
+              rows[change.row_id] = rows[change.row_id].merge(change.new_values)
+            end
+          when Change::OP_DELETE
+            rows.delete(change.row_id)
+          end
+        end
+
+        {
+          table: changes.first&.table_name,
+          as_of: time.iso8601,
+          rows: columns ? rows.values.map { |r| r.select { |k| columns.include?(k) } } : rows.values,
+          count: rows.size
+        }
+      end
+
+      def apply_changes(changes, start_time, end_time, columns)
+        results = []
+        current_state = {}
+
+        changes.each do |change|
+          case change.operation
+          when Change::OP_INSERT
+            current_state[change.row_id] = change.new_values
+          when Change::OP_UPDATE
+            if current_state.key?(change.row_id)
+              current_state[change.row_id] = current_state[change.row_id].merge(change.new_values)
+            end
+          when Change::OP_DELETE
+            current_state.delete(change.row_id)
+          end
+
+          # Record state at this point
+          if change.timestamp >= start_time && change.timestamp <= end_time
+            results << {
+              timestamp: change.timestamp.iso8601,
+              operation: change.operation,
+              row_id: change.row_id,
+              data: columns ? change.new_values.select { |k| columns.include?(k) } : change.new_values
+            }
+          end
+        end
+
+        results
+      end
+
+      def find_version_at_time(changes, row_id, time)
+        # Find the version of a row at a specific time
+        current = nil
+        changes.each do |change|
+          if change.row_id == row_id && change.timestamp <= time
+            if change.operation == Change::OP_DELETE
+              current = nil
+            else
+              current = change.new_values.dup
+            end
+          end
+        end
+        current
+      end
+    end
+  end
+end

data/lib/rubydb/history/timeline.rb

@@ -0,0 +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

data/lib/rubydb/indexes/btree.rb

@@ -0,0 +1,186 @@
+# 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