innodb_ruby 0.9.16 → 0.11.0

data/lib/innodb/undo_log.rb

@@ -1,134 +1,156 @@
-# -*- encoding : utf-8 -*-
-
-class Innodb::UndoLog
-  attr_reader :page
-  attr_reader :position
-  def initialize(page, position)
-    @page = page
-    @position = position
-  end
-
-  def size_xa_header
-    4 + 4 + 4 + 128
-  end
+# frozen_string_literal: true
+
+module Innodb
+  class UndoLog
+    Header = Struct.new(
+      :trx_id,
+      :trx_no,
+      :delete_mark_flag,
+      :log_start_offset,
+      :xid_flag,
+      :ddl_flag,
+      :ddl_table_id,
+      :next_log_offset,
+      :prev_log_offset,
+      :history_list_node,
+      :xid,
+      keyword_init: true
+    )
+
+    HeaderXid = Struct.new(
+      :format,
+      :trid_len,
+      :bqual_len,
+      :data,
+      keyword_init: true
+    )
+
+    attr_reader :page
+    attr_reader :position
+
+    def initialize(page, position)
+      @page = page
+      @position = position
+    end
 
-  def size_header
-    8 + 8 + 2 + 2 + 1 + 1 + 8 + 2 + 2 + Innodb::List::NODE_SIZE + size_xa_header
-  end
+    def size_xa_header
+      4 + 4 + 4 + 128
+    end
 
-  def header
-    @header ||= page.cursor(@position).name("header") do |c|
-      xid_flag = nil
-      {
-        :trx_id => c.name("trx_id") { c.get_uint64 },
-        :trx_no => c.name("trx_no") { c.get_uint64 },
-        :delete_mark_flag => c.name("delete_mark_flag") { (c.get_uint16 != 0) },
-        :log_start_offset => c.name("log_start_offset") { c.get_uint16 },
-        :xid_flag => c.name("xid_flag") { xid_flag = (c.get_uint8 != 0) },
-        :ddl_flag => c.name("ddl_flag") { (c.get_uint8 != 0) },
-        :ddl_table_id => c.name("ddl_table_id") { c.get_uint64 },
-        :next_log_offset => c.name("next_log_offset") { c.get_uint16 },
-        :prev_log_offset => c.name("prev_log_offset") { c.get_uint16 },
-        :history_list_node => c.name("history_list_node") {
-          Innodb::List.get_node(c)
-        },
-        :xid => c.name("xid") {
-          if xid_flag
-            {
-              :format => c.name("format") { c.get_uint32 },
-              :trid_len => c.name("trid_len") { c.get_uint32 },
-              :bqual_len => c.name("bqual_len") { c.get_uint32 },
-              :data => c.name("data") { c.get_bytes(128) },
-            }
-          end
-        },
-      }
+    def size_header
+      8 + 8 + 2 + 2 + 1 + 1 + 8 + 2 + 2 + Innodb::List::NODE_SIZE + size_xa_header
     end
-  end
 
-  def prev_address
-    header[:history_list_node][:prev]
-  end
+    def header
+      @header ||= page.cursor(@position).name("header") do |c|
+        header = Header.new(
+          trx_id: c.name("trx_id") { c.read_uint64 },
+          trx_no: c.name("trx_no") { c.read_uint64 },
+          delete_mark_flag: c.name("delete_mark_flag") { (c.read_uint16 != 0) },
+          log_start_offset: c.name("log_start_offset") { c.read_uint16 },
+          xid_flag: c.name("xid_flag") { (c.read_uint8 != 0) },
+          ddl_flag: c.name("ddl_flag") { (c.read_uint8 != 0) },
+          ddl_table_id: c.name("ddl_table_id") { c.read_uint64 },
+          next_log_offset: c.name("next_log_offset") { c.read_uint16 },
+          prev_log_offset: c.name("prev_log_offset") { c.read_uint16 },
+          history_list_node: c.name("history_list_node") { Innodb::List.get_node(c) }
+        )
+
+        if header.xid_flag
+          header.xid = c.name("xid") do
+            HeaderXid.new(
+              format: c.name("format") { c.read_uint32 },
+              trid_len: c.name("trid_len") { c.read_uint32 },
+              bqual_len: c.name("bqual_len") { c.read_uint32 },
+              data: c.name("data") { c.read_bytes(128) }
+            )
+          end
+        end
 
-  def next_address
-    header[:history_list_node][:next]
-  end
+        header
+      end
+    end
 
