innodb_ruby 0.9.13 → 0.11.0

data/lib/innodb/inode.rb

@@ -1,144 +1,186 @@
-# -*- encoding : utf-8 -*-
-
-class Innodb::Inode
-  # The number of "slots" (each representing one page) in the fragment array
-  # within each Inode entry.
-  FRAG_ARRAY_N_SLOTS  = 32 # FSP_EXTENT_SIZE / 2
-
-  # The size (in bytes) of each slot in the fragment array.
-  FRAG_SLOT_SIZE      = 4
-
-  # A magic number which helps determine if an Inode structure is in use
-  # and populated with valid data.
-  MAGIC_N_VALUE	= 97937874
-
-  # The size (in bytes) of an Inode entry.
-  SIZE = (16 + (3 * Innodb::List::BASE_NODE_SIZE) +
-    (FRAG_ARRAY_N_SLOTS * FRAG_SLOT_SIZE))
-
-  # Read an array of page numbers (32-bit integers, which may be nil) from
-  # the provided cursor.
-  def self.page_number_array(size, cursor)
-    size.times.map do |n|
-      cursor.name("page[#{n}]") do |c|
-        Innodb::Page.maybe_undefined(c.get_uint32)
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Innodb
+  class Inode
+    extend Forwardable
+
+    Header = Struct.new(
+      :offset,
+      :fseg_id,
+      :not_full_n_used,
+      :free,
+      :not_full,
+      :full,
+      :magic_n,
+      :frag_array,
+      keyword_init: true
+    )
+
+    # The number of "slots" (each representing one page) in the fragment array
+    # within each Inode entry.
+    FRAG_ARRAY_N_SLOTS = 32 # FSP_EXTENT_SIZE / 2
+
+    # The size (in bytes) of each slot in the fragment array.
+    FRAG_SLOT_SIZE = 4
+
+    # A magic number which helps determine if an Inode structure is in use
+    # and populated with valid data.
+    MAGIC_N_VALUE	= 97_937_874
+
+    # The size (in bytes) of an Inode entry.
+    SIZE = (16 + (3 * Innodb::List::BASE_NODE_SIZE) +
+      (FRAG_ARRAY_N_SLOTS * FRAG_SLOT_SIZE))
+
+    LISTS = %i[
+      free
+      not_full
+      full
+    ].freeze
+
+    # Read an array of page numbers (32-bit integers, which may be nil) from
+    # the provided cursor.
+    def self.page_number_array(size, cursor)
+      size.times.map do |n|
+        cursor.name("page[#{n}]") do |c|
+          Innodb::Page.maybe_undefined(c.read_uint32)
+        end
       end
     end
-  end
 
-  # Construct a new Inode by reading an FSEG header from a cursor.
-  def self.new_from_cursor(space, cursor)
-    data = {
-      :offset => cursor.position,
-      :fseg_id => cursor.name("fseg_id") {
-        cursor.get_uint64
-      },
-      :not_full_n_used => cursor.name("not_full_n_used") {
-        cursor.get_uint32
-      },
-      :free => cursor.name("list[free]") { 
-        Innodb::List::Xdes.new(space, Innodb::List.get_base_node(cursor))
-      },
-      :not_full => cursor.name("list[not_full]") { 
-        Innodb::List::Xdes.new(space, Innodb::List.get_base_node(cursor))
-      },
-      :full => cursor.name("list[full]") { 
-        Innodb::List::Xdes.new(space, Innodb::List.get_base_node(cursor))
-      },
-      :magic_n => cursor.name("magic_n") {
-        cursor.get_uint32
-      },
-      :frag_array => cursor.name("frag_array") { 
-        page_number_array(FRAG_ARRAY_N_SLOTS, cursor)
-      },
-    }
-
-    Innodb::Inode.new(space, data)
-  end
+    # Construct a new Inode by reading an FSEG header from a cursor.
+    def self.new_from_cursor(space, cursor)
+      Innodb::Inode.new(
+        space,
+        Header.new(
+          offset: cursor.position,
+          fseg_id: cursor.name("fseg_id") { cursor.read_uint64 },
+          not_full_n_used: cursor.name("not_full_n_used") { cursor.read_uint32 },
+          free: cursor.name("list[free]") { Innodb::List::Xdes.new(space, Innodb::List.get_base_node(cursor)) },
+          not_full: cursor.name("list[not_full]") { Innodb::List::Xdes.new(space, Innodb::List.get_base_node(cursor)) },
+          full: cursor.name("list[full]") { Innodb::List::Xdes.new(space, Innodb::List.get_base_node(cursor)) },
+          magic_n: cursor.name("magic_n") { cursor.read_uint32 },
+          frag_array: cursor.name("frag_array") { page_number_array(FRAG_ARRAY_N_SLOTS, cursor) }
+        )
+      )
+    end
 
