innodb_ruby 0.7.12 → 0.8.0

data/bin/innodb_space

@@ -262,7 +262,12 @@ def page_account(space, page_number)
   end
 
   page = space.page(page_number)
-  puts "  Page type is #{page.type}."
+  page_type = Innodb::Page::PAGE_TYPE[page.type]
+  puts "  Page type is %s (%s, %s)." % [
+    page.type,
+    page_type[:description],
+    page_type[:usage],
+  ]
 
   xdes = space.xdes_for_page(page_number)
   puts "  Extent descriptor for pages %d-%d is at page %d, offset %d." % [
@@ -354,7 +359,7 @@ def page_directory_summary(page)
     record = page.record(offset)
     key = if [:conventional, :node_pointer].include? record[:header][:type]
       if record[:key]
-        "(%s)" % record[:key].join(", ")
+        "(%s)" % record[:key].map { |r| "%s=%s" % [r[:name], r[:value]] }.join(", ")
       end
     end
     puts "%-8i%-8i%-14s%-8i%s" % [
@@ -409,8 +414,8 @@ def index_recurse(index)
         page.each_record do |record|
           puts "%sRECORD: (%s) -> (%s)" % [
             "  " * (depth+1),
-            record[:key].join(", "),
-            record[:row].join(", "),
+            record[:key].map { |r| "%s=%s" % [r[:name], r[:value]] }.join(", "),
+            record[:row].map { |r| "%s=%s" % [r[:name], r[:value]] }.join(", "),
           ]
         end
       end
@@ -418,7 +423,7 @@ def index_recurse(index)
     lambda do |parent_page, child_page, child_min_key, depth|
       puts "%sNODE POINTER RECORD >= (%s) -> #%i" % [
         "  " * depth,
-        child_min_key.join(", "),
+        child_min_key.map { |r| "%s=%s" % [r[:name], r[:value]] }.join(", "),
         child_page.offset,
       ]
     end
@@ -479,7 +484,7 @@ def index_level_summary(index, levels)
         page.record_space,
         page.free_space,
         page.records,
-        page.first_record[:key].join("|"),
+        page.first_record[:key].map { |r| r[:value] }.join("|"),
       ]
     end
   end
@@ -667,9 +672,11 @@ end
 space = Innodb::Space.new(@options.file, @options.page_size)
 
 if @options.describer
-  unless space.record_describer = eval(@options.describer)
-    space.record_describer = Innodb::RecordDescriber.const_get(@options.describer)
+  describer = eval(@options.describer)
+  unless describer
+    describer = Innodb::RecordDescriber.const_get(@options.describer)
   end
+  space.record_describer = describer.new
 end
 
 if ARGV.empty?

data/lib/innodb.rb

@@ -6,6 +6,8 @@ require "enumerator"
 
 require "innodb/version"
 require "innodb/checksum"
+require "innodb/record_describer"
+require "innodb/data_dictionary"
 require "innodb/page"
 require "innodb/page/blob"
 require "innodb/page/fsp_hdr_xdes"
@@ -14,7 +16,6 @@ require "innodb/page/index"
 require "innodb/page/trx_sys"
 require "innodb/page/sys"
 require "innodb/page/undo_log"
-require "innodb/record_describer"
 require "innodb/field"
 require "innodb/space"
 require "innodb/inode"

data/lib/innodb/data_dictionary.rb

@@ -0,0 +1,53 @@
+class Innodb::DataDictionary
+  # A record describer for SYS_TABLES clustered records.
+  class SYS_TABLES_PRIMARY < Innodb::RecordDescriber
+    type :clustered
+    key "NAME",         "VARCHAR(100)",      :NOT_NULL
+    row "ID",           :BIGINT, :UNSIGNED,  :NOT_NULL
+    row "N_COLS",       :INT,    :UNSIGNED,  :NOT_NULL
+    row "TYPE",         :INT,    :UNSIGNED,  :NOT_NULL
+    row "MIX_ID",       :BIGINT, :UNSIGNED,  :NOT_NULL
+    row "MIX_LEN",      :INT,    :UNSIGNED,  :NOT_NULL
+    row "CLUSTER_NAME", "VARCHAR(100)",      :NOT_NULL
+    row "SPACE",        :INT,    :UNSIGNED,  :NOT_NULL
+  end
+
+  # A record describer for SYS_TABLES secondary key on ID.
+  class SYS_TABLES_ID < Innodb::RecordDescriber
+    type :secondary
+    key "ID",           :BIGINT, :UNSIGNED,  :NOT_NULL
+    row "NAME",         "VARCHAR(100)",      :NOT_NULL
+  end
+
+  # A record describer for SYS_COLUMNS clustered records.
+  class SYS_COLUMNS_PRIMARY < Innodb::RecordDescriber
+    type :clustered
+    key "TABLE_ID",     :BIGINT, :UNSIGNED,  :NOT_NULL
+    key "POS",          :INT,    :UNSIGNED,  :NOT_NULL
+    row "NAME",         "VARCHAR(100)",      :NOT_NULL
+    row "MTYPE",        :INT,    :UNSIGNED,  :NOT_NULL
+    row "PRTYPE",       :INT,    :UNSIGNED,  :NOT_NULL
+    row "LEN",          :INT,    :UNSIGNED,  :NOT_NULL
+    row "PREC",         :INT,    :UNSIGNED,  :NOT_NULL
+  end
+
+  # A record describer for SYS_INDEXES clustered records.
+  class SYS_INDEXES_PRIMARY < Innodb::RecordDescriber
+    type :clustered
+    key "TABLE_ID",     :BIGINT, :UNSIGNED,  :NOT_NULL
+    key "ID",           :BIGINT, :UNSIGNED,  :NOT_NULL
+    row "NAME",         "VARCHAR(100)",      :NOT_NULL
+    row "N_FIELDS",     :INT,    :UNSIGNED,  :NOT_NULL
+    row "TYPE",         :INT,    :UNSIGNED,  :NOT_NULL
+    row "SPACE",        :INT,    :UNSIGNED,  :NOT_NULL
+    row "PAGE_NO",      :INT,    :UNSIGNED,  :NOT_NULL
+  end
+
+  # A record describer for SYS_FIELDS clustered records.
+  class SYS_FIELDS_PRIMARY < Innodb::RecordDescriber
+    type :clustered
+    key "INDEX_ID",     :BIGINT, :UNSIGNED,  :NOT_NULL
+    key "POS",          :INT,    :UNSIGNED,  :NOT_NULL
+    row "COL_NAME",     "VARCHAR(100)",      :NOT_NULL
+  end
+end

data/lib/innodb/index.rb

@@ -201,7 +201,7 @@ class Innodb::Index
       puts "linear_search_from_cursor: page=%i, level=%i, start=(%s)" % [
         page.offset,
         page.level,
-        this_rec && this_rec[:key].join(", "),
+        this_rec && this_rec[:key].map { |r| r[:value] }.join(", "),
       ]
     end
 
@@ -214,19 +214,19 @@ class Innodb::Index
         puts "linear_search_from_cursor: page=%i, level=%i, current=(%s)" % [
           page.offset,
           page.level,
-          this_rec && this_rec[:key].join(", "),
+          this_rec && this_rec[:key].map { |r| r[:value] }.join(", "),
         ]
       end
 
       # If we reach supremum, return the last non-system record we got.
       return this_rec if next_rec[:header][:type] == :supremum
 
-      if compare_key(key, this_rec[:key]) < 0
+      if compare_key(key, this_rec[:key][:value]) < 0
         return this_rec
       end
 
-      if (compare_key(key, this_rec[:key]) >= 0) &&
-        (compare_key(key, next_rec[:key]) < 0)
+      if (compare_key(key, this_rec[:key][:value]) >= 0) &&
+        (compare_key(key, next_rec[:key][:value]) < 0)
         # The desired key is either an exact match for this_rec or is greater
         # than it but less than next_rec. If this is a non-leaf page, that
         # will mean that the record will fall on the leaf page this node
@@ -263,7 +263,7 @@ class Innodb::Index
         page.level,
         dir.size,
         mid,
-        rec[:key] && rec[:key].join(", "),
+        rec[:key] && rec[:key].map { |r| r[:value] }.join(", "),
       ]
     end
 
