innodb_ruby 0.4

data/bin/innodb_dump_log

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require "innodb"
+
+filename, block_number = ARGV.shift(2)
+
+log = Innodb::Log.new(filename)
+
+puts "%-10s%-20s%-10s%-10s" % [
+  "block",
+  "type",
+  "space",
+  "page",
+]
+log.each_block do |block_number, block|
+  if block.record
+    puts "%-10i%-20s%-10i%-10i" % [
+      block_number,
+      block.record[:type],
+      block.record[:space],
+      block.record[:page_number],
+    ]
+    #block.dump
+  end
+end

data/bin/innodb_dump_space

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require "pp"
+require "innodb"
+
+file, page_number = ARGV.shift(2)
+
+space = Innodb::Space.new(file)
+#space.page(page_number).dump
+#exit
+
+page_types = Hash.new(0)
+page_levels = Hash.new(0)
+records_per_level = {}
+puts "%-8s%-8s%-8s%-8s" % ["page", "index", "level", "data"]
+space.each_page do |page_number, page|
+  page_types[page.type] += 1
+  if page.type == :INDEX
+    puts "%-8i%-8i%-8i%-8i" % [
+      page_number,
+      page.ph[:index_id],
+      page.ph[:level],
+      page.record_space,
+    ]
+    #page_levels[page.ph[:index_id]] ||= Hash.new(0)
+    #page_levels[page.ph[:index_id]][page.ph[:level]] += 1
+    #records_per_level[page.ph[:level]] ||= Hash.new(0)
+    #records_per_level[page.ph[:level]][page.ph[:n_recs]] += 1
+  end
+  if page.type == :ALLOCATED
+    puts "%-8i%-8i%-8i%-8i" % [ page_number, 0, 0, 0 ]
+  end
+end

data/lib/innodb.rb

@@ -0,0 +1,8 @@
+# A set of classes for parsing and working with InnoDB data files.
+module Innodb; end
+
+require "innodb/version"
+require "innodb/page"
+require "innodb/space"
+require "innodb/log_block"
+require "innodb/log"

data/lib/innodb/cursor.rb

