rubydb 0.1.4 → 0.1.6

data/lib/rubydb/storage/page_header.rb

@@ -1,67 +1,63 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Storage
-    # PageHeader - Metadata for a page
-    class PageHeader
-      SIZE = 64  # Fixed header size
-
-      attr_accessor :page_number, :page_size, :header_size, :data_end,
-                   :flags, :checksum, :version, :page_type, :next_page,
-                   :prev_page, :free_start, :free_end
-
-      def initialize
-        @page_number = 0
-        @page_size = Constants::DEFAULT_PAGE_SIZE
-        @header_size = SIZE
-        @data_end = SIZE
-        @flags = 0
-        @checksum = 0
-        @version = 1
-        @page_type = 0  # 0=normal, 1=index, 2=overflow, 3=free
-        @next_page = 0
-        @prev_page = 0
-        @free_start = SIZE
-        @free_end = @page_size
-      end
-
-      def flags=(value)
-        @flags = value
-      end
-
-      def page_type=(value)
-        @page_type = value
-      end
-
-      def serialize
-        [
-          @page_number, @page_size, @header_size, @data_end,
-          @flags, @checksum, @version, @page_type,
-          @next_page, @prev_page, @free_start, @free_end
-        ].pack("Q>Q>I>I>I>I>I>I>Q>Q>I>I")
-      end
-
-      def self.deserialize(data)
-        header = new
-        values = data.unpack("Q>Q>I>I>I>I>I>I>Q>Q>I>I")
-        header.page_number = values[0]
-        header.page_size = values[1]
-        header.header_size = values[2]
-        header.data_end = values[3]
-        header.flags = values[4]
-        header.checksum = values[5]
-        header.version = values[6]
-        header.page_type = values[7]
-        header.next_page = values[8]
-        header.prev_page = values[9]
-        header.free_start = values[10]
-        header.free_end = values[11]
-        header
-      end
-
-      def to_s
-        "PageHeader(page=#{@page_number}, type=#{@page_type}, data_end=#{@data_end})"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Storage
+    # PageHeader - Metadata for a page
+    class PageHeader
+      SIZE = 64  # Fixed header size
+
+      attr_accessor :page_number, :page_size, :header_size, :data_end,
+        :flags, :checksum, :version, :page_type, :next_page,
+        :prev_page, :free_start, :free_end
+
+      def initialize
+        @page_number = 0
+        @page_size = Constants::DEFAULT_PAGE_SIZE
+        @header_size = SIZE
+        @data_end = SIZE
+        @flags = 0
+        @checksum = 0
+        @version = 1
+        @page_type = 0  # 0=normal, 1=index, 2=overflow, 3=free
+        @next_page = 0
+        @prev_page = 0
+        @free_start = SIZE
+        @free_end = @page_size
+      end
+
+      attr_writer :flags
+
+      attr_writer :page_type
+
+      def serialize
+        [
+          @page_number, @page_size, @header_size, @data_end,
+          @flags, @checksum, @version, @page_type,
+          @next_page, @prev_page, @free_start, @free_end
+        ].pack("Q>Q>I>I>I>I>I>I>Q>Q>I>I")
+      end
+
+      def self.deserialize(data)
+        header = new
+        values = data.unpack("Q>Q>I>I>I>I>I>I>Q>Q>I>I")
+        header.page_number = values[0]
+        header.page_size = values[1]
+        header.header_size = values[2]
+        header.data_end = values[3]
+        header.flags = values[4]
+        header.checksum = values[5]
+        header.version = values[6]
+        header.page_type = values[7]
+        header.next_page = values[8]
+        header.prev_page = values[9]
+        header.free_start = values[10]
+        header.free_end = values[11]
+        header
+      end
+
+      def to_s
+        "PageHeader(page=#{@page_number}, type=#{@page_type}, data_end=#{@data_end})"
+      end
+    end
+  end
+end

data/lib/rubydb/storage/page_manager.rb

