innodb_ruby 0.9.16 → 0.11.0

data/lib/innodb/field.rb

@@ -1,114 +1,127 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 require "innodb/data_type"
 
 # A single field in an InnoDB record (within an INDEX page). This class
 # provides essential information to parse records, including the length
 # of the fixed-width and variable-width portion of the field.
-class Innodb::Field
-  attr_reader :position, :name, :data_type, :nullable
-
-  # Size of a reference to data stored externally to the page.
-  EXTERN_FIELD_SIZE = 20
-
-  def initialize(position, name, type_definition, *properties)
-    @position = position
-    @name = name
-    @nullable = properties.delete(:NOT_NULL) ? false : true
-    base_type, modifiers = parse_type_definition(type_definition.to_s)
-    @data_type = Innodb::DataType.new(base_type, modifiers, properties)
-  end
+module Innodb
+  class Field
+    ExternReference = Struct.new(
+      :space_id,
+      :page_number,
+      :offset,
+      :length, # rubocop:disable Lint/StructNewOverride
+      keyword_init: true
+    )
+
+    attr_reader :position
+    attr_reader :name
+    attr_reader :data_type
+    attr_reader :nullable
+
+    # Size of a reference to data stored externally to the page.
+    EXTERN_FIELD_SIZE = 20
+
+    def initialize(position, name, type_definition, *properties)
+      @position = position
+      @name = name
+      @nullable = !properties.delete(:NOT_NULL)
+      base_type, modifiers = parse_type_definition(type_definition.to_s)
+      @data_type = Innodb::DataType.new(base_type, modifiers, properties)
+    end
 
-  # Return whether this field can be NULL.
-  def nullable?
-    @nullable
-  end
+    # Return whether this field can be NULL.
+    def nullable?
+      @nullable
+    end
 
-  # Return whether this field is NULL.
-  def null?(record)
-    nullable? && record[:header][:nulls].include?(@name)
-  end
+    # Return whether this field is NULL.
+    def null?(record)
+      nullable? && record.header.nulls.include?(@name)
+    end
 
-  # Return whether a part of this field is stored externally (off-page).
-  def extern?(record)
-    record[:header][:externs].include?(@name)
-  end
+    # Return whether a part of this field is stored externally (off-page).
+    def extern?(record)
+      record.header.externs.include?(@name)
+    end
 
-  def variable?
-    @data_type.is_a? Innodb::DataType::BlobType or
-    @data_type.is_a? Innodb::DataType::VariableBinaryType or
-    @data_type.is_a? Innodb::DataType::VariableCharacterType
-  end
+    def variable?
+      [
+        Innodb::DataType::BlobType,
+        Innodb::DataType::VariableBinaryType,
+        Innodb::DataType::VariableCharacterType,
+      ].any? { |c| @data_type.is_a?(c) }
+    end
 
-  def blob?
-    @data_type.is_a? Innodb::DataType::BlobType
-  end
+    def blob?
+      @data_type.is_a?(Innodb::DataType::BlobType)
+    end
 
-  # Return the actual length of this variable-length field.
-  def length(record)
-    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
+    # Return the actual length of this variable-length field.
+    def length(record)
+      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
+      extern?(record) ? len - EXTERN_FIELD_SIZE : len
     end
-    extern?(record) ? len - EXTERN_FIELD_SIZE : len
-  end
 
-  # Read an InnoDB encoded data field.
-  def read(cursor, field_length)
-    cursor.name(@data_type.name) { cursor.get_bytes(field_length) }
-  end
+    # Read an InnoDB encoded data field.
+    def read(cursor, field_length)
+      cursor.name(@data_type.name) { cursor.read_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)
+    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
-  end
 
-  # Read the data value (e.g. encoded in the data).
-  def value(cursor, record)
-    return :NULL if null?(record)
-    value_by_length(cursor, length(record))
-  end
+    # Read the data value (e.g. encoded in the data).
+    def value(cursor, record)
+      return :NULL if null?(record)
 
-  # Read an InnoDB external pointer field.
-  def extern(cursor, record)
-    return nil if not extern?(record)
-    cursor.name(@name) { read_extern(cursor) }
-  end
+      value_by_length(cursor, length(record))
+    end
 
