/** * Constructor for this database browser. * * @param berkeley * BerkeleyEnv * @param l * UpdateListener * @param clazz * Class<AnyType> */ public BerkeleyBrowser(BerkeleyEnv berkeley, UpdateListener l, Class<? extends AnyType> clazz) { // berkeley env for event propagation this.berkeley = berkeley; // persistent update listener this.listener = l; // class for objects this.clazz = clazz; // set cursor to read uncommitted data cc = new CursorConfig(); cc.setReadUncommitted(true); }
Cursor openPrimaryCursor() { CursorConfig config = new CursorConfig(); config.setReadCommitted(true); return db.get().openCursor(tm.getInternalTx(), config); }
/** * Returns this cursor's configuration. * * <p>This may differ from the configuration used to open this object if * the cursor existed previously.</p> * * @return This cursor's configuration. */ public CursorConfig getConfig() { try { return config.clone(); } catch (Error E) { dbImpl.getEnv().invalidate(E); throw E; } }
transactionConfig.setReadCommitted(true); safeCursorConfig = new CursorConfig(); safeCursorConfig.setReadCommitted(true); unsafeCursorConfig = new CursorConfig(); unsafeCursorConfig.setReadUncommitted(true);
public static CursorConfig cloneCursorConfig(CursorConfig config) { CursorConfig newConfig = new CursorConfig(); newConfig.setReadCommitted(config.getReadCommitted()); newConfig.setReadUncommitted(config.getReadUncommitted()); return newConfig; }
cdbConfig = new CursorConfig(); DbCompat.setWriteCursor(cdbConfig, true); } else {
dbConfig.setReadOnly(false); config.setReadCommitted(true);
if (cursorConfig.getReadUncommitted() && cursorConfig.getReadCommitted()) { throw new IllegalArgumentException( "Only one may be specified: " +
cursorConfig.getReadUncommitted() || locker.isReadUncommittedDefault(); this.logger = databaseImpl.getEnv().getLogger(); nonSticky = cursorConfig.getNonSticky();
/** * Creates a cursor for a given locker with retainNonTxnLocks=false. * * <p>If locker is null or is non-transactional, a non-transactional cursor * will be created that releases locks for the prior operation when the * next operation succeeds.</p> */ Cursor(final Database dbHandle, Locker locker, CursorConfig cursorConfig) { if (cursorConfig == null) { cursorConfig = CursorConfig.DEFAULT; } /* Check that Database is open for internal Cursor usage. */ final DatabaseImpl dbImpl = dbHandle.checkOpen(); locker = LockerFactory.getReadableLocker( dbHandle, locker, cursorConfig.getReadCommitted()); init(dbHandle, dbImpl, locker, cursorConfig, false /*retainNonTxnLocks*/); }
CursorConfig config = new CursorConfig(); Cursor crsr = _store.openCursor(null, config); final DatabaseEntry keyEntry;
/** * Creates a cursor for a given user transaction with * retainNonTxnLocks=false. * * <p>If txn is null, a non-transactional cursor will be created that * releases locks for the prior operation when the next operation * succeeds.</p> */ Cursor(final Database dbHandle, final Transaction txn, CursorConfig cursorConfig) { if (cursorConfig == null) { cursorConfig = CursorConfig.DEFAULT; } /* Check that Database is open for internal Cursor usage. */ final DatabaseImpl dbImpl = dbHandle.checkOpen(); /* Do not allow auto-commit when creating a user cursor. */ Locker locker = LockerFactory.getReadableLocker( dbHandle, txn, cursorConfig.getReadCommitted()); init(dbHandle, dbImpl, locker, cursorConfig, false /*retainNonTxnLocks*/); }
/** * Uses a transaction to open a read only cursor for it to work when called from a different * threads than the one it was created at. The transaction is aborted at {@link #close()} */ public CursorRevObjectIterator(final Iterator<ObjectId> objectIds, final BulkOpListener listener, final Class<?> filter) { this.filter = filter; this.unsortedIds = Iterators.partition(objectIds, getBulkPartitionSize()); this.sortedIds = Collections.emptyIterator(); this.listener = listener; CursorConfig cursorConfig = new CursorConfig(); cursorConfig.setReadUncommitted(true); transaction = getOrCreateTransaction(); this.cursor = objectDb.openCursor(transaction, cursorConfig); }
Cursor openForeignCursor() { CursorConfig config = new CursorConfig(); config.setReadCommitted(true); return secondary.get().openCursor(tm.getInternalTx(), config); }
cursorConfig = new CursorConfig(); DbCompat.setWriteCursor(cursorConfig, true);
this, txn, cursorConfig.getReadCommitted());
@Override public int size() { if (size == null) { CursorConfig cc = new CursorConfig(); cc.setReadUncommitted(true); Cursor c = berkeley.openDupCursor(proxyObject, null, clazz, cc); if (c.getSearchKey(theKey, new DatabaseEntry(), LockMode.DEFAULT) != OperationStatus.SUCCESS) { size = 0; } else { size = c.count(); } berkeley.releaseCursor(c); } return size; }
Map <Integer, RepNodeImpl> nodes = new HashMap<Integer, RepNodeImpl>(); final CursorConfig cursorConfig = new CursorConfig(); cursorConfig.setReadCommitted(true);
@Override public long countIndexed() throws StoreException { long count = 0L; try { SecondaryCursor crsr = _index.openCursor(null, new CursorConfig()); final DatabaseEntry keyEntry = new DatabaseEntry(); final DatabaseEntry primaryKeyEntry = new DatabaseEntry(); final DatabaseEntry data = new DatabaseEntry(); try { OperationStatus status = crsr.getFirst(keyEntry, primaryKeyEntry, data, null); for (; status == OperationStatus.SUCCESS; status = crsr.getNext(keyEntry, primaryKeyEntry, data, null)) { ++count; } return count; } finally { crsr.close(); } } catch (DatabaseException de) { _convertDBE(null, de); return count; } }
this, txn, cursorConfig.getReadCommitted());