@@ -1,131 +1,127 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Storage
-    # PageManager - Manages page allocation and deallocation
-    class PageManager
-      attr_reader :file_manager
-
-      def initialize(file_manager)
-        @file_manager = file_manager
-        @free_list = []
-        @page_type_map = {}
-        @lock = Mutex.new
-        load_free_list
-      end
-
-      def allocate_page(page_type = 0)
-        @lock.synchronize do
-          page_number = nil
-
-          # Try to get from free list
-          if @free_list.any?
-            page_number = @free_list.pop
-            @page_type_map[page_number] = page_type
-            return page_number
-          end
-
-          # Allocate new page
-          page_number = @file_manager.num_pages
-          @file_manager.extend_file(1)
-
-          # Initialize page
-          page = Page.new(page_number, @file_manager.page_size)
-          page.header.page_type = page_type
-          page.write_header
-          @file_manager.write_page(page_number, page.data)
-
-          @page_type_map[page_number] = page_type
-          page_number
-        end
-      end
-
-      def free_page(page_number)
-        @lock.synchronize do
-          return unless page_exists?(page_number)
-
-          # Clear the page
-          page = Page.new(page_number, @file_manager.page_size)
-          page.header.page_type = 3  # Free page type
-          page.write_header
-          @file_manager.write_page(page_number, page.data)
-
-          @free_list << page_number
-          @page_type_map.delete(page_number)
-          true
-        end
-      end
-
-      def page_exists?(page_number)
-        page_number < @file_manager.num_pages
-      end
-
-      def page_type(page_number)
-        @page_type_map[page_number] || 0
-      end
-
-      def get_page(page_number)
-        @lock.synchronize do
-          raise StorageError, "Page #{page_number} does not exist" unless page_exists?(page_number)
-
-          data = @file_manager.read_page(page_number)
-          page = Page.new(page_number, @file_manager.page_size)
-          page.instance_variable_set(:@data, data)
-          page.read_header
-          page
-        end
-      end
-
-      def write_page(page)
-        @lock.synchronize do
-          raise StorageError, "Page #{page.page_number} does not exist" unless page_exists?(page.page_number)
-
-          page.write_header
-          @file_manager.write_page(page.page_number, page.data)
-          page.instance_variable_set(:@dirty, false)
-        end
-      end
-
-      def total_pages
-        @file_manager.num_pages
-      end
-
-      def free_pages
-        @free_list.size
-      end
-
-      def used_pages
-        total_pages - free_pages
-      end
-
-      def load_free_list
-        # Scan all pages to find free ones
-        @free_list = []
-        @page_type_map = {}
-
-        (0...@file_manager.num_pages).each do |page_number|
-          begin
-            data = @file_manager.read_page(page_number)
-            header = PageHeader.deserialize(data[0, PageHeader::SIZE])
-
-            if header.page_type == 3  # Free page
-              @free_list << page_number
-            else
-              @page_type_map[page_number] = header.page_type
-            end
-          rescue => e
-            # Ignore errors during free list loading
-          end
-        end
-
-        # Don't include page 0 (superblock)
-        @free_list.delete(0)
-        @free_list.sort!
-      end
-
-      def flush
-        @file_manager.sync
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Storage
+    # PageManager - Manages page allocation and deallocation
+    class PageManager
+      attr_reader :file_manager
+
+      def initialize(file_manager)
+        @file_manager = file_manager
+        @free_list = []
+        @page_type_map = {}
+        @lock = Mutex.new
+        load_free_list
+      end
+
+      def allocate_page(page_type = 0)
+        @lock.synchronize do
+          # Try to get from free list
+          if @free_list.any?
+            page_number = @free_list.pop
+            @page_type_map[page_number] = page_type
+            return page_number
+          end
+
+          # Allocate new page
+          page_number = @file_manager.num_pages
+          @file_manager.extend_file(1)
+
+          # Initialize page
+          page = Page.new(page_number, @file_manager.page_size)
+          page.header.page_type = page_type
+          page.write_header
+          @file_manager.write_page(page_number, page.data)
+
+          @page_type_map[page_number] = page_type
+          page_number
+        end
+      end
+
+      def free_page(page_number)
+        @lock.synchronize do
+          return unless page_exists?(page_number)
+
+          # Clear the page
+          page = Page.new(page_number, @file_manager.page_size)
+          page.header.page_type = 3  # Free page type
+          page.write_header
+          @file_manager.write_page(page_number, page.data)
+
+          @free_list << page_number
+          @page_type_map.delete(page_number)
+          true
+        end
+      end
+
+      def page_exists?(page_number)
+        page_number < @file_manager.num_pages
+      end
+
+      def page_type(page_number)
+        @page_type_map[page_number] || 0
+      end
+
+      def get_page(page_number)
+        @lock.synchronize do
+          raise StorageError, "Page #{page_number} does not exist" unless page_exists?(page_number)
+
+          data = @file_manager.read_page(page_number)
+          page = Page.new(page_number, @file_manager.page_size)
+          page.instance_variable_set(:@data, data)
+          page.read_header
+          page
+        end
+      end
+
+      def write_page(page)
+        @lock.synchronize do
+          raise StorageError, "Page #{page.page_number} does not exist" unless page_exists?(page.page_number)
+
+          page.write_header
+          @file_manager.write_page(page.page_number, page.data)
+          page.instance_variable_set(:@dirty, false)
+        end
+      end
+
+      def total_pages
+        @file_manager.num_pages
+      end
+
+      def free_pages
+        @free_list.size
+      end
+
+      def used_pages
+        total_pages - free_pages
+      end
+
+      def load_free_list
+        # Scan all pages to find free ones
+        @free_list = []
+        @page_type_map = {}
+
+        (0...@file_manager.num_pages).each do |page_number|
+          data = @file_manager.read_page(page_number)
+          header = PageHeader.deserialize(data[0, PageHeader::SIZE])
+
+          if header.page_type == 3  # Free page
+            @free_list << page_number
+          else
+            @page_type_map[page_number] = header.page_type
+          end
+        rescue
+          # Ignore errors during free list loading
+        end
+
+        # Don't include page 0 (superblock)
+        @free_list.delete(0)
+        @free_list.sort!
+      end
+
+      def flush
+        @file_manager.sync
+      end
+    end
+  end
+end

