innodb_ruby 0.9.16 → 0.11.0

data/lib/innodb/util/buffer_cursor.rb

@@ -1,4 +1,4 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 require "bindata"
 
@@ -17,7 +17,7 @@ class BufferCursor
     attr_accessor :direction
     attr_accessor :name
 
-    def initialize(cursor, position=0, direction=:forward, name=nil)
+    def initialize(cursor, position = 0, direction = :forward, name = nil)
       @cursor = cursor
       @position = position
       @direction = direction
@@ -37,21 +37,25 @@ class BufferCursor
     end
   end
 
-  @@global_tracing = false
+  @global_tracing = false
 
   # Enable tracing for all BufferCursor objects globally.
-  def self.trace!(arg=true)
-    @@global_tracing = arg
+  def self.trace!(arg = true) # rubocop:disable Style/OptionalBooleanParameter
+    @global_tracing = arg
+  end
+
+  def self.global_tracing?
+    @global_tracing
   end
 
   # Initialize a cursor within a buffer at the given position.
   def initialize(buffer, position)
     @buffer = buffer
-    @stack = [ StackEntry.new(self, position) ]
+    @stack = [StackEntry.new(self, position)]
 
     trace false
     trace_with :print_trace
-    trace_to STDOUT
+    trace_to $stdout
   end
 
   def inspect
@@ -62,46 +66,49 @@ class BufferCursor
     ]
   end
 
-  def trace(arg=true)
+  def trace(arg = true) # rubocop:disable Style/OptionalBooleanParameter
     @instance_tracing = arg
+
     self
   end
 
   # Print a trace output for this cursor. The method is passed a cursor object,
   # position, raw byte buffer, and array of names.
-  def print_trace(cursor, position, bytes, name)
+  def print_trace(_cursor, position, bytes, name)
     slice_size = 16
     bytes.each_slice(slice_size).each_with_index do |slice_bytes, slice_count|
       @trace_io.puts "%06i %s %-32s  %s" % [
         position + (slice_count * slice_size),
         direction == :backward ? "←" : "→",
         slice_bytes.map { |n| "%02x" % n }.join,
-        slice_count == 0 ? name.join(".") : "↵",
+        slice_count.zero? ? name.join(".") : "↵",
       ]
     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)
+  def trace_with(arg = nil)
     if arg.nil?
       @trace_proc = nil
-    elsif arg.class == Proc
+    elsif arg.instance_of?(Proc)
       @trace_proc = arg
-    elsif arg.class == Symbol
-      @trace_proc = lambda { |cursor, position, bytes, name| self.send(arg, cursor, position, bytes, name) }
+    elsif arg.instance_of?(Symbol)
+      @trace_proc = ->(cursor, position, bytes, name) { send(arg, cursor, position, bytes, name) }
     else
       raise "Don't know how to trace with #{arg}"
     end
+
     self
   end
 
   def tracing_enabled?
-    (@@global_tracing or @instance_tracing) && @trace_proc
+    (self.class.global_tracing? || @instance_tracing) && @trace_proc
   end
 
   # Generate a trace record from the current cursor.
@@ -123,14 +130,10 @@ class BufferCursor
   end
 
   # Set the field name.
-  def name(name_arg=nil)
-    if name_arg.nil?
-      return current.name
-    end
+  def name(name_arg = nil)
+    return current.name if name_arg.nil?
 
-    unless block_given?
-      raise "No block given"
-    end
+    raise "No block given" unless block_given?
 
     current.name.push name_arg
     ret = yield(self)
@@ -139,12 +142,11 @@ class BufferCursor
   end
 
   # Return the direction of the current cursor.
-  def direction(direction_arg=nil)
-    if direction_arg.nil?
-      return current.direction
-    end
+  def direction(direction_arg = nil)
+    return current.direction if direction_arg.nil?
 
     current.direction = direction_arg
+
     self
   end
 
@@ -166,34 +168,40 @@ class BufferCursor
   # Move the current cursor to a new absolute position.
   def seek(position)
     current.position = position if position
+
     self
   end
 
   # Adjust the current cursor to a new relative position.
   def adjust(relative_position)
     current.position += relative_position
+
     self
   end
 
   # Save the current cursor position and start a new (nested, stacked) cursor.
-  def push(position=nil)
+  def push(position = nil)
     @stack.push current.dup
     seek(position)
+
     self
   end
 
   # Restore the last cursor position.
   def pop
     raise "No cursors to pop" unless @stack.size > 1
+
     @stack.pop
+
     self
   end
 
   # Execute a block and restore the cursor to the previous position after
   # the block returns. Return the block's return value after restoring the
   # cursor. Optionally seek to provided position before executing block.