-  private
-
-  # Return an external reference field. An extern field contains the page
-  # address and the length of the externally stored part of the record data.
-  def get_extern_reference(cursor)
-    {
-      :space_id     => cursor.name("space_id")    { cursor.get_uint32 },
-      :page_number  => cursor.name("page_number") { cursor.get_uint32 },
-      :offset       => cursor.name("offset")      { cursor.get_uint32 },
-      :length       => cursor.name("length")      { cursor.get_uint64 & 0x3fffffff }
-    }
-  end
+    # Read an InnoDB external pointer field.
+    def extern(cursor, record)
+      return unless extern?(record)
 
-  def read_extern(cursor)
-    cursor.name("extern") { get_extern_reference(cursor) }
-  end
+      cursor.name(@name) { read_extern(cursor) }
+    end
 
-  # 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)
-      base_type = matches[1].upcase.to_sym
-      if matches[3]
-        modifiers = matches[3].sub(/[ ]/, "").split(/,/).map { |s| s.to_i }
-      else
-        modifiers = []
+    private
+
+    # Return an external reference field. An extern field contains the page
+    # address and the length of the externally stored part of the record data.
+    def read_extern(cursor)
+      cursor.name("extern") do |c|
+        ExternReference.new(
+          space_id: c.name("space_id") { c.read_uint32 },
+          page_number: c.name("page_number") { c.read_uint32 },
+          offset: c.name("offset") { c.read_uint32 },
+          length: c.name("length") { c.read_uint64 & 0x3fffffff }
+        )
       end
-      [base_type, modifiers]
+    end
+
+    # Parse a data type definition and extract the base type and any modifiers.
+    def parse_type_definition(type_string)
+      matches = /^([a-zA-Z0-9_]+)(\(([0-9, ]+)\))?$/.match(type_string)
+      return unless matches
+
+      base_type = matches[1].upcase.to_sym
+      return [base_type, []] unless matches[3]
+
+      [base_type, matches[3].sub(/ /, "").split(/,/).map(&:to_i)]
     end
   end
 end

data/lib/innodb/fseg_entry.rb

@@ -1,36 +1,32 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 # An InnoDB file segment entry, which appears in a few places, such as the
 # FSEG header of INDEX pages, and in the TRX_SYS pages.
 
-class Innodb::FsegEntry
-  # The size (in bytes) of an FSEG entry, which contains a two 32-bit integers
-  # and a 16-bit integer.
-  SIZE = 4 + 4 + 2
+module Innodb
+  class FsegEntry
+    # The size (in bytes) of an FSEG entry, which contains a two 32-bit integers
+    # and a 16-bit integer.
+    SIZE = 4 + 4 + 2
 
-  # Return the FSEG entry address, which points to an entry on an INODE page.
-  def self.get_entry_address(cursor)
-    {
-      :space_id     => cursor.name("space_id")    { cursor.get_uint32 },
-      :page_number  => cursor.name("page_number") {
-        Innodb::Page.maybe_undefined(cursor.get_uint32)
-      },
-      :offset       => cursor.name("offset")      { cursor.get_uint16 },
-    }
-  end
-
-  # Return an INODE entry which represents this file segment.
-  def self.get_inode(space, cursor)
-    address = cursor.name("address") { get_entry_address(cursor) }
-    if address[:offset] == 0
-      return nil
+    # Return the FSEG entry address, which points to an entry on an INODE page.
+    def self.get_entry_address(cursor)
+      {
+        space_id: cursor.name("space_id") { cursor.read_uint32 },
+        page_number: cursor.name("page_number") { Innodb::Page.maybe_undefined(cursor.read_uint32) },
+        offset: cursor.name("offset") { cursor.read_uint16 },
+      }
     end
 
-    page = space.page(address[:page_number])
-    if page.type != :INODE
-      return nil
-    end
+    # Return an INODE entry which represents this file segment.
+    def self.get_inode(space, cursor)
+      address = cursor.name("address") { get_entry_address(cursor) }
+      return nil if address[:offset].zero?
 
