rubydb 0.1.4 → 0.1.6

data/lib/rubydb/mvcc/snapshot.rb

@@ -1,147 +1,146 @@
-# 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
+# frozen_string_literal: true
+
+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

@@ -1,180 +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
+# 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&.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