innodb_ruby 0.9.0 → 0.9.5

data/lib/innodb/inode.rb

@@ -29,6 +29,7 @@ class Innodb::Inode
   # 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
       },
@@ -62,6 +63,7 @@ class Innodb::Inode
     @data = data
   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
@@ -70,6 +72,14 @@ class Innodb::Inode
   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
+
   # Helper method to determine if an Inode is in use. Inodes that are not in
   # use have an fseg_id of 0.
   def allocated?
@@ -124,7 +134,7 @@ class Innodb::Inode
 
   # Compare one Innodb::Inode to another.
   def ==(other)
-    fseg_id == other.fseg_id
+    fseg_id == other.fseg_id if other
   end
 
   # Dump a summary of this object for debugging purposes.

data/lib/innodb/list.rb

@@ -109,8 +109,8 @@ class Innodb::List
   end
 
   # Return a list cursor for the list.
-  def list_cursor(node=nil)
-    ListCursor.new(self, node)
+  def list_cursor(node=:min, direction=:forward)
+    ListCursor.new(self, node, direction)
   end
 
   # Return whether the given item is present in the list. This depends on the
@@ -127,36 +127,50 @@ class Innodb::List
       return enum_for(:each)
     end
 
-    c = list_cursor
-    while e = c.next
-      yield e
+    list_cursor.each_node do |node|
+      yield node
     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=nil)
-      @list   = list
-      @cursor = node
+    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
+      end
     end
 
-    # Reset the list cursor to its default starting state, which will allow
-    # iteration forwards from the first entry (using #next) or backwards
-    # from the last entry (using #prev).
-    def reset
-      @cursor = nil
+    def node
+      if @initial
+        @initial = false
+        return @node
+      end
+
+      case @direction
+      when :forward
+        next_node
+      when :backward
+        prev_node
+      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
-      if @cursor
-        @cursor = @list.prev(@cursor)
-      else
-        @cursor = @list.last
+    def prev_node
+      if node = @list.prev(@node)
+        @node = node
       end
     end
 
@@ -164,11 +178,19 @@ class Innodb::List
     # 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
-      if @cursor
-        @cursor = @list.next(@cursor)
-      else
-        @cursor = @list.first
+    def next_node
+      if node = @list.next(@node)
+        @node = node
+      end
+    end
+
+    def each_node
+      unless block_given?
+        return enum_for(:each_node)
+      end
+
+      while n = node
+        yield n
       end
     end
   end

data/lib/innodb/log.rb

@@ -1,7 +1,6 @@
 # -*- encoding : utf-8 -*-
 
 # An InnoDB transaction log file.