@@ -0,0 +1,148 @@
+# A cursor to walk through InnoDB data structures to read fields.
+class Innodb::Cursor
+  def initialize(buffer, offset)
+    @buffer = buffer
+    @cursor = [ offset ]
+    @direction = :forward
+  end
+
+  # Set the direction of the cursor to "forward".
+  def forward
+    @direction = :forward
+    self
+  end
+
+  # Set the direction of the cursor to "backward".
+  def backward
+    @direction = :backward
+    self
+  end
+
+  # Return the position of the current cursor.
+  def position
+    @cursor[0]
+  end
+
+  # Move the current cursor to a new absolute position.
+  def seek(offset)
+    @cursor[0] = offset if offset
+    self
+  end
+
+  # Adjust the current cursor to a new relative position.
+  def adjust(relative_offset)
+    @cursor[0] += relative_offset
+    self
+  end
+
+  # Save the current cursor position and start a new (nested, stacked) cursor.
+  def push(offset=nil)
+    @cursor.unshift(offset.nil? ? @cursor[0] : offset)
+    self
+  end
+
+  # Restore the last cursor position.
+  def pop
+    raise "No cursors to pop" unless @cursor.size > 1
+    @cursor.shift
+    self
+  end
+
+  # Execute a block and restore the cursor to the previous position after
+  # the block returns. Return the block's return value after restoring the
+  # cursor.
+  def peek
+    raise "No block given" unless block_given?
+    push
+    result = yield
+    pop
+    result
+  end
+
+  # Read a number of bytes forwards or backwards from the current cursor
+  # position and adjust the cursor position by that amount, optionally
+  # unpacking the data using the provided type.
+  def read_and_advance(length, type=nil)
+    data = nil
+    #print "data(#{@cursor[0]}..."
+    case @direction
+    when :forward
+      data = @buffer.data(@cursor[0], length)
+      adjust(length)
+    when :backward
+      adjust(-length)
+      data = @buffer.data(@cursor[0], length)
+    end
+    #puts "#{@cursor[0]}) = #{data.bytes.map { |n| "%02x" % n }.join}"
+    type ? data.unpack(type).first : data
+  end
+
+  # Return raw bytes.
+  def get_bytes(length)
+    read_and_advance(length)
+  end
+
+  # Return a big-endian unsigned 8-bit integer.
+  def get_uint8(offset=nil)
+    seek(offset)
+    read_and_advance(1, "C")
+  end
+
+  # Return a big-endian unsigned 16-bit integer.
+  def get_uint16(offset=nil)
+    seek(offset)
+    read_and_advance(2, "n")
+  end
+
+  # Return a big-endian signed 16-bit integer.
+  def get_sint16(offset=nil)
+    seek(offset)
+    uint = read_and_advance(2, "n")
+    (uint & 32768) == 0 ? uint : -(uint ^ 65535) - 1
+  end
+
+  # Return a big-endian unsigned 24-bit integer.
+  def get_uint24(offset=nil)
+    seek(offset)
+    # Ruby 1.8 doesn't support big-endian 24-bit unpack; unpack as one
+    # 8-bit and one 16-bit big-endian instead.
+    high, low = read_and_advance(3).unpack("nC")
+    (high << 8) | low
+  end
+
+  # Return a big-endian unsigned 32-bit integer.
+  def get_uint32(offset=nil)
+    seek(offset)
+    read_and_advance(4, "N")
+  end
+
+  # Return a big-endian unsigned 64-bit integer.
+  def get_uint64(offset=nil)
+    seek(offset)
+    # Ruby 1.8 doesn't support big-endian quad-word unpack; unpack as two
+    # 32-bit big-endian instead.
+    high, low = read_and_advance(8).unpack("NN")
+    (high << 32) | low
+  end
+
+  # Return an InnoDB-compressed unsigned 32-bit integer.
+  def get_ic_uint32
+    flag = peek { get_uint8 }
+
+    case
+    when flag < 0x80
+      get_uint8
+    when flag < 0xc0
+      get_uint16 & 0x7fff
+    when flag < 0xe0
+      get_uint24 & 0x3fffff
+    when flag < 0xf0
+      get_uint32 & 0x1fffffff
+    when flag == 0xf0
+      adjust(+1) # Skip the flag.
+      get_uint32
+    else
+      raise "Invalid flag #{flag.to_s(16)} seen"
+    end
+  end
+end

data/lib/innodb/log.rb

@@ -0,0 +1,43 @@
+# An InnoDB transaction log file.
+class Innodb::Log
+  HEADER_SIZE   = 4 * Innodb::LogBlock::BLOCK_SIZE
+  HEADER_START  = 0
+  DATA_START    = HEADER_START + HEADER_SIZE
+
+#define LOG_GROUP_ID		0	/* log group number */
+#define LOG_FILE_START_LSN	4	/* lsn of the start of data in this
+#define LOG_FILE_NO		12	/* 4-byte archived log file number;
+#define LOG_FILE_WAS_CREATED_BY_HOT_BACKUP 16
+#define	LOG_FILE_ARCH_COMPLETED	OS_FILE_LOG_BLOCK_SIZE
+#define LOG_FILE_END_LSN	(OS_FILE_LOG_BLOCK_SIZE + 4)
+#define LOG_CHECKPOINT_1	OS_FILE_LOG_BLOCK_SIZE
+#define LOG_CHECKPOINT_2	(3 * OS_FILE_LOG_BLOCK_SIZE)
+#define LOG_FILE_HDR_SIZE	(4 * OS_FILE_LOG_BLOCK_SIZE)
+
+  # Open a log file.
+  def initialize(file)
+    @file = File.open(file)
+    @size = @file.stat.size
+    @blocks = ((@size - DATA_START) / Innodb::LogBlock::BLOCK_SIZE)
+  end
+
+  # Return a log block with a given block number as an InnoDB::LogBlock object.
+  # Blocks are numbered after the log file header, starting from 0.
+  def block(block_number)
+    offset = DATA_START + (block_number.to_i * Innodb::LogBlock::BLOCK_SIZE)
+    return nil unless offset < @size
+    return nil unless (offset + Innodb::LogBlock::BLOCK_SIZE) <= @size
+    @file.seek(offset)
+    block_data = @file.read(Innodb::LogBlock::BLOCK_SIZE)
+    Innodb::LogBlock.new(block_data)
+  end
+
+  # Iterate through all log blocks, returning the block number and an
+  # InnoDB::LogBlock object for each block.
+  def each_block
+    (0...@blocks).each do |block_number|
+      current_block = block(block_number)
+      yield block_number, current_block if current_block
+    end
+  end
+end