@@ -276,7 +276,7 @@ class Innodb::Index
     end
 
     # Compare the desired key to the mid-point record's key.
-    case compare_key(key, rec[:key])
+    case compare_key(key, rec[:key][:value])
     when 0
       # An exact match for the key was found. Return the record.
       @stats[:binary_search_by_directory_exact_match] += 1
@@ -292,7 +292,7 @@ class Innodb::Index
         binary_search_by_directory(page, dir[mid...dir.size], key)
       else
         next_rec = page.record(dir[mid+1])
-        next_key = next_rec && compare_key(key, next_rec[:key])
+        next_key = next_rec && compare_key(key, next_rec[:key][:value])
         if dir.size == 1 || next_key == -1 || next_key == 0
           # This is the last entry remaining from the directory, or our key is
           # greater than rec and less than rec+1's key. Use linear search to
@@ -350,7 +350,7 @@ class Innodb::Index
         # We're on a leaf page, so return the page and record if there is a
         # match. If there is no match, break the loop and cause nil to be
         # returned.
-        return page, rec if compare_key(key, rec[:key]) == 0
+        return page, rec if compare_key(key, rec[:key][:value]) == 0
         break
       end
     end
@@ -383,7 +383,7 @@ class Innodb::Index
         # We're on a leaf page, so return the page and record if there is a
         # match. If there is no match, break the loop and cause nil to be
         # returned.
