innodb_ruby 0.9.0 → 0.9.5

data/lib/innodb/undo_record.rb

@@ -0,0 +1,259 @@
+# -*- encoding : utf-8 -*-
+
+# A single undo log record.
+class Innodb::UndoRecord
+  attr_reader :undo_page
+  attr_reader :position
+
+  attr_accessor :undo_log
+  attr_accessor :index_page
+
+  def initialize(undo_page, position)
+    @undo_page = undo_page
+    @position = position
+
+    @undo_log = nil
+    @index_page = nil
+  end
+
+  def new_subordinate(undo_page, position)
+    new_undo_record = self.class.new(undo_page, position)
+    new_undo_record.undo_log = undo_log
+    new_undo_record.index_page = index_page
+
+    new_undo_record
+  end
+
+  # The header really starts 2 bytes before the undo record position, as the
+  # pointer to the previous record is written there.
+  def pos_header
+    @position - 2
+  end
+
+  # The size of the header.
+  def size_header
+    2 + 2 + 1
+  end
+
+  def pos_record
+    pos_header + size_header
+  end
+
+  # Return a BufferCursor starting before the header.
+  def cursor(position)
+    new_cursor = @undo_page.cursor(position)
+    if @undo_log
+      new_cursor.push_name("undo_log[#{@undo_log.position}]")
+    end
+    new_cursor.push_name("undo_record[#{@position}]")
+    new_cursor
+  end
+
+  # Possible undo record types.
+  TYPE = {
+    11 => :insert,
+    12 => :update_existing,
+    13 => :update_deleted,
+    14 => :delete,
+  }
+
+  TYPE_MASK = 0x0f
+  COMPILATION_INFO_MASK = 0x70
+  COMPILATION_INFO_SHIFT = 4
+  COMPILATION_INFO_NO_ORDER_CHANGE_BV = 1
+  COMPILATION_INFO_NO_SIZE_CHANGE_BV = 2
+  EXTERN_FLAG = 0x80
+
+  def header
+    @header ||= cursor(pos_header).name("header") do |c|
+      header = {
+        :prev => c.name("prev") { c.get_uint16 },
+        :next => c.name("next") { c.get_uint16 },
+      }
+
+      info = c.name("info") { c.get_uint8 }
+      cmpl = (info & COMPILATION_INFO_MASK) >> COMPILATION_INFO_SHIFT
+      header[:type] = TYPE[info & TYPE_MASK]
+      header[:extern_flag] = (info & EXTERN_FLAG) != 0
+      header[:info] = {
+        :order_may_change => (cmpl & COMPILATION_INFO_NO_ORDER_CHANGE_BV) == 0,
+        :size_may_change  => (cmpl & COMPILATION_INFO_NO_SIZE_CHANGE_BV) == 0,
+      }
+
+      header
+    end
+  end
+
+  def type
+    header[:type]
+  end
+
+  def has_previous_version?
+    [:update_existing, :update_deleted, :delete].include?(type)
+  end
+
+  def get(prev_or_next)
+    if header[prev_or_next] != 0
+      new_undo_record = new_subordinate(@undo_page, header[prev_or_next])
+      if new_undo_record.type
+        new_undo_record
+      end
+    end
+  end
+
+  def prev
+    get(:prev)
+  end
+
+  def next
+    get(:next)
+  end
+
+  def record_size
+    header[:next] - @position - size_header
+  end
+
+  def read_record
+    cursor(pos_record).name("record") do |c|
+      this_record = {
+        :page => undo_page.offset,
+        :offset => position,
+        :header => header,
+        :undo_no => c.name("undo_no") { c.get_imc_uint64 },
+        :table_id => c.name("table_id") { c.get_imc_uint64 },
+      }
+
+      if has_previous_version?
+        this_record[:info_bits] = c.name("info_bits") { c.get_uint8 }
+        this_record[:trx_id] = c.name("trx_id") { c.get_ic_uint64 }
+        this_record[:roll_ptr] = c.name("roll_ptr") {
+          Innodb::DataType::RollPointerType.parse_roll_pointer(c.get_ic_uint64)
+        }
+      end
+
+      if index_page
+        read_record_fields(this_record, c)
+      else
+        # Slurp up the remaining data as a string.
+        this_record[:data] = c.get_bytes(header[:next] - c.position - 2)
+      end
+
+      this_record
+    end
+  end
+
+  def read_record_fields(this_record, c)
+    this_record[:key] = []
+    index_page.record_format[:key].each do |field|
+      this_record[:key][field.position] = {
+        :name => field.name,
+        :type => field.data_type.name,
+        :value => c.name(field.name) {
+          field_length = c.name("field_length") { c.get_ic_uint32 }
+          field.value_by_length(c, field_length)
+        }
+      }
+    end
+
+    if has_previous_version?
+      field_count = c.name("field_count") { c.get_ic_uint32 }
+      this_record[:row] = Array.new(index_page.record_format[:row].size)
+      field_count.times do
+        field_number = c.name("field_number[#{field_count}]") { c.get_ic_uint32 }
+        field = nil
+        field_index = nil
+        index_page.record_format[:row].each_with_index do |candidate_field, index|
+          if candidate_field.position == field_number
+            field = candidate_field
+            field_index = index
+          end
+        end
+        raise "Unknown field #{field_number}" unless field
+        this_record[:row][field_index] = {
+          :name => field.name,
+          :type => field.data_type.name,
+          :value => c.name(field.name) {
+            field_length = c.name("field_length") { c.get_ic_uint32 }
+            field.value_by_length(c, field_length)
+          }
+        }
+      end
+    end
+  end
+
+  def undo_record
+    @undo_record ||= read_record
+  end
+
+  def undo_no
+    undo_record[:undo_no]
+  end
+
+  def table_id
+    undo_record[:table_id]
+  end
+
+  def trx_id
+    undo_record[:trx_id]
+  end
+
+  def roll_ptr
+    undo_record[:roll_ptr]
+  end
+
+  def key
+    undo_record[:key]
+  end
+
+  def key_string
+    key && key.map { |r| "%s=%s" % [r[:name], r[:value].inspect] }.join(", ")
+  end
+
+  def row
+    undo_record[:row]
+  end
+
+  def row_string
+    row && row.select { |r| !r.nil? }.map { |r| r && "%s=%s" % [r[:name], r[:value].inspect] }.join(", ")
+  end
+
+  def string
+    "(%s) → (%s)" % [key_string, row_string]
+  end
+
+  # Find the previous row version by following the roll_ptr from one undo
+  # record to the next (backwards through the record version history). Since
+  # we are operating without the benefit of knowing about active transactions
+  # and without protection from purge, check that everything looks sane before
+  # returning it.
+  def prev_by_history
+    unless has_previous_version?
+      # This undo record type has no previous version information.
+      return nil
+    end
+
+    undo_log = roll_ptr[:undo_log]
+    older_undo_page = @undo_page.space.page(undo_log[:page])
+
+    unless older_undo_page and older_undo_page.is_a?(Innodb::Page::UndoLog)
+      # The page was probably re-used for something else.
+      return nil
+    end
+
+    older_undo_record = new_subordinate(older_undo_page,
+                                        undo_log[:offset])
+
+    unless older_undo_record and table_id == older_undo_record.table_id
+      # The record space was probably re-used for something else.
+      return nil
+    end
+
+    unless older_undo_record.trx_id.nil? or trx_id >= older_undo_record.trx_id
+      # The trx_id should not be newer; but may be absent (for insert).
+      return nil
+    end
+
+    older_undo_record
+  end
+
+end