data/lib/rubydb/storage/record.rb

@@ -1,58 +1,58 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Storage
-    # Record - A single record stored on a page
-    class Record
-      attr_reader :page_number, :offset, :length, :data
-      attr_accessor :row_id
-
-      def initialize(page_number, offset, length, data = nil)
-        @page_number = page_number
-        @offset = offset
-        @length = length
-        @data = data || "\x00".b * length
-        @row_id = nil
-        @dirty = false
-        @deleted = false
-      end
-
-      def read(storage_manager)
-        return @data unless @data.nil?
-
-        @data = storage_manager.read_record(@page_number, @offset, @length)
-        @data
-      end
-
-      def write(storage_manager)
-        return unless @dirty
-
-        storage_manager.write_record(@page_number, @offset, @data)
-        @dirty = false
-      end
-
-      def mark_deleted
-        @deleted = true
-        @dirty = true
-      end
-
-      def deleted?
-        @deleted
-      end
-
-      def update(new_data)
-        @data = new_data
-        @length = new_data.bytesize
-        @dirty = true
-      end
-
-      def to_s
-        "Record(row_id=#{@row_id}, page=#{@page_number}, offset=#{@offset}, length=#{@length}, deleted=#{@deleted})"
-      end
-
-      def inspect
-        to_s
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Storage
+    # Record - A single record stored on a page
+    class Record
+      attr_reader :page_number, :offset, :length, :data
+      attr_accessor :row_id
+
+      def initialize(page_number, offset, length, data = nil)
+        @page_number = page_number
+        @offset = offset
+        @length = length
+        @data = data || "\x00".b * length
+        @row_id = nil
+        @dirty = false
+        @deleted = false
+      end
+
+      def read(storage_manager)
+        return @data unless @data.nil?
+
+        @data = storage_manager.read_record(@page_number, @offset, @length)
+        @data
+      end
+
+      def write(storage_manager)
+        return unless @dirty
+
+        storage_manager.write_record(@page_number, @offset, @data)
+        @dirty = false
+      end
+
+      def mark_deleted
+        @deleted = true
+        @dirty = true
+      end
+
+      def deleted?
+        @deleted
+      end
+
+      def update(new_data)
+        @data = new_data
+        @length = new_data.bytesize
+        @dirty = true
+      end
+
+      def to_s
+        "Record(row_id=#{@row_id}, page=#{@page_number}, offset=#{@offset}, length=#{@length}, deleted=#{@deleted})"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+  end
+end

