innodb_ruby 0.9.13 → 0.11.0

data/lib/innodb/log_group.rb

@@ -1,84 +1,73 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 # Group of InnoDB logs files that make up the redo log.
-class Innodb::LogGroup
-
-  # Initialize group given a set of sorted log files.
-  def initialize(log_files)
-    @logs = log_files.map { |fn| Innodb::Log.new(fn) }
-    sizes = @logs.map { |log| log.size }
-    raise "Log file sizes do not match" unless sizes.uniq.size == 1
-  end
-
-  # Iterate through all logs.
-  def each_log
-    unless block_given?
-      return enum_for(:each_log)
+module Innodb
+  class LogGroup
+    # Initialize group given a set of sorted log files.
+    def initialize(log_files)
+      @logs = log_files.map { |fn| Innodb::Log.new(fn) }
+      raise "Log file sizes do not match" unless @logs.map(&:size).uniq.size == 1
     end
 
-    @logs.each do |log|
-      yield log
-    end
-  end
+    # Iterate through all logs.
+    def each_log(&block)
+      return enum_for(:each_log) unless block_given?
 
-  # Iterate through all blocks.
-  def each_block
-    unless block_given?
-      return enum_for(:each_block)
+      @logs.each(&block)
     end
 
-    each_log do |log|
-      log.each_block do |block_index, block|
-        yield block_index, block
+    # Iterate through all blocks.
+    def each_block(&block)
+      return enum_for(:each_block) unless block_given?
+
+      each_log do |log|
+        log.each_block(&block)
       end
     end
-  end
 
-  # The number of log files in the group.
-  def logs
-    @logs.count
-  end
+    # The number of log files in the group.
+    def logs
+      @logs.count
+    end
 
-  # Returns the log at the given position in the log group.
-  def log(log_no)
-    @logs.at(log_no)
-  end
+    # Returns the log at the given position in the log group.
+    def log(log_no)
+      @logs.at(log_no)
+    end
 
-  # The size in byes of each and every log in the group.
-  def log_size
-    @logs.first.size
-  end
+    # The size in byes of each and every log in the group.
+    def log_size
+      @logs.first.size
+    end
 
-  # The size of the log group (in bytes)
-  def size
-    @logs.first.size * @logs.count
-  end
+    # The size of the log group (in bytes)
+    def size
+      @logs.first.size * @logs.count
+    end
 
-  # The log group capacity (in bytes).
-  def capacity
-    @logs.first.capacity * @logs.count
-  end
+    # The log group capacity (in bytes).
+    def capacity
+      @logs.first.capacity * @logs.count
+    end
 
-  # Returns the LSN coordinates of the data at the start of the log group.
-  def start_lsn
-    [@logs.first.header[:start_lsn], Innodb::Log::LOG_HEADER_SIZE]
-  end
+    # Returns the LSN coordinates of the data at the start of the log group.
+    def start_lsn
+      [@logs.first.header[:start_lsn], Innodb::Log::LOG_HEADER_SIZE]
+    end
 
-  # Returns the LSN coordinates of the most recent (highest) checkpoint.
-  def max_checkpoint_lsn
-    checkpoint = @logs.first.checkpoint.max_by{|f,v| v[:number]}.last
-    checkpoint.values_at(:lsn, :lsn_offset)
-  end
+    # Returns the LSN coordinates of the most recent (highest) checkpoint.
+    def max_checkpoint_lsn
+      @logs.first.checkpoint.max_by(&:number).to_h.values_at(:lsn, :lsn_offset)
+    end
 
-  # Returns a LogReader using the given LSN reference coordinates.
-  def reader(lsn_coord = start_lsn)
-    lsn_no, lsn_offset = lsn_coord
-    lsn = Innodb::LSN.new(lsn_no, lsn_offset)
-    Innodb::LogReader.new(lsn, self)
-  end
+    # Returns a LogReader using the given LSN reference coordinates.
+    def reader(lsn_coordinates = start_lsn)
+      Innodb::LogReader.new(Innodb::LSN.new(*lsn_coordinates), self)
+    end
 
-  # Parse and return a record at a given LSN.
-  def record(lsn_no)
-    reader.seek(lsn_no).record
+    # Parse and return a record at a given LSN.
+    def record(lsn_no)
+      reader.seek(lsn_no).record
+    end
   end
 end

data/lib/innodb/log_reader.rb

@@ -1,116 +1,117 @@
-# -*- encoding : utf-8 -*-
-
-require "ostruct"
+# frozen_string_literal: true
 
 # Representation of the log group as a seekable stream of log records.
