innodb_ruby 0.9.0 → 0.9.5

data/lib/innodb.rb

@@ -14,7 +14,10 @@ module Innodb
   end
 end
 
+require "pp"
 require "enumerator"
+require "innodb/util/buffer_cursor"
+require "innodb/util/read_bits_at_offset"
 
 require "innodb/version"
 require "innodb/stats"
@@ -33,9 +36,16 @@ require "innodb/record"
 require "innodb/field"
 require "innodb/space"
 require "innodb/system"
+require "innodb/history"
+require "innodb/history_list"
 require "innodb/inode"
 require "innodb/index"
+require "innodb/log_record"
 require "innodb/log_block"
 require "innodb/log"
+require "innodb/lsn"
+require "innodb/log_group"
+require "innodb/log_reader"
 require "innodb/undo_log"
+require "innodb/undo_record"
 require "innodb/xdes"

data/lib/innodb/data_dictionary.rb

@@ -437,7 +437,7 @@ class Innodb::DataDictionary
     end
 
     unless table = table_by_name(table_name)
-      raise "Table not found"
+      raise "Table #{table_name} not found"
     end
 
     each_index_by_table_id(table["ID"]) do |record|
@@ -467,7 +467,7 @@ class Innodb::DataDictionary
     end
 
     unless index = index_by_name(table_name, index_name)
-      raise "Index not found"
+      raise "Index #{index_name} for table #{table_name} not found"
     end
 
     each_field_by_index_id(index["ID"]) do |record|
@@ -497,7 +497,7 @@ class Innodb::DataDictionary
     end
 
     unless table = table_by_name(table_name)
-      raise "Table not found"
+      raise "Table #{table_name} not found"
     end
 
     each_column_by_table_id(table["ID"]) do |record|
@@ -543,7 +543,7 @@ class Innodb::DataDictionary
   # for a given table name.
   def clustered_index_name_by_table_name(table_name)
     unless table_record = table_by_name(table_name)
