IN (starrocks-bdb-je 18.3.17 API)

java.lang.Object
- com.sleepycat.je.tree.Node
- - com.sleepycat.je.tree.IN

All Implemented Interfaces:

LatchContext, Loggable, Comparable<IN>

Direct Known Subclasses:

BIN, DIN
```
public class IN
extends Node
implements Comparable<IN>, LatchContext
```
An IN represents an Internal Node in the JE tree. Explanation of KD (KnownDeleted) and PD (PendingDelete) entry flags =================================================================== PD: set for all LN entries that are deleted, even before the LN is committed. Is used as an authoritative (transactionally correct) indication that an LN is deleted. PD will be cleared if the txn for the deleted LN is aborted. KD: set under special conditions for entries containing LNs which are known to be obsolete. Not used for entries in an active/uncommitted transaction. First notice that IN.fetchLN will allow a FileNotFoundException when the PD or KD flag is set on the entry. And it will allow a NULL_LSN when the KD flag is set. KD was implemented first, and was originally used when the cleaner attempts to migrate an LN and discovers it is deleted (see Cleaner.migrateLN). We need KD because the INCompressor may not have run, and may not have compressed the BIN. There's the danger that we'll try to fetch that entry, and that the file was deleted by the cleaner. KD was used more recently when an unexpected exception occurs while logging an LN, after inserting the entry. Rather than delete the entry to clean up, we mark the entry KD so it won't cause a fetch error later. In this case the entry LSN is NULL_LSN. See Tree.insertNewSlot. PD is closely related to the first use of KD above (for cleaned deleted LNs) and came about because of a cleaner optimization we make. The cleaner considers all deleted LN log entries to be obsolete, without doing a tree lookup, and without any record of an obsolete offset. This makes the cost of cleaning of deleted LNs very low. For example, if the log looks like this: 100 LNA 200 delete of LNA then LSN 200 will be considered obsolete when this file is processed by the cleaner. After all, only two things can happen: (1) the txn commits, and we don't need LSN 200, because we can wipe this LN out of the tree, or (2) the txn aborts, and we don't need LSN 200, because we are going to revert to LSN 100/LNA. We set PD for the entry of a deleted LN at the time of the operation, and we clear PD if the transaction aborts. There is no real danger that this log entry will be processed by the cleaner before it's committed, because cleaning can only happen after the first active LSN. Just as in the first use of KD above, setting PD is necessary to avoid a fetch error, when the file is deleted by the cleaner but the entry containing the deleted LN has not been deleted by the INCompressor. PD is also set in replication rollback, when LNs are marked as invisible. When LSN locking was implemented (see CursorImpl.lockLN), the PD flag took on additional meaning. PD is used to determine whether an LN is deleted without fetching it, and therefore is relied on to be transactionally correct. In addition to the setting and use of the KD/PD flags described above, the situation is complicated by the fact that we must restore the state of these flags during abort, recovery, and set them properly during slot reuse. We have been meaning to consider whether PD and KD can be consolidated into one flag: simply the Deleted flag. The Deleted flag would be set in the same way as PD is currently set, as well as the second use of KD described above (when the LSN is NULL_LSN after an insertion error). The use of KD and PD for invisible entries and recovery rollback should also be considered. If we consolidate the two flags and set the Deleted flag during a delete operation (like PD), we'll have to remove optimizations (in CursorImpl for example) that consider a slot deleted when KD is set. Since KD is rarely set currently, this shouldn't have a noticeable performance impact.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ACCUMULATED_LIMIT`
`static int`	`ACCUMULATED_LIMIT_DEFAULT`
`static int`	`BIN_LEVEL`
`static int`	`DBMAP_LEVEL`
`static boolean`	`disableCompactLsns`
`static int`	`EXACT_MATCH`
`static int`	`INSERT_SUCCESS`
`static int`	`LEVEL_MASK`
`static int`	`MAIN_LEVEL`
`static int`	`MAX_FILE_OFFSET`
`static int`	`MIN_LEVEL`
`static long`	`NON_EVICTABLE_IN`

Fields inherited from class com.sleepycat.je.tree.Node
NULL_NODE_ID

Constructor Summary

Constructors
Constructor and Description
`IN()` Create an empty IN, with no node ID, to be filled in from the log.
`IN(DatabaseImpl dbImpl, byte[] identifierKey, int capacity, int level)` Create a new IN.
`IN(SizeofMarker marker)` For Sizeof.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`attachNode(int idx, Node node, byte[] newKey)` Attach the given node as the idx-th child of "this" node.
`String`	`beginTag()`
`void`	`clearLastLoggedSize(int idx)` The last logged size is not stored for UINs.
`void`	`clearOffHeapBINId(int idx)`
`long`	`compactMemory()` Compacts the representation of the IN, if possible.
`int`	`compareTo(IN argIN)` Sort based on equality key.
`long`	`computeMemorySize()` Count up the memory usage attributable to this node alone.
`void`	`convertKey(int idx, byte[] newKey)` This method is used in DupConvert, where it is called to convert the keys of an upper IN that has just been fetched from the log and is not attached to in-memory tree yet.
`void`	`deleteEntry(int index)` Removes the slot at index from this IN.
`void`	`deleteRecord(int idx, long oldMemSize, long newLSN, long newVLSN, int newSize)` Update the idx slot slot of this BIN to reflect a deletion of the associated record.
`void`	`detachNode(int idx, boolean updateLsn, long newLsn)`
`void`	`dumpLog(StringBuilder sb, boolean verbose)` Write the object into the string buffer for log dumping.
`protected void`	`dumpLogAdditional(StringBuilder sb)` Allows subclasses to add additional fields before the end tag.
`String`	`dumpString(int nSpaces, boolean dumpTags)` For unit test support:
`String`	`endTag()`
`boolean`	`equals(Object obj)`
`IN`	`fetchIN(int idx, CacheMode cacheMode)` Returns the idx-th child of "this" upper IN, fetching the child from the log and attaching it to its parent if it is not already attached.
`LN`	`fetchLN(int idx, CacheMode cacheMode)` Returns the target of the idx'th entry, fetching from disk if necessary.
`Node`	`fetchLNOrDIN(int idx, CacheMode cacheMode)`
`int`	`findEntry(byte[] key, boolean indicateIfDuplicate, boolean exact)`
`int`	`findEntry(byte[] key, boolean indicateIfDuplicate, boolean exact, Comparator<byte[]> comparator)` Find the entry in this IN for which key is LTE the key arg.
`long`	`getBudgetedMemorySize()` Returns the amount of memory currently budgeted for this IN.
`protected int`	`getCompactMaxKeyLength()`
`byte[]`	`getData(int idx)`
`DatabaseImpl`	`getDatabase()` Get the database for this IN.
`DatabaseId`	`getDatabaseId()`
`boolean`	`getDirty()`
`EnvironmentImpl`	`getEnv()`
`EnvironmentImpl`	`getEnvImplForFatalException()` Returns envImpl, or may throw another exception in unit tests.
`boolean`	`getFetchedCold()` Indicates that the BIN was fetched from disk, or loaded from the off-heap cache, using CacheMode.UNCHANGED, and has not been accessed with another CacheMode.
`boolean`	`getFetchedColdOffHeap()`
`protected long`	`getFixedMemoryOverhead()`
`LogEntryType`	`getGenericLogType()` Returns the generic LogEntryType for this node.
`byte[]`	`getIdentifierKey()`
`boolean`	`getInListResident()` Returns whether this IN is on the INList.
`long`	`getInMemorySize()`
`byte[]`	`getKey(int idx)` Return the idx'th key.
`Comparator<byte[]>`	`getKeyComparator()` Convenience method to return the database key comparator.
`byte[]`	`getKeyPrefix()`
`INKeyRep`	`getKeyVals()`
`int`	`getKnownChildIndex(Node child)` Returns the index of the given child.
`long`	`getLastDeltaLsn()` Returns the last delta version LSN, or NULL_LSN if a delta was not last logged.
`long`	`getLastFullLsn()` Returns the last full version LSN, or NULL_LSN if never logged.
`long`	`getLastLoggedLsn()` Returns the LSN of the last last logged version of this IN, or NULL_LSN if never logged.
`int`	`getLastLoggedSize(int idx)` The last logged size is not stored for UINs.
`String`	`getLatchName()` Returns the latch name for debugging.
`int`	`getLatchNWaiters()`
`LatchTable`	`getLatchTable()` Returns LatchTable for debug/test tracking.
`int`	`getLatchTimeoutMs()` Returns EnvironmentParams.ENV_LATCH_TIMEOUT
`int`	`getLevel()` Cover for LN's and just return 0 since they'll always be at the bottom of the tree.
`LN`	`getLN(int idx, CacheMode cacheMode)` Return the idx'th LN target, enforcing rules defined by the cache modes for the LN.
`int`	`getLogSize()`
`int`	`getLogSize(boolean deltasOnly)`
`LogEntryType`	`getLogType()` Get the log type of this node.
`long`	`getLsn(int idx)` Return the idx'th LSN for this entry.
`int`	`getMaxEntries()`
`int`	`getNDeltas()`
`int`	`getNEntries()`
`IN`	`getNextLRUNode()`
`long`	`getNodeId()`
`int`	`getNormalizedLevel()`
`int`	`getNumEmbeddedLNs()`
`int`	`getOffHeapBINId(int idx)`
`long`	`getOffHeapBINIdsMemorySize()`
`IN`	`getParent()` This method should be used carefully.
`IN`	`getPrevLRUNode()`
`boolean`	`getProhibitNextDelta()`
`boolean`	`getRecalcToggle()`
`byte`	`getState(int idx)`
`Node`	`getTarget(int idx)` Return the idx'th target.
`INTargetRep`	`getTargets()`
`boolean`	`hasCachedChildren()` Returns whether any child is non-null in the main or off-heap cache.
`boolean`	`hasCachedChildrenFlag()`
`int`	`hashCode()` We would like as even a hash distribution as possible so that the Evictor's LRU is as accurate as possible.
`boolean`	`hasKeyPrefix()`
`boolean`	`hasOffHeapBINIds()`
`boolean`	`haveEmbeddedData(int idx)`
`protected void`	`init(DatabaseImpl db, byte[] identifierKey, int initialCapacity, int level)` Initialize IN object.
`boolean`	`insertEntry(Node child, byte[] key, long childLsn)` Inserts a slot with the given key, lsn and child node into this IN, if a slot with the same key does not exist already.
`int`	`insertEntry1(Node child, byte[] key, byte[] data, long childLsn, boolean blindInsertion)` Inserts a slot with the given key, lsn and child node into this IN, if a slot with the same key does not exist already.
`int`	`insertEntry1(Node child, byte[] key, byte[] data, long childLsn, byte state, boolean blindInsertion)` Inserts a slot with the given key, lsn, state, and child node into this IN, if a slot with the same key does not exist already.
`void`	`insertRecord(int idx, LN newLN, long newLSN, int newSize, byte[] newKey, byte[] newData, int expiration, boolean expirationInHours)` Update the idx slot of this BIN to reflect a record insertion in an existing KD slot.
`boolean`	`isBINDelta()`
`boolean`	`isBINDelta(boolean checkLatched)`
`boolean`	`isDirty(int idx)`
`static boolean`	`isEmbeddedLN(byte state)`
`boolean`	`isEmbeddedLN(int idx)` Return true if the LN at the given slot is embedded.
`boolean`	`isEntryKnownDeleted(int idx)`
`boolean`	`isEntryPendingDeleted(int idx)`
`boolean`	`isExpirationInHours()`
`boolean`	`isIN()`
`boolean`	`isInPri2LRU()`
`boolean`	`isKeyInBounds(byte[] key)` Returns whether the given key is greater than or equal to the first key in the IN and less than or equal to the last key in the IN.
`boolean`	`isLatchExclusiveOwner()`
`boolean`	`isLatchOwner()`
`static boolean`	`isNoDataLN(byte state)`
`boolean`	`isNoDataLN(int idx)` Return true if the LN at the given slot is an embedded LN with no data.
`boolean`	`isOffHeapBINDirty(int idx)`
`boolean`	`isOffHeapBINPri2(int idx)`
`boolean`	`isPinned()`
`boolean`	`isRoot()`
`boolean`	`isUpperIN()`
`void`	`latch()` Latch this node exclusive and update the LRU using the default cacheMode.
`void`	`latch(CacheMode cacheMode)` Latch this node exclusive and update the LRU using the given cacheMode.
`void`	`latchNoUpdateLRU()` Latch this node exclusive and do not update the LRU or cause other related side effects.
`void`	`latchNoUpdateLRU(DatabaseImpl db)` Latch this node exclusive and do not update the LRU or cause other related side effects.
`boolean`	`latchNoWait(CacheMode cacheMode)` Latch this node if it is not latched by another thread.
`IN`	`latchParent()` Latches the parent exclusively, leaving this node latched.
`void`	`latchShared()` Latch this node shared and update the LRU using the default cacheMode.
`void`	`latchShared(CacheMode cacheMode)` Latch this node shared and update the LRU using the given cacheMode.
`IN`	`loadIN(int idx, CacheMode cacheMode)` Returns the idx-th child of "this" upper IN, loading the child from off-heap and attaching it to its parent if it is not already attached and is cached off-heap.
`long`	`log()`
`long`	`log(boolean allowDeltas, boolean isProvisional, boolean backgroundIO, IN parent)`
`long`	`log(boolean allowDeltas, Provisional provisional, boolean backgroundIO, IN parent)`
`void`	`logDirtyChildren()` When splits and checkpoints intermingle in a deferred write databases, a checkpoint target may appear which has a valid target but a null LSN.
`static long`	`logEntry(INLogEntry<BIN> logEntry, Provisional provisional, boolean backgroundIO, IN parent)`
`boolean`	`logicalEquals(Loggable other)`
`String`	`makeFetchErrorMsg(String msg, long lsn, int idx)`
`void`	`materialize(ByteBuffer itemBuffer, int entryVersion, boolean deltasOnly, boolean clearDirtyBits)` WARNING: In the case of BINs this method is used not only for logging but also for off-heap caching.
`boolean`	`mayHaveExpirationValues(ByteBuffer itemBuffer, int entryVersion)` Returns whether the given serialized IN is a BIN that may have expiration values.
`void`	`mutateToFullBIN(boolean leaveFreeSlot)`
`boolean`	`needsSplitting()` Return true if this node needs splitting.
`long`	`partialEviction()` Try to compact or otherwise reclaim memory in this IN and return the number of bytes reclaimed.
`void`	`pin()`
`void`	`postFetchInit(DatabaseImpl db, long fetchedLsn)` Initialize a node that has been read in from the log.
`void`	`postRecoveryInit(DatabaseImpl db, long lastLoggedLsn)` Initialize a node read in during recovery.
`void`	`prepareForSlotReuse(int idx)` Called prior to changing a slot to contain a different logical node.
`protected long`	`printMemorySize()`
`void`	`readFromLog(ByteBuffer itemBuffer, int entryVersion)` Initialize this object from the data in itemBuf.
`void`	`readFromLog(ByteBuffer itemBuffer, int entryVersion, boolean deltasOnly)`
`void`	`recalcKeyPrefix()` Forces computation of the key prefix, without requiring a split.
`void`	`recoverIN(int idx, Node node, long lsn, int lastLoggedSize)` Update the cached-child and LSN properties of the idx-th slot.
`void`	`recoverRecord(int idx, long lsn, boolean knownDeleted, boolean pendingDeleted, byte[] key, byte[] data, long vlsn, int logrecSize, int expiration, boolean expirationInHours)` This method is used by the RecoveryManager to change the current version of a record, either to a later version (in case of redo), or to an earlier version (in case of undo).
`void`	`releaseLatch()` Release the latch on this node.
`void`	`releaseLatchIfOwner()` Release the latch on this node if it is owned.
`long`	`resetAndGetMemorySize()` Called as part of a memory budget reset (during a checkpoint) to clear the accumulated delta and return the total memory size.
`void`	`serialize(ByteBuffer logBuffer, boolean deltasOnly, boolean clearDirtyBits)` WARNING: In the case of BINs this method is not only used for logging but also for off-heap caching.
`void`	`setDatabase(DatabaseImpl db)` Set the database reference for this node.
`void`	`setDirty(boolean dirty)`
`void`	`setFetchedCold(boolean val)`
`void`	`setFetchedColdOffHeap(boolean val)`
`void`	`setFetchINHook(TestHook hook)`
`void`	`setIdentifierKey(byte[] key, boolean makeDirty)` Set the identifier key for this node.
`void`	`setInListResident(boolean resident)` Called when adding/removing this IN to/from the INList.
`void`	`setInPri2LRU(boolean value)`
`boolean`	`setKey(int idx, byte[] key, byte[] data, boolean isInsertion)` This method inserts or updates a key at a given slot.
`void`	`setKnownDeleted(int idx)` Set KD flag to true and clear the PD flag (PD does not need to be on if KD is on).
`void`	`setKnownDeletedAndEvictLN(int index)` Set knownDeleted flag to true and evict the child LN if cached.
`void`	`setLastFullLsn(long lsn)` Sets the last full version LSN.
`void`	`setLastLoggedLsn(long lsn)` Sets the last logged LSN, which for a BIN may be a delta.
`void`	`setLastLoggedSize(int idx, int lastLoggedSize)` The last logged size is not stored for UINs.
`void`	`setLsn(int idx, long lsn)` Set the LSN of the idx'th slot, mark the slot dirty, and update memory consuption.
`void`	`setNextLRUNode(IN node)`
`void`	`setOffHeapBINId(int idx, int val, boolean pri2, boolean dirty)`
`void`	`setParent(IN in)`
`void`	`setPendingDeleted(int idx)` Set pendingDeleted to true.
`void`	`setPrevLRUNode(IN node)`
`void`	`setProhibitNextDelta(boolean val)` Disallow delta on next log.
`void`	`setRecalcToggle(boolean toggle)`
`String`	`shortClassName()`
`IN`	`split(IN parent, int childIndex, IN grandParent, int maxEntries)` Split this into two nodes.
`String`	`toSafeString(int... slotIndexes)` Converts to an identifying string that is safe to output in a log.
`String`	`toString()` Default toString method at the root of the tree.
`void`	`unpin()`
`void`	`updateEntry(int idx, long newLSN, long newVLSN, int newSize)` This method is called after the idx'th child of this node gets logged, and changes position as a result.
`void`	`updateLRU(CacheMode cacheMode)`
`void`	`updateMemoryBudget()` Move the accumulated delta to the memory budget.
`protected void`	`updateMemorySize(long oldSize, long newSize)`
`void`	`updateRecord(int idx, long oldMemSize, long newLSN, long newVLSN, int newSize, byte[] newKey, byte[] newData, int expiration, boolean expirationInHours)` Update the idx slot of this BIN to reflect an update of the associated record.
`protected void`	`updateRepCacheStats(boolean increment)` Adds (increments) or removes (decrements) the cache stats for the key and target representations.
`boolean`	`verifyMemorySize()`
`void`	`writeToLog(ByteBuffer logBuffer)` Serialize this object into the buffer.
`void`	`writeToLog(ByteBuffer logBuffer, boolean deltasOnly)`

Methods inherited from class com.sleepycat.je.tree.Node
containsDuplicates, dump, getMemorySizeIncludedByParent, getTransactionId, getType, isBIN, isDBIN, isDIN, isLN

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - MAX_FILE_OFFSET
```
public static final int MAX_FILE_OFFSET
```
    See Also:
    
    Constant Field Values
  - DBMAP_LEVEL
```
public static final int DBMAP_LEVEL
```
    See Also:
    
    Constant Field Values
  - MAIN_LEVEL
```
public static final int MAIN_LEVEL
```
    See Also:
    
    Constant Field Values
  - LEVEL_MASK
```
public static final int LEVEL_MASK
```
    See Also:
    
    Constant Field Values
  - MIN_LEVEL
```
public static final int MIN_LEVEL
```
    See Also:
    
    Constant Field Values
  - BIN_LEVEL
```
public static final int BIN_LEVEL
```
    See Also:
    
    Constant Field Values
  - EXACT_MATCH
```
public static final int EXACT_MATCH
```
    See Also:
    
    Constant Field Values
  - INSERT_SUCCESS
```
public static final int INSERT_SUCCESS
```
    See Also:
    
    Constant Field Values
  - NON_EVICTABLE_IN
```
public static final long NON_EVICTABLE_IN
```
    See Also:
    
    Constant Field Values
  - disableCompactLsns
```
public static boolean disableCompactLsns
```
  - ACCUMULATED_LIMIT_DEFAULT
```
public static final int ACCUMULATED_LIMIT_DEFAULT
```
    See Also:
    
    Constant Field Values
  - ACCUMULATED_LIMIT
```
public static int ACCUMULATED_LIMIT
```
- Constructor Detail
  - IN
```
public IN()
```
    Create an empty IN, with no node ID, to be filled in from the log.
  - IN
```
public IN(DatabaseImpl dbImpl,
          byte[] identifierKey,
          int capacity,
          int level)