-class Innodb::LogReader
-
-  # Whether to checksum blocks.
-  attr_accessor :checksum
-
-  def initialize(lsn, group)
-    @group = group
-    @context = OpenStruct.new(:buffer => String.new,
-      :buffer_lsn => lsn.dup, :record_lsn => lsn.dup)
-  end
+module Innodb
+  class LogReader
+    # Checksum failed exception.
+    class ChecksumError < RuntimeError; end
+
+    # EOF reached exception.
+    class EOFError < EOFError; end
+
+    Context = Struct.new(
+      :buffer,
+      :buffer_lsn,
+      :record_lsn,
+      keyword_init: true
+    )
+
+    # Whether to checksum blocks.
+    # TODO: Hmm, nothing seems to actually set this.
+    attr_accessor :checksum
+
+    def initialize(lsn, group)
+      @group = group
+      @context = Context.new(buffer: String.new, buffer_lsn: lsn.dup, record_lsn: lsn.dup)
+    end
 
-  # Seek to record starting position.
-  def seek(lsn_no)
-    check_lsn_no(lsn_no)
-    @context.buffer = String.new
-    @context.buffer_lsn.reposition(lsn_no, @group)
-    @context.record_lsn = @context.buffer_lsn.dup
-    self
-  end
+    # Seek to record starting position.
+    def seek(lsn_no)
+      check_lsn_no(lsn_no)
+      @context.buffer = String.new
+      @context.buffer_lsn.reposition(lsn_no, @group)
+      @context.record_lsn = @context.buffer_lsn.dup
+      self
+    end
 
-  # Returns the current LSN starting position.
-  def tell
-    @context.record_lsn.no
-  end
+    # Returns the current LSN starting position.
+    def tell
+      @context.record_lsn.no
+    end
 
-  # Read a record.
-  def record
-    cursor = BufferCursor.new(self, 0)
-    record = Innodb::LogRecord.new
-    record.read(cursor)
-    record.lsn = reposition(cursor.position)
-    record
-  end
+    # Read a record.
+    def record
+      cursor = BufferCursor.new(self, 0)
+      record = Innodb::LogRecord.new
+      record.read(cursor)
+      record.lsn = reposition(cursor.position)
+      record
+    end
 
-  # Call the given block once for each record in the log until the
-  # end of the log (or a corrupted block) is reached. If the follow
-  # argument is true, retry.
-  def each_record(follow, wait=0.5)
-    begin
+    # Call the given block once for each record in the log until the
+    # end of the log (or a corrupted block) is reached. If the follow
+    # argument is true, retry.
+    def each_record(follow, wait = 0.5)
       loop { yield record }
     rescue EOFError, ChecksumError
-      sleep(wait) and retry if follow
-    end
-  end
-
-  # Read a slice of log data (that is, log data used for records).
-  def slice(position, length)
-    buffer = @context.buffer
-    length = position + length
-
-    if length > buffer.size
-      preload(length)
+      sleep(wait) && retry if follow
     end
 
-    buffer.slice(position, length - position)
-  end
+    # Read a slice of log data (that is, log data used for records).
+    def slice(position, length)
+      buffer = @context.buffer
+      length = position + length
 
-  # Checksum failed exception.
-  class ChecksumError < RuntimeError
-  end
+      preload(length) if length > buffer.size
 
-  # EOF reached exception.
-  class EOFError < EOFError
-  end
+      buffer.slice(position, length - position)
+    end
 
-  private
+    private
 
-  # Check if LSN points to where records may be located.
-  def check_lsn_no(lsn_no)
-    lsn = @context.record_lsn.dup
-    lsn.reposition(lsn_no, @group)
-    raise "LSN #{lsn_no} is out of bounds" unless lsn.record?(@group)
-  end
-
-  # Reposition to the beginning of the next record.
-  def reposition(length)
-    start_lsn_no = @context.record_lsn.no
-    delta_lsn_no = @context.record_lsn.delta(length)
-    @context.record_lsn.advance(delta_lsn_no, @group)
-    @context.buffer.slice!(0, length)
-    [start_lsn_no, start_lsn_no + delta_lsn_no]
-  end
+    # Check if LSN points to where records may be located.
+    def check_lsn_no(lsn_no)
+      lsn = @context.record_lsn.dup
+      lsn.reposition(lsn_no, @group)
+      raise "LSN #{lsn_no} is out of bounds" unless lsn.record?(@group)
+    end
 
-  # Reads the log block at the given LSN position.
-  def get_block(lsn)
-    log_no, block_no, block_offset = lsn.location(@group)
-    [@group.log(log_no).block(block_no), block_offset]
-  end
+    # Reposition to the beginning of the next record.
+    def reposition(length)
+      start_lsn_no = @context.record_lsn.no
+      delta_lsn_no = @context.record_lsn.delta(length)
+      @context.record_lsn.advance(delta_lsn_no, @group)
+      @context.buffer.slice!(0, length)
+      [start_lsn_no, start_lsn_no + delta_lsn_no]
+    end
 