-        return page, rec if compare_key(key, rec[:key]) == 0
+        return page, rec if compare_key(key, rec[:key][:value]) == 0
         break
       end
     end

data/lib/innodb/page.rb

@@ -112,21 +112,75 @@ class Innodb::Page
 
   # 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
+    :ALLOCATED => {
+      :value => 0,
+      :description => "Freshly allocated",
+      :usage => "page type field has not been initialized",
+    },
+    :UNDO_LOG => {
+      :value => 2,
+      :description => "Undo log",
+      :usage => "stores previous values of modified records",
+    },
+    :INODE => {
+      :value => 3,
+      :description => "File segment inode",
+      :usage => "bookkeeping for file segments",
+    },
+    :IBUF_FREE_LIST => {
+      :value => 4,
+      :description => "Insert buffer free list",
+      :usage => "bookkeeping for insert buffer free space management",
+    },
+    :IBUF_BITMAP => {
+      :value => 5,
+      :description => "Insert buffer bitmap",
+      :usage => "bookkeeping for insert buffer writes to be merged",
+    },
+    :SYS => {
+      :value => 6,
+      :description => "System internal",
+      :usage => "used for various purposes in the system tablespace",
+    },
+    :TRX_SYS => {
+      :value => 7,
+      :description => "Transaction system header",
+      :usage => "bookkeeping for the transaction system in system tablespace",
+    },
+    :FSP_HDR => {
+      :value => 8,
+      :description => "File space header",
+      :usage => "header page (page 0) for each tablespace file",
+    },
+    :XDES => {
+      :value => 9,
+      :description => "Extent descriptor",
+      :usage => "header page for subsequent blocks of 16,384 pages",
+    },
+    :BLOB => {
+      :value => 10,
+      :description => "Uncompressed BLOB",
+      :usage => "externally-stored uncompressed BLOB column data",
+    },
+    :ZBLOB => {
+      :value => 11,
+      :description => "First compressed BLOB",
+      :usage => "externally-stored compressed BLOB column data, first page",
+    },
+    :ZBLOB2 => {
+      :value => 12,
+      :description => "Subsequent compressed BLOB",
+      :usage => "externally-stored compressed BLOB column data, subsequent page",
+    },
+    :INDEX => {
+      :value => 17855,
+      :description => "B+Tree index",
+      :usage => "table and index data stored in B+Tree structure",
+    },
   }
 
+  PAGE_TYPE_BY_VALUE = PAGE_TYPE.inject({}) { |h, (k, v)| h[v[:value]] = k; h }
+
   # A helper to convert "undefined" values stored in previous and next pointers
   # in the page header to nil.
   def self.maybe_undefined(value)
@@ -146,7 +200,7 @@ class Innodb::Page
           Innodb::Page.maybe_undefined(c.get_uint32)
         },
         :lsn        => c.name("lsn") { c.get_uint64 },
-        :type       => c.name("type") { PAGE_TYPE[c.get_uint16] },
+        :type       => c.name("type") { PAGE_TYPE_BY_VALUE[c.get_uint16] },
         :flush_lsn  => c.name("flush_lsn") { c.get_uint64 },
         :space_id   => c.name("space_id") { c.get_uint32 },
       }