-  attr_accessor :space
+    attr_accessor :space
+    attr_accessor :header
 
-  def initialize(space, data)
-    @space = space
-    @data = data
-  end
+    def initialize(space, header)
+      @space = space
+      @header = header
+    end
 
-  def offset;           @data[:offset];           end
-  def fseg_id;          @data[:fseg_id];          end
-  def not_full_n_used;  @data[:not_full_n_used];  end
-  def free;             @data[:free];             end
-  def not_full;         @data[:not_full];         end
-  def full;             @data[:full];             end
-  def magic_n;          @data[:magic_n];          end
-  def frag_array;       @data[:frag_array];       end
-
-  def inspect
-    "<%s space=%s, fseg=%i>" % [
-      self.class.name,
-      space.inspect,
-      fseg_id,
-    ]
-  end
+    def_delegator :header, :offset
+    def_delegator :header, :fseg_id
+    def_delegator :header, :not_full_n_used
+    def_delegator :header, :free
+    def_delegator :header, :not_full
+    def_delegator :header, :full
+    def_delegator :header, :magic_n
+    def_delegator :header, :frag_array
+
+    def inspect
+      "<%s space=%s, fseg=%i>" % [
+        self.class.name,
+        space.inspect,
+        fseg_id,
+      ]
+    end
 
-  # Helper method to determine if an Inode is in use. Inodes that are not in
-  # use have an fseg_id of 0.
-  def allocated?
-    fseg_id != 0
-  end
+    # Helper method to determine if an Inode is in use. Inodes that are not in
+    # use have an fseg_id of 0.
+    def allocated?
+      fseg_id != 0
+    end
 
-  # Helper method to return an array of only non-nil fragment pages.
-  def frag_array_pages
-    frag_array.select { |n| ! n.nil? }
-  end
+    # Helper method to return an array of only non-nil fragment pages.
+    def frag_array_pages
+      frag_array.reject(&:nil?)
+    end
 
-  # Helper method to count non-nil fragment pages.
-  def frag_array_n_used
-    frag_array.inject(0) { |n, i| n += 1 if i; n }
-  end
+    # Helper method to count non-nil fragment pages.
+    def frag_array_n_used
+      frag_array_pages.count
+    end
 
-  # Calculate the total number of pages in use (not free) within this fseg.
-  def used_pages
-    frag_array_n_used + not_full_n_used +
-      (full.length * @space.pages_per_extent)
-  end
+    # Calculate the total number of pages in use (not free) within this fseg.
+    def used_pages
+      frag_array_n_used + not_full_n_used +
+        (full.length * @space.pages_per_extent)
+    end
 
-  # Calculate the total number of pages within this fseg.
-  def total_pages
-    frag_array_n_used +
-      (free.length * @space.pages_per_extent) +
-      (not_full.length * @space.pages_per_extent) +
-      (full.length * @space.pages_per_extent)
-  end
+    # Calculate the total number of pages within this fseg.
+    def total_pages
+      frag_array_n_used +
+        (free.length * @space.pages_per_extent) +
+        (not_full.length * @space.pages_per_extent) +
+        (full.length * @space.pages_per_extent)
+    end
 
-  # Calculate the fill factor of this fseg, in percent.
-  def fill_factor
-    total_pages > 0 ? 100.0 * (used_pages.to_f / total_pages.to_f) : 0.0
-  end
+    # Calculate the fill factor of this fseg, in percent.
+    def fill_factor
+      total_pages.positive? ? 100.0 * (used_pages.to_f / total_pages) : 0.0
+    end
 
-  # Return an array of lists within an fseg.
-  def lists
-    [:free, :not_full, :full]
-  end
+    # Return a list from the fseg, given its name as a symbol.
+    def list(name)
+      return unless LISTS.include?(name)
 
-  # Return a list from the fseg, given its name as a symbol.
-  def list(name)
-    @data[name] if lists.include? name
-  end
+      header[name]
+    end
+
+    # Iterate through all lists, yielding the list name and the list itself.
+    def each_list
+      return enum_for(:each_list) unless block_given?
+
+      LISTS.each do |name|
+        yield name, list(name)
+      end
 
-  # Iterate through all lists, yielding the list name and the list itself.
-  def each_list
-    lists.each do |name|
-      yield name, list(name)
+      nil
     end
-  end
 