-  def peek(position=nil)
+  def peek(position = nil)
     raise "No block given" unless block_given?
+
     push(position)
     result = yield(self)
     pop
@@ -219,105 +227,101 @@ class BufferCursor
   end
 
   # Return raw bytes.
-  def get_bytes(length)
+  def read_bytes(length)
     read_and_advance(length)
   end
 
   # Return a null-terminated string.
-  def get_string(length)
+  def read_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)
-    end
+  def each_byte_as_uint8(length, &block)
+    return enum_for(:each_byte_as_uint8, length) unless block_given?
 
-    read_and_advance(length).bytes.each do |byte|
-      yield byte
-    end
+    read_and_advance(length).bytes.each(&block)
 
     nil
   end
 
   # Return raw bytes as hex.
-  def get_hex(length)
+  def read_hex(length)
     read_and_advance(length).bytes.map { |c| "%02x" % c }.join
   end
 
   # Read an unsigned 8-bit integer.
-  def get_uint8(position=nil)
+  def read_uint8(position = nil)
     seek(position)
     data = read_and_advance(1)
     BinData::Uint8.read(data).to_i
   end
 
   # Read a big-endian unsigned 16-bit integer.
-  def get_uint16(position=nil)
+  def read_uint16(position = nil)
     seek(position)
     data = read_and_advance(2)
     BinData::Uint16be.read(data).to_i
   end
 
   # Read a big-endian signed 16-bit integer.
-  def get_sint16(position=nil)
+  def read_sint16(position = nil)
     seek(position)
     data = read_and_advance(2)
     BinData::Int16be.read(data).to_i
   end
 
   # Read a big-endian unsigned 24-bit integer.
-  def get_uint24(position=nil)
+  def read_uint24(position = nil)
     seek(position)
     data = read_and_advance(3)
     BinData::Uint24be.read(data).to_i
   end
 
   # Read a big-endian unsigned 32-bit integer.
-  def get_uint32(position=nil)
+  def read_uint32(position = nil)
     seek(position)
     data = read_and_advance(4)
     BinData::Uint32be.read(data).to_i
   end
 
   # Read a big-endian unsigned 48-bit integer.
-  def get_uint48(position=nil)
+  def read_uint48(position = nil)
     seek(position)
     data = read_and_advance(6)
     BinData::Uint48be.read(data).to_i
   end
 
   # Read a big-endian unsigned 64-bit integer.
-  def get_uint64(position=nil)
+  def read_uint64(position = nil)
     seek(position)
     data = read_and_advance(8)
     BinData::Uint64be.read(data).to_i
   end
 
   # Read a big-endian unsigned integer given its size in bytes.
-  def get_uint_by_size(size)
+  def read_uint_by_size(size)
     case size
     when 1
-      get_uint8
+      read_uint8
     when 2
-      get_uint16
+      read_uint16
     when 3
-      get_uint24
+      read_uint24
     when 4
-      get_uint32
+      read_uint32
     when 6
-      get_uint48
+      read_uint48
     when 8
-      get_uint64
+      read_uint64
     else
       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 }
+  def read_uint_array_by_size(size, count)
+    count.times.map { read_uint_by_size(size) }
   end
 
   # Read an InnoDB-compressed unsigned 32-bit integer (1-5 bytes).
@@ -327,30 +331,28 @@ class BufferCursor
   # 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
+  # the case in read_imc_uint64).
+  def read_ic_uint32(flag = nil)
+    name("ic_uint32") do
+      flag ||= peek { name("uint8_or_flag") { read_uint8 } }
 
       case
       when flag < 0x80
         adjust(+1)
         flag
       when flag < 0xc0
-        name("uint16") { get_uint16 } & 0x7fff
+        name("uint16") { read_uint16 } & 0x7fff
       when flag < 0xe0
-        name("uint24") { get_uint24 } & 0x3fffff
+        name("uint24") { read_uint24 } & 0x3fffff
       when flag < 0xf0
-        name("uint32") { get_uint32 } & 0x1fffffff
+        name("uint32") { read_uint32 } & 0x1fffffff
       when flag == 0xf0
         adjust(+1) # Skip the flag byte.
-        name("uint32+1") { get_uint32 }
+        name("uint32+1") { read_uint32 }
       else
-        raise "Invalid flag #{flag.to_s} seen"
+        raise "Invalid flag #{flag} seen"
       end
-    }
+    end
   end
 
   # Read an InnoDB-compressed unsigned 64-bit integer (5-9 bytes).
@@ -359,13 +361,13 @@ class BufferCursor
   # 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 } }
