innodb_ruby 0.9.16 → 0.11.0

data/lib/innodb/page/index_compressed.rb

@@ -1,46 +1,46 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 # This is horribly incomplete and broken. InnoDB compression does not
 # currently work in innodb_ruby. Patches are welcome!
 # (Hint hint, nudge nudge, Facebook developers!)
 
-class Innodb::Page::Index::Compressed < Innodb::Page::Index
-  # The number of directory slots in use.
-  def directory_slots
-    page_header[:n_heap] - 2
-  end
+module Innodb
+  class Page
+    class IndexCompressed < Index
+      specialization_for({ type: :INDEX, compressed: true })
 
-  def directory
-    super.map { |n| n & 0x3fff }
-  end
+      # The number of directory slots in use.
+      def directory_slots
+        page_header[:n_heap] - 2
+      end
 
-  def uncompressed_columns_size
-    if level == 0
-      if record_format && record_format[:type] == :clustered
-        6 + 7 # Transaction ID + Roll Pointer
-      else
-        0
+      def directory
+        super.map { |n| n & 0x3fff }
       end
-    else
-      4 # Node pointer for non-leaf pages
-    end
-  end
 
-  # Return the amount of free space in the page.
-  def free_space
-    free_space_start = size - size_fil_trailer - directory_space -
-      (uncompressed_columns_size * (page_header[:n_heap] - 2))
-    puts "Free space start == %04x" % [offset * size + free_space_start]
-    c = cursor(free_space_start).backward
-    zero_bytes = 0
-    while (b = c.get_uint8) == 0
-      zero_bytes += 1
+      def uncompressed_columns_size
+        if leaf?
+          if record_format && record_format[:type] == :clustered
+            6 + 7 # Transaction ID + Roll Pointer
+          else
+            0
+          end
+        else
+          4 # Node pointer for non-leaf pages
+        end
+      end
+
+      # Return the amount of free space in the page.
+      def free_space
+        free_space_start =
+          size - size_fil_trailer - directory_space - (uncompressed_columns_size * (page_header.n_heap - 2))
+        puts "Free space start == %04x" % [offset * size + free_space_start]
+        c = cursor(free_space_start).backward
+        zero_bytes = 0
+        zero_bytes += 1 while c.read_uint8.zero?
+        zero_bytes
+        # page_header[:garbage] + (size - size_fil_trailer - directory_space - page_header[:heap_top])
+      end
     end
-    zero_bytes
-    #page_header[:garbage] +
-    #  (size - size_fil_trailer - directory_space - page_header[:heap_top])
   end
 end
-
-Innodb::Page::SPECIALIZED_CLASSES[{:type => :INDEX, :compressed => true}] = Innodb::Page::Index::Compressed
-

data/lib/innodb/page/inode.rb

@@ -1,139 +1,130 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 require "innodb/list"
 
 # A specialized class for handling INODE pages, which contain index FSEG (file
 # segment) information. This allows all extents and individual pages assigned
 # to each index to be found.
-class Innodb::Page::Inode < Innodb::Page
-  # Return the byte offset of the list node, which immediately follows the
-  # FIL header.
-  def pos_list_entry
-    pos_page_body
-  end
-
-  # Return the size of the list node.
-  def size_list_entry
-    Innodb::List::NODE_SIZE
-  end
-
-  # Return the byte offset of the Inode array in the page, which immediately
-  # follows the list entry.
-  def pos_inode_array
-    pos_list_entry + size_list_entry
-  end
-
-  # The number of Inode entries that fit on a page.
-  def inodes_per_page
-    (size - pos_inode_array - 10) / Innodb::Inode::SIZE
-  end
+module Innodb
+  class Page
+    class Inode < Page
+      specialization_for :INODE
+
+      # Return the byte offset of the list node, which immediately follows the
+      # FIL header.
+      def pos_list_entry
+        pos_page_body
+      end
 
-  def size_inode_array
-    inodes_per_page * Innodb::Inode::SIZE
-  end
+      # Return the size of the list node.
+      def size_list_entry
+        Innodb::List::NODE_SIZE
+      end
 
-  # Return the list entry.
-  def list_entry
-    cursor(pos_list_entry).name("list") do |c|
-      Innodb::List.get_node(c)
-    end
-  end
+      # Return the byte offset of the Inode array in the page, which immediately
+      # follows the list entry.
+      def pos_inode_array
+        pos_list_entry + size_list_entry
+      end
 
-  # Return the "previous" address pointer from the list entry. This is used
-  # by Innodb::List::Inode to iterate through Inode lists.
-  def prev_address
-    list_entry[:prev]
-  end
+      # The number of Inode entries that fit on a page.
+      def inodes_per_page
+        (size - pos_inode_array - 10) / Innodb::Inode::SIZE
+      end
 
-  # Return the "next" address pointer from the list entry. This is used
-  # by Innodb::List::Inode to iterate through Inode lists.
-  def next_address
-    list_entry[:next]
-  end
+      def size_inode_array
+        inodes_per_page * Innodb::Inode::SIZE
+      end
 
-  # Read a single Inode entry from the provided byte offset by creating a
-  # cursor and reading the inode using the inode method.
-  def inode_at(cursor)
-    cursor.name("inode[#{cursor.position}]") { |c| Innodb::Inode.new_from_cursor(@space, c) }
-  end
+      # Return the list entry.
+      def list_entry
+        cursor(pos_list_entry).name("list") { |c| Innodb::List.get_node(c) }
+      end
 
-  # Iterate through all Inodes in the inode array.
-  def each_inode
-    unless block_given?
-      return enum_for(:each_inode)
-    end
+      # Return the "previous" address pointer from the list entry. This is used
+      # by Innodb::List::Inode to iterate through Inode lists.
+      def prev_address
+        list_entry.prev
+      end
 
-    inode_cursor = cursor(pos_inode_array)
-    inodes_per_page.times do |n|
-      inode_cursor.name("inode[#{n}]") do |c|
-        this_inode = Innodb::Inode.new_from_cursor(@space, c)
-        yield this_inode
+      # Return the "next" address pointer from the list entry. This is used
+      # by Innodb::List::Inode to iterate through Inode lists.
+      def next_address
+        list_entry.next
       end
-    end
-  end
 
-  # Iterate through all allocated inodes in the inode array.
-  def each_allocated_inode
-    unless block_given?
-      return enum_for(:each_allocated_inode)
-    end
+      # Read a single Inode entry from the provided byte offset by creating a
+      # cursor and reading the inode using the inode method.
+      def inode_at(cursor)
+        cursor.name("inode[#{cursor.position}]") { |c| Innodb::Inode.new_from_cursor(@space, c) }
+      end
 
-    each_inode do |this_inode|
-      yield this_inode if this_inode.allocated?
-    end
-  end
+      # Iterate through all Inodes in the inode array.
+      def each_inode
+        return enum_for(:each_inode) unless block_given?
 
-  def each_region
-    unless block_given?
-      return enum_for(:each_region)
-    end
+        inode_cursor = cursor(pos_inode_array)
+        inodes_per_page.times do |n|
+          inode_cursor.name("inode[#{n}]") do |c|
+            yield Innodb::Inode.new_from_cursor(@space, c)
+          end
+        end
+      end
 
-    super do |region|
-      yield region
-    end
+      # Iterate through all allocated inodes in the inode array.
+      def each_allocated_inode
+        return enum_for(:each_allocated_inode) unless block_given?
 
-    yield({
-      :offset => pos_list_entry,
-      :length => size_list_entry,
-      :name => :list_entry,
-      :info => "Inode List Entry",
-    })
-
-    each_inode do |inode|
-      if inode.allocated?
-        yield({
-          :offset => inode.offset,
-          :length => Innodb::Inode::SIZE,
-          :name => :inode_used,
-          :info => "Inode (used)",
-        })
-      else
-        yield({
-          :offset => inode.offset,
-          :length => Innodb::Inode::SIZE,
-          :name => :inode_free,
-          :info => "Inode (free)",
-        })
+        each_inode do |this_inode|
+          yield this_inode if this_inode.allocated?
+        end
       end
-    end
 
