innodb_ruby 0.9.13 → 0.11.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.rb

@@ -1,341 +1,496 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
+require "forwardable"
 
 # A generic class for any type of page, which handles reading the common
 # FIL header and trailer, and can handle (via #parse) dispatching to a more
 # specialized class depending on page type (which comes from the FIL header).
 # A page being handled by Innodb::Page indicates that its type is not currently
 # handled by any more specialized class.
-class Innodb::Page
-  # A hash of page types to specialized classes to handle them. Normally
-  # subclasses will register themselves in this list.
-  SPECIALIZED_CLASSES = {}
-
-  # Load a page as a generic page in order to make the "fil" header accessible,
-  # and then attempt to hand off the page to a specialized class to be
-  # re-parsed if possible. If there is no specialized class for this type
-  # of page, return the generic object.
-  #
-  # This could be optimized to reach into the page buffer and efficiently
-  # extract the page type in order to avoid throwing away a generic
-  # Innodb::Page object when parsing every specialized page, but this is
-  # a bit cleaner, and we're not particularly performance sensitive.
-  def self.parse(space, buffer)
-    # Create a page object as a generic page.
-    page = Innodb::Page.new(space, buffer)
-
-    # If there is a specialized class available for this page type, re-create
-    # the page object using that specialized class.
-    if specialized_class = SPECIALIZED_CLASSES[page.type]
-      page = specialized_class.handle(page, space, buffer)
-    end
-
-    page
-  end
+module Innodb
+  class Page
+    extend Forwardable
+
+    Address = Struct.new(
+      :page,
+      :offset,
+      keyword_init: true
+    )
+
+    FilHeader = Struct.new(
+      :checksum,
+      :offset,
+      :prev,
+      :next,
+      :lsn,
+      :type,
+      :flush_lsn,
+      :space_id,
+      keyword_init: true
+    )
+
+    class FilHeader
+      def lsn_low32
+        lsn & 0xffffffff
+      end
+    end
 
-  # Allow the specialized class to do something that isn't 'new' with this page.
-  def self.handle(page, space, buffer)
-    self.new(space, buffer)
-  end
+    FilTrailer = Struct.new(
+      :checksum,
+      :lsn_low32,
+      keyword_init: true
+    )
+
+    Region = Struct.new(
+      :offset,
+      :length, # rubocop:disable Lint/StructNewOverride
+      :name,
+      :info,
+      keyword_init: true
+    )
+
+    # A hash of page types to specialized classes to handle them. Normally
+    # subclasses will register themselves in this list.
+    @specialized_classes = {}
+
+    class << self
+      attr_reader :specialized_classes
+    end
 
-  # Initialize a page by passing in a buffer containing the raw page contents.
-  # The buffer size should match the space's page size.
-  def initialize(space, buffer)
-    unless space && buffer
-      raise "Page can't be initialized from nil space or buffer (space: #{space}, buffer: #{buffer})"
+    def self.register_specialization(page_type, specialized_class)
+      @specialized_classes[page_type] = specialized_class
     end
 
-    unless space.page_size == buffer.size
-      raise "Buffer size #{buffer.size} is different than space page size"
+    def self.specialization_for(page_type)
+      # This needs to intentionally use Innodb::Page because we need to register
+      # in the class instance variable in *that* class.
+      Innodb::Page.register_specialization(page_type, self)
     end
 
-    @space  = space
-    @buffer = buffer
-  end
+    def self.specialization_for?(page_type)
+      Innodb::Page.specialized_classes.include?(page_type)
+    end
 
-  attr_reader :space
+    # Load a page as a generic page in order to make the "fil" header accessible,
+    # and then attempt to hand off the page to a specialized class to be
+    # re-parsed if possible. If there is no specialized class for this type
+    # of page, return the generic object.
+    #
+    # This could be optimized to reach into the page buffer and efficiently
+    # extract the page type in order to avoid throwing away a generic
+    # Innodb::Page object when parsing every specialized page, but this is
+    # a bit cleaner, and we're not particularly performance sensitive.
+    def self.parse(space, buffer, page_number = nil)
+      # Create a page object as a generic page.
+      page = Innodb::Page.new(space, buffer, page_number)
+
+      # If there is a specialized class available for this page type, re-create
+      # the page object using that specialized class.
+      if (specialized_class = specialized_classes[page.type])
+        page = specialized_class.handle(page, space, buffer, page_number)
+      end
+
+      page
+    end
 
