innodb_ruby 0.7.11 → 0.7.12

data/lib/innodb/field.rb

@@ -1,75 +1,49 @@
+# -*- encoding : utf-8 -*-
+require "innodb/field_type"
+
 # A single field in an InnoDB record (within an INDEX page). This class
-# provides essential information to parse records: the length of the fixed
-# width portion of the field
+# provides essential information to parse records, including the length
+# of the fixed-width and variable-width portion of the field.
 class Innodb::Field
-  attr_reader :position, :nullable, :fixed_len, :variable_len
-
-  def initialize(position, type, *properties)
-    @position = position
-    @type, @fixed_len, @variable_len = parse_data_type(type.to_s)
-    @nullable = (not properties.include?(:NOT_NULL))
-    @unsigned = properties.include?(:UNSIGNED)
-  end
+  attr_reader :position, :type
 
-  # Parse the data type description string of a field.
-  def parse_data_type(data_type)
-    case data_type
-    when /^(tinyint|smallint|mediumint|int|bigint)$/i
-      type = data_type.upcase.to_sym
-      fixed_len = fixed_len_map[type]
-      [type, fixed_len, 0]
-    when /^varchar\((\d+)\)$/i
-      [:VARCHAR, 0, $1.to_i]
-    when /^char\((\d+)\)$/i
-      [:CHAR, $1.to_i, 0]
-    else
-      raise "Data type '#{data_type}' is not supported"
-    end
-  end
+  # Size of a reference to data stored externally to the page.
+  EXTERN_FIELD_SIZE = 20
 
-  # Maps data type to fixed storage length.
-  def fixed_len_map
-    {
-      :TINYINT    => 1,
-      :SMALLINT   => 2,
-      :MEDIUMINT  => 3,
-      :INT        => 4,
-      :BIGINT     => 8,
-    }
+  def initialize(position, data_type, *properties)
+    @position = position
+    @type = Innodb::FieldType.new(data_type.to_s, properties)
   end
 
   # Return whether this field is NULL.
   def null?(record)
-    case record[:format]
-    when :compact
-      header = record[:header]
-      header[:null_bitmap][@position]
-    end
+    type.nullable? && record[:header][:field_nulls][position]
+  end
+
+  # Return whether a part of this field is stored externally (off-page).
+  def extern?(record)
+    record[:header][:field_externs][position]
   end
 
-  # Return the length of this variable-length field.
-  def get_variable_len(record)
-    case record[:format]
-    when :compact
-      header = record[:header]
-      header[:variable_length][@position]
+  # Return the actual length of this variable-length field.
+  def length(record)
+    if type.variable?
+      len = record[:header][:field_lengths][position]
+    else
+      len = type.length
     end
+    extern?(record) ? len - EXTERN_FIELD_SIZE : len
   end
 
   # Read an InnoDB encoded data field.
   def read(record, cursor)
-    return :NULL if @nullable and null?(record)
+    return :NULL if null?(record)
+    cursor.name(type.name) { type.reader.read(cursor, length(record)) }
+  end
 
-    case @type
-    when :TINYINT, :SMALLINT, :MEDIUMINT, :INT, :BIGINT
-      symbol = @unsigned ? :get_uint_by_size : :get_i_sint_by_size
-      cursor.send(symbol, @fixed_len)
-    when :VARCHAR
-      cursor.get_bytes(get_variable_len(record))
-    when :CHAR
-      # Fixed-width character fields will be space-padded up to their length,
-      # so SQL defines that trailing spaces should be removed.
-      cursor.get_bytes(fixed_len).sub(/[ ]+$/, "")
-    end
+  # Read an InnoDB external pointer field.
+  def read_extern(record, cursor)
+    return nil if not extern?(record)
+    cursor.name(type.name) { type.reader.read_extern(cursor) }
   end
 end

data/lib/innodb/field_type.rb