+  def read_ic_uint64
+    name("ic_uint64") do
+      high = name("high") { read_ic_uint32 }
+      low = name("low") { name("uint32") { read_uint32 } }
 
       (high << 32) | low
-    }
+    end
   end
 
   # Read an InnoDB-"much compressed" unsigned 64-bit integer (1-11 bytes).
@@ -376,31 +378,31 @@ class BufferCursor
   # 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") {
+  def read_imc_uint64
+    name("imc_uint64") do
       high = 0
-      flag = peek { name("uint8_or_flag") { get_uint8 } }
+      flag = peek { name("uint8_or_flag") { read_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 }
+        high = name("high") { read_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) }
+      low = name("low") { read_ic_uint32(flag) }
 
       (high << 32) | low
-    }
+    end
   end
 
   # Read an array of 1-bit integers.
-  def get_bit_array(num_bits)
+  def read_bit_array(num_bits)
     size = (num_bits + 7) / 8
     data = read_and_advance(size)
-    bit_array = BinData::Array.new(:type => :bit1, :initial_length => size * 8)
+    bit_array = BinData::Array.new(type: :bit1, initial_length: size * 8)
     bit_array.read(data).to_ary
   end
 end

data/lib/innodb/util/read_bits_at_offset.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ReadBitsAtOffset
   # Read a given number of bits from an integer at a specific bit offset. The
   # value returned is 0-based so does not need further shifting or adjustment.
@@ -5,4 +7,3 @@ module ReadBitsAtOffset
     ((data & (((1 << bits) - 1) << offset)) >> offset)
   end
 end
-

data/lib/innodb/version.rb

@@ -1,5 +1,5 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 module Innodb
-  VERSION = "0.9.16"
+  VERSION = "0.11.0"
 end

data/lib/innodb/xdes.rb

@@ -1,166 +1,168 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
+require "forwardable"
 
 # An InnoDB "extent descriptor entry" or "+XDES+". These structures are used
 # in the +XDES+ entry array contained in +FSP_HDR+ and +XDES+ pages.
 #
 # Note the distinction between +XDES+ _entries_ and +XDES+ _pages_.
-class Innodb::Xdes
-  # Number of bits per page in the +XDES+ entry bitmap field. Currently
-  # +XDES+ entries store two bits per page, with the following meanings:
-  #
-  # * 1 = free (the page is free, or not in use)
-  # * 2 = clean (currently unused, always 1 when initialized)
-  BITS_PER_PAGE = 2
-
-  # The bit value for a free page.
-  BITMAP_BV_FREE  = 1
-
-  # The bit value for a clean page (currently unused in InnoDB).
-  BITMAP_BV_CLEAN = 2
-
-  # The bitwise-OR of all bitmap bit values.
-  BITMAP_BV_ALL = (BITMAP_BV_FREE | BITMAP_BV_CLEAN)
-
-  # The values used in the +:state+ field indicating what the extent is
-  # used for (or what list it is on).
-  STATES = {
-    1 => :free,       # The extent is completely empty and unused, and should
-                      # be present on the filespace's FREE list.
-
-    2 => :free_frag,  # Some pages of the extent are used individually, and
-                      # the extent should be present on the filespace's
-                      # FREE_FRAG list.
-
-    3 => :full_frag,  # All pages of the extent are used individually, and
-                      # the extent should be present on the filespace's
-                      # FULL_FRAG list.
-
-    4 => :fseg,       # The extent is wholly allocated to a file segment.
-                      # Additional information about the state of this extent
-                      # can be derived from the its presence on particular
-                      # file segment lists (FULL, NOT_FULL, or FREE).
-  }
-
-  def initialize(page, cursor)
-    @page = page
-    @xdes = read_xdes_entry(page, cursor)
-  end
+module Innodb
+  class Xdes
+    # An XDES entry structure.
+    Entry = Struct.new(:offset, :start_page, :end_page, :fseg_id, :this, :list, :state, :bitmap, keyword_init: true)
+
+    PageStatus = Struct.new(:free, :clean, keyword_init: true)
+
+    # Number of bits per page in the +XDES+ entry bitmap field. Currently
+    # +XDES+ entries store two bits per page, with the following meanings:
+    #
+    # * 1 = free (the page is free, or not in use)
+    # * 2 = clean (currently unused, always 1 when initialized)
+    BITS_PER_PAGE = 2
+
+    # The bit value for a free page.
+    BITMAP_BV_FREE  = 1
+
+    # The bit value for a clean page (currently unused in InnoDB).
+    BITMAP_BV_CLEAN = 2
+
+    # The bitwise-OR of all bitmap bit values.
+    BITMAP_BV_ALL = (BITMAP_BV_FREE | BITMAP_BV_CLEAN)
+
+    # The values used in the +:state+ field indicating what the extent is
+    # used for (or what list it is on).
+    STATES = {
+      # The extent is completely empty and unused, and should be present on the filespace's FREE list.
+      1 => :free,
+
+      # Some pages of the extent are used individually, and the extent should be present on the filespace's
+      # FREE_FRAG list.
+      2 => :free_frag,
+
+      # All pages of the extent are used individually, and the extent should be present on the filespace's
+      # FULL_FRAG list.
+      3 => :full_frag,
+
+      # The extent is wholly allocated to a file segment. Additional information about the state of this extent can
+      # be derived from the its presence on particular file segment lists (FULL, NOT_FULL, or FREE).
+      4 => :fseg,
+    }.freeze
+
+    attr_reader :xdes
+
+    extend Forwardable
+
+    def_delegator :xdes, :offset
+    def_delegator :xdes, :start_page
+    def_delegator :xdes, :end_page
+    def_delegator :xdes, :fseg_id
+    def_delegator :xdes, :this
+    def_delegator :xdes, :list
+    def_delegator :xdes, :state
+    def_delegator :xdes, :bitmap
+
+    def initialize(page, cursor)
+      @page = page
+      @xdes = read_xdes_entry(page, cursor)
+    end
 
