rubydb 0.1.0

data/lib/rubydb/mvcc/garbage_collector.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module MVCC
+    # GarbageCollector - Collects and removes garbage versions
+    class GarbageCollector
+      attr_reader :stats
+
+      def initialize(version_store, visibility, config = {})
+        @version_store = version_store
+        @visibility = visibility
+        @config = config
+        @collection_interval = config[:interval] || 300  # 5 minutes
+        @threshold = config[:threshold] || 0.2  # 20% garbage triggers collection
+        @max_collect_per_run = config[:max_collect] || 10000
+        @stats = {
+          collections: 0,
+          garbage_collected: 0,
+          space_freed: 0,
+          last_collection: nil,
+          average_collected: 0
+        }
+        @lock = Mutex.new
+        @running = false
+        @gc_thread = nil
+      end
+
+      def start
+        @lock.synchronize do
+          return if @running
+
+          @running = true
+          @gc_thread = Thread.new do
+            while @running
+              sleep(@collection_interval)
+              begin
+                collect
+              rescue => e
+                # Log error but continue
+                puts "GC error: #{e.message}"
+              end
+            end
+          end
+        end
+      end
+
+      def stop
+        @lock.synchronize do
+          @running = false
+          @gc_thread&.kill
+          @gc_thread = nil
+        end
+      end
+
+      def collect
+        @lock.synchronize do
+          @stats[:collections] += 1
+          start_time = Time.now
+
+          collected = 0
+
+          # Find garbage versions
+          garbage = find_garbage
+
+          # Remove garbage
+          garbage.each do |version|
+            # Check if version is still referenced
+            if is_referenced?(version)
+              next
+            end
+
+            # Remove the version
+            @version_store.delete_version(version)
+            @stats[:garbage_collected] += 1
+            collected += 1
+
+            break if collected >= @max_collect_per_run
+          end
+
+          # Update stats
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:last_collection] = {
+            time: Time.now.iso8601,
+            elapsed_ms: elapsed_ms,
+            collected: collected,
+            garbage_found: garbage.size
+          }
+
+          @stats[:average_collected] = @stats[:garbage_collected] / @stats[:collections].to_f
+
+          collected
+        end
+      end
+
+      def find_garbage
+        garbage = []
+        versions_by_row = @version_store.instance_variable_get(:@versions)
+
+        versions_by_row.each do |row_id, versions|
+          # Find versions that are garbage
+          versions.each do |version|
+            if is_garbage?(version)
+              garbage << version
+            end
+          end
+        end
+
+        garbage
+      end
+
+      def is_garbage?(version)
+        # Check if version is garbage based on rules
+
+        # 1. Aborted versions are garbage
+        return true if version.is_aborted
+
+        # 2. Deleted versions that are old
+        if version.is_deleted && version.is_committed
+          # Check if there's a newer version
+          versions = @version_store.get_all_versions(version.row_id)
+          newer_versions = versions.select { |v| v.created_at > version.created_at }
+          if newer_versions.any?
+            return true
+          end
+        end
+
+        # 3. Committed versions that are no longer referenced
+        if version.is_committed && !version.is_deleted
+          # Check if any active transaction needs this version
+          if !has_references?(version)
+            return true
+          end
+        end
+
+        false
+      end
+
+      def is_referenced?(version)
+        # Check if version is referenced by any active transaction
+        # or is needed for rollback
+        has_references?(version)
+      end
+
+      def has_references?(version)
+        # Check if any active transaction might need this version
+        # For simplicity, we check if there are any active versions
+        # that reference this version as previous version
+        versions_by_row = @version_store.instance_variable_get(:@versions)
+
+        versions_by_row.each do |_, versions|
+          versions.each do |v|
+            if v.prev_version_id == version.version_id
+              return true
+            end
+          end
+        end
+
+        false
+      end
+
+      def force_collect
+        collect
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            running: @running,
+            interval: @collection_interval,
+            threshold: @threshold,
+            max_per_run: @max_collect_per_run,
+            garbage_ratio: garbage_ratio
+          })
+        end
+      end
+
+      def garbage_ratio
+        total = @version_store.version_count
+        return 0.0 if total == 0
+
+        # Estimate garbage count
+        garbage = find_garbage
+        garbage.size.to_f / total
+      end
+
+      def status
+        @lock.synchronize do
+          {
+            running: @running,
+            last_collection: @stats[:last_collection],
+            total_collected: @stats[:garbage_collected],
+            average_collected: @stats[:average_collected],
+            garbage_ratio: garbage_ratio
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/mvcc/mvcc.rb

@@ -0,0 +1,16 @@
+# lib/rubydb/mvcc.rb
+# frozen_string_literal: true
+
+# Main entry point for MVCC module
+require_relative "mvcc/version"
+require_relative "mvcc/visibility"
+require_relative "mvcc/snapshot"
+require_relative "mvcc/version_store"
+require_relative "mvcc/vacuum"
+require_relative "mvcc/garbage_collector"
+
+module RubyDB
+  module MVCC
+    # All classes are now loaded
+  end
+end

data/lib/rubydb/mvcc/snapshot.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "set"
+require "time"
+
+module RubyDB
+  module MVCC
+    # Snapshot - Represents a consistent view of the database at a point in time
+    class Snapshot
+      attr_reader :id, :transaction_id, :created_at
+      attr_reader :active_transactions, :committed_transactions
+      attr_reader :min_transaction_id, :max_transaction_id
+      attr_reader :read_keys, :write_keys, :read_predicates
+
+      def initialize(transaction_id, active_transactions = [], committed_transactions = [])
+        @id = generate_snapshot_id(transaction_id)
+        @transaction_id = transaction_id
+        @created_at = Time.now
+        @active_transactions = Set.new(active_transactions)
+        @committed_transactions = Set.new(committed_transactions)
+        @min_transaction_id = active_transactions.min || 0
+        @max_transaction_id = active_transactions.max || 0
+        @version_cache = {}
+        @read_keys = Set.new
+        @write_keys = Set.new
+        @read_predicates = Set.new
+        @cache_size = 1000
+        @lock = Mutex.new
+      end
+
+      def record_read(key)
+        @lock.synchronize { @read_keys.add(key) }
+      end
+
+      def record_write(key)
+        @lock.synchronize { @write_keys.add(key) }
+      end
+
+      def record_predicate(predicate)
+        @lock.synchronize { @read_predicates.add(predicate) }
+      end
+
+      def generate_snapshot_id(transaction_id)
+        "snapshot_#{transaction_id}_#{Time.now.to_i}_#{rand(10000)}"
+      end
+
+      def visible?(version, check_transaction_id = nil)
+        @lock.synchronize do
+          # Check cache
+          cache_key = version.version_id
+          if @version_cache.key?(cache_key)
+            return @version_cache[cache_key]
+          end
+
+          result = check_visibility(version, check_transaction_id)
+
+          # Cache result
+          if @version_cache.size < @cache_size
+            @version_cache[cache_key] = result
+          end
+
+          result
+        end
+      end
+
+      def check_visibility(version, check_transaction_id = nil)
+        txn_id = check_transaction_id || @transaction_id
+
+        # Same transaction sees its own versions
+        return true if version.transaction_id == txn_id
+
+        # Check if version is from an active transaction
+        if @active_transactions.include?(version.transaction_id)
+          # Active transactions are not visible (unless it's the current transaction)
+          return false
+        end
+
+        # Check if version is from a committed transaction
+        if version.is_committed && @committed_transactions.include?(version.transaction_id)
+          # Check if the commit happened after snapshot was taken
+          if version.committed_at && version.committed_at > @created_at
+            return false
+          end
+          return true
+        end
+
+        # If transaction is not in our lists, it committed before snapshot
+        if version.is_committed
+          # Check if it was committed before snapshot
+          if version.commit_id && version.commit_id < @min_transaction_id
+            return true
+          end
+        end
+
+        # Default: not visible
+        false
+      end
+
+      def add_active_transaction(transaction_id)
+        @lock.synchronize do
+          @active_transactions.add(transaction_id)
+          @min_transaction_id = [@min_transaction_id, transaction_id].min
+          @max_transaction_id = [@max_transaction_id, transaction_id].max
+        end
+      end
+
+      def add_committed_transaction(transaction_id)
+        @lock.synchronize do
+          @committed_transactions.add(transaction_id)
+          @active_transactions.delete(transaction_id)
+        end
+      end
+
+      def remove_transaction(transaction_id)
+        @lock.synchronize do
+          @active_transactions.delete(transaction_id)
+          @committed_transactions.delete(transaction_id)
+        end
+      end
+
+      def includes_transaction?(transaction_id)
+        @active_transactions.include?(transaction_id) ||
+        @committed_transactions.include?(transaction_id)
+      end
+
+      def to_hash
+        {
+          id: @id,
+          transaction_id: @transaction_id,
+          created_at: @created_at.iso8601,
+          active_transactions: @active_transactions.to_a,
+          committed_transactions: @committed_transactions.to_a,
+          min_transaction_id: @min_transaction_id,
+          max_transaction_id: @max_transaction_id
+        }
+      end
+
+      def inspect
+        "#<Snapshot id=#{@id} txn=#{@transaction_id} active=#{@active_transactions.size} committed=#{@committed_transactions.size}>"
+      end
+
+      def to_s
+        inspect
+      end
+    end
+  end
+end

data/lib/rubydb/mvcc/vacuum.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module MVCC
+    # Vacuum - Manages cleanup of old versions and reclaims space
+    class Vacuum
+      attr_reader :stats
+
+      def initialize(version_store, config = {})
+        @version_store = version_store
+        @config = config
+        @vacuum_interval = config[:interval] || 60  # seconds
+        @max_versions_per_row = config[:max_versions] || 100
+        @min_age = config[:min_age] || 3600  # 1 hour
+        @batch_size = config[:batch_size] || 1000
+        @threshold = config[:threshold] || 0.3  # 30% of max versions
+        @stats = {
+          vacuum_runs: 0,
+          versions_removed: 0,
+          rows_compacted: 0,
+          space_reclaimed: 0,
+          last_vacuum: nil,
+          average_removed_per_run: 0
+        }
+        @lock = Mutex.new
+        @running = false
+        @vacuum_thread = nil
+      end
+
+      def start
+        @lock.synchronize do
+          return if @running
+
+          @running = true
+          @vacuum_thread = Thread.new do
+            while @running
+              sleep(@vacuum_interval)
+              begin
+                run
+              rescue => e
+                # Log error but continue
+                puts "Vacuum error: #{e.message}"
+              end
+            end
+          end
+        end
+      end
+
+      def stop
+        @lock.synchronize do
+          @running = false
+          @vacuum_thread&.kill
+          @vacuum_thread = nil
+        end
+      end
+
+      def run
+        @lock.synchronize do
+          @stats[:vacuum_runs] += 1
+          start_time = Time.now
+
+          # Remove old versions
+          removed = vacuum_versions
+
+          # Compact version chains
+          compacted = compact_version_chains
+
+          # Update stats
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:last_vacuum] = {
+            time: Time.now.iso8601,
+            elapsed_ms: elapsed_ms,
+            removed: removed,
+            compacted: compacted
+          }
+
+          @stats[:versions_removed] += removed
+          @stats[:rows_compacted] += compacted
+          @stats[:average_removed_per_run] = @stats[:versions_removed] / @stats[:vacuum_runs].to_f
+
+          { removed: removed, compacted: compacted }
+        end
+      end
+
+      def vacuum_versions
+        removed = 0
+        batch_removed = 0
+
+        # Get rows with excessive versions
+        rows = @version_store.instance_variable_get(:@versions)
+        candidates = rows.select do |_, versions|
+          versions.size > @max_versions_per_row * @threshold
+        end
+
+        candidates.each do |row_id, versions|
+          # Calculate how many to remove
+          remove_count = versions.size - @max_versions_per_row
+          next if remove_count <= 0
+
+          # Remove oldest versions
+          remove_count.times do
+            version = versions.shift
+            if version && version.is_committed && !version.is_deleted
+              # Check age
+              if Time.now - version.created_at > @min_age
+                @version_store.instance_variable_get(:@version_map).delete(version.version_id)
+                removed += 1
+                batch_removed += 1
+              end
+            end
+            break if batch_removed >= @batch_size
+          end
+
+          break if batch_removed >= @batch_size
+        end
+
+        removed
+      end
+
+      def compact_version_chains
+        compacted = 0
+        rows = @version_store.instance_variable_get(:@versions)
+
+        rows.each do |row_id, versions|
+          next if versions.size <= 1
+
+          # Check if there are gaps or holes in the chain
+          # Remove versions with no data (deleted, aborted)
+          original_size = versions.size
+          versions.delete_if do |version|
+            version.is_deleted || version.is_aborted
+          end
+
+          if versions.size < original_size
+            compacted += 1
+          end
+
+          # Update next_version_id links
+          versions.each_with_index do |version, idx|
+            if idx < versions.size - 1
+              version.instance_variable_set(:@next_version_id, versions[idx + 1].version_id)
+            else
+              version.instance_variable_set(:@next_version_id, nil)
+            end
+          end
+        end
+
+        compacted
+      end
+
+      def force_run
+        run
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            running: @running,
+            interval: @vacuum_interval,
+            threshold: @threshold,
+            max_versions: @max_versions_per_row,
+            min_age: @min_age
+          })
+        end
+      end
+
+      def status
+        @lock.synchronize do
+          {
+            running: @running,
+            last_vacuum: @stats[:last_vacuum],
+            total_removed: @stats[:versions_removed],
+            total_compacted: @stats[:rows_compacted],
+            average_removed: @stats[:average_removed_per_run]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/mvcc/version.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "time"
+
+module RubyDB
+  module MVCC
+    # Version - Represents a version of a row
+    class Version
+      attr_reader :row_id, :version_id, :created_at, :transaction_id
+      attr_reader :data, :prev_version_id, :next_version_id
+      attr_accessor :is_committed, :is_aborted, :is_deleted
+      attr_reader :commit_id, :committed_at, :aborted_at, :visibility
+
+      def initialize(row_id, data, transaction_id, prev_version_id = nil)
+        @row_id = row_id
+        @version_id = generate_version_id
+        @data = data
+        @transaction_id = transaction_id
+        @prev_version_id = prev_version_id
+        @next_version_id = nil
+        @created_at = Time.now
+        @is_committed = false
+        @is_aborted = false
+        @is_deleted = false
+        @commit_id = nil
+        @visibility = :active  # :active, :visible, :hidden, :deleted
+        @lock = Mutex.new
+      end
+
+      def generate_version_id
+        "#{row_id}_#{Time.now.to_i}_#{rand(10000)}"
+      end
+
+      def commit(commit_id = nil)
+        @lock.synchronize do
+          @commit_id = commit_id || transaction_id
+          @is_committed = true
+          @visibility = :visible
+          @committed_at = Time.now
+        end
+      end
+
+      def abort
+        @lock.synchronize do
+          @is_aborted = true
+          @visibility = :hidden
+          @aborted_at = Time.now
+        end
+      end
+
+      def mark_deleted
+        @lock.synchronize do
+          @is_deleted = true
+          @visibility = :deleted
+        end
+      end
+
+      def visible_to?(transaction_id, snapshot = nil)
+        @lock.synchronize do
+          # Check snapshot first
+          if snapshot
+            return snapshot.visible?(self, transaction_id)
+          end
+
+          # If not committed, only visible to its own transaction
+          return false unless @is_committed
+
+          # Check if deleted
+          return false if @is_deleted && @visibility == :deleted
+
+          # Committed versions are visible to all transactions
+          # except those that started before this version was committed
+          if @commit_id && transaction_id
+            return @commit_id <= transaction_id
+          end
+
+          true
+        end
+      end
+
+      def to_hash
+        {
+          row_id: @row_id,
+          version_id: @version_id,
+          created_at: @created_at.iso8601,
+          transaction_id: @transaction_id,
+          prev_version_id: @prev_version_id,
+          next_version_id: @next_version_id,
+          is_committed: @is_committed,
+          is_aborted: @is_aborted,
+          is_deleted: @is_deleted,
+          visibility: @visibility,
+          commit_id: @commit_id
+        }
+      end
+
+      def inspect
+        "#<Version row_id=#{@row_id} version=#{@version_id} txn=#{@transaction_id} visibility=#{@visibility}>"
+      end
+
+      def to_s
+        inspect
+      end
+    end
+  end
+end