-  # Compare one Innodb::Inode to another.
-  def ==(other)
-    fseg_id == other.fseg_id if other
-  end
+    # Iterate through the fragment array followed by all lists, yielding the
+    # page number. This allows a convenient way to identify all pages that are
+    # part of this inode.
+    def each_page_number(&block)
+      return enum_for(:each_page_number) unless block_given?
+
+      frag_array_pages.each(&block)
+
+      each_list do |_fseg_name, fseg_list|
+        fseg_list.each do |xdes|
+          xdes.each_page_status(&block)
+        end
+      end
 
-  # Dump a summary of this object for debugging purposes.
-  def dump
-    pp @data
+      nil
+    end
+
+    # Iterate through the page as associated with this inode using the
+    # each_page_number method, and yield the page number and page.
+    def each_page
+      return enum_for(:each_page) unless block_given?
+
+      each_page_number do |page_number|
+        yield page_number, space.page(page_number)
+      end
+
+      nil
+    end
+
+    # Compare one Innodb::Inode to another.
+    def ==(other)
+      fseg_id == other.fseg_id if other
+    end
+
+    # Dump a summary of this object for debugging purposes.
+    def dump
+      pp header
+    end
   end
 end

data/lib/innodb/list.rb

@@ -1,233 +1,241 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 # An abstract InnoDB "free list" or FLST (renamed to just "list" here as it
 # frequently is used for structures that aren't free lists). This class must
 # be sub-classed to provide an appropriate #object_from_address method.
 
-class Innodb::List
-  # An "address", which consists of a page number and byte offset within the
-  # page. This points to the list "node" pointers (prev and next) of the
-  # node, not necessarily the node object.
-  ADDRESS_SIZE = 4 + 2
-
-  # Read a node address from a cursor. Return nil if the address is an end
-  # or "NULL" pointer (the page number is UINT32_MAX), or the address if
-  # valid.
-  def self.get_address(cursor)
-    page    = cursor.name("page") {
-      Innodb::Page.maybe_undefined(cursor.get_uint32)
-    }
-    offset  = cursor.name("offset") { cursor.get_uint16 }
-    if page
-      {
-        :page     => page,
-        :offset   => offset,
-      }
+module Innodb
+  class List
+    BaseNode = Struct.new(
+      :length, # rubocop:disable Lint/StructNewOverride
+      :first, # rubocop:disable Lint/StructNewOverride
+      :last,
+      keyword_init: true
+    )
+
+    Node = Struct.new(
+      :prev,
+      :next,
+      keyword_init: true
+    )
+
+    # An "address", which consists of a page number and byte offset within the
+    # page. This points to the list "node" pointers (prev and next) of the
+    # node, not necessarily the node object.
+    ADDRESS_SIZE = 4 + 2
+
+    # Read a node address from a cursor. Return nil if the address is an end
+    # or "NULL" pointer (the page number is UINT32_MAX), or the address if
+    # valid.
+    def self.get_address(cursor)
+      page = cursor.name("page") { Innodb::Page.maybe_undefined(cursor.read_uint32) }
+      offset = cursor.name("offset") { cursor.read_uint16 }
+
+      Innodb::Page::Address.new(page: page, offset: offset) if page
     end
-  end
-
-  # A list node consists of two addresses: the "previous" node address, and
-  # the "next" node address.
-  NODE_SIZE = 2 * ADDRESS_SIZE
-
-  # Read a node, consisting of two consecutive addresses (:prev and :next)
-  # from a cursor. Either address may be nil, indicating the end of the
-  # linked list.
-  def self.get_node(cursor)
-    {
-      :prev => cursor.name("prev") { get_address(cursor) },
-      :next => cursor.name("next") { get_address(cursor) },
-    }
-  end
 
-  # A list base node consists of a list length followed by two addresses:
-  # the "first" node address, and the "last" node address.
-  BASE_NODE_SIZE = 4 + (2 * ADDRESS_SIZE)
-
-  # Read a base node, consisting of a list length followed by two addresses
-  # (:first and :last) from a cursor. Either address may be nil. An empty list
-  # has a :length of 0 and :first and :last are nil. A list with only a single
-  # item will have a :length of 1 and :first and :last will point to the same
-  # address.
-  def self.get_base_node(cursor)
-    {
-      :length => cursor.name("length") { cursor.get_uint32 },
-      :first  => cursor.name("first") { get_address(cursor) },
-      :last   => cursor.name("last")  { get_address(cursor) },
-    }
-  end
+    # A list node consists of two addresses: the "previous" node address, and
+    # the "next" node address.
+    NODE_SIZE = 2 * ADDRESS_SIZE
+
+    # Read a node, consisting of two consecutive addresses (:prev and :next)
+    # from a cursor. Either address may be nil, indicating the end of the
+    # linked list.
+    def self.get_node(cursor)
+      Node.new(
+        prev: cursor.name("prev") { get_address(cursor) },
+        next: cursor.name("next") { get_address(cursor) }
+      )
+    end
 