-  # Preload the log buffer with enough data to satisfy the requested amount.
-  def preload(size)
-    buffer = @context.buffer
-    buffer_lsn = @context.buffer_lsn
-
-    # If reading for the first time, offset points to the start of the
-    # record (somewhere in the block). Otherwise, the block is read as
-    # a whole and offset points to the start of the next block to read.
-    while buffer.size < size
-      block, offset = get_block(buffer_lsn)
-      break if checksum && corrupt = block.corrupt?
-      data = offset == 0 ? block.data : block.data(offset)
-      data_length = block.header[:data_length]
-      buffer << data
-      buffer_lsn.advance(data_length - offset, @group)
-      break if data_length < Innodb::LogBlock::BLOCK_SIZE
+    # Reads the log block at the given LSN position.
+    def get_block(lsn)
+      log_no, block_no, block_offset = lsn.location(@group)
+      [@group.log(log_no).block(block_no), block_offset]
     end
 
-    raise ChecksumError, "Block is corrupted" if corrupt
-    raise EOFError, "End of log reached" if buffer.size < size
+    # Preload the log buffer with enough data to satisfy the requested amount.
+    def preload(size)
+      buffer = @context.buffer
+      buffer_lsn = @context.buffer_lsn
+
+      # If reading for the first time, offset points to the start of the
+      # record (somewhere in the block). Otherwise, the block is read as
+      # a whole and offset points to the start of the next block to read.
+      while buffer.size < size
+        block, offset = get_block(buffer_lsn)
+        break if checksum && (corrupt = block.corrupt?)
+
+        data = offset.zero? ? block.data : block.data(offset)
+        data_length = block.header[:data_length]
+        buffer << data
+        buffer_lsn.advance(data_length - offset, @group)
+        break if data_length < Innodb::LogBlock::BLOCK_SIZE
+      end
+
+      raise ChecksumError, "Block is corrupted" if corrupt
+      raise EOFError, "End of log reached" if buffer.size < size
+    end
   end
 end

data/lib/innodb/log_record.rb

@@ -1,317 +1,366 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 # An InnoDB transaction log block.
-class Innodb::LogRecord
-  # Start and end LSNs for this record.
-  attr_accessor :lsn
+module Innodb
+  class LogRecord
+    Preamble = Struct.new(
+      :type,
+      :single_record,
+      :space,
+      :page_number,
+      keyword_init: true
+    )
 
-  # The size (in bytes) of the record.
-  attr_reader :size
+    IndexFieldInfo = Struct.new(
+      :mtype,
+      :prtype,
+      :length, # rubocop:disable Lint/StructNewOverride
+      keyword_init: true
+    )
 
-  attr_reader :preamble
+    Index = Struct.new(
+      :n_cols,
+      :n_uniq,
+      :cols,
+      keyword_init: true
+    )
 
-  attr_reader :payload
+    # Start and end LSNs for this record.
+    attr_accessor :lsn
 
-  # InnoDB log record types.
-  RECORD_TYPES =
-    {
-       1 => :MLOG_1BYTE,                 2 => :MLOG_2BYTE,
-       4 => :MLOG_4BYTE,                 8 => :MLOG_8BYTE,
-       9 => :REC_INSERT,                10 => :REC_CLUST_DELETE_MARK,
-      11 => :REC_SEC_DELETE_MARK,       13 => :REC_UPDATE_IN_PLACE,
-      14 => :REC_DELETE,                15 => :LIST_END_DELETE,
-      16 => :LIST_START_DELETE,         17 => :LIST_END_COPY_CREATED,
-      18 => :PAGE_REORGANIZE,           19 => :PAGE_CREATE,
-      20 => :UNDO_INSERT,               21 => :UNDO_ERASE_END,
-      22 => :UNDO_INIT,                 23 => :UNDO_HDR_DISCARD,
-      24 => :UNDO_HDR_REUSE,            25 => :UNDO_HDR_CREATE,
-      26 => :REC_MIN_MARK,              27 => :IBUF_BITMAP_INIT,
-      28 => :LSN,                       29 => :INIT_FILE_PAGE,
-      30 => :WRITE_STRING,              31 => :MULTI_REC_END,
-      32 => :DUMMY_RECORD,              33 => :FILE_CREATE,
-      34 => :FILE_RENAME,               35 => :FILE_DELETE,
-      36 => :COMP_REC_MIN_MARK,         37 => :COMP_PAGE_CREATE,
-      38 => :COMP_REC_INSERT,           39 => :COMP_REC_CLUST_DELETE_MARK,
-      40 => :COMP_REC_SEC_DELETE_MARK,  41 => :COMP_REC_UPDATE_IN_PLACE,
-      42 => :COMP_REC_DELETE,           43 => :COMP_LIST_END_DELETE,
-      44 => :COMP_LIST_START_DELETE,    45 => :COMP_LIST_END_COPY_CREATE,
-      46 => :COMP_PAGE_REORGANIZE,      47 => :FILE_CREATE2,
-      48 => :ZIP_WRITE_NODE_PTR,        49 => :ZIP_WRITE_BLOB_PTR,
-      50 => :ZIP_WRITE_HEADER,          51 => :ZIP_PAGE_COMPRESS,
-    }
+    # The size (in bytes) of the record.
+    attr_reader :size
 
