rubydb 0.1.0

data/lib/rubydb/transactions/transaction_id.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Transactions
+    # TransactionId - Represents a unique transaction identifier
+    class TransactionId
+      attr_reader :id, :timestamp, :sequence
+
+      def initialize(id = nil, timestamp = nil, sequence = nil)
+        if id
+          @id = id
+          parse_id(id)
+        else
+          @timestamp = timestamp || Time.now
+          @sequence = sequence || 0
+          @id = generate_id
+        end
+      end
+
+      def to_s
+        @id
+      end
+
+      def to_i
+        @id.hash
+      end
+
+      def ==(other)
+        other.is_a?(TransactionId) && @id == other.id
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        @id.hash
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(TransactionId)
+        @timestamp <=> other.timestamp
+      end
+
+      def <(other)
+        return false unless other.is_a?(TransactionId)
+        @timestamp < other.timestamp
+      end
+
+      def >(other)
+        return false unless other.is_a?(TransactionId)
+        @timestamp > other.timestamp
+      end
+
+      def inspect
+        "#<TransactionId id=#{@id} timestamp=#{@timestamp}>"
+      end
+
+      def serialize
+        @id
+      end
+
+      def self.deserialize(id)
+        new(id)
+      end
+
+      private
+
+      def generate_id
+        "txn_#{@timestamp.to_i}_#{@sequence}"
+      end
+
+      def parse_id(id)
+        if id =~ /txn_(\d+)_(\d+)/
+          @timestamp = Time.at($1.to_i)
+          @sequence = $2.to_i
+        else
+          @timestamp = Time.now
+          @sequence = 0
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/transactions/transaction_log.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+# Import transaction for serialization
+require_relative "transaction"
+
+module RubyDB
+  module Transactions
+    # TransactionLog - Logs transaction operations for recovery
+    class TransactionLog
+      attr_reader :log_path, :stats
+
+      # Log entry types
+      ENTRY_START = :start
+      ENTRY_PREPARE = :prepare
+      ENTRY_COMMIT = :commit
+      ENTRY_ROLLBACK = :rollback
+      ENTRY_CHANGE = :change
+      ENTRY_SAVEPOINT = :savepoint
+      ENTRY_CHECKPOINT = :checkpoint
+
+      def initialize(log_path = nil)
+        @log_path = log_path || "transaction.log"
+        @log_file = nil
+        @current_lsn = 0
+        @checkpoint_lsn = 0
+        @buffer = []
+        @buffer_size = 1000
+        @stats = {
+          entries_written: 0,
+          entries_read: 0,
+          checkpoints: 0,
+          buffer_flushes: 0,
+          recovery_runs: 0
+        }
+        @lock = Mutex.new
+        @flush_thread = nil
+        
+        create_log_directory
+        open_log_file
+        start_flush_thread
+      end
+
+      def log_start(transaction)
+        write_entry({
+          type: ENTRY_START,
+          transaction_id: transaction.id,
+          timestamp: Time.now.iso8601,
+          isolation_level: transaction.isolation_level,
+          read_only: transaction.read_only
+        })
+      end
+
+      def log_prepare(transaction)
+        write_entry({
+          type: ENTRY_PREPARE,
+          transaction_id: transaction.id,
+          timestamp: Time.now.iso8601,
+          changes: transaction.changes.size,
+          modified_rows: transaction.modified_rows.size
+        })
+      end
+
+      def log_commit(transaction)
+        write_entry({
+          type: ENTRY_COMMIT,
+          transaction_id: transaction.id,
+          timestamp: Time.now.iso8601,
+          commit_time: Time.now.iso8601
+        })
+      end
+
+      def log_rollback(transaction)
+        write_entry({
+          type: ENTRY_ROLLBACK,
+          transaction_id: transaction.id,
+          timestamp: Time.now.iso8601,
+          rollback_time: Time.now.iso8601
+        })
+      end
+
+      def log_change(transaction, change)
+        write_entry({
+          type: ENTRY_CHANGE,
+          transaction_id: transaction.id,
+          timestamp: Time.now.iso8601,
+          change: change
+        })
+      end
+
+      def log_savepoint(transaction, savepoint)
+        write_entry({
+          type: ENTRY_SAVEPOINT,
+          transaction_id: transaction.id,
+          timestamp: Time.now.iso8601,
+          savepoint: savepoint.name,
+          position: savepoint.position
+        })
+      end
+
+      def log_checkpoint
+        @lock.synchronize do
+          @checkpoint_lsn = @current_lsn
+          write_entry({
+            type: ENTRY_CHECKPOINT,
+            timestamp: Time.now.iso8601,
+            lsn: @checkpoint_lsn,
+            active_transactions: active_transactions
+          })
+          @stats[:checkpoints] += 1
+          flush_buffer
+        end
+      end
+
+      def recover
+        @lock.synchronize do
+          @stats[:recovery_runs] += 1
+          
+          entries = []
+          redo_entries = []
+          undo_entries = []
+          
+          # Read all entries from log
+          File.open(@log_path, "r") do |file|
+            file.each_line do |line|
+              entry = JSON.parse(line, symbolize_names: true)
+              entries << entry
+              
+              case entry[:type]
+              when ENTRY_PREPARE, ENTRY_COMMIT
+                redo_entries << entry
+              when ENTRY_START
+                # Track active transactions
+              end
+            end
+          end
+          
+          # Find last checkpoint
+          checkpoint = entries.reverse.find { |e| e[:type] == ENTRY_CHECKPOINT }
+          
+          # REDO: Apply committed transactions
+          committed = Set.new
+          entries.each do |entry|
+            if entry[:type] == ENTRY_COMMIT
+              committed.add(entry[:transaction_id])
+            end
+          end
+          
+          redo_entries.each do |entry|
+            if committed.include?(entry[:transaction_id])
+              # REDO the changes
+            end
+          end
+          
+          # UNDO: Rollback uncommitted transactions
+          entries.each do |entry|
+            if entry[:type] == ENTRY_START && !committed.include?(entry[:transaction_id])
+              # UNDO the changes
+            end
+          end
+          
+          @stats[:entries_read] += entries.size
+          
+          { entries: entries, committed: committed, checkpoint: checkpoint }
+        end
+      end
+
+      def flush
+        @lock.synchronize do
+          flush_buffer
+          @log_file.flush if @log_file
+        end
+      end
+
+      def close
+        @lock.synchronize do
+          flush
+          @log_file.close if @log_file
+          @flush_thread.kill if @flush_thread
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            current_lsn: @current_lsn,
+            checkpoint_lsn: @checkpoint_lsn,
+            buffer_size: @buffer.size
+          })
+        end
+      end
+
+      private
+
+      def create_log_directory
+        dir = File.dirname(@log_path)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      end
+
+      def open_log_file
+        @log_file = File.open(@log_path, "a+")
+        @log_file.sync = false
+      rescue SystemCallError => e
+        raise StorageError, "Failed to open transaction log: #{e.message}"
+      end
+
+      def write_entry(entry)
+        @lock.synchronize do
+          @current_lsn += 1
+          entry[:lsn] = @current_lsn
+          
+          @buffer << entry
+          @stats[:entries_written] += 1
+          
+          if @buffer.size >= @buffer_size
+            flush_buffer
+          end
+        end
+      end
+
+      def flush_buffer
+        return if @buffer.empty?
+        
+        @lock.synchronize do
+          @buffer.each do |entry|
+            @log_file.puts(JSON.generate(entry))
+          end
+          @log_file.flush
+          @buffer.clear
+          @stats[:buffer_flushes] += 1
+        end
+      rescue SystemCallError => e
+        raise StorageError, "Failed to flush transaction log: #{e.message}"
+      end
+
+      def active_transactions
+        # Get active transaction IDs
+        @transaction_manager ? @transaction_manager.active_transactions.keys : []
+      end
+
+      def start_flush_thread
+        @flush_thread = Thread.new do
+          loop do
+            sleep(5)  # Flush every 5 seconds
+            begin
+              flush
+            rescue => e
+              # Log error but continue
+            end
+          end
+        end
+      end
+    end
+  end
+end