```
    Create a new IN.
  - IN
```
public IN(SizeofMarker marker)
```
    For Sizeof.
- Method Detail
  - init
```
protected void init(DatabaseImpl db,
                    byte[] identifierKey,
                    int initialCapacity,
                    int level)
```
    Initialize IN object.
  - isIN
```
public final boolean isIN()
```
    Overrides:
    
    isIN in class Node
  - isUpperIN
```
public final boolean isUpperIN()
```
    Overrides:
    
    isUpperIN in class Node
  - getLatchName
```
public final String getLatchName()
```
    Description copied from interface: LatchContext
    
    Returns the latch name for debugging.
    
    Specified by:
    
    getLatchName in interface LatchContext
  - getLatchTimeoutMs
```
public final int getLatchTimeoutMs()
```
    Description copied from interface: LatchContext
    
    Returns EnvironmentParams.ENV_LATCH_TIMEOUT
    
    Specified by:
    
    getLatchTimeoutMs in interface LatchContext
  - getLatchTable
```
public final LatchTable getLatchTable()
```
    Description copied from interface: LatchContext
    
    Returns LatchTable for debug/test tracking.
    
    Specified by:
    
    getLatchTable in interface LatchContext
  - latchNoWait
```
public final boolean latchNoWait(CacheMode cacheMode)
```
    Latch this node if it is not latched by another thread. Update the LRU using the given cacheMode if the latch succeeds.
  - latch
```
public void latch(CacheMode cacheMode)
```
    Latch this node exclusive and update the LRU using the given cacheMode.
  - latch
```
public final void latch()
```
    Latch this node exclusive and update the LRU using the default cacheMode.
    
    Overrides:
    
    latch in class Node
  - latchShared
```
public void latchShared(CacheMode cacheMode)
```
    Latch this node shared and update the LRU using the given cacheMode.
    
    Overrides:
    
    latchShared in class Node
  - latchShared
```
public final void latchShared()
```
    Latch this node shared and update the LRU using the default cacheMode.
    
    Overrides:
    
    latchShared in class Node
  - latchNoUpdateLRU
```
public final void latchNoUpdateLRU(DatabaseImpl db)
```
    Latch this node exclusive and do not update the LRU or cause other related side effects.
    
    Parameters:
    
    db - is passed in order to initialize the database for an uninitialized node, which is necessary in order to latch it.
  - latchNoUpdateLRU
```
public final void latchNoUpdateLRU()
```
    Latch this node exclusive and do not update the LRU or cause other related side effects.
  - releaseLatch
```
public final void releaseLatch()
```
    Release the latch on this node.
    
    Overrides:
    
    releaseLatch in class Node
  - releaseLatchIfOwner
```
public final void releaseLatchIfOwner()
```
    Release the latch on this node if it is owned.
  - isLatchOwner
```
public final boolean isLatchOwner()
```
    Returns:
    
    true if this thread holds the IN's latch
  - isLatchExclusiveOwner
```
public final boolean isLatchExclusiveOwner()
```
  - getLatchNWaiters
```
public final int getLatchNWaiters()
```
  - updateLRU
```
public final void updateLRU(CacheMode cacheMode)
```
  - getParent
```
public IN getParent()
```
    This method should be used carefully. Unless this node and the parent are already known to be latched, call latchParent instead to access the parent safely.
  - setParent
```
public void setParent(IN in)
```
  - latchParent
```
public final IN latchParent()
```
    Latches the parent exclusively, leaving this node latched. The parent must not already be latched. This node must be latched on entry and will be latched on exit. This node's latch may be released temporarily, in which case it will be ex-latched (since the parent is ex-latched, this isn't a drawback). Does not perform cache mode processing, since this node is already latched.
    
    Returns:
    
    the ex-latched parent, for which calling getKnownChildIndex with this node is guaranteed to succeed.
    
    Throws:
    
    EnvironmentFailureException - (fatal) if the parent latch is already held.
  - getKnownChildIndex
```
public int getKnownChildIndex(Node child)
```
    Returns the index of the given child. Should only be called when the caller knows that the given child is resident.
  - pin
```
public final void pin()
```
  - unpin
```
public final void unpin()
```
  - isPinned
```
public final boolean isPinned()
```
  - getDatabase
```
public final DatabaseImpl getDatabase()
```
    Get the database for this IN.
  - setDatabase
```
public final void setDatabase(DatabaseImpl db)
```
    Set the database reference for this node.
  - getDatabaseId
```
public final DatabaseId getDatabaseId()
```
  - getEnvImplForFatalException
```
public final EnvironmentImpl getEnvImplForFatalException()
```
    Description copied from interface: LatchContext
    
    Returns envImpl, or may throw another exception in unit tests.
    
    Specified by:
    
    getEnvImplForFatalException in interface LatchContext
  - getEnv
```
public final EnvironmentImpl getEnv()
```
  - getKeyComparator
```
public final Comparator<byte[]> getKeyComparator()
```
    Convenience method to return the database key comparator.
  - getLevel
```
public final int getLevel()
```
    Description copied from class: Node
    
    Cover for LN's and just return 0 since they'll always be at the bottom of the tree.
    
    Overrides:
    
    getLevel in class Node
  - getNormalizedLevel
```
public final int getNormalizedLevel()
```
  - getNodeId
```
public final long getNodeId()
```
  - hashCode
```
public final int hashCode()
```
    We would like as even a hash distribution as possible so that the Evictor's LRU is as accurate as possible. ConcurrentHashMap takes the value returned by this method and runs its own hash algorithm on it. So a bit complement of the node ID is sufficient as the return value and is a little better than returning just the node ID. If we use a different container in the future that does not re-hash the return value, we should probably implement the Wang-Jenkins hash function here.
    
    Overrides:
    
    hashCode in class Object
  - equals
```
public final boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - compareTo
```
public final int compareTo(IN argIN)
```
    Sort based on equality key.
    
    Specified by:
    
    compareTo in interface Comparable<IN>
  - getDirty
```
public final boolean getDirty()
```
  - setDirty
```
public final void setDirty(boolean dirty)
```
  - isBINDelta
```
public final boolean isBINDelta()
```
    Overrides:
    
    isBINDelta in class Node
  - isBINDelta
```
public final boolean isBINDelta(boolean checkLatched)
```
    Overrides:
    
    isBINDelta in class Node
  - getFetchedCold
```
public final boolean getFetchedCold()
```
    Indicates that the BIN was fetched from disk, or loaded from the off-heap cache, using CacheMode.UNCHANGED, and has not been accessed with another CacheMode. BINs in this state should be evicted from main cache as soon as they are no longer referenced by a cursor. If they were loaded from off-heap cache, they should be stored off-heap when they are evicted from main. The FetchedColdOffHeap flag indicates whether the BIN was loaded from off-heap cache.
  - setFetchedCold
```
public final void setFetchedCold(boolean val)
```
    See Also:
    
    getFetchedCold()
  - getFetchedColdOffHeap
```
public final boolean getFetchedColdOffHeap()
```
    See Also:
    
    getFetchedCold()
  - setFetchedColdOffHeap
```
public final void setFetchedColdOffHeap(boolean val)
```
    See Also:
    
    getFetchedCold()
  - getRecalcToggle
```
public final boolean getRecalcToggle()
```
  - setRecalcToggle
