innodb_ruby 0.9.16 → 0.11.0

data/lib/innodb/page/undo_log.rb

@@ -1,95 +1,109 @@
-# -*- encoding : utf-8 -*-
-
-class Innodb::Page::UndoLog < Innodb::Page
-  def pos_undo_page_header
-    pos_page_body
-  end
-
-  def size_undo_page_header
-    2 + 2 + 2 + Innodb::List::NODE_SIZE
-  end
-
-  def pos_undo_segment_header
-    pos_undo_page_header + size_undo_page_header
-  end
-
-  def size_undo_segment_header
-    2 + 2 + Innodb::FsegEntry::SIZE + Innodb::List::BASE_NODE_SIZE
-  end
-
-  def pos_undo_logs
-    pos_undo_segment_header + size_undo_segment_header
-  end
-
-  UNDO_PAGE_TYPES = {
-    1 => :insert,
-    2 => :update,
-  }
-
-  UNDO_SEGMENT_STATES = {
-    1 => :active,
-    2 => :cached,
-    3 => :to_free,
-    4 => :to_purge,
-    5 => :prepared,
-  }
-
-  def undo_page_header
-    @undo_page_header ||=
-      cursor(pos_undo_page_header).name("undo_page_header") do |c|
-      {
-        :type => c.name("type") { UNDO_PAGE_TYPES[c.get_uint16] },
-        :latest_log_record_offset => c.name("latest_log_record_offset") { c.get_uint16 },
-        :free_offset => c.name("free_offset") { c.get_uint16 },
-        :page_list_node => c.name("page_list") { Innodb::List.get_node(c) },
-      }
+# frozen_string_literal: true
+
+module Innodb
+  class Page
+    class UndoLog < Page
+      specialization_for :UNDO_LOG
+
+      PageHeader = Struct.new(
+        :type,
+        :latest_log_record_offset,
+        :free_offset,
+        :page_list_node,
+        keyword_init: true
+      )
+
+      SegmentHeader = Struct.new(
+        :state,
+        :last_log_offset,
+        :fseg,
+        :page_list,
+        keyword_init: true
+      )
+
+      def pos_undo_page_header
+        pos_page_body
+      end
+
+      def size_undo_page_header
+        2 + 2 + 2 + Innodb::List::NODE_SIZE
+      end
+
+      def pos_undo_segment_header
+        pos_undo_page_header + size_undo_page_header
+      end
+
+      def size_undo_segment_header
+        2 + 2 + Innodb::FsegEntry::SIZE + Innodb::List::BASE_NODE_SIZE
+      end
+
+      def pos_undo_logs
+        pos_undo_segment_header + size_undo_segment_header
+      end
+
+      UNDO_PAGE_TYPES = {
+        1 => :insert,
+        2 => :update,
+      }.freeze
+
+      UNDO_SEGMENT_STATES = {
+        1 => :active,
+        2 => :cached,
+        3 => :to_free,
+        4 => :to_purge,
+        5 => :prepared,
+      }.freeze
+
+      def undo_page_header
+        @undo_page_header ||= cursor(pos_undo_page_header).name("undo_page_header") do |c|
+          PageHeader.new(
+            type: c.name("type") { UNDO_PAGE_TYPES[c.read_uint16] },
+            latest_log_record_offset: c.name("latest_log_record_offset") { c.read_uint16 },
+            free_offset: c.name("free_offset") { c.read_uint16 },
+            page_list_node: c.name("page_list") { Innodb::List.get_node(c) }
+          )
+        end
+      end
+
+      def prev_address
+        undo_page_header[:page_list_node][:prev]
+      end
+
+      def next_address
+        undo_page_header[:page_list_node][:next]
+      end
+
+      def undo_segment_header
+        @undo_segment_header ||= cursor(pos_undo_segment_header).name("undo_segment_header") do |c|
+          SegmentHeader.new(
+            state: c.name("state") { UNDO_SEGMENT_STATES[c.read_uint16] },
+            last_log_offset: c.name("last_log_offset") { c.read_uint16 },
+            fseg: c.name("fseg") { Innodb::FsegEntry.get_inode(@space, c) },
+            page_list: c.name("page_list") { Innodb::List::UndoPage.new(@space, Innodb::List.get_base_node(c)) }
+          )
+        end
+      end
+
+      def undo_log(pos)
+        Innodb::UndoLog.new(self, pos)
+      end
+
+      # Dump the contents of a page for debugging purposes.
+      def dump
+        super
+
+        puts "undo page header:"
+        pp undo_page_header
+        puts
+
+        puts "undo segment header:"
+        pp undo_segment_header
+        puts
+
+        puts "last undo log:"
+        undo_log(undo_segment_header[:last_log_offset]).dump unless undo_segment_header[:last_log_offset].zero?
+        puts
+      end
     end
   end