@@ -0,0 +1,124 @@
+# -*- encoding : utf-8 -*-
+class Innodb::FieldType
+  class GenericType
+    attr_reader :type
+
+    def initialize(type)
+      @type = type
+    end
+
+    def read(cursor, length)
+      cursor.get_bytes(length)
+    end
+
+    def read_extern(cursor)
+      cursor.name("extern") { get_extern_field(cursor) }
+    end
+
+    # Return an external reference field. An extern field contains the page
+    # address and the length of the externally stored part of the record data.
+    def get_extern_field(cursor)
+      {
+        :space_id     => cursor.name("space_id")    { cursor.get_uint32 },
+        :page_number  => cursor.name("page_number") { cursor.get_uint32 },
+        :offset       => cursor.name("offset")      { cursor.get_uint32 },
+        :length       => cursor.name("length")      { cursor.get_uint64 & 0x3fffffff }
+      }
+    end
+  end
+
+  class IntegerType < GenericType
+    def read(cursor, length)
+      method = type.unsigned? ? :get_uint_by_size : :get_i_sint_by_size
+      cursor.send(method, type.length)
+    end
+  end
+
+  class VariableStringType < GenericType
+    def read(cursor, length)
+      # The SQL standard defines that VARCHAR fields should have end-spaces
+      # stripped off.
+      super.sub(/[ ]+$/, "")
+    end
+  end
+
+  # Maps data type to fixed storage length.
+  TYPES = {
+    :TINYINT    => { :class => IntegerType, :length => 1 },
+    :SMALLINT   => { :class => IntegerType, :length => 2 },
+    :MEDIUMINT  => { :class => IntegerType, :length => 3 },
+    :INT        => { :class => IntegerType, :length => 4 },
+    :INT6       => { :class => IntegerType, :length => 6 },
+    :BIGINT     => { :class => IntegerType, :length => 8 },
+    :CHAR       => { :class => GenericType },
+    :VARCHAR    => { :class => VariableStringType },
+    :BLOB       => { :class => GenericType },
+  }
+
+  def self.parse_base_type_and_modifiers(type_string)
+    if matches = /^([a-zA-Z0-9]+)(\(([0-9, ]+)\))?$/.match(type_string)
+      base_type = matches[1].upcase.to_sym
+      if matches[3]
+        modifiers = matches[3].sub(/[ ]/, "").split(/,/).map { |s| s.to_i }
+      else
+        modifiers = []
+      end
+      [base_type, modifiers]
+    end
+  end
+
+  attr_reader :base_type
+  attr_reader :length
+  attr_reader :reader
+  def initialize(type_string, properties)
+    @base_type, modifiers = self.class.parse_base_type_and_modifiers(type_string)
+    @length = nil
+    @nullable = !properties.include?(:NOT_NULL)
+    @unsigned = properties.include?(:UNSIGNED)
+    @variable = false
+    @blob = false
+    case
+    when TYPES[base_type][:class] == IntegerType
+      @length = TYPES[base_type][:length]
+    when base_type == :CHAR
+      @length = modifiers[0]
+    when base_type == :VARCHAR
+      @length = modifiers[0]
+      @variable = true
+    when base_type == :BLOB
+      @blob = true
+      @variable = true
+    else
+      raise "Data type '#{type_string}' is not supported"
+    end
+    @reader = TYPES[base_type][:class].new(self)
+  end
+
+  def unsigned?
+    @unsigned
+  end
+
+  def nullable?
+    @nullable
+  end
+
+  def variable?
+    @variable
+  end
+
+  def blob?
+    @blob
+  end
+
+  def name_suffix
+    if [:CHAR, :VARCHAR].include?(base_type)
+      "(#{length})"
+    else
+      ""
+    end
+  end
+
+  def name
+    "#{base_type}#{name_suffix}"
+  end
+end

data/lib/innodb/fseg_entry.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 # An InnoDB file segment entry, which appears in a few places, such as the
 # FSEG header of INDEX pages, and in the TRX_SYS pages.
 class Innodb::FsegEntry
