Examples of com.caucho.db.block.Block

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

                         boolean isOverride,
                         boolean isRead,
                         long blockId)
    throws IOException, SQLException, InterruptedException
  {
    Block block;


    if (blockId == _rootBlockId) {
      block = _rootBlock;
      block.allocate();
    }
    else
      block = _store.loadBlock(blockId);
    
    try {
      validateIndex(block);
        
      if (isRead && insertReadChild(keyBuffer, keyOffset, keyLength,
                                    value, isOverride, block))
        return true;
      else
        return insertWriteChild(keyBuffer, keyOffset, keyLength,
                                value, isOverride, block);
    } finally {
      block.free();
    }
  }

View Full Code Here

   */
  private void split(Block parent,
                     long blockId)
    throws IOException, SQLException, InterruptedException
  {
    Block block = _store.readBlock(blockId);


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


      try {
        split(parent, block);


        validate(block);
      } finally {
        blockLock.unlock();
      }
    } finally {
      block.free();
    }
  }

View Full Code Here


    if (length < 2)
      throw new IllegalStateException(L.l("illegal length '{0}' for block {1}",
                                          length, debugId(blockId)));
      
    Block leftBlock = null;


    try {
      parentBlock.setFlushDirtyOnCommit(false);
    
      byte []parentBuffer = parentBlock.getBuffer();
      int parentLength = getLength(parentBuffer);
    
      validate(parentId, parentBuffer);
      validate(blockId, buffer);
      
      leftBlock = _store.allocateIndexBlock();
      // System.out.println("TREE-alloc1:" + Long.toHexString(leftBlock.getBlockId()));
      leftBlock.setFlushDirtyOnCommit(false);
      // System.out.println("ALLOC: " + leftBlock);
      
      byte []leftBuffer = leftBlock.getBuffer();
      long leftBlockId = leftBlock.getBlockId();


      int pivot = length / 2;


      int pivotSize = pivot * _tupleSize;
      int pivotEnd = HEADER_SIZE + pivotSize;
      int blockEnd = HEADER_SIZE + length * _tupleSize;
      
      System.arraycopy(buffer, HEADER_SIZE,
                       leftBuffer, HEADER_SIZE,
                       pivotSize);


      setInt(leftBuffer, FLAGS_OFFSET, getInt(buffer, FLAGS_OFFSET));
      setLength(leftBuffer, pivot);
      // XXX: NEXT_OFFSET needs to work with getRightIndex
      setPointer(leftBuffer, NEXT_OFFSET, 0);
      
      setPointer(leftBuffer, PARENT_OFFSET, parentId);


      System.arraycopy(buffer, pivotEnd,
                       buffer, HEADER_SIZE,
                       blockEnd - pivotEnd);


      setLength(buffer, length - pivot);


      insertLeafBlock(parentId, parentBuffer,
                      leftBuffer, pivotEnd - _tupleSize + PTR_SIZE, _keySize,
                      leftBlockId,
                      true);
      
      validate(parentId, parentBuffer);
      validate(leftBlockId, leftBuffer);
      validate(blockId, buffer);
      
      validate(block);
      validate(parentBlock);
      validate(leftBlock);
      
      leftBlock.setDirty(0, BlockStore.BLOCK_SIZE);
      parentBlock.setDirty(0, BlockStore.BLOCK_SIZE);
    } finally {
      if (leftBlock != null)
        leftBlock.free();
      
      block.setDirty(0, BlockStore.BLOCK_SIZE);
    }
  }

View Full Code Here

   * @throws InterruptedException 
   */
  private void splitRoot(long rootBlockId)
    throws IOException, SQLException, InterruptedException
  {
    Block rootBlock = _rootBlock; // store.readBlock(rootBlockId);
    rootBlock.allocate();


    try {
      Lock rootLock = rootBlock.getWriteLock();
      rootLock.tryLock(_timeout, TimeUnit.MILLISECONDS);
      
      try {
        splitRoot(rootBlock);


        validate(rootBlock);
      } finally {
        rootLock.unlock();
      }
    } finally {
      rootBlock.free();
    }
  }