-  # Size (in bytes) of the bitmap field in the +XDES+ entry.
-  def size_bitmap
-    (@page.space.pages_per_extent * BITS_PER_PAGE) / 8
-  end
+    # Size (in bytes) of the bitmap field in the +XDES+ entry.
+    def size_bitmap
+      (@page.space.pages_per_extent * BITS_PER_PAGE) / 8
+    end
 
-  # Size (in bytes) of the an +XDES+ entry.
-  def size_entry
-    8 + Innodb::List::NODE_SIZE + 4 + size_bitmap
-  end
+    # Size (in bytes) of the an +XDES+ entry.
+    def size_entry
+      8 + Innodb::List::NODE_SIZE + 4 + size_bitmap
+    end
 
-  # Read an XDES entry from a cursor.
-  def read_xdes_entry(page, cursor)
-    extent_number = (cursor.position - page.pos_xdes_array) / size_entry
-    start_page = page.offset + (extent_number * page.space.pages_per_extent)
-    cursor.name("xdes[#{extent_number}]") do |c|
-      {
-        :offset     => c.position,
-        :start_page => start_page,
-        :end_page   => start_page + page.space.pages_per_extent - 1,
-        :fseg_id    => c.name("fseg_id") { c.get_uint64 },
-        :this       => {:page => page.offset, :offset => c.position},
-        :list       => c.name("list") { Innodb::List.get_node(c) },
-        :state      => c.name("state") { STATES[c.get_uint32] },
-        :bitmap     => c.name("bitmap") { c.get_bytes(size_bitmap) },
-      }
+    # Read an XDES entry from a cursor.
+    def read_xdes_entry(page, cursor)
+      extent_number = (cursor.position - page.pos_xdes_array) / size_entry
+      start_page = page.offset + (extent_number * page.space.pages_per_extent)
+      cursor.name("xdes[#{extent_number}]") do |c|
+        Entry.new(
+          offset: c.position,
+          start_page: start_page,
+          end_page: start_page + page.space.pages_per_extent - 1,
+          fseg_id: c.name("fseg_id") { c.read_uint64 },
+          this: Innodb::Page::Address.new(page: page.offset, offset: c.position),
+          list: c.name("list") { Innodb::List.get_node(c) },
+          state: c.name("state") { STATES[c.read_uint32] },
+          bitmap: c.name("bitmap") { c.read_bytes(size_bitmap) }
+        )
+      end
     end
-  end
 
-  # Return the stored extent descriptor entry.
-  def xdes
-    @xdes
-  end
+    # Return whether this XDES entry is allocated to an fseg (the whole extent
+    # then belongs to the fseg).
+    def allocated_to_fseg?
+      fseg_id != 0
+    end
 
-  def offset;     @xdes[:offset];     end
-  def start_page; @xdes[:start_page]; end
-  def end_page;   @xdes[:end_page];   end
-  def fseg_id;    @xdes[:fseg_id];    end
-  def this;       @xdes[:this];       end
-  def list;       @xdes[:list];       end
-  def state;      @xdes[:state];      end
-  def bitmap;     @xdes[:bitmap];     end
-
-  # Return whether this XDES entry is allocated to an fseg (the whole extent
-  # then belongs to the fseg).
-  def allocated_to_fseg?
-    fseg_id != 0
-  end
+    # Return the status for a given page. This is relatively inefficient as
+    # implemented and could be done better.
+    def page_status(page_number)
+      page_status_array = each_page_status.to_a
+      page_status_array[page_number - start_page][1]
+    end
 