-
-  def prev_address
-    undo_page_header[:page_list_node][:prev]
-  end
-
-  def next_address
-    undo_page_header[:page_list_node][:next]
-  end
-
-  def undo_segment_header
-    @undo_segment_header ||=
-      cursor(pos_undo_segment_header).name("undo_segment_header") do |c|
-      {
-        :state => c.name("state") { UNDO_SEGMENT_STATES[c.get_uint16] },
-        :last_log_offset => c.name("last_log_offset") { c.get_uint16 },
-        :fseg => c.name("fseg") { Innodb::FsegEntry.get_inode(@space, c) },
-        :page_list => c.name("page_list") {
-          Innodb::List::UndoPage.new(@space, Innodb::List.get_base_node(c))
-        },
-      }
-    end
-  end
-
-  def undo_log(pos)
-    Innodb::UndoLog.new(self, pos)
-  end
-
-  # Dump the contents of a page for debugging purposes.
-  def dump
-    super
-
-    puts "undo page header:"
-    pp undo_page_header
-    puts
-
-    puts "undo segment header:"
-    pp undo_segment_header
-    puts
-
-    puts "last undo log:"
-    if undo_segment_header[:last_log_offset] != 0
-      undo_log(undo_segment_header[:last_log_offset]).dump
-    end
-    puts
-  end
 end
-
-Innodb::Page::SPECIALIZED_CLASSES[:UNDO_LOG] = Innodb::Page::UndoLog

data/lib/innodb/record.rb

@@ -1,195 +1,156 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
-class Innodb::Record
-  attr_reader :page
-  attr_accessor :record
+require "forwardable"
 
-  def initialize(page, record)
-    @page = page
-    @record = record
-  end
-
-  def header
-    record[:header]
-  end
-
-  def type
-    header[:type]
-  end
-
-  def heap_number
-    header[:heap_number]
-  end
-
-  def n_owned
-    header[:n_owned]
-  end
-
-  def deleted?
-    header[:deleted]
-  end
-
-  def min_rec?
-    header[:min_rec]
-  end
+module Innodb
+  class Record
+    extend Forwardable
 
-  def offset
-    record[:offset]
-  end
-
-  def length
-    record[:length]
-  end
+    attr_reader :page
+    attr_accessor :record
 
-  def next
-    record[:next]
-  end
-
-  def key
-    record[:key]
-  end
+    def initialize(page, record)
+      @page = page
+      @record = record
+    end
 
-  def key_string
-    key && key.map { |r| "%s=%s" % [r[:name], r[:value].inspect] }.join(", ")
-  end
+    def_delegator :record, :header
+    def_delegator :record, :offset
+    def_delegator :record, :length
+    def_delegator :record, :next
+    def_delegator :record, :key
+    def_delegator :record, :row
+    def_delegator :record, :transaction_id
+    def_delegator :record, :roll_pointer
+    def_delegator :record, :child_page_number
+
+    def_delegator :header, :type
+    def_delegator :header, :heap_number
+    def_delegator :header, :n_owned
+    def_delegator :header, :heap_number
+    def_delegator :header, :deleted?
+    def_delegator :header, :min_rec?
+
+    def key_string
+      key&.map { |r| "%s=%s" % [r.name, r.value.inspect] }&.join(", ")
+    end
 
-  def row
-    record[:row]
-  end
+    def row_string
+      row&.map { |r| "%s=%s" % [r.name, r.value.inspect] }&.join(", ")
+    end
 
-  def row_string
-    row && row.map { |r| "%s=%s" % [r[:name], r[:value].inspect] }.join(", ")
-  end
+    def undo
+      return nil unless roll_pointer
+      return unless (innodb_system = @page.space.innodb_system)
 
-  def transaction_id
-    record[:transaction_id]
-  end
+      undo_page = innodb_system.system_space.page(roll_pointer.undo_log.page)
+      return unless undo_page
 
-  def roll_pointer
-    record[:roll_pointer]
-  end
+      new_undo_record = Innodb::UndoRecord.new(undo_page, roll_pointer.undo_log.offset)
+      new_undo_record.index_page = page
+      new_undo_record
+    end
 
-  def undo
-    return nil unless roll_pointer
+    def each_undo_record
+      return enum_for(:each_undo_record) unless block_given?
 
-    if innodb_system = @page.space.innodb_system
-      undo_space = innodb_system.system_space
-      if undo_page = undo_space.page(roll_pointer[:undo_log][:page])
-        new_undo_record = Innodb::UndoRecord.new(undo_page, roll_pointer[:undo_log][:offset])
-        new_undo_record.index_page = page
-        new_undo_record
+      undo_record = undo
+      while undo_record
+        yield undo_record
+        undo_record = undo_record.prev_by_history
       end
-    end
-  end
 
-  def each_undo_record
-    unless block_given?
-      return enum_for(:each_undo_record)
+      nil
     end
 
-    undo_record = undo
-    while undo_record
-      yield undo_record
-      undo_record = undo_record.prev_by_history
-    end
-
-    nil
-  end
-
-  def child_page_number
-    record[:child_page_number]
-  end
-
-  def string
-    if child_page_number
-      "(%s) → #%s" % [key_string, child_page_number]
-    else
-      "(%s) → (%s)" % [key_string, row_string]
+    def string
+      if child_page_number
+        "(%s) → #%s" % [key_string, child_page_number]
+      else
+        "(%s) → (%s)" % [key_string, row_string]
+      end
     end
