rubydb 0.1.4 → 0.1.5

data/lib/rubydb/wal/record.rb

@@ -1,105 +1,105 @@
-# frozen_string_literal: true
-
-require "json"
-require "digest"
-require "time"
-require_relative "../errors/corruption_error"
-
-module RubyDB
-  module WAL
-    # Record - A single WAL record
-    class Record
-      # Record types
-      TYPE_BEGIN = :begin
-      TYPE_COMMIT = :commit
-      TYPE_ROLLBACK = :rollback
-      TYPE_INSERT = :insert
-      TYPE_UPDATE = :update
-      TYPE_DELETE = :delete
-      TYPE_CREATE_TABLE = :create_table
-      TYPE_DROP_TABLE = :drop_table
-      TYPE_CREATE_INDEX = :create_index
-      TYPE_DROP_INDEX = :drop_index
-      TYPE_CHECKPOINT = :checkpoint
-      TYPE_SCHEMA_CHANGE = :schema_change
-      TYPE_PREPARE = :prepare
-      TYPE_SAVEPOINT = :savepoint
-
-      attr_reader :lsn, :type, :data, :transaction_id, :timestamp
-      attr_reader :checksum, :prev_lsn, :size
-
-      def initialize(type, data = {}, transaction_id: nil, prev_lsn: nil)
-        @type = type
-        @data = data
-        @transaction_id = transaction_id
-        @prev_lsn = prev_lsn
-        @timestamp = Time.now
-        @lsn = nil
-        @checksum = nil
-        @size = 0
-      end
-
-      def serialize
-        # Build record data
-        record_data = {
-          type: @type,
-          transaction_id: @transaction_id,
-          prev_lsn: @prev_lsn&.to_s,
-          timestamp: @timestamp.iso8601,
-          data: @data
-        }
-
-        json_data = JSON.generate(record_data)
-        # The serialized payload is checksum (16 ASCII bytes) followed by JSON.
-        # Segment framing is owned by Segment, so this is the payload size.
-        @size = json_data.bytesize + 16
-
-        # Calculate checksum
-        @checksum = Digest::SHA256.hexdigest(json_data)[0...16]
-
-        # Return serialized record
-        {
-          checksum: @checksum,
-          data: json_data,
-          size: @size
-        }
-      end
-
-      def self.deserialize(raw_data, lsn)
-        checksum = raw_data[0...16]
-        json_data = raw_data[16..-1]
-
-        # Verify checksum
-        calculated = Digest::SHA256.hexdigest(json_data)[0...16]
-        raise CorruptionError, "WAL record checksum mismatch" if calculated != checksum
-
-        parsed = JSON.parse(json_data, symbolize_names: true)
-
-        record = new(
-          parsed[:type].to_sym,
-          parsed[:data] || {},
-          transaction_id: parsed[:transaction_id],
-          prev_lsn: parsed[:prev_lsn] ? LSN.from_s(parsed[:prev_lsn]) : nil
-        )
-        record.instance_variable_set(:@timestamp, Time.parse(parsed[:timestamp]))
-        record.instance_variable_set(:@lsn, lsn)
-        record.instance_variable_set(:@checksum, checksum)
-        record.instance_variable_set(:@size, raw_data.bytesize)
-
-        record
-      end
-
-      def to_s
-        "WALRecord(lsn=#{@lsn}, type=#{@type}, txn=#{@transaction_id})"
-      end
-
-      def inspect
-        to_s
-      end
-
-      def size
-        @size || 0
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+require "time"
+require_relative "../errors/corruption_error"
+
+module RubyDB
+  module WAL
+    # Record - A single WAL record
+    class Record
+      # Record types
+      TYPE_BEGIN = :begin
+      TYPE_COMMIT = :commit
+      TYPE_ROLLBACK = :rollback
+      TYPE_INSERT = :insert
+      TYPE_UPDATE = :update
+      TYPE_DELETE = :delete
+      TYPE_CREATE_TABLE = :create_table
+      TYPE_DROP_TABLE = :drop_table
+      TYPE_CREATE_INDEX = :create_index
+      TYPE_DROP_INDEX = :drop_index
+      TYPE_CHECKPOINT = :checkpoint
+      TYPE_SCHEMA_CHANGE = :schema_change
+      TYPE_PREPARE = :prepare
+      TYPE_SAVEPOINT = :savepoint
+
+      attr_reader :lsn, :type, :data, :transaction_id, :timestamp
+      attr_reader :checksum, :prev_lsn, :size
+
+      def initialize(type, data = {}, transaction_id: nil, prev_lsn: nil)
+        @type = type
+        @data = data
+        @transaction_id = transaction_id
+        @prev_lsn = prev_lsn
+        @timestamp = Time.now
+        @lsn = nil
+        @checksum = nil
+        @size = 0
+      end
+
+      def serialize
+        # Build record data
+        record_data = {
+          type: @type,
+          transaction_id: @transaction_id,
+          prev_lsn: @prev_lsn&.to_s,
+          timestamp: @timestamp.iso8601,
+          data: @data
+        }
+
+        json_data = JSON.generate(record_data)
+        # The serialized payload is checksum (16 ASCII bytes) followed by JSON.
+        # Segment framing is owned by Segment, so this is the payload size.
+        @size = json_data.bytesize + 16
+
+        # Calculate checksum
+        @checksum = Digest::SHA256.hexdigest(json_data)[0...16]
+
+        # Return serialized record
+        {
+          checksum: @checksum,
+          data: json_data,
+          size: @size
+        }
+      end
+
+      def self.deserialize(raw_data, lsn)
+        checksum = raw_data[0...16]
+        json_data = raw_data[16..]
+
+        # Verify checksum
+        calculated = Digest::SHA256.hexdigest(json_data)[0...16]
+        raise CorruptionError, "WAL record checksum mismatch" if calculated != checksum
+
+        parsed = JSON.parse(json_data, symbolize_names: true)
+
+        record = new(
+          parsed[:type].to_sym,
+          parsed[:data] || {},
+          transaction_id: parsed[:transaction_id],
+          prev_lsn: parsed[:prev_lsn] ? LSN.from_s(parsed[:prev_lsn]) : nil
+        )
+        record.instance_variable_set(:@timestamp, Time.parse(parsed[:timestamp]))
+        record.instance_variable_set(:@lsn, lsn)
+        record.instance_variable_set(:@checksum, checksum)
+        record.instance_variable_set(:@size, raw_data.bytesize)
+
+        record
+      end
+
+      def to_s
+        "WALRecord(lsn=#{@lsn}, type=#{@type}, txn=#{@transaction_id})"
+      end
+
+      def inspect
+        to_s
+      end
+
+      def size
+        @size || 0
+      end
+    end
+  end
+end