@@ -8,18 +9,20 @@ class Innodb::FsegEntry
   # Return the FSEG entry address, which points to an entry on an INODE page.
   def self.get_entry_address(cursor)
     {
-      :space_id     => cursor.get_uint32,
-      :page_number  => cursor.get_uint32,
-      :offset       => cursor.get_uint16,
+      :space_id     => cursor.name("space_id")    { cursor.get_uint32 },
+      :page_number  => cursor.name("page_number") {
+        Innodb::Page.maybe_undefined(cursor.get_uint32)
+      },
+      :offset       => cursor.name("offset")      { cursor.get_uint16 },
     }
   end
 
   # Return an INODE entry which represents this file segment.
   def self.get_inode(space, cursor)
-    address = get_entry_address(cursor)
+    address = cursor.name("address") { get_entry_address(cursor) }
     page = space.page(address[:page_number])
     if page.type == :INODE
-      page.inode_at(address[:offset])
+      page.inode_at(page.cursor(address[:offset]))
     end
   end
-end
+end

data/lib/innodb/index.rb

@@ -1,13 +1,17 @@
+# -*- encoding : utf-8 -*-
 # An InnoDB index B-tree, given an Innodb::Space and a root page number.
 class Innodb::Index
   attr_reader :root
   attr_reader :stats
   attr_accessor :debug
+  attr_accessor :record_describer
 
-  def initialize(space, root_page_number)
-    @space = space
-    @root = @space.page(root_page_number)
+  def initialize(space, root_page_number, record_describer=nil)
     @debug = false
+    @space = space
+    @record_describer = record_describer || space.record_describer
+
+    @root = page(root_page_number)
 
     unless @root
       raise "Page #{root_page_number} couldn't be read"
@@ -26,6 +30,12 @@ class Innodb::Index
     reset_stats
   end
 
+  def page(page_number)
+    page = @space.page(page_number)
+    page.record_describer = @record_describer
+    page
+  end
+
   def reset_stats
     @stats = Hash.new(0)
   end
@@ -53,7 +63,7 @@ class Innodb::Index
     end
 
     parent_page.each_child_page do |child_page_number, child_min_key|
-      child_page = @space.page(child_page_number)
+      child_page = page(child_page_number)
       child_page.record_describer = @space.record_describer
       if child_page.type == :INDEX
         if link_proc
@@ -76,7 +86,7 @@ class Innodb::Index
     page = @root
     record = @root.first_record
     while record && page.level > level
-      page = @space.page(record[:child_page_number])
+      page = page(record[:child_page_number])
       record = page.first_record
     end
     page if page.level == level
@@ -104,8 +114,8 @@ class Innodb::Index
       return enum_for(:each_fseg_list, fseg)
     end
 
-    [:full, :not_full, :free].each do |list_name|
-      yield list_name, fseg[list_name] if fseg[list_name].is_a?(Innodb::List)
+    fseg.each_list do |list_name, list|
+      yield list_name, list
     end
   end
 
@@ -115,8 +125,8 @@ class Innodb::Index
       return enum_for(:each_fseg_frag_page, fseg)
     end
 
-    fseg[:frag_array].each do |page_number|
-      yield page_number, @space.page(page_number) if page_number
+    fseg.frag_array_pages.each do |page_number|
+      yield page_number, page(page_number)
     end
   end
 
@@ -128,7 +138,8 @@ class Innodb::Index
 
     while page && page.type == :INDEX
       yield page
-      page = @space.page(page.next)
+      break unless page.next
+      page = page(page.next)
     end
   end
 
@@ -334,7 +345,7 @@ class Innodb::Index
       if page.level > 0
         # If we haven't reached a leaf page yet, move down the tree and search
         # again using linear search.
-        page = @space.page(rec[:child_page_number])
+        page = page(rec[:child_page_number])
       else
         # 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
@@ -367,7 +378,7 @@ class Innodb::Index
       if page.level > 0
         # If we haven't reached a leaf page yet, move down the tree and search
         # again using binary search.
-        page = @space.page(rec[:child_page_number])
+        page = page(rec[:child_page_number])
       else
         # 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

data/lib/innodb/inode.rb

