innodb_ruby 0.9.0 → 0.9.5

data/lib/innodb/page/inode.rb

@@ -28,6 +28,10 @@ class Innodb::Page::Inode < Innodb::Page
     (size - pos_inode_array - 10) / Innodb::Inode::SIZE
   end
 
+  def size_inode_array
+    inodes_per_page * Innodb::Inode::SIZE
+  end
+
   # Return the list entry.
   def list_entry
     cursor(pos_list_entry).name("list") do |c|
@@ -50,7 +54,7 @@ class Innodb::Page::Inode < Innodb::Page
   # 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(cursor)
-    cursor.name("inode") { |c| Innodb::Inode.new_from_cursor(@space, c) }
+    cursor.name("inode[#{cursor.position}]") { |c| Innodb::Inode.new_from_cursor(@space, c) }
   end
 
   # Iterate through all Inodes in the inode array.
@@ -68,6 +72,34 @@ class Innodb::Page::Inode < Innodb::Page
     end
   end
 
+  def each_region
+    unless block_given?
+      return enum_for(:each_region)
+    end
+
+    super do |region|
+      yield region
+    end
+
+    yield({
+      :offset => pos_list_entry,
+      :length => size_list_entry,
+      :name => :list_entry,
+      :info => "Inode List Entry",
+    })
+
+    each_inode do |inode|
+      yield({
+        :offset => inode.offset,
+        :length => Innodb::Inode::SIZE,
+        :name => :inode,
+        :info => "Inode",
+      })
+    end
+
+    nil
+  end
+
   # Dump the contents of a page for debugging purposes.
   def dump
     super

data/lib/innodb/page/sys_data_dictionary_header.rb

@@ -41,6 +41,25 @@ class Innodb::Page::SysDataDictionaryHeader < Innodb::Page
     end
   end
 
+  def each_region
+    unless block_given?
+      return enum_for(:each_region)
+    end
+
+    super do |region|
+      yield region
+    end
+
+    yield({
+      :offset => pos_data_dictionary_header,
+      :length => size_data_dictionary_header,
+      :name => :data_dictionary_header,
+      :info => "Data Dictionary Header",
+    })
+
+    nil
+  end
+
   def dump
     super
 

data/lib/innodb/page/sys_rseg_header.rb

@@ -1,6 +1,9 @@
 # -*- encoding : utf-8 -*-
 
 class Innodb::Page::SysRsegHeader < Innodb::Page
+  # The number of undo log slots in the page.
+  UNDO_SEGMENT_SLOTS = 1024
+
   # The position of the rollback segment header within the page.
   def pos_rseg_header
     pos_fil_header + size_fil_header
@@ -15,6 +18,10 @@ class Innodb::Page::SysRsegHeader < Innodb::Page
     pos_rseg_header + size_rseg_header
   end
 
+  def size_undo_segment_slot
+    4
+  end
+
   # Parse the rollback segment header from the page.
   def rseg_header
     cursor(pos_rseg_header).name("rseg_header") do |c|
@@ -29,21 +36,53 @@ class Innodb::Page::SysRsegHeader < Innodb::Page
     end
   end
 
+  def history_list
+    Innodb::HistoryList.new(rseg_header[:history_list])
+  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|
+      (0...UNDO_SEGMENT_SLOTS).each do |slot|
         page_number = c.name("slot[#{slot}]") {
           Innodb::Page.maybe_undefined(c.get_uint32)
         }
-        yield slot, page_number if page_number
+        yield slot, page_number
       end
     end
   end
 
+  def each_region
+    unless block_given?
+      return enum_for(:each_region)
+    end
+
+    super do |region|
+      yield region
+    end
+
+    yield({
+      :offset => pos_rseg_header,
+      :length => size_rseg_header,
+      :name => :rseg_header,
+      :info => "Rollback Segment Header",
+    })
+
+    (0...UNDO_SEGMENT_SLOTS).each do |slot|
+      yield({
+        :offset => pos_undo_segment_array + (slot * size_undo_segment_slot),
+        :length => size_undo_segment_slot,
+        :name => :undo_segment_slot,
+        :info => "Undo Segment Slot",
+      })
+    end
+
+    nil
+  end
+
   def dump
     super
 

data/lib/innodb/page/trx_sys.rb

@@ -15,6 +15,18 @@ class Innodb::Page::TrxSys < Innodb::Page
     pos_fil_header + size_fil_header
   end
 
+  def size_trx_sys_header
+    8 + Innodb::FsegEntry::SIZE
+  end
+
+  def pos_rsegs_array
+    pos_trx_sys_header + size_trx_sys_header
+  end
+
+  def size_mysql_log_info
+    4 + 8 + 100
+  end
+
   # The master's binary log information is located 2000 bytes from the end of
   # the page.
   def pos_mysql_master_log_info