-
 class Innodb::Log
   # A map of the name and position of the blocks that form the log header.
   LOG_HEADER_BLOCK_MAP = {
@@ -14,32 +13,39 @@ class Innodb::Log
   # Number of blocks in the log file header.
   LOG_HEADER_BLOCKS = LOG_HEADER_BLOCK_MAP.size
 
+  # The size in bytes of the log file header.
+  LOG_HEADER_SIZE = LOG_HEADER_BLOCKS * Innodb::LogBlock::BLOCK_SIZE
+
   # Maximum number of log group checkpoints.
   LOG_CHECKPOINT_GROUPS = 32
 
   # Open a log file.
-  def initialize(file)
-    @file = File.open(file)
+  def initialize(filename)
+    @file = File.open(filename)
     @size = @file.stat.size
     @blocks = (@size / Innodb::LogBlock::BLOCK_SIZE) - LOG_HEADER_BLOCKS
+    @capacity = @blocks * Innodb::LogBlock::BLOCK_SIZE
   end
 
   # The size (in bytes) of the log.
   attr_reader :size
 
-  # The number of blocks in the the log.
+  # The log capacity (in bytes).
+  attr_reader :capacity
+
+  # The number of blocks in the log.
   attr_reader :blocks
 
   # Get the raw byte buffer for a specific block by block offset.
   def block_data(offset)
     raise "Invalid block offset" unless (offset % Innodb::LogBlock::BLOCK_SIZE).zero?
-    @file.seek(offset)
-    @file.read(Innodb::LogBlock::BLOCK_SIZE)
+    @file.sysseek(offset)
+    @file.sysread(Innodb::LogBlock::BLOCK_SIZE)
   end
 
   # Get a cursor to a block in a given offset of the log.
   def block_cursor(offset)
-    Innodb::Cursor.new(block_data(offset), 0)
+    BufferCursor.new(block_data(offset), 0)
   end
 
   # Return the log header.
@@ -49,7 +55,8 @@ class Innodb::Log
       {
         :group_id   => c.name("group_id")   { c.get_uint32 },
         :start_lsn  => c.name("start_lsn")  { c.get_uint64 },
-        :created_by => c.name("created_by") { c.seek(16).get_bytes(4) }
+        :file_no    => c.name("file_no")    { c.get_uint32 },
+        :created_by => c.name("created_by") { c.get_string(32) }
       }
     end
   end
@@ -62,7 +69,7 @@ class Innodb::Log
     {
       :number         => c.name("number")       { c.get_uint64 },
       :lsn            => c.name("lsn")          { c.get_uint64 },
-      :offset         => c.name("offset")       { c.get_uint32 },
+      :lsn_offset     => c.name("lsn_offset")   { c.get_uint32 },
       :buffer_size    => c.name("buffer_size")  { c.get_uint32 },
       :archived_lsn   => c.name("archived_lsn") { c.get_uint64 },
       :group_array    =>
@@ -88,10 +95,14 @@ class Innodb::Log
     @checkpoint ||=
       {
         :checkpoint_1 => block_cursor(offset1).name("checkpoint_1") do |cursor|
-          read_checkpoint(cursor)
+          cp = read_checkpoint(cursor)
+          cp.delete(:group_array)
+          cp
         end,
         :checkpoint_2 => block_cursor(offset2).name("checkpoint_2") do |cursor|
-          read_checkpoint(cursor)
+          cp = read_checkpoint(cursor)
+          cp.delete(:group_array)
+          cp
         end
       }
   end

data/lib/innodb/log_block.rb

@@ -1,8 +1,5 @@
 # -*- encoding : utf-8 -*-
 
-require "innodb/cursor"
-require "pp"
-
 # An InnoDB transaction log block.
 class Innodb::LogBlock
   # Log blocks are fixed-length at 512 bytes in InnoDB.
@@ -11,9 +8,21 @@ class Innodb::LogBlock
   # Offset of the header within the log block.
   HEADER_OFFSET = 0
 
+  # The size of the block header.
+  HEADER_SIZE = 4 + 2 + 2 + 4
+
   # Offset of the trailer within ths log block.
   TRAILER_OFFSET = BLOCK_SIZE - 4
 
+  # The size of the block trailer.
+  TRAILER_SIZE = 4
+
+  # Offset of the start of data in the block.
+  DATA_OFFSET = HEADER_SIZE
+
+  # Size of the space available for log records.
+  DATA_SIZE = BLOCK_SIZE - HEADER_SIZE - TRAILER_SIZE
+
   # Mask used to get the flush bit in the header.
   HEADER_FLUSH_BIT_MASK = 0x80000000
 
@@ -21,15 +30,15 @@ class Innodb::LogBlock
   # log block contents.
   def initialize(buffer)
     unless buffer.size == BLOCK_SIZE
-      raise "Log block buffer provided was not #{BLOCK_SIZE} bytes" 
+      raise "Log block buffer provided was not #{BLOCK_SIZE} bytes"
     end
 
     @buffer = buffer
   end
 
-  # Return an Innodb::Cursor object positioned at a specific offset.
+  # Return an BufferCursor object positioned at a specific offset.
   def cursor(offset)
-    Innodb::Cursor.new(@buffer, offset)
+    BufferCursor.new(@buffer, offset)
   end
 
   # Return the log block header.
@@ -49,6 +58,22 @@ class Innodb::LogBlock
     end
   end
 
+  # Return a slice of actual block data (that is, excluding header and
+  # trailer) starting at the given offset.
+  def data(offset = DATA_OFFSET)
+    length = header[:data_length]
+
+    if length == BLOCK_SIZE
+      length -= TRAILER_SIZE
+    end
+
+    if offset < DATA_OFFSET || offset > length
+      raise "Invalid block data offset"
+    end
+
+    @buffer.slice(offset, length - offset)
+  end
+
   # Return the log block trailer.
   def trailer
     @trailer ||= cursor(TRAILER_OFFSET).name("trailer") do |c|
@@ -58,79 +83,28 @@ class Innodb::LogBlock
     end
   end
 
-  # The constants used by InnoDB for identifying different log record types.
-  RECORD_TYPES = {
-    1  => :MLOG_1BYTE,
-    2  => :MLOG_2BYTE,
-    4  => :MLOG_4BYTE,
-    8  => :MLOG_8BYTE,
-    9  => :REC_INSERT,
-    10 => :REC_CLUST_DELETE_MARK,
-    11 => :REC_SEC_DELETE_MARK,
-    13 => :REC_UPDATE_IN_PLACE,
-    14 => :REC_DELETE,
-    15 => :LIST_END_DELETE,
-    16 => :LIST_START_DELETE,
-    17 => :LIST_END_COPY_CREATED,
-    18 => :PAGE_REORGANIZE,
-    19 => :PAGE_CREATE,
-    20 => :UNDO_INSERT,
-    21 => :UNDO_ERASE_END,
-    22 => :UNDO_INIT,
-    23 => :UNDO_HDR_DISCARD,
-    24 => :UNDO_HDR_REUSE,
-    25 => :UNDO_HDR_CREATE,
-    26 => :REC_MIN_MARK,
-    27 => :IBUF_BITMAP_INIT,
-    28 => :LSN,
-    29 => :INIT_FILE_PAGE,
-    30 => :WRITE_STRING,
-    31 => :MULTI_REC_END,
-    32 => :DUMMY_RECORD,
-    33 => :FILE_CREATE,
-    34 => :FILE_RENAME,
-    35 => :FILE_DELETE,
-    36 => :COMP_REC_MIN_MARK,
-    37 => :COMP_PAGE_CREATE,
-    38 => :COMP_REC_INSERT,
-    39 => :COMP_REC_CLUST_DELETE_MARK,
-    40 => :COMP_REC_SEC_DELETE_MARK,
-    41 => :COMP_REC_UPDATE_IN_PLACE,
-    42 => :COMP_REC_DELETE,
-    43 => :COMP_LIST_END_DELETE,
-    44 => :COMP_LIST_START_DELETE,
-    45 => :COMP_LIST_END_COPY_CREATE,
-    46 => :COMP_PAGE_REORGANIZE,
-    47 => :FILE_CREATE2,
-    48 => :ZIP_WRITE_NODE_PTR,
-    49 => :ZIP_WRITE_BLOB_PTR,
-    50 => :ZIP_WRITE_HEADER,
-    51 => :ZIP_PAGE_COMPRESS,
-  }
-
-  SINGLE_RECORD_MASK = 0x80
-  RECORD_TYPE_MASK   = 0x7f
-
-  # Return a preamble of the first record in this block.
-  def first_record_preamble
-    return nil unless header[:first_rec_group] > 0
-    cursor(header[:first_rec_group]).name("header") do |c|
-      type_and_flag = c.name("type") { c.get_uint8 }
-      type = type_and_flag & RECORD_TYPE_MASK
-      type = RECORD_TYPES[type] || type
-      single_record = (type_and_flag & SINGLE_RECORD_MASK) > 0
-      case type
-      when :MULTI_REC_END, :DUMMY_RECORD
-        { :type => type }
-      else
-        {
-          :type           => type,
-          :single_record  => single_record,
-          :space          => c.name("space") { c.get_ic_uint32 },
-          :page_number    => c.name("page_number") { c.get_ic_uint32 },
-        }
-      end
+  # A helper function to return the checksum from the trailer, for
+  # easier access.
+  def checksum
+    trailer[:checksum]
+  end
+
+  # Calculate the checksum of the block using InnoDB's log block
+  # checksum algorithm.
+  def calculate_checksum
+    cksum = 1
+    shift = (0..24).cycle
+    cursor(0).each_byte_as_uint8(TRAILER_OFFSET) do |b|
+      cksum &= 0x7fffffff
+      cksum += b + (b << shift.next)
     end
+    cksum
+  end
+
+  # Is the block corrupt? Calculate the checksum of the block and compare to
+  # the stored checksum; return true or false.
+  def corrupt?
+    checksum != calculate_checksum
   end
 
   # Dump the contents of a log block for debugging purposes.
@@ -142,9 +116,5 @@ class Innodb::LogBlock
     puts
     puts "trailer:"
     pp trailer
-
-    puts
-    puts "record:"
-    pp first_record_preamble
   end
 end

data/lib/innodb/log_group.rb

@@ -1,79 +1,84 @@
 # -*- encoding : utf-8 -*-
 
+# Group of InnoDB logs files that make up the redo log.
 class Innodb::LogGroup
-  def initialize
-    @files = []
+
+  # Initialize group given a set of sorted log files.
+  def initialize(log_files)
+    @logs = log_files.map { |fn| Innodb::Log.new(fn) }
+    sizes = @logs.map { |log| log.size }
+    raise "Log file sizes do not match" unless sizes.uniq.size == 1
   end
 
-  def add_log(file)
-    if file = Innodb::Log.new(file)
-      @files.push file
-    else
-      raise "Couldn't open #{file}"
+  # Iterate through all logs.
+  def each_log
+    unless block_given?
+      return enum_for(:each_log)
+    end
+
+    @logs.each do |log|
+      yield log
     end
   end
 
+  # Iterate through all blocks.
   def each_block
-    @files.each do |file|
-      file.each_block do |block_number, block|
-        yield block_number, block
+    unless block_given?
+      return enum_for(:each_block)
+    end
+
+    each_log do |log|
+      log.each_block do |block_index, block|
+        yield block_index, block
       end
     end
   end
 
-  def current_tail_position
-    max       = 0
-    max_file  = nil
-    max_block = nil
+  # The number of log files in the group.
+  def logs
+    @logs.count
+  end
 
-    @files.each_with_index do |file, file_number|
-      file.each_block do |block_number, block|
-        if block.header[:block] > max
-          max   = block.header[:block]
-          max_file  = file_number
-          max_block = block_number
-        end
-      end
-    end
+  # Returns the log at the given position in the log group.
+  def log(log_no)
+    @logs.at(log_no)
+  end
 
-    { :file => max_file, :block => max_block }
+  # The size in byes of each and every log in the group.
+  def log_size
+    @logs.first.size
   end
 
-  def successor_position(position)
-    if position[:block] == @files[position[:file]].blocks
-      if position[:file] == @files.size
-        { :file => 0, :block => 0 }
-      else
-        { :file => position[:file] + 1, :block => 0 }
-      end
-    else
-      { :file => position[:file], :block => position[:block] + 1 }
-    end
+  # The size of the log group (in bytes)
+  def size
+    @logs.first.size * @logs.count
   end
 
-  def block(file_number, block_number)
-    @files[file_number].block(block_number)
+  # The log group capacity (in bytes).
+  def capacity
+    @logs.first.capacity * @logs.count
   end
 
-  def block_if_newer(old_block, new_block)
-    return new_block if old_block.nil?
-    #puts "old: #{old_block.header[:block]} new: #{new_block.header[:block]}"
-    if new_block.header[:block] >= old_block.header[:block]
-      new_block
-    end
+  # Returns the LSN coordinates of the data at the start of the log group.
+  def start_lsn
+    [@logs.first.header[:start_lsn], Innodb::Log::LOG_HEADER_SIZE]
   end
 
-  def tail_blocks
-    position = current_tail_position
-    current_block = nil
-    while true
-      until block_if_newer(current_block, new_block = block(position[:file], position[:block]))
-        #puts "Waiting at the tail: #{position[:file]} #{position[:block]}"
-        sleep 0.1
-      end
-      yield new_block
-      position = successor_position(position)
-      current_block = new_block
-    end
+  # Returns the LSN coordinates of the most recent (highest) checkpoint.
+  def max_checkpoint_lsn
+    checkpoint = @logs.first.checkpoint.max_by{|f,v| v[:number]}.last
+    checkpoint.values_at(:lsn, :lsn_offset)
+  end
+
+  # Returns a LogReader using the given LSN reference coordinates.
+  def reader(lsn_coord = start_lsn)
+    lsn_no, lsn_offset = lsn_coord
+    lsn = Innodb::LSN.new(lsn_no, lsn_offset)
+    Innodb::LogReader.new(lsn, self)
+  end
+
+  # Parse and return a record at a given LSN.
+  def record(lsn_no)
+    reader.seek(lsn_no).record
   end
 end