data/lib/innodb/{cursor.rb → util/buffer_cursor.rb}

@@ -2,8 +2,11 @@
 
 require "bindata"
 
-# A cursor to walk through InnoDB data structures to read fields.
-class Innodb::Cursor
+# A cursor to walk through data structures to read fields. The cursor can move
+# forwards, backwards, is seekable, and supports peeking without moving the
+# cursor. The BinData module is used for interpreting bytes as desired.
+class BufferCursor
+  VERSION = "0.9.0"
 
   # An entry in a stack of cursors. The cursor position, direction, and
   # name array are each attributes of the current cursor stack and are
@@ -21,16 +24,24 @@ class Innodb::Cursor
       @name = name || []
     end
 
+    def inspect
+      "<%s direction=%s position=%s>" % [
+        self.class.name,
+        @direction.inspect,
+        @position,
+      ]
+    end
+
     def dup
       StackEntry.new(cursor, position, direction, name.dup)
     end
   end
 
-  @@tracing = false
+  @@global_tracing = false
 
-  # Enable tracing for all Innodb::Cursor objects.
+  # Enable tracing for all BufferCursor objects globally.
   def self.trace!(arg=true)
-    @@tracing = arg
+    @@global_tracing = arg
   end
 
   # Initialize a cursor within a buffer at the given position.
