rubydb 0.1.3 → 0.1.5

data/lib/rubydb/storage/serializer.rb

@@ -1,51 +1,51 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Storage
-    # Serializer - Converts Ruby objects to binary format
-    class Serializer
-      def self.serialize(value, type)
-        type_obj = Types::TypeRegistry.lookup(type)
-        type_obj.serialize(value)
-      end
-
-      def self.serialize_row(row, columns, null_bitmap: false)
-        data = +""
-        if null_bitmap
-          bitmap_size = (columns.size + 7) / 8
-          bitmap = Array.new(bitmap_size, 0)
-          columns.each_with_index do |col, index|
-            bitmap[index / 8] |= (1 << (index % 8)) if row[col.name].nil?
-          end
-          data << bitmap.pack("C*")
-        end
-        columns.each do |col|
-          value = row[col.name]
-          serialized = serialize(value, col.type_class)
-          if variable_length_type?(col.type_class)
-            data << [serialized.bytesize].pack("N")
-          end
-          data << serialized
-        end
-        data
-      end
-
-      def self.variable_length_type?(type)
-        !%i[integer bigint smallint float boolean date time timestamp].include?(type.to_sym)
-      end
-
-      def self.serialize_header(row_id, column_count)
-        [row_id, column_count, Time.now.to_i].pack("Q>I>Q>")
-      end
-
-      def self.serialize_metadata(table_name, column_names, column_types)
-        {
-          table_name: table_name,
-          column_names: column_names,
-          column_types: column_types,
-          created_at: Time.now.iso8601
-        }.to_json
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Storage
+    # Serializer - Converts Ruby objects to binary format
+    class Serializer
+      def self.serialize(value, type)
+        type_obj = Types::TypeRegistry.lookup(type)
+        type_obj.serialize(value)
+      end
+
+      def self.serialize_row(row, columns, null_bitmap: false)
+        data = +""
+        if null_bitmap
+          bitmap_size = (columns.size + 7) / 8
+          bitmap = Array.new(bitmap_size, 0)
+          columns.each_with_index do |col, index|
+            bitmap[index / 8] |= (1 << (index % 8)) if row[col.name].nil?
+          end
+          data << bitmap.pack("C*")
+        end
+        columns.each do |col|
+          value = row[col.name]
+          serialized = serialize(value, col.type_class)
+          if variable_length_type?(col.type_class)
+            data << [serialized.bytesize].pack("N")
+          end
+          data << serialized
+        end
+        data
+      end
+
+      def self.variable_length_type?(type)
+        !%i[integer bigint smallint float boolean date time timestamp].include?(type.to_sym)
+      end
+
+      def self.serialize_header(row_id, column_count)
+        [row_id, column_count, Time.now.to_i].pack("Q>I>Q>")
+      end
+
+      def self.serialize_metadata(table_name, column_names, column_types)
+        {
+          table_name: table_name,
+          column_names: column_names,
+          column_types: column_types,
+          created_at: Time.now.iso8601
+        }.to_json
+      end
+    end
+  end
+end

data/lib/rubydb/storage/storage_layout.rb