-  # Return the page size, to eventually be able to deal with non-16kB pages.
-  def size
-    @size ||= @buffer.size
-  end
+    # Allow the specialized class to do something that isn't 'new' with this page.
+    def self.handle(_page, space, buffer, page_number = nil)
+      new(space, buffer, page_number)
+    end
 
-  # Return a simple string to uniquely identify this page within the space.
-  # Be careful not to call anything which would instantiate a BufferCursor
-  # so that we can use this method in cursor initialization.
-  def name
-    page_offset = BinData::Uint32be.read(@buffer.slice(4, 4))
-    page_type = BinData::Uint16be.read(@buffer.slice(24, 2))
-    "%i,%s" % [
-      page_offset,
-      PAGE_TYPE_BY_VALUE[page_type],
-    ]
-  end
+    # Initialize a page by passing in a buffer containing the raw page contents.
+    # The buffer size should match the space's page size.
+    def initialize(space, buffer, page_number = nil)
+      unless space && buffer
+        raise "Page can't be initialized from nil space or buffer (space: #{space}, buffer: #{buffer})"
+      end
+
+      raise "Buffer size #{buffer.size} is different than space page size" unless space.page_size == buffer.size
 
-  # If no block is passed, return an BufferCursor object positioned at a
-  # specific offset. If a block is passed, create a cursor at the provided
-  # offset and yield it to the provided block one time, and then return the
-  # return value of the block.
-  def cursor(buffer_offset)
-    new_cursor = BufferCursor.new(@buffer, buffer_offset)
-    new_cursor.push_name("space[#{space.name}]")
-    new_cursor.push_name("page[#{name}]")
-
-    if block_given?
-      # Call the block once and return its return value.
-      yield new_cursor
-    else
-      # Return the cursor itself.
-      new_cursor
+      @space  = space
+      @buffer = buffer
+      @page_number = page_number
     end
-  end
 
-  # Return the byte offset of the start of the "fil" header, which is at the
-  # beginning of the page. Included here primarily for completeness.
-  def pos_fil_header
-    0
-  end
+    attr_reader :space
 
-  # Return the size of the "fil" header, in bytes.
-  def size_fil_header
-    4 + 4 + 4 + 4 + 8 + 2 + 8 + 4
-  end
+    # Return the page size, to eventually be able to deal with non-16kB pages.
+    def size
+      @size ||= @buffer.size
+    end
 
-  # Return the byte offset of the start of the "fil" trailer, which is at
-  # the end of the page.
-  def pos_fil_trailer
-    size - size_fil_trailer
-  end
+    def default_page_size?
+      size == Innodb::Space::DEFAULT_PAGE_SIZE
+    end
 
-  # Return the size of the "fil" trailer, in bytes.
-  def size_fil_trailer
-    4 + 4
-  end
+    # Return a simple string to uniquely identify this page within the space.
+    # Be careful not to call anything which would instantiate a BufferCursor
+    # so that we can use this method in cursor initialization.
+    def name
+      page_offset = BinData::Uint32be.read(@buffer.slice(4, 4))
+      page_type = BinData::Uint16be.read(@buffer.slice(24, 2))
+      "%i,%s" % [
+        page_offset,
+        PAGE_TYPE_BY_VALUE[page_type],
+      ]
+    end
 
-  # Return the position of the "body" of the page, which starts after the FIL
-  # header.
-  def pos_page_body
-    pos_fil_header + size_fil_header
-  end
+    # If no block is passed, return an BufferCursor object positioned at a
+    # specific offset. If a block is passed, create a cursor at the provided
+    # offset and yield it to the provided block one time, and then return the
+    # return value of the block.
+    def cursor(buffer_offset)
+      new_cursor = BufferCursor.new(@buffer, buffer_offset)
+      new_cursor.push_name("space[#{space.name}]")
+      new_cursor.push_name("page[#{name}]")
+
+      if block_given?
+        # Call the block once and return its return value.
+        yield new_cursor
+      else
+        # Return the cursor itself.
+        new_cursor
+      end
+    end
 