data/lib/innodb/page/index.rb

@@ -335,22 +335,22 @@ class Innodb::Page::Index < Innodb::Page
 
   # Return an array indicating which fields are null.
   def record_header_compact_null_bitmap(cursor)
-    fields = (record_format[:key] + record_format[:row])
+    columns = (record_format[:key] + record_format[:row])
 
     # The number of bits in the bitmap is the number of nullable fields.
-    size = fields.count { |f| f.type.nullable? }
+    size = columns.count { |c| c[:field].type.nullable? }
 
     # There is no bitmap if there are no nullable fields.
     return nil unless size > 0
 
     # To simplify later checks, expand bitmap to one for each field.
-    bitmap = Array.new(fields.last.position + 1, false)
+    bitmap = Array.new(columns.last[:field].position + 1, false)
 
     null_bit_array = cursor.get_bit_array(size).reverse!
 
     # For every nullable field, set whether the field is actually null.
-    fields.each do |f|
-      bitmap[f.position] = f.type.nullable? ? (null_bit_array.shift == 1) : false
+    columns.each do |c|
+      bitmap[c[:field].position] = c[:field].type.nullable? ? (null_bit_array.shift == 1) : false
     end
 
     return bitmap
@@ -359,14 +359,15 @@ class Innodb::Page::Index < Innodb::Page
   # Return an array containing an array of the length of each variable-length
   # field and an array indicating which fields are stored externally.
   def record_header_compact_variable_lengths_and_externs(cursor, null_bitmap)
-    fields = (record_format[:key] + record_format[:row])
+    columns = (record_format[:key] + record_format[:row])
 
-    len_array = Array.new(fields.last.position + 1, 0)
-    ext_array = Array.new(fields.last.position + 1, false)
+    len_array = Array.new(columns.last[:field].position + 1, 0)
+    ext_array = Array.new(columns.last[:field].position + 1, false)
 
     # For each non-NULL variable-length field, the record header contains
     # the length in one or two bytes.
-    fields.each do |f|
+    columns.each do |c|
+      f = c[:field]
       next if !f.type.variable? or (null_bitmap && null_bitmap[f.position])
 
       len = cursor.get_uint8
@@ -449,21 +450,29 @@ class Innodb::Page::Index < Innodb::Page
 
   # Return a set of field objects that describe the record.
   def make_record_description
-    description = record_describer.cursor_sendable_description(self)
+    description = record_describer.description
 
     position = 0
     fields = {:type => description[:type], :key => [], :row => []}
 
-    description[:key].each do |d|
-      fields[:key] << Innodb::Field.new(position, *d)
+    description[:key].each do |field|
+      fields[:key] << {
+        :name => field[:name],
+        :field => Innodb::Field.new(position, *field[:type]),
+      }
       position += 1
     end
 
-    # Account for TRX_ID and ROLL_PTR.
-    position += 2
+    if description[:type] == :clustered
+      # Account for TRX_ID and ROLL_PTR.
+      position += 2
+    end
 
-    description[:row].each do |d|
-      fields[:row] << Innodb::Field.new(position, *d)
+    description[:row].each do |field|
+      fields[:row] << {
+        :name => field[:name],
+        :field => Innodb::Field.new(position, *field[:type]),
+      }
       position += 1
     end
 
@@ -499,11 +508,13 @@ class Innodb::Page::Index < Innodb::Page
 
         # Read the key fields present in all types of pages.
         this_record[:key] = []
-        this_record[:key_ext] = []
-        c.name("key") do
-          record_format[:key].each do |f|
-            this_record[:key].push f.read(this_record, c)
-            this_record[:key_ext].push f.read_extern(this_record, c)
+        record_format[:key].each do |column|
+          c.name("key[#{column[:name]}]") do
+            this_record[:key] << {
+              :name => column[:name],
+              :value => column[:field].read(this_record, c),
+              :extern => column[:field].read_extern(this_record, c),
+            }
           end
         end
 
@@ -532,11 +543,13 @@ class Innodb::Page::Index < Innodb::Page
           (record_format[:type] == :secondary)
           # Read the non-key fields.
           this_record[:row] = []
