innodb_ruby 0.9.14 → 0.12.0

data/lib/innodb/lsn.rb

@@ -1,103 +1,108 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 # A Log Sequence Number and its byte offset into the log group.
-class Innodb::LSN
-  # The Log Sequence Number.
-  attr_reader :lsn_no
-
-  # Alias :lsn_no attribute.
-  alias_method :no, :lsn_no
+module Innodb
+  class LSN
+    # The Log Sequence Number.
+    attr_reader :lsn_no
+
+    # Alias :lsn_no attribute.
+    alias no lsn_no
+
+    # Initialize coordinates.
+    def initialize(lsn, offset)
+      @lsn_no = lsn
+      @lsn_offset = offset
+    end
 
-  # Initialize coordinates.
-  def initialize(lsn, offset)
-    @lsn_no = lsn
-    @lsn_offset = offset
-  end
+    # Place LSN in a new position.
+    def reposition(new_lsn_no, group)
+      new_offset = offset_of(@lsn_no, @lsn_offset, new_lsn_no, group)
+      @lsn_no = new_lsn_no
+      @lsn_offset = new_offset
 
-  # Place LSN in a new position.
-  def reposition(new_lsn_no, group)
-    new_offset = offset_of(@lsn_no, @lsn_offset, new_lsn_no, group)
-    @lsn_no, @lsn_offset = [new_lsn_no, new_offset]
-  end
+      [@lsn_no, @lsn_offset]
+    end
 
-  # Advance by a given LSN amount.
-  def advance(count_lsn_no, group)
-    new_lsn_no = @lsn_no + count_lsn_no
-    reposition(new_lsn_no, group)
-  end
+    # Advance by a given LSN amount.
+    def advance(count_lsn_no, group)
+      new_lsn_no = @lsn_no + count_lsn_no
+      reposition(new_lsn_no, group)
+    end
 
-  # Returns the location coordinates of this LSN.
-  def location(group)
-    location_of(@lsn_offset, group)
-  end
+    # Returns the location coordinates of this LSN.
+    def location(group)
+      location_of(@lsn_offset, group)
+    end
 
-  # Returns the LSN delta for the given amount of data.
-  def delta(length)
-    fragment = (@lsn_no % LOG_BLOCK_SIZE) - LOG_BLOCK_HEADER_SIZE
-    raise "Invalid fragment #{fragment} for LSN #{@lsn_no}" unless
-      fragment.between?(0, LOG_BLOCK_DATA_SIZE - 1)
-    length + (fragment + length) / LOG_BLOCK_DATA_SIZE * LOG_BLOCK_FRAME_SIZE
-  end
+    # Returns the LSN delta for the given amount of data.
+    def delta(length)
+      fragment = (@lsn_no % LOG_BLOCK_SIZE) - LOG_BLOCK_HEADER_SIZE
+      raise "Invalid fragment #{fragment} for LSN #{@lsn_no}" unless fragment.between?(0, LOG_BLOCK_DATA_SIZE - 1)
 
-  # Whether LSN might point to log record data.
-  def record?(group)
-    data_offset?(@lsn_offset, group)
-  end
+      length + (fragment + length) / LOG_BLOCK_DATA_SIZE * LOG_BLOCK_FRAME_SIZE
+    end
 
-  private
+    # Whether LSN might point to log record data.
+    def record?(group)
+      data_offset?(@lsn_offset, group)
+    end
 
-  # Short alias for the size of a log file header.
-  LOG_HEADER_SIZE = Innodb::Log::LOG_HEADER_SIZE
+    private
 
-  # Short aliases for the sizes of the subparts of a log block.
-  LOG_BLOCK_SIZE = Innodb::LogBlock::BLOCK_SIZE
-  LOG_BLOCK_HEADER_SIZE = Innodb::LogBlock::HEADER_SIZE
-  LOG_BLOCK_TRAILER_SIZE = Innodb::LogBlock::TRAILER_SIZE
-  LOG_BLOCK_DATA_SIZE = Innodb::LogBlock::DATA_SIZE
-  LOG_BLOCK_FRAME_SIZE = LOG_BLOCK_HEADER_SIZE + LOG_BLOCK_TRAILER_SIZE
+    # Short alias for the size of a log file header.
+    LOG_HEADER_SIZE = Innodb::Log::LOG_HEADER_SIZE
 