-  def undo_record(offset)
-    new_undo_record = Innodb::UndoRecord.new(page, offset)
-    new_undo_record.undo_log = self
-    new_undo_record
-  end
+    def prev_address
+      header.history_list_node.prev
+    end
 
-  def min_undo_record
-    undo_record(header[:log_start_offset])
-  end
+    def next_address
+      header.history_list_node.next
+    end
 
-  class UndoRecordCursor
-    def initialize(undo_log, offset, direction=:forward)
-      @initial = true
-      @undo_log = undo_log
-      @offset = offset
-      @direction = direction
-
-      case offset
-      when :min
-        @undo_record = @undo_log.min_undo_record
-      when :max
-        raise "Not implemented"
-      else
-        @undo_record = @undo_log.undo_record(offset)
-      end
+    def undo_record(offset)
+      new_undo_record = Innodb::UndoRecord.new(page, offset)
+      new_undo_record.undo_log = self
+      new_undo_record
     end
 
-    def next_undo_record
-      if rec = @undo_record.next
-        @undo_record = rec
-      end
+    def min_undo_record
+      undo_record(header.log_start_offset)
     end
 
-    def prev_undo_record
-      if rec = @undo_record.prev
-        @undo_record = rec
+    class UndoRecordCursor
+      def initialize(undo_log, offset, direction = :forward)
+        @initial = true
+        @undo_log = undo_log
+        @offset = offset
+        @direction = direction
+
+        case offset
+        when :min
+          @undo_record = @undo_log.min_undo_record
+        when :max
+          raise "Not implemented"
+        else
+          @undo_record = @undo_log.undo_record(offset)
+        end
       end
-    end
 
-    def undo_record
-      if @initial
-        @initial = false
-        return @undo_record
+      def next_undo_record
+        rec = @undo_record.next
+        @undo_record = rec if rec
       end
 
-      case @direction
-      when :forward
-        next_undo_record
-      when :backward
-        prev_undo_record
+      def prev_undo_record
+        rec = @undo_record.prev
+        @undo_record = rec if rec
       end
-    end
 
-    def each_undo_record
-      unless block_given?
-        return enum_for(:each_undo_record)
+      def undo_record
+        if @initial
+          @initial = false
+          return @undo_record
+        end
+
+        case @direction
+        when :forward
+          next_undo_record
+        when :backward
+          prev_undo_record
+        end
       end
 
-      while rec = undo_record
-        yield rec
+      def each_undo_record
+        return enum_for(:each_undo_record) unless block_given?
+
+        while (rec = undo_record)
+          yield rec
+        end
       end
     end
-  end
 
-  def undo_record_cursor(offset, direction=:forward)
-    UndoRecordCursor.new(self, offset, direction)
-  end
+    def undo_record_cursor(offset, direction = :forward)
+      UndoRecordCursor.new(self, offset, direction)
+    end
 
-  def first_undo_record_cursor
-    undo_record_cursor(header[:log_start_offset])
-  end
+    def first_undo_record_cursor
+      undo_record_cursor(header.log_start_offset)
+    end
 
-  def dump
-    puts "header:"
-    pp header
-    puts
+    def dump
+      puts "header:"
+      pp header
+      puts
+    end
   end
 end

data/lib/innodb/undo_record.rb

@@ -1,165 +1,204 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
+require "forwardable"
 
 # A single undo log record.
-class Innodb::UndoRecord
-  attr_reader :undo_page
-  attr_reader :position
+module Innodb
+  class UndoRecord
+    extend Forwardable
+
+    Header = Struct.new(
+      :prev,
+      :next,
+      :type,
+      :extern_flag,
+      :info,
+      keyword_init: true
+    )
+
+    HeaderInfo = Struct.new(
+      :order_may_change,
+      :size_may_change,
+      keyword_init: true
+    )
+
+    Record = Struct.new(
+      :page,
+      :offset,
+      :header,
+      :undo_no,
+      :table_id,
+      :info_bits,
+      :trx_id,
+      :roll_ptr,
+      :data,
+      :key,
+      :row,
+      keyword_init: true
+    )
+
+    Field = Struct.new(
+      :name,
+      :type,
+      :value,
+      keyword_init: true
+    )
+
+    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
 
-  attr_accessor :undo_log
-  attr_accessor :index_page
+    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
 
-  def initialize(undo_page, position)
-    @undo_page = undo_page
-    @position = position
+      new_undo_record
+    end
 