data/lib/rubydb/wal/segment.rb

@@ -1,193 +1,193 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module RubyDB
-  module WAL
-    # Segment - A WAL segment file
-    class Segment
-      attr_reader :segment_id, :path, :size, :max_size
-      attr_reader :first_lsn, :last_lsn, :record_count
-
-      DEFAULT_MAX_SIZE = 16 * 1024 * 1024  # 16MB
-      FRAME_HEADER_SIZE = 4
-
-      def initialize(segment_id, wal_dir, max_size = DEFAULT_MAX_SIZE)
-        @segment_id = segment_id
-        @wal_dir = wal_dir
-        @max_size = max_size
-        @path = File.join(wal_dir, "wal_#{segment_id.to_s.rjust(8, '0')}.log")
-        @size = 0
-        @record_count = 0
-        @first_lsn = nil
-        @last_lsn = nil
-        @file = nil
-        @is_open = false
-        @is_full = false
-        @lock = Mutex.new
-      end
-
-      def open
-        @lock.synchronize do
-          return if @is_open
-
-          FileUtils.mkdir_p(@wal_dir) unless Dir.exist?(@wal_dir)
-
-          if File.exist?(@path)
-            @file = File.open(@path, "a+b")
-            @size = File.size(@path)
-            @record_count = count_records
-          else
-            @file = File.open(@path, "w+b")
-            @size = 0
-            @record_count = 0
-          end
-
-          @is_open = true
-          self
-        end
-      end
-
-      def close
-        @lock.synchronize do
-          return unless @is_open
-
-          @file.close if @file
-          @is_open = false
-          true
-        end
-      end
-
-      def append(record_data, lsn)
-        @lock.synchronize do
-          raise "Segment is full" if @is_full
-          raise "Segment not open" unless @is_open
-
-          # Each record is framed as a 4-byte big-endian payload length followed
-          # by the checksum+JSON payload. This makes records independently
-          # readable and lets recovery safely stop at a torn tail record.
-          frame = [record_data.bytesize].pack("N") + record_data
-
-          # Write record
-          @file.seek(0, IO::SEEK_END)
-          @file.write(frame)
-          @file.flush
-
-          @size += frame.bytesize
-          @record_count += 1
-
-          @first_lsn ||= lsn
-          @last_lsn = lsn
-
-          # Check if segment is full
-          if @size >= @max_size
-            @is_full = true
-            return :full
-          end
-
-          :ok
-        end
-      end
-
-      def read_at(offset, length)
-        @lock.synchronize do
-          raise "Segment not open" unless @is_open
-
-          @file.seek(offset)
-          @file.read(length)
-        end
-      end
-
-      def read_record_at(offset)
-        @lock.synchronize do
-          raise "Segment not open" unless @is_open
-
-          @file.seek(offset)
-          header = @file.read(FRAME_HEADER_SIZE)
-          return nil if header.nil? || header.empty?
-          return nil if header.bytesize < FRAME_HEADER_SIZE
-
-          payload_size = header.unpack1("N")
-          return nil if payload_size < 16
-
-          payload = @file.read(payload_size)
-          return nil if payload.nil? || payload.bytesize < payload_size
-
-          payload
-        end
-      end
-
-      def truncate
-        @lock.synchronize do
-          return unless @is_open
-
-          @file.truncate(0)
-          @size = 0
-          @record_count = 0
-          @first_lsn = nil
-          @last_lsn = nil
-          @is_full = false
-          true
-        end
-      end
-
-      def full?
-        @is_full
-      end
-
-      def open?
-        @is_open
-      end
-
-      def exists?
-        File.exist?(@path)
-      end
-
-      def delete
-        @lock.synchronize do
-          close if @is_open
-          File.delete(@path) if exists?
-          true
-        end
-      end
-
-      def archive
-        # Move segment to archive
-        archived_path = File.join(@wal_dir, "archive", "wal_#{@segment_id.to_s.rjust(8, '0')}.log")
-        FileUtils.mkdir_p(File.dirname(archived_path))
-        FileUtils.mv(@path, archived_path)
-        archived_path
-      end
-
-      def to_s
-        "Segment(#{@segment_id}, size=#{@size}, records=#{@record_count}, full=#{@is_full})"
-      end
-
-      def inspect
-        to_s
-      end
-
-      private
-
-      def count_records
-        count = 0
-        offset = 0
-        loop do
-          @file.seek(offset)
-          header = @file.read(FRAME_HEADER_SIZE)
-          break if header.nil? || header.bytesize < FRAME_HEADER_SIZE
-
-          payload_size = header.unpack1("N")
-          break if payload_size < 16
-
-          payload = @file.read(payload_size)
-          break if payload.nil? || payload.bytesize < payload_size
-
-          count += 1
-          offset += FRAME_HEADER_SIZE + payload_size
-        end
-        count
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "fileutils"
+
+module RubyDB
+  module WAL
+    # Segment - A WAL segment file
+    class Segment
+      attr_reader :segment_id, :path, :size, :max_size
+      attr_reader :first_lsn, :last_lsn, :record_count
+
+      DEFAULT_MAX_SIZE = 16 * 1024 * 1024  # 16MB
+      FRAME_HEADER_SIZE = 4
+
+      def initialize(segment_id, wal_dir, max_size = DEFAULT_MAX_SIZE)
+        @segment_id = segment_id
+        @wal_dir = wal_dir
+        @max_size = max_size
+        @path = File.join(wal_dir, "wal_#{segment_id.to_s.rjust(8, "0")}.log")
+        @size = 0
+        @record_count = 0
+        @first_lsn = nil
+        @last_lsn = nil
+        @file = nil
+        @is_open = false
+        @is_full = false
+        @lock = Mutex.new
+      end
+
+      def open
+        @lock.synchronize do
+          return if @is_open
+
+          FileUtils.mkdir_p(@wal_dir) unless Dir.exist?(@wal_dir)
+
+          if File.exist?(@path)
+            @file = File.open(@path, "a+b")
+            @size = File.size(@path)
+            @record_count = count_records
+          else
+            @file = File.open(@path, "w+b")
+            @size = 0
+            @record_count = 0
+          end
+
+          @is_open = true
+          self
+        end
+      end
+
+      def close
+        @lock.synchronize do
+          return unless @is_open
+
+          @file&.close
+          @is_open = false
+          true
+        end
+      end
+
+      def append(record_data, lsn)
+        @lock.synchronize do
+          raise "Segment is full" if @is_full
+          raise "Segment not open" unless @is_open
+
+          # Each record is framed as a 4-byte big-endian payload length followed
+          # by the checksum+JSON payload. This makes records independently
+          # readable and lets recovery safely stop at a torn tail record.
+          frame = [record_data.bytesize].pack("N") + record_data
+
+          # Write record
+          @file.seek(0, IO::SEEK_END)
+          @file.write(frame)
+          @file.flush
+
+          @size += frame.bytesize
+          @record_count += 1
+
+          @first_lsn ||= lsn
+          @last_lsn = lsn
+
+          # Check if segment is full
+          if @size >= @max_size
+            @is_full = true
+            return :full
+          end
+
+          :ok
+        end
+      end
+
+      def read_at(offset, length)
+        @lock.synchronize do
+          raise "Segment not open" unless @is_open
+
+          @file.seek(offset)
+          @file.read(length)
+        end
+      end
+
+      def read_record_at(offset)
+        @lock.synchronize do
+          raise "Segment not open" unless @is_open
+
+          @file.seek(offset)
+          header = @file.read(FRAME_HEADER_SIZE)
+          return nil if header.nil? || header.empty?
+          return nil if header.bytesize < FRAME_HEADER_SIZE
+
+          payload_size = header.unpack1("N")
+          return nil if payload_size < 16
+
+          payload = @file.read(payload_size)
+          return nil if payload.nil? || payload.bytesize < payload_size
+
+          payload
+        end
+      end
+
+      def truncate
+        @lock.synchronize do
+          return unless @is_open
+
+          @file.truncate(0)
+          @size = 0
+          @record_count = 0
+          @first_lsn = nil
+          @last_lsn = nil
+          @is_full = false
+          true
+        end
+      end
+
+      def full?
+        @is_full
+      end
+
+      def open?
+        @is_open
+      end
+
+      def exists?
+        File.exist?(@path)
+      end
+
+      def delete
+        @lock.synchronize do
+          close if @is_open
+          File.delete(@path) if exists?
+          true
+        end
+      end
+
+      def archive
+        # Move segment to archive
+        archived_path = File.join(@wal_dir, "archive", "wal_#{@segment_id.to_s.rjust(8, "0")}.log")
+        FileUtils.mkdir_p(File.dirname(archived_path))
+        FileUtils.mv(@path, archived_path)
+        archived_path
+      end
+
+      def to_s
+        "Segment(#{@segment_id}, size=#{@size}, records=#{@record_count}, full=#{@is_full})"
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      def count_records
+        count = 0
+        offset = 0
+        loop do
+          @file.seek(offset)
+          header = @file.read(FRAME_HEADER_SIZE)
+          break if header.nil? || header.bytesize < FRAME_HEADER_SIZE
+
+          payload_size = header.unpack1("N")
+          break if payload_size < 16
+
+          payload = @file.read(payload_size)
+          break if payload.nil? || payload.bytesize < payload_size
+
+          count += 1
+          offset += FRAME_HEADER_SIZE + payload_size
+        end
+        count
+      end
+    end
+  end
+end