-  end
 
-  def uncached_fields
-    fields_hash = {}
-    [:key, :row].each do |group|
-      if record[group]
-        record[group].each do |column|
-          fields_hash[column[:name]] = column[:value]
+    def uncached_fields
+      fields_hash = {}
+      %i[key row].each do |group|
+        record[group]&.each do |column|
+          fields_hash[column.name] = column.value
         end
       end
+      fields_hash
     end
-    fields_hash
-  end
 
-  def fields
-    @fields ||= uncached_fields
-  end
+    def fields
+      @fields ||= uncached_fields
+    end
+
+    # Compare two arrays of fields to determine if they are equal. This follows
+    # the same comparison rules as strcmp and others:
+    #   0 = a is equal to b
+    #   -1 = a is less than b
+    #   +1 = a is greater than b
+    def compare_key(other_key)
+      Innodb::Stats.increment :compare_key
+
+      return 0 if other_key.nil? && key.nil?
+      return -1 if other_key.nil? || (!key.nil? && other_key.size < key.size)
+      return +1 if key.nil? || (!other_key.nil? && other_key.size > key.size)
+
+      key.each_index do |i|
+        Innodb::Stats.increment :compare_key_field_comparison
+        return -1 if other_key[i] < key[i].value
+        return +1 if other_key[i] > key[i].value
+      end
 
-  # Compare two arrays of fields to determine if they are equal. This follows
-  # the same comparison rules as strcmp and others:
-  #   0 = a is equal to b
-  #   -1 = a is less than b
-  #   +1 = a is greater than b
-  def compare_key(other_key)
-    Innodb::Stats.increment :compare_key
-
-    return 0 if other_key.nil? && key.nil?
-    return -1 if other_key.nil? || (!key.nil? && other_key.size < key.size)
-    return +1 if key.nil? || (!other_key.nil? && other_key.size > key.size)
-
-    key.each_index do |i|
-      Innodb::Stats.increment :compare_key_field_comparison
-      return -1 if other_key[i] < key[i][:value]
-      return +1 if other_key[i] > key[i][:value]
+      0
     end
 
-    return 0
-  end
+    def dump
+      puts "Record at offset %i" % offset
+      puts
 
-  def dump
-    puts "Record at offset %i" % offset
-    puts
-
-    puts "Header:"
-    puts "  %-20s: %i" % ["Next record offset", header[:next]]
-    puts "  %-20s: %i" % ["Heap number", header[:heap_number]]
-    puts "  %-20s: %s" % ["Type", header[:type]]
-    puts "  %-20s: %s" % ["Deleted", header[:deleted]]
-    puts "  %-20s: %s" % ["Length", header[:length]]
-    puts
-
-    if page.leaf?
-      puts "System fields:"
-      puts "  Transaction ID: %s" % transaction_id
-      puts "  Roll Pointer:"
-      puts "    Undo Log: page %i, offset %i" % [
-        roll_pointer[:undo_log][:page],
-        roll_pointer[:undo_log][:offset],
-      ]
-      puts "    Rollback Segment ID: %i" % roll_pointer[:rseg_id]
-      puts "    Insert: %s" % roll_pointer[:is_insert]
+      puts "Header:"
+      puts "  %-20s: %i" % ["Next record offset", header.next]
+      puts "  %-20s: %i" % ["Heap number", header.heap_number]
+      puts "  %-20s: %s" % ["Type", header.type]
+      puts "  %-20s: %s" % ["Deleted", header.deleted?]
+      puts "  %-20s: %s" % ["Length", header.length]
       puts
-    end
 
-    puts "Key fields:"
-    key.each do |field|
-      puts "  %s: %s" % [
-        field[:name],
-        field[:value].inspect,
-      ]
-    end
-    puts
+      if page.leaf?
+        puts "System fields:"
+        puts "  Transaction ID: %s" % transaction_id
+        puts "  Roll Pointer:"
+        puts "    Undo Log: page %i, offset %i" % [
+          roll_pointer.undo_log.page,
+          roll_pointer.undo_log.offset,
+        ]
+        puts "    Rollback Segment ID: %i" % roll_pointer.rseg_id
+        puts "    Insert: %s" % roll_pointer.is_insert
+        puts
+      end
 
-    if page.leaf?
-      puts "Non-key fields:"
-      row.each do |field|
+      puts "Key fields:"
+      key.each do |field|
         puts "  %s: %s" % [
-          field[:name],
-          field[:value].inspect,
+          field.name,
+          field.value.inspect,
         ]
       end
       puts
-    else
-      puts "Child page number: %i" % child_page_number
+
+      if page.leaf?
+        puts "Non-key fields:"
+        row.each do |field|
+          puts "  %s: %s" % [
+            field.name,
+            field.value.inspect,
+          ]
+        end
+      else
+        puts "Child page number: %i" % child_page_number
+      end
       puts
     end
   end