-    page.inode_at(page.cursor(address[:offset]))
+      page = space.page(address[:page_number])
+      return nil unless page.type == :INODE
+
+      page.inode_at(page.cursor(address[:offset]))
+    end
   end
 end

data/lib/innodb/history.rb

@@ -1,30 +1,30 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 # 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
+module Innodb
+  class History
+    def initialize(innodb_system)
+      @innodb_system = innodb_system
+    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
+    # A helper to get to the trx_sys page in the Innodb::System.
+    def trx_sys
+      @innodb_system.system_space.trx_sys
+    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)
+    # 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
 
-    trx_sys.rsegs.each do |slot|
-      yield history_list(slot[:space_id], slot[:page_number])
+    # Iterate through all history lists (one per rollback segment, nominally
+    # there are 128 rollback segments).
+    def each_history_list
+      return enum_for(:each_history_list) unless block_given?
+
+      trx_sys.rsegs.each do |slot|
+        yield history_list(slot[:space_id], slot[:page_number])
+      end
     end
   end
 end

data/lib/innodb/history_list.rb

@@ -1,106 +1,102 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 # 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
+module Innodb
+  class 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
+    # Initialize from a provided Innodb::List::History.
+    def initialize(list)
+      @list = list
+    end
 
-      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)
+    class UndoRecordCursor
+      def initialize(history, undo_record, direction = :forward)
+        @history = history
+        @undo_record = undo_record
+
+        # rubocop:disable Style/IfUnlessModifier
+        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
-      else
-        raise "Not implemented"
+        # rubocop:enable Style/IfUnlessModifier
       end
-    end
 
-    def undo_record
-      unless @undo_record_cursor
-        return nil
-      end
+      def undo_record
+        return nil unless @undo_record_cursor
 
-      if rec = @undo_record_cursor.undo_record
-        return rec
-      end
+        if (rec = @undo_record_cursor.undo_record)
+          return rec
+        end
 
-      case @direction
-      when :forward
-        next_undo_record
-      when :backward
-        prev_undo_record
+        case @direction
+        when :forward
+          next_undo_record
+        when :backward
+          prev_undo_record
+        end
       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
+      def move_cursor(page, undo_record)
+        @undo_log = page
+        @undo_log_cursor = @undo_log.undo_record_cursor(undo_record, @direction)
       end
 
-      if undo_log = @undo_log_cursor.node
-        @undo_log = undo_log
-        @undo_record_cursor = @undo_log.undo_record_cursor(:min, @direction)
-      end
+      def next_undo_record
+        if (rec = @undo_record_cursor.undo_record)
+          return rec
+        end
 
-      @undo_record_cursor.undo_record
-    end
+        if (undo_log = @undo_log_cursor.node)
+          @undo_log = undo_log
+          @undo_record_cursor = @undo_log.undo_record_cursor(:min, @direction)
+        end
 
-    def prev_undo_record
-      if rec = @undo_log_cursor.undo_record
-        return rec
+        @undo_record_cursor.undo_record
       end
 
-      if undo_log = @undo_log_cursor.node
-        @undo_log = undo_log
-        @undo_record_cursor = @undo_log.undo_record_cursor(:max, @direction)
-      end
+      def prev_undo_record
+        if (rec = @undo_log_cursor.undo_record)
+          return rec
+        end
 
-      @undo_record_cursor.undo_record
-    end
+        if (undo_log = @undo_log_cursor.node)
+          @undo_log = undo_log
+          @undo_record_cursor = @undo_log.undo_record_cursor(:max, @direction)
+        end
 
-    def each_undo_record
-      unless block_given?
-        return enum_for(:each_undo_record)
+        @undo_record_cursor.undo_record
       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(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)
+    def undo_record_cursor(undo_record = :min, direction = :forward)
+      UndoRecordCursor.new(self, undo_record, direction)
     end
 
-    undo_record_cursor.each_undo_record do |rec|
-      yield rec
+    def each_undo_record(&block)
+      return enum_for(:each_undo_record) unless block_given?
+
+      undo_record_cursor.each_undo_record(&block)
     end
   end
 end