```
public final void setRecalcToggle(boolean toggle)
```
  - isRoot
```
public final boolean isRoot()
```
  - hasCachedChildrenFlag
```
public final boolean hasCachedChildrenFlag()
```
  - isInPri2LRU
```
public final boolean isInPri2LRU()
```
  - setInPri2LRU
```
public final void setInPri2LRU(boolean value)
```
  - isExpirationInHours
```
public boolean isExpirationInHours()
```
  - getIdentifierKey
```
public final byte[] getIdentifierKey()
```
    Returns:
    
    the identifier key for this node.
  - setIdentifierKey
```
public final void setIdentifierKey(byte[] key,
                                   boolean makeDirty)
```
    Set the identifier key for this node.
    
    Parameters:
    
    key - - the new identifier key for this node.
    
    makeDirty - should normally be true, but may be false when an expired slot containing the identifier key has been deleted.
  - getNEntries
```
public final int getNEntries()
```
    Returns:
    
    the number of entries in this node.
  - getMaxEntries
```
public int getMaxEntries()
```
    Returns:
    
    the maximum number of entries in this node. Overriden by TestIN in INEntryTestBase.java
  - getState
```
public final byte getState(int idx)
```
  - isDirty
```
public final boolean isDirty(int idx)
```
    Returns:
    
    true if the object is dirty.
  - isEntryPendingDeleted
```
public final boolean isEntryPendingDeleted(int idx)
```
    Returns:
    
    true if the idx'th entry has been deleted, although the transaction that performed the deletion may not be committed.
  - setPendingDeleted
```
public final void setPendingDeleted(int idx)
```
    Set pendingDeleted to true.
  - isEntryKnownDeleted
```
public final boolean isEntryKnownDeleted(int idx)
```
    Returns:
    
    true if the idx'th entry is deleted for sure. If a transaction performed the deletion, it has been committed.
  - setKnownDeleted
```
public final void setKnownDeleted(int idx)
```
    Set KD flag to true and clear the PD flag (PD does not need to be on if KD is on).
  - setKnownDeletedAndEvictLN
```
public final void setKnownDeletedAndEvictLN(int index)
```
    Set knownDeleted flag to true and evict the child LN if cached. The child LN is evicted to save memory, since it will never be fetched again.
  - isEmbeddedLN
```
public final boolean isEmbeddedLN(int idx)
```
    Return true if the LN at the given slot is embedded.
  - isEmbeddedLN
```
public static boolean isEmbeddedLN(byte state)
```
  - isNoDataLN
```
public final boolean isNoDataLN(int idx)
```
    Return true if the LN at the given slot is an embedded LN with no data.
  - isNoDataLN
```
public static boolean isNoDataLN(byte state)
```
  - haveEmbeddedData
```
public final boolean haveEmbeddedData(int idx)
```
  - getNumEmbeddedLNs
```
public final int getNumEmbeddedLNs()
```
  - getKeyVals
```
public final INKeyRep getKeyVals()
```
  - getKeyPrefix
```
public final byte[] getKeyPrefix()
```
  - hasKeyPrefix
```
public final boolean hasKeyPrefix()
```
  - getKey
```
public final byte[] getKey(int idx)
```
    Return the idx'th key. If prefixing is enabled, construct a new byte[] containing the prefix and suffix. If prefixing is not enabled, just return the current byte[] in entryKeys.
  - getData
```
public final byte[] getData(int idx)
```
  - setKey
```
public boolean setKey(int idx,
                      byte[] key,
                      byte[] data,
                      boolean isInsertion)
```
    This method inserts or updates a key at a given slot. In either case, the associated embedded data (if any) is inserted or updated as well, and the key prefix is adjusted, if necessary. In case of insertion (indicated by a true value for the isInsertion param), it is assumed that the idx slot does not store any valid info, so any change to the key prefix (if any) is due to the insertion of this new new key and not to the removal of the current key at the idx slot. In case of update, the method does not check if the current key is indeed different from the new key; it just updates the key unconditionally. If the slot has embedded data, that data will also be updated (if the data param is not null), or be removed (if the data param is null). If the slot does not have embedded data and the data param is not null, the given data will be embedded. Note: For BINs, the maintenance of the EMBEDDED_LN_BIT andNO_DATA_LN_BIT is done by the callers of this method.
    
    Parameters:
    
    data - If the data portion of a record must be embedded in this BIN, "data" stores the record's data. Null otherwise. See also comment for the keyEntries field.
    
    Returns:
    
    true if a multi-slot change was made and the complete IN memory size must be updated.
  - recalcKeyPrefix
```
public final void recalcKeyPrefix()
```
    Forces computation of the key prefix, without requiring a split. Is public for use by DbCacheSize.
  - isKeyInBounds
```
public final boolean isKeyInBounds(byte[] key)
```
    Returns whether the given key is greater than or equal to the first key in the IN and less than or equal to the last key in the IN. This method is used to determine whether a key to be inserted belongs in this IN, without doing a tree search. If false is returned it is still possible that the key belongs in this IN, but a tree search must be performed to find out.
  - getLsn
```
public final long getLsn(int idx)
```
    Return the idx'th LSN for this entry.
    
    Returns:
    
    the idx'th LSN for this entry.
  - setLsn
```
public void setLsn(int idx,
                   long lsn)
```
    Set the LSN of the idx'th slot, mark the slot dirty, and update memory consuption. Throw exception if the update is not legitimate.
  - setLastLoggedSize
```
public void setLastLoggedSize(int idx,
                              int lastLoggedSize)
```
    The last logged size is not stored for UINs.
  - clearLastLoggedSize
```
public void clearLastLoggedSize(int idx)
```
    The last logged size is not stored for UINs.
  - getLastLoggedSize
```
public int getLastLoggedSize(int idx)
```
    The last logged size is not stored for UINs.
  - setOffHeapBINId
```
public void setOffHeapBINId(int idx,
                            int val,
                            boolean pri2,
                            boolean dirty)
```
  - clearOffHeapBINId
```
public void clearOffHeapBINId(int idx)
```
  - getOffHeapBINId
```
public int getOffHeapBINId(int idx)
```
  - hasOffHeapBINIds
```
public boolean hasOffHeapBINIds()
```
  - getOffHeapBINIdsMemorySize
```
public long getOffHeapBINIdsMemorySize()
```
  - isOffHeapBINDirty
```
public boolean isOffHeapBINDirty(int idx)
```
  - isOffHeapBINPri2
```
public boolean isOffHeapBINPri2(int idx)
```
  - getTargets
```
public final INTargetRep getTargets()
```
  - getTarget
```
public final Node getTarget(int idx)
```
    Return the idx'th target. This method does not load children from off-heap cache, so it always returns null when then child is not in main cache. Note that when children are INs (this is not a BIN), when this method returns null it is does not imply that the child is non-dirty, because dirty BINs are stored off-heap. To fetch the current version from off-heap cache in that case, call loadIN instead.
  - fetchIN
```
public IN fetchIN(int idx,
                  CacheMode cacheMode)
```
    Returns the idx-th child of "this" upper IN, fetching the child from the log and attaching it to its parent if it is not already attached. On entry, the parent must be EX-latched already and it stays EX-latched for the duration of this method and on return (even in case of exceptions).
    
    Parameters:
    
    idx - The slot of the child to fetch.
  - loadIN
```
public IN loadIN(int idx,
                 CacheMode cacheMode)
```
    Returns the idx-th child of "this" upper IN, loading the child from off-heap and attaching it to its parent if it is not already attached and is cached off-heap. This method does not fetch from disk, and will return null if the child is not in the main or off-heap cache. On entry, the parent must be EX-latched already and it stays EX-latched for the duration of this method and on return (even in case of exceptions).
    
    Parameters:
    
    idx - The slot of the child to fetch.
    
    Returns:
    
    null if the LN is not in the main or off-heap cache.
  - fetchLN
```
public final LN fetchLN(int idx,
                        CacheMode cacheMode)
```
    Returns the target of the idx'th entry, fetching from disk if necessary. Null is returned in the following cases: 1. if the LSN is null and the KnownDeleted flag is set; or 2. if the LSN's file has been cleaned and: a. the PendingDeleted or KnownDeleted flag is set, or b. the entry is "probably expired". Note that checking for PD/KD before calling this method is not sufficient to ensure that null is not returned, because null is also returned for expired records. When null is returned, the caller must treat the record as deleted. Note that null can only be returned for a slot that could contain an LN, not other node types and not a DupCountLN since DupCountLNs are never deleted or expired. An exclusive latch must be held on this BIN.
    
    Returns:
    
    the LN or null.
  - fetchLNOrDIN
```
public final Node fetchLNOrDIN(int idx,
                               CacheMode cacheMode)
```
  - getLN
```
public final LN getLN(int idx,
                      CacheMode cacheMode)
```
    Return the idx'th LN target, enforcing rules defined by the cache modes for the LN. This method should be called instead of getTarget when a cache mode applies to user operations such as reads and updates.
  - postFetchInit
```
public final void postFetchInit(DatabaseImpl db,
                                long fetchedLsn)
```
    Initialize a node that has been read in from the log.
    
    Overrides:
    
    postFetchInit in class Node
  - postRecoveryInit
```
public final void postRecoveryInit(DatabaseImpl db,
                                   long lastLoggedLsn)
```
    Initialize a node read in during recovery.
  - makeFetchErrorMsg
```
public String makeFetchErrorMsg(String msg,
                                long lsn,
                                int idx)
```
  - findEntry
```
public final int findEntry(byte[] key,
                           boolean indicateIfDuplicate,
                           boolean exact)
```
  - findEntry
```
public final int findEntry(byte[] key,
                           boolean indicateIfDuplicate,
                           boolean exact,
                           Comparator<byte[]> comparator)
```
    Find the entry in this IN for which key is LTE the key arg. Currently uses a binary search, but eventually, this may use binary or linear search depending on key size, number of entries, etc. This method guarantees that the key parameter, which is the user's key parameter in user-initiated search operations, is always the left hand parameter to the Comparator.compare method. This allows a comparator to perform specialized searches, when passed down from upper layers. This is public so that DbCursorTest can access it. Note that the 0'th entry's key is treated specially in an IN. It always compares lower than any other key.
    
    Parameters:
    
    key - - the key to search for.
    
    indicateIfDuplicate - - true if EXACT_MATCH should be or'd onto the return value if key is already present in this node.
    
    exact - - true if an exact match must be found.
    
    Returns:
    
    offset for the entry that has a key LTE the arg. 0 if key is less than the 1st entry. -1 if exact is true and no exact match is found. If indicateIfDuplicate is true and an exact match was found then EXACT_MATCH is or'd onto the return value.
  - insertEntry
```
public final boolean insertEntry(Node child,
                                 byte[] key,
                                 long childLsn)
                          throws DatabaseException
```
    Inserts a slot with the given key, lsn and child node into this IN, if a slot with the same key does not exist already. The state of the new slot is set to DIRTY. Assumes this node is already latched by the caller.
    
    Returns:
    
    true if the entry was successfully inserted, false if it was a duplicate.
    
    Throws:
    
    EnvironmentFailureException - if the node is full (it should have been split earlier).
    
    DatabaseException
  - insertEntry1
```
public final int insertEntry1(Node child,
                              byte[] key,
                              byte[] data,
                              long childLsn,
                              boolean blindInsertion)
```
    Inserts a slot with the given key, lsn and child node into this IN, if a slot with the same key does not exist already. The state of the new slot is set to DIRTY. Assumes this node is already latched by the caller.
    
    Parameters:
    
    data - If the data portion of a record must be embedded in this BIN, "data" stores the record's data. Null otherwise. See also comment for the keyEntries field.
    
    Returns:
    
    either (1) the index of location in the IN where the entry was inserted |'d with INSERT_SUCCESS, or (2) the index of the duplicate in the IN if the entry was found to be a duplicate.
    
    Throws:
    
    EnvironmentFailureException - if the node is full (it should have been split earlier).
  - insertEntry1
```
public final int insertEntry1(Node child,
                              byte[] key,
                              byte[] data,
                              long childLsn,
                              byte state,
                              boolean blindInsertion)
```
    Inserts a slot with the given key, lsn, state, and child node into this IN, if a slot with the same key does not exist already. Assumes this node is already latched by the caller. This returns a failure if there's a duplicate match. The caller must do the processing to check if the entry is actually deleted and can be overwritten. This is foisted upon the caller rather than handled in this object because there may be some latch releasing/retaking in order to check a child LN.
    
    Parameters:
    
    data - If the data portion of a record must be embedded in this BIN, "data" stores the record's data. Null otherwise. See also comment for the keyEntries field.
    
    Returns:
    
    either (1) the index of location in the IN where the entry was inserted |'d with INSERT_SUCCESS, or (2) the index of the duplicate in the IN if the entry was found to be a duplicate.
    
    Throws:
    
    EnvironmentFailureException - if the node is full (it should have been split earlier).
  - deleteEntry
```
public void deleteEntry(int index)
```
    Removes the slot at index from this IN. Assumes this node is already latched by the caller.
    
    Parameters:
    
    index - The index of the entry to delete from the IN.
  - updateEntry
```
public final void updateEntry(int idx,
                              long newLSN,
                              long newVLSN,
                              int newSize)
```
    This method is called after the idx'th child of this node gets logged, and changes position as a result.
    
    Parameters:
    
    newLSN - The new on-disk position of the child.
    
    newVLSN - The VLSN of the logrec at the new position. For LN children only.
    
    newSize - The size of the logrec at the new position. For LN children only.
  - insertRecord
```
public final void insertRecord(int idx,
                               LN newLN,
                               long newLSN,
                               int newSize,
                               byte[] newKey,
                               byte[] newData,
                               int expiration,
                               boolean expirationInHours)
```
    Update the idx slot of this BIN to reflect a record insertion in an existing KD slot. It is called from CursorImpl.insertRecordInternal(), after logging the insertion op.
    
    Parameters:
    
    newLN - The LN associated with the new record.
    
    newLSN - The LSN of the insertion logrec.
    
    newSize - The size of the insertion logrec.
    
    newKey - The value for the record's key. It is equal to the current key value in the slot, but may not be identical to that value if a custom comparator is used.
    
    newData - If the record's data must be embedded in this BIN, "data" stores the record's data. Null otherwise. See also comment for the keyEntries field.
  - updateRecord
```
public final void updateRecord(int idx,
                               long oldMemSize,
                               long newLSN,
                               long newVLSN,
                               int newSize,
                               byte[] newKey,
                               byte[] newData,
                               int expiration,
                               boolean expirationInHours)
```
    Update the idx slot of this BIN to reflect an update of the associated record. It is called from CursorImpl.updateRecordInternal(), after logging the update op.
    
    Parameters:
    
    oldMemSize - If the child LN was cached before the update op, it has already been updated in-place by the caller. In this case, oldMemSize stores the size of the child LN before the update, and it is used to do memory counting. Otherwise oldMemSize is 0 and the newly created LN has not been attached to the tree; it will be attached later by the caller, if needed.
    
    newLSN - The LSN of the update logrec.
    
    newVLSN - The VLSN of the update logrec.
    
    newSize - The on-disk size of the update logrec.
    
    newKey - The new value for the record's key. It is equal to the current value, but may not be identical to the current value if a custom comparator is used. It may be null, if the caller knows for sure that the key does not change.
    
    newData - If the record's data must be embedded in this BIN, "data" stores the record's data. Null otherwise. See also comment for the keyEntries field.
  - deleteRecord
```
public final void deleteRecord(int idx,
                               long oldMemSize,
                               long newLSN,
                               long newVLSN,
                               int newSize)
```
    Update the idx slot slot of this BIN to reflect a deletion of the associated record. It is called from CursorImpl.deleteCurrentRecord(), after logging the deletion op.
    
    Parameters:
    
    oldMemSize - If the child LN was cached before the deletion, it has already been updated in-place by the caller (the ln contents have been deleted). In this case, oldMemSize stores the in-memory size of the child LN before the update, and it is used to do memory counting. Otherwise oldMemSize is 0 and the newly created LN has not been attached to the tree; it will be attached later by the caller, if needed.
    
    newLSN - The LSN of the deletion logrec.
    
    newVLSN - The VLSN of the deletion logrec.
    
    newSize - The on-disk size of the deletion logrec.
  - recoverRecord