-  # Types of undo log segments.
-  UNDO_TYPES = { 1 => :UNDO_INSERT, 2 => :UNDO_UPDATE }
+    attr_reader :preamble
 
-  def read(cursor)
-    origin = cursor.position
-    @preamble = read_preamble(cursor)
-    @payload = read_payload(@preamble[:type], cursor)
-    @size = cursor.position - origin
-  end
+    attr_reader :payload
 
-  # Dump the contents of the record.
-  def dump
-    pp({:lsn => lsn, :size => size, :content => @preamble.merge(@payload)})
-  end
+    # InnoDB log record types.
+    RECORD_TYPES = {
+      1 => :MLOG_1BYTE,
+      2 => :MLOG_2BYTE,
+      4 => :MLOG_4BYTE,
+      8 => :MLOG_8BYTE,
+      9 => :REC_INSERT,
+      10 => :REC_CLUST_DELETE_MARK,
+      11 => :REC_SEC_DELETE_MARK,
+      13 => :REC_UPDATE_IN_PLACE,
+      14 => :REC_DELETE,
+      15 => :LIST_END_DELETE,
+      16 => :LIST_START_DELETE,
+      17 => :LIST_END_COPY_CREATED,
+      18 => :PAGE_REORGANIZE,
+      19 => :PAGE_CREATE,
+      20 => :UNDO_INSERT,
+      21 => :UNDO_ERASE_END,
+      22 => :UNDO_INIT,
+      23 => :UNDO_HDR_DISCARD,
+      24 => :UNDO_HDR_REUSE,
+      25 => :UNDO_HDR_CREATE,
+      26 => :REC_MIN_MARK,
+      27 => :IBUF_BITMAP_INIT,
+      28 => :LSN,
+      29 => :INIT_FILE_PAGE,
+      30 => :WRITE_STRING,
+      31 => :MULTI_REC_END,
+      32 => :DUMMY_RECORD,
+      33 => :FILE_CREATE,
+      34 => :FILE_RENAME,
+      35 => :FILE_DELETE,
+      36 => :COMP_REC_MIN_MARK,
+      37 => :COMP_PAGE_CREATE,
+      38 => :COMP_REC_INSERT,
+      39 => :COMP_REC_CLUST_DELETE_MARK,
+      40 => :COMP_REC_SEC_DELETE_MARK,
+      41 => :COMP_REC_UPDATE_IN_PLACE,
+      42 => :COMP_REC_DELETE,
+      43 => :COMP_LIST_END_DELETE,
+      44 => :COMP_LIST_START_DELETE,
+      45 => :COMP_LIST_END_COPY_CREATE,
+      46 => :COMP_PAGE_REORGANIZE,
+      47 => :FILE_CREATE2,
+      48 => :ZIP_WRITE_NODE_PTR,
+      49 => :ZIP_WRITE_BLOB_PTR,
+      50 => :ZIP_WRITE_HEADER,
+      51 => :ZIP_PAGE_COMPRESS,
+    }.freeze
 
-  # Single record flag is masked in the record type.
-  SINGLE_RECORD_MASK = 0x80
-  RECORD_TYPE_MASK   = 0x7f
+    # Types of undo log segments.
+    UNDO_TYPES = {
+      1 => :UNDO_INSERT,
+      2 => :UNDO_UPDATE,
+    }.freeze
 
-  # Return a preamble of the first record in this block.
-  def read_preamble(c)
-    type_and_flag = c.name("type") { c.get_uint8 }
-    type = type_and_flag & RECORD_TYPE_MASK
-    type = RECORD_TYPES[type] || type
-    # Whether this is a single record for a single page.
-    single_record = (type_and_flag & SINGLE_RECORD_MASK) > 0
-    case type
-    when :MULTI_REC_END, :DUMMY_RECORD
-      { :type => type }
-    else
-      {
-        :type           => type,
-        :single_record  => single_record,
-        :space          => c.name("space") { c.get_ic_uint32 },
-        :page_number    => c.name("page_number") { c.get_ic_uint32 },
-      }
+    def read(cursor)
+      origin = cursor.position
+      @preamble = read_preamble(cursor)
+      @payload = read_payload(@preamble.type, cursor)
+      @size = cursor.position - origin
     end
-  end
 
