innodb_ruby 0.7.11 → 0.7.12

data/lib/innodb/page/inode.rb

@@ -1,27 +1,17 @@
+# -*- encoding : utf-8 -*-
 require "innodb/list"
 
 # A specialized class for handling INODE pages, which contain index FSEG (file
 # segment) information. This allows all extents and individual pages assigned
 # to each index to be found.
 class Innodb::Page::Inode < Innodb::Page
-  # 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
-
   # Return the byte offset of the list node, which immediately follows the
   # FIL header.
   def pos_list_entry
     pos_fil_header + size_fil_header
   end
 
-  # Return the byte offset of the list node.
+  # Return the size of the list node.
   def size_list_entry
     Innodb::List::NODE_SIZE
   end
@@ -32,21 +22,16 @@ class Innodb::Page::Inode < Innodb::Page
     pos_list_entry + size_list_entry
   end
 
-  # The size (in bytes) of an Inode entry.
-  def size_inode
-    (16 + (3 * Innodb::List::BASE_NODE_SIZE) +
-      (FRAG_ARRAY_N_SLOTS * FRAG_SLOT_SIZE))
-  end
-
   # The number of Inode entries that fit on a page.
   def inodes_per_page
-    (size - pos_inode_array - 10) / size_inode
+    (size - pos_inode_array - 10) / Innodb::Inode::SIZE
   end
 
   # Return the list entry.
   def list_entry
-    c = cursor(pos_list_entry)
-    Innodb::List.get_node(c)
+    cursor(pos_list_entry).name("list") do |c|
+      Innodb::List.get_node(c)
+    end
   end
 
   # Return the "previous" address pointer from the list entry. This is used
@@ -61,40 +46,24 @@ class Innodb::Page::Inode < Innodb::Page
     list_entry[:next]
   end
 
-  # Read an array of page numbers (32-bit integers, which may be nil) from
-  # the provided cursor.
-  def page_number_array(size, cursor)
-    size.times.map { |n| Innodb::Page.maybe_undefined(cursor.get_uint32) }
-  end
-
-  # Read a single Inode entry from the provided cursor.
-  def inode(cursor)
-    {
-      :fseg_id            => cursor.get_uint64,
-      :not_full_n_used    => cursor.get_uint32,
-      :free               => Innodb::List::Xdes.new(@space,
-                              Innodb::List.get_base_node(cursor)),
-      :not_full           => Innodb::List::Xdes.new(@space,
-                              Innodb::List.get_base_node(cursor)),
-      :full               => Innodb::List::Xdes.new(@space,
-                              Innodb::List.get_base_node(cursor)),
-      :magic_n            => cursor.get_uint32,
-      :frag_array         => page_number_array(FRAG_ARRAY_N_SLOTS, cursor),
-    }
-  end
-
   # Read a single Inode entry from the provided byte offset by creating a
   # cursor and reading the inode using the inode method.
-  def inode_at(offset)
-    inode(cursor(offset))
+  def inode_at(cursor)
+    cursor.name("inode") { |c| Innodb::Inode.new_from_cursor(@space, c) }
   end
 
   # Iterate through all Inodes in the inode array.
   def each_inode
+    unless block_given?
+      return enum_for(:each_inode)
+    end
+
     inode_cursor = cursor(pos_inode_array)
-    inodes_per_page.times do
-      this_inode = inode(inode_cursor)
-      yield this_inode if this_inode[:fseg_id] != 0
+    inodes_per_page.times do |n|
+      inode_cursor.name("inode[#{n}]") do |c|
+        this_inode = Innodb::Inode.new_from_cursor(@space, c)
+        yield this_inode if this_inode.allocated?
+      end
     end
   end
 
@@ -107,11 +76,11 @@ class Innodb::Page::Inode < Innodb::Page
     puts
 
     puts "inodes:"
-    each_inode do |i|
-      pp i
+    each_inode do |inode|
+      inode.dump
     end
     puts
   end
 end
 
-Innodb::Page::SPECIALIZED_CLASSES[:INODE] = Innodb::Page::Inode
+Innodb::Page::SPECIALIZED_CLASSES[:INODE] = Innodb::Page::Inode

data/lib/innodb/page/sys.rb

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

data/lib/innodb/page/sys_data_dictionary_header.rb