-    @undo_log = nil
-    @index_page = nil
-  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
 
-  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
+    # The size of the header.
+    def size_header
+      2 + 2 + 1
+    end
 
-    new_undo_record
-  end
+    def pos_record
+      pos_header + size_header
+    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
+    # Return a BufferCursor starting before the header.
+    def cursor(position)
+      new_cursor = @undo_page.cursor(position)
+      new_cursor.push_name("undo_log[#{@undo_log.position}]") if @undo_log
+      new_cursor.push_name("undo_record[#{@position}]")
+      new_cursor
+    end
 
-  # The size of the header.
-  def size_header
-    2 + 2 + 1
-  end
+    # Possible undo record types.
+    TYPE = {
+      11 => :insert,
+      12 => :update_existing,
+      13 => :update_deleted,
+      14 => :delete,
+    }.freeze
+
+    TYPES_WITH_PREVIOUS_VERSIONS = %i[
+      update_existing
+      update_deleted
+      delete
+    ].freeze
+
+    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 = Header.new(
+          prev: c.name("prev") { c.read_uint16 },
+          next: c.name("next") { c.read_uint16 }
+        )
+
+        info = c.name("info") { c.read_uint8 }
+        cmpl = (info & COMPILATION_INFO_MASK) >> COMPILATION_INFO_SHIFT
+        header.type = TYPE[info & TYPE_MASK]
+        header.extern_flag = (info & EXTERN_FLAG) != 0
+        header.info = HeaderInfo.new(
+          order_may_change: (cmpl & COMPILATION_INFO_NO_ORDER_CHANGE_BV).zero?,
+          size_may_change: (cmpl & COMPILATION_INFO_NO_SIZE_CHANGE_BV).zero?
+        )
+
+        header
+      end
+    end
 
-  def pos_record
-    pos_header + size_header
-  end
+    def_delegator :header, :type
 
-  # 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}]")
+    def previous_version?
+      TYPES_WITH_PREVIOUS_VERSIONS.include?(type)
     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 get(prev_or_next)
+      return if header[prev_or_next].zero?
 
-  def type
-    header[:type]
-  end
+      new_undo_record = new_subordinate(@undo_page, header[prev_or_next])
+      new_undo_record if new_undo_record.type
+    end
 
-  def has_previous_version?
-    [:update_existing, :update_deleted, :delete].include?(type)
-  end
+    def prev
+      get(:prev)
+    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
+    def next
+      get(:next)
     end
-  end
 
-  def prev
-    get(:prev)
-  end
+    def record_size
+      header[:next] - @position - size_header
+    end
 
-  def next
-    get(:next)
-  end
+    def read_record
+      cursor(pos_record).name("record") do |c|
+        this_record = Record.new(
+          page: undo_page.offset,
+          offset: position,
+          header: header,
+          undo_no: c.name("undo_no") { c.read_imc_uint64 },
+          table_id: c.name("table_id") { c.read_imc_uint64 }
+        )
+
+        if previous_version?
+          this_record.info_bits = c.name("info_bits") { c.read_uint8 }
+          this_record.trx_id = c.name("trx_id") { c.read_ic_uint64 }
+          this_record.roll_ptr = c.name("roll_ptr") do
+            Innodb::DataType::RollPointerType.parse_roll_pointer(c.read_ic_uint64)
+          end
+        end
 
-  def record_size
-    header[:next] - @position - size_header
-  end
+        if index_page
+          read_record_fields(this_record, c)
+        else
+          # Slurp up the remaining data as a string.
+          this_record.data = c.read_bytes(header[:next] - c.position - 2)
+        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)
-        }
+        this_record
       end
+    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
+    def read_record_fields(this_record, cursor)
+      this_record.key = []
+      index_page.record_format[:key].each do |field|
+        length = cursor.name("field_length") { cursor.read_ic_uint32 }
+        value = cursor.name(field.name) { field.value_by_length(cursor, length) }
 
-      this_record
-    end
-  end
+        this_record.key[field.position] = Field.new(name: field.name, type: field.data_type.name, value: value)
+      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
+      return unless previous_version?
 