-  # Read the index part of a log record for a compact record insert.
-  # Ref. mlog_parse_index
-  def read_index(c)
-    n_cols = c.name("n_cols") { c.get_uint16 }
-    n_uniq = c.name("n_uniq") { c.get_uint16 }
-    cols = n_cols.times.collect do
-      info = c.name("field_info") { c.get_uint16 }
-      {
-        :mtype  => ((info + 1) & 0x7fff) <= 1 ? :BINARY : :FIXBINARY,
-        :prtype => (info & 0x8000) != 0 ? :NOT_NULL : nil,
-        :length => info & 0x7fff
-      }
+    # Dump the contents of the record.
+    def dump
+      pp({ lsn: lsn, size: size, preamble: @preamble, payload: @payload })
     end
-    {
-      :n_cols => n_cols,
-      :n_uniq => n_uniq,
-      :cols   => cols,
-    }
-  end
 
-  # Flag of whether an insert log record contains info and status.
-  INFO_AND_STATUS_MASK = 0x1
+    # Single record flag is masked in the record type.
+    SINGLE_RECORD_MASK = 0x80
+    RECORD_TYPE_MASK   = 0x7f
+
+    # Return a preamble of the first record in this block.
+    def read_preamble(cursor)
+      type_and_flag = cursor.name("type") { cursor.read_uint8 }
+      type = type_and_flag & RECORD_TYPE_MASK
+      type = RECORD_TYPES[type] || type
+      # Whether this is a single record for a single page.
+      single_record = (type_and_flag & SINGLE_RECORD_MASK).positive?
+      case type
+      when :MULTI_REC_END, :DUMMY_RECORD
+        Preamble.new(type: type)
+      else
+        Preamble.new(
+          type: type,
+          single_record: single_record,
+          space: cursor.name("space") { cursor.read_ic_uint32 },
+          page_number: cursor.name("page_number") { cursor.read_ic_uint32 }
+        )
+      end
+    end
 
-  # Read the insert record into page part of a insert log.
-  # Ref. page_cur_parse_insert_rec
-  def read_insert_record(c)
-    page_offset = c.name("page_offset") { c.get_uint16 }
-    end_seg_len = c.name("end_seg_len") { c.get_ic_uint32 }
+    # Read the index part of a log record for a compact record insert.
+    # Ref. mlog_parse_index
+    def read_index(cursor)
+      n_cols = cursor.name("n_cols") { cursor.read_uint16 }
+      n_uniq = cursor.name("n_uniq") { cursor.read_uint16 }
+      cols = n_cols.times.collect do
+        info = cursor.name("field_info") { cursor.read_uint16 }
+        IndexFieldInfo.new(
+          mtype: ((info + 1) & 0x7fff) <= 1 ? :BINARY : :FIXBINARY,
+          prtype: (info & 0x8000).zero? ? nil : :NOT_NULL,
+          length: info & 0x7fff
+        )
+      end
 
-    if (end_seg_len & INFO_AND_STATUS_MASK) != 0
-      info_and_status_bits = c.get_uint8
-      origin_offset = c.get_ic_uint32
-      mismatch_index = c.get_ic_uint32
+      Index.new(n_cols: n_cols, n_uniq: n_uniq, cols: cols)
     end
 
-    {
-      :page_offset => page_offset,
-      :end_seg_len => end_seg_len >> 1,
-      :info_and_status_bits => info_and_status_bits,
-      :origin_offset => origin_offset,
-      :mismatch_index => mismatch_index,
-      :record => c.name("record") { c.get_bytes(end_seg_len >> 1) },
-    }
-  end
+    # Flag of whether an insert log record contains info and status.
+    INFO_AND_STATUS_MASK = 0x1
 
-  # Read the log record for an in-place update.
-  # Ref. btr_cur_parse_update_in_place
-  def read_update_in_place_record(c)
-    {
-      :flags => c.name("flags") { c.get_uint8 },
-      :sys_fields => read_sys_fields(c),
-      :rec_offset => c.name("rec_offset") { c.get_uint16 },
-      :update_index => read_update_index(c),
-    }
-  end
+    # Read the insert record into page part of a insert log.
+    # Ref. page_cur_parse_insert_rec
+    def read_insert_record(cursor)
+      page_offset = cursor.name("page_offset") { cursor.read_uint16 }
+      end_seg_len = cursor.name("end_seg_len") { cursor.read_ic_uint32 }
 
-  LENGTH_NULL = 0xFFFFFFFF
+      if (end_seg_len & INFO_AND_STATUS_MASK) != 0
+        info_and_status_bits = cursor.read_uint8
+        origin_offset = cursor.read_ic_uint32
+        mismatch_index = cursor.read_ic_uint32
+      end
 
-  # Read the update vector for an update log record.
-  # Ref. row_upd_index_parse
-  def read_update_index(c)
-    info_bits = c.name("info_bits") { c.get_uint8 }
-    n_fields  = c.name("n_fields") { c.get_ic_uint32 }
-    fields = n_fields.times.collect do
       {
-        :field_no => c.name("field_no") { c.get_ic_uint32 },
-        :len      => len = c.name("len") { c.get_ic_uint32 },
-        :data     => c.name("data") { len != LENGTH_NULL ? c.get_bytes(len) : :NULL },
+        page_offset: page_offset,
+        end_seg_len: end_seg_len >> 1,
+        info_and_status_bits: info_and_status_bits,
+        origin_offset: origin_offset,
+        mismatch_index: mismatch_index,
+        record: cursor.name("record") { cursor.read_bytes(end_seg_len >> 1) },
       }
     end
