manageiq-smartstate 0.1.0

data/lib/db/MiqSqlite/MiqSqlite3.rb

@@ -0,0 +1,330 @@
+# encoding: US-ASCII
+
+############################################################################################
+#
+#  SQLite implements an external (disk-based) database using BTrees.
+#  For a detailed discussion of BTrees, refer to
+#
+#      Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3:
+#      "Sorting And Searching", pages 473-480. Addison-Wesley
+#      Publishing Company, Reading, Massachusetts.
+#
+#  The basic idea is that each page of the file contains N database
+#  entries and N+1 pointers to subpages.
+#
+#    ----------------------------------------------------------------
+#    |  Ptr(0) | Key(0) | Ptr(1) | Key(1) | ... | Key(N-1) | Ptr(N) |
+#    ----------------------------------------------------------------
+#
+#  All of the keys on the page that Ptr(0) points to have values less
+#  than Key(0).  All of the keys on page Ptr(1) and its subpages have
+#  values greater than Key(0) and less than Key(1).  All of the keys
+#  on Ptr(N) and its subpages have values greater than Key(N-1).  And
+#  so forth.
+#
+#  Finding a particular key requires reading O(log(M)) pages from the
+#  disk where M is the number of entries in the tree.
+#
+#  In this implementation, a single file can hold one or more separate
+#  BTrees.  Each BTree is identified by the index of its root page.  The
+#  key and data for any entry are combined to form the "payload".  A
+#  fixed amount of payload can be carried directly on the database
+#  page.  If the payload is larger than the preset amount then surplus
+#  bytes are stored on overflow pages.  The payload for an entry
+#  and the preceding pointer are combined to form a "Cell".  Each
+#  page has a small header which contains the Ptr(N) pointer and other
+#  information such as the size of key and data.
+#
+#  FORMAT DETAILS
+#
+#  The file is divided into pages.  The first page is called page 1,
+#  the second is page 2, and so forth.  A page number of zero indicates
+#  "no such page".  The page size can be anything between 512 and 65536.
+#  Each page can be either a btree page, a freelist page or an overflow
+#  page.
+#
+#  The first page is always a btree page.  The first 100 bytes of the first
+#  page contain a special header (the "file header") that describes the file.
+#  The format of the file header is as follows:
+#
+#    OFFSET   SIZE    DESCRIPTION
+#       0      16     Header string: "SQLite format 3\000"
+#      16       2     Page size in bytes.
+#      18       1     File format write version
+#      19       1     File format read version
+#      20       1     Bytes of unused space at the end of each page
+#      21       1     Max embedded payload fraction
+#      22       1     Min embedded payload fraction
+#      23       1     Min leaf payload fraction
+#      24       4     File change counter
+#      28       4     Reserved for future use
+#      32       4     First freelist page
+#      36       4     Number of freelist pages in the file
+#      40      60     15 4-byte meta values passed to higher layers
+#
+#  All of the integer values are big-endian (most significant byte first).
+#
+#  The file change counter is incremented when the database is changed
+#  This counter allows other processes to know when the file has changed
+#  and thus when they need to flush their cache.
+#
+#  The max embedded payload fraction is the amount of the total usable
+#  space in a page that can be consumed by a single cell for standard
+#  B-tree (non-LEAFDATA) tables.  A value of 255 means 100%.  The default
+#  is to limit the maximum cell size so that at least 4 cells will fit
+#  on one page.  Thus the default max embedded payload fraction is 64.
+#
+#  If the payload for a cell is larger than the max payload, then extra
+#  payload is spilled to overflow pages.  Once an overflow page is allocated,
+#  as many bytes as possible are moved into the overflow pages without letting
+#  the cell size drop below the min embedded payload fraction.
+#
+#  The min leaf payload fraction is like the min embedded payload fraction
+#  except that it applies to leaf nodes in a LEAFDATA tree.  The maximum
+#  payload fraction for a LEAFDATA tree is always 100% (or 255) and it
+#  not specified in the header.
+#
+#  Each btree pages is divided into three sections:  The header, the
+#  cell pointer array, and the cell content area.  Page 1 also has a 100-byte
+#  file header that occurs before the page header.
+#
+#       |----------------|
+#       | file header    |   100 bytes.  Page 1 only.
+#       |----------------|
+#       | page header    |   8 bytes for leaves.  12 bytes for interior nodes
+#       |----------------|
+#       | cell pointer   |   |  2 bytes per cell.  Sorted order.
+#       | array          |   |  Grows downward
+#       |                |   v
+#       |----------------|
+#       | unallocated    |
+#       | space          |
+#       |----------------|   ^  Grows upwards
+#       | cell content   |   |  Arbitrary order interspersed with freeblocks.
+#       | area           |   |  and free space fragments.
+#       |----------------|
+#
+#  The page headers looks like this:
+#
+#    OFFSET   SIZE     DESCRIPTION
+#       0       1      Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf
+#       1       2      byte offset to the first freeblock
+#       3       2      number of cells on this page
+#       5       2      first byte of the cell content area
+#       7       1      number of fragmented free bytes
+#       8       4      Right child (the Ptr(N) value).  Omitted on leaves.
+#
+#  The flags define the format of this btree page.  The leaf flag means that
+#  this page has no children.  The zerodata flag means that this page carries
+#  only keys and no data.  The intkey flag means that the key is a integer
+#  which is stored in the key size entry of the cell header rather than in
+#  the payload area.
+#
+#  The cell pointer array begins on the first byte after the page header.
+#  The cell pointer array contains zero or more 2-byte numbers which are
+#  offsets from the beginning of the page to the cell content in the cell
+#  content area.  The cell pointers occur in sorted order.  The system strives
+#  to keep free space after the last cell pointer so that new cells can
+#  be easily added without having to defragment the page.
+#
+#  Cell content is stored at the very end of the page and grows toward the
+#  beginning of the page.
+#
+#  Unused space within the cell content area is collected into a linked list of
+#  freeblocks.  Each freeblock is at least 4 bytes in size.  The byte offset
+#  to the first freeblock is given in the header.  Freeblocks occur in
+#  increasing order.  Because a freeblock must be at least 4 bytes in size,
+#  any group of 3 or fewer unused bytes in the cell content area cannot
+#  exist on the freeblock chain.  A group of 3 or fewer free bytes is called
+#  a fragment.  The total number of bytes in all fragments is recorded.
+#  in the page header at offset 7.
+#
+#     SIZE    DESCRIPTION
+#       2     Byte offset of the next freeblock
+#       2     Bytes in this freeblock
+#
+#  Cells are of variable length.  Cells are stored in the cell content area at
+#  the end of the page.  Pointers to the cells are in the cell pointer array
+#  that immediately follows the page header.  Cells is not necessarily
+#  contiguous or in order, but cell pointers are contiguous and in order.
+#
+#  Cell content makes use of variable length integers.  A variable
+#  length integer is 1 to 9 bytes where the lower 7 bits of each
+#  byte are used.  The integer consists of all bytes that have bit 8 set and
+#  the first byte with bit 8 clear.  The most significant byte of the integer
+#  appears first.  A variable-length integer may not be more than 9 bytes long.
+#  As a special case, all 8 bytes of the 9th byte are used as data.  This
+#  allows a 64-bit integer to be encoded in 9 bytes.
+#
+#     0x00                      becomes  0x00000000
+#     0x7f                      becomes  0x0000007f
+#     0x81 0x00                 becomes  0x00000080
+#     0x82 0x00                 becomes  0x00000100
+#     0x80 0x7f                 becomes  0x0000007f
+#     0x8a 0x91 0xd1 0xac 0x78  becomes  0x12345678
+#     0x81 0x81 0x81 0x81 0x01  becomes  0x10204081
+#
+#  Variable length integers are used for rowids and to hold the number of
+#  bytes of key and data in a btree cell.
+#
+#  The content of a cell looks like this:
+#
+#     SIZE    DESCRIPTION
+#       4     Page number of the left child. Omitted if leaf flag is set.
+#      var    Number of bytes of data. Omitted if the zerodata flag is set.
+#      var    Number of bytes of key. Or the key itself if intkey flag is set.
+#       *     Payload
+#       4     First page of the overflow chain.  Omitted if no overflow
+#
+#  Overflow pages form a linked list.  Each page except the last is completely
+#  filled with data (pagesize - 4 bytes).  The last page can have as little
+#  as 1 byte of data.
+#
+#     SIZE    DESCRIPTION
+#       4     Page number of next overflow page
+#       *     Data
+#
+#  Freelist pages come in two subtypes: trunk pages and leaf pages.  The
+#  file header points to the first in a linked list of trunk page.  Each trunk
+#  page points to multiple leaf pages.  The content of a leaf page is
+#  unspecified.  A trunk page looks like this:
+#
+#     SIZE    DESCRIPTION
+#       4     Page number of next trunk page
+#       4     Number of leaf pointers on this page
+#       *     zero or more pages numbers of leaves
+
+require 'ostruct'
+require 'enumerator'
+
+require 'binary_struct'
+
+require_relative 'MiqSqlite3Page'
+require_relative 'MiqSqlite3Table'
+
+module MiqSqlite3DB
+  # Database Header (all numbers in Big-Endian format)
+  DBHEADER = BinaryStruct.new([             #    OFFSET   SIZE    DESCRIPTION
+    'a16',  'magic',                     #       0      16     Header string: "SQLite format 3\000"
+    'n',    'page_size',                 #      16       2     Page size in bytes.
+    'C',    'write_version',             #      18       1     File format write version
+    'C',    'read_version',              #      19       1     File format read version
+    'C',    'unused_space',              #      20       1     Bytes of unused space at the end of each page
+    'C',    'max_payload_node_fraction', #      21       1     Max embedded payload fraction
+    'C',    'min_payload_node_fraction', #      22       1     Min embedded payload fraction
+    'C',    'min_payload_leaf_fraction', #      23       1     Min leaf payload fraction
+    'N',    'file_change_counter',       #      24       4     File change counter
+    'a4',   'reserved',                  #      28       4     Reserved for future use
+    'N',    'first_freelist_page',       #      32       4     First freelist page
+    'N',    'number_freelist_pages',     #      36       4     Number of freelist pages in the file
+    'N15',  'meta_values',               #      40      60     15 4-byte meta values passed to higher layers
+  ])
+
+  SIZEOF_DBHEADER = DBHEADER.size
+
+  SQLITE_MAX_PAGE_SIZE = 32768
+
+  class MiqSqlite3
+    attr_reader :pageSize, :maxLocal, :minLocal, :usableSize, :maxLeaf, :minLeaf, :npages
+
+    def initialize(fileName = nil, fs = nil)
+      @fs = fs unless fs.nil?
+      open(fileName) unless fileName.nil?
+
+      if  @pageSize < 512 || @pageSize > SQLITE_MAX_PAGE_SIZE || ((@pageSize - 1) & @pageSize) != 0
+        #        @pageSize = 0
+        #        sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize);
+        @maxEmbedFrac = 64   # 25.0%
+        @minEmbedFrac = 32   # 12.5%
+        @minLeafFrac  = 32   # 12.5%
+        @nReserve     = 0
+      else
+        @nReserve     = @header.unused_space
+        @maxEmbedFrac = @header.max_payload_node_fraction
+        @minEmbedFrac = @header.min_payload_node_fraction
+        @minLeafFrac  = @header.min_payload_leaf_fraction
+        @pageSizeFixed = true
+      end
+
+      @usableSize = @pageSize - @nReserve
+      #      assert( (pBt->pageSize & 7)==0 );  /* 8-byte alignment of pageSize */
+
+      #########################################################################
+      # /* maxLocal is the maximum amount of payload to store locally for
+      # ** a cell.  Make sure it is small enough so that at least minFanout
+      # ** cells can will fit on one page.  We assume a 10-byte page header.
+      # ** Besides the payload, the cell must store:
+      # **     2-byte pointer to the cell
+      # **     4-byte child pointer
+      # **     9-byte nKey value
+      # **     4-byte nData value
+      # **     4-byte overflow page pointer
+      # ** So a cell consists of a 2-byte poiner, a header which is as much as
+      # ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
+      # ** page pointer.
+      #########################################################################
+      @maxLocal = (@usableSize - 12) * @maxEmbedFrac / 255 - 23
+      @minLocal = (@usableSize - 12) * @minEmbedFrac / 255 - 23
+      @maxLeaf  = @usableSize - 35
+      @minLeaf  = (@usableSize - 12) * @minLeafFrac / 255 - 23
+    end
+
+    # Open the database
+    def open(filename)
+      # Get header & check.
+      @filename = filename
+      @file     = fileOpen(@filename)
+      @header   = OpenStruct.new(DBHEADER.decode(@file.read(SIZEOF_DBHEADER)))
+      @pageSize = @header.page_size
+      @npages   = fileSize / @pageSize
+
+      raise "#{@filename} is not a SQLite3 Database."                                 if @header.magic != "SQLite format 3\000"
+      raise "#{@filename} is corrupt -- has incomplete pages (pagesize=#{@pageSize})" if (@pageSize * @npages) != fileSize
+    end
+
+    # Close the database
+    def close
+      @db.close   if @db
+      @file.close if @file
+      @db = @header = @file = @filename = nil
+    end
+
+    def each_page
+      for pagenum in 1..npages
+        yield MiqSqlite3Page.getPage(self, pagenum)
+      end
+    end
+
+    def readPage(pagenum)
+      where = (pagenum - 1) * @pageSize
+      @file.seek(where)
+      @file.read(@pageSize)
+    end
+
+    def size
+      fileSize
+    end
+
+    def table_names
+      MiqSqlite3Table.table_names(self)
+    end
+
+    def getTable(name)
+      MiqSqlite3Table.getTable(self, name)
+    end
+
+    private
+
+    def fileSize
+      # Use MiqFS or File depending on @fs.
+      return File.size(@filename)    if @fs.nil?
+      @fs.fileSize(@filename)
+    end
+
+    def fileOpen(_fileName)
+      # Return a file object using MiqFS or File as the case may be.
+      return File.open(@filename, "rb") if @fs.nil?
+      @fs.fileOpen(@filename, "r")
+    end
+  end
+end

