rubydb 0.1.0

data/lib/rubydb/transactions/transaction_manager.rb

@@ -0,0 +1,435 @@
+# frozen_string_literal: true
+
+require "set"
+require "concurrent"
+
+# Import all transaction components
+require_relative "transaction"
+require_relative "transaction_id"
+require_relative "lock_manager"
+require_relative "commit_manager"
+require_relative "transaction_log"
+require_relative "isolation"
+require_relative "savepoint"
+
+# Import engine for rollback operations
+require_relative "../storage/engine"
+
+module RubyDB
+  module Transactions
+    # TransactionManager - Manages all database transactions
+    class TransactionManager
+      attr_reader :active_transactions, :committed_transactions, :aborted_transactions
+      attr_reader :lock_manager, :commit_manager, :stats
+
+      def initialize(engine, config = {})
+        @engine = engine
+        @config = config
+        @active_transactions = {}
+        @committed_transactions = []
+        @aborted_transactions = []
+        @transaction_log = TransactionLog.new(config[:log_path])
+        @lock_manager = LockManager.new(config.merge(transaction_manager: self))
+        @commit_manager = CommitManager.new(self, config)
+        @stats = {
+          transactions_started: 0,
+          transactions_committed: 0,
+          transactions_aborted: 0,
+          transactions_prepared: 0,
+          transactions_in_doubt: 0,
+          deadlocks_detected: 0,
+          deadlocks_resolved: 0,
+          lock_timeouts: 0,
+          total_commit_time_ms: 0,
+          total_rollback_time_ms: 0
+        }
+        @next_txn_id = 1
+        @lock = Mutex.new
+        @cleanup_thread = nil
+        
+        # Start cleanup thread
+        start_cleanup_thread if config[:auto_cleanup] != false
+        
+        # Recover transactions on startup
+        recover if config[:recovery] != false
+      end
+
+      def begin_transaction(options = {})
+        @lock.synchronize do
+          txn = Transaction.new({
+            id: generate_id,
+            isolation_level: options[:isolation_level] || :read_committed,
+            read_only: options[:read_only] || false,
+            timeout: options[:timeout] || 30,
+            priority: options[:priority] || 0,
+            name: options[:name]
+          })
+
+          @active_transactions[txn.id] = txn
+          @stats[:transactions_started] += 1
+          
+          # Log transaction start
+          @transaction_log.log_start(txn)
+          
+          txn
+        end
+      end
+
+      def commit_transaction(transaction)
+        @lock.synchronize do
+          return false unless transaction && transaction.active?
+          
+          start_time = Time.now
+          
+          # Check for conflicts
+          if detect_conflicts(transaction)
+            @stats[:deadlocks_detected] += 1
+            return false
+          end
+          
+          # Prepare transaction
+          transaction.prepare
+          @stats[:transactions_prepared] += 1
+          
+          # Log prepare
+          @transaction_log.log_prepare(transaction)
+          
+          # Commit
+          @commit_manager.commit(transaction)
+          
+          # Update stats
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:transactions_committed] += 1
+          @stats[:total_commit_time_ms] += elapsed_ms
+          
+          # Log commit
+          @transaction_log.log_commit(transaction)
+          
+          # Move to committed
+          @active_transactions.delete(transaction.id)
+          @committed_transactions << transaction
+          
+          # Clean old committed transactions
+          cleanup_committed_transactions if @committed_transactions.size > 1000
+          
+          true
+        end
+      end
+
+      def rollback_transaction(transaction)
+        @lock.synchronize do
+          return false unless transaction && transaction.active?
+          
+          start_time = Time.now
+          
+          # Rollback changes
+          rollback_changes(transaction)
+          
+          # Abort transaction
+          transaction.abort
+          @stats[:transactions_aborted] += 1
+          
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:total_rollback_time_ms] += elapsed_ms
+          
+          # Log rollback
+          @transaction_log.log_rollback(transaction)
+          
+          # Move to aborted
+          @active_transactions.delete(transaction.id)
+          @aborted_transactions << transaction
+          
+          # Clean old aborted transactions
+          cleanup_aborted_transactions if @aborted_transactions.size > 1000
+          
+          true
+        end
+      end
+
+      def get_transaction(id)
+        @lock.synchronize do
+          @active_transactions[id] || 
+          @committed_transactions.find { |t| t.id == id } ||
+          @aborted_transactions.find { |t| t.id == id }
+        end
+      end
+
+      def active_transaction_count
+        @active_transactions.size
+      end
+
+      def find_latest_transaction
+        @lock.synchronize do
+          all = @committed_transactions + @aborted_transactions
+          all.max_by { |t| t.start_time }
+        end
+      end
+
+      def detect_deadlock
+        cycles = detect_cycles(build_wait_for_graph)
+        return false if cycles.empty?
+
+        @lock.synchronize { @stats[:deadlocks_detected] += cycles.size }
+        cycles.each { |cycle| resolve_deadlock(cycle) }
+        true
+      end
+
+      def resolve_deadlock(cycle)
+        transactions = Array(cycle).filter_map do |entry|
+          if entry.respond_to?(:priority)
+            entry
+          else
+            @lock.synchronize { @active_transactions[entry] }
+          end
+        end
+        victim = @lock.synchronize do
+          transactions.min_by { |transaction| transaction.priority.to_i }
+        end
+        return nil unless victim
+
+        rollback_transaction(victim)
+        @lock.synchronize { @stats[:deadlocks_resolved] += 1 }
+        victim
+      end
+
+      def acquire_lock(transaction, table_name, row_id, lock_type)
+        valid = @lock.synchronize do
+          return false unless transaction.active?
+
+          # Check for timeout
+          if transaction.expired?
+            @stats[:lock_timeouts] += 1
+            return false
+          end
+          true
+        end
+        return false unless valid
+
+        # Do not hold the transaction-manager mutex while a lock wait blocks;
+        # deadlock resolution must be able to return through this method.
+        result = @lock_manager.acquire_lock(
+          transaction,
+          table_name,
+          row_id,
+          lock_type,
+          transaction.timeout
+        )
+
+        if result
+          transaction.add_locked_row(table_name, row_id, lock_type)
+        elsif @lock_manager.deadlock_victim?(transaction.id)
+          @lock.synchronize do
+            @stats[:deadlocks_detected] += 1
+          end
+          rollback_transaction(transaction)
+          @lock_manager.clear_deadlock_victim(transaction.id)
+        end
+
+        result
+      end
+
+      def release_locks(transaction)
+        @lock.synchronize do
+          @lock_manager.release_locks(transaction)
+          transaction.locked_rows.clear
+          true
+        end
+      end
+
+      def release_all_locks
+        @lock.synchronize do
+          @lock_manager.release_all_locks
+          @active_transactions.each do |_, txn|
+            txn.locked_rows.clear
+          end
+          true
+        end
+      end
+
+      def recover
+        @lock.synchronize do
+          # Recover from transaction log
+          recovery = @transaction_log.recover
+          entries = recovery[:entries] || []
+          
+          entries.each do |entry|
+            case entry[:type]
+            when :prepare
+              # Transaction was prepared but not committed
+              txn = get_transaction(entry[:transaction_id])
+              if txn && txn.prepared?
+                # Commit if we can
+                if can_commit?(txn)
+                  commit_transaction(txn)
+                else
+                  txn.mark_in_doubt
+                  @stats[:transactions_in_doubt] += 1
+                end
+              end
+            when :commit
+              # Already committed
+            when :rollback
+              # Already rolled back
+            end
+          end
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            active_count: @active_transactions.size,
+            committed_count: @committed_transactions.size,
+            aborted_count: @aborted_transactions.size,
+            in_doubt_count: @active_transactions.count { |_, t| t.in_doubt? },
+            avg_commit_time: average_commit_time,
+            avg_rollback_time: average_rollback_time,
+            locks_held: @lock_manager.total_locks,
+            lock_waiting: @lock_manager.waiting_transactions
+          })
+        end
+      end
+
+      private
+
+      def generate_id
+        "txn_#{Time.now.to_i}_#{@next_txn_id}"
+      ensure
+        @next_txn_id += 1
+      end
+
+      def rollback_changes(transaction)
+        # Rollback in reverse order
+        transaction.modified_rows.each do |row_id, info|
+          @engine.update_row(info[:table], row_id, info[:old])
+        end
+        transaction.changes.reverse.each do |change|
+          undo_change(change)
+        end
+      end
+
+      def undo_change(change)
+        case change[:type]
+        when :insert
+          # Delete inserted row
+          @engine.delete_row(change[:table], change[:row_id])
+        when :update
+          # Restore old values
+          @engine.update_row(change[:table], change[:row_id], change[:old_values])
+        when :delete
+          # Reinsert deleted row
+          @engine.insert_row(change[:table], change[:columns], change[:row_data])
+        end
+      end
+
+      def detect_conflicts(transaction)
+        # Check for write-write conflicts
+        transaction.modified_rows.each do |row_id, info|
+          @active_transactions.each do |_, other_txn|
+            next if other_txn.id == transaction.id
+            
+            if other_txn.modified_rows.key?(row_id)
+              return true
+            end
+          end
+        end
+        
+        false
+      end
+
+      def build_wait_for_graph
+        @lock_manager.wait_for_graph
+      end
+
+      def detect_cycles(graph)
+        cycles = []
+        visited = Set.new
+        active = Set.new
+        path = []
+
+        graph.each_key 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.include?(cycle)
+          return
+        end
+        return if visited.include?(node)
+
+        visited.add(node)
+        active.add(node)
+        path << node
+
+        graph[node]&.each { |neighbor| detect_cycle_dfs(neighbor, graph, visited, active, path, cycles) }
+
+        path.pop
+        active.delete(node)
+      end
+
+      def can_commit?(transaction)
+        # Check if all prerequisites are met
+        transaction.modified_rows.each do |_, info|
+          # Check if no other active transaction modified the same row
+          @active_transactions.each do |_, other|
+            next if other.id == transaction.id
+            if other.modified_rows.key?(info[:row_id])
+              return false
+            end
+          end
+        end
+        
+        true
+      end
+
+      def cleanup_committed_transactions
+        if @committed_transactions.size > 1000
+          @committed_transactions = @committed_transactions.last(100)
+        end
+      end
+
+      def cleanup_aborted_transactions
+        if @aborted_transactions.size > 1000
+          @aborted_transactions = @aborted_transactions.last(100)
+        end
+      end
+
+      def average_commit_time
+        return 0 if @stats[:transactions_committed] == 0
+        @stats[:total_commit_time_ms] / @stats[:transactions_committed]
+      end
+
+      def average_rollback_time
+        return 0 if @stats[:transactions_aborted] == 0
+        @stats[:total_rollback_time_ms] / @stats[:transactions_aborted]
+      end
+
+      def start_cleanup_thread
+        @cleanup_thread = Thread.new do
+          loop do
+            sleep(60)  # Run every minute
+            
+            begin
+              # Cleanup expired transactions
+              @active_transactions.each do |id, txn|
+                if txn.expired?
+                  rollback_transaction(txn)
+                end
+              end
+              
+              # Detect deadlocks
+              detect_deadlock
+            rescue => e
+              # Log error but continue
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/types/bigint.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # 64-bit signed integer
+    class BigInt < Type
+      RANGE = (-9_223_372_036_854_775_808..9_223_372_036_854_775_807).freeze
+      SIZE = 8
+
+      def initialize
+        super(:bigint, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        [value.to_i].pack("q>")  # Big-endian 64-bit signed
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.unpack("q>").first
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid bigint: #{value}" unless value.is_a?(::Integer)
+        raise ConstraintError, "BigInt out of range: #{value}" unless RANGE.include?(value)
+        true
+      end
+
+      def default
+        0
+      end
+    end
+  end
+end

data/lib/rubydb/types/blob.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # Binary large object (arbitrary binary data)
+    class Blob < Type
+      def initialize
+        super(:blob)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "".b if value.nil?
+        value.is_a?(String) ? value.b : value.to_s.b
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.b
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid blob: #{value}" unless value.respond_to?(:to_s)
+        true
+      end
+
+      def default
+        "".b
+      end
+
+      def storage_size
+        nil  # Variable length
+      end
+    end
+  end
+end

data/lib/rubydb/types/boolean.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # Boolean type (true/false)
+    class Boolean < Type
+      SIZE = 1
+
+      def initialize
+        super(:boolean, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        value ? "\x01".b : "\x00".b
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.unpack("C").first == 1
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid boolean: #{value}" unless [true, false].include?(value)
+        true
+      end
+
+      def default
+        false
+      end
+    end
+  end
+end

data/lib/rubydb/types/date.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "date"
+
+module RubyDB
+  module Types
+    # Date type (year, month, day)
+    class Date < Type
+      SIZE = 4  # Days since epoch (stored as integer)
+
+      def initialize
+        super(:date, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "\x00" * SIZE if value.nil?
+        days = value - Date.new(1970, 1, 1)
+        [days.to_i].pack("l>")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        days = bytes.unpack("l>").first
+        Date.new(1970, 1, 1) + days
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid date: #{value}" unless value.is_a?(::Date) || value.is_a?(::DateTime)
+        true
+      end
+
+      def default
+        Date.today
+      end
+    end
+  end
+end

data/lib/rubydb/types/decimal.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module RubyDB
+  module Types
+    # Arbitrary precision decimal
+    class Decimal < Type
+      attr_reader :precision, :scale
+
+      def initialize(precision: 10, scale: 2)
+        super(:decimal, precision: precision, scale: scale)
+        @precision = precision
+        @scale = scale
+      end
+
+      def serialize(value)
+        validate(value)
+        bd = value.is_a?(BigDecimal) ? value : BigDecimal(value.to_s)
+        bd.to_s("F").encode("UTF-8")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        str = bytes.force_encoding("UTF-8")
+        BigDecimal(str)
+      end
+
+      def validate(value)
+        return true if value.nil?
+        bd = value.is_a?(BigDecimal) ? value : BigDecimal(value.to_s)
+        raise ConstraintError, "Invalid decimal: #{value}" unless bd
+        true
+      rescue ArgumentError, TypeError
+        raise ConstraintError, "Invalid decimal: #{value}"
+      end
+
+      def default
+        BigDecimal("0")
+      end
+
+      def storage_size
+        # Variable length, stored as string
+        nil
+      end
+    end
+  end
+end

data/lib/rubydb/types/float.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # 64-bit floating point (Double precision)
+    class Float < Type
+      SIZE = 8
+
+      def initialize
+        super(:float, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        [value.to_f].pack("E")  # Big-endian double
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.unpack("E").first
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid float: #{value}" unless value.is_a?(::Numeric)
+        true
+      end
+
+      def default
+        0.0
+      end
+    end
+  end
+end

data/lib/rubydb/types/integer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # 32-bit signed integer
+    class Integer < Type
+      RANGE = (-2_147_483_648..2_147_483_647).freeze
+      SIZE = 4
+
+      def initialize
+        super(:integer, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        [value.to_i].pack("l>")  # Big-endian 32-bit signed
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.unpack("l>").first
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid integer: #{value}" unless value.is_a?(::Integer)
+        raise ConstraintError, "Integer out of range: #{value}" unless RANGE.include?(value)
+        true
+      end
+
+      def default
+        0
+      end
+    end
+  end
+end