data/lib/innodb/log_block.rb

@@ -0,0 +1,182 @@
+require "innodb/cursor"
+require "pp"
+
+# An InnoDB transaction log block.
+class Innodb::LogBlock
+  # Log blocks are fixed-length at 512 bytes in InnoDB.
+  BLOCK_SIZE = 512
+
+  HEADER_SIZE = 12
+  HEADER_START = 0
+
+  TRAILER_SIZE = 4
+  TRAILER_START = BLOCK_SIZE - TRAILER_SIZE
+
+  RECORD_START = HEADER_START + HEADER_SIZE
+
+# Header:
+#define	LOG_BLOCK_HDR_NO	0	/* block number which must be > 0 and
+#define	LOG_BLOCK_HDR_DATA_LEN	4	/* number of bytes of log written to
+#define	LOG_BLOCK_FIRST_REC_GROUP 6	/* offset of the first start of an
+#define LOG_BLOCK_CHECKPOINT_NO	8	/* 4 lower bytes of the value of
+
+# Trailer:
+#define	LOG_BLOCK_CHECKSUM	0	/* 4 byte checksum of the log block
+
+#/* Offsets for a checkpoint field */
+#define LOG_CHECKPOINT_NO		0
+#define LOG_CHECKPOINT_LSN		8
+#define LOG_CHECKPOINT_OFFSET		16
+#define LOG_CHECKPOINT_LOG_BUF_SIZE	20
+#define	LOG_CHECKPOINT_ARCHIVED_LSN	24
+#define	LOG_CHECKPOINT_GROUP_ARRAY	32
+
+  # Initialize a log block by passing in a 512-byte buffer containing the raw
+  # log block contents.
+  def initialize(buffer)
+    unless buffer.size == BLOCK_SIZE
+      raise "Log block buffer provided was not #{BLOCK_SIZE} bytes" 
+    end
+
+    @buffer = buffer
+  end
+
+  # A helper function to return bytes from the log block buffer based on offset
+  # and length, both in bytes.
+  def data(offset, length)
+    @buffer[offset...(offset + length)]
+  end
+
+  # Return an Innodb::Cursor object positioned at a specific offset.
+  def cursor(offset)
+    Innodb::Cursor.new(self, offset)
+  end
+
+  # Return the log block header.
+  def header
+    @header ||= begin
+      c = cursor(HEADER_START)
+      {
+        :block            => c.get_uint32,
+        :data_length      => c.get_uint16,
+        :first_rec_group  => c.get_uint16,
+        :checkpoint_no    => c.get_uint32,
+      }
+    end
+  end
+
+  # Return the log block trailer.
+  def trailer
+    @trailer ||= begin
+      c = cursor(TRAILER_START)
+      {
+        :checksum => c.get_uint32,
+      }
+    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,
+  }
+
+  # Return the log record contents. (This is mostly unimplemented.)
+  def record_content(record_type, offset)
+    c = cursor(offset)
+    case record_type
+    when :MLOG_1BYTE
+      c.get_uint8
+    when :MLOG_2BYTE
+      c.get_uint16
+    when :MLOG_4BYTE
+      c.get_uint32
+    when :MLOG_8BYTE
+      c.get_uint64
+    when :UNDO_INSERT
+    when :COMP_REC_INSERT
+    end
+  end
+
+  SINGLE_RECORD_MASK = 0x80
+  RECORD_TYPE_MASK = 0x7f
+
+  # Return the log record. (This is mostly unimplemented.)
+  def record
+    @record ||= begin
+      if header[:first_rec_group] != 0
+        c = cursor(header[:first_rec_group])
+        type_and_flag = c.get_uint8
+        type = type_and_flag & RECORD_TYPE_MASK
+        type = RECORD_TYPES[type] || type
+        single_record = (type_and_flag & SINGLE_RECORD_MASK) == SINGLE_RECORD_MASK
+        {
+          :type           => type,
+          :single_record  => single_record,
+          :content        => record_content(type, c.position),
+          :space          => c.get_ic_uint32,
+          :page_number    => c.get_ic_uint32,
+        }
+      end
+    end
+  end
+
+  # Dump the contents of a log block for debugging purposes.
+  def dump
+    puts
+    puts "header:"
+    pp header
+
+    puts
+    puts "trailer:"
+    pp trailer
+
+    puts
+    puts "record:"
+    pp record
+  end
+end