@@ -1,151 +1,151 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Storage
-    # StorageLayout - Defines the on-disk storage format
-    module StorageLayout
-      # Magic number for file identification
-      MAGIC_NUMBER = "RUBYDB".freeze
-
-      # Current format version
-      FORMAT_VERSION = 1
-
-      # Page types
-      PAGE_TYPE_SUPERBLOCK = 0
-      PAGE_TYPE_FREE = 1
-      PAGE_TYPE_TABLE = 2
-      PAGE_TYPE_INDEX = 3
-      PAGE_TYPE_OVERFLOW = 4
-      PAGE_TYPE_INDEX_LEAF = 5
-      PAGE_TYPE_INDEX_INTERNAL = 6
-
-      # Superblock layout
-      class Superblock
-        attr_accessor :magic, :version, :page_size, :num_pages,
-                      :root_page, :created_at, :modified_at
-
-        def initialize
-          @magic = MAGIC_NUMBER
-          @version = FORMAT_VERSION
-          @page_size = Constants::DEFAULT_PAGE_SIZE
-          @num_pages = 1
-          @root_page = 0
-          @created_at = Time.now.to_i
-          @modified_at = Time.now.to_i
-        end
-
-        def serialize
-          data = ""
-          data << @magic.ljust(16)
-          data << [@version, @page_size, @num_pages, @root_page].pack("I>I>Q>Q>")
-          data << [@created_at, @modified_at].pack("Q>Q>")
-          data
-        end
-
-        def self.deserialize(data)
-          sb = new
-          sb.magic = data[0, 16].strip
-          sb.version, sb.page_size, sb.num_pages, sb.root_page = data[16, 16].unpack("I>I>Q>Q>")
-          sb.created_at, sb.modified_at = data[32, 16].unpack("Q>Q>")
-          sb
-        end
-      end
-
-      # Table metadata layout
-      class TableMetadata
-        attr_accessor :table_id, :table_name, :column_count,
-                      :row_count, :first_page, :last_page,
-                      :created_at, :updated_at
-
-        def initialize
-          @table_id = 0
-          @table_name = ""
-          @column_count = 0
-          @row_count = 0
-          @first_page = 0
-          @last_page = 0
-          @created_at = Time.now.to_i
-          @updated_at = Time.now.to_i
-        end
-
-        def serialize
-          data = +""
-          data << [@table_id].pack("Q>")
-          data << @table_name.to_s.ljust(64)
-          data << [@column_count, @row_count].pack("I>Q>")
-          data << [@first_page, @last_page].pack("Q>Q>")
-          data << [@created_at, @updated_at].pack("Q>Q>")
-          data
-        end
-
-        def self.deserialize(data)
-          tm = new
-          tm.table_id = data[0, 8].unpack("Q>").first
-          tm.table_name = data[8, 64].strip
-          tm.column_count, tm.row_count = data[72, 12].unpack("I>Q>")
-          tm.first_page, tm.last_page = data[84, 16].unpack("Q>Q>")
-          tm.created_at, tm.updated_at = data[100, 16].unpack("Q>Q>")
-          tm
-        end
-      end
-
-      # Column metadata layout
-      class ColumnMetadata
-        attr_accessor :column_id, :column_name, :data_type,
-                      :is_nullable, :is_primary_key, :position,
-                      :default, :created_at
-
-        def initialize
-          @column_id = 0
-          @column_name = ""
-          @data_type = :text
-          @is_nullable = true
-          @is_primary_key = false
-          @position = 0
-          @default = nil
-          @created_at = Time.now.to_i
-        end
-
-        def serialize
-          data = +""
-          data << [@column_id, @position].pack("I>I>")
-          data << @column_name.to_s.ljust(64)
-          data << [@data_type.to_s].pack("Z*")
-          flags = 0
-          flags |= 1 if @is_nullable
-          flags |= 2 if @is_primary_key
-          data << [flags].pack("C")
-          default_payload = @default.nil? ? "" : @default.to_s
-          data << default_payload.ljust(64)
-          data << [@created_at].pack("Q>")
-          data
-        end
-
-        def self.deserialize(data)
-          cm = new
-          cm.column_id, cm.position = data[0, 8].unpack("I>I>")
-          cm.column_name = data[8, 64].strip
-          cm.data_type = data[72].unpack("Z*").first.to_sym
-          flags = data[72 + cm.data_type.to_s.length + 1].unpack("C").first
-          cm.is_nullable = (flags & 1) != 0
-          cm.is_primary_key = (flags & 2) != 0
-          cm.default = data[73 + cm.data_type.to_s.length, 64].strip unless data[73 + cm.data_type.to_s.length, 64].strip.empty?
-          cm.created_at = data[137, 8].unpack("Q>").first
-          cm
-        end
-      end
-
-      def self.page_header_size
-        PageHeader::SIZE
-      end
-
-      def self.record_header_size
-        8  # [row_id(4)] + [length(4)]
-      end
-
-      def self.max_record_size(page_size)
-        page_size - PageHeader::SIZE - 4  # 4 bytes for record pointer
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Storage
+    # StorageLayout - Defines the on-disk storage format
+    module StorageLayout
+      # Magic number for file identification
+      MAGIC_NUMBER = "RUBYDB"
+
+      # Current format version
+      FORMAT_VERSION = 1
+
+      # Page types
+      PAGE_TYPE_SUPERBLOCK = 0
+      PAGE_TYPE_FREE = 1
+      PAGE_TYPE_TABLE = 2
+      PAGE_TYPE_INDEX = 3
+      PAGE_TYPE_OVERFLOW = 4
+      PAGE_TYPE_INDEX_LEAF = 5
+      PAGE_TYPE_INDEX_INTERNAL = 6
+
+      # Superblock layout
+      class Superblock
+        attr_accessor :magic, :version, :page_size, :num_pages,
+          :root_page, :created_at, :modified_at
+
+        def initialize
+          @magic = MAGIC_NUMBER
+          @version = FORMAT_VERSION
+          @page_size = Constants::DEFAULT_PAGE_SIZE
+          @num_pages = 1
+          @root_page = 0
+          @created_at = Time.now.to_i
+          @modified_at = Time.now.to_i
+        end
+
+        def serialize
+          data = ""
+          data << @magic.ljust(16)
+          data << [@version, @page_size, @num_pages, @root_page].pack("I>I>Q>Q>")
+          data << [@created_at, @modified_at].pack("Q>Q>")
+          data
+        end
+
+        def self.deserialize(data)
+          sb = new
+          sb.magic = data[0, 16].strip
+          sb.version, sb.page_size, sb.num_pages, sb.root_page = data[16, 16].unpack("I>I>Q>Q>")
+          sb.created_at, sb.modified_at = data[32, 16].unpack("Q>Q>")
+          sb
+        end
+      end
+
+      # Table metadata layout
+      class TableMetadata
+        attr_accessor :table_id, :table_name, :column_count,
+          :row_count, :first_page, :last_page,
+          :created_at, :updated_at
+
+        def initialize
+          @table_id = 0
+          @table_name = ""
+          @column_count = 0
+          @row_count = 0
+          @first_page = 0
+          @last_page = 0
+          @created_at = Time.now.to_i
+          @updated_at = Time.now.to_i
+        end
+
+        def serialize
+          data = +""
+          data << [@table_id].pack("Q>")
+          data << @table_name.to_s.ljust(64)
+          data << [@column_count, @row_count].pack("I>Q>")
+          data << [@first_page, @last_page].pack("Q>Q>")
+          data << [@created_at, @updated_at].pack("Q>Q>")
+          data
+        end
+
+        def self.deserialize(data)
+          tm = new
+          tm.table_id = data[0, 8].unpack1("Q>")
+          tm.table_name = data[8, 64].strip
+          tm.column_count, tm.row_count = data[72, 12].unpack("I>Q>")
+          tm.first_page, tm.last_page = data[84, 16].unpack("Q>Q>")
+          tm.created_at, tm.updated_at = data[100, 16].unpack("Q>Q>")
+          tm
+        end
+      end
+
+      # Column metadata layout
+      class ColumnMetadata
+        attr_accessor :column_id, :column_name, :data_type,
+          :is_nullable, :is_primary_key, :position,
+          :default, :created_at
+
+        def initialize
+          @column_id = 0
+          @column_name = ""
+          @data_type = :text
+          @is_nullable = true
+          @is_primary_key = false
+          @position = 0
+          @default = nil
+          @created_at = Time.now.to_i
+        end
+
+        def serialize
+          data = +""
+          data << [@column_id, @position].pack("I>I>")
+          data << @column_name.to_s.ljust(64)
+          data << [@data_type.to_s].pack("Z*")
+          flags = 0
+          flags |= 1 if @is_nullable
+          flags |= 2 if @is_primary_key
+          data << [flags].pack("C")
+          default_payload = @default.nil? ? "" : @default.to_s
+          data << default_payload.ljust(64)
+          data << [@created_at].pack("Q>")
+          data
+        end
+
+        def self.deserialize(data)
+          cm = new
+          cm.column_id, cm.position = data[0, 8].unpack("I>I>")
+          cm.column_name = data[8, 64].strip
+          cm.data_type = data[72].unpack1("Z*").to_sym
+          flags = data[72 + cm.data_type.to_s.length + 1].unpack1("C")
+          cm.is_nullable = (flags & 1) != 0
+          cm.is_primary_key = (flags & 2) != 0
+          cm.default = data[73 + cm.data_type.to_s.length, 64].strip unless data[73 + cm.data_type.to_s.length, 64].strip.empty?
+          cm.created_at = data[137, 8].unpack1("Q>")
+          cm
+        end
+      end
+
+      def self.page_header_size
+        PageHeader::SIZE
+      end
+
+      def self.record_header_size
+        8  # [row_id(4)] + [length(4)]
+      end
+
+      def self.max_record_size(page_size)
+        page_size - PageHeader::SIZE - 4  # 4 bytes for record pointer
+      end
+    end
+  end
+end