@@ -0,0 +1,92 @@
+# -*- encoding : utf-8 -*-
+class Innodb::Page::SysDataDictionaryHeader < Innodb::Page
+  # The position of the data dictionary header within the page.
+  def pos_data_dictionary_header
+    pos_fil_header + size_fil_header
+  end
+
+  # The size of the data dictionary header.
+  def size_data_dictionary_header
+    ((8 * 3) + (4 * 7) + 4 + Innodb::FsegEntry::SIZE)
+  end
+
+  # Parse the data dictionary header from the page.
+  def data_dictionary_header
+    cursor(pos_data_dictionary_header).name("data_dictionary_header") do |c|
+      {
+        :max_row_id => c.name("max_row_id") { c.get_uint64 },
+        :max_table_id => c.name("max_table_id") { c.get_uint64 },
+        :max_index_id => c.name("max_index_id") { c.get_uint64 },
+        :max_space_id => c.name("max_space_id") { c.get_uint32 },
+        :unused_mix_id_low => c.name("unused_mix_id_low") { c.get_uint32 },
+        :indexes => c.name("indexes") {{
+          :SYS_TABLES => c.name("SYS_TABLES") {{
+            :PRIMARY => c.name("PRIMARY") { c.get_uint32 },
+            :ID      => c.name("ID")      { c.get_uint32 }, 
+          }},
+          :SYS_COLUMNS => c.name("SYS_COLUMNS") {{
+            :PRIMARY => c.name("PRIMARY") { c.get_uint32 },
+          }},
+          :SYS_INDEXES => c.name("SYS_INDEXES") {{
+            :PRIMARY => c.name("PRIMARY") { c.get_uint32 },
+          }},
+          :SYS_FIELDS => c.name("SYS_FIELDS") {{
+            :PRIMARY => c.name("PRIMARY") { c.get_uint32 },
+          }}
+        }},
+        :unused_space => c.name("unused_space") { c.get_bytes(4) },
+        :fseg => c.name("fseg") { Innodb::FsegEntry.get_inode(@space, c) },
+      }
+    end
+  end
+
+  # Iterate through all indexes in the data dictionary, yielding the table
+  # name, index name, and the index itself as an Innodb::Index.
+  def each_index
+    unless block_given?
+      return enum_for(:each_index)
+    end
+
+    data_dictionary_header[:indexes].each do |table_name, indexes|
+      indexes.each do |index_name, root_page_number|
+        yield table_name, index_name, @space.index(root_page_number)
+      end
+    end
+  end
+
+  def dump
+    super
+
+    puts
+    puts "data_dictionary header:"
+    pp data_dictionary_header
+  end
+
+  # A record describer for SYS_TABLES clustered records.
+  class SYS_TABLES_PRIMARY
+    def self.cursor_sendable_description(page)
+      {
+        :type => :clustered,
+        :key => [
+          ["VARCHAR(100)",      :NOT_NULL],       # NAME
+        ],
+        :row => [
+          [:BIGINT, :UNSIGNED,  :NOT_NULL],       # ID
+          [:INT,    :UNSIGNED,  :NOT_NULL],       # N_COLS
+          [:INT,    :UNSIGNED,  :NOT_NULL],       # TYPE
+          [:BIGINT, :UNSIGNED,  :NOT_NULL],       # MIX_ID
+          [:INT,    :UNSIGNED,  :NOT_NULL],       # MIX_LEN
+          ["VARCHAR(100)"],                       # CLUSTER_NAME
+          [:INT,    :UNSIGNED,  :NOT_NULL],       # SPACE
+        ]
+      }
+    end
+  end
+
+  RECORD_DESCRIBERS = {
+    :SYS_TABLES  => { :PRIMARY => SYS_TABLES_PRIMARY, :ID => nil },
+    :SYS_COLUMNS => { :PRIMARY => nil },
+    :SYS_INDEXES => { :PRIMARY => nil },
+    :SYS_FIELDS  => { :PRIMARY => nil },
+  }
+end

data/lib/innodb/page/sys_rseg_header.rb

@@ -0,0 +1,59 @@
+# -*- encoding : utf-8 -*-
+class Innodb::Page::SysRsegHeader < Innodb::Page
+  # The position of the rollback segment header within the page.
+  def pos_rseg_header
+    pos_fil_header + size_fil_header
+  end
+
+  # The size of the rollback segment header.
+  def size_rseg_header
+    4 + 4 + Innodb::List::BASE_NODE_SIZE + Innodb::FsegEntry::SIZE
+  end
+
+  def pos_undo_segment_array
+    pos_rseg_header + size_rseg_header
+  end
+
+  # Parse the rollback segment header from the page.
+  def rseg_header
+    cursor(pos_rseg_header).name("rseg_header") do |c|
+      {
+        :max_size => c.name("max_size") { c.get_uint32 },
+        :history_size => c.name("history_size") { c.get_uint32 },
+        :history_list => c.name("history_list") {
+          Innodb::List::History.new(@space, Innodb::List.get_base_node(c))
+        },
+        :fseg => c.name("fseg") { Innodb::FsegEntry.get_inode(@space, c) },
+      }
+    end
+  end
+
+  def each_undo_segment
+    unless block_given?
+      return enum_for(:each_undo_segment)
+    end
+
+    cursor(pos_undo_segment_array).name("undo_segment_array") do |c|
+      (0...1023).each do |slot|
+        page_number = c.name("slot[#{slot}]") {
+          Innodb::Page.maybe_undefined(c.get_uint32)
+        }
+        yield slot, page_number if page_number
+      end
+    end
+  end
+
+  def dump
+    super
+
+    puts
+    puts "rollback segment header:"
+    pp rseg_header
+
+    puts
+    puts "undo segment array:"
+    each_undo_segment do |slot, page_number|
+      puts "  #{slot}: #{page_number}"
+    end
+  end
+end