data/lib/innodb/page.rb

@@ -0,0 +1,313 @@
+require "innodb/cursor"
+
+class Innodb::Page
+  # Currently only 16kB InnoDB pages are supported.
+  PAGE_SIZE = 16384
+
+  # InnoDB Page Type constants from include/fil0fil.h.
+  PAGE_TYPE = {
+    0     => :ALLOCATED,      # Freshly allocated page
+    2     => :UNDO_LOG,       # Undo log page
+    3     => :INODE,          # Index node
+    4     => :IBUF_FREE_LIST, # Insert buffer free list
+    5     => :IBUF_BITMAP,    # Insert buffer bitmap
+    6     => :SYS,            # System page
+    7     => :TRX_SYS,        # Transaction system data
+    8     => :FSP_HDR,        # File space header
+    9     => :XDES,           # Extent descriptor page
+    10    => :BLOB,           # Uncompressed BLOB page
+    11    => :ZBLOB,          # First compressed BLOB page
+    12    => :ZBLOB2,         # Subsequent compressed BLOB page
+    17855 => :INDEX,          # B-tree node
+  }
+
+  # Initialize a page by passing in a 16kB buffer containing the raw page
+  # contents. Currently only 16kB pages are supported.
+  def initialize(buffer)
+    unless buffer.size == PAGE_SIZE
+      raise "Page buffer provided was not #{PAGE_SIZE} bytes" 
+    end
+
+    @buffer = buffer
+  end
+
+  # A helper function to return bytes from the page buffer based on offset
+  # and length, both in bytes.
+  def data(offset, length)
+    @buffer[offset...(offset + length)]
+  end
+
+  # Return an Innodb::Cursor object positioned at a specific offset.
+  def cursor(offset)
+    Innodb::Cursor.new(self, offset)
+  end
+
+  FIL_HEADER_SIZE   = 38
+  FIL_HEADER_START  = 0
+
+  # A helper to convert "undefined" values stored in previous and next pointers
+  # in the page header to nil.
+  def maybe_undefined(value)
+    value == 4294967295 ? nil : value
+  end
+
+  # Return the "fil" header from the page, which is common for all page types.
+  def fil_header
+    c = cursor(FIL_HEADER_START)
+    @fil_header ||= {
+      :checksum   => c.get_uint32,
+      :offset     => c.get_uint32,
+      :prev       => maybe_undefined(c.get_uint32),
+      :next       => maybe_undefined(c.get_uint32),
+      :lsn        => c.get_uint64,
+      :type       => PAGE_TYPE[c.get_uint16],
+      :flush_lsn  => c.get_uint64,
+      :space_id   => c.get_uint32,
+    }
+  end
+  alias :fh :fil_header
+
+  # A helper function to return the page type from the "fil" header, for easier
+  # access.
+  def type
+    fil_header[:type]
+  end
+
+  # A helper function to return the page number of the logical previous page
+  # (from the doubly-linked list from page to page) from the "fil" header,
+  # for easier access.
+  def prev
+    fil_header[:prev]
+  end
+
+  # A helper function to return the page number of the logical next page
+  # (from the doubly-linked list from page to page) from the "fil" header,
+  # for easier access.
+  def next
+    fil_header[:next]
+  end
+
+  PAGE_HEADER_SIZE  = 36
+  PAGE_HEADER_START = FIL_HEADER_START + FIL_HEADER_SIZE
+
+  PAGE_TRAILER_SIZE  = 16
+  PAGE_TRAILER_START = PAGE_SIZE - PAGE_TRAILER_SIZE
+
+  FSEG_HEADER_SIZE  = 10
+  FSEG_HEADER_START = PAGE_HEADER_START + PAGE_HEADER_SIZE
+  FSEG_HEADER_COUNT = 2
+
+  MUM_RECORD_SIZE   = 8
+  
+  RECORD_BITS_SIZE  = 3
+  RECORD_NEXT_SIZE  = 2
+
+  # Page direction values possible in the page_header[:direction] field.
+  PAGE_DIRECTION = {
+    1 => :left,
+    2 => :right,
+    3 => :same_rec,
+    4 => :same_page,
+    5 => :no_direction,
+  }
+
+  # Return the size of the header for each record.
+  def size_record_header
+    case page_header[:format]
+    when :compact
+      RECORD_BITS_SIZE + RECORD_NEXT_SIZE
+    when :redundant
+      RECORD_BITS_SIZE + RECORD_NEXT_SIZE + 1
+    end
+  end
+
+  # Return the size of a field in the record header for which no description
+  # could be found (but must be skipped anyway).
+  def size_record_undefined
+    case page_header[:format]
+    when :compact
+      0
+    when :redundant
+      1
+    end
+  end
+
+  # Return the "page" header; currently only "INDEX" pages are supported.
+  def page_header
+    return nil unless type == :INDEX
+
+    c = cursor(PAGE_HEADER_START)
+    @page_header ||= {
+      :n_dir_slots  => c.get_uint16,
+      :heap_top     => c.get_uint16,
+      :n_heap       => ((n_heap = c.get_uint16) & (2**15-1)),
+      :free         => c.get_uint16,
+      :garbage      => c.get_uint16,
+      :last_insert  => c.get_uint16,
+      :direction    => PAGE_DIRECTION[c.get_uint16],
+      :n_direction  => c.get_uint16,
+      :n_recs       => c.get_uint16,
+      :max_trx_id   => c.get_uint64,
+      :level        => c.get_uint16,
+      :index_id     => c.get_uint64,
+      :format       => (n_heap & 1<<15) == 0 ? :redundant : :compact,
+    }
+  end
+  alias :ph :page_header
+
+  # Parse and return simple fixed-format system records, such as InnoDB's
+  # internal infimum and supremum records.
+  def system_record(offset)
+    return nil unless type == :INDEX
+
+    c = cursor(offset)
+    c.adjust(-2)
+    {
+      :next => offset + c.get_sint16,
+      :data => c.get_bytes(8),
+    }
+  end
+
+  # Return the byte offset of the start of the "origin" of the infimum record,
+  # which is always the first record in the singly-linked record chain on any
+  # page, and represents a record with a "lower value than any possible user
+  # record". The infimum record immediately follows the page header.
+  def pos_infimum
+    pos_records + size_record_header + size_record_undefined
+  end
+
+  # Return the infimum record on a page.
+  def infimum
+    @infimum ||= system_record(pos_infimum)
+  end
+
+  # Return the byte offset of the start of the "origin" of the supremum record,
+  # which is always the last record in the singly-linked record chain on any
+  # page, and represents a record with a "higher value than any possible user
+  # record". The supremum record immediately follows the infimum record.
+  def pos_supremum
+    pos_infimum + size_record_header + size_record_undefined + MUM_RECORD_SIZE
+  end
+
+  # Return the supremum record on a page.
+  def supremum
+    @supremum ||= system_record(pos_supremum)
+  end
+
+  # Return the byte offset of the start of records within the page (the
+  # position immediately after the page header).
+  def pos_records
+    FIL_HEADER_SIZE + 
+      PAGE_HEADER_SIZE + 
+      (FSEG_HEADER_COUNT * FSEG_HEADER_SIZE)
+  end
+
+  # Return the byte offset of the start of the user records in a page, which
+  # immediately follows the supremum record.
+  def pos_user_records
+    pos_supremum + size_record_header + size_record_undefined + MUM_RECORD_SIZE
+  end
+
+  # Return the amount of free space in the page.
+  def free_space
+    unused_space = (PAGE_TRAILER_START - page_header[:heap_top])
+    unused_space + page_header[:garbage]
+  end
+
+  # Return the amount of used space in the page.
+  def used_space
+    PAGE_SIZE - free_space
+  end
+
+  # Return the amount of space occupied by records in the page.
+  def record_space
+    used_space - pos_user_records
+  end
+
+  # Return the actual bytes of the portion of the page which is used to
+  # store user records (eliminate the headers and trailer from the page).
+  def record_bytes
+    data(pos_user_records, page_header[:heap_top] - pos_user_records)
+  end
+
+  # Return the header from a record. (This is mostly unimplemented.)
+  def record_header(offset)
+    return nil unless type == :INDEX
+
+    c = cursor(offset).backward
+    case page_header[:format]
+    when :compact
+      header = {}
+      header[:next] = c.get_sint16
+      bits1 = c.get_uint16
+      header[:type] = bits1 & 0x07
+      header[:order] = (bits1 & 0xf8) >> 3
+      bits2 = c.get_uint8
+      header[:n_owned] = bits2 & 0x0f
+      header[:deleted] = (bits2 & 0xf0) >> 4
+      header
+    when :redundant
+      raise "Not implemented"
+    end
+  end
+
+  # Return a record. (This is mostly unimplemented.)
+  def record(offset)
+    return nil unless offset
+    return nil unless type == :INDEX
+    return nil if offset == pos_infimum
+    return nil if offset == pos_supremum
+
+    c = cursor(offset).forward
+    # There is a header preceding the row itself, so back up and read it.
+    header = record_header(offset)
+    {
+      :header => header,
+      :next => header[:next] == 0 ? nil : (offset + header[:next]),
+      # These system records may not be present depending on schema.
+      :rec1 => c.get_bytes(6),
+      :rec2 => c.get_bytes(6),
+      :rec3 => c.get_bytes(7),
+      # Read a few bytes just so it can be visually verified.
+      :data => c.get_bytes(8),
+    }
+  end
+
+  # Iterate through all records. (This is mostly unimplemented.)
+  def each_record
+    rec = infimum
+    while rec = record(rec[:next])
+      yield rec
+    end
+    nil
+  end
+
+  # Dump the contents of a page for debugging purposes.
+  def dump
+    puts
+    puts "fil header:"
+    pp fil_header
+
+    puts
+    puts "page header:"
+    pp page_header
+
+    puts
+    puts "free space: #{free_space}"
+    puts "used space: #{used_space}"
+    puts "record space: #{record_space}"
+
+    if type == :INDEX
+      puts
+      puts "system records:"
+      pp infimum
+      pp supremum
+      
+      puts
+      puts "records:"
+      each_record do |rec|
+        pp rec
+      end
+    end
+  end
+end