-  # Returns the coordinates of the given offset.
-  def location_of(offset, group)
-    log_no, log_offset = offset.divmod(group.size)
-    block_no, block_offset = (log_offset - LOG_HEADER_SIZE).divmod(LOG_BLOCK_SIZE)
-    [log_no, block_no, block_offset]
-  end
+    # Short aliases for the sizes of the subparts of a log block.
+    LOG_BLOCK_SIZE = Innodb::LogBlock::BLOCK_SIZE
+    LOG_BLOCK_HEADER_SIZE = Innodb::LogBlock::HEADER_SIZE
+    LOG_BLOCK_TRAILER_SIZE = Innodb::LogBlock::TRAILER_SIZE
+    LOG_BLOCK_DATA_SIZE = Innodb::LogBlock::DATA_SIZE
+    LOG_BLOCK_FRAME_SIZE = LOG_BLOCK_HEADER_SIZE + LOG_BLOCK_TRAILER_SIZE
 
-  # Returns the offset of the given LSN within a log group.
-  def offset_of(lsn, offset, new_lsn, group)
-    log_size = group.log_size
-    group_capacity = group.capacity
-
-    # Calculate the offset in LSN.
-    if new_lsn >= lsn
-      lsn_offset = new_lsn - lsn
-    else
-      lsn_offset = lsn - new_lsn
-      lsn_offset %= group_capacity
-      lsn_offset = group_capacity - lsn_offset
+    # Returns the coordinates of the given offset.
+    def location_of(offset, group)
+      log_no, log_offset = offset.divmod(group.size)
+      block_no, block_offset = (log_offset - LOG_HEADER_SIZE).divmod(LOG_BLOCK_SIZE)
+      [log_no, block_no, block_offset]
     end
 
-    # Transpose group size offset to a group capacity offset.
-    group_offset = offset - (LOG_HEADER_SIZE * (1 + offset / log_size))
+    # Returns the offset of the given LSN within a log group.
+    def offset_of(lsn, offset, new_lsn, group)
+      log_size = group.log_size
+      group_capacity = group.capacity
 
-    offset = (lsn_offset + group_offset) % group_capacity
+      # Calculate the offset in LSN.
+      if new_lsn >= lsn
+        lsn_offset = new_lsn - lsn
+      else
+        lsn_offset = lsn - new_lsn
+        lsn_offset %= group_capacity
+        lsn_offset = group_capacity - lsn_offset
+      end
 
-    # Transpose group capacity offset to a group size offset.
-    offset + LOG_HEADER_SIZE * (1 + offset / (log_size - LOG_HEADER_SIZE))
-  end
+      # Transpose group size offset to a group capacity offset.
+      group_offset = offset - (LOG_HEADER_SIZE * (1 + offset / log_size))
 
-  # Whether offset points to the data area of an existing log block.
-  def data_offset?(offset, group)
-    log_offset = offset % group.size
-    log_no, block_no, block_offset = location_of(offset, group)
+      offset = (lsn_offset + group_offset) % group_capacity
 
-    status ||= log_no > group.logs
-    status ||= log_offset <= LOG_HEADER_SIZE
-    status ||= block_no < 0
-    status ||= block_no >= group.log(log_no).blocks
-    status ||= block_offset < Innodb::LogBlock::DATA_OFFSET
-    status ||= block_offset >= Innodb::LogBlock::TRAILER_OFFSET
+      # Transpose group capacity offset to a group size offset.
+      offset + LOG_HEADER_SIZE * (1 + offset / (log_size - LOG_HEADER_SIZE))
+    end
+
+    # Whether offset points to the data area of an existing log block.
+    def data_offset?(offset, group)
+      log_offset = offset % group.size
+      log_no, block_no, block_offset = location_of(offset, group)
 
-    !status
+      status ||= log_no > group.logs
+      status ||= log_offset <= LOG_HEADER_SIZE
+      status ||= block_no.negative?
+      status ||= block_no >= group.log(log_no).blocks
+      status ||= block_offset < Innodb::LogBlock::DATA_OFFSET
+      status ||= block_offset >= Innodb::LogBlock::TRAILER_OFFSET
+
+      !status
+    end
   end
 end

data/lib/innodb/page/blob.rb

