innodb_ruby 0.9.16 → 0.11.0

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