com.sleepycat.je.dbi
Class CursorImpl

java.lang.Object
  extended by com.sleepycat.je.dbi.CursorImpl
All Implemented Interfaces:
Cloneable

public class CursorImpl
extends Object
implements Cloneable

A CursorImpl is the internal implementation of the cursor.


Nested Class Summary
static class CursorImpl.KeyChangeStatus
          Holder for an OperationStatus and a keyChange flag.
static class CursorImpl.SearchMode
          public for Cursor et al
static interface CursorImpl.WithCursor
          Callback object for traverseDbWithCursor.
 
Field Summary
static int EXACT_DATA
           
static int EXACT_KEY
           
static int FOUND
           
static int FOUND_LAST
           
 
Constructor Summary
CursorImpl(DatabaseImpl database, Locker locker)
          Creates a cursor with retainNonTxnLocks=true.
CursorImpl(DatabaseImpl databaseImpl, Locker locker, boolean retainNonTxnLocks)
          Creates a cursor.
 
Method Summary
 void addCursor()
          Add to the current cursor.
 void addCursor(BIN bin)
           
 boolean advanceCursor(DatabaseEntry key, DatabaseEntry data)
          Advance a cursor.
 void checkCursorState(boolean mustBeInitialized)
          Check that the cursor is open and optionally if it is initialized.
 void checkEnv()
           
 void clearClosingLocker()
          Called when a cursor move operation is complete.
 void clearDupBIN(boolean alreadyLatched)
          Clear the reference to the dup tree, if any.
 CursorImpl cloneCursor(boolean addCursor, CacheMode cacheMode)
          Shallow copy.
 CursorImpl cloneCursor(boolean addCursor, CacheMode cacheMode, CursorImpl usePosition)
          Performs a shallow copy.
 void close()
           
 void close(CursorImpl newCursor)
          Close a cursor.
 int count(LockType lockType)
           
 void criticalEviction()
           
 OperationStatus delete(ReplicationContext repContext)
          Delete the item pointed to by the cursor.
 void dump()
          dump the cursor for debugging purposes.
 void dump(boolean verbose)
          Dump the cursor for debugging purposes.
 String dumpToString(boolean verbose)
           
 void dumpTree()
           
 CursorImpl dup(boolean samePosition)
          Return a new copy of the cursor.
 void evict()
          Evict the LN node at the cursor position.
 void evict(boolean alreadyLatched)
          Evict the LN node at the cursor position.
 BIN getBIN()
           
 BIN getBINToBeRemoved()
           
 CacheMode getCacheMode()
           
 OperationStatus getCurrent(DatabaseEntry foundKey, DatabaseEntry foundData, LockType lockType)
          Retrieve the current record.
 OperationStatus getCurrentAlreadyLatched(DatabaseEntry foundKey, DatabaseEntry foundData, LockType lockType, boolean first)
          Retrieve the current record.
 LN getCurrentLN(LockType lockType)
          Retrieve the current LN, return with the target bin unlatched.
 LN getCurrentLNAlreadyLatched(LockType lockType)
          Retrieve the current LN, assuming the BIN is already latched.
 DBIN getDupBIN()
           
 DBIN getDupBINToBeRemoved()
           
 int getDupIndex()
           
 OperationStatus getFirstDuplicate(DatabaseEntry foundKey, DatabaseEntry foundData, LockType lockType)
          Retrieve the first duplicate at the current cursor position.
 int getIndex()
           
 DIN getLatchedDupRoot(boolean isDBINLatched)
          Fetch, latch and return the DIN root of the duplicate tree at the cursor position.
 Locker getLocker()
           
 StatGroup getLockStats()
           
 OperationStatus getNext(DatabaseEntry foundKey, DatabaseEntry foundData, LockType lockType, boolean forward, boolean alreadyLatched)
           
 OperationStatus getNextDuplicate(DatabaseEntry foundKey, DatabaseEntry foundData, LockType lockType, boolean forward, boolean alreadyLatched)
          Enter with dupBin unlatched.
 OperationStatus getNextNoDup(DatabaseEntry foundKey, DatabaseEntry foundData, LockType lockType, boolean forward, boolean alreadyLatched)
           
 CursorImpl.KeyChangeStatus getNextWithKeyChangeStatus(DatabaseEntry foundKey, DatabaseEntry foundData, LockType lockType, boolean forward, boolean alreadyLatched)
          Move the cursor forward and return the next record.
 int hashCode()
           
 void incrementLNCount()
           
 boolean isClosed()
           
 boolean isInternalDbCursor()
           
 boolean isNotInitialized()
           
 BIN latchBIN()
           
 void latchBINs()
           
 DBIN latchDBIN()
           
 LockResult lockDupCountLN(DIN dupRoot, LockType lockType)
          Locks the DupCountLN for the given duplicate root.
 void lockEofNode(LockType lockType)
          Locks the logical EOF node for the databaseImpl.
 LockResult lockLNDeletedAllowed(LN ln, LockType lockType)
          Locks the given LN's node ID; a deleted LN will be locked and returned.
 void lockNextKeyForInsert(DatabaseEntry key, DatabaseEntry data)
          Search for the next key (or duplicate) following the given key (and datum), and acquire a range insert lock on it.
 boolean positionFirstOrLast(boolean first, DIN duplicateRoot)
          Position the cursor at the first or last record of the databaseImpl.
 OperationStatus put(DatabaseEntry key, DatabaseEntry data, LN ln, PutMode putMode, DatabaseEntry returnOldData, DatabaseEntry returnNewData, ReplicationContext repContext)
          Performs all put operations except for CURRENT (use putCurrent instead).
 OperationStatus putCurrent(DatabaseEntry data, DatabaseEntry foundKey, DatabaseEntry foundData, DatabaseEntry returnNewData, long checkNodeId, ReplicationContext repContext)
          Modify the current record with this data.
 OperationStatus putLN(byte[] key, LN ln, DatabaseEntry returnNewData, boolean allowDuplicates, ReplicationContext repContext)
          Insert the given LN in the tree or return KEYEXIST if the key is already present.
 void releaseBIN()
           
 void releaseBINs()
           
 void releaseDBIN()
           
 void reset()
          Reset a cursor to an uninitialized state, but unlike close(), allow it to be used further.
 int searchAndPosition(DatabaseEntry matchKey, DatabaseEntry matchData, CursorImpl.SearchMode searchMode, LockType lockType)
          Position the cursor at the key.
 void setAllowEviction(boolean allowed)
          Disables or enables eviction during cursor operations.
 void setBIN(BIN newBin)
           
 void setCacheMode(CacheMode mode)
          Sets the effective cache mode to use for the next operation.
 void setClosingLocker(CursorImpl closingCursor)
          Called when a cursor has been duplicated prior to being moved.
static void setDbt(DatabaseEntry data, byte[] bytes)
          Helper to return a Data DBT from a BIN.
 void setDupBIN(DBIN newDupBin)
           
 void setDupIndex(int dupIdx)
           
 void setIndex(int idx)
           
 void setTestHook(TestHook hook)
           
 void setTreeStatsAccumulator(TreeWalkerStatsAccumulator tSA)
           
static void traverseDbWithCursor(DatabaseImpl db, LockType lockType, boolean allowEviction, CursorImpl.WithCursor withCursor)
          Enumerates all records in a databaseImpl non-transactionally and calls the withCursor method for each record.
 void updateBin(BIN bin, int index)
           
 void updateDBin(DBIN dupBin, int dupIndex)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

FOUND

public static final int FOUND
See Also:
Constant Field Values

EXACT_KEY

public static final int EXACT_KEY
See Also:
Constant Field Values

EXACT_DATA

public static final int EXACT_DATA
See Also:
Constant Field Values

FOUND_LAST

public static final int FOUND_LAST
See Also:
Constant Field Values
Constructor Detail

CursorImpl

public CursorImpl(DatabaseImpl database,
                  Locker locker)
Creates a cursor with retainNonTxnLocks=true.


CursorImpl

public CursorImpl(DatabaseImpl databaseImpl,
                  Locker locker,
                  boolean retainNonTxnLocks)
Creates a cursor. A cursor always retains transactional locks when it is reset or closed. Non-transaction locks may be retained or not, depending on the retainNonTxnLocks parameter value. Normally a user-created non-transactional Cursor releases locks on reset and close, and a ThreadLocker is normally used. However, by passing true for retainNonTxnLocks a ThreadLocker can be made to retain locks; this capability is used by SecondaryCursor.readPrimaryAfterGet. For internal (non-user) cursors, a BasicLocker is often used and locks are retained. BasicLocker does not currently support releasing locks per cursor operation, so true must be passed for retainNonTxnLocks. In addition, in these internal use cases the caller explicitly calls BasicLocker.operationEnd, and retainNonTxnLocks is set to true to prevent operationEnd from being called when the cursor is closed. BasicLocker is also used for NameLN operations while opening a Database handle. Database handle locks must be retained, even if the Database is opened non-transactionally.

Parameters:
retainNonTxnLocks - is true if non-transactional locks should be retained (not released automatically) when the cursor is reset or closed.
Method Detail

hashCode

public int hashCode()
Overrides:
hashCode in class Object

incrementLNCount

public void incrementLNCount()

setAllowEviction

public void setAllowEviction(boolean allowed)
Disables or enables eviction during cursor operations. For example, a cursor used to implement eviction (e.g., in some UtilizationProfile and most DbTree and VLSNIndex methods) should not itself perform eviction, but eviction should be enabled for user cursors. Eviction is disabled by default.


criticalEviction

public void criticalEviction()

cloneCursor

public CursorImpl cloneCursor(boolean addCursor,
                              CacheMode cacheMode)
                       throws DatabaseException
Shallow copy. addCursor() is optionally called.

Throws:
DatabaseException

cloneCursor

public CursorImpl cloneCursor(boolean addCursor,
                              CacheMode cacheMode,
                              CursorImpl usePosition)
                       throws DatabaseException
Performs a shallow copy.

Parameters:
addCursor - If true, addCursor() is called to register the new cursor with the BINs. This is done after the usePosition parameter is applied, if any. There are two cases where you may not want addCursor() to be called: 1) When creating a fresh uninitialized cursor as in when Cursor.dup(false) is called, or 2) when the caller will call addCursor() as part of a larger operation.
usePosition - Is null to duplicate the position of this cursor, or non-null to duplicate the position of the given cursor.
Throws:
DatabaseException

setClosingLocker

public void setClosingLocker(CursorImpl closingCursor)
Called when a cursor has been duplicated prior to being moved. The new locker is informed of the old locker, so that a preempted lock taken by the old locker can be ignored. [#16513]

Parameters:
closingCursor - the old cursor that will be closed if the new cursor is moved successfully.

clearClosingLocker

public void clearClosingLocker()
Called when a cursor move operation is complete. Clears the closingLocker so that a reference to the old closed locker is not held.


getIndex

public int getIndex()

setIndex

public void setIndex(int idx)

getBIN

public BIN getBIN()

setBIN

public void setBIN(BIN newBin)

getBINToBeRemoved

public BIN getBINToBeRemoved()

getDupIndex

public int getDupIndex()

setDupIndex

public void setDupIndex(int dupIdx)

getDupBIN

public DBIN getDupBIN()

setDupBIN

public void setDupBIN(DBIN newDupBin)

getDupBINToBeRemoved

public DBIN getDupBINToBeRemoved()

getCacheMode

public CacheMode getCacheMode()

setCacheMode

public void setCacheMode(CacheMode mode)
Sets the effective cache mode to use for the next operation. The cacheMode field will never be set to null or DYNAMIC, and can be passed directly to latching methods.

See Also:
performCacheEviction(com.sleepycat.je.dbi.CursorImpl)

setTreeStatsAccumulator

public void setTreeStatsAccumulator(TreeWalkerStatsAccumulator tSA)

advanceCursor

public boolean advanceCursor(DatabaseEntry key,
                             DatabaseEntry data)
Advance a cursor. Used so that verify can advance a cursor even in the face of an exception [12932].

Parameters:
key - on return contains the key if available, or null.
data - on return contains the data if available, or null.

latchBIN

public BIN latchBIN()
             throws DatabaseException
Throws:
DatabaseException

releaseBIN

public void releaseBIN()

latchBINs

public void latchBINs()
               throws DatabaseException
Throws:
DatabaseException

releaseBINs

public void releaseBINs()

latchDBIN

public DBIN latchDBIN()
               throws DatabaseException
Throws:
DatabaseException

releaseDBIN

public void releaseDBIN()

getLocker

public Locker getLocker()

addCursor

public void addCursor(BIN bin)

addCursor

public void addCursor()
Add to the current cursor. (For dups)


updateBin

public void updateBin(BIN bin,
                      int index)
               throws DatabaseException
Throws:
DatabaseException

updateDBin

public void updateDBin(DBIN dupBin,
                       int dupIndex)

clearDupBIN

public void clearDupBIN(boolean alreadyLatched)
                 throws DatabaseException
Clear the reference to the dup tree, if any.

Throws:
DatabaseException

dumpTree

public void dumpTree()

isClosed

public boolean isClosed()
Returns:
true if this cursor is closed

isNotInitialized

public boolean isNotInitialized()
Returns:
true if this cursor is not initialized

isInternalDbCursor

public boolean isInternalDbCursor()

reset

public void reset()
           throws DatabaseException
Reset a cursor to an uninitialized state, but unlike close(), allow it to be used further.

Throws:
DatabaseException

close

public void close()
           throws DatabaseException
Throws:
DatabaseException

close

public void close(CursorImpl newCursor)
           throws DatabaseException
Close a cursor.

Parameters:
newCursor - is another cursor that is kept open by the parent Cursor object, or null if no other cursor is kept open.
Throws:
DatabaseException - if the cursor was previously closed.

count

public int count(LockType lockType)
          throws DatabaseException
Throws:
DatabaseException

delete

public OperationStatus delete(ReplicationContext repContext)
                       throws DatabaseException
Delete the item pointed to by the cursor. If cursor is not initialized or item is already deleted, return appropriate codes. Returns with nothing latched. bin and dupBin are latched as appropriate.

Returns:
0 on success, appropriate error code otherwise.
Throws:
DatabaseException

dup

public CursorImpl dup(boolean samePosition)
               throws DatabaseException
Return a new copy of the cursor.

Parameters:
samePosition - If true, position the returned cursor at the same position as this cursor; if false, return a new uninitialized cursor.
Throws:
DatabaseException

evict

public void evict()
           throws DatabaseException
Evict the LN node at the cursor position.

Throws:
DatabaseException

evict

public void evict(boolean alreadyLatched)
           throws DatabaseException
Evict the LN node at the cursor position.

Throws:
DatabaseException

lockNextKeyForInsert

public void lockNextKeyForInsert(DatabaseEntry key,
                                 DatabaseEntry data)
                          throws DatabaseException
Search for the next key (or duplicate) following the given key (and datum), and acquire a range insert lock on it. If there are no more records following the given key and datum, lock the special EOF node for the databaseImpl.

Throws:
DatabaseException

put

public OperationStatus put(DatabaseEntry key,
                           DatabaseEntry data,
                           LN ln,
                           PutMode putMode,
                           DatabaseEntry returnOldData,
                           DatabaseEntry returnNewData,
                           ReplicationContext repContext)
Performs all put operations except for CURRENT (use putCurrent instead).


putLN

public OperationStatus putLN(byte[] key,
                             LN ln,
                             DatabaseEntry returnNewData,
                             boolean allowDuplicates,
                             ReplicationContext repContext)
                      throws DatabaseException
Insert the given LN in the tree or return KEYEXIST if the key is already present.

This method is called directly internally for putting tree map LNs and file summary LNs. It should not be used otherwise, and in the future we should find a way to remove this special case.

Parameters:
returnNewData - if non-null, is used to return a complete copy of the resulting data after any partial data has been resolved.
Throws:
DatabaseException

putCurrent

public OperationStatus putCurrent(DatabaseEntry data,
                                  DatabaseEntry foundKey,
                                  DatabaseEntry foundData,
                                  DatabaseEntry returnNewData,
                                  long checkNodeId,
                                  ReplicationContext repContext)
                           throws DatabaseException
Modify the current record with this data.

Parameters:
data - to overwrite, may be partial.
foundKey - if non-null, is used to return a copy of the existing key, may be partial.
foundData - if non-null, is used to return a copy of the existing data, may be partial.
returnNewData - if non-null, is used to return a complete copy of the resulting data after any partial data has been resolved.
checkNodeId - if not Node.NULL_NODE_ID, is the node ID to be overwritten. If the given node ID is not equal to the node ID at the current position, an EnvironmentFailureExcepion UNEXPECTED_STATE is thrown.
Throws:
DatabaseException

getCurrent

public OperationStatus getCurrent(DatabaseEntry foundKey,
                                  DatabaseEntry foundData,
                                  LockType lockType)
                           throws DatabaseException
Retrieve the current record.

Throws:
DatabaseException

getCurrentAlreadyLatched

public OperationStatus getCurrentAlreadyLatched(DatabaseEntry foundKey,
                                                DatabaseEntry foundData,
                                                LockType lockType,
                                                boolean first)
                                         throws DatabaseException
Retrieve the current record. Assume the bin is already latched. Return with the target bin unlatched.

Throws:
DatabaseException

getCurrentLN

public LN getCurrentLN(LockType lockType)
                throws DatabaseException
Retrieve the current LN, return with the target bin unlatched.

Throws:
DatabaseException

getCurrentLNAlreadyLatched

public LN getCurrentLNAlreadyLatched(LockType lockType)
                              throws DatabaseException
Retrieve the current LN, assuming the BIN is already latched. Return with the target BIN unlatched.

Throws:
DatabaseException

getNext

public OperationStatus getNext(DatabaseEntry foundKey,
                               DatabaseEntry foundData,
                               LockType lockType,
                               boolean forward,
                               boolean alreadyLatched)
                        throws DatabaseException
Throws:
DatabaseException

getNextWithKeyChangeStatus

public CursorImpl.KeyChangeStatus getNextWithKeyChangeStatus(DatabaseEntry foundKey,
                                                             DatabaseEntry foundData,
                                                             LockType lockType,
                                                             boolean forward,
                                                             boolean alreadyLatched)
                                                      throws DatabaseException
Move the cursor forward and return the next record. This will cross BIN boundaries and dip into duplicate sets.

Parameters:
foundKey - DatabaseEntry to use for returning key
foundData - DatabaseEntry to use for returning data
forward - if true, move forward, else move backwards
alreadyLatched - if true, the bin that we're on is already latched.
Returns:
the status and an indication of whether we advanced to a new key during the operation.
Throws:
DatabaseException

getNextNoDup

public OperationStatus getNextNoDup(DatabaseEntry foundKey,
                                    DatabaseEntry foundData,
                                    LockType lockType,
                                    boolean forward,
                                    boolean alreadyLatched)
                             throws DatabaseException
Throws:
DatabaseException

getFirstDuplicate

public OperationStatus getFirstDuplicate(DatabaseEntry foundKey,
                                         DatabaseEntry foundData,
                                         LockType lockType)
                                  throws DatabaseException
Retrieve the first duplicate at the current cursor position.

Throws:
DatabaseException

getNextDuplicate

public OperationStatus getNextDuplicate(DatabaseEntry foundKey,
                                        DatabaseEntry foundData,
                                        LockType lockType,
                                        boolean forward,
                                        boolean alreadyLatched)
                                 throws DatabaseException
Enter with dupBin unlatched. Pass foundKey == null to just advance cursor to next duplicate without fetching data.

Throws:
DatabaseException

positionFirstOrLast

public boolean positionFirstOrLast(boolean first,
                                   DIN duplicateRoot)
                            throws DatabaseException
Position the cursor at the first or last record of the databaseImpl. It's okay if this record is deleted. Returns with the target BIN latched.

Returns:
true if a first or last position is found, false if the tree being searched is empty.
Throws:
DatabaseException

searchAndPosition

public int searchAndPosition(DatabaseEntry matchKey,
                             DatabaseEntry matchData,
                             CursorImpl.SearchMode searchMode,
                             LockType lockType)
                      throws DatabaseException
Position the cursor at the key. This returns a three part value that's bitwise or'ed into the int. We find out if there was any kind of match and if the match was exact. Note that this match focuses on whether the searching criteria (key, or key and data, depending on the search type) is met.

Note this returns with the BIN latched!

If this method returns without the FOUND bit set, the caller can assume that no match is possible. Otherwise, if the FOUND bit is set, the caller should check the EXACT_KEY and EXACT_DATA bits. If EXACT_KEY is not set (or for BOTH and BOTH_RANGE, if EXACT_DATA is not set), an approximate match was found. In an approximate match, the cursor is always positioned before the target key/data. This allows the caller to perform a 'next' operation to advance to the value that is equal or higher than the target key/data.

Even if the search returns an exact result, the record may be deleted. The caller must therefore check for both an approximate match and for whether the cursor is positioned on a deleted record.

If SET or BOTH is specified, the FOUND bit will only be returned if an exact match is found. However, the record found may be deleted.

There is one special case where this method may be called without checking the EXACT_KEY (and EXACT_DATA) bits and without checking for a deleted record: If SearchMode.SET is specified then only the FOUND bit need be checked. When SET is specified and FOUND is returned, it is guaranteed to be an exact match on a non-deleted record. It is for this case only that this method is public.

If FOUND is set, FOUND_LAST may also be set if the cursor is positioned on the last record in the databaseImpl. Note that this state can only be counted on as long as the BIN is latched, so it is not set if this method must release the latch to lock the record. Therefore, it should only be used for optimizations. If FOUND_LAST is set, the cursor is positioned on the last record and the BIN is latched. If FOUND_LAST is not set, the cursor may or may not be positioned on the last record. Note that exact searches always perform an unlatch and a lock, so FOUND_LAST will only be set for inexact (range) searches.

Be aware that when an approximate match is returned, the index or dupIndex may be set to -1. This is done intentionally so that a 'next' operation will increment it.

Throws:
DatabaseException

lockLNDeletedAllowed

public LockResult lockLNDeletedAllowed(LN ln,
                                       LockType lockType)
                                throws DatabaseException
Locks the given LN's node ID; a deleted LN will be locked and returned. Attempts to use a non-blocking lock to avoid unlatching/relatching. Retries if necessary, to handle the case where the LN is changed while the BIN is unlatched. Preconditions: The target BIN must be latched. When positioned in a dup tree, the BIN may be latched on entry also and if so it will be latched on exit. Postconditions: The target BIN is latched. When positioned in a dup tree, the DBIN will be latched if it was latched on entry or a blocking lock was needed. Therefore, when positioned in a dup tree, releaseDBIN should be called.

Parameters:
ln - the LN to be locked.
lockType - the type of lock requested.
Returns:
the LockResult containing the LN that was locked, or containing a null LN if the LN was cleaned.
Throws:
DatabaseException

lockDupCountLN

public LockResult lockDupCountLN(DIN dupRoot,
                                 LockType lockType)
                          throws DatabaseException
Locks the DupCountLN for the given duplicate root. Attempts to use a non-blocking lock to avoid unlatching/relatching. Preconditions: The dupRoot, BIN and DBIN are latched. Postconditions: The dupRoot, BIN and DBIN are latched. Note that the dupRoot may change during locking and should be refetched if needed.

Parameters:
dupRoot - the duplicate root containing the DupCountLN to be locked.
lockType - the type of lock requested.
Returns:
the LockResult containing the LN that was locked.
Throws:
DatabaseException

getLatchedDupRoot

public DIN getLatchedDupRoot(boolean isDBINLatched)
                      throws DatabaseException
Fetch, latch and return the DIN root of the duplicate tree at the cursor position. Preconditions: The BIN must be latched and the current BIN entry must contain a DIN. Postconditions: The BIN and DIN will be latched. The DBIN will remain latched if isDBINLatched is true.

Parameters:
isDBINLatched - is true if the DBIN is currently latched.
Throws:
DatabaseException

setDbt

public static void setDbt(DatabaseEntry data,
                          byte[] bytes)
Helper to return a Data DBT from a BIN.


checkCursorState

public void checkCursorState(boolean mustBeInitialized)
Check that the cursor is open and optionally if it is initialized.

Throws:
IllegalStateException - via all Cursor methods that call Cursor.checkState (all get and put methods, plus more).

lockEofNode

public void lockEofNode(LockType lockType)
                 throws DatabaseException
Locks the logical EOF node for the databaseImpl.

Throws:
DatabaseException

checkEnv

public void checkEnv()
Throws:
EnvironmentFailureException - if the underlying environment is invalid.

traverseDbWithCursor

public static void traverseDbWithCursor(DatabaseImpl db,
                                        LockType lockType,
                                        boolean allowEviction,
                                        CursorImpl.WithCursor withCursor)
                                 throws DatabaseException
Enumerates all records in a databaseImpl non-transactionally and calls the withCursor method for each record. Stops the enumeration if the callback returns false.

Parameters:
db - DatabaseImpl to traverse.
lockType - non-null LockType for reading records.
allowEviction - should normally be true to evict when performing multiple operations, but may be false if eviction is disallowed in a particular context.
withCursor - callback object.
Throws:
DatabaseException

dump

public void dump(boolean verbose)
Dump the cursor for debugging purposes. Dump the bin and dbin that the cursor refers to if verbose is true.


dump

public void dump()
dump the cursor for debugging purposes.


dumpToString

public String dumpToString(boolean verbose)

getLockStats

public StatGroup getLockStats()
                       throws DatabaseException
Throws:
DatabaseException

setTestHook

public void setTestHook(TestHook hook)


Copyright (c) 2004-2010 Oracle. All rights reserved.