-    nil
-  end
+      def each_region(&block)
+        return enum_for(:each_region) unless block_given?
+
+        super(&block)
+
+        yield Region.new(
+          offset: pos_list_entry,
+          length: size_list_entry,
+          name: :list_entry,
+          info: "Inode List Entry"
+        )
+
+        each_inode do |inode|
+          if inode.allocated?
+            yield Region.new(
+              offset: inode.offset,
+              length: Innodb::Inode::SIZE,
+              name: :inode_used,
+              info: "Inode (used)"
+            )
+          else
+            yield Region.new(
+              offset: inode.offset,
+              length: Innodb::Inode::SIZE,
+              name: :inode_free,
+              info: "Inode (free)"
+            )
+          end
+        end
+
+        nil
+      end
 
-  # Dump the contents of a page for debugging purposes.
-  def dump
-    super
+      # Dump the contents of a page for debugging purposes.
+      def dump
+        super
 
-    puts "list entry:"
-    pp list_entry
-    puts
+        puts "list entry:"
+        pp list_entry
+        puts
 
-    puts "inodes:"
-    each_inode do |inode|
-      inode.dump
+        puts "inodes:"
+        each_inode(&:dump)
+        puts
+      end
     end
-    puts
   end
 end
-
-Innodb::Page::SPECIALIZED_CLASSES[:INODE] = Innodb::Page::Inode

data/lib/innodb/page/sys.rb

@@ -1,4 +1,4 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 require "innodb/page/sys_rseg_header"
 require "innodb/page/sys_data_dictionary_header"
@@ -7,20 +7,18 @@ require "innodb/page/sys_ibuf_header"
 # Another layer of indirection for pages of type SYS, as they have multiple
 # uses within InnoDB. We'll override the self.handle method and check the
 # page offset to decide which type of SYS page this is.
-class Innodb::Page::Sys < Innodb::Page
-  def self.handle(page, space, buffer, page_number=nil)
-    case
-    when page.offset == 3
-      Innodb::Page::SysIbufHeader.new(space, buffer, page_number)
-    when page.offset == 7
-      Innodb::Page::SysDataDictionaryHeader.new(space, buffer, page_number)
-    when space.rseg_page?(page.offset)
-      Innodb::Page::SysRsegHeader.new(space, buffer, page_number)
-    else
-      # We can't do anything better, so pass on the generic InnoDB::Page.
-      page
+module Innodb
+  class Page
+    class Sys < Page
+      specialization_for :SYS
+
+      def self.handle(page, space, buffer, page_number = nil)
+        return Innodb::Page::SysIbufHeader.new(space, buffer, page_number) if page.offset == 3
+        return Innodb::Page::SysDataDictionaryHeader.new(space, buffer, page_number) if page.offset == 7
+        return Innodb::Page::SysRsegHeader.new(space, buffer, page_number) if space.rseg_page?(page.offset)
+
+        page
+      end
     end
   end
 end
-
-Innodb::Page::SPECIALIZED_CLASSES[:SYS] = Innodb::Page::Sys

data/lib/innodb/page/sys_data_dictionary_header.rb

@@ -1,70 +1,92 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
-class Innodb::Page::SysDataDictionaryHeader < Innodb::Page
-  # The position of the data dictionary header within the page.
-  def pos_data_dictionary_header
-    pos_page_body
-  end
+module Innodb
+  class Page
+    class SysDataDictionaryHeader < Page
+      Header = Struct.new(
+        :max_row_id,
+        :max_table_id,
+        :max_index_id,
+        :max_space_id,
+        :unused_mix_id_low,
+        :indexes,
+        :unused_space,
+        :fseg,
+        keyword_init: true
+      )
 
-  # The size of the data dictionary header.
-  def size_data_dictionary_header
-    ((8 * 3) + (4 * 7) + 4 + Innodb::FsegEntry::SIZE)
-  end
+      # The position of the data dictionary header within the page.
+      def pos_data_dictionary_header
+        pos_page_body
+      end
 