-    {
-      :info_bits => info_bits,
-      :n_fields  => n_fields,
-      :fields    => fields,
-    }
-  end
-
-  # Read system fields values in a log record.
-  # Ref. row_upd_parse_sys_vals
-  def read_sys_fields(c)
-    {
-      :trx_id_pos => c.name("trx_id_pos") { c.get_ic_uint32 },
-      :roll_ptr   => c.name("roll_ptr") { c.get_bytes(7) },
-      :trx_id     => c.name("trx_id") { c.get_ic_uint64 },
-    }
-  end
 
-  # Read the log record for delete marking or unmarking of a clustered
-  # index record.
-  # Ref. btr_cur_parse_del_mark_set_clust_rec
-  def read_clust_delete_mark(c)
-    {
-      :flags => c.name("flags") { c.get_uint8 },
-      :value => c.name("value") { c.get_uint8 },
-      :sys_fields => c.name("sys_fields") { read_sys_fields(c) },
-      :offset => c.name("offset") { c.get_uint16 },
-    }
-  end
-
-  def read_payload(type, c)
-    case type
-    when :MLOG_1BYTE, :MLOG_2BYTE, :MLOG_4BYTE
-      {
-        :page_offset => c.name("page_offset") { c.get_uint16 },
-        :value       => c.name("value")  { c.get_ic_uint32 }
-      }
-    when :MLOG_8BYTE
-      {
-        :offset   => c.name("offset") { c.get_uint16 },
-        :value    => c.name("value")  { c.get_ic_uint64 }
-      }
-    when :UNDO_HDR_CREATE, :UNDO_HDR_REUSE
+    # Read the log record for an in-place update.
+    # Ref. btr_cur_parse_update_in_place
+    def read_update_in_place_record(cursor)
       {
-        :trx_id   => c.name("trx_id") { c.get_ic_uint64 }
+        flags: cursor.name("flags") { cursor.read_uint8 },
+        sys_fields: read_sys_fields(cursor),
+        rec_offset: cursor.name("rec_offset") { cursor.read_uint16 },
+        update_index: read_update_index(cursor),
       }