@@ -33,14 +45,21 @@ class Innodb::Page::TrxSys < Innodb::Page
     size - 200
   end
 
+  def size_doublewrite_info
+    Innodb::FsegEntry::SIZE + (2 * (4 + 4 + 4)) + 4
+  end
+
   # A magic number present in each MySQL binary log information structure,
   # which helps identify whether the structure is populated or not.
   MYSQL_LOG_MAGIC_N = 873422344
 
+  N_RSEGS = 128
+
   def rsegs_array(cursor)
-    @rsegs_array ||= (0...256).to_a.inject([]) do |a, n|
+    @rsegs_array ||= (0...N_RSEGS).to_a.inject([]) do |a, n|
       cursor.name("slot[#{n}]") do |c|
         slot = {
+          :offset => c.position,
           :space_id => c.name("space_id") {
             Innodb::Page.maybe_undefined(c.get_uint32)
           },
@@ -134,6 +153,55 @@ class Innodb::Page::TrxSys < Innodb::Page
   def master_log;   trx_sys[:master_log];   end
   def doublewrite;  trx_sys[:doublewrite];  end
 
+  def each_region
+    unless block_given?
+      return enum_for(:each_region)
+    end
+
+    super do |region|
+      yield region
+    end
+
+    yield({
+      :offset => pos_trx_sys_header,
+      :length => size_trx_sys_header,
+      :name => :trx_sys_header,
+      :info => "Transaction System Header",
+    })
+
+    rsegs.each do |rseg|
+      yield({
+        :offset => rseg[:offset],
+        :length => 4 + 4,
+        :name => :rseg,
+        :info => "Rollback Segment",
+      })
+    end
+
+    yield({
+      :offset => pos_mysql_binary_log_info,
+      :length => size_mysql_log_info,
+      :name => :mysql_binary_log_info,
+      :info => "Binary Log Info",
+    })
+
+    yield({
+      :offset => pos_mysql_master_log_info,
+      :length => size_mysql_log_info,
+      :name => :mysql_master_log_info,
+      :info => "Master Log Info",
+    })
+
+    yield({
+      :offset => pos_doublewrite_info,
+      :length => size_doublewrite_info,
+      :name => :doublewrite_info,
+      :info => "Double Write Buffer Info",
+    })
+
+    nil
+  end
+
   # Dump the contents of a page for debugging purposes.
   def dump
     super

data/lib/innodb/record.rb

@@ -17,6 +17,10 @@ class Innodb::Record
     record[:offset]
   end
 
+  def length
+    record[:length]
+  end
+
   def next
     record[:next]
   end
@@ -37,6 +41,39 @@ class Innodb::Record
     row && row.map { |r| "%s=%s" % [r[:name], r[:value].inspect] }.join(", ")
   end
 
+  def transaction_id
+    record[:transaction_id]
+  end
+
+  def roll_pointer
+    record[:roll_pointer]
+  end
+
+  def undo
+    if innodb_system = @page.space.innodb_system
+      undo_space = innodb_system.system_space
+      if undo_page = undo_space.page(roll_pointer[:undo_log][:page])
+        new_undo_record = Innodb::UndoRecord.new(undo_page, roll_pointer[:undo_log][:offset])
+        new_undo_record.index_page = page
+        new_undo_record
+      end
+    end
+  end
+
+  def each_undo_record
+    unless block_given?
+      return enum_for(:each_undo_record)
+    end
+
+    undo_record = undo
+    while undo_record
+      yield undo_record
+      undo_record = undo_record.prev_by_history
+    end
+
+    nil
+  end
+
   def child_page_number
     record[:child_page_number]
   end

data/lib/innodb/space.rb

@@ -54,6 +54,29 @@ class Innodb::Space
   # The number of pages in the space.
   attr_reader :pages
 
+  # Return a string which can uniquely identify this space. Be careful not
+  # to do anything which could instantiate a BufferCursor so that we can use
+  # this method in cursor initialization.
+  def name
+    return @name if @name
+
+    prefix = ""
+    if File.extname(@file.path) == ".ibd"
+      prefix = File.basename(File.dirname(@file.path)) + "/"
+    end
+
+    @name = prefix + File.basename(@file.path)
+  end
+
+  def inspect
+    "<%s file=%s, page_size=%i, pages=%i>" % [
+      self.class.name,
+      name.inspect,
+      page_size,
+      pages,
+    ]
+  end
+
   # Read the FSP header "flags" field by byte offset within the space file.
   # This is useful in order to initialize the page size, as we can't properly
   # read the FSP_HDR page before we know its size.
@@ -190,10 +213,11 @@ class Innodb::Space
 
   def rseg_page?(page_number)
     if trx_sys
-      trx_sys.rsegs.include?({
-        :space_id => 0,
-        :page_number => page_number,
-      })
+      rseg_match = trx_sys.rsegs.select { |rseg|
+        rseg[:space_id] == 0 && rseg[:page_number] == page_number
+      }
+
+      ! rseg_match.empty?
     end
   end
 

data/lib/innodb/system.rb

@@ -165,4 +165,8 @@ class Innodb::System
 
     index
   end
+
+  def history
+    Innodb::History.new(self)
+  end
 end

data/lib/innodb/undo_log.rb

@@ -16,24 +16,24 @@ class Innodb::UndoLog
     8 + 8 + 2 + 2 + 1 + 1 + 8 + 2 + 2 + Innodb::List::NODE_SIZE + size_xa_header
   end
 
-  def read_header(cursor)
-    cursor.name("header") do |c|
-      xid_exists = nil
+  def header
+    @header ||= page.cursor(@position).name("header") do |c|
+      xid_flag = nil
       {
         :trx_id => c.name("trx_id") { c.get_hex(8) },
-        :trx_no => c.name("trx_no") { c.get_uint64 },
-        :delete_marks => c.name("delete_marks") { (c.get_uint16 != 0) },
-        :log_start => c.name("log_start") { c.get_uint16 },
-        :xid_exists => c.name("xid_exists") { xid_exists = (c.get_uint8 != 0) },
-        :dict_trans => c.name("dict_trans") { (c.get_uint8 != 0) },
-        :table_id => c.name("table_id") { c.get_uint64 },
-        :next_log => c.name("next_log") { c.get_uint16 },
-        :prev_log => c.name("prev_log") { c.get_uint16 },
+        :trx_no => c.name("trx_no") { c.get_hex(8) },
+        :delete_mark_flag => c.name("delete_mark_flag") { (c.get_uint16 != 0) },
+        :log_start_offset => c.name("log_start_offset") { c.get_uint16 },
+        :xid_flag => c.name("xid_flag") { xid_flag = (c.get_uint8 != 0) },
+        :ddl_flag => c.name("ddl_flag") { (c.get_uint8 != 0) },
+        :ddl_table_id => c.name("ddl_table_id") { c.get_uint64 },
+        :next_log_offset => c.name("next_log_offset") { c.get_uint16 },
+        :prev_log_offset => c.name("prev_log_offset") { c.get_uint16 },
         :history_list_node => c.name("history_list_node") {
           Innodb::List.get_node(c)
         },
         :xid => c.name("xid") {
-          if xid_exists
+          if xid_flag
             {
               :format => c.name("format") { c.get_uint32 },
               :trid_len => c.name("trid_len") { c.get_uint32 },
@@ -46,18 +46,6 @@ class Innodb::UndoLog
     end
   end
 
-  def undo_log
-    @undo_log ||= page.cursor(position).name("undo_log") do |c|
-      {
-        :header => read_header(c),
-      }
-    end
-  end
-
-  def header
-    undo_log[:header]
-  end
-
   def prev_address
     header[:history_list_node][:prev]
   end
@@ -66,6 +54,78 @@ class Innodb::UndoLog
     header[:history_list_node][:next]
   end
 
+  def undo_record(offset)
+    new_undo_record = Innodb::UndoRecord.new(page, offset)
+    new_undo_record.undo_log = self
+    new_undo_record
+  end
+
+  def min_undo_record
+    undo_record(header[:log_start_offset])
+  end
+
+  class UndoRecordCursor
+    def initialize(undo_log, offset, direction=:forward)
+      @initial = true
+      @undo_log = undo_log
+      @offset = offset
+      @direction = direction
+
+      case offset
+      when :min
+        @undo_record = @undo_log.min_undo_record
+      when :max
+        raise "Not implemented"
+      else
+        @undo_record = @undo_log.undo_record(offset)
+      end
+    end
+
+    def next_undo_record
+      if rec = @undo_record.next
+        @undo_record = rec
+      end
+    end
+
+    def prev_undo_record
+      if rec = @undo_record.prev
+        @undo_record = rec
+      end
+    end
+
+    def undo_record
+      if @initial
+        @initial = false
+        return @undo_record
+      end
+
+      case @direction
+      when :forward
+        next_undo_record
+      when :backward
+        prev_undo_record
+      end
+    end
+
+    def each_undo_record
+      unless block_given?
+        return enum_for(:each_undo_record)
+      end
+
+      while rec = undo_record
+        yield rec
+      end
+    end
+  end
+
+  def undo_record_cursor(offset, direction=:forward)
+    UndoRecordCursor.new(self, offset, direction)
+  end
+
+  def first_undo_record_cursor
+    undo_record_cursor(header[:log_start_offset])
+  end
+
   def dump
     puts "header:"
     pp header