-  def initialize(space, base)
-    @space  = space
-    @base   = base
-  end
+    # A list base node consists of a list length followed by two addresses:
+    # the "first" node address, and the "last" node address.
+    BASE_NODE_SIZE = 4 + (2 * ADDRESS_SIZE)
+
+    # Read a base node, consisting of a list length followed by two addresses
+    # (:first and :last) from a cursor. Either address may be nil. An empty list
+    # has a :length of 0 and :first and :last are nil. A list with only a single
+    # item will have a :length of 1 and :first and :last will point to the same
+    # address.
+    def self.get_base_node(cursor)
+      BaseNode.new(
+        length: cursor.name("length") { cursor.read_uint32 },
+        first: cursor.name("first") { get_address(cursor) },
+        last: cursor.name("last") { get_address(cursor) }
+      )
+    end
 
-  attr_reader :space
-  attr_reader :base
+    attr_reader :space
+    attr_reader :base
 
-  # Abstract #object_from_address method which must be implemented by
-  # sub-classes in order to return a useful object given an object address.
-  def object_from_address(address)
-    raise "#{self.class} must implement object_from_address"
-  end
+    def initialize(space, base)
+      @space = space
+      @base = base
+    end
 
-  # Return the object pointed to by the "previous" address pointer of the
-  # provided object.
-  def prev(object)
-    unless object.respond_to? :prev_address
-      raise "Class #{object.class} does not respond to prev_address"
+    # Abstract #object_from_address method which must be implemented by
+    # sub-classes in order to return a useful object given an object address.
+    def object_from_address(_address)
+      raise "#{self.class} must implement object_from_address"
     end
 
-    object_from_address(object.prev_address)
-  end
+    # Return the object pointed to by the "previous" address pointer of the
+    # provided object.
+    def prev(object)
+      raise "Class #{object.class} does not respond to prev_address" unless object.respond_to?(:prev_address)
 
-  # Return the object pointed to by the "next" address pointer of the
-  # provided object.
-  def next(object)
-    unless object.respond_to? :next_address
-      raise "Class #{object.class} does not respond to next_address"
+      object_from_address(object.prev_address)
     end
 
-    object_from_address(object.next_address)
-  end
+    # Return the object pointed to by the "next" address pointer of the
+    # provided object.
+    def next(object)
+      raise "Class #{object.class} does not respond to next_address" unless object.respond_to?(:next_address)
 
-  # Return the number of items in the list.
-  def length
-    @base[:length]
-  end
+      object_from_address(object.next_address)
+    end
 
-  # Return the first object in the list using the list base node "first"
-  # address pointer.
-  def first
-    object_from_address(@base[:first])
-  end
+    # Return the number of items in the list.
+    def length
+      @base.length
+    end
 
-  # Return the first object in the list using the list base node "last"
-  # address pointer.
-  def last
-    object_from_address(@base[:last])
-  end
+    # Return the first object in the list using the list base node "first"
+    # address pointer.
+    def first
+      object_from_address(@base.first)
+    end
 
-  # Return a list cursor for the list.
-  def list_cursor(node=:min, direction=:forward)
-    ListCursor.new(self, node, direction)
-  end
+    # Return the first object in the list using the list base node "last"
+    # address pointer.
+    def last
+      object_from_address(@base.last)
+    end
 
-  # Return whether the given item is present in the list. This depends on the
-  # item and the items in the list implementing some sufficient == method.
-  # This is implemented rather inefficiently by constructing an array and
-  # leaning on Array#include? to do the real work.
-  def include?(item)
-    each.to_a.include? item
-  end
+    # Return a list cursor for the list.
+    def list_cursor(node = :min, direction = :forward)
+      ListCursor.new(self, node, direction)
+    end
 
-  # Iterate through all nodes in the list.
-  def each
-    unless block_given?
-      return enum_for(:each)
+    # Return whether the given item is present in the list. This depends on the
+    # item and the items in the list implementing some sufficient == method.
+    # This is implemented rather inefficiently by constructing an array and
+    # leaning on Array#include? to do the real work.
+    def include?(item)
+      each.to_a.include?(item)
     end
 
-    list_cursor.each_node do |node|
-      yield node
+    # Iterate through all nodes in the list.
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      list_cursor.each_node(&block)
     end