-    when :UNDO_INSERT
-      {
-        :length   => len = c.name("length") { c.get_uint16 },
-        :value    => c.name("value") { c.get_bytes(len) }
-      }
-    when :REC_INSERT
-      {
-        :record   => c.name("record") { read_insert_record(c) }
-      }
-    when :COMP_REC_INSERT
-      {
-        :index    => c.name("index")  { read_index(c) },
-        :record   => c.name("record") { read_insert_record(c) }
-      }
-    when :COMP_REC_UPDATE_IN_PLACE
-      {
-        :index    => c.name("index")  { read_index(c) },
-        :record   => c.name("record") { read_update_in_place_record(c) }
-      }
-    when :REC_UPDATE_IN_PLACE
-      {
-        :record   => c.name("record") { read_update_in_place_record(c) }
-      }
-    when :WRITE_STRING
-      {
-        :offset   => c.name("offset") { c.get_uint16 },
-        :length   => length = c.name("length") { c.get_uint16 },
-        :value    => c.name("value")  { c.get_bytes(length) },
-      }
-    when :UNDO_INIT
-      {
-        :type     => c.name("type")   { UNDO_TYPES[c.get_ic_uint32] }
-      }
-    when :FILE_CREATE, :FILE_DELETE
-      {
-        :name_len => len = c.name("name_len") { c.get_uint16 },
-        :name     => c.name("name") { c.get_bytes(len) },
-      }
-    when :FILE_CREATE2
-      {
-        :flags    => c.name("flags") { c.get_uint32 },
-        :name_len => len = c.name("name_len") { c.get_uint16 },
-        :name     => c.name("name") { c.get_bytes(len) },
-      }
-    when :FILE_RENAME
-      {
-        :old => {
-          :name_len => len = c.name("name_len") { c.get_uint16 },
-          :name     => c.name("name") { c.get_bytes(len) },
-        },
-        :new => {
-          :name_len => len = c.name("name_len") { c.get_uint16 },
-          :name     => c.name("name") { c.get_bytes(len) },
+    end
+
+    LENGTH_NULL = 0xFFFFFFFF
+
+    # Read the update vector for an update log record.
+    # Ref. row_upd_index_parse
+    def read_update_index(cursor)
+      info_bits = cursor.name("info_bits") { cursor.read_uint8 }
+      n_fields  = cursor.name("n_fields") { cursor.read_ic_uint32 }
+      fields = n_fields.times.collect do
+        {
+          field_no: cursor.name("field_no") { cursor.read_ic_uint32 },
+          len: len = cursor.name("len") { cursor.read_ic_uint32 },
+          data: cursor.name("data") { len == LENGTH_NULL ? :NULL : cursor.read_bytes(len) },
         }
-      }
-    when :COMP_REC_CLUST_DELETE_MARK
+      end
       {
-        :index    => c.name("index")  { read_index(c) },
-        :record   => c.name("record") { read_clust_delete_mark(c) }
+        info_bits: info_bits,
+        n_fields: n_fields,
+        fields: fields,
       }
-    when :REC_CLUST_DELETE_MARK
-      {
-        :record   => c.name("record") { read_clust_delete_mark(c) }
-      }
-    when :COMP_REC_SEC_DELETE_MARK
-      {
-        :index    => c.name("index")  { read_index(c) },
-        :value    => c.name("value")  { c.get_uint8 },
-        :offset   => c.name("offset") { c.get_uint16 },
-      }
-    when :REC_SEC_DELETE_MARK
-      {
-        :value    => c.name("value")  { c.get_uint8 },
-        :offset   => c.name("offset") { c.get_uint16 },
-      }
-    when :REC_DELETE
-      {
-        :offset   => c.name("offset") { c.get_uint16 },
-      }
-    when :COMP_REC_DELETE
-      {
-        :index    => c.name("index")  { read_index(c) },
-        :offset   => c.name("offset") { c.get_uint16 },
-      }
-    when :REC_MIN_MARK, :COMP_REC_MIN_MARK
-      {
-        :offset   => c.name("offset") { c.get_uint16 },
-      }
-    when :LIST_START_DELETE, :LIST_END_DELETE
-      {
-        :offset   => c.name("offset") { c.get_uint16 },
-      }
-    when :COMP_LIST_START_DELETE, :COMP_LIST_END_DELETE
-      {
-        :index    => c.name("index")  { read_index(c) },
-        :offset   => c.name("offset") { c.get_uint16 },
-      }
-    when :LIST_END_COPY_CREATED
-      {
-        :length   => len = c.name("length") { c.get_uint32 },
-        :data     => c.name("data") { c.get_bytes(len) }
-      }
-    when :COMP_LIST_END_COPY_CREATE
+    end
+
+    # Read system fields values in a log record.
+    # Ref. row_upd_parse_sys_vals
+    def read_sys_fields(cursor)
       {
-        :index    => c.name("index")  { read_index(c) },
-        :length   => len = c.name("length") { c.get_uint32 },
-        :data     => c.name("data") { c.get_bytes(len) }
+        trx_id_pos: cursor.name("trx_id_pos") { cursor.read_ic_uint32 },
+        roll_ptr: cursor.name("roll_ptr") { cursor.read_bytes(7) },
+        trx_id: cursor.name("trx_id") { cursor.read_ic_uint64 },
       }
-    when :COMP_PAGE_REORGANIZE
+    end
+
+    # Read the log record for delete marking or unmarking of a clustered
+    # index record.
+    # Ref. btr_cur_parse_del_mark_set_clust_rec
+    def read_clust_delete_mark(cursor)
       {
-        :index    => c.name("index")  { read_index(c) },
+        flags: cursor.name("flags") { cursor.read_uint8 },
+        value: cursor.name("value") { cursor.read_uint8 },
+        sys_fields: cursor.name("sys_fields") { read_sys_fields(cursor) },
+        offset: cursor.name("offset") { cursor.read_uint16 },
       }
-    when :DUMMY_RECORD, :MULTI_REC_END, :INIT_FILE_PAGE,
-         :IBUF_BITMAP_INIT, :PAGE_CREATE, :COMP_PAGE_CREATE,
-         :PAGE_REORGANIZE, :UNDO_ERASE_END, :UNDO_HDR_DISCARD
-      {}
-    else
-      raise "Unsupported log record type: #{type.to_s}"
     end
+
+    # The bodies of the branches here are sometimes duplicates, but logically distinct.
+    # rubocop:disable Lint/DuplicateBranch
+    def read_payload(type, cursor)
+      case type
+      when :MLOG_1BYTE, :MLOG_2BYTE, :MLOG_4BYTE
+        {
+          page_offset: cursor.name("page_offset") { cursor.read_uint16 },
+          value: cursor.name("value") { cursor.read_ic_uint32 },
+        }
+      when :MLOG_8BYTE
+        {
+          offset: cursor.name("offset") { cursor.read_uint16 },
+          value: cursor.name("value") { cursor.read_ic_uint64 },
+        }
+      when :UNDO_HDR_CREATE, :UNDO_HDR_REUSE
+        {
+          trx_id: cursor.name("trx_id") { cursor.read_ic_uint64 },
+        }
+      when :UNDO_INSERT
+        {
+          length: length = cursor.name("length") { cursor.read_uint16 },
+          value: cursor.name("value") { cursor.read_bytes(length) },
+        }
+      when :REC_INSERT
+        {
+          record: cursor.name("record") { read_insert_record(cursor) },
+        }
+      when :COMP_REC_INSERT
+        {
+          index: cursor.name("index") { read_index(cursor) },
+          record: cursor.name("record") { read_insert_record(cursor) },
+        }
+      when :COMP_REC_UPDATE_IN_PLACE
+        {
+          index: cursor.name("index") { read_index(cursor) },
+          record: cursor.name("record") { read_update_in_place_record(cursor) },
+        }
+      when :REC_UPDATE_IN_PLACE
+        {
+          record: cursor.name("record") { read_update_in_place_record(cursor) },
+        }
+      when :WRITE_STRING
+        {
+          offset: cursor.name("offset") { cursor.read_uint16 },
+          length: length = cursor.name("length") { cursor.read_uint16 },
+          value: cursor.name("value") { cursor.read_bytes(length) },
+        }
+      when :UNDO_INIT
+        {
+          type: cursor.name("type") { UNDO_TYPES[cursor.read_ic_uint32] },
+        }
+      when :FILE_CREATE, :FILE_DELETE
+        {
+          name_len: name_len = cursor.name("name_len") { cursor.read_uint16 },
+          name: cursor.name("name") { cursor.read_bytes(name_len) },
+        }
+      when :FILE_CREATE2
+        {
+          flags: cursor.name("flags") { cursor.read_uint32 },
+          name_len: name_len = cursor.name("name_len") { cursor.read_uint16 },
+          name: cursor.name("name") { cursor.read_bytes(name_len) },
+        }
+      when :FILE_RENAME
+        {
+          old: {
+            name_len: name_len = cursor.name("name_len") { cursor.read_uint16 },
+            name: cursor.name("name") { cursor.read_bytes(name_len) },
+          },
+          new: {
+            name_len: name_len = cursor.name("name_len") { cursor.read_uint16 },
+            name: cursor.name("name") { cursor.read_bytes(name_len) },
+          },
+        }
+      when :COMP_REC_CLUST_DELETE_MARK
+        {
+          index: cursor.name("index") { read_index(cursor) },
+          record: cursor.name("record") { read_clust_delete_mark(cursor) },
+        }
+      when :REC_CLUST_DELETE_MARK
+        {
+          record: cursor.name("record") { read_clust_delete_mark(cursor) },
+        }
+      when :COMP_REC_SEC_DELETE_MARK
+        {
+          index: cursor.name("index") { read_index(cursor) },
+          value: cursor.name("value") { cursor.read_uint8 },
+          offset: cursor.name("offset") { cursor.read_uint16 },
+        }
+      when :REC_SEC_DELETE_MARK
+        {
+          value: cursor.name("value") { cursor.read_uint8 },
+          offset: cursor.name("offset") { cursor.read_uint16 },
+        }
+      when :REC_DELETE
+        {
+          offset: cursor.name("offset") { cursor.read_uint16 },
+        }
+      when :COMP_REC_DELETE
+        {
+          index: cursor.name("index") { read_index(cursor) },
+          offset: cursor.name("offset") { cursor.read_uint16 },
+        }
+      when :REC_MIN_MARK, :COMP_REC_MIN_MARK
+        {
+          offset: cursor.name("offset") { cursor.read_uint16 },
+        }
+      when :LIST_START_DELETE, :LIST_END_DELETE
+        {
+          offset: cursor.name("offset") { cursor.read_uint16 },
+        }
+      when :COMP_LIST_START_DELETE, :COMP_LIST_END_DELETE
+        {
+          index: cursor.name("index") { read_index(cursor) },
+          offset: cursor.name("offset") { cursor.read_uint16 },
+        }
+      when :LIST_END_COPY_CREATED
+        {
+          length: length = cursor.name("length") { cursor.read_uint32 },
+          data: cursor.name("data") { cursor.read_bytes(length) },
+        }
+      when :COMP_LIST_END_COPY_CREATE
+        {
+          index: cursor.name("index") { read_index(cursor) },
+          length: length = cursor.name("length") { cursor.read_uint32 },
+          data: cursor.name("data") { cursor.read_bytes(length) },
+        }
+      when :COMP_PAGE_REORGANIZE
+        {
+          index: cursor.name("index") { read_index(cursor) },
+        }
+      when :DUMMY_RECORD, :MULTI_REC_END, :INIT_FILE_PAGE,
+           :IBUF_BITMAP_INIT, :PAGE_CREATE, :COMP_PAGE_CREATE,
+           :PAGE_REORGANIZE, :UNDO_ERASE_END, :UNDO_HDR_DISCARD
+        {}
+      else
+        raise "Unsupported log record type: #{type}"
+      end
+    end
+    # rubocop:enable Lint/DuplicateBranch
   end
 end