data/lib/innodb/page/trx_sys.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 # A specialized class for TRX_SYS pages, which contain various information
 # about the transaction system within InnoDB. Only one TRX_SYS page exists in
 # any given InnoDB installation, and it is page 5 of the system tablespace
@@ -35,14 +36,34 @@ class Innodb::Page::TrxSys < Innodb::Page
   # which helps identify whether the structure is populated or not.
   MYSQL_LOG_MAGIC_N = 873422344
 
+  def rsegs_array(cursor)
+    @rsegs_array ||= (0...256).to_a.inject([]) do |a, n|
+      cursor.name("slot[#{n}]") do |c|
+        slot = {
+          :space_id => c.name("space_id") {
+            Innodb::Page.maybe_undefined(c.get_uint32)
+          },
+          :page_number => c.name("page_number") {
+            Innodb::Page.maybe_undefined(c.get_uint32)
+          },
+        }
+        if slot[:space_id] && slot[:page_number]
+          a << slot
+        end
+      end
+      a
+    end
+  end
+
   # Read a MySQL binary log information structure from a given position.
-  def mysql_log_info(offset)
-    c = cursor(offset)
-    if c.get_uint32 == MYSQL_LOG_MAGIC_N
-      {
-        :offset => c.get_uint64,
-        :name => c.get_bytes(100),
-      }
+  def mysql_log_info(cursor, offset)
+    cursor.peek(offset) do |c|
+      if c.name("magic_n") { c.get_uint32 } == MYSQL_LOG_MAGIC_N
+        {
+          :offset => c.name("offset") { c.get_uint64 },
+          :name   => c.name("name")   { c.get_bytes(100) },
+        }
+      end
     end
   end
 
@@ -53,10 +74,10 @@ class Innodb::Page::TrxSys < Innodb::Page
   # Read a single doublewrite buffer information structure from a given cursor.
   def doublewrite_page_info(cursor)
     {
-      :magic_n => cursor.get_uint32,
+      :magic_n => cursor.name("magic_n") { cursor.get_uint32 },
       :page_number => [
-        cursor.get_uint32,
-        cursor.get_uint32,
+        cursor.name("page[0]") { cursor.get_uint32 },
+        cursor.name("page[1]") { cursor.get_uint32 },
       ],
     }
   end
@@ -66,30 +87,52 @@ class Innodb::Page::TrxSys < Innodb::Page
   DOUBLEWRITE_SPACE_ID_STORED_MAGIC_N = 1783657386
 
   # Read the overall doublewrite buffer structures
-  def doublewrite_info
-    c = cursor(pos_doublewrite_info)
-    {
-      :fseg => Innodb::FsegEntry.get_inode(@space, c),
-      :page_info => [
-        doublewrite_page_info(c),
-        doublewrite_page_info(c),
-      ],
-      :space_id_stored => c.get_uint32 == DOUBLEWRITE_SPACE_ID_STORED_MAGIC_N,
-    }
+  def doublewrite_info(cursor)
+    cursor.peek(pos_doublewrite_info) do |c_doublewrite|
+      c_doublewrite.name("doublewrite") do |c|
+        {
+          :fseg => c.name("fseg") { Innodb::FsegEntry.get_inode(@space, c) },
+          :page_info => [
+            c.name("group[0]") { doublewrite_page_info(c) },
+            c.name("group[1]") { doublewrite_page_info(c) },
+          ],
+          :space_id_stored =>
+            (c.name("space_id_stored") { c.get_uint32 } ==
+               DOUBLEWRITE_SPACE_ID_STORED_MAGIC_N),
+        }
+      end
+    end
   end
 
   # Read the TRX_SYS headers and other information.
   def trx_sys