data/lib/rubydb/storage/storage_manager.rb

@@ -1,114 +1,114 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Storage
-    # StorageManager - Central storage management
-    class StorageManager
-      attr_reader :file_manager, :page_manager, :page_allocator,
-                  :buffer_pool, :free_space_map, :visibility_map, :page_size
-
-      def initialize(path, config = {})
-        @path = path
-        @page_size = config[:page_size] || Constants::DEFAULT_PAGE_SIZE
-        @buffer_size = config[:buffer_size] || Constants::DEFAULT_BUFFER_POOL_SIZE
-
-        # Initialize components
-        @file_manager = FileManager.new(path, @page_size, config)
-        @page_manager = PageManager.new(@file_manager)
-        @buffer_pool = BufferPool.new(@buffer_size)
-        @free_space_map = FreeSpaceMap.new(@page_manager)
-        visibility_path = config[:visibility_path] || "#{path}.visibility"
-        @visibility_map = VisibilityMap.new(@page_manager, config.merge(visibility_path: visibility_path))
-        @page_allocator = PageAllocator.new(@page_manager, buffer_pool: @buffer_pool)
-
-        # Connect components
-        @buffer_pool.set_page_manager(@page_manager)
-
-        @is_open = false
-        @stats = {
-          reads: 0,
-          writes: 0,
-          allocations: 0,
-          frees: 0
-        }
-      end
-
-      def open
-        @file_manager.create_or_open
-        @page_manager.load_free_list
-        @is_open = true
-        self
-      rescue => e
-        raise StorageError, "Failed to open storage: #{e.message}"
-      end
-
-      def close
-        return unless @is_open
-
-        flush
-        @file_manager.close
-        @is_open = false
-        true
-      end
-
-      def flush
-        @buffer_pool.flush_all
-        @file_manager.sync
-      end
-
-      def read_page(page_number)
-        @stats[:reads] += 1
-        frame = @buffer_pool.get_page(page_number)
-        frame.access
-        frame.page
-      end
-
-      def write_page(page)
-        @stats[:writes] += 1
-        @buffer_pool.write_page(page)
-      end
-
-      def allocate_page(page_type = 0)
-        @stats[:allocations] += 1
-        @page_manager.allocate_page(page_type)
-      end
-
-      def free_page(page_number)
-        @stats[:frees] += 1
-        @page_manager.free_page(page_number)
-        @buffer_pool.remove_page(page_number)
-      end
-
-      def read_record(page_number, offset, length)
-        page = read_page(page_number)
-        page.read(offset, length)
-      end
-
-      def write_record(page_number, offset, data)
-        page = read_page(page_number)
-        page.write(offset, data)
-        write_page(page)
-      end
-
-      def stats
-        {
-          page_size: @page_size,
-          total_pages: @page_manager.total_pages,
-          free_pages: @page_manager.free_pages,
-          used_pages: @page_manager.used_pages,
-          buffer_hits: @buffer_pool.hit_count,
-          buffer_misses: @buffer_pool.miss_count,
-          buffer_hit_rate: @buffer_pool.hit_rate,
-          reads: @stats[:reads],
-          writes: @stats[:writes],
-          allocations: @stats[:allocations],
-          frees: @stats[:frees]
-        }
-      end
-
-      def open?
-        @is_open
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Storage
+    # StorageManager - Central storage management
+    class StorageManager
+      attr_reader :file_manager, :page_manager, :page_allocator,
+        :buffer_pool, :free_space_map, :visibility_map, :page_size
+
+      def initialize(path, config = {})
+        @path = path
+        @page_size = config[:page_size] || Constants::DEFAULT_PAGE_SIZE
+        @buffer_size = config[:buffer_size] || Constants::DEFAULT_BUFFER_POOL_SIZE
+
+        # Initialize components
+        @file_manager = FileManager.new(path, @page_size, config)
+        @page_manager = PageManager.new(@file_manager)
+        @buffer_pool = BufferPool.new(@buffer_size)
+        @free_space_map = FreeSpaceMap.new(@page_manager)
+        visibility_path = config[:visibility_path] || "#{path}.visibility"
+        @visibility_map = VisibilityMap.new(@page_manager, config.merge(visibility_path: visibility_path))
+        @page_allocator = PageAllocator.new(@page_manager, buffer_pool: @buffer_pool)
+
+        # Connect components
+        @buffer_pool.set_page_manager(@page_manager)
+
+        @is_open = false
+        @stats = {
+          reads: 0,
+          writes: 0,
+          allocations: 0,
+          frees: 0
+        }
+      end
+
+      def open
+        @file_manager.create_or_open
+        @page_manager.load_free_list
+        @is_open = true
+        self
+      rescue => e
+        raise StorageError, "Failed to open storage: #{e.message}"
+      end
+
+      def close
+        return unless @is_open
+
+        flush
+        @file_manager.close
+        @is_open = false
+        true
+      end
+
+      def flush
+        @buffer_pool.flush_all
+        @file_manager.sync
+      end
+
+      def read_page(page_number)
+        @stats[:reads] += 1
+        frame = @buffer_pool.get_page(page_number)
+        frame.access
+        frame.page
+      end
+
+      def write_page(page)
+        @stats[:writes] += 1
+        @buffer_pool.write_page(page)
+      end
+
+      def allocate_page(page_type = 0)
+        @stats[:allocations] += 1
+        @page_manager.allocate_page(page_type)
+      end
+
+      def free_page(page_number)
+        @stats[:frees] += 1
+        @page_manager.free_page(page_number)
+        @buffer_pool.remove_page(page_number)
+      end
+
+      def read_record(page_number, offset, length)
+        page = read_page(page_number)
+        page.read(offset, length)
+      end
+
+      def write_record(page_number, offset, data)
+        page = read_page(page_number)
+        page.write(offset, data)
+        write_page(page)
+      end
+
+      def stats
+        {
+          page_size: @page_size,
+          total_pages: @page_manager.total_pages,
+          free_pages: @page_manager.free_pages,
+          used_pages: @page_manager.used_pages,
+          buffer_hits: @buffer_pool.hit_count,
+          buffer_misses: @buffer_pool.miss_count,
+          buffer_hit_rate: @buffer_pool.hit_rate,
+          reads: @stats[:reads],
+          writes: @stats[:writes],
+          allocations: @stats[:allocations],
+          frees: @stats[:frees]
+        }
+      end
+
+      def open?
+        @is_open
+      end
+    end
+  end
+end