@@ -1,86 +1,85 @@
-# -*- encoding : utf-8 -*-
-
-class Innodb::Page::Blob < Innodb::Page
-  def pos_blob_header
-    pos_page_body
-  end
-
-  def size_blob_header
-    4 + 4
-  end
-
-  def pos_blob_data
-    pos_blob_header + size_blob_header
-  end
-
-  def blob_header
-    cursor(pos_blob_header).name("blob_header") do |c|
-      {
-        :length => c.name("length") { c.get_uint32 },
-        :next   => c.name("next") { Innodb::Page.maybe_undefined(c.get_uint32) },
-      }
-    end
-  end
-
-  def blob_data
-    cursor(pos_blob_data).name("blob_data") do |c|
-      c.get_bytes(blob_header[:length])
-    end
-  end
-
-  def dump_hex(string)
-    slice_size = 16
-    bytes = string.split("").map { |s| s.ord }
-    string.split("").each_slice(slice_size).each_with_index do |slice_bytes, slice_count|
-      puts "%08i  %-23s  %-23s  |%-16s|" % [
-        (slice_count * slice_size),
-        slice_bytes[0..8].map { |n| "%02x" % n.ord }.join(" "),
-        slice_bytes[8..16].map { |n| "%02x" % n.ord }.join(" "),
-        slice_bytes.join(""),
-      ]
+# frozen_string_literal: true
+
+module Innodb
+  class Page
+    class Blob < Page
+      specialization_for :BLOB
+
+      def pos_blob_header
+        pos_page_body
+      end
+
+      def size_blob_header
+        4 + 4
+      end
+
+      def pos_blob_data
+        pos_blob_header + size_blob_header
+      end
+
+      def blob_header
+        cursor(pos_blob_header).name("blob_header") do |c|
+          {
+            length: c.name("length") { c.read_uint32 },
+            next: c.name("next") { Innodb::Page.maybe_undefined(c.read_uint32) },
+          }
+        end
+      end
+
+      def blob_data
+        cursor(pos_blob_data).name("blob_data") do |c|
+          c.read_bytes(blob_header[:length])
+        end
+      end
+
+      def dump_hex(string)
+        slice_size = 16
+        string.chars.each_slice(slice_size).each_with_index do |slice_bytes, slice_count|
+          puts "%08i  %-23s  %-23s  |%-16s|" % [
+            (slice_count * slice_size),
+            slice_bytes[0..8].map { |n| "%02x" % n.ord }.join(" "),
+            slice_bytes[8..16].map { |n| "%02x" % n.ord }.join(" "),
+            slice_bytes.join,
+          ]
+        end
+      end
+
+      def each_region(&block)
+        return enum_for(:each_region) unless block_given?
+
+        super(&block)
+
+        yield Region.new(
+          offset: pos_blob_header,
+          length: size_blob_header,
+          name: :blob_header,
+          info: "Blob Header"
+        )
+
+        yield Region.new(
+          offset: pos_blob_data,
+          length: blob_header[:length],
+          name: :blob_data,
+          info: "Blob Data"
+        )
+
+        nil
+      end
+
+      # Dump the contents of a page for debugging purposes.
+      def dump
+        super
+
+        puts "blob header:"
+        pp blob_header
+        puts
+
+        puts "blob data:"
+        dump_hex(blob_data)
+        puts
+
+        puts
+      end
     end
   end
-
-  def each_region
-    unless block_given?
-      return enum_for(:each_region)
-    end
-
-    super do |region|
-      yield region
-    end
-
-    yield({
-      :offset => pos_blob_header,
-      :length => size_blob_header,
-      :name => :blob_header,
-      :info => "Blob Header",
-    })
-
-    yield({
-      :offset => pos_blob_data,
-      :length => blob_header[:length],
-      :name => :blob_data,
-      :info => "Blob Data",
-    })
-
-    nil
-  end
-
-  # Dump the contents of a page for debugging purposes.
-  def dump
-    super
-
-    puts "blob header:"
-    pp blob_header
-    puts
-
-    puts "blob data:"
-    dump_hex(blob_data)
-    puts
-
-    puts
-  end
 end
-
-Innodb::Page::SPECIALIZED_CLASSES[:BLOB] = Innodb::Page::Blob

data/lib/innodb/page/fsp_hdr_xdes.rb

@@ -1,4 +1,4 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 require "innodb/list"
 require "innodb/xdes"
@@ -12,186 +12,195 @@ require "innodb/xdes"
 #
 # The basic structure of FSP_HDR and XDES pages is: FIL header, FSP header,
 # an array of 256 XDES entries, empty (unused) space, and FIL trailer.
