Examples of com.caucho.db.lock.Lock

com.caucho.db.lock.Lock
Locking for tables/etc.

    Block block = _store.readBlock(blockId);


    try {
      validate(block);
        
      Lock blockLock = block.getLock();
      blockLock.lockReadAndWrite(_timeout);
  
      try {
        split(parent, block);


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

View Full Code Here

  {
    Block rootBlock = _rootBlock; // store.readBlock(rootBlockId);
    rootBlock.allocate();


    try {
      Lock rootLock = rootBlock.getLock();
      rootLock.lockReadAndWrite(_timeout);
      
      try {
  splitRoot(rootBlock);


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

View Full Code Here

                             byte []keyBuffer,
                             int keyOffset,
                             int keyLength)
    throws IOException, SQLException
  {
    Lock blockLock = block.getLock();
    blockLock.lockRead(_timeout);


    try {
      validateIndex(block);
        
      byte []buffer = block.getBuffer();
      long blockId = block.getBlockId();


      if (isLeaf(buffer, block))
        return false;
      
      long childId;
  
      childId = lookupTuple(blockId, buffer,
                            keyBuffer, keyOffset, keyLength,
                            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.unlockRead();
    }
  }

View Full Code Here

    throws IOException, SQLException
  {
    byte []buffer = block.getBuffer();
    long blockId = block.getBlockId();
    
    Lock blockLock = block.getLock();
    blockLock.lockReadAndWrite(_timeout);


    try {
      boolean isLeaf = isLeaf(buffer, block);


      if (isLeaf) {
        block.setFlushDirtyOnCommit(false);


        removeLeafEntry(blockId, buffer,
                        keyBuffer, keyOffset, keyLength);
        
        block.setDirty(0, BlockStore.BLOCK_SIZE);
      }
      else {
        long childId;
  
        childId = lookupTuple(blockId, buffer,
                              keyBuffer, keyOffset, keyLength,
                              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 + " " + block.getLock());
            }
            childBlock.deallocate();
          }


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

View Full Code Here

      Block leftBlock = _store.readBlock(leftBlockId);


      try {
        byte []leftBuffer = leftBlock.getBuffer();
  
        Lock leftLock = leftBlock.getLock();
        leftLock.lockReadAndWrite(_timeout);
    
        try {
          int leftLength = getLength(leftBuffer);


          Lock blockLock = block.getLock();
          blockLock.lockReadAndWrite(_timeout);
      
          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.unlockReadAndWrite();
          }
        } finally {
          leftLock.unlockReadAndWrite();
        }
      } 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.getLock();
        blockLock.lockReadAndWrite(_timeout);


        try {
          Lock rightLock = rightBlock.getLock();
          rightLock.lockReadAndWrite(_timeout);
        
          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.unlockReadAndWrite();
          }
        } finally {
          blockLock.unlockReadAndWrite();
        }
      } 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.getLock();
        leftLock.lockReadAndWrite(_timeout);


        try {
          int leftLength = getLength(leftBuffer);
      
          Lock blockLock = block.getLock();
          blockLock.lockReadAndWrite(_timeout);


          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.unlockReadAndWrite();
          }
        } finally {
          leftLock.unlockReadAndWrite();
        }
      } 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.getLock();
        blockLock.lockReadAndWrite(_timeout);


        try {
          Lock rightLock = rightBlock.getLock();
          rightLock.lockReadAndWrite(_timeout);


          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.unlockReadAndWrite();
          }
        } finally {
          blockLock.unlockReadAndWrite();
        }
      } finally {

View Full Code Here

      if (columns[i].getAutoIncrement() >= 0)
        autoIncrementColumn = columns[i];
    }
    _autoIncrementColumn = autoIncrementColumn;


    new Lock("table-insert:" + name);
    new Lock("table-alloc:" + name);
  }

View Full Code Here

  }


  private int allocateRow(Block block, Transaction xa)
    throws IOException, SQLException
  {
    Lock blockLock = block.getLock();


    blockLock.lockReadAndWrite(xa.getTimeout());
    try {
      block.read();


      byte []buffer = block.getBuffer();


      int rowOffset = 0;


      for (; rowOffset < _rowEnd; rowOffset += _rowLength) {
        if (buffer[rowOffset] == 0) {
          buffer[rowOffset] = ROW_ALLOC;


          block.setDirty(rowOffset, rowOffset + 1);


          return rowOffset;
        }
      }
    } finally {
      blockLock.unlockReadAndWrite();
    }


    return -1;
  }

View Full Code Here

  private void releaseLocks()
  {
    // need to unlock write before upgrade to block other threads
    if (_writeLocks != null) {
      for (int i = 0; i < _writeLocks.size(); i++) {
  Lock lock = _writeLocks.get(i);


  if (_readLocks != null)
    _readLocks.remove(lock);


  try {
    lock.unlockReadAndWrite();
  } catch (Throwable e) {
    log.log(Level.WARNING, e.toString(), e);
  }
      }


      _writeLocks.clear();
    }
    
    if (_readLocks != null) {
      for (int i = 0; i < _readLocks.size(); i++) {
  Lock lock = _readLocks.get(i);


  try {
    lock.unlockRead();
  } catch (Throwable e) {
    log.log(Level.WARNING, e.toString(), e);
  }
      }

View Full Code Here

0 1 2

TOP

Related Classes of com.caucho.db.lock.Lock

com.caucho.db.block.Block

com.caucho.db.block.BlockStore

com.caucho.db.index.BTree

com.caucho.db.table.Table

com.caucho.db.xa.DbTransaction

com.caucho.db.xa.Transaction

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.