@@ -38,7 +49,22 @@ class Innodb::Cursor
     @buffer = buffer
     @stack = [ StackEntry.new(self, position) ]
 
+    trace false
     trace_with :print_trace
+    trace_to STDOUT
+  end
+
+  def inspect
+    "<%s size=%i current=%s>" % [
+      self.class.name,
+      @buffer.size,
+      current.inspect,
+    ]
+  end
+
+  def trace(arg=true)
+    @instance_tracing = arg
+    self
   end
 
   # Print a trace output for this cursor. The method is passed a cursor object,
@@ -46,7 +72,7 @@ class Innodb::Cursor
   def print_trace(cursor, position, bytes, name)
     slice_size = 16
     bytes.each_slice(slice_size).each_with_index do |slice_bytes, slice_count|
-      puts "%06i %s %-32s  %s" % [
+      @trace_io.puts "%06i %s %-32s  %s" % [
         position + (slice_count * slice_size),
         direction == :backward ? "←" : "→",
         slice_bytes.map { |n| "%02x" % n }.join,
@@ -55,6 +81,11 @@ class Innodb::Cursor
     end
   end
 
+  def trace_to(file)
+    @trace_io = file
+    self
+  end
+
   # Set a Proc or method on self to trace with.
   def trace_with(arg=nil)
     if arg.nil?
@@ -66,11 +97,16 @@ class Innodb::Cursor
     else
       raise "Don't know how to trace with #{arg}"
     end
+    self
+  end
+
+  def tracing_enabled?
+    (@@global_tracing or @instance_tracing) && @trace_proc
   end
 
   # Generate a trace record from the current cursor.
-  def trace(position, bytes, name)
-    @trace_proc.call(self, position, bytes, name) if @@tracing && @trace_proc
+  def record_trace(position, bytes, name)
+    @trace_proc.call(self, position, bytes, name) if tracing_enabled?
   end
 
   # The current cursor object; the top of the stack.
@@ -78,6 +114,14 @@ class Innodb::Cursor
     @stack.last
   end
 
+  def push_name(name_arg)
+    current.name.push name_arg
+  end
+
+  def pop_name
+    current.name.pop
+  end
+
   # Set the field name.
   def name(name_arg=nil)
     if name_arg.nil?
@@ -170,7 +214,7 @@ class Innodb::Cursor
       data = @buffer.slice(current.position, length)
     end
 
-    trace(cursor_start, data.bytes, current.name)
+    record_trace(cursor_start, data.bytes, current.name)
     data
   end
 
@@ -179,6 +223,12 @@ class Innodb::Cursor
     read_and_advance(length)
   end
 
+  # Return a null-terminated string.
+  def get_string(length)
+    BinData::Stringz.read(read_and_advance(length))
+  end
+
+  # Iterate through length bytes returning each as an unsigned 8-bit integer.
   def each_byte_as_uint8(length)
     unless block_given?
       return enum_for(:each_byte_as_uint8, length)
@@ -261,33 +311,89 @@ class Innodb::Cursor
     when 8
       get_uint64
     else
-      raise "Not implemented"
+      raise "Integer size #{size} not implemented"
     end
   end
 
+  # Read an array of count unsigned integers given their size in bytes.
   def get_uint_array_by_size(size, count)
     (0...count).to_a.inject([]) { |a, n| a << get_uint_by_size(size); a }
   end
 
-  # Read an InnoDB-compressed unsigned 32-bit integer.
-  def get_ic_uint32
-    flag = peek { name("ic_uint32") { get_uint8 } }
-
-    case
-    when flag < 0x80
-      name("uint8") { get_uint8 }
-    when flag < 0xc0
-      name("uint16") { get_uint16 } & 0x7fff
-    when flag < 0xe0
-      name("uint24") { get_uint24 } & 0x3fffff
-    when flag < 0xf0
-      name("uint32") { get_uint32 } & 0x1fffffff
-    when flag == 0xf0
-      adjust(+1) # Skip the flag.
-      name("uint32+1") { get_uint32 }
-    else
-      raise "Invalid flag #{flag.to_s} seen"
-    end
+  # Read an InnoDB-compressed unsigned 32-bit integer (1-5 bytes).
+  #
+  # The first byte makes up part of the value stored as well as indicating
+  # the number of bytes stored, maximally an additional 4 bytes after the
+  # flag for integers >= 0xf0000000.
+  #
+  # Optionally accept a flag (first byte) if it has already been read (as is
+  # the case in get_imc_uint64).
+  def get_ic_uint32(flag=nil)
+    name("ic_uint32") {
+      if !flag
+        flag = peek { name("uint8_or_flag") { get_uint8 } }
+      end
+
+      case
+      when flag < 0x80
+        adjust(+1)
+        flag
+      when flag < 0xc0
+        name("uint16") { get_uint16 } & 0x7fff
+      when flag < 0xe0
+        name("uint24") { get_uint24 } & 0x3fffff
+      when flag < 0xf0
+        name("uint32") { get_uint32 } & 0x1fffffff
+      when flag == 0xf0
+        adjust(+1) # Skip the flag byte.
+        name("uint32+1") { get_uint32 }
+      else
+        raise "Invalid flag #{flag.to_s} seen"
+      end
+    }
+  end
+
+  # Read an InnoDB-compressed unsigned 64-bit integer (5-9 bytes).
+  #
+  # The high 32 bits are stored as an InnoDB-compressed unsigned 32-bit
+  # integer (1-5 bytes) while the low 32 bits are stored as a standard
+  # big-endian 32-bit integer (4 bytes). This makes a combined size of
+  # between 5 and 9 bytes.
+  def get_ic_uint64
+    name("ic_uint64") {
+      high = name("high") { get_ic_uint32 }
+      low  = name("low")  { name("uint32") { get_uint32 } }
+
+      (high << 32) | low
+    }
+  end
+
+  # Read an InnoDB-"much compressed" unsigned 64-bit integer (1-11 bytes).
+  #
+  # If the first byte is 0xff, this indicates that the high 32 bits are
+  # stored immediately afterwards as an InnoDB-compressed 32-bit unsigned
+  # integer. If it is any other value it represents the first byte (which
+  # is also a flag) of the low 32 bits of the value, also as an InnoDB-
+  # compressed 32-bit unsigned integer. This makes for a combined size
+  # of between 1 and 11 bytes.
+  def get_imc_uint64
+    name("imc_uint64") {
+      high = 0
+      flag = peek { name("uint8_or_flag") { get_uint8 } }
+
+      if flag == 0xff
+        # The high 32-bits are stored first as an ic_uint32.
+        adjust(+1) # Skip the flag byte.
+        high = name("high") { get_ic_uint32 }
+        flag = nil
+      end
+
+      # The low 32-bits are stored as an ic_uint32; pass the flag we already
+      # read, so we don't have to read it again.
+      low = name("low") { get_ic_uint32(flag) }
+
+      (high << 32) | low
+    }
   end
 
   # Read an array of 1-bit integers.