-  # Return the status for a given page. This is relatively inefficient as
-  # implemented and could be done better.
-  def page_status(page_number)
-    page_status_array = each_page_status.to_a
-    page_status_array[page_number - xdes[:start_page]][1]
-  end
+    # Iterate through all pages represented by this extent descriptor,
+    # yielding a page status hash for each page, containing the following
+    # fields:
+    #
+    #   :page   The page number.
+    #   :free   Boolean indicating whether the page is free.
+    #   :clean  Boolean indicating whether the page is clean (currently
+    #           this bit is unused by InnoDB, and always set true).
+    def each_page_status
+      return enum_for(:each_page_status) unless block_given?
+
+      bitmap.each_byte.each_with_index do |byte, byte_index|
+        (0..3).each do |page_offset|
+          page_number = start_page + (byte_index * 4) + page_offset
+          page_bits = ((byte >> (page_offset * BITS_PER_PAGE)) & BITMAP_BV_ALL)
+          page_status = PageStatus.new(
+            free: (page_bits & BITMAP_BV_FREE != 0),
+            clean: (page_bits & BITMAP_BV_CLEAN != 0)
+          )
+          yield page_number, page_status
+        end
+      end
 
-  # Iterate through all pages represented by this extent descriptor,
-  # yielding a page status hash for each page, containing the following
-  # fields:
-  #
-  #   :page   The page number.
-  #   :free   Boolean indicating whether the page is free.
-  #   :clean  Boolean indicating whether the page is clean (currently
-  #           this bit is unused by InnoDB, and always set true).
-  def each_page_status
-    unless block_given?
-      return enum_for(:each_page_status)
+      nil
     end
 
-    bitmap = xdes[:bitmap].enum_for(:each_byte)
-
-    bitmap.each_with_index do |byte, byte_index|
-      (0..3).each do |page_offset|
-        page_number = xdes[:start_page] + (byte_index * 4) + page_offset
-        page_bits = ((byte >> (page_offset * BITS_PER_PAGE)) & BITMAP_BV_ALL)
-        page_status = {
-          :free   => (page_bits & BITMAP_BV_FREE  != 0),
-          :clean  => (page_bits & BITMAP_BV_CLEAN != 0),
-        }
-        yield page_number, page_status
+    # Return the count of free pages (free bit is true) on this extent.
+    def free_pages
+      each_page_status.inject(0) do |sum, (_page_number, page_status)|
+        sum += 1 if page_status.free
+        sum
       end
     end
 
-    nil
-  end
-
-  # Return the count of free pages (free bit is true) on this extent.
-  def free_pages
-    each_page_status.inject(0) do |sum, (page_number, page_status)|
-      sum += 1 if page_status[:free]
-      sum
+    # Return the count of used pages (free bit is false) on this extent.
+    def used_pages
+      @page.space.pages_per_extent - free_pages
     end
-  end
-
-  # Return the count of used pages (free bit is false) on this extent.
-  def used_pages
-    @page.space.pages_per_extent - free_pages
-  end
 
-  # Return the address of the previous list pointer from the list node
-  # contained within the XDES entry. This is used by +Innodb::List::Xdes+
-  # to iterate through XDES entries in a list.
-  def prev_address
-    xdes[:list][:prev]
-  end
+    # Return the address of the previous list pointer from the list node
+    # contained within the XDES entry. This is used by +Innodb::List::Xdes+
+    # to iterate through XDES entries in a list.
+    def prev_address
+      list.prev
+    end
 
-  # Return the address of the next list pointer from the list node
-  # contained within the XDES entry. This is used by +Innodb::List::Xdes+
-  # to iterate through XDES entries in a list.
-  def next_address
-    xdes[:list][:next]
-  end
+    # Return the address of the next list pointer from the list node
+    # contained within the XDES entry. This is used by +Innodb::List::Xdes+
+    # to iterate through XDES entries in a list.
+    def next_address
+      list.next
+    end
 
-  # Compare one Innodb::Xdes to another.
-  def ==(other)
-    xdes[:this][:page] == other.xdes[:this][:page] &&
-      xdes[:this][:offset] == other.xdes[:this][:offset]
+    # Compare one Innodb::Xdes to another.
+    def ==(other)
+      this.page == other.this.page && this.offset == other.this.offset
+    end
   end
 end