-          this_record[:row_ext] = []
-          c.name("row") do
-            record_format[:row].each do |f|
-              this_record[:row].push f.read(this_record, c)
-              this_record[:row_ext].push f.read_extern(this_record, c)
+          record_format[:row].each do |column|
+            c.name("row[#{column[:name]}]") do
+              this_record[:row] << {
+                :name => column[:name],
+                :value => column[:field].read(this_record, c),
+                :extern => column[:field].read_extern(this_record, c),
+              }
             end
           end
         end

data/lib/innodb/page/sys_data_dictionary_header.rb

@@ -1,5 +1,18 @@
 # -*- encoding : utf-8 -*-
+
+require "innodb/data_dictionary"
+
 class Innodb::Page::SysDataDictionaryHeader < Innodb::Page
+  RECORD_DESCRIBERS = {
+    :SYS_TABLES  => {
+      :PRIMARY => Innodb::DataDictionary::SYS_TABLES_PRIMARY,
+      :ID => Innodb::DataDictionary::SYS_TABLES_ID
+    },
+    :SYS_COLUMNS => { :PRIMARY => Innodb::DataDictionary::SYS_COLUMNS_PRIMARY },
+    :SYS_INDEXES => { :PRIMARY => Innodb::DataDictionary::SYS_INDEXES_PRIMARY },
+    :SYS_FIELDS  => { :PRIMARY => Innodb::DataDictionary::SYS_FIELDS_PRIMARY },
+  }
+
   # The position of the data dictionary header within the page.
   def pos_data_dictionary_header
     pos_fil_header + size_fil_header
@@ -40,6 +53,22 @@ class Innodb::Page::SysDataDictionaryHeader < Innodb::Page
     end
   end
 
+  def index(table_name, index_name)
+    unless table_entry = data_dictionary_header[:indexes][table_name]
+      raise "Unknown data dictionary table #{table_name}"
+    end
+
+    unless index_root_page = table_entry[index_name]
+      raise "Unknown data dictionary index #{table_name}.#{index_name}"
+    end
+
+    # If we have a record describer for this index, load it.
+    record_describer = RECORD_DESCRIBERS[table_name] &&
+                       RECORD_DESCRIBERS[table_name][index_name]
+
+    @space.index(index_root_page, record_describer.new)
+  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
@@ -49,7 +78,7 @@ class Innodb::Page::SysDataDictionaryHeader < Innodb::Page
 
     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)
+        yield table_name, index_name, index(table_name, index_name)
       end
     end
   end
@@ -61,32 +90,4 @@ class Innodb::Page::SysDataDictionaryHeader < Innodb::Page
     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/record_describer.rb

@@ -1,3 +1,112 @@
 # -*- encoding : utf-8 -*-