-class Innodb::Page::FspHdrXdes < Innodb::Page
-  extend ReadBitsAtOffset
-
-  # A value added to the adjusted exponent stored in the page size field of
-  # the flags in the FSP header.
-  FLAGS_PAGE_SIZE_SHIFT = 9
-
-  def self.shift_page_size(page_size_shifted)
-    if page_size_shifted != 0
-      (1 << (FLAGS_PAGE_SIZE_SHIFT + page_size_shifted))
-    end
-  end
-
-  # Decode the "flags" field in the FSP header, returning a hash of useful
-  # decodings of the flags (based on MySQl 5.6 definitions). The flags are:
-  #
-  # Offset    Size    Description
-  # 0         1       Post-Antelope Flag.
-  # 1         4       Compressed Page Size (zip_size). This is stored as a
-  #                   power of 2, minus 9. Since 0 is reserved to mean "not
-  #                   compressed", the minimum value is 1, thus making the
-  #                   smallest page size 1024 (2 ** (9 + 1)).
-  # 5         1       Atomic Blobs Flag.
-  # 6         4       System Page Size (innodb_page_size, UNIV_PAGE_SIZE).
-  #                   The setting of the system page size when the tablespace
-  #                   was created, stored in the same format as the compressed
-  #                   page size above.
-  # 10        1       Data Directory Flag.
-  #
-  def self.decode_flags(flags)
-    system_page_size =
-      shift_page_size(read_bits_at_offset(flags, 4, 6)) ||
-      Innodb::Space::DEFAULT_PAGE_SIZE
-    compressed_page_size = shift_page_size(read_bits_at_offset(flags, 4, 1))
-
-    {
-      :system_page_size => system_page_size,
-      :compressed => compressed_page_size ? false : true,
-      :page_size => compressed_page_size || system_page_size,
-      :post_antelope => read_bits_at_offset(flags, 1, 0) == 1,
-      :atomic_blobs => read_bits_at_offset(flags, 1, 5) == 1,
-      :data_directory => read_bits_at_offset(flags, 1, 10) == 1,
-      :value => flags,
-    }
-  end
-
-  # The FSP header immediately follows the FIL header.
-  def pos_fsp_header
-    pos_page_body
-  end
-
-  # The FSP header contains six 32-bit integers, one 64-bit integer, and 5
-  # list base nodes.
-  def size_fsp_header
-    ((4 * 6) + (1 * 8) + (5 * Innodb::List::BASE_NODE_SIZE))
-  end
-
-  # The XDES entry array immediately follows the FSP header.
-  def pos_xdes_array
-    pos_fsp_header + size_fsp_header
-  end
+module Innodb
+  class Page
+    class FspHdrXdes < Page
+      extend ReadBitsAtOffset
+
+      specialization_for :FSP_HDR
+      specialization_for :XDES
+
+      Flags = Struct.new(
+        :system_page_size,
+        :compressed,
+        :page_size,
+        :post_antelope,
+        :atomic_blobs,
+        :data_directory,
+        :value,
+        keyword_init: true
+      )
+
+      Header = Struct.new(
+        :space_id,
+        :unused,
+        :size, # rubocop:disable Lint/StructNewOverride
+        :free_limit,
+        :flags,
+        :frag_n_used,
+        :free,
+        :free_frag,
+        :full_frag,
+        :first_unused_seg,
+        :full_inodes,
+        :free_inodes,
+        keyword_init: true
+      )
+
+      # A value added to the adjusted exponent stored in the page size field of
+      # the flags in the FSP header.
+      FLAGS_PAGE_SIZE_SHIFT = 9
+
+      def self.shift_page_size(page_size_shifted)
+        (1 << (FLAGS_PAGE_SIZE_SHIFT + page_size_shifted)) if page_size_shifted != 0
+      end
 