-  # InnoDB Page Type constants from include/fil0fil.h.
-  PAGE_TYPE = {
-    :ALLOCATED => {
-      :value => 0,
-      :description => "Freshly allocated",
-      :usage => "page type field has not been initialized",
-    },
-    :UNDO_LOG => {
-      :value => 2,
-      :description => "Undo log",
-      :usage => "stores previous values of modified records",
-    },
-    :INODE => {
-      :value => 3,
-      :description => "File segment inode",
-      :usage => "bookkeeping for file segments",
-    },
-    :IBUF_FREE_LIST => {
-      :value => 4,
-      :description => "Insert buffer free list",
-      :usage => "bookkeeping for insert buffer free space management",
-    },
-    :IBUF_BITMAP => {
-      :value => 5,
-      :description => "Insert buffer bitmap",
-      :usage => "bookkeeping for insert buffer writes to be merged",
-    },
-    :SYS => {
-      :value => 6,
-      :description => "System internal",
-      :usage => "used for various purposes in the system tablespace",
-    },
-    :TRX_SYS => {
-      :value => 7,
-      :description => "Transaction system header",
-      :usage => "bookkeeping for the transaction system in system tablespace",
-    },
-    :FSP_HDR => {
-      :value => 8,
-      :description => "File space header",
-      :usage => "header page (page 0) for each tablespace file",
-    },
-    :XDES => {
-      :value => 9,
-      :description => "Extent descriptor",
-      :usage => "header page for subsequent blocks of 16,384 pages",
-    },
-    :BLOB => {
-      :value => 10,
-      :description => "Uncompressed BLOB",
-      :usage => "externally-stored uncompressed BLOB column data",
-    },
-    :ZBLOB => {
-      :value => 11,
-      :description => "First compressed BLOB",
-      :usage => "externally-stored compressed BLOB column data, first page",
-    },
-    :ZBLOB2 => {
-      :value => 12,
-      :description => "Subsequent compressed BLOB",
-      :usage => "externally-stored compressed BLOB column data, subsequent page",
-    },
-    :INDEX => {
-      :value => 17855,
-      :description => "B+Tree index",
-      :usage => "table and index data stored in B+Tree structure",
-    },
-  }
-
-  PAGE_TYPE_BY_VALUE = PAGE_TYPE.inject({}) { |h, (k, v)| h[v[:value]] = k; h }
-
-  # A helper to convert "undefined" values stored in previous and next pointers
-  # in the page header to nil.
-  def self.maybe_undefined(value)
-    value == 4294967295 ? nil : value
-  end
+    # Return the byte offset of the start of the "fil" header, which is at the
+    # beginning of the page. Included here primarily for completeness.
+    def pos_fil_header
+      0
+    end
 
-  # Return the "fil" header from the page, which is common for all page types.
-  def fil_header
-    @fil_header ||= cursor(pos_fil_header).name("fil") do |c|
-      {
-        :checksum   => c.name("checksum") { c.get_uint32 },
-        :offset     => c.name("offset") { c.get_uint32 },
-        :prev       => c.name("prev") {
-          Innodb::Page.maybe_undefined(c.get_uint32)
-        },
-        :next       => c.name("next") {
-          Innodb::Page.maybe_undefined(c.get_uint32)
-        },
-        :lsn        => c.name("lsn") { c.get_uint64 },
-        :type       => c.name("type") { PAGE_TYPE_BY_VALUE[c.get_uint16] },
-        :flush_lsn  => c.name("flush_lsn") { c.get_uint64 },
-        :space_id   => c.name("space_id") { c.get_uint32 },
-      }
+    # Return the size of the "fil" header, in bytes.
+    def size_fil_header
+      4 + 4 + 4 + 4 + 8 + 2 + 8 + 4
     end
-  end
 
-  # A helper function to return the checksum from the "fil" header, for easier
-  # access.
-  def checksum
-    fil_header[:checksum]
-  end
+    # The start of the checksummed portion of the file header.
+    def pos_partial_page_header
+      pos_fil_header + 4
+    end
 
-  # A helper function to return the page offset from the "fil" header, for
-  # easier access.
-  def offset
-    fil_header[:offset]
-  end
+    # The size of the portion of the fil header that is included in the
+    # checksum. Exclude the following:
+    #   :checksum   (offset 4, size 4)
+    #   :flush_lsn  (offset 26, size 8)
+    #   :space_id   (offset 34, size 4)
+    def size_partial_page_header
+      size_fil_header - 4 - 8 - 4
+    end
 