-    c = cursor(pos_trx_sys_header)
-    @trx_sys ||= {
-      :trx_id       => c.get_uint64,
-      :fseg         => Innodb::FsegEntry.get_inode(@space, c),
-      :binary_log   => mysql_log_info(pos_mysql_binary_log_info),
-      :master_log   => mysql_log_info(pos_mysql_master_log_info),
-      :doublewrite  => doublewrite_info,
-    }
+    @trx_sys ||= cursor(pos_trx_sys_header).name("trx_sys") do |c|
+      {
+        :trx_id       => c.name("trx_id") { c.get_uint64 },
+        :fseg         => c.name("fseg") {
+          Innodb::FsegEntry.get_inode(@space, c)
+        },
+        :rsegs        => c.name("rsegs") {
+          rsegs_array(c)
+        },
+        :binary_log   => c.name("binary_log") {
+          mysql_log_info(c, pos_mysql_binary_log_info)
+        },
+        :master_log   => c.name("master_log") {
+          mysql_log_info(c, pos_mysql_master_log_info)
+        },
+        :doublewrite  => doublewrite_info(c),
+      }
+    end
   end
 
+  def trx_id;       trx_sys[:trx_id];       end
+  def fseg;         trx_sys[:fseg];         end
+  def rsegs;        trx_sys[:rsegs];        end
+  def binary_log;   trx_sys[:binary_log];   end
+  def master_log;   trx_sys[:master_log];   end
+  def doublewrite;  trx_sys[:doublewrite];  end
+
   # Dump the contents of a page for debugging purposes.
   def dump
     super
@@ -100,4 +143,4 @@ class Innodb::Page::TrxSys < Innodb::Page
   end
 end
 
-Innodb::Page::SPECIALIZED_CLASSES[:TRX_SYS] = Innodb::Page::TrxSys
+Innodb::Page::SPECIALIZED_CLASSES[:TRX_SYS] = Innodb::Page::TrxSys

data/lib/innodb/page/undo_log.rb

@@ -0,0 +1,95 @@
+# -*- encoding : utf-8 -*-
+
+class Innodb::Page::UndoLog < Innodb::Page
+  def pos_undo_page_header
+    pos_fil_header + size_fil_header
+  end
+
+  def size_undo_page_header
+    2 + 2 + 2 + Innodb::List::NODE_SIZE
+  end
+
+  def pos_undo_segment_header
+    pos_undo_page_header + size_undo_page_header
+  end
+
+  def size_undo_segment_header
+    2 + 2 + Innodb::FsegEntry::SIZE + Innodb::List::BASE_NODE_SIZE
+  end
+
+  def pos_undo_logs
+    pos_undo_segment_header + size_undo_segment_header
+  end
+
+  UNDO_PAGE_TYPES = {
+    1 => :insert,
+    2 => :update,
+  }
+
+  UNDO_SEGMENT_STATES = {
+    1 => :active,
+    2 => :cached,
+    3 => :to_free,
+    4 => :to_purge,
+    5 => :prepared,
+  }
+
+  def undo_page_header
+    @undo_page_header ||=
+      cursor(pos_undo_page_header).name("undo_page_header") do |c|
+      {
+        :type => c.name("type") { UNDO_PAGE_TYPES[c.get_uint16] },
+        :latest_log_record_offset => c.name("latest_log_record_offset") { c.get_uint16 },
+        :free_offset => c.name("free_offset") { c.get_uint16 },
+        :page_list_node => c.name("page_list") { Innodb::List.get_node(c) },
+      }
+    end
+  end
+
+  def prev_address
+    undo_page_header[:page_list_node][:prev]
+  end
+
+  def next_address
+    undo_page_header[:page_list_node][:next]
+  end
+
+  def undo_segment_header
+    @undo_segment_header ||=
+      cursor(pos_undo_segment_header).name("undo_segment_header") do |c|
+      {
+        :state => c.name("state") { UNDO_SEGMENT_STATES[c.get_uint16] },
+        :last_log_offset => c.name("last_log_offset") { c.get_uint16 },
+        :fseg => c.name("fseg") { Innodb::FsegEntry.get_inode(@space, c) },
+        :page_list => c.name("page_list") {
+          Innodb::List::UndoPage.new(@space, Innodb::List.get_base_node(c))
+        },
+      }
+    end
+  end
+
+  def undo_log(pos)
+    Innodb::UndoLog.new(self, pos)
+  end
+
+  # Dump the contents of a page for debugging purposes.
+  def dump
+    super
+
+    puts "undo page header:"
+    pp undo_page_header
+    puts
+
+    puts "undo segment header:"
+    pp undo_segment_header
+    puts
+
+    puts "last undo log:"
+    if undo_segment_header[:last_log_offset] != 0
+      undo_log(undo_segment_header[:last_log_offset]).dump
+    end
+    puts
+  end
+end
+
+Innodb::Page::SPECIALIZED_CLASSES[:UNDO_LOG] = Innodb::Page::UndoLog