innodb_ruby 0.8.8 → 0.9.0

data/lib/innodb/page/index_compressed.rb

@@ -1,5 +1,9 @@
 # -*- encoding : utf-8 -*-
 
+# This is horribly incomplete and broken. InnoDB compression does not
+# currently work in innodb_ruby. Patches are welcome!
+# (Hint hint, nudge nudge, Facebook developers!)
+
 class Innodb::Page::Index::Compressed < Innodb::Page::Index
   # The number of directory slots in use.
   def directory_slots

data/lib/innodb/page/sys_data_dictionary_header.rb

@@ -1,18 +1,6 @@
 # -*- 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
@@ -35,7 +23,7 @@ class Innodb::Page::SysDataDictionaryHeader < Innodb::Page
         :indexes => c.name("indexes") {{
           :SYS_TABLES => c.name("SYS_TABLES") {{
             :PRIMARY => c.name("PRIMARY") { c.get_uint32 },
-            :ID      => c.name("ID")      { c.get_uint32 }, 
+            :ID      => c.name("ID")      { c.get_uint32 },
           }},
           :SYS_COLUMNS => c.name("SYS_COLUMNS") {{
             :PRIMARY => c.name("PRIMARY") { c.get_uint32 },
@@ -53,36 +41,6 @@ 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
-    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, index(table_name, index_name)
-      end
-    end
-  end
-
   def dump
     super
 

data/lib/innodb/record.rb

@@ -1,9 +1,11 @@
 # -*- encoding : utf-8 -*-
 
 class Innodb::Record
+  attr_reader :page
   attr_accessor :record
 
-  def initialize(record)
+  def initialize(page, record)
+    @page = page
     @record = record
   end
 
@@ -24,7 +26,7 @@ class Innodb::Record
   end
 
   def key_string
-    key && key.map { |r| "%s=%s" % [r[:name], r[:value]] }.join(", ")
+    key && key.map { |r| "%s=%s" % [r[:name], r[:value].inspect] }.join(", ")
   end
 
   def row
@@ -32,13 +34,21 @@ class Innodb::Record
   end
 
   def row_string
-    key && key.map { |r| "%s=%s" % [r[:name], r[:value]] }.join(", ")
+    row && row.map { |r| "%s=%s" % [r[:name], r[:value].inspect] }.join(", ")
   end
 
   def child_page_number
     record[:child_page_number]
   end
 
+  def string
+    if child_page_number
+      "(%s) → #%s" % [key_string, child_page_number]
+    else
+      "(%s) → (%s)" % [key_string, row_string]
+    end
+  end
+
   def uncached_fields
     fields_hash = {}
     [:key, :row].each do |group|
@@ -54,4 +64,25 @@ class Innodb::Record
   def fields
     @fields ||= uncached_fields
   end
+
+  # Compare two arrays of fields to determine if they are equal. This follows
+  # the same comparison rules as strcmp and others:
+  #   0 = a is equal to b
+  #   -1 = a is less than b
+  #   +1 = a is greater than b
+  def compare_key(other_key)
+    Innodb::Stats.increment :compare_key
+
+    return 0 if other_key.nil? && key.nil?
+    return -1 if other_key.nil? || (!key.nil? && other_key.size < key.size)
+    return +1 if key.nil? || (!other_key.nil? && other_key.size > key.size)
+
+    key.each_index do |i|
+      Innodb::Stats.increment :compare_key_field_comparison
+      return -1 if other_key[i] < key[i][:value]
+      return +1 if other_key[i] > key[i][:value]
+    end
+
+    return 0
+  end
 end

data/lib/innodb/record_describer.rb

@@ -88,6 +88,8 @@ class Innodb::RecordDescriber
 
   def initialize
     @description = self.class.static_description.dup
+    @description[:key] = @description[:key].dup
+    @description[:row] = @description[:row].dup
   end
 
   # Set the type of this record (:clustered or :secondary).

data/lib/innodb/space.rb

@@ -2,7 +2,6 @@
 
 # An InnoDB space file, which can be either a multi-table ibdataN file
 # or a single-table "innodb_file_per_table" .ibd file.
-
 class Innodb::Space
   # InnoDB's default page size is 16KiB.
   DEFAULT_PAGE_SIZE = 16384
@@ -35,9 +34,13 @@ class Innodb::Space
 
     @pages = (@size / @page_size)
     @compressed = fsp_flags[:compressed]
+    @innodb_system = nil
     @record_describer = nil
   end
 
+  # The Innodb::System to which this space belongs, if any.
+  attr_accessor :innodb_system
+
   # An object which can be used to describe records found in pages within
   # this space.
   attr_accessor :record_describer
@@ -142,13 +145,7 @@ class Innodb::Space
 
   # Get an Innodb::Page object for a specific page by page number.
   def page(page_number)
-    this_page = Innodb::Page.parse(self, page_data(page_number))
-
-    if this_page.type == :INDEX
-      this_page.record_describer = @record_describer
-    end
-
-    this_page
+    Innodb::Page.parse(self, page_data(page_number))
   end
 
   # Determine whether this space looks like a system space. If the initial
@@ -206,7 +203,7 @@ class Innodb::Space
   end
 
   # Get the Innodb::Page::SysDataDictionaryHeader page for a system space.
-  def data_dictionary
+  def data_dictionary_page
     page(page_sys_data_dictionary) if system_space?
   end
 
@@ -219,32 +216,47 @@ class Innodb::Space
 
   # Get an Innodb::Index object for a specific index by root page number.
   def index(root_page_number, record_describer=nil)
-    Innodb::Index.new(self, root_page_number, record_describer || @record_describer)
+    Innodb::Index.new(self, root_page_number,
+                      record_describer || @record_describer)
   end
 
-  # Iterate through each index by guessing that the root pages will be
-  # present starting at page 3, and walking forward until we find a non-
-  # root page. This should work fine for IBD files, but not for ibdata
-  # files.
-  def each_index
+  # Iterate through all root page numbers for indexes in the space.
+  def each_index_root_page_number
     unless block_given?
-      return enum_for(:each_index)
+      return enum_for(:each_index_root_page_number)
     end
 
-    if system_space?
-      data_dictionary.each_index do |table_name, index_name, index|
-        yield index
+    if innodb_system
+      # Retrieve the index root page numbers from the data dictionary.
+      innodb_system.data_dictionary.each_index_by_space_id(space_id) do |record|
+        yield record["PAGE_NO"]
       end
     else
+      # Guess that the index root pages will be present starting at page 3,
+      # and walk forward until we find a non-root page. This should work fine
+      # for IBD files, if they haven't added indexes online.
       (3...@pages).each do |page_number|
         page = page(page_number)
         if page.type == :INDEX && page.root?
-          yield index(page_number)
-        else
-          break
+          yield page_number
         end
       end
     end
+
+    nil
+  end
+
+  # Iterate through all indexes in the space.
+  def each_index
+    unless block_given?
+      return enum_for(:each_index)
+    end
+
+    each_index_root_page_number do |page_number|
+      yield index(page_number)
+    end
+
+    nil
   end
 
   # An array of Innodb::Inode list names.
@@ -336,6 +348,8 @@ class Innodb::Space
     end
   end
 
+  # Iterate through all pages, yielding the page number, page object,
+  # and page status.
   def each_page_status(start_page=0)
     unless block_given?
       return enum_for(:each_page_with_status, start_page)
@@ -353,6 +367,7 @@ class Innodb::Space
     end
   end
 
+  # A helper to produce a printable page type.
   def type_for_page(page, page_status)
     page_status[:free] ? "FREE (#{page.type})" : page.type
   end

data/lib/innodb/stats.rb

@@ -0,0 +1,46 @@
+# -*- encoding : utf-8 -*-
+
+# Collect stats globally within innodb_ruby for comparison purposes and for
+# correctness checking.
+class Innodb::Stats
+  @@data = Hash.new(0)
+
+  # Return the data hash directly.
+  def self.data
+    @@data
+  end
+
+  # Increment a statistic by name (typically a symbol), optionally by a value
+  # provided.
+  def self.increment(name, value=1)
+    @@data[name] += value
+  end
+
+  # Get a statistic by name.
+  def self.get(name)
+    @@data[name]
+  end
+
+  # Reset all statistics.
+  def self.reset
+    @@data.clear
+    nil
+  end
+
+  # Print a simple report of collected statistics, optionally to the IO object
+  # provided, or by default to STDOUT.
+  def self.print_report(io=STDOUT)
+    io.puts "%-50s%10s" % [
+      "Statistic",
+      "Count",
+    ]
+    @@data.sort.each do |name, count|
+      io.puts "%-50s%10i" % [
+        name,
+        count
+      ]
+    end
+
+    nil
+  end
+end

data/lib/innodb/system.rb

@@ -1,88 +1,168 @@
 # -*- encoding : utf-8 -*-
 
+# A class representing an entire InnoDB system, having a system tablespace
+# and any number of attached single-table tablespaces.
 class Innodb::System
+  # A hash of configuration options by configuration key.
   attr_reader :config
-  attr_accessor :spaces
+
+  # A hash of spaces by space ID.
+  attr_reader :spaces
+
+  # The Innodb::DataDictionary for this system.
+  attr_reader :data_dictionary
+
+  # The space ID of the system space, always 0.
+  SYSTEM_SPACE_ID = 0
 
   def initialize(system_space_file)
+    @spaces = {}
     @config = {
-      :datadir => ".",
+      :datadir => File.dirname(system_space_file),
     }
-    @spaces = {}
-    @spaces[0] = Innodb::Space.new(system_space_file)
+
+    add_space_file(system_space_file)
+
+    @data_dictionary = Innodb::DataDictionary.new(system_space)
   end
 
+  # A helper to get the system space.
   def system_space
-    @spaces[0]
+    spaces[SYSTEM_SPACE_ID]
+  end
+
+  # Add an already-constructed Innodb::Space object.
+  def add_space(space)
+    unless space.is_a?(Innodb::Space)
+      raise "Object was not an Innodb::Space"
+    end
+
+    spaces[space.space_id.to_i] = space
+  end
+
+  # Add a space by filename.
+  def add_space_file(space_file)
+    space = Innodb::Space.new(space_file)
+    space.innodb_system = self
+    add_space(space)
+  end
+
+  # Add a space by table name, constructing an appropriate filename
+  # from the provided table name.
+  def add_table(table_name)
+    add_space_file("%s/%s.ibd" % [config[:datadir], table_name])
   end
 
-  def each_record_from_data_dictionary_index(table, index)
+  # Return an Innodb::Space object for a given space ID, looking up
+  # and adding the single-table space if necessary.
+  def space(space_id)
+    return spaces[space_id] if spaces[space_id]
+
+    unless table_record = data_dictionary.table_by_space_id(space_id)
+      raise "Table with space ID #{space_id} not found"
+    end
+
+    add_table(table_record["NAME"])
+
+    spaces[space_id]
+  end
+
+  # Return an Innodb::Space object by table name.
+  def space_by_table_name(table_name)
+    unless table_record = data_dictionary.table_by_name(table_name)
+      raise "Table #{table_name} not found"
+    end
+
+    if table_record["SPACE"] == 0
+      return nil
+    end
+
+    space(table_record["SPACE"])
+  end
+
+  # Iterate through all table names.
+  def each_table_name
     unless block_given?
-      return enum_for(:each_record_from_data_dictionary_index, table, index)
+      return enum_for(:each_table_name)
     end
 
-    index = system_space.data_dictionary.index(table, index)
-    index.each_record do |record|
-      yield record
+    data_dictionary.each_table do |record|
+      yield record["NAME"]
     end
+
     nil
   end
 
-  def each_table
+  # Iterate through all column names by table name.
+  def each_column_name_by_table_name(table_name)
     unless block_given?
-      return enum_for(:each_table)
+      return enum_for(:each_column_name_by_table_name, table_name)
     end
 
-    each_record_from_data_dictionary_index(:SYS_TABLES, :PRIMARY) do |record|
-      yield record.fields
+    data_dictionary.each_column_by_table_name(table_name) do |record|
+      yield record["NAME"]
     end
+
+    nil
   end
 
-  def each_index
+  # Iterate through all index names by table name.
+  def each_index_name_by_table_name(table_name)
     unless block_given?
-      return enum_for(:each_index)
+      return enum_for(:each_index_name_by_table_name, table_name)
     end
 
-    each_record_from_data_dictionary_index(:SYS_INDEXES, :PRIMARY) do |record|
-      yield record.fields
+    data_dictionary.each_index_by_table_name(table_name) do |record|
+      yield record["NAME"]
     end
-  end
 
-  def object_by_field(method, field, value)
-    send(method).select { |o| o[field] == value }.first
+    nil
   end
 
-  def object_by_two_fields(method, f1, v1, f2, v2)
-    send(method).select { |o| o[f1] == v1 && o[f2] == v2 }.first
-  end
+  # Iterate through all field names in a given index by table name
+  # and index name.
+  def each_index_field_name_by_index_name(table_name, index_name)
+    unless block_given?
+      return enum_for(:each_index_field_name_by_index_name,
+                      table_name, index_name)
+    end
 
-  def table_by_id(value)
-    object_by_field(:each_table, "ID", value)
-  end
+    data_dictionary.each_field_by_index_name(table_name, index_name) do |record|
+      yield record["COL_NAME"]
+    end
 
-  def table_by_name(value)
-    object_by_field(:each_table, "NAME", value)
+    nil
   end
 
-  def index_by_id(value)
-    object_by_field(:each_index, "ID", value)
+  # Return the table name given a table ID.
+  def table_name_by_id(table_id)
+    if table_record = data_dictionary.table_by_id(table_id)
+      table_record["NAME"]
+    end
   end
 
-  def index_by_name(table_name, index_name)
-    unless table = table_by_name(table_name)
-      return nil
+  # Return the index name given an index ID.
+  def index_name_by_id(index_id)
+    if index_record = data_dictionary.index_by_id(index_id)
+      index_record["NAME"]
     end
-
-    object_by_two_fields(:each_index,
-                         "TABLE_ID", table["ID"],
-                         "NAME", index_name)
   end
 
-  def add_space(space)
-    @spaces[space.space_id] = space
+  # Return an array of the table name and index name given an index ID.
+  def table_and_index_name_by_id(index_id)
+    if index_record = data_dictionary.index_by_id(index_id)
+      [table_name_by_id(index_record["TABLE_ID"]), index_record["NAME"]]
+    end
   end
 
-  def add_space_file(space_file)
-    add_space(Innodb::Space.new(space_file))
+  # Return an Innodb::Index object given a table name and index name.
+  def index_by_name(table_name, index_name)
+    index_record = data_dictionary.index_by_name(table_name, index_name)
+
+    index_space = space(index_record["SPACE"])
+    describer = data_dictionary.record_describer_by_index_name(table_name, index_name)
+    index = index_space.index(index_record["PAGE_NO"], describer)
+
+    index
   end
 end