-  # A helper function to return the page number of the logical previous page
-  # (from the doubly-linked list from page to page) from the "fil" header,
-  # for easier access.
-  def prev
-    fil_header[:prev]
-  end
+    # Return the byte offset of the start of the "fil" trailer, which is at
+    # the end of the page.
+    def pos_fil_trailer
+      size - size_fil_trailer
+    end
 
-  # A helper function to return the page number of the logical next page
-  # (from the doubly-linked list from page to page) from the "fil" header,
-  # for easier access.
-  def next
-    fil_header[:next]
-  end
+    # Return the size of the "fil" trailer, in bytes.
+    def size_fil_trailer
+      4 + 4
+    end
 
-  # A helper function to return the LSN, for easier access.
-  def lsn
-    fil_header[:lsn]
-  end
+    # Return the position of the "body" of the page, which starts after the FIL
+    # header.
+    def pos_page_body
+      pos_fil_header + size_fil_header
+    end
 
-  # A helper function to return the page type from the "fil" header, for easier
-  # access.
-  def type
-    fil_header[:type]
-  end
+    # Return the size of the page body, excluding the header and trailer.
+    def size_page_body
+      size - size_fil_trailer - size_fil_header
+    end
 
-  # Calculate the checksum of the page using InnoDB's algorithm. Two sections
-  # of the page are checksummed separately, and then added together to produce
-  # the final checksum.
-  def calculate_checksum
-    unless size == 16384
-      raise "Checksum calculation is only supported for 16 KiB pages"
+    # InnoDB Page Type constants from include/fil0fil.h.
+    PAGE_TYPE = {
+      ALLOCATED: {
+        value: 0,
+        description: "Freshly allocated",
+        usage: "page type field has not been initialized",
+      },
+      UNDO_LOG: {
+        value: 2,
+        description: "Undo log",
+        usage: "stores previous values of modified records",
+      },
+      INODE: {
+        value: 3,
+        description: "File segment inode",
+        usage: "bookkeeping for file segments",
+      },
+      IBUF_FREE_LIST: {
+        value: 4,
+        description: "Insert buffer free list",
+        usage: "bookkeeping for insert buffer free space management",
+      },
+      IBUF_BITMAP: {
+        value: 5,
+        description: "Insert buffer bitmap",
+        usage: "bookkeeping for insert buffer writes to be merged",
+      },
+      SYS: {
+        value: 6,
+        description: "System internal",
+        usage: "used for various purposes in the system tablespace",
+      },
+      TRX_SYS: {
+        value: 7,
+        description: "Transaction system header",
+        usage: "bookkeeping for the transaction system in system tablespace",
+      },
+      FSP_HDR: {
+        value: 8,
+        description: "File space header",
+        usage: "header page (page 0) for each tablespace file",
+      },
+      XDES: {
+        value: 9,
+        description: "Extent descriptor",
+        usage: "header page for subsequent blocks of 16,384 pages",
+      },
+      BLOB: {
+        value: 10,
+        description: "Uncompressed BLOB",
+        usage: "externally-stored uncompressed BLOB column data",
+      },
+      ZBLOB: {
+        value: 11,
+        description: "First compressed BLOB",
+        usage: "externally-stored compressed BLOB column data, first page",
+      },
+      ZBLOB2: {
+        value: 12,
+        description: "Subsequent compressed BLOB",
+        usage: "externally-stored compressed BLOB column data, subsequent page",
+      },
+      INDEX: {
+        value: 17_855,
+        description: "B+Tree index",
+        usage: "table and index data stored in B+Tree structure",
+      },
+    }.freeze
+
+    PAGE_TYPE_BY_VALUE = PAGE_TYPE.each_with_object({}) { |(k, v), h| h[v[:value]] = k }
+
+    # A page number representing "undefined" values, (4294967295).
+    UNDEFINED_PAGE_NUMBER = 2**32 - 1
+
+    # A helper to check if a page number is the undefined page number.
+    def self.undefined?(page_number)
+      page_number == UNDEFINED_PAGE_NUMBER
     end
 