```
public final void recoverRecord(int idx,
                                long lsn,
                                boolean knownDeleted,
                                boolean pendingDeleted,
                                byte[] key,
                                byte[] data,
                                long vlsn,
                                int logrecSize,
                                int expiration,
                                boolean expirationInHours)
```
    This method is used by the RecoveryManager to change the current version of a record, either to a later version (in case of redo), or to an earlier version (in case of undo). The current version may or may not be cached as a child LN of this BIN (it may be only in case of txn abort during normal processing). If it is, it is evicted. The new version is not attached to the in-memory tree, to save memory during crash recovery.
    
    Parameters:
    
    idx - The BIN slot for the record.
    
    lsn - The LSN of the new record version. It may be null in case of undo, if the logrec that is being undone is an insertion and the record did not exist at all in the DB before that insertion.
    
    knownDeleted - True if the new version is a committed deletion.
    
    pendingDeleted - True if the new version is a deletion, which may or may not be committed.
    
    key - The key of the new version. It is null only if we are undoing and the revert-to version was not embedded (in this case the key of the revert-to version is not stored in the logrec). If it is null and the DB allows key updates, the new record version is fetched from disk to retrieve its key, so that the key values stored in the BIN slots are always transactionally correct.
    
    data - The data of the new version. It is non-null if and only if the new version must be embedded in the BIN.
    
    vlsn - The VLSN of the new version.
    
    logrecSize - The on-disk size of the logrec corresponding to the new version. It may be 0 (i.e. unknown) in case of undo.
  - recoverIN
```
public final void recoverIN(int idx,
                            Node node,
                            long lsn,
                            int lastLoggedSize)
```
    Update the cached-child and LSN properties of the idx-th slot. This method is used by the RecoveryManager.recoverChildIN() to change the version of a child IN, a later version The child IN may or may not be already attached to the tree.
  - attachNode
```
public final void attachNode(int idx,
                             Node node,
                             byte[] newKey)
```
    Attach the given node as the idx-th child of "this" node. If the child node is an LN, update the key of the parent slot to the given key value, if that value is non-null and an update is indeed necessary. This method is called after the child node has been either (a) fetched in from disk and is not dirty, or (b) is a newly created instance that will be written out later by something like a checkpoint. In either case, the slot LSN does not need to be updated. Note: does not dirty the node unless the LN slot key is changed.
  - detachNode
```
public final void detachNode(int idx,
                             boolean updateLsn,
                             long newLsn)
```
  - convertKey
```
public final void convertKey(int idx,
                             byte[] newKey)
```
    This method is used in DupConvert, where it is called to convert the keys of an upper IN that has just been fetched from the log and is not attached to in-memory tree yet.
  - needsSplitting
```
public final boolean needsSplitting()
```
    Return true if this node needs splitting. For the moment, needing to be split is defined by there being no free entries available.
  - split
```
public final IN split(IN parent,
                      int childIndex,
                      IN grandParent,
                      int maxEntries)
```
    Split this into two nodes. Parent IN is passed in parent and should be latched by the caller. childIndex is the index in parent of where "this" can be found.
  - prepareForSlotReuse
```
public void prepareForSlotReuse(int idx)
```
    Called prior to changing a slot to contain a different logical node. Necessary to support assertions for transient LSNs in shouldUpdateLsn. Examples: LN slot reuse, and splits where a new node is placed in an existing slot. Also needed to free the off-heap BIN associated with the old node. TODO: This method is no longer used for LN slot reuse, and freeing of the off-heap BIN could be done by the only caller, splitInternal, and then this method could be removed.
  - getInMemorySize
```
public long getInMemorySize()
```
  - computeMemorySize
```
public long computeMemorySize()
```
    Count up the memory usage attributable to this node alone. LNs children are counted by their BIN parents, but INs are not counted by their parents because they are resident on the IN list. The identifierKey is "intentionally" not kept track of in the memory budget.
  - getFixedMemoryOverhead
```
protected long getFixedMemoryOverhead()
```
  - compactMemory
```
public long compactMemory()
```
    Compacts the representation of the IN, if possible. Called by the evictor to reduce memory usage. Should not be called too often (e.g., every CRUD operation), since this could cause lots of memory allocations as the representations contract and expend, resulting in expensive GC.
    
    Returns:
    
    number of bytes reclaimed.
  - getBudgetedMemorySize
```
public long getBudgetedMemorySize()
```
    Returns the amount of memory currently budgeted for this IN.
  - resetAndGetMemorySize
```
public long resetAndGetMemorySize()
```
    Called as part of a memory budget reset (during a checkpoint) to clear the accumulated delta and return the total memory size.
  - updateMemorySize
```
protected void updateMemorySize(long oldSize,
                                long newSize)
```
  - updateMemoryBudget
```
public void updateMemoryBudget()
```
    Move the accumulated delta to the memory budget.
  - printMemorySize
```
protected long printMemorySize()
```
  - verifyMemorySize
```
public boolean verifyMemorySize()
```
  - updateRepCacheStats
```
protected void updateRepCacheStats(boolean increment)
```
    Adds (increments) or removes (decrements) the cache stats for the key and target representations. Used when rep objects are being replaced with a new instance, rather than by calling their mutator methods. Specifically, it is called when mutating from full bin to bin delta or vice-versa.
  - getCompactMaxKeyLength
```
protected int getCompactMaxKeyLength()
```
  - setInListResident
```
public void setInListResident(boolean resident)
```
    Called when adding/removing this IN to/from the INList.
  - getInListResident
```
public boolean getInListResident()
```
    Returns whether this IN is on the INList.
  - getPrevLRUNode
```
public IN getPrevLRUNode()
```
  - setPrevLRUNode
```
public void setPrevLRUNode(IN node)
```
  - getNextLRUNode
```
public IN getNextLRUNode()
```
  - setNextLRUNode
```
public void setNextLRUNode(IN node)
```
  - partialEviction
```
public long partialEviction()
```
    Try to compact or otherwise reclaim memory in this IN and return the number of bytes reclaimed. For example, a BIN should evict LNs, if possible. Used by the evictor to reclaim memory by some means short of evicting the entire node. If a positive value is returned, the evictor will postpone full eviction of this node.
  - hasCachedChildren
```
public boolean hasCachedChildren()
```
    Returns whether any child is non-null in the main or off-heap cache.
  - setProhibitNextDelta
```
public void setProhibitNextDelta(boolean val)
```
    Disallow delta on next log. Set to true (a) when we we delete a slot from a BIN, (b) when the cleaner marks a BIN as dirty so that it will be migrated during the next checkpoint.
  - getProhibitNextDelta
```
public boolean getProhibitNextDelta()
```
  - setLastLoggedLsn
```
public void setLastLoggedLsn(long lsn)
```
    Sets the last logged LSN, which for a BIN may be a delta. It is called from IN.postFetch/RecoveryInit(). If the logrec we have just read was a BINDelta, this.lastFullVersion has already been set (in BINDeltaLogEntry.readMainItem() or in OldBinDelta.reconstituteBIN()). So, this method will set this.lastDeltaVersion. Otherwise, if the logrec was a full BIN, this.lastFullVersion has not been set yet, and it will be set here. In this case, this.lastDeltaVersion will remain NULL.
  - getLastLoggedLsn
```
public final long getLastLoggedLsn()
```
    Returns the LSN of the last last logged version of this IN, or NULL_LSN if never logged.
  - setLastFullLsn
```
public final void setLastFullLsn(long lsn)
```
    Sets the last full version LSN.
  - getLastFullLsn
```
public final long getLastFullLsn()
```
    Returns the last full version LSN, or NULL_LSN if never logged.
  - getLastDeltaLsn
```
public long getLastDeltaLsn()
```
    Returns the last delta version LSN, or NULL_LSN if a delta was not last logged. For BINs, it just returns the value of the lastDeltaVersion field. Public for unit testing.
  - logDirtyChildren