-  # The number of entries in the XDES array. Defined as page size divided by
-  # extent size.
-  def entries_in_xdes_array
-    size / space.pages_per_extent
-  end
+      # Decode the "flags" field in the FSP header, returning a hash of useful
+      # decodings of the flags (based on MySQl 5.6 definitions). The flags are:
+      #
+      # Offset    Size    Description
+      # 0         1       Post-Antelope Flag.
+      # 1         4       Compressed Page Size (zip_size). This is stored as a
+      #                   power of 2, minus 9. Since 0 is reserved to mean "not
+      #                   compressed", the minimum value is 1, thus making the
+      #                   smallest page size 1024 (2 ** (9 + 1)).
+      # 5         1       Atomic Blobs Flag.
+      # 6         4       System Page Size (innodb_page_size, UNIV_PAGE_SIZE).
+      #                   The setting of the system page size when the tablespace
+      #                   was created, stored in the same format as the compressed
+      #                   page size above.
+      # 10        1       Data Directory Flag.
+      #
+      def self.decode_flags(flags)
+        system_page_size =
+          shift_page_size(read_bits_at_offset(flags, 4, 6)) ||
+          Innodb::Space::DEFAULT_PAGE_SIZE
+        compressed_page_size = shift_page_size(read_bits_at_offset(flags, 4, 1))
+
+        Flags.new(
+          system_page_size: system_page_size,
+          compressed: compressed_page_size ? false : true,
+          page_size: compressed_page_size || system_page_size,
+          post_antelope: read_bits_at_offset(flags, 1, 0) == 1,
+          atomic_blobs: read_bits_at_offset(flags, 1, 5) == 1,
+          data_directory: read_bits_at_offset(flags, 1, 10) == 1,
+          value: flags
+        )
+      end
 
-  def size_xdes_entry
-    @size_xdes_entry ||= Innodb::Xdes.new(self, cursor(pos_xdes_array)).size_entry
-  end
+      # The FSP header immediately follows the FIL header.
+      def pos_fsp_header
+        pos_page_body
+      end
 
-  def size_xdes_array
-    entries_in_xdes_array * size_xdes_entry
-  end
+      # The FSP header contains six 32-bit integers, one 64-bit integer, and 5
+      # list base nodes.
+      def size_fsp_header
+        ((4 * 6) + (1 * 8) + (5 * Innodb::List::BASE_NODE_SIZE))
+      end
 
-  # Read the FSP (filespace) header, which contains a few counters and flags,
-  # as well as list base nodes for each list maintained in the filespace.
-  def fsp_header
-    @fsp_header ||= cursor(pos_fsp_header).name("fsp") do |c|
-      {
-        :space_id           => c.name("space_id") { c.get_uint32 },
-        :unused             => c.name("unused") { c.get_uint32 },
-        :size               => c.name("size") { c.get_uint32 },
-        :free_limit         => c.name("free_limit") { c.get_uint32 },
-        :flags              => c.name("flags") {
-          self.class.decode_flags(c.get_uint32)
-        },
-        :frag_n_used        => c.name("frag_n_used") { c.get_uint32 },
-        :free               => c.name("list[free]") {
-          Innodb::List::Xdes.new(@space, Innodb::List.get_base_node(c))
-        },
-        :free_frag          => c.name("list[free_frag]") {
-          Innodb::List::Xdes.new(@space, Innodb::List.get_base_node(c))
-        },
-        :full_frag          => c.name("list[full_frag]") {
-          Innodb::List::Xdes.new(@space, Innodb::List.get_base_node(c))
-        },
-        :first_unused_seg   => c.name("first_unused_seg") { c.get_uint64 },
-        :full_inodes        => c.name("list[full_inodes]") {
-          Innodb::List::Inode.new(@space, Innodb::List.get_base_node(c))
-        },
-        :free_inodes        => c.name("list[free_inodes]") {
-          Innodb::List::Inode.new(@space, Innodb::List.get_base_node(c))
-        },
-      }
-    end
-  end
+      # The XDES entry array immediately follows the FSP header.
+      def pos_xdes_array
+        pos_fsp_header + size_fsp_header
+      end
 
-  # Iterate through all lists in the file space.
-  def each_list
-    unless block_given?
-      return enum_for(:each_list)
-    end
+      # The number of entries in the XDES array. Defined as page size divided by
+      # extent size.
+      def entries_in_xdes_array
+        size / space.pages_per_extent
+      end
 
-    fsp_header.each do |key, value|
-      yield key, value if value.is_a?(Innodb::List)
-    end
-  end
+      def size_xdes_entry
+        @size_xdes_entry ||= Innodb::Xdes.new(self, cursor(pos_xdes_array)).size_entry
+      end
 
-  # Iterate through all XDES entries in order. This is useful for debugging,
-  # but each of these entries is actually a node in some other list. The state
-  # field in the XDES entry indicates which type of list it is present in,
-  # although not necessarily which list (e.g. :fseg).
-  def each_xdes
-    unless block_given?
-      return enum_for(:each_xdes)
-    end
+      def size_xdes_array
+        entries_in_xdes_array * size_xdes_entry
+      end
 