@@ -0,0 +1,133 @@
+# -*- encoding : utf-8 -*-
+class Innodb::Inode
+  # The number of "slots" (each representing one page) in the fragment array
+  # within each Inode entry.
+  FRAG_ARRAY_N_SLOTS  = 32 # FSP_EXTENT_SIZE / 2
+
+  # The size (in bytes) of each slot in the fragment array.
+  FRAG_SLOT_SIZE      = 4
+
+  # A magic number which helps determine if an Inode structure is in use
+  # and populated with valid data.
+  MAGIC_N_VALUE	= 97937874
+
+  # The size (in bytes) of an Inode entry.
+  SIZE = (16 + (3 * Innodb::List::BASE_NODE_SIZE) +
+    (FRAG_ARRAY_N_SLOTS * FRAG_SLOT_SIZE))
+
+  # Read an array of page numbers (32-bit integers, which may be nil) from
+  # the provided cursor.
+  def self.page_number_array(size, cursor)
+    size.times.map do |n|
+      cursor.name("page[#{n}]") do |c|
+        Innodb::Page.maybe_undefined(c.get_uint32)
+      end
+    end
+  end
+
+  # Construct a new Inode by reading an FSEG header from a cursor.
+  def self.new_from_cursor(space, cursor)
+    data = {
+      :fseg_id => cursor.name("fseg_id") {
+        cursor.get_uint64
+      },
+      :not_full_n_used => cursor.name("not_full_n_used") {
+        cursor.get_uint32
+      },
+      :free => cursor.name("list[free]") { 
+        Innodb::List::Xdes.new(space, Innodb::List.get_base_node(cursor))
+      },
+      :not_full => cursor.name("list[not_full]") { 
+        Innodb::List::Xdes.new(space, Innodb::List.get_base_node(cursor))
+      },
+      :full => cursor.name("list[full]") { 
+        Innodb::List::Xdes.new(space, Innodb::List.get_base_node(cursor))
+      },
+      :magic_n => cursor.name("magic_n") {
+        cursor.get_uint32
+      },
+      :frag_array => cursor.name("frag_array") { 
+        page_number_array(FRAG_ARRAY_N_SLOTS, cursor)
+      },
+    }
+
+    Innodb::Inode.new(space, data)
+  end
+
+  attr_accessor :space
+
+  def initialize(space, data)
+    @space = space
+    @data = data
+  end
+
+  def fseg_id;          @data[:fseg_id];          end
+  def not_full_n_used;  @data[:not_full_n_used];  end
+  def free;             @data[:free];             end
+  def not_full;         @data[:not_full];         end
+  def full;             @data[:full];             end
+  def magic_n;          @data[:magic_n];          end
+  def frag_array;       @data[:frag_array];       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?
+    fseg_id != 0
+  end
+
+  # Helper method to return an array of only non-nil fragment pages.
+  def frag_array_pages
+    frag_array.select { |n| ! n.nil? }
+  end
+
+  # Helper method to count non-nil fragment pages.
+  def frag_array_n_used
+    frag_array.inject(0) { |n, i| n += 1 if i; n }
+  end
+
+  # Calculate the total number of pages in use (not free) within this fseg.
+  def used_pages
+    frag_array_n_used + not_full_n_used
+      (full.length * @space.pages_per_extent)
+  end
+
+  # Calculate the total number of pages within this fseg.
+  def total_pages
+    frag_array_n_used +
+      (free.length * @space.pages_per_extent) +
+      (not_full.length * @space.pages_per_extent) +
+      (full.length * @space.pages_per_extent)
+  end
+
+  # Calculate the fill factor of this fseg, in percent.
+  def fill_factor
+    total_pages > 0 ? 100.0 * (used_pages.to_f / total_pages.to_f) : 0.0
+  end
+
+  # Return an array of lists within an fseg.
+  def lists
+    [:free, :not_full, :full]
+  end
+
+  # Return a list from the fseg, given its name as a symbol.
+  def list(name)
+    @data[name] if lists.include? name
+  end
+
+  # Iterate through all lists, yielding the list name and the list itself.
+  def each_list
+    lists.each do |name|
+      yield name, list(name)
+    end
+  end
+
+  # Compare one Innodb::Inode to another.
+  def ==(other)
+    fseg_id == other.fseg_id
+  end
+
+  # Dump a summary of this object for debugging purposes.
+  def dump
+    pp @data
+  end
+end