View Full Code Here

  {
    long parentId = parentBlock.getBlockId();
    
    log.finest("btree splitting root " + (parentId / BLOCK_SIZE));


    Block leftBlock = null;
    Block rightBlock = null;


    try {
      byte []parentBuffer = parentBlock.getBuffer();
      int length = getLength(parentBuffer);


      if (length == 1)
        return;
      
      parentBlock.setFlushDirtyOnCommit(false);


      int parentFlags = getInt(parentBuffer, FLAGS_OFFSET);


      leftBlock = _store.allocateIndexBlock();
      // System.out.println("TREE-alloc2:" + Long.toHexString(leftBlock.getBlockId()));
      leftBlock.setFlushDirtyOnCommit(false);
      
      long leftBlockId = leftBlock.getBlockId();
    
      rightBlock = _store.allocateIndexBlock();
      // System.out.println("TREE-alloc3:" + Long.toHexString(rightBlock.getBlockId()));
      rightBlock.setFlushDirtyOnCommit(false);
      
      long rightBlockId = rightBlock.getBlockId();


      int pivot = (length - 1) / 2;
      
      //System.out.println("INDEX SPLIT ROOT: " + (parentId / BLOCK_SIZE)
      //                    + " PIVOT=" + pivot);


      if (length <= 2 || _n < length || pivot < 1 || length <= pivot)
        throw new IllegalStateException(Long.toHexString(parentBlock.getBlockId()) + ": " + length + " is an illegal length, or pivot " + pivot + " is bad, with n=" + _n);


      int pivotOffset = HEADER_SIZE + pivot * _tupleSize;
      long pivotValue = getPointer(parentBuffer, pivotOffset);


      byte []leftBuffer = leftBlock.getBuffer();


      System.arraycopy(parentBuffer, HEADER_SIZE,
                       leftBuffer, HEADER_SIZE,
                       pivotOffset + _tupleSize - HEADER_SIZE);
      setInt(leftBuffer, FLAGS_OFFSET, parentFlags);
      setLength(leftBuffer, pivot + 1);
      setPointer(leftBuffer, PARENT_OFFSET, parentId);
      setPointer(leftBuffer, NEXT_OFFSET, 0); // rightBlockId); 


      byte []rightBuffer = rightBlock.getBuffer();


      if (length - pivot - 1 < 0)
        throw new IllegalStateException("illegal length " + pivot + " " + length);


      System.arraycopy(parentBuffer, pivotOffset + _tupleSize,
                       rightBuffer, HEADER_SIZE,
                       (length - pivot - 1) * _tupleSize);


      setInt(rightBuffer, FLAGS_OFFSET, parentFlags);
      setLength(rightBuffer, length - pivot - 1);
      setPointer(rightBuffer, PARENT_OFFSET, parentId);
      setPointer(rightBuffer, NEXT_OFFSET,
                 getPointer(parentBuffer, NEXT_OFFSET));


      System.arraycopy(parentBuffer, pivotOffset,
                       parentBuffer, HEADER_SIZE,
                       _tupleSize);
      setPointer(parentBuffer, HEADER_SIZE, leftBlockId);


      setLeaf(parentBuffer, false);
      setLength(parentBuffer, 1);
      setPointer(parentBuffer, NEXT_OFFSET, rightBlockId);
      
      parentBlock.setDirty(0, BlockStore.BLOCK_SIZE);
      leftBlock.setDirty(0, BlockStore.BLOCK_SIZE);
      rightBlock.setDirty(0, BlockStore.BLOCK_SIZE);
      
      validate(parentBlock);
      validate(leftBlock);
      validate(rightBlock);
    } finally {
      if (leftBlock != null)
        leftBlock.free();
      
      if (rightBlock != null)
        rightBlock.free();
    }
  }

View Full Code Here

    public void write(byte []buffer, int offset, int length)
      throws IOException
    {
      while (length > 0) {
        while (_blockList.size() <= _length / BlockStore.BLOCK_SIZE) {
          Block block = _store.allocateBlock();


          _blockList.add(block.getBlockId());
          
          block.free();
        }


        int blockOffset = (int) (_length % BlockStore.BLOCK_SIZE);
        long blockAddress = _blockList.get(_blockList.size() - 1);


        int sublen = BlockStore.BLOCK_SIZE - blockOffset;
        if (length < sublen)
          sublen = length;


        _length += sublen;
        
        Block block = _store.writeBlock(blockAddress, blockOffset,
                                        buffer, offset, sublen);
        
        _xa.addUpdateBlock(block);


        length -= sublen;

View Full Code Here

    public void write(char []buffer, int offset, int length)
      throws IOException
    {
      while (length > 0) {
        while (_blockList.size() <= _length / BlockStore.BLOCK_SIZE) {
          Block block = _store.allocateBlock();


          _blockList.add(block.getBlockId());
          
          block.free();
        }


        int blockOffset = (int) (_length % BlockStore.BLOCK_SIZE);
        long blockId = _blockList.get(_blockList.size() - 1);


        int sublen = (BlockStore.BLOCK_SIZE - blockOffset) / 2;
        if (length < sublen)
          sublen = length;


        _length += 2 * sublen;
        Block block = _store.writeBlock(blockId, blockOffset,
                                        buffer, offset, sublen);


        _xa.addUpdateBlock(block);
        
        length -= sublen;

View Full Code Here

      throw new IllegalStateException();


    int len = _tableIterators.length;


    for (int i = 0; i < len; i++) {
      Block bestBlock = null;
      long bestId = Long.MAX_VALUE;


      loop:
      for (int j = 0; j < len; j++) {
        TableIterator iter = _tableIterators[j];


        if (iter == null)
          continue;


        Block block = iter.getBlock();


        if (block == null)
          continue;


        long id = block.getBlockId();
        if (bestId <= id)
          continue;


        for (int k = 0; k < i; k++) {
          if (_blockLocks[k] == block)

View Full Code Here

    int len = _blockLocks.length;


    // need to unlock first since the writeData/commit will wait for
    // write locks to clear before committing
    for (int i = len - 1; i >= 0; i--) {
      Block block = _blockLocks[i];


      if (block == null) {
      }
      else if (_isWrite) {
        block.getWriteLock().unlock();
      }
      else {
        block.getReadLock().unlock();
      }
    }


    try {
      _xa.writeData();
    } finally {
      for (int i = len - 1; i >= 0; i--) {
        Block block = _blockLocks[i];
        _blockLocks[i] = null;


        if (block == null) {
        }
        else if (_isWrite) {
          try {
            block.commit();
          } catch (Exception e) {
            log.log(Level.FINE, e.toString(), e);
          }
        }
      }

View Full Code Here

  public static BTree createStringTest(Path path, int keySize)
    throws IOException, java.sql.SQLException
  {
    BlockStore store = BlockStore.create(path);


    Block block = store.allocateIndexBlock();
    long blockId = block.getBlockId();
    block.free();


    return new BTree(store, blockId, keySize, new StringKeyCompare());
  }

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.