-    cursor(pos_xdes_array).name("xdes_array") do |c|
-      entries_in_xdes_array.times do |n|
-        yield Innodb::Xdes.new(self, c)
+      # Read the FSP (filespace) header, which contains a few counters and flags,
+      # as well as list base nodes for each list maintained in the filespace.
+      def fsp_header
+        @fsp_header ||= cursor(pos_fsp_header).name("fsp") do |c|
+          Header.new(
+            space_id: c.name("space_id") { c.read_uint32 },
+            unused: c.name("unused") { c.read_uint32 },
+            size: c.name("size") { c.read_uint32 },
+            free_limit: c.name("free_limit") { c.read_uint32 },
+            flags: c.name("flags") { self.class.decode_flags(c.read_uint32) },
+            frag_n_used: c.name("frag_n_used") { c.read_uint32 },
+            free: c.name("list[free]") { Innodb::List::Xdes.new(@space, Innodb::List.get_base_node(c)) },
+            free_frag: c.name("list[free_frag]") { Innodb::List::Xdes.new(@space, Innodb::List.get_base_node(c)) },
+            full_frag: c.name("list[full_frag]") { Innodb::List::Xdes.new(@space, Innodb::List.get_base_node(c)) },
+            first_unused_seg: c.name("first_unused_seg") { c.read_uint64 },
+            full_inodes: c.name("list[full_inodes]") { Innodb::List::Inode.new(@space, Innodb::List.get_base_node(c)) },
+            free_inodes: c.name("list[free_inodes]") { Innodb::List::Inode.new(@space, Innodb::List.get_base_node(c)) }
+          )
+        end
       end
-    end
-  end
 
-  def each_region
-    unless block_given?
-      return enum_for(:each_region)
-    end
+      # Iterate through all lists in the file space.
+      def each_list
+        return enum_for(:each_list) unless block_given?
 
-    super do |region|
-      yield region
-    end
+        fsp_header.to_h.each do |key, value|
+          yield key, value if value.is_a?(Innodb::List)
+        end
+      end
 
-    yield({
-      :offset => pos_fsp_header,
-      :length => size_fsp_header,
-      :name => :fsp_header,
-      :info => "FSP Header",
-    })
-
-    each_xdes do |xdes|
-      state = xdes.state || "unused"
-      yield({
-        :offset => xdes.offset,
-        :length => size_xdes_entry,
-        :name => "xdes_#{state}".to_sym,
-        :info => "Extent Descriptor (#{state})",
-      })
-    end
+      # Iterate through all XDES entries in order. This is useful for debugging,
+      # but each of these entries is actually a node in some other list. The state
+      # field in the XDES entry indicates which type of list it is present in,
+      # although not necessarily which list (e.g. :fseg).
+      def each_xdes
+        return enum_for(:each_xdes) unless block_given?
+
+        cursor(pos_xdes_array).name("xdes_array") do |c|
+          entries_in_xdes_array.times do
+            yield Innodb::Xdes.new(self, c)
+          end
+        end
+      end
 
-    nil
-  end
+      def each_region(&block)
+        return enum_for(:each_region) unless block_given?
+
+        super(&block)
+
+        yield Region.new(
+          offset: pos_fsp_header,
+          length: size_fsp_header,
+          name: :fsp_header,
+          info: "FSP Header"
+        )
+
+        each_xdes do |xdes|
+          state = xdes.state || "unused"
+          yield Region.new(
+            offset: xdes.offset,
+            length: size_xdes_entry,
+            name: "xdes_#{state}".to_sym,
+            info: "Extent Descriptor (#{state})"
+          )
+        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 "fsp header:"
-    pp fsp_header
-    puts
+        puts "fsp header:"
+        pp fsp_header
+        puts
 
-    puts "xdes entries:"
-    each_xdes do |xdes|
-      pp xdes
+        puts "xdes entries:"
+        each_xdes do |xdes|
+          pp xdes
+        end
+        puts
+      end
     end
-    puts
   end
 end
-
-Innodb::Page::SPECIALIZED_CLASSES[:FSP_HDR] = Innodb::Page::FspHdrXdes
-Innodb::Page::SPECIALIZED_CLASSES[:XDES]    = Innodb::Page::FspHdrXdes