-    # Calculate the checksum of the FIL header, except for the following:
-    #   :checksum   (offset 4, size 4)
-    #   :flush_lsn  (offset 26, size 8)
-    #   :space_id   (offset 34, size 4)
-    c_partial_header =
-      Innodb::Checksum.fold_enumerator(
-        cursor(pos_fil_header + 4).each_byte_as_uint8(
-          size_fil_header - 4 - 8 - 4
+    # A helper to convert "undefined" values stored in previous and next pointers
+    # in the page header to nil.
+    def self.maybe_undefined(page_number)
+      page_number unless undefined?(page_number)
+    end
+
+    # Return the "fil" header from the page, which is common for all page types.
+    def fil_header
+      @fil_header ||= cursor(pos_fil_header).name("fil_header") do |c|
+        FilHeader.new(
+          checksum: c.name("checksum") { c.read_uint32 },
+          offset: c.name("offset") { c.read_uint32 },
+          prev: c.name("prev") { Innodb::Page.maybe_undefined(c.read_uint32) },
+          next: c.name("next") { Innodb::Page.maybe_undefined(c.read_uint32) },
+          lsn: c.name("lsn") { c.read_uint64 },
+          type: c.name("type") { PAGE_TYPE_BY_VALUE[c.read_uint16] },
+          flush_lsn: c.name("flush_lsn") { c.read_uint64 },
+          space_id: c.name("space_id") { c.read_uint32 }
         )
-      )
+      end
+    end
 
-    # Calculate the checksum of the page body, except for the FIL header and
-    # the FIL trailer.
-    c_page_body =
-      Innodb::Checksum.fold_enumerator(
-        cursor(pos_page_body).each_byte_as_uint8(
-          size - size_fil_trailer - size_fil_header
+    # Return the "fil" trailer from the page, which is common for all page types.
+    def fil_trailer
+      @fil_trailer ||= cursor(pos_fil_trailer).name("fil_trailer") do |c|
+        FilTrailer.new(
+          checksum: c.name("checksum") { c.read_uint32 },
+          lsn_low32: c.name("lsn_low32") { c.read_uint32 }
         )
-      )
+      end
+    end
 
-    # Add the two checksums together, and mask the result back to 32 bits.
-    (c_partial_header + c_page_body) & Innodb::Checksum::MAX
-  end
+    def_delegator :fil_header, :checksum
+    def_delegator :fil_header, :offset
+    def_delegator :fil_header, :prev
+    def_delegator :fil_header, :next
+    def_delegator :fil_header, :lsn
+    def_delegator :fil_header, :type
+    def_delegator :fil_header, :space_id
 
-  # Is the page corrupt? Calculate the checksum of the page and compare to
-  # the stored checksum; return true or false.
-  def corrupt?
-    checksum != calculate_checksum
-  end
+    # Iterate each byte of the FIL header.
+    def each_page_header_byte_as_uint8(&block)
+      return enum_for(:each_page_header_byte_as_uint8) unless block_given?
 
-  def each_region
-    unless block_given?
-      return enum_for(:each_region)
+      cursor(pos_partial_page_header).each_byte_as_uint8(size_partial_page_header, &block)
     end
 
-    yield({
-      :offset => pos_fil_header,
-      :length => size_fil_header,
-      :name   => :fil_header,
-      :info   => "FIL Header",
-    })
+    # Iterate each byte of the page body, except for the FIL header and
+    # the FIL trailer.
+    def each_page_body_byte_as_uint8(&block)
+      return enum_for(:each_page_body_byte_as_uint8) unless block_given?
 
-    yield({
-      :offset => pos_fil_trailer,
-      :length => size_fil_trailer,
-      :name   => :fil_trailer,
-      :info   => "FIL Trailer",
-    })
+      cursor(pos_page_body).each_byte_as_uint8(size_page_body, &block)
+    end
 
-    nil
-  end
+    # Calculate the checksum of the page using InnoDB's algorithm.
+    def checksum_innodb
+      raise "Checksum calculation is only supported for 16 KiB pages" unless default_page_size?
 
-  # Implement a custom inspect method to avoid irb printing the contents of
-  # the page buffer, since it's very large and mostly not interesting.
-  def inspect
-    if fil_header
-      "#<%s: size=%i, space_id=%i, offset=%i, type=%s, prev=%s, next=%s>" % [
-        self.class,
-        size,
-        fil_header[:space_id],
-        fil_header[:offset],
-        fil_header[:type],
-        fil_header[:prev] || "nil",
-        fil_header[:next] || "nil",
-      ]
-    else
-      "#<#{self.class}>"
+      @checksum_innodb ||= begin
+        # Calculate the InnoDB checksum of the page header.
+        c_partial_header = Innodb::Checksum.fold_enumerator(each_page_header_byte_as_uint8)
+
+        # Calculate the InnoDB checksum of the page body.
+        c_page_body = Innodb::Checksum.fold_enumerator(each_page_body_byte_as_uint8)
+
+        # Add the two checksums together, and mask the result back to 32 bits.
+        (c_partial_header + c_page_body) & Innodb::Checksum::MAX
+      end
+    end
+
+    def checksum_innodb?
+      checksum == checksum_innodb
+    end
+
+    # Calculate the checksum of the page using the CRC32c algorithm.
+    def checksum_crc32
+      raise "Checksum calculation is only supported for 16 KiB pages" unless default_page_size?
+
+      @checksum_crc32 ||= begin
+        # Calculate the CRC32c of the page header.
+        crc_partial_header = Digest::CRC32c.new
+        each_page_header_byte_as_uint8 do |byte|
+          crc_partial_header << byte.chr
+        end
+
+        # Calculate the CRC32c of the page body.
+        crc_page_body = Digest::CRC32c.new
+        each_page_body_byte_as_uint8 do |byte|
+          crc_page_body << byte.chr
+        end
+
+        # Bitwise XOR the two checksums together.
+        crc_partial_header.checksum ^ crc_page_body.checksum
+      end
+    end
+
+    def checksum_crc32?
+      checksum == checksum_crc32
+    end
+
+    # Is the page checksum correct?
+    def checksum_valid?
+      checksum_crc32? || checksum_innodb?
+    end
+
+    # Is the page checksum incorrect?
+    def checksum_invalid?
+      !checksum_valid?
+    end
+
+    def checksum_type
+      return :crc32 if checksum_crc32?
+      return :innodb if checksum_innodb?
+
+      nil
+    end
+
+    # Is the LSN stored in the header different from the one stored in the
+    # trailer?
+    def torn?
+      fil_header.lsn_low32 != fil_trailer.lsn_low32
     end
-  end
 
-  # Dump the contents of a page for debugging purposes.
-  def dump
-    puts "#{self}:"
-    puts
+    # Is the page in the doublewrite buffer?
+    def in_doublewrite_buffer?
+      space&.system_space? && space&.doublewrite_page?(offset)
+    end
+
+    # Is the space ID stored in the header different from that of the space
+    # provided when initializing this page?
+    def misplaced_space?
+      space && (space_id != space.space_id)
+    end
+
+    # Is the page number stored in the header different from the page number
+    # which was supposed to be read?
+    def misplaced_offset?
+      offset != @page_number
+    end
+
+    # Is the page misplaced in the wrong file or by offset in the file?
+    def misplaced?
+      !in_doublewrite_buffer? && (misplaced_space? || misplaced_offset?)
+    end
 
-    puts "fil header:"
-    pp fil_header
-    puts
+    # Is the page corrupt, either due to data corruption, tearing, or in the
+    # wrong place?
+    def corrupt?
+      checksum_invalid? || torn? || misplaced?
+    end
+
+    # Is this an extent descriptor page (either FSP_HDR or XDES)?
+    def extent_descriptor?
+      type == :FSP_HDR || type == :XDES
+    end
+
+    def each_region
+      return enum_for(:each_region) unless block_given?
+
+      yield Region.new(
+        offset: pos_fil_header,
+        length: size_fil_header,
+        name: :fil_header,
+        info: "FIL Header"
+      )
+
+      yield Region.new(
+        offset: pos_fil_trailer,
+        length: size_fil_trailer,
+        name: :fil_trailer,
+        info: "FIL Trailer"
+      )
+
+      nil
+    end
+
+    def inspect_header_fields
+      return nil unless fil_header
+
+      %i[
+        size
+        space_id
+        offset
+        type
+        prev
+        next
+        checksum_valid?
+        checksum_type
+        torn?
+        misplaced?
+      ].map { |m| "#{m}=#{send(m).inspect}" }.join(", ")
+    end
+
+    # Implement a custom inspect method to avoid irb printing the contents of
+    # the page buffer, since it's very large and mostly not interesting.
+    def inspect
+      "#<#{self.class} #{inspect_header_fields || '(page header unavailable)'}>"
+    end
+
+    # Dump the contents of a page for debugging purposes.
+    def dump
+      puts "#{self}:"
+      puts
+
+      puts "fil header:"
+      pp fil_header
+      puts
+
+      puts "fil trailer:"
+      pp fil_trailer
+      puts
+    end
   end
 end