-  end
 
-  # A list iteration cursor used primarily by the Innodb::List #cursor method
-  # implicitly. Keeps its own state for iterating through lists efficiently.
-  class ListCursor
-    def initialize(list, node=:min, direction=:forward)
-      @initial = true
-      @list = list
-      @direction = direction
-
-      case node
-      when :min
-        @node = @list.first
-      when :max
-        @node = @list.last
-      else
-        @node = node
+    # A list iteration cursor used primarily by the Innodb::List #cursor method
+    # implicitly. Keeps its own state for iterating through lists efficiently.
+    class ListCursor
+      def initialize(list, node = :min, direction = :forward)
+        @initial = true
+        @list = list
+        @direction = direction
+        @node = initial_node(node)
       end
-    end
 
-    def node
-      if @initial
-        @initial = false
-        return @node
+      def initial_node(node)
+        case node
+        when :min
+          @list.first
+        when :max
+          @list.last
+        else
+          node
+        end
       end
 
-      case @direction
-      when :forward
-        next_node
-      when :backward
-        prev_node
+      def node
+        if @initial
+          @initial = false
+          return @node
+        end
+
+        case @direction
+        when :forward
+          next_node
+        when :backward
+          prev_node
+        end
       end
-    end
 
-    # Return the previous entry from the current position, and advance the
-    # cursor position to the returned entry. If the cursor is currently nil,
-    # return the last entry in the list and adjust the cursor position to
-    # that entry.
-    def prev_node
-      if node = @list.prev(@node)
-        @node = node
+      def goto_node(node)
+        @node = node if node
       end
-    end
 
-    # Return the next entry from the current position, and advance the
-    # cursor position to the returned entry. If the cursor is currently nil,
-    # return the first entry in the list and adjust the cursor position to
-    # that entry.
-    def next_node
-      if node = @list.next(@node)
-        @node = node
+      # Return the previous entry from the current position, and advance the
+      # cursor position to the returned entry. If the cursor is currently nil,
+      # return the last entry in the list and adjust the cursor position to
+      # that entry.
+      def prev_node
+        goto_node(@list.prev(@node))
       end
-    end
 
-    def each_node
-      unless block_given?
-        return enum_for(:each_node)
+      # Return the next entry from the current position, and advance the
+      # cursor position to the returned entry. If the cursor is currently nil,
+      # return the first entry in the list and adjust the cursor position to
+      # that entry.
+      def next_node
+        goto_node(@list.next(@node))
       end
 
-      while n = node
-        yield n
+      def each_node
+        return enum_for(:each_node) unless block_given?
+
+        while (n = node)
+          yield n
+        end
       end
     end
-  end
-end
 
-# A list of extent descriptor entries. Objects returned by list methods
-# will be Innodb::Xdes objects.
-class Innodb::List::Xdes < Innodb::List
-  def object_from_address(address)
-    if address && page = @space.page(address[:page])
-      Innodb::Xdes.new(page, page.cursor(address[:offset] - 8))
+    # A list of extent descriptor entries. Objects returned by list methods
+    # will be Innodb::Xdes objects.
+    class Xdes < Innodb::List
+      def object_from_address(address)
+        return unless address
+
+        page = @space.page(address.page)
+        return unless page
+
+        Innodb::Xdes.new(page, page.cursor(address.offset - 8))
+      end
     end
-  end
-end
 
-# A list of Inode pages. Objects returned by list methods will be
-# Innodb::Page::Inode objects.
-class Innodb::List::Inode < Innodb::List
-  def object_from_address(address)
-    if address && page = @space.page(address[:page])
-      page
+    # A list of Inode pages. Objects returned by list methods will be
+    # Innodb::Page::Inode objects.
+    class Inode < Innodb::List
+      def object_from_address(address)
+        return unless address
+
+        @space.page(address.page)
+      end
     end
-  end
-end
 
-class Innodb::List::UndoPage < Innodb::List
-  def object_from_address(address)
-    if address && page = @space.page(address[:page])
-      page
+    class UndoPage < Innodb::List
+      def object_from_address(address)
+        return unless address
+
+        @space.page(address.page)
+      end
     end
-  end
-end
 
-class Innodb::List::History < Innodb::List
-  def object_from_address(address)
-    if address && page = @space.page(address[:page])
-      Innodb::UndoLog.new(page, address[:offset] - 34)
+    class History < Innodb::List
+      def object_from_address(address)
+        return unless address
+
+        page = @space.page(address.page)
+        return unless page
+
+        Innodb::UndoLog.new(page, address.offset - 34)
+      end
     end
   end
 end