```
public void logDirtyChildren()
                      throws DatabaseException
```
    When splits and checkpoints intermingle in a deferred write databases, a checkpoint target may appear which has a valid target but a null LSN. Deferred write dbs are written out in checkpoint style by either Database.sync() or a checkpoint which has cleaned a file containing deferred write entries. For example, INa | BINb A checkpoint or Database.sync starts The INList is traversed, dirty nodes are selected BINb is bypassed on the INList, since it's not dirty BINb is split, creating a new sibling, BINc, and dirtying INa INa is selected as a dirty node for the ckpt If this happens, INa is in the selected dirty set, but not its dirty child BINb and new child BINc. In a durable db, the existence of BINb and BINc are logged anyway. But in a deferred write db, there is an entry that points to BINc, but no logged version. This will not cause problems with eviction, because INa can't be evicted until BINb and BINc are logged, are non-dirty, and are detached. But it can cause problems at recovery, because INa will have a null LSN for a valid entry, and the LN children of BINc will not find a home. To prevent this, search for all dirty children that might have been missed during the selection phase, and write them out. It's not sufficient to write only null-LSN children, because the existing sibling must be logged lest LN children recover twice (once in the new sibling, once in the old existing sibling. TODO: Would the problem above be solved by logging dirty nodes using a tree traversal (post-order), rather than using the dirty map?
    
    Throws:
    
    DatabaseException
  - log
```
public final long log()
```
  - log
```
public final long log(boolean allowDeltas,
                      boolean isProvisional,
                      boolean backgroundIO,
                      IN parent)
```
  - log
```
public final long log(boolean allowDeltas,
                      Provisional provisional,
                      boolean backgroundIO,
                      IN parent)
```
  - logEntry
```
public static long logEntry(INLogEntry<BIN> logEntry,
                            Provisional provisional,
                            boolean backgroundIO,
                            IN parent)
```
  - mutateToFullBIN
```
public void mutateToFullBIN(boolean leaveFreeSlot)
```
  - getNDeltas
```
public final int getNDeltas()
```
  - getGenericLogType
```
public final LogEntryType getGenericLogType()
```
    Description copied from class: Node
    
    Returns the generic LogEntryType for this node. Returning the actual type used to log the node is not always possible. Specifically, for LN nodes the generic type is less specific than the actual type used to log the node: + A non-transactional type is always returned. + LOG_INS_LN is returned rather than LOG_UPD_LN. + LOG_DEL_LN is returned rather than LOG_DEL_DUPLN.
    
    Specified by:
    
    getGenericLogType in class Node
    
    See Also:
    
    Node.getGenericLogType()
  - getLogType
```
public LogEntryType getLogType()
```
    Get the log type of this node.
  - getLogSize
```
public int getLogSize()
```
    Specified by:
    
    getLogSize in interface Loggable
    
    Returns:
    
    number of bytes used to store this object.
    
    See Also:
    
    Overrriden by DIN and DBIN classes.
  - getLogSize
```
public final int getLogSize(boolean deltasOnly)
```
  - writeToLog
```
public void writeToLog(ByteBuffer logBuffer)
```
    Description copied from interface: Loggable
    
    Serialize this object into the buffer.
    
    Specified by:
    
    writeToLog in interface Loggable
    
    Parameters:
    
    logBuffer - is the destination buffer
  - writeToLog
```
public void writeToLog(ByteBuffer logBuffer,
                       boolean deltasOnly)
```
  - serialize
```
public final void serialize(ByteBuffer logBuffer,
                            boolean deltasOnly,
                            boolean clearDirtyBits)
```
    WARNING: In the case of BINs this method is not only used for logging but also for off-heap caching. Therefore, this method should not have side effects unless the clearDirtyBits param is true.
  - mayHaveExpirationValues
```
public boolean mayHaveExpirationValues(ByteBuffer itemBuffer,
                                       int entryVersion)
```
    Returns whether the given serialized IN is a BIN that may have expiration values.
  - readFromLog
```
public void readFromLog(ByteBuffer itemBuffer,
                        int entryVersion)
```
    Description copied from interface: Loggable
    
    Initialize this object from the data in itemBuf.
    
    Specified by:
    
    readFromLog in interface Loggable
    
    Parameters:
    
    itemBuffer - the source buffer
    
    entryVersion - the log version of the data
  - readFromLog
```
public void readFromLog(ByteBuffer itemBuffer,
                        int entryVersion,
                        boolean deltasOnly)
```
  - materialize
```
public final void materialize(ByteBuffer itemBuffer,
                              int entryVersion,
                              boolean deltasOnly,
                              boolean clearDirtyBits)
```
    WARNING: In the case of BINs this method is used not only for logging but also for off-heap caching. Therefore, this method should not have side effects unless the clearDirtyBits param is true or an older log version is passed (off-heap caching uses the current version).
  - logicalEquals
```
public final boolean logicalEquals(Loggable other)
```
    Specified by:
    
    logicalEquals in interface Loggable
    
    Returns:
    
    true if these two loggable items are logically the same. Used for replication testing.
    
    See Also:
    
    Always return false, this item should never be compared.
  - dumpLog
```
public final void dumpLog(StringBuilder sb,
                          boolean verbose)
```
    Description copied from interface: Loggable
    
    Write the object into the string buffer for log dumping. Each object should be dumped without indentation or new lines and should be valid XML.
    
    Specified by:
    
    dumpLog in interface Loggable
    
    Parameters:
    
    sb - destination string buffer
    
    verbose - if true, dump the full, verbose version
    
    See Also:
    
    Loggable.dumpLog(java.lang.StringBuilder, boolean)
  - dumpLogAdditional
```
protected void dumpLogAdditional(StringBuilder sb)
```
    Allows subclasses to add additional fields before the end tag. If they just overload dumpLog, the xml isn't nested.
  - beginTag
```
public String beginTag()
```
  - endTag
```
public String endTag()
```
  - dumpString
```
public String dumpString(int nSpaces,
                         boolean dumpTags)
```
    For unit test support:
    
    Returns:
    
    a string that dumps information about this IN, without
  - toSafeString
```
public String toSafeString(int... slotIndexes)
```
    Converts to an identifying string that is safe to output in a log. Keys are not included for security/privacy reasons.
  - toString
```
public String toString()
```
    Description copied from class: Node
    
    Default toString method at the root of the tree.
    
    Overrides:
    
    toString in class Node
  - shortClassName
```
public String shortClassName()
```
  - setFetchINHook
```
public final void setFetchINHook(TestHook hook)
```

Class IN

Field Summary

Fields inherited from class com.sleepycat.je.tree.Node

Constructor Summary

Method Summary

Methods inherited from class com.sleepycat.je.tree.Node

Methods inherited from class java.lang.Object

Field Detail

MAX_FILE_OFFSET

DBMAP_LEVEL

MAIN_LEVEL

LEVEL_MASK

MIN_LEVEL

BIN_LEVEL

EXACT_MATCH

INSERT_SUCCESS

NON_EVICTABLE_IN

disableCompactLsns

ACCUMULATED_LIMIT_DEFAULT

ACCUMULATED_LIMIT

Constructor Detail

IN

IN

IN

Method Detail

init

isIN

isUpperIN

getLatchName

getLatchTimeoutMs

getLatchTable

latchNoWait

latch

latch

latchShared

latchShared

latchNoUpdateLRU

latchNoUpdateLRU

releaseLatch

releaseLatchIfOwner

isLatchOwner

isLatchExclusiveOwner

getLatchNWaiters

updateLRU

getParent

setParent

latchParent

getKnownChildIndex

pin

unpin

isPinned

getDatabase

setDatabase

getDatabaseId

getEnvImplForFatalException

getEnv

getKeyComparator

getLevel

getNormalizedLevel

getNodeId

hashCode

equals

compareTo

getDirty

setDirty

isBINDelta

isBINDelta

getFetchedCold

setFetchedCold

getFetchedColdOffHeap

setFetchedColdOffHeap

getRecalcToggle

setRecalcToggle

isRoot

hasCachedChildrenFlag

isInPri2LRU

setInPri2LRU

isExpirationInHours

getIdentifierKey

setIdentifierKey