-      raise "Table not found"
+      raise "Table #{table_name} not found"
     end
 
     if index_record = object_by_two_fields(:each_index,
@@ -576,7 +576,7 @@ class Innodb::DataDictionary
     end
 
     unless index = index_by_name(table_name, index_name)
-      raise "Index not found"
+      raise "Index #{index_name} for table #{table_name} not found"
     end
 
     columns_in_index = {}
@@ -606,7 +606,7 @@ class Innodb::DataDictionary
   # index by table name and index name.
   def record_describer_by_index_name(table_name, index_name)
     unless index = index_by_name(table_name, index_name)
-      raise "Index not found"
+      raise "Index #{index_name} for table #{table_name} not found"
     end
 
     describer = Innodb::RecordDescriber.new
@@ -633,11 +633,11 @@ class Innodb::DataDictionary
   # in a given index by index ID.
   def record_describer_by_index_id(index_id)
     unless index = index_by_id(index_id)
-      raise "Index not found"
+      raise "Index #{index_id} not found"
     end
 
     unless table = table_by_id(index["TABLE_ID"])
-      raise "Table not found"
+      raise "Table #{INDEX["TABLE_ID"]} not found"
     end
 
     record_describer_by_index_name(table["NAME"], index["NAME"])

data/lib/innodb/data_type.rb

@@ -317,6 +317,53 @@ class Innodb::DataType
     end
   end
 
+  #
+  # Data types for InnoDB system columns.
+  #
+
+  # Transaction ID.
+  class TransactionIdType
+    attr_reader :name, :width
+
+    def initialize(base_type, modifiers, properties)
+      @width = 6
+      @name = Innodb::DataType.make_name(base_type, modifiers, properties)
+    end
+
+    def read(c)
+      c.name("transaction_id") { c.get_hex(6) }
+    end
+  end
+
+  # Rollback data pointer.
+  class RollPointerType
+    extend ReadBitsAtOffset
+
+    attr_reader :name, :width
+
+    def initialize(base_type, modifiers, properties)
+      @width = 7
+      @name = Innodb::DataType.make_name(base_type, modifiers, properties)
+    end
+
+    def self.parse_roll_pointer(roll_ptr)
+      {
+        :is_insert  => read_bits_at_offset(roll_ptr, 1, 55) == 1,
+        :rseg_id    => read_bits_at_offset(roll_ptr, 7, 48),
+        :undo_log   => {
+          :page   => read_bits_at_offset(roll_ptr, 32, 16),
+          :offset => read_bits_at_offset(roll_ptr, 16, 0),
+        }
+      }
+    end
+
+    def value(data)
+      roll_ptr = BinData::Uint56be.read(data)
+      self.class.parse_roll_pointer(roll_ptr)
+    end
+
+  end
+
   # Maps base type to data type class.
   TYPES = {
     :BIT        => BitType,
@@ -349,6 +396,8 @@ class Innodb::DataType
     :DATE       => DateType,
     :DATETIME   => DatetimeType,
     :TIMESTAMP  => TimestampType,
+    :TRX_ID     => TransactionIdType,
+    :ROLL_PTR   => RollPointerType,
   }
 
   def self.make_name(base_type, modifiers, properties)

data/lib/innodb/field.rb

@@ -26,12 +26,12 @@ class Innodb::Field
 
   # Return whether this field is NULL.
   def null?(record)
-    nullable? && record[:header][:field_nulls][position]
+    nullable? && record[:header][:nulls].include?(@name)
   end
 
   # Return whether a part of this field is stored externally (off-page).
   def extern?(record)
-    record[:header][:field_externs][position]
+    record[:header][:externs].include?(@name)
   end
 
   def variable?
@@ -46,8 +46,9 @@ class Innodb::Field
 
   # Return the actual length of this variable-length field.
   def length(record)
-    if variable?
-      len = record[:header][:field_lengths][position]
+    if record[:header][:lengths].include?(@name)
+      len = record[:header][:lengths][@name]
+      raise "Fixed-length mismatch" unless variable? || len == @data_type.width
     else
       len = @data_type.width
     end
@@ -55,19 +56,28 @@ class Innodb::Field
   end
 
   # Read an InnoDB encoded data field.
-  def read(record, cursor)
-    cursor.name(@data_type.name) { cursor.get_bytes(length(record)) }
+  def read(cursor, field_length)
+    cursor.name(@data_type.name) { cursor.get_bytes(field_length) }
+  end
+
+  def value_by_length(cursor, field_length)
+    if @data_type.respond_to?(:read)
+      cursor.name(@data_type.name) { @data_type.read(cursor) }
+    elsif @data_type.respond_to?(:value)
+      @data_type.value(read(cursor, field_length))
+    else
+      read(cursor, field_length)
+    end
   end
 
   # Read the data value (e.g. encoded in the data).
-  def value(record, cursor)
+  def value(cursor, record)
     return :NULL if null?(record)
-    data = read(record, cursor)
-    @data_type.respond_to?(:value) ? @data_type.value(data) : data
+    value_by_length(cursor, length(record))
   end
 
   # Read an InnoDB external pointer field.
-  def extern(record, cursor)
+  def extern(cursor, record)
     return nil if not extern?(record)
     cursor.name(@name) { read_extern(cursor) }
   end
@@ -91,7 +101,7 @@ class Innodb::Field
 
   # Parse a data type definition and extract the base type and any modifiers.
   def parse_type_definition(type_string)
-    if matches = /^([a-zA-Z0-9]+)(\(([0-9, ]+)\))?$/.match(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 }

data/lib/innodb/history.rb

@@ -0,0 +1,30 @@
+# -*- encoding : utf-8 -*-
+
+# The global history of record versions implemented through undo logs.
+class Innodb::History
+  def initialize(innodb_system)
+    @innodb_system = innodb_system
+  end
+
+  # A helper to get to the trx_sys page in the Innodb::System.
+  def trx_sys
+    @innodb_system.system_space.trx_sys
+  end
+
+  # A helper to get to the history_list of a given space_id and page number.
+  def history_list(space_id, page_number)
+    @innodb_system.space(space_id).page(page_number).history_list
+  end
+
+  # Iterate through all history lists (one per rollback segment, nominally
+  # there are 128 rollback segments).
+  def each_history_list
+    unless block_given?
+      return enum_for(:each_history_list)
+    end
+
+    trx_sys.rsegs.each do |slot|
+      yield history_list(slot[:space_id], slot[:page_number])
+    end
+  end
+end

data/lib/innodb/history_list.rb

@@ -0,0 +1,106 @@
+# -*- encoding : utf-8 -*-
+
+# A single history list; this is a more intelligent wrapper around the basic
+# Innodb::List::History which is provided elsewhere.
+class Innodb::HistoryList
+  attr_reader :list
+
+  # Initialize from a provided Innodb::List::History.
+  def initialize(list)
+    @list = list
+  end
+
+  class UndoRecordCursor
+    def initialize(history, undo_record, direction=:forward)
+      @history = history
+      @undo_record = undo_record
+
+      case undo_record
+      when :min
+        @undo_log_cursor = history.list.list_cursor(:min, direction)
+        if @undo_log = @undo_log_cursor.node
+          @undo_record_cursor = @undo_log.undo_record_cursor(:min, direction)
+        end
+      when :max
+        @undo_log_cursor = history.list.list_cursor(:max, direction)
+        if @undo_log = @undo_log_cursor.node
+          @undo_record_cursor = @undo_log.undo_record_cursor(:max, direction)
+        end
+      else
+        raise "Not implemented"
+      end
+    end
+
+    def undo_record
+      unless @undo_record_cursor
+        return nil
+      end
+
+      if rec = @undo_record_cursor.undo_record
+        return rec
+      end
+
+      case @direction
+      when :forward
+        next_undo_record
+      when :backward
+        prev_undo_record
+      end
+    end
+
+    def move_cursor(page, undo_record)
+      @undo_log = page
+      @undo_log_cursor = @undo_log.undo_record_cursor(undo_record, @direction)
+    end
+
+    def next_undo_record
+      if rec = @undo_record_cursor.undo_record
+        return rec
+      end
+
+      if undo_log = @undo_log_cursor.node
+        @undo_log = undo_log
+        @undo_record_cursor = @undo_log.undo_record_cursor(:min, @direction)
+      end
+
+      @undo_record_cursor.undo_record
+    end
+
+    def prev_undo_record
+      if rec = @undo_log_cursor.undo_record
+        return rec
+      end
+
+      if undo_log = @undo_log_cursor.node
+        @undo_log = undo_log
+        @undo_record_cursor = @undo_log.undo_record_cursor(:max, @direction)
+      end
+
+      @undo_record_cursor.undo_record
+    end
+
+    def each_undo_record
+      unless block_given?
+        return enum_for(:each_undo_record)
+      end
+
+      while rec = undo_record
+        yield rec
+      end
+    end
+  end
+
+  def undo_record_cursor(undo_record=:min, direction=:forward)
+    UndoRecordCursor.new(self, undo_record, direction)
+  end
+
+  def each_undo_record
+    unless block_given?
+      return enum_for(:each_undo_record)
+    end
+
+    undo_record_cursor.each_undo_record do |rec|
+      yield rec
+    end
+  end
+end

data/lib/innodb/index.rb

@@ -261,7 +261,6 @@ class Innodb::Index
   class IndexCursor
     def initialize(index, record, direction)
       Innodb::Stats.increment :index_cursor_create
-      @initial = true
       @index = index
       @direction = direction
       case record
@@ -278,66 +277,12 @@ class Innodb::Index
         @page = record.page
         @page_cursor = @page.record_cursor(record.offset, direction)
       end
-      @record = @page_cursor.record
-    end
-
-    # Return the current record, mostly as a helper.
-    def current_record
-      @record
-    end
-
-    # Move to the next record in the forward direction and return it.
-    def next_record
-      Innodb::Stats.increment :index_cursor_next_record
-
-      while true
-        if rec = @page_cursor.record
-          return rec
-        end
-
-        unless next_page = @page.next
-          return nil
-        end
-
-        unless @page = @index.page(next_page)
-          raise "Failed to load next page"
-        end
-
-        unless @page_cursor = @page.record_cursor(:min, @direction)
-          raise "Failed to position cursor"
-        end
-      end
-    end
-
-    # Move to the previous record in the backward direction and return it.
-    def prev_record
-      Innodb::Stats.increment :index_cursor_prev_record
-
-      while true
-        if rec = @page_cursor.record
-          return rec
-        end
-
-        unless prev_page = @page.prev
-          return nil
-        end
-
-        unless @page = @index.page(prev_page)
-          raise "Failed to load prev page"
-        end
-
-        unless @page_cursor = @page.record_cursor(:max, @direction)
-          raise "Failed to position cursor"
-        end
-      end
-      raise "Not implemented"
     end
 
     # Return the next record in the order defined when the cursor was created.
     def record
-      if @initial
-        @initial = false
-        return current_record
+      if rec = @page_cursor.record
+        return rec
       end
 
       case @direction
@@ -358,6 +303,53 @@ class Innodb::Index
         yield rec
       end
     end
+
+    private
+
+    # Move the cursor to a new starting position in a given page.
+    def move_cursor(page, record)
+      unless @page = @index.page(page)
+        raise "Failed to load page"
+      end
+
+      unless @page_cursor = @page.record_cursor(record, @direction)
+        raise "Failed to position cursor"
+      end
+    end
+
+    # Move to the next record in the forward direction and return it.
+    def next_record
+      Innodb::Stats.increment :index_cursor_next_record
+
+      if rec = @page_cursor.record
+        return rec
+      end
+
+      unless next_page = @page.next
+        return nil
+      end
+
+      move_cursor(next_page, :min)
+
+      @page_cursor.record
+    end
+
+    # Move to the previous record in the backward direction and return it.
+    def prev_record
+      Innodb::Stats.increment :index_cursor_prev_record
+
+      if rec = @page_cursor.record
+        return rec
+      end
+
+      unless prev_page = @page.prev
+        return nil
+      end
+
+      move_cursor(prev_page, :max)
+
+      @page_cursor.record
+    end
   end
 
   # Return an IndexCursor starting at the given record (an Innodb::Record,