rubydb 0.1.4 → 0.1.5

data/lib/rubydb/transactions/commit_manager.rb

@@ -1,220 +1,219 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Transactions
-
-    # Import dependencies
-require_relative "transaction"
-require_relative "transaction_log"
-
-    # CommitManager - Manages two-phase commit and commit coordination
-    class CommitManager
-      attr_reader :stats
-
-      def initialize(transaction_manager, config = {})
-        @transaction_manager = transaction_manager
-        @config = config
-        @prepared_transactions = {}
-        @commit_queue = []
-        @stats = {
-          prepared_count: 0,
-          committed_count: 0,
-          rolled_back_count: 0,
-          in_doubt_count: 0,
-          two_phase_commits: 0
-        }
-        @lock = Mutex.new
-        @commit_thread = nil
-        
-        start_commit_thread if config[:async_commit] != false
-      end
-
-      def commit(transaction)
-        @lock.synchronize do
-          # Two-phase commit
-          if @config[:two_phase_commit]
-            two_phase_commit(transaction)
-          else
-            one_phase_commit(transaction)
-          end
-        end
-      end
-
-      def prepare(transaction)
-        @lock.synchronize do
-          # Validate that transaction can be prepared
-          return false unless transaction.active?
-          
-          # Write prepare record to log
-          @transaction_manager.transaction_log.log_prepare(transaction)
-          
-          # Store prepared transaction
-          @prepared_transactions[transaction.id] = {
-            transaction: transaction,
-            prepared_at: Time.now,
-            resources: transaction.modified_rows.keys
-          }
-          
-          @stats[:prepared_count] += 1
-          true
-        end
-      end
-
-      def commit_prepared(transaction)
-        @lock.synchronize do
-          prepared = @prepared_transactions[transaction.id]
-          return false unless prepared
-          
-          # Write commit record
-          @transaction_manager.transaction_log.log_commit(transaction)
-          
-          # Commit changes
-          commit_changes(transaction)
-          
-          @prepared_transactions.delete(transaction.id)
-          @stats[:committed_count] += 1
-          true
-        end
-      end
-
-      def rollback_prepared(transaction)
-        @lock.synchronize do
-          prepared = @prepared_transactions[transaction.id]
-          return false unless prepared
-          
-          # Write rollback record
-          @transaction_manager.transaction_log.log_rollback(transaction)
-          
-          # Rollback changes
-          rollback_changes(transaction)
-          
-          @prepared_transactions.delete(transaction.id)
-          @stats[:rolled_back_count] += 1
-          true
-        end
-      end
-
-      def resolve_in_doubt
-        @lock.synchronize do
-          @prepared_transactions.each do |id, prepared|
-            next unless prepared[:transaction].in_doubt?
-            
-            # Try to resolve by checking if commit was successful
-            if can_commit?(prepared[:transaction])
-              commit_prepared(prepared[:transaction])
-            else
-              rollback_prepared(prepared[:transaction])
-            end
-          end
-        end
-      end
-
-      def async_commit(transaction)
-        @lock.synchronize do
-          @commit_queue << {
-            transaction: transaction,
-            added_at: Time.now
-          }
-        end
-      end
-
-      private
-
-      def one_phase_commit(transaction)
-        # Simple commit - write to log and apply changes
-        @transaction_manager.transaction_log.log_commit(transaction)
-        commit_changes(transaction)
-        @stats[:committed_count] += 1
-        true
-      end
-
-      def two_phase_commit(transaction)
-        @stats[:two_phase_commits] += 1
-        
-        # Phase 1: Prepare
-        unless prepare(transaction)
-          return false
-        end
-        
-        # Phase 2: Commit
-        commit_prepared(transaction)
-        
-        true
-      end
-
-      def commit_changes(transaction)
-        # Apply all changes
-        transaction.modified_rows.each do |row_id, info|
-          @transaction_manager.engine.update_row(
-            info[:table],
-            row_id,
-            info[:new]
-          )
-        end
-        
-        # Update indexes
-        if @transaction_manager.engine.respond_to?(:index_manager)
-          transaction.modified_rows.each do |row_id, info|
-            # Update index entries
-            @transaction_manager.engine.index_manager.update_row(
-              info[:table],
-              info[:old],
-              info[:new]
-            )
-          end
-        end
-      end
-
-      def rollback_changes(transaction)
-        # Rollback in reverse order
-        transaction.modified_rows.each do |row_id, info|
-          @transaction_manager.engine.update_row(
-            info[:table],
-            row_id,
-            info[:old]
-          )
-        end
-      end
-
-      def can_commit?(transaction)
-        # Check if all resources are available
-        transaction.modified_rows.each do |row_id, info|
-          # Check if no other transaction modified the same row
-          @transaction_manager.active_transactions.each do |_, other|
-            next if other.id == transaction.id
-            if other.modified_rows.key?(row_id)
-              return false
-            end
-          end
-        end
-        
-        true
-      end
-
-      def start_commit_thread
-        @commit_thread = Thread.new do
-          loop do
-            sleep(1)  # Process every second
-            
-            begin
-              # Process commit queue
-              while !@commit_queue.empty?
-                entry = @commit_queue.shift
-                commit(entry[:transaction])
-              end
-              
-              # Resolve in-doubt transactions
-              resolve_in_doubt
-            rescue => e
-              # Log error but continue
-            end
-          end
-        end
-      end
-
-      def engine
-        @transaction_manager.engine
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Transactions
+    # Import dependencies
+    require_relative "transaction"
+    require_relative "transaction_log"
+
+    # CommitManager - Manages two-phase commit and commit coordination
+    class CommitManager
+      attr_reader :stats
+
+      def initialize(transaction_manager, config = {})
+        @transaction_manager = transaction_manager
+        @config = config
+        @prepared_transactions = {}
+        @commit_queue = []
+        @stats = {
+          prepared_count: 0,
+          committed_count: 0,
+          rolled_back_count: 0,
+          in_doubt_count: 0,
+          two_phase_commits: 0
+        }
+        @lock = Mutex.new
+        @commit_thread = nil
+
+        start_commit_thread if config[:async_commit] != false
+      end
+
+      def commit(transaction)
+        @lock.synchronize do
+          # Two-phase commit
+          if @config[:two_phase_commit]
+            two_phase_commit(transaction)
+          else
+            one_phase_commit(transaction)
+          end
+        end
+      end
+
+      def prepare(transaction)
+        @lock.synchronize do
+          # Validate that transaction can be prepared
+          return false unless transaction.active?
+
+          # Write prepare record to log
+          @transaction_manager.transaction_log.log_prepare(transaction)
+
+          # Store prepared transaction
+          @prepared_transactions[transaction.id] = {
+            transaction: transaction,
+            prepared_at: Time.now,
+            resources: transaction.modified_rows.keys
+          }
+
+          @stats[:prepared_count] += 1
+          true
+        end
+      end
+
+      def commit_prepared(transaction)
+        @lock.synchronize do
+          prepared = @prepared_transactions[transaction.id]
+          return false unless prepared
+
+          # Write commit record
+          @transaction_manager.transaction_log.log_commit(transaction)
+
+          # Commit changes
+          commit_changes(transaction)
+
+          @prepared_transactions.delete(transaction.id)
+          @stats[:committed_count] += 1
+          true
+        end
+      end
+
+      def rollback_prepared(transaction)
+        @lock.synchronize do
+          prepared = @prepared_transactions[transaction.id]
+          return false unless prepared
+
+          # Write rollback record
+          @transaction_manager.transaction_log.log_rollback(transaction)
+
+          # Rollback changes
+          rollback_changes(transaction)
+
+          @prepared_transactions.delete(transaction.id)
+          @stats[:rolled_back_count] += 1
+          true
+        end
+      end
+
+      def resolve_in_doubt
+        @lock.synchronize do
+          @prepared_transactions.each do |id, prepared|
+            next unless prepared[:transaction].in_doubt?
+
+            # Try to resolve by checking if commit was successful
+            if can_commit?(prepared[:transaction])
+              commit_prepared(prepared[:transaction])
+            else
+              rollback_prepared(prepared[:transaction])
+            end
+          end
+        end
+      end
+
+      def async_commit(transaction)
+        @lock.synchronize do
+          @commit_queue << {
+            transaction: transaction,
+            added_at: Time.now
+          }
+        end
+      end
+
+      private
+
+      def one_phase_commit(transaction)
+        # Simple commit - write to log and apply changes
+        @transaction_manager.transaction_log.log_commit(transaction)
+        commit_changes(transaction)
+        @stats[:committed_count] += 1
+        true
+      end
+
+      def two_phase_commit(transaction)
+        @stats[:two_phase_commits] += 1
+
+        # Phase 1: Prepare
+        unless prepare(transaction)
+          return false
+        end
+
+        # Phase 2: Commit
+        commit_prepared(transaction)
+
+        true
+      end
+
+      def commit_changes(transaction)
+        # Apply all changes
+        transaction.modified_rows.each do |row_id, info|
+          @transaction_manager.engine.update_row(
+            info[:table],
+            row_id,
+            info[:new]
+          )
+        end
+
+        # Update indexes
+        if @transaction_manager.engine.respond_to?(:index_manager)
+          transaction.modified_rows.each do |row_id, info|
+            # Update index entries
+            @transaction_manager.engine.index_manager.update_row(
+              info[:table],
+              info[:old],
+              info[:new]
+            )
+          end
+        end
+      end
+
+      def rollback_changes(transaction)
+        # Rollback in reverse order
+        transaction.modified_rows.each do |row_id, info|
+          @transaction_manager.engine.update_row(
+            info[:table],
+            row_id,
+            info[:old]
+          )
+        end
+      end
+
+      def can_commit?(transaction)
+        # Check if all resources are available
+        transaction.modified_rows.each do |row_id, info|
+          # Check if no other transaction modified the same row
+          @transaction_manager.active_transactions.each do |_, other|
+            next if other.id == transaction.id
+            if other.modified_rows.key?(row_id)
+              return false
+            end
+          end
+        end
+
+        true
+      end
+
+      def start_commit_thread
+        @commit_thread = Thread.new do
+          loop do
+            sleep(1)  # Process every second
+
+            begin
+              # Process commit queue
+              until @commit_queue.empty?
+                entry = @commit_queue.shift
+                commit(entry[:transaction])
+              end
+
+              # Resolve in-doubt transactions
+              resolve_in_doubt
+            rescue
+              # Log error but continue
+            end
+          end
+        end
+      end
+
+      def engine
+        @transaction_manager.engine
+      end
+    end
+  end
+end