-# An empty class in order to establish the Innodb::RecordDescriber namespace.
-class Innodb::RecordDescriber; end
+
+#
+# A class to describe record layouts for InnoDB indexes. Designed to be usable
+# in two different ways: statically built and dynamically built. Note that in
+# both cases, the order that statements are encountered is critical. Columns
+# must be added to the key and row structures in the correct order.
+#
+# STATIC USAGE
+#
+# Static building is useful for building a custom describer for any index
+# and looks like the following:
+#
+# To describe the SQL syntax:
+#
+#   CREATE TABLE my_table (
+#     id BIGINT NOT NULL,
+#     name VARCHAR(100) NOT NULL,
+#     age INT UNSIGNED,
+#     PRIMARY KEY (id)
+#   );
+#
+# The clustered key would require a class like:
+#
+#   class MyTableClusteredDescriber < Innodb::RecordDescriber
+#     type :clustered
+#     key "id", :BIGINT, :UNSIGNED, :NOT_NULL
+#     row "name", "VARCHAR(100)", :NOT_NULL
+#     row "age", :INT, :UNSIGNED
+#   end
+#
+# It can then be instantiated as usual:
+#
+#   my_table_clustered = MyTableClusteredDescriber.new
+#
+# All statically-defined type, key, and row information will be copied into
+# the instance when it is initialized. Once initialized, the instance can
+# be additionally used dynamically, as per below. (A dynamic class is just
+# the same as a static class that is empty.)
+#
+# Note that since InnoDB works in terms of *indexes* individually, a new class
+# must be created for each index.
+#
+# DYNAMIC USAGE
+#
+# If a record describer needs to be built based on runtime information, such
+# as index descriptions from a live data dictionary, instances can be built
+# dynamically. For the same table above, this would require:
+#
+#   my_table_clustered = Innodb::RecordDescriber.new
+#   my_table_clustered.type = :clustered
+#   my_table_clustered.key "id", :BIGINT, :UNSIGNED, :NOT_NULL
+#   my_table_clustered.row "name", "VARCHAR(100)", :NOT_NULL
+#   my_table_clustered.row "age", :INT, :UNSIGNED
+#
+
+class Innodb::RecordDescriber
+  # Internal method to initialize the class's instance variable on access.
+  def self.static_description
+    @static_description ||= {
+      :type => nil,
+      :key => [],
+      :row => []
+    }
+  end
+
+  # A 'type' method to be used from the DSL.
+  def self.type(type)
+    static_description[:type] = type
+  end
+
+  # An internal method wrapped with 'key' and 'row' helpers.
+  def self.add_static_field(group, name, type)
+    static_description[group] << { :name => name, :type => type }
+  end
+
+  # A 'key' method to be used from the DSL.
+  def self.key(name, *type)
+    add_static_field :key, name, type
+  end
+
+  # A 'row' method to be used from the DSL.
+  def self.row(name, *type)
+    add_static_field :row, name, type
+  end
+
+  attr_accessor :description
+
+  def initialize
+    @description = self.class.static_description.dup
+  end
+
+  # Set the type of this record (:clustered or :secondary).
+  def type(type)
+    description[:type] = type
+  end
+
+  # An internal method wrapped with 'key' and 'row' helpers.
+  def add_field(group, name, type)
+    description[group] << { :name => name, :type => type }
+  end
+
+  # Add a key column to the record description.
+  def key(name, *type)
+    add_field :key, name, type
+  end
+
+  # Add a row (non-key) column to the record description.
+  def row(name, *type)
+    add_field :row, name, type
+  end
+end

data/lib/innodb/space.rb

@@ -57,7 +57,7 @@ class Innodb::Space
     # to offset 0 and page type :FSP_HDR (8).
     page_offset = BinData::Uint32be.read(read_at_offset(4, 4))
     page_type   = BinData::Uint16be.read(read_at_offset(24, 2))
-    unless page_offset == 0 && Innodb::Page::PAGE_TYPE[page_type] == :FSP_HDR
+    unless page_offset == 0 && Innodb::Page::PAGE_TYPE_BY_VALUE[page_type] == :FSP_HDR
       raise "Something is very wrong; Page 0 does not seem to be type FSP_HDR"
     end
 
@@ -165,14 +165,24 @@ class Innodb::Space
     true
   end
 
+  # Return the page number for the space's FSP_HDR page.
+  def page_fsp_hdr
+    0
+  end
+
   # Get (and cache) the FSP header from the FSP_HDR page.
   def fsp
-    @fsp ||= page(0).fsp_header
+    @fsp ||= page(page_fsp_hdr).fsp_header
+  end
+
+  # Return the page number for the space's TRX_SYS page.
+  def page_trx_sys
+    5
   end
 
   # Get the Innodb::Page::TrxSys page for a system space.
   def trx_sys
-    page(5) if system_space?
+    page(page_trx_sys) if system_space?
   end
 
   def rseg_page?(page_number)
@@ -184,9 +194,14 @@ class Innodb::Space
     end
   end
 
+  # Return the page number for the space's SYS data dictionary header.
+  def page_sys_data_dictionary
+    7
+  end
+
   # Get the Innodb::Page::SysDataDictionaryHeader page for a system space.
   def data_dictionary
-    page(7) if system_space?
+    page(page_sys_data_dictionary) if system_space?
   end
 
   # Get an Innodb::List object for a specific list by list name.

data/lib/innodb/version.rb

@@ -1,4 +1,4 @@
 # -*- encoding : utf-8 -*-
 module Innodb
-  VERSION = "0.7.12"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: innodb_ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.12
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-13 00:00:00.000000000 Z
+date: 2013-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bindata
@@ -39,6 +39,7 @@ files:
 - lib/innodb.rb
 - lib/innodb/checksum.rb
 - lib/innodb/cursor.rb
+- lib/innodb/data_dictionary.rb
 - lib/innodb/field.rb
 - lib/innodb/field_type.rb
 - lib/innodb/fseg_entry.rb