data/lib/rubydb/storage/row.rb

@@ -1,78 +1,78 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Storage
-    # Row - Represents a database row with typed values
-    class Row
-      attr_reader :row_id, :columns, :values
-      attr_accessor :record
-
-      def initialize(row_id, columns, values = {})
-        @row_id = row_id
-        @columns = columns
-        @values = {}
-        @record = nil
-        @dirty = false
-
-        normalized_values = if values.is_a?(Array)
-          columns.each_with_index.each_with_object({}) do |(col, index), result|
-            result[col.name] = values[index]
-          end
-        else
-          values
-        end
-
-        # Initialize values
-        columns.each do |col|
-          value = if normalized_values.key?(col.name)
-                    normalized_values[col.name]
-                  elsif normalized_values.key?(col.name.to_sym)
-                    normalized_values[col.name.to_sym]
-                  else
-                    col.default
-                  end
-          @values[col.name] = value
-        end
-      end
-
-      def [](column_name)
-        @values[column_name]
-      end
-
-      def []=(column_name, value)
-        @values[column_name] = value
-        @dirty = true
-      end
-
-      def column_value(column_index)
-        column_name = @columns[column_index]&.name
-        @values[column_name]
-      end
-
-      def to_hash
-        @values.dup
-      end
-
-      def to_ary
-        @columns.map { |col| @values[col.name] }
-      end
-
-      def to_sql
-        values = @columns.map { |col| @values[col.name] }
-        "ROW(#{values.map { |v| v.nil? ? 'NULL' : v.inspect }.join(', ')})"
-      end
-
-      def dirty?
-        @dirty
-      end
-
-      def mark_clean
-        @dirty = false
-      end
-
-      def clone
-        Row.new(@row_id, @columns, @values.dup)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Storage
+    # Row - Represents a database row with typed values
+    class Row
+      attr_reader :row_id, :columns, :values
+      attr_accessor :record
+
+      def initialize(row_id, columns, values = {})
+        @row_id = row_id
+        @columns = columns
+        @values = {}
+        @record = nil
+        @dirty = false
+
+        normalized_values = if values.is_a?(Array)
+          columns.each_with_index.each_with_object({}) do |(col, index), result|
+            result[col.name] = values[index]
+          end
+        else
+          values
+        end
+
+        # Initialize values
+        columns.each do |col|
+          value = if normalized_values.key?(col.name)
+            normalized_values[col.name]
+          elsif normalized_values.key?(col.name.to_sym)
+            normalized_values[col.name.to_sym]
+          else
+            col.default
+          end
+          @values[col.name] = value
+        end
+      end
+
+      def [](column_name)
+        @values[column_name]
+      end
+
+      def []=(column_name, value)
+        @values[column_name] = value
+        @dirty = true
+      end
+
+      def column_value(column_index)
+        column_name = @columns[column_index]&.name
+        @values[column_name]
+      end
+
+      def to_hash
+        @values.dup
+      end
+
+      def to_ary
+        @columns.map { |col| @values[col.name] }
+      end
+
+      def to_sql
+        values = @columns.map { |col| @values[col.name] }
+        "ROW(#{values.map { |v| v.nil? ? "NULL" : v.inspect }.join(", ")})"
+      end
+
+      def dirty?
+        @dirty
+      end
+
+      def mark_clean
+        @dirty = false
+      end
+
+      def clone
+        Row.new(@row_id, @columns, @values.dup)
+      end
+    end
+  end
+end