data/lib/db/MiqSqlite/MiqSqlite3Cell.rb

@@ -0,0 +1,167 @@
+# encoding: US-ASCII
+
+require 'ostruct'
+require 'enumerator'
+
+require 'binary_struct'
+require_relative 'MiqSqlite3Util'
+require_relative 'MiqSqlite3Page'
+
+module MiqSqlite3DB
+  class MiqSqlite3Cell
+    attr_accessor :left_child, :key, :data, :pointer
+
+    def initialize(page, pointer)
+      @page    = page
+      @pointer = pointer
+      @data = @key = @left_child = @fields = nil
+
+      offset = nData = 0
+      unless @page.leaf
+        @left_child = @page.buf[@pointer + offset, 4].unpack('N')[0]
+        offset += 4
+      end
+
+      if @page.hasData
+        nData, count = MiqSqlite3DB.variableInteger(@page.buf[@pointer + offset, 9])
+        offset += count
+      end
+
+      nKey, count = MiqSqlite3DB.variableInteger(@page.buf[@pointer + offset, 9])
+      offset += count
+      if @page.intKey
+        @key = nKey
+        nKey = 0
+      end
+
+      getPayload(nData, nKey, offset)
+    end
+
+    def fields
+      return @fields if @fields
+
+      return nil if @data.nil?
+      len     = @data[0].ord
+      @fields = []
+      offset   = len
+      byte     = 1
+      while byte < len
+        val, count  = MiqSqlite3DB.variableInteger(@data[byte..-1])
+        byte += count
+        flen, type = decodeField(val)
+
+        field = {}
+        if flen == 0
+          if type == 'null'
+            field['type'] = 'text'
+            field['data'] = nil
+          else
+            field['type'] = 'boolean'
+            field['data'] = true   if type == 'true'
+            field['data'] = false  if type == 'false'
+          end
+        else
+          field['len']  = flen
+          field['type'] = type
+          fdata = @data[offset, flen]
+          offset += flen
+          if type == 'integer'
+            fdata = "\x00".concat(fdata) if flen == 3
+            field['data'] = fdata.unpack("C")[0]  if flen == 1
+            field['data'] = fdata.unpack("n")[0]  if flen == 2
+            field['data'] = fdata.unpack("N")[0]  if flen == 3 || flen == 4
+          else
+            field['data'] = fdata
+          end
+        end
+        @fields << field
+      end
+      @fields
+    end
+
+    def dump
+      puts "======== Dumping Cell ========="
+      puts "Page:                            #{@page.pagenum}"
+      puts "Cell:                            #{@pointer}"
+      puts "Left Child:                      #{@left_child}" if @left_child
+      puts "Key:                             #{@key}"        if @key
+      puts "Data:                            #{@data}"       if @data
+      puts "Data Length:                     #{@data.size}"  if @data
+      fields.each do |f|
+        p f
+      end
+    end
+
+    private
+
+    def getPayload(nData, nKey, offset)
+      nPayload = nData + nKey
+      if nPayload <= @page.maxLocal
+        ## This is the (easy) common case where the entire payload fits
+        ## on the local page.  No overflow is required.
+        nLocal = nPayload
+        iOverflow = 0
+        nSize = nPayload + offset   # Total size of cell content in bytes
+        nSize = 4 if nSize < 4      # Minimum cell size is 4
+        @data = @page.buf[@pointer + offset,      nData] if nData > 0
+        @key  = @page.buf[@pointer + offset + nData, nKey]  if nKey > 0
+      else
+        ## If the payload will not fit completely on the local page, we have
+        ## to decide how much to store locally and how much to spill onto
+        ## overflow pages.  The strategy is to minimize the amount of unused
+        ## space on overflow pages while keeping the amount of local storage
+        ## in between minLocal and maxLocal.
+        ##
+        ## Warning:  changing the way overflow payload is distributed in any
+        ## way will result in an incompatible file format.
+        ##
+        minLocal  = @page.minLocal  # Minimum amount of payload held locally
+        maxLocal  = @page.maxLocal  # Maximum amount of payload held locally
+        surplus   = minLocal + (nPayload - minLocal) % (@db.usableSize - 4)   # Overflow payload available for local storage
+        nLocal    = (surplus <= maxLocal) ? surplus : minLocal
+        iOverflow = nLocal + offset
+        nSize     = iOverflow + 4
+        @overflow = @page.buf[@pointer + iOverflow, 4].unpack('N')[0]
+        raise "cell (#{@number}): PAYLOAD OVERFLOW NOT SUPPORTED"
+      end
+    end
+
+    # ** The following table describes the various storage classes for data:
+    # **
+    # **   serial type        bytes of data      type
+    # **   --------------     ---------------    ---------------
+    # **      0                     0            NULL
+    # **      1                     1            signed integer
+    # **      2                     2            signed integer
+    # **      3                     3            signed integer
+    # **      4                     4            signed integer
+    # **      5                     6            signed integer
+    # **      6                     8            signed integer
+    # **      7                     8            IEEE float
+    # **      8                     0            Integer constant 0
+    # **      9                     0            Integer constant 1
+    # **     10,11                               reserved for expansion
+    # **    N>=12 and even       (N-12)/2        BLOB
+    # **    N>=13 and odd        (N-13)/2        text
+    def decodeField(serial_type)
+      case serial_type
+      when 0 then         return 0, 'null'
+      when 1 then         return 1, 'integer'
+      when 2 then         return 2, 'integer'
+      when 3 then         return 3, 'integer'
+      when 4 then         return 4, 'integer'
+      when 6 then         return 6, 'integer'
+      when 8 then         return 8, 'integer'
+      when 7 then         return 8, 'float'
+      when 8 then         return 0, 'false'
+      when 9 then         return 0, 'true'
+      when 10 then        raise "Unknown Column Type #{serial_type}"
+      when 11 then        raise "Unknown Column Type #{serial_type}"
+      end
+
+      type = serial_type.even? ? 'blob' : 'text'
+      len  = (serial_type - 12) / 2
+      return len, type
+    end
+  end
+end

