Examples of com.caucho.db.block.Block

com.caucho.db.block.Block
Represents a versioned row

  }


  public void init(DbTransaction xa)
    throws SQLException
  {
    Block block = _block;
    _block = null;
    _buffer = null;


    if (block != null) {
      block.free();
    }
    
    _blockId = 0;
    _rowOffset = Integer.MAX_VALUE / 2;
    _queryContext = null;

View Full Code Here

  public boolean nextBlock()
    throws IOException
  {
    byte []buffer = _buffer;


    Block block = _block;
    _block = null;
    _buffer = null;


    if (block != null) {
      block.free();
    }


    _blockId = _table.firstRowBlock(_blockId + Table.BLOCK_SIZE);


    if (_blockId < 0) {
      return false;
    }


    block = _xa.readBlock(_table, _blockId);


    buffer = block.getBuffer();
    _block = block;
    _buffer = buffer;
    _rowOffset = 0;


    return true;

View Full Code Here

    long blockId = _table.addressToBlockId(rowAddr);


    if (blockId != _blockId) {
      _blockId = blockId;
    
      Block block = _block;
      _block = null;
      _buffer = null;


      if (block != null) {
        block.free();
      }


      _block = _xa.readBlock(_table, _blockId);
      _buffer = _block.getBuffer();
    }

View Full Code Here

   * Sets the next row.
   */
  public void initNullRow()
    throws IOException
  {
    Block block = _block;
    _block = null;
    _buffer = null;


    if (block != null)
      block.free();


    _rowOffset = 0;
    _buffer = _nullBuffer;
  }

View Full Code Here

    _block.setDirty(_rowOffset, _rowOffset + _rowLength);
  }


  public void free()
  {
    Block block = _block;
    _block = null;


    if (block != null)
      block.free();
  }

View Full Code Here

                      int keyOffset,
                      int keyLength)
    throws SQLException
  {
    try {
      Block rootBlock = _rootBlock; // _store.readBlock(_rootBlockId);
      rootBlock.allocate();


      try {
        if (! removeRead(rootBlock, keyBuffer, keyOffset, keyLength)) {
          removeWrite(rootBlock, keyBuffer, keyOffset, keyLength);
        }
      } finally {
        rootBlock.free();
      }
    } catch (RuntimeException e) {
      throw e;
    } catch (SQLException e) {
      throw e;

View Full Code Here

                            false);


      if (childId == FAIL)
        return true;


      Block childBlock = _store.readBlock(childId);
        
      try {
        validateIndex(childBlock);
        
        if (removeRead(childBlock, keyBuffer, keyOffset, keyLength))
          return true;
        else
          return removeWrite(childBlock, keyBuffer, keyOffset, keyLength);
      } finally {
        childBlock.free();
      }
    } finally {
      blockLock.unlock();
    }
  }