data/lib/innodb/space.rb

@@ -0,0 +1,29 @@
+# An InnoDB tablespace file, which can be either a multi-table ibdataN file
+# or a single-table "innodb_file_per_table" .ibd file.
+class Innodb::Space
+  # Open a tablespace file.
+  def initialize(file)
+    @file = File.open(file)
+    @size = @file.stat.size
+    @pages = (@size / Innodb::Page::PAGE_SIZE)
+  end
+
+  # Get an Innodb::Page object for a specific page by page number.
+  def page(page_number)
+    offset = page_number.to_i * Innodb::Page::PAGE_SIZE
+    return nil unless offset < @size
+    return nil unless (offset + Innodb::Page::PAGE_SIZE) <= @size
+    @file.seek(offset)
+    page_data = @file.read(Innodb::Page::PAGE_SIZE)
+    Innodb::Page.new(page_data)
+  end
+
+  # Iterate through all pages in a tablespace, returning the page number
+  # and an Innodb::Page object for each one.
+  def each_page
+    (0...@pages).each do |page_number|
+      current_page = page(page_number)
+      yield page_number, current_page if current_page
+    end
+  end
+end

data/lib/innodb/version.rb

@@ -0,0 +1,3 @@
+module Innodb
+  VERSION = "0.4"
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: innodb_ruby
+version: !ruby/object:Gem::Version 
+  hash: 3
+  prerelease: 
+  segments: 
+  - 0
+  - 4
+  version: "0.4"
+platform: ruby
+authors: 
+- Jeremy Cole
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-20 00:00:00 Z
+dependencies: []
+
+description: Library for parsing InnoDB data files in Ruby
+email: jeremy@jcole.us
+executables: 
+- innodb_dump_log
+- innodb_dump_space
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/innodb.rb
+- lib/innodb/cursor.rb
+- lib/innodb/log.rb
+- lib/innodb/log_block.rb
+- lib/innodb/page.rb
+- lib/innodb/space.rb
+- lib/innodb/version.rb
+- bin/innodb_dump_log
+- bin/innodb_dump_space
+homepage: http://jcole.us/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: InnoDB data file parser
+test_files: []
+
+has_rdoc: