rubydb 0.1.0

data/lib/rubydb/transactions/lock_manager.rb

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+
+require "set"
+
+module RubyDB
+  module Transactions
+
+    # Import lock and transaction classes
+    require_relative "lock"
+    require_relative "transaction"
+
+    # LockManager - Manages locks for transactions
+    class LockManager
+      attr_reader :locks, :waiting, :stats
+
+      def initialize(config = {})
+        @locks = {}
+        @waiting = {}
+        @lock_timeout = config[:lock_timeout] || 30
+        @deadlock_detection = config[:deadlock_detection] != false
+        @transaction_manager = config[:transaction_manager]
+        @stats = {
+          locks_acquired: 0,
+          locks_released: 0,
+          lock_waits: 0,
+          lock_timeouts: 0,
+          deadlocks_detected: 0,
+          deadlocks_resolved: 0
+        }
+        @lock = Mutex.new
+        @condition = ConditionVariable.new
+        @transactions = {}
+        @deadlock_victims = {}
+      end
+
+      def acquire_lock(transaction, table_name, row_id, lock_type, timeout = @lock_timeout)
+        @lock.synchronize do
+          @transactions[transaction.id] = transaction
+          return false unless transaction.active?
+
+          key = lock_key(table_name, row_id)
+          
+          # Check if transaction already has lock
+          if has_lock?(transaction, key)
+            return upgrade_lock(transaction, key, lock_type)
+          end
+          
+          # Check if lock is available
+          current_lock = @locks[key]
+          
+          if current_lock.nil?
+            # No lock exists - acquire
+            @locks[key] = Lock.new(key, lock_type, transaction)
+            @stats[:locks_acquired] += 1
+            return true
+          end
+          
+          # Check compatibility
+          if compatible?(current_lock, lock_type, transaction)
+            # Add transaction to lock
+            current_lock.add_holder(transaction, lock_type)
+            @stats[:locks_acquired] += 1
+            return true
+          end
+          
+          # Lock conflict - wait
+          @stats[:lock_waits] += 1
+          result = wait_for_lock(transaction, key, lock_type, timeout)
+          
+          result
+        end
+      end
+
+      def release_locks(transaction)
+        @lock.synchronize do
+          @locks.each do |key, lock|
+            if lock.holders.key?(transaction.id)
+              lock.remove_holder(transaction)
+              @stats[:locks_released] += 1
+              
+              # Remove empty lock
+              if lock.holders.empty?
+                @locks.delete(key)
+                
+                # Wake up waiting transactions
+                wake_waiting_transactions(key)
+                @condition.broadcast
+              end
+            end
+          end
+          @transactions.delete(transaction.id)
+        end
+      end
+
+      def release_all_locks
+        @lock.synchronize do
+          @locks.clear
+          @waiting.clear
+          @transactions.clear
+          @deadlock_victims.clear
+          @stats[:locks_released] += 1
+        end
+      end
+
+      def has_lock?(transaction, key)
+        lock = @locks[key]
+        return false unless lock
+        lock.holders.key?(transaction.id)
+      end
+
+      def lock_type(transaction, key)
+        lock = @locks[key]
+        return nil unless lock
+        lock.holders[transaction.id] if lock.holders.key?(transaction.id)
+      end
+
+      def waiting_transactions
+        @waiting.size
+      end
+
+      def deadlock_victim?(transaction_id)
+        @lock.synchronize { @deadlock_victims.key?(transaction_id) }
+      end
+
+      def clear_deadlock_victim(transaction_id)
+        @lock.synchronize { @deadlock_victims.delete(transaction_id) }
+      end
+
+      def total_locks
+        @locks.size
+      end
+
+      def lock_info
+        @locks.transform_values do |lock|
+          {
+            type: lock.type,
+            holders: lock.holders.keys,
+            waiters: lock.waiters.keys
+          }
+        end
+      end
+
+      # Return the current wait-for graph as transaction ids. This is a
+      # snapshot intended for monitoring and transaction-manager deadlock
+      # resolution; callers never receive mutable lock-manager state.
+      def wait_for_graph
+        @lock.synchronize { build_wait_for_graph }
+      end
+
+      private
+
+      def build_wait_for_graph
+        graph = {}
+        @waiting.each do |transaction_id, waits|
+          graph[transaction_id] = Set.new
+          waits.each_key do |key|
+            @locks[key]&.holders&.each_key do |holder_id|
+              graph[holder_id] ||= Set.new
+              graph[transaction_id] << holder_id
+            end
+          end
+        end
+        graph
+      end
+
+      def lock_key(table_name, row_id)
+        "#{table_name}:#{row_id}"
+      end
+
+      def compatible?(lock, lock_type, transaction)
+        # Check if any holder has incompatible lock
+        lock.holders.each do |holder_id, holder_type|
+          next if holder_id == transaction.id
+          
+          if !compatible_lock_types(holder_type, lock_type)
+            return false
+          end
+        end
+        
+        true
+      end
+
+      def compatible_lock_types(type1, type2)
+        # Shared locks are compatible with shared locks
+        if type1 == :shared && type2 == :shared
+          return true
+        end
+        
+        # Exclusive locks are incompatible with any other
+        if type1 == :exclusive || type2 == :exclusive
+          return false
+        end
+        
+        true
+      end
+
+      def upgrade_lock(transaction, key, new_type)
+        lock = @locks[key]
+        current_type = lock.holders[transaction.id]
+        
+        # Check if upgrade is needed
+        return true if current_type == new_type
+        
+        # Check if upgrade is possible
+        if new_type == :exclusive && current_type == :shared
+          # Need to check if other transactions hold shared locks
+          if lock.holders.size == 1 && lock.holders.key?(transaction.id)
+            # Only this transaction holds the lock - upgrade
+            lock.holders[transaction.id] = :exclusive
+            @stats[:locks_acquired] += 1
+            return true
+          end
+        end
+        
+        false
+      end
+
+      def wait_for_lock(transaction, key, lock_type, timeout)
+        start_time = Time.now
+        
+        # Add to waiters
+        @waiting[transaction.id] ||= {}
+        @waiting[transaction.id][key] = {
+          lock_type: lock_type,
+          start_time: start_time
+        }
+        
+        # Wait loop
+        while (remaining = timeout - (Time.now - start_time)) > 0
+          if !transaction.active? || @deadlock_victims.key?(transaction.id)
+            waits = @waiting[transaction.id]
+            waits&.delete(key)
+            @waiting.delete(transaction.id) if waits&.empty?
+            return false
+          end
+
+          # Check if lock is available
+          if @locks[key].nil? || compatible?(@locks[key], lock_type, transaction)
+            # Remove from waiting
+            @waiting[transaction.id].delete(key)
+            @waiting.delete(transaction.id) if @waiting[transaction.id].empty?
+            
+            # Acquire lock
+            @locks[key] ||= Lock.new(key, lock_type)
+            @locks[key].add_holder(transaction, lock_type)
+            @stats[:locks_acquired] += 1
+            return true
+          end
+
+          # ConditionVariable releases @lock while waiting, allowing the
+          # current holder to release its lock and wake this waiter.
+          @condition.wait(@lock, remaining)
+        end
+        
+        # Detect while the timed-out waiter is still in the wait graph. The
+        # previous ordering removed it first, making a two-transaction cycle
+        # impossible to observe. Resolution is performed by the unlocked
+        # helper because this method already owns @lock.
+        detect_deadlock if @deadlock_detection
+
+        # Timeout or deadlock victim
+        @stats[:lock_timeouts] += 1
+        waits = @waiting[transaction.id]
+        waits&.delete(key)
+        @waiting.delete(transaction.id) if waits&.empty?
+        false
+      end
+
+      def wake_waiting_transactions(key)
+        # Find waiting transactions for this key
+        @waiting.each do |txn_id, waits|
+          if waits.key?(key)
+            # Transaction is waiting - it will be woken in wait loop
+          end
+        end
+      end
+
+      def detect_deadlock
+        graph = build_wait_for_graph
+
+        # Detect cycles
+        cycles = detect_cycles(graph)
+        
+        if cycles.any?
+          @stats[:deadlocks_detected] += 1
+          # Resolve by aborting the lowest-priority transaction. The victim is
+          # marked before locks are released so its waiter cannot reacquire a
+          # lock after the condition variable wakes it.
+          cycles.each do |cycle|
+            victim = cycle.compact.min_by { |id| [@transactions[id]&.priority.to_i, id.to_s] }
+            abort_transaction_unlocked(victim) if victim
+          end
+        end
+      end
+
+      def detect_cycles(graph)
+        cycles = []
+        visited = Set.new
+        active = Set.new
+        path = []
+        
+        graph.keys.each do |node|
+          detect_cycle_dfs(node, graph, visited, active, path, cycles) unless visited.include?(node)
+        end
+        
+        cycles
+      end
+
+      def detect_cycle_dfs(node, graph, visited, active, path, cycles)
+        if active.include?(node)
+          start = path.index(node)
+          cycle = path[start..] + [node]
+          cycles << cycle unless cycles.any? { |existing| existing == cycle }
+          return
+        end
+        return if visited.include?(node)
+        
+        visited.add(node)
+        active.add(node)
+        path << node
+        
+        graph[node]&.each do |neighbor|
+          detect_cycle_dfs(neighbor, graph, visited, active, path, cycles)
+        end
+        
+        path.pop
+        active.delete(node)
+      end
+
+      def abort_transaction(transaction_id)
+        transaction = if @transaction_manager.respond_to?(:get_transaction)
+          @transaction_manager.get_transaction(transaction_id)
+        end
+        if transaction && @transaction_manager.respond_to?(:rollback_transaction)
+          @transaction_manager.rollback_transaction(transaction)
+        end
+        @lock.synchronize { abort_transaction_unlocked(transaction_id) }
+      end
+
+      # Called only while @lock is held. It must never call back into the
+      # transaction manager, whose own mutex may be held by the caller.
+      def abort_transaction_unlocked(transaction_id)
+        transaction = @transactions[transaction_id]
+        if @transaction_manager
+          @deadlock_victims[transaction_id] = transaction if transaction
+        else
+          transaction&.abort
+        end
+
+        @waiting.delete(transaction_id)
+        @locks.each do |key, lock|
+          next unless lock.holders.key?(transaction_id)
+
+          lock.remove_holder(Transaction.new(id: transaction_id))
+          @locks.delete(key) if lock.holders.empty?
+        end
+        @stats[:deadlocks_resolved] += 1
+        @condition.broadcast
+      end
+    end
+  end
+end

data/lib/rubydb/transactions/savepoint.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Transactions
+
+    # Import transaction dependency
+require_relative "transaction"
+    # Savepoint - Represents a savepoint within a transaction
+    class Savepoint
+      attr_reader :name, :transaction, :created_at, :position
+      attr_reader :modified_rows, :locked_rows, :changes
+
+      def initialize(name, transaction)
+        @name = name
+        @transaction = transaction
+        @created_at = Time.now
+        @position = transaction.savepoints.size
+        @modified_rows = {}
+        @locked_rows = {}
+        @changes = []
+        @state = :active
+        @lock = Mutex.new
+        
+        # Save current state
+        save_state
+      end
+
+      def active?
+        @state == :active
+      end
+
+      def released?
+        @state == :released
+      end
+
+      def rollbacked?
+        @state == :rollbacked
+      end
+
+      def rollback
+        @lock.synchronize do
+          return false unless active?
+          
+          # Rollback changes in reverse order
+          @changes.reverse.each do |change|
+            undo_change(change)
+          end
+          
+          @state = :rollbacked
+          true
+        end
+      end
+
+      def release
+        @lock.synchronize do
+          return false unless active?
+          @state = :released
+          true
+        end
+      end
+
+      def record_change(change)
+        @lock.synchronize do
+          @changes << change
+        end
+      end
+
+      def record_modified_row(table_name, row_id, old_value, new_value)
+        @lock.synchronize do
+          @modified_rows[row_id] = {
+            table: table_name,
+            old: old_value,
+            new: new_value
+          }
+        end
+      end
+
+      def record_locked_row(table_name, row_id, lock_type)
+        @lock.synchronize do
+          key = "#{table_name}:#{row_id}"
+          @locked_rows[key] = {
+            table: table_name,
+            row_id: row_id,
+            lock_type: lock_type
+          }
+        end
+      end
+
+      def to_hash
+        {
+          name: @name,
+          position: @position,
+          created_at: @created_at.iso8601,
+          state: @state,
+          changes: @changes.size,
+          modified_rows: @modified_rows.size,
+          locked_rows: @locked_rows.size
+        }
+      end
+
+      def inspect
+        "#<Savepoint name=#{@name} position=#{@position} state=#{@state}>"
+      end
+
+      private
+
+      def save_state
+        # Save current transaction state
+        @transaction.modified_rows.each do |row_id, info|
+          @modified_rows[row_id] = info.dup
+        end
+        @transaction.locked_rows.each do |key, info|
+          @locked_rows[key] = info.dup
+        end
+      end
+
+      def undo_change(change)
+        case change[:type]
+        when :insert
+          # Delete inserted row
+          @transaction.instance_variable_get(:@engine).delete_row(
+            change[:table],
+            change[:row_id]
+          )
+        when :update
+          # Restore old values
+          @transaction.instance_variable_get(:@engine).update_row(
+            change[:table],
+            change[:row_id],
+            change[:old_values]
+          )
+        when :delete
+          # Reinsert deleted row
+          @transaction.instance_variable_get(:@engine).insert_row(
+            change[:table],
+            change[:columns],
+            change[:row_data]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/transactions/transaction.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+
+# Import dependencies
+require_relative "savepoint"      # For Savepoint class
+require_relative "transaction_id"
+
+module RubyDB
+  module Transactions
+    # Transaction - Represents a database transaction
+    class Transaction
+      attr_reader :id, :start_time, :status, :isolation_level, :read_only, :priority
+      attr_reader :timeout
+      attr_reader :savepoints, :locked_rows, :modified_rows, :accessed_tables
+      attr_reader :changes
+      attr_accessor :parent_transaction
+
+      # Transaction statuses
+      STATUS_ACTIVE = :active
+      STATUS_COMMITTED = :committed
+      STATUS_ABORTED = :aborted
+      STATUS_PREPARED = :prepared
+      STATUS_IN_DOUBT = :in_doubt
+
+      def initialize(options = {})
+        @id = options[:id] || generate_id
+        @start_time = Time.now
+        @status = STATUS_ACTIVE
+        @isolation_level = options[:isolation_level] || :read_committed
+        @read_only = options[:read_only] || false
+        @parent_transaction = options[:parent]
+        @savepoints = []
+        @locked_rows = {}
+        @modified_rows = {}
+        @accessed_tables = Set.new
+        @changes = []
+        @undo_log = []
+        @timeout = options[:timeout] || 30  # 30 seconds default
+        @deadline = @start_time + @timeout
+        @lock = Mutex.new
+        @name = options[:name]
+        @priority = options[:priority] || 0
+      end
+
+      def active?
+        @status == STATUS_ACTIVE
+      end
+
+      def committed?
+        @status == STATUS_COMMITTED
+      end
+
+      def aborted?
+        @status == STATUS_ABORTED
+      end
+
+      def prepared?
+        @status == STATUS_PREPARED
+      end
+
+      def in_doubt?
+        @status == STATUS_IN_DOUBT
+      end
+
+      def expired?
+        Time.now > @deadline
+      end
+
+      def add_change(change)
+        @lock.synchronize do
+          @changes << change
+          @undo_log << create_undo_entry(change)
+        end
+      end
+
+      def add_modified_row(table_name, row_id, old_value, new_value)
+        @lock.synchronize do
+          @modified_rows[row_id] ||= {
+            table: table_name,
+            old: old_value,
+            new: new_value,
+            timestamp: Time.now
+          }
+        end
+      end
+
+      def add_locked_row(table_name, row_id, lock_type)
+        @lock.synchronize do
+          key = "#{table_name}:#{row_id}"
+          @locked_rows[key] = {
+            table: table_name,
+            row_id: row_id,
+            lock_type: lock_type,
+            timestamp: Time.now
+          }
+        end
+      end
+
+      def add_accessed_table(table_name)
+        @lock.synchronize do
+          @accessed_tables.add(table_name)
+        end
+      end
+
+      def create_savepoint(name = nil)
+        @lock.synchronize do
+          savepoint = Savepoint.new(name || "savepoint_#{@savepoints.size + 1}", self)
+          @savepoints << savepoint
+          savepoint
+        end
+      end
+
+      def rollback_to_savepoint(name)
+        @lock.synchronize do
+          index = @savepoints.index { |sp| sp.name == name }
+          return false unless index
+
+          # Rollback changes after this savepoint
+          @savepoints[index + 1..-1].each do |sp|
+            sp.rollback
+          end
+          @savepoints = @savepoints[0..index]
+
+          true
+        end
+      end
+
+      def release_savepoint(name)
+        @lock.synchronize do
+          index = @savepoints.index { |sp| sp.name == name }
+          return false unless index
+
+          @savepoints.delete_at(index)
+          true
+        end
+      end
+
+      def commit
+        @lock.synchronize do
+          return false unless active?
+          @status = STATUS_COMMITTED
+          @commit_time = Time.now
+          true
+        end
+      end
+
+      def abort
+        @lock.synchronize do
+          return false unless active?
+          @status = STATUS_ABORTED
+          @abort_time = Time.now
+          true
+        end
+      end
+
+      def prepare
+        @lock.synchronize do
+          return false unless active?
+          @status = STATUS_PREPARED
+          @prepare_time = Time.now
+          true
+        end
+      end
+
+      def mark_in_doubt
+        @lock.synchronize do
+          @status = STATUS_IN_DOUBT
+          @in_doubt_time = Time.now
+        end
+      end
+
+      def to_hash
+        {
+          id: @id,
+          start_time: @start_time.iso8601,
+          status: @status,
+          isolation_level: @isolation_level,
+          read_only: @read_only,
+          changes: @changes.size,
+          locked_rows: @locked_rows.size,
+          modified_rows: @modified_rows.size,
+          accessed_tables: @accessed_tables.to_a,
+          savepoints: @savepoints.map(&:name),
+          timeout: @timeout,
+          expired: expired?
+        }
+      end
+
+      def inspect
+        "#<Transaction id=#{@id} status=#{@status} isolation=#{@isolation_level}>"
+      end
+
+      def to_s
+        inspect
+      end
+
+      private
+
+      def generate_id
+        "txn_#{Time.now.to_i}_#{SecureRandom.hex(8)}"
+      end
+
+      def create_undo_entry(change)
+        {
+          change: change,
+          timestamp: Time.now,
+          type: change[:type]
+        }
+      end
+    end
+  end
+end