-  # Parse the data dictionary header from the page.
-  def data_dictionary_header
-    cursor(pos_data_dictionary_header).name("data_dictionary_header") do |c|
-      {
-        :max_row_id => c.name("max_row_id") { c.get_uint64 },
-        :max_table_id => c.name("max_table_id") { c.get_uint64 },
-        :max_index_id => c.name("max_index_id") { c.get_uint64 },
-        :max_space_id => c.name("max_space_id") { c.get_uint32 },
-        :unused_mix_id_low => c.name("unused_mix_id_low") { c.get_uint32 },
-        :indexes => c.name("indexes") {{
-          :SYS_TABLES => c.name("SYS_TABLES") {{
-            :PRIMARY => c.name("PRIMARY") { c.get_uint32 },
-            :ID      => c.name("ID")      { c.get_uint32 },
-          }},
-          :SYS_COLUMNS => c.name("SYS_COLUMNS") {{
-            :PRIMARY => c.name("PRIMARY") { c.get_uint32 },
-          }},
-          :SYS_INDEXES => c.name("SYS_INDEXES") {{
-            :PRIMARY => c.name("PRIMARY") { c.get_uint32 },
-          }},
-          :SYS_FIELDS => c.name("SYS_FIELDS") {{
-            :PRIMARY => c.name("PRIMARY") { c.get_uint32 },
-          }}
-        }},
-        :unused_space => c.name("unused_space") { c.get_bytes(4) },
-        :fseg => c.name("fseg") { Innodb::FsegEntry.get_inode(@space, c) },
-      }
-    end
-  end
+      # The size of the data dictionary header.
+      def size_data_dictionary_header
+        ((8 * 3) + (4 * 7) + 4 + Innodb::FsegEntry::SIZE)
+      end
 
-  def each_region
-    unless block_given?
-      return enum_for(:each_region)
-    end
+      # Parse the data dictionary header from the page.
+      def data_dictionary_header
+        cursor(pos_data_dictionary_header).name("data_dictionary_header") do |c|
+          Header.new(
+            max_row_id: c.name("max_row_id") { c.read_uint64 },
+            max_table_id: c.name("max_table_id") { c.read_uint64 },
+            max_index_id: c.name("max_index_id") { c.read_uint64 },
+            max_space_id: c.name("max_space_id") { c.read_uint32 },
+            unused_mix_id_low: c.name("unused_mix_id_low") { c.read_uint32 },
+            indexes: c.name("indexes") do
+              {
+                SYS_TABLES: c.name("SYS_TABLES") do
+                  {
+                    PRIMARY: c.name("PRIMARY") { c.read_uint32 },
+                    ID: c.name("ID") { c.read_uint32 },
+                  }
+                end,
+                SYS_COLUMNS: c.name("SYS_COLUMNS") do
+                  {
+                    PRIMARY: c.name("PRIMARY") { c.read_uint32 },
+                  }
+                end,
+                SYS_INDEXES: c.name("SYS_INDEXES") do
+                  {
+                    PRIMARY: c.name("PRIMARY") { c.read_uint32 },
+                  }
+                end,
+                SYS_FIELDS: c.name("SYS_FIELDS") do
+                  {
+                    PRIMARY: c.name("PRIMARY") { c.read_uint32 },
+                  }
+                end,
+              }
+            end,
+            unused_space: c.name("unused_space") { c.read_bytes(4) },
+            fseg: c.name("fseg") { Innodb::FsegEntry.get_inode(@space, c) }
+          )
+        end
+      end
 
-    super do |region|
-      yield region
-    end
+      def each_region(&block)
+        return enum_for(:each_region) unless block_given?
 
-    yield({
-      :offset => pos_data_dictionary_header,
-      :length => size_data_dictionary_header,
-      :name => :data_dictionary_header,
-      :info => "Data Dictionary Header",
-    })
+        super(&block)
 
-    nil
-  end
+        yield Region.new(
+          offset: pos_data_dictionary_header,
+          length: size_data_dictionary_header,
+          name: :data_dictionary_header,
+          info: "Data Dictionary Header"
+        )
 
-  def dump
-    super
+        nil
+      end
 
-    puts
-    puts "data_dictionary header:"
-    pp data_dictionary_header
+      def dump
+        super
+
+        puts
+        puts "data_dictionary header:"
+        pp data_dictionary_header
+      end
+    end
   end
 end