data/lib/rubydb/transactions/isolation.rb

@@ -1,98 +1,98 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Transactions
-    # Isolation - Defines isolation levels and their behaviors
-    module Isolation
-      # Isolation levels
-      READ_UNCOMMITTED = :read_uncommitted
-      READ_COMMITTED = :read_committed
-      REPEATABLE_READ = :repeatable_read
-      SERIALIZABLE = :serializable
-
-      # Phenomena that can occur at each isolation level
-      PHENOMENA = {
-        READ_UNCOMMITTED => {
-          dirty_reads: true,
-          non_repeatable_reads: true,
-          phantom_reads: true,
-          serialization_anomalies: true
-        },
-        READ_COMMITTED => {
-          dirty_reads: false,
-          non_repeatable_reads: true,
-          phantom_reads: true,
-          serialization_anomalies: true
-        },
-        REPEATABLE_READ => {
-          dirty_reads: false,
-          non_repeatable_reads: false,
-          phantom_reads: true,
-          serialization_anomalies: true
-        },
-        SERIALIZABLE => {
-          dirty_reads: false,
-          non_repeatable_reads: false,
-          phantom_reads: false,
-          serialization_anomalies: false
-        }
-      }
-
-      def self.dirty_reads_allowed?(level)
-        PHENOMENA[level][:dirty_reads]
-      end
-
-      def self.non_repeatable_reads_allowed?(level)
-        PHENOMENA[level][:non_repeatable_reads]
-      end
-
-      def self.phantom_reads_allowed?(level)
-        PHENOMENA[level][:phantom_reads]
-      end
-
-      def self.serialization_anomalies_allowed?(level)
-        PHENOMENA[level][:serialization_anomalies]
-      end
-
-      def self.isolation_level_name(level)
-        level.to_s.upcase
-      end
-
-      def self.valid_level?(level)
-        PHENOMENA.key?(level)
-      end
-
-      def self.default_level
-        READ_COMMITTED
-      end
-
-      def self.highest_level
-        SERIALIZABLE
-      end
-
-      def self.lowest_level
-        READ_UNCOMMITTED
-      end
-
-      def self.next_higher(level)
-        case level
-        when READ_UNCOMMITTED then READ_COMMITTED
-        when READ_COMMITTED then REPEATABLE_READ
-        when REPEATABLE_READ then SERIALIZABLE
-        when SERIALIZABLE then SERIALIZABLE
-        else default_level
-        end
-      end
-
-      def self.next_lower(level)
-        case level
-        when SERIALIZABLE then REPEATABLE_READ
-        when REPEATABLE_READ then READ_COMMITTED
-        when READ_COMMITTED then READ_UNCOMMITTED
-        when READ_UNCOMMITTED then READ_UNCOMMITTED
-        else default_level
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Transactions
+    # Isolation - Defines isolation levels and their behaviors
+    module Isolation
+      # Isolation levels
+      READ_UNCOMMITTED = :read_uncommitted
+      READ_COMMITTED = :read_committed
+      REPEATABLE_READ = :repeatable_read
+      SERIALIZABLE = :serializable
+
+      # Phenomena that can occur at each isolation level
+      PHENOMENA = {
+        READ_UNCOMMITTED => {
+          dirty_reads: true,
+          non_repeatable_reads: true,
+          phantom_reads: true,
+          serialization_anomalies: true
+        },
+        READ_COMMITTED => {
+          dirty_reads: false,
+          non_repeatable_reads: true,
+          phantom_reads: true,
+          serialization_anomalies: true
+        },
+        REPEATABLE_READ => {
+          dirty_reads: false,
+          non_repeatable_reads: false,
+          phantom_reads: true,
+          serialization_anomalies: true
+        },
+        SERIALIZABLE => {
+          dirty_reads: false,
+          non_repeatable_reads: false,
+          phantom_reads: false,
+          serialization_anomalies: false
+        }
+      }
+
+      def self.dirty_reads_allowed?(level)
+        PHENOMENA[level][:dirty_reads]
+      end
+
+      def self.non_repeatable_reads_allowed?(level)
+        PHENOMENA[level][:non_repeatable_reads]
+      end
+
+      def self.phantom_reads_allowed?(level)
+        PHENOMENA[level][:phantom_reads]
+      end
+
+      def self.serialization_anomalies_allowed?(level)
+        PHENOMENA[level][:serialization_anomalies]
+      end
+
+      def self.isolation_level_name(level)
+        level.to_s.upcase
+      end
+
+      def self.valid_level?(level)
+        PHENOMENA.key?(level)
+      end
+
+      def self.default_level
+        READ_COMMITTED
+      end
+
+      def self.highest_level
+        SERIALIZABLE
+      end
+
+      def self.lowest_level
+        READ_UNCOMMITTED
+      end
+
+      def self.next_higher(level)
+        case level
+        when READ_UNCOMMITTED then READ_COMMITTED
+        when READ_COMMITTED then REPEATABLE_READ
+        when REPEATABLE_READ then SERIALIZABLE
+        when SERIALIZABLE then SERIALIZABLE
+        else default_level
+        end
+      end
+
+      def self.next_lower(level)
+        case level
+        when SERIALIZABLE then REPEATABLE_READ
+        when REPEATABLE_READ then READ_COMMITTED
+        when READ_COMMITTED then READ_UNCOMMITTED
+        when READ_UNCOMMITTED then READ_UNCOMMITTED
+        else default_level
+        end
+      end
+    end
+  end
+end