data/lib/db/MiqSqlite/MiqSqlite3Page.rb

@@ -0,0 +1,151 @@
+require 'ostruct'
+require 'enumerator'
+
+require 'binary_struct'
+require_relative 'MiqSqlite3Util'
+require_relative 'MiqSqlite3Cell'
+
+module MiqSqlite3DB
+  class MiqSqlite3Page
+    # Page Header.
+    HEADER = BinaryStruct.new([              # All integers are in Big-Endian (or Network) Order
+      #    OFFSET   SIZE     DESCRIPTION
+      'C',  'flags',                      #       0       1      Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf
+      'n',  'offset2freeblock',           #       1       2      byte offset to the first freeblock
+      'n',  'num_cells',                  #       3       2      number of cells on this page
+      'n',  'offset2cell',                #       5       2      first byte of the cell content area
+      'C',  'num_fragmented_free_bytes',  #       7       1      number of fragmented free bytes
+      'N',  'right_child',                #       8       4      Right child (the Ptr(N) value).  Omitted on leaves.
+    ])
+
+    SIZEOF_HEADER = HEADER.size
+
+    #####################################
+    ## Class Methods
+    #####################################
+
+    def self.getPage(db, pagenum)
+      MiqSqlite3Page.new(db.readPage(pagenum), db, pagenum)
+    end
+
+    def self.intKey?(f)
+      f & 0x01 == 0x01
+    end
+
+    def self.zeroData?(f)
+      f & 0x02 == 0x02
+    end
+
+    def self.leafData?(f)
+      f & 0x04 == 0x04
+    end
+
+    def self.leaf?(f)
+      f & 0x08 == 0x08
+    end
+
+    #####################################
+    ## Instance Methods
+    #####################################
+
+    attr_accessor :buf, :leaf, :hasData, :intKey, :maxLocal, :minLocal, :pagenum
+
+    def initialize(buf, db, pagenum)
+      raise "Nil buffer" if buf.nil?
+      @pagenum    = pagenum
+      @db         = db
+      @buf        = buf
+      @pagesize   = buf.size
+      skip        = (pagenum == 1) ? SIZEOF_DBHEADER : 0
+      @header     = OpenStruct.new(HEADER.decode(@buf[skip, SIZEOF_HEADER]))
+      decodeFlags
+      headerSize  = SIZEOF_HEADER - @childPtrSize
+      @data       = buf[skip + headerSize..-1]
+      @cells = @cellPointers = nil
+    end
+
+    def decodeFlags
+      @leafData = MiqSqlite3Page.leafData?(@header.flags)
+      @zeroData = MiqSqlite3Page.zeroData?(@header.flags)
+      @leaf     = MiqSqlite3Page.leaf?(@header.flags)
+      @childPtrSize = @leaf ? 4 : 0
+      if MiqSqlite3Page.leafData?(@header.flags)
+        @intKey   = MiqSqlite3Page.intKey?(@header.flags)
+        @maxLocal = @db.maxLeaf
+        @minLocal = @db.minLeaf
+      else
+        @intKey   = false
+        @maxLocal = @db.maxLocal
+        @minLocal = @db.minLocal
+      end
+      @hasData = !(@zeroData || (!@leaf && @leafData))
+    end
+
+    def each_child
+      each_cell do |cell|
+        yield cell.left_child if cell.left_child
+      end
+      yield @header.right_child unless @leaf
+    end
+
+    def each_cell
+      initCells if @cells.nil?
+      @cells.each { |c| yield c }
+    end
+
+    def leaves
+      each_child do |child|
+        MiqSqlite3Page.getPage(@db, child).leaves { |p| yield p }
+      end
+      yield self if @leaf
+    end
+
+    def dump
+      puts "================="
+      puts "Page:                            #{@pagenum}"
+      #     puts "Page Size:                       #{@pagesize}"
+      #     puts "Data Size:                       #{@data.size}"
+      #     puts "Flags (Raw):                     #{@header.flags}"
+      puts "Flags:                           #{flags2str}"
+      puts "Offset to First Freeblock:       #{@header.offset2freeblock}"
+      puts "Offset to Cell Content Area:     #{@header.offset2cell}"
+      puts "Number of Cells:                 #{@header.num_cells}"
+      puts "Number of Fragmented Free Bytes: #{@header.num_fragmented_free_bytes}"
+      puts "Right Child:                     #{@header.right_child}"   unless @leaf
+      puts "Cell Pointers:                   #{cellPointers2String}"
+
+      #     each_cell { |cell| p cell }
+      #     each_child { |kid| puts "Child: #{kid}"}
+    end
+
+    def flags2str
+      str = ""
+      str << "IntKey "   if @intKey
+      str << "ZeroData " if @zeroData
+      str << "LeafData " if @leafData
+      str << "Leaf "     if @leaf
+      str.chomp
+    end
+
+    def cellPointers2String
+      initCellPointers if @cellPointers.nil?
+      str = ""
+      @cellPointers.each { |p| str << "#{p} " }
+      return nil if str == ""
+      str.chomp
+    end
+
+    def initCellPointers
+      @cellPointers = []
+      for i in 1..@header.num_cells
+        @cellPointers << @data[(i - 1) * 2, 2].unpack('n')[0]
+      end
+    end
+
+    def initCells
+      @cells = []
+      initCellPointers if @cellPointers.nil?
+      @cellPointers.each { |p| @cells << MiqSqlite3Cell.new(self, p) }
+    end
+  end
+end