View Full Code Here

                              isLeaf);


        if (childId == FAIL)
          return true;


        Block childBlock = _store.readBlock(childId);
        try {
          validateIndex(childBlock);


          boolean isJoin;


          isJoin = ! removeWrite(childBlock, keyBuffer, keyOffset, keyLength);


          if (isJoin && joinBlocks(block, childBlock)) {
            if (childBlock.getUseCount() > 2) {
              System.out.println("USE: " + childBlock.getUseCount() + " " + block);
            }
            childBlock.deallocate();
          }


          validate(block);
        } finally {
          childBlock.free();
        }
      }
      
      return _minN <= getLength(buffer);
    } finally {

View Full Code Here

    long rightBlockId = getRightBlockId(parent, blockId);


    // If the left block has extra data, shift the last left item
    // to the block
    if (leftBlockId > 0) {
      Block leftBlock = _store.readBlock(leftBlockId);


      try {
        byte []leftBuffer = leftBlock.getBuffer();


        Lock leftLock = leftBlock.getWriteLock();
        leftLock.tryLock(_timeout, TimeUnit.MILLISECONDS);


        try {
          int leftLength = getLength(leftBuffer);


          Lock blockLock = block.getWriteLock();
          blockLock.tryLock(_timeout, TimeUnit.MILLISECONDS);


          try {
            if (_minN < leftLength) {
              validateEqualLeaf(buffer, leftBuffer, block, leftBlock);
              
              parent.setFlushDirtyOnCommit(false);


              leftBlock.setFlushDirtyOnCommit(false);


              validate(parentBlockId, parentBuffer);
              validate(leftBlockId, leftBuffer);
              validate(blockId, buffer);
              
              // System.out.println("MOVE_FROM_LEFT: " + debugId(blockId) + " from " + debugId(leftBlockId));
              moveFromLeft(parentBuffer, leftBuffer, buffer, blockId);
              validate(parentBlockId, parentBuffer);
              validate(leftBlockId, leftBuffer);
              validate(blockId, buffer);
              
              parent.setDirty(0, BlockStore.BLOCK_SIZE);
              leftBlock.setDirty(0, BlockStore.BLOCK_SIZE);


              return false;
            }
          } finally {
            blockLock.unlock();
          }
        } finally {
          leftLock.unlock();
        }
      } finally {
        leftBlock.free();
      }
    }


    // If the right block has extra data, shift the first right item
    // to the block
    if (rightBlockId > 0) {
      Block rightBlock = _store.readBlock(rightBlockId);


      try {
        byte []rightBuffer = rightBlock.getBuffer();


        Lock blockLock = block.getWriteLock();
        blockLock.tryLock(_timeout, TimeUnit.MILLISECONDS);


        try {
          Lock rightLock = rightBlock.getWriteLock();
          rightLock.tryLock(_timeout, TimeUnit.MILLISECONDS);


          try {
            int rightLength = getLength(rightBuffer);


            if (_minN < rightLength) {
              validateEqualLeaf(buffer, rightBuffer, block, rightBlock);
              
              parent.setFlushDirtyOnCommit(false);


              rightBlock.setFlushDirtyOnCommit(false);


              // System.out.println("MOVE_FROM_RIGHT: " + debugId(blockId) + " from " + debugId(rightBlockId));


              moveFromRight(parentBuffer, buffer, rightBuffer, blockId);
              validate(parentBlockId, parentBuffer);
              validate(blockId, buffer);
              validate(rightBlockId, rightBuffer);
              
              parent.setDirty(0, BlockStore.BLOCK_SIZE);
              rightBlock.setDirty(0, BlockStore.BLOCK_SIZE);


              return false;
            }
          } finally {
            rightLock.unlock();
          }
        } finally {
          blockLock.unlock();
        }
      } finally {
        rightBlock.free();
      }
    }


    if (parentLength < 2)
      return false;
    
    // If the left block has space, merge with it
    if (leftBlockId > 0) {
      Block leftBlock = _store.readBlock(leftBlockId);
      
      try {
        byte []leftBuffer = leftBlock.getBuffer();


        Lock leftLock = leftBlock.getWriteLock();
        leftLock.tryLock(_timeout, TimeUnit.MILLISECONDS);


        try {
          int leftLength = getLength(leftBuffer);


          Lock blockLock = block.getWriteLock();
          blockLock.tryLock(_timeout, TimeUnit.MILLISECONDS);


          try {
            int length = getLength(buffer);


            if (length + leftLength <= _n) {
              validateEqualLeaf(leftBuffer, buffer, leftBlock, block);
              
              parent.setFlushDirtyOnCommit(false);


              leftBlock.setFlushDirtyOnCommit(false);
      
              // System.out.println("MERGE_LEFT: " + debugId(blockId) + " from " + debugId(leftBlockId));


              mergeLeft(parentBuffer,
                        leftBuffer, leftBlockId,
                        buffer, blockId);
              
              validate(parentBlockId, parentBuffer);
              validate(leftBlockId, leftBuffer);
              
              parent.setDirty(0, BlockStore.BLOCK_SIZE);
              leftBlock.setDirty(0, BlockStore.BLOCK_SIZE);


              // System.out.println("FREE-ML: " + block);


              return true;
            }
          } finally {
            blockLock.unlock();
          }
        } finally {
          leftLock.unlock();
        }
      } finally {
        leftBlock.free();
      }
    }
    
    // If the right block has space, merge with it
    if (rightBlockId > 0) {
      Block rightBlock = _store.readBlock(rightBlockId);


      try {
        byte []rightBuffer = rightBlock.getBuffer();


        Lock blockLock = block.getWriteLock();
        blockLock.tryLock(_timeout, TimeUnit.MILLISECONDS);


        try {
          Lock rightLock = rightBlock.getWriteLock();
          rightLock.tryLock(_timeout, TimeUnit.MILLISECONDS);


          try {
            int length = getLength(buffer);
            int rightLength = getLength(rightBuffer);


            if (length + rightLength <= _n) {
              validateEqualLeaf(rightBuffer, buffer, rightBlock, block);


              rightBlock.setFlushDirtyOnCommit(false);


              parent.setFlushDirtyOnCommit(false);


              // System.out.println("MERGE_RIGHT: " + debugId(blockId) + " from " + debugId(rightBlockId));


              validate(blockId, buffer);
              validate(parentBlockId, parentBuffer);
              validate(rightBlockId, rightBuffer);
              
              mergeRight(parentBuffer, buffer, rightBuffer, blockId);
              
              validate(parentBlockId, parentBuffer);
              validate(rightBlockId, rightBuffer);
              
              rightBlock.setDirty(0, BlockStore.BLOCK_SIZE);
              parent.setDirty(0, BlockStore.BLOCK_SIZE);


              // System.out.println("FREE-MR: " + block);


              return true;
            }
          } finally {
            rightLock.unlock();
          }
        } finally {
          blockLock.unlock();
        }
      } finally {
        rightBlock.free();
      }
    }


    // XXX: error

View Full Code Here


    if (! _store.isIndexBlock(blockId)) {
      return null;
    }
    
    Block block = _store.readBlock(blockId);


    block.read();
    byte []buffer = block.getBuffer();
      
    int length = getInt(buffer, LENGTH_OFFSET);
    int offset = HEADER_SIZE;
    int tupleSize = _tupleSize;


    ArrayList<String> keys = new ArrayList<String>();
    for (int i = 0; i < length; i++) {
      keys.add(_keyCompare.toString(buffer,
                                    offset + i * tupleSize + PTR_SIZE,
                                    tupleSize - PTR_SIZE));
    }


    block.free();
    
    return keys;
  }

View Full Code Here

0 1 2 3 4 5 6 7

TOP

Related Classes of com.caucho.db.block.Block

com.caucho.db.blob.Inode

com.caucho.db.blob.InodeBlobInputStream

com.caucho.db.index.BTree

com.caucho.db.lock.Lock

com.caucho.db.sql.QueryContext

com.caucho.db.table.Table

com.caucho.db.table.TableIterator

com.caucho.db.xa.DbTransaction

com.caucho.db.xa.Transaction

com.caucho.server.cache.TempFileInode$TempFileOutputStream

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.