-    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 = cursor.name("field_count") { cursor.read_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_number = cursor.name("field_number[#{field_count}]") { cursor.read_ic_uint32 }
         field = nil
         field_index = nil
         index_page.record_format[:row].each_with_index do |candidate_field, index|
@@ -168,140 +207,109 @@ class Innodb::UndoRecord
             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
+        raise "Unknown field #{field_number}" unless field
 
-  def roll_ptr
-    undo_record[:roll_ptr]
-  end
+        length = cursor.name("field_length") { cursor.read_ic_uint32 }
+        value = cursor.name(field.name) { field.value_by_length(cursor, length) }
 
-  def key
-    undo_record[:key]
-  end
+        this_record.row[field_index] = Field.new(name: field.name, type: field.data_type.name, value: value)
+      end
+    end
 
-  def page
-    undo_record[:page]
-  end
+    def undo_record
+      @undo_record ||= read_record
+    end
 
-  def offset
-    undo_record[:offset]
-  end
+    def_delegator :undo_record, :undo_no
+    def_delegator :undo_record, :table_id
+    def_delegator :undo_record, :trx_id
+    def_delegator :undo_record, :roll_ptr
+    def_delegator :undo_record, :key
+    def_delegator :undo_record, :page
+    def_delegator :undo_record, :offset
 
-  def key_string
-    key && key.map { |r| "%s=%s" % [r[:name], r[:value].inspect] }.join(", ")
-  end
+    def key_string
+      key&.map { |r| "%s=%s" % [r[:name], r[:value].inspect] }&.join(", ")
+    end
 
-  def row
-    undo_record[:row]
-  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 row_string
+      row&.reject(&:nil?)&.map { |r| r && "%s=%s" % [r[:name], r[:value].inspect] }&.join(", ")
+    end
 
-  def string
-    "(%s) → (%s)" % [key_string, row_string]
-  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?
+    # 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
       # This undo record type has no previous version information.
-      return nil
-    end
+      return unless previous_version?
 
-    undo_log = roll_ptr[:undo_log]
-    older_undo_page = @undo_page.space.page(undo_log[:page])
+      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
+      return unless older_undo_page.is_a?(Innodb::Page::UndoLog)
 
-    older_undo_record = new_subordinate(older_undo_page,
-                                        undo_log[:offset])
+      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
+      return unless older_undo_record && table_id == older_undo_record.table_id
 
-    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
+      return unless older_undo_record.trx_id.nil? || trx_id >= older_undo_record.trx_id
 
-    older_undo_record
-  end
-
-  def dump
-    puts "Undo record at offset %i" % offset
-    puts
-
-    puts "Header:"
-    puts "  %-25s: %i" % ["Previous record offset", header[:prev]]
-    puts "  %-25s: %i" % ["Next record offset", header[:next]]
-    puts "  %-25s: %s" % ["Type", header[:type]]
-    puts
-
-    puts "System fields:"
-    puts "  Transaction ID: %s" % trx_id
-    puts "  Roll Pointer:"
-    puts "    Undo Log: page %i, offset %i" % [
-      roll_ptr[:undo_log][:page],
-      roll_ptr[:undo_log][:offset],
-    ]
-    puts "    Rollback Segment ID: %i" % roll_ptr[:rseg_id]
-    puts
-
-    puts "Key fields:"
-    key.each do |field|
-      puts "  %s: %s" % [
-        field[:name],
-        field[:value].inspect,
-      ]
+      older_undo_record
     end
-    puts
-
-    puts "Non-key fields:"
-    row.each do |field|
-      next if !field
-      puts "  %s: %s" % [
-        field[:name],
-        field[:value].inspect,
+
+    def dump
+      puts "Undo record at offset %i" % offset
+      puts
+
+      puts "Header:"
+      puts "  %-25s: %i" % ["Previous record offset", header[:prev]]
+      puts "  %-25s: %i" % ["Next record offset", header[:next]]
+      puts "  %-25s: %s" % ["Type", header[:type]]
+      puts
+
+      puts "System fields:"
+      puts "  Transaction ID: %s" % trx_id
+      puts "  Roll Pointer:"
+      puts "    Undo Log: page %i, offset %i" % [
+        roll_ptr[:undo_log][:page],
+        roll_ptr[:undo_log][:offset],
       ]
+      puts "    Rollback Segment ID: %i" % roll_ptr[:rseg_id]
+      puts
+
+      puts "Key fields:"
+      key.each do |field|
+        puts "  %s: %s" % [
+          field[:name],
+          field[:value].inspect,
+        ]
+      end
+      puts
+
+      puts "Non-key fields:"
+      row.each do |field|
+        next unless field
+
+        puts "  %s: %s" % [
+          field[:name],
+          field[:value].inspect,
+        ]
+      end
+      puts
     end
-    puts
   end
-
 end