BIN (starrocks-bdb-je 18.3.17 API)

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

All Implemented Interfaces:

LatchContext, Loggable, Comparable<IN>

Direct Known Subclasses:

DBIN
```
public class BIN
extends IN
```
A BIN represents a Bottom Internal Node in the JE tree. BIN-deltas ========== A BIN-delta is a BIN with the non-dirty slots omitted. A "full BIN", OTOH contains all slots. On disk and in memory, the format of a BIN-delta is the same as that of a BIN. In memory, a BIN object is actually a BIN-delta when the BIN-delta flag is set (IN.isBINDelta). On disk, the NewBINDelta log entry type (class BINDeltaLogEntry) is the only thing that distinguishes it from a full BIN, which has the BIN log entry type. BIN-deltas provides two benefits: Reduced writing and reduced memory usage. Reduced Writing --------------- Logging a BIN-delta rather a full BIN reduces writing significantly. The cost, however, is that two reads are necessary to reconstruct a full BIN from scratch. The reduced writing is worth this cost, particularly because less writing means less log cleaning. A BIN-delta is logged when 25% or less (configured with EnvironmentConfig TREE_BIN_DELTA) of the slots in a BIN are dirty. When a BIN-delta is logged, the dirty flag is cleared on the the BIN in cache. If more slots are dirtied and another BIN-delta is logged, it will contain all entries dirtied since the last full BIN was logged. In other words, BIN-deltas are cumulative and not chained, to avoid reading many (more than two) log entries to reconstruct a full BIN. The dirty flag on each slot is cleared only when a full BIN is logged. In addition to the cost of fetching two entries on a BIN cache miss, another drawback of the current approach is that dirtiness propagates upward in the Btree due to BIN-delta logging, causing repeated logging of upper INs. The slot of the parent IN contains the LSN of the most recent BIN-delta or full BIN that was logged. A BINDeltaLogEntry in turn contains the LSN of the last full BIN logged. Historical note: The pre-JE 5 implementation of OldBINDeltas worked differently and had a different cost/benefit trade-off. When an OldBINDelta was logged, its dirty flag was not cleared, causing it to be logged repeatedly at every checkpoint. A full BIN was logged after 10 deltas, to prevent endless logging of the same BIN. One benefit of this approach is that the BIN's parent IN was not dirtied when logging the OldBINDelta, preventing dirtiness from propagating upward. Another benefit is that the OldBINDelta was only processed by recovery, and did not have to be fetched to reconstruct a full BIN from scratch on a cache miss. But the cost (the logging of an OldBINDelta every checkpoint, even when it hadn't changed since the last time logged) outweighed the benefits. When the current approach was implemented in JE 5, performance improved due to less logging. In JE 6, deltas were also maintained in the Btree cache. This was done to provide the reduced memory benefits described in the next section. The log format for a delta was also changed. The OldBINDelta log format is different (not the same as the BIN format) and is supported for backward compatibility as the OldBINDeltaLogEntry. Its log entry type name is still BINDelta, which is why the new type is named NewBINDelta (for backward compatibility, log entry type names cannot be changed.) This is also why the spelling "BIN-delta" is used to refer to deltas in the new approach. The old BINDelta class was renamed to OldBINDelta and there is no longer a class named BINDelta. Reduced Memory Usage -------------------- In the Btree cache, a BIN may be represented as a full BIN or a BIN-delta. Eviction will mutate a full BIN to a BIN-delta in preference to discarding the entire BIN. A BIN-delta in cache occupies less memory than a full BIN, and can be exploited as follows: - When a full BIN is needed, it can be constructed with only one fetch rather than two, reducing IO overall. IN.fetchIN implements this optimization. - Certain operations can sometimes be performed using the BIN-delta alone, allowing such operations on a given data set to take place using less less IO (for a given cache size). The latter benefit is not yet implemented. No user CRUD operations are currently implemented using BIN-deltas. In the future we plan to implement the following operations using the BIN-delta alone. - Consider recording deletions in a BIN-delta. Currently, slot deletion prohibits a BIN-delta from being logged. To record deletion in BIN-deltas, slot deletion will have to be deferred until a full BIN is logged. - User reads by key, updates and deletions can be implemented if the key happens to appear in the BIN-delta. - The Cleaner can migrate an LN if its key happens to appear in the BIN-delta. This is similar to a user update operation, but in a different code path. - Insertions, deletions and updates can always be performed in a BIN-delta during replica replay, since the Master operation has already determined whether the key exists. - Recovery LN redo could also apply insertions, updates and inserts in the manner described. - Add idempotent put/delete operations, which can always be applied in a BIN-delta. - Store a hash of the keys in the full BIN in the BIN-delta and use it to perform the following in the delta: - putIfAbsent (true insertion) - get/delete/putIfPresent operations that return NOTFOUND - to avoid accumulating unnecessary deletions However, some internal operations do currently exploit BIN-deltas to avoid unnecessary IO. The following are currently implemented. - The Evictor and Checkpointer log a BIN-delta that is present in the cache, without having to fetch the full BIN. - The Cleaner can use the BIN-delta to avoid fetching when processing a BIN log entry (delta or full) and the BIN is not present in cache, To support BIB-delta-aware operations, the IN.fetchIN() and IN.getTarget() methods may return a BIN delta. IN.getTarget() will return whatever object is cached under the parent IN, and IN.fetchIN() will do a single I/O to fetch the most recently log record for the requested BIN, which may be a full BIN or a delta. Callers of these methods must be prepared to handle a BIN delta; either doing their operation directly on the delta, if possible, or mutating the delta to a full BIN by calling BIN.mutateToFullBIN().

Field Summary

Fields
Modifier and Type Field and Description

static boolean TEST_NO_LAST_LOGGED_SIZES
Can be set to true by tests to prevent last logged sizes from being stored.
- Fields inherited from class com.sleepycat.je.tree.IN
  ACCUMULATED_LIMIT, ACCUMULATED_LIMIT_DEFAULT, BIN_LEVEL, DBMAP_LEVEL, disableCompactLsns, EXACT_MATCH, INSERT_SUCCESS, LEVEL_MASK, MAIN_LEVEL, MAX_FILE_OFFSET, MIN_LEVEL, NON_EVICTABLE_IN
- Fields inherited from class com.sleepycat.je.tree.Node
  NULL_NODE_ID

Fields
Modifier and Type	Field and Description
`static boolean`	`TEST_NO_LAST_LOGGED_SIZES` Can be set to true by tests to prevent last logged sizes from being stored.

Constructor Summary

Constructors
Constructor and Description

BIN()

BIN(DatabaseImpl db, byte[] identifierKey, int capacity, int level)

BIN(SizeofMarker marker)
For Sizeof.

Constructors
Constructor and Description
`BIN()`
`BIN(DatabaseImpl db, byte[] identifierKey, int capacity, int level)`
`BIN(SizeofMarker marker)` For Sizeof.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addCursor(CursorImpl cursor)` Register a cursor with this BIN.
`String`	`beginTag()`
`boolean`	`canMutateToBINDelta()` Returns whether mutateToBINDelta can be called.
`void`	`clearLastLoggedSize(int idx)` The last logged size is not stored for UINs.
`void`	`clearOffHeapLNIds()`
`BIN`	`cloneBINDelta()` This method assumes that "this" BIN is a delta and creates a clone of it.
`long`	`compactMemory()` Compacts the representation of the IN, if possible.
`boolean`	`compress(boolean compressDirtySlots, LocalUtilizationTracker localTracker)` Compress a full BIN by removing any slots that are deleted or expired.
`long`	`computeMemorySize()` Adds vlsnCache size to computed memory size.
`protected IN`	`createNewInstance(byte[] identifierKey, int maxEntries, int level)` Create a new BIN.
`BINReference`	`createReference()`
`long`	`discardVLSNCache()`
`String`	`endTag()`
`void`	`evictLN(int index)`
`void`	`evictLN(int index, boolean ifFetchedCold)`
`long`	`evictLNs()` Reduce memory consumption by evicting all LN targets.
`Set<CursorImpl>`	`getCursorSet()`
`int`	`getExpiration(int idx)` Returns the expiration time for a slot.
`protected long`	`getFixedMemoryOverhead()`
`int`	`getFullBinMaxEntries()`
`int`	`getFullBinNEntries()`
`long`	`getLastDeltaLsn()` Overrides the IN method to account for deltas.
`int`	`getLastLoggedSize(int idx)` The last logged size is not stored for UINs.
`int`	`getLastLoggedSizeUnconditional(int idx)`
`LogEntryType`	`getLogType()` Get the log type of this node.
`long`	`getOffHeapLNId(int idx)`
`long`	`getOffHeapLNIdsMemorySize()`
`int`	`getOffHeapLruId()`
`long`	`getVLSN(int idx, boolean allowFetch, CacheMode cacheMode)` Returns the VLSN.
`INLongRep`	`getVLSNCache()` For unit testing.
`boolean`	`hasExpirationValues()`
`boolean`	`hasOffHeapLNs()`
`boolean`	`isBIN()`
`boolean`	`isDefunct(int idx)` Returns whether the slot is known-deleted, pending-deleted, or expired.
`boolean`	`isDeleted(int idx)` Returns whether the slot is known-deleted or pending-deleted.
`boolean`	`isExpired(int idx)` Returns whether the slot is expired.
`boolean`	`isProbablyExpired(int idx)`
`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.
`boolean`	`mayHaveKeyInFullBin(byte[] key)`
`long`	`mutateToBINDelta()` Mutate to a delta (discard non-dirty entries and resize arrays).
`void`	`mutateToFullBIN(BIN fullBIN, boolean leaveFreeSlot)` Mutates this delta to a full BIN by applying this delta to the fullBIN param and then replacing this BIN's contents with it.
`void`	`mutateToFullBIN(boolean leaveFreeSlot)` Fetch the full BIN and apply the deltas in this BIN to it, then use the merged result to replace the contents of this BIN.
`int`	`nCursors()`
`long`	`partialEviction()` Reduce memory consumption.
`protected long`	`printMemorySize()`
`void`	`queueSlotDeletion(int idx)` This method is called opportunistically at certain places where a deleted slot is observed (when the slot's PendingDeleted or KnownDeleted flag is set), to ensure that the slot is compressed away.
`BIN`	`reconstituteBIN(DatabaseImpl dbImpl)` Create a BIN by fetching its most recent full version from the log and applying to it the deltas in this BIN delta.
`void`	`reconstituteBIN(DatabaseImpl dbImpl, BIN fullBIN, boolean leaveFreeSlot)` Given a full version BIN, apply to it the deltas in this BIN delta.
`void`	`removeCursor(CursorImpl cursor)` Unregister a cursor with this bin.
`void`	`setCachedVLSN(int idx, long vlsn)`
`void`	`setExpiration(int idx, int value, boolean hours)` Sets the expiration time for a slot in days or hours.
`void`	`setFullBinMaxEntries(int n)`
`void`	`setFullBinNEntries(int n)`
`void`	`setLastDeltaLsn(long lsn)`
`void`	`setLastLoggedSize(int idx, int lastLoggedSize)` Sets last logged size if necessary.
`void`	`setOffHeapLNId(int idx, long memId)`
`void`	`setOffHeapLruId(int id)`
`String`	`shortClassName()`
`boolean`	`shouldLogDelta()` Decide whether to log a full or partial BIN, depending on the ratio of the delta size to full BIN size.
`void`	`verifyCursors()` For each cursor in this BIN's cursor set, ensure that the cursor is actually referring to this BIN.

Methods inherited from class com.sleepycat.je.tree.IN
attachNode, clearOffHeapBINId, compareTo, convertKey, deleteEntry, deleteRecord, detachNode, dumpLog, dumpLogAdditional, dumpString, equals, fetchIN, fetchLN, fetchLNOrDIN, findEntry, findEntry, getBudgetedMemorySize, getCompactMaxKeyLength, getData, getDatabase, getDatabaseId, getDirty, getEnv, getEnvImplForFatalException, getFetchedCold, getFetchedColdOffHeap, getGenericLogType, getIdentifierKey, getInListResident, getInMemorySize, getKey, getKeyComparator, getKeyPrefix, getKeyVals, getKnownChildIndex, getLastFullLsn, getLastLoggedLsn, getLatchName, getLatchNWaiters, getLatchTable, getLatchTimeoutMs, getLevel, getLN, getLogSize, getLogSize, getLsn, getMaxEntries, getNDeltas, getNEntries, getNextLRUNode, getNodeId, getNormalizedLevel, getNumEmbeddedLNs, getOffHeapBINId, getOffHeapBINIdsMemorySize, getParent, getPrevLRUNode, getProhibitNextDelta, getRecalcToggle, getState, getTarget, getTargets, hasCachedChildren, hasCachedChildrenFlag, hashCode, hasKeyPrefix, hasOffHeapBINIds, haveEmbeddedData, init, insertEntry, insertEntry1, insertEntry1, insertRecord, isBINDelta, isBINDelta, isDirty, isEmbeddedLN, isEmbeddedLN, isEntryKnownDeleted, isEntryPendingDeleted, isExpirationInHours, isIN, isInPri2LRU, isKeyInBounds, isLatchExclusiveOwner, isLatchOwner, isNoDataLN, isNoDataLN, isOffHeapBINDirty, isOffHeapBINPri2, isPinned, isRoot, isUpperIN, latch, latch, latchNoUpdateLRU, latchNoUpdateLRU, latchNoWait, latchParent, latchShared, latchShared, loadIN, log, log, log, logEntry, logicalEquals, makeFetchErrorMsg, materialize, mayHaveExpirationValues, needsSplitting, pin, postFetchInit, postRecoveryInit, prepareForSlotReuse, readFromLog, readFromLog, recalcKeyPrefix, recoverIN, recoverRecord, releaseLatch, releaseLatchIfOwner, resetAndGetMemorySize, serialize, setDatabase, setDirty, setFetchedCold, setFetchedColdOffHeap, setFetchINHook, setIdentifierKey, setInListResident, setInPri2LRU, setKey, setKnownDeleted, setKnownDeletedAndEvictLN, setLastFullLsn, setLastLoggedLsn, setLsn, setNextLRUNode, setOffHeapBINId, setParent, setPendingDeleted, setPrevLRUNode, setProhibitNextDelta, setRecalcToggle, split, toSafeString, toString, unpin, updateEntry, updateLRU, updateMemoryBudget, updateMemorySize, updateRecord, updateRepCacheStats, verifyMemorySize, writeToLog, writeToLog

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

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

- Field Detail
  - TEST_NO_LAST_LOGGED_SIZES
```
public static boolean TEST_NO_LAST_LOGGED_SIZES
```
    Can be set to true by tests to prevent last logged sizes from being stored.
- Constructor Detail
  - BIN
```
public BIN()
```
  - BIN
```
public BIN(DatabaseImpl db,
           byte[] identifierKey,
           int capacity,
           int level)
```
  - BIN
```
public BIN(SizeofMarker marker)
```
    For Sizeof.
- Method Detail
  - createNewInstance
```
protected IN createNewInstance(byte[] identifierKey,
                               int maxEntries,
                               int level)
```
    Create a new BIN. Need this because we can't call newInstance() without getting a 0 for nodeId.
  - createReference
```
public BINReference createReference()
```
  - isBIN
```
public boolean isBIN()
```
    Overrides:
    
    isBIN in class Node
  - shortClassName
```
public String shortClassName()
```
    Overrides:
    
    shortClassName in class IN
  - beginTag
```
public String beginTag()
```
    Overrides:
    
    beginTag in class IN
  - endTag
```
public String endTag()
```
    Overrides:
    
    endTag in class IN
  - setCachedVLSN
```
public void setCachedVLSN(int idx,
                          long vlsn)
```
  - getVLSN
```
public long getVLSN(int idx,
                    boolean allowFetch,
                    CacheMode cacheMode)
```
    Returns the VLSN. VLSN.NULL_VLSN_SEQUENCE (-1) is returned in two cases: 1) This is a standalone environment. 2) The VLSN is not cached (perhaps VLSN caching is not configured), and the allowFetch param is false. WARNING: Because the vlsnCache is only updated when an LN is evicted, it is critical that getVLSN returns the VLSN for a resident LN before getting the VLSN from the cache.
  - getVLSNCache
```
public INLongRep getVLSNCache()
```
    For unit testing.
  - setLastLoggedSize
```
public void setLastLoggedSize(int idx,
                              int lastLoggedSize)
```
    Sets last logged size if necessary. This method does not dirty the IN because the caller methods dirty it, for example, when setting the LSN, key, or node. This method is sometimes called to add the logged size for a pre log version 9 BIN, for example, during fetchTarget and preload. This makes the logged size available for obsolete counting but does not dirty the IN, since that could cause an unexpected write of the IN being read.
    
    Overrides:
    
    setLastLoggedSize in class IN
    
    Parameters:
    
    lastLoggedSize - is positive if the size is known, zero if the size is unknown, or -1 if the size should not be changed because logging of the LN was deferred.
  - clearLastLoggedSize
```
public void clearLastLoggedSize(int idx)
```
    Description copied from class: IN
    
    The last logged size is not stored for UINs.
    
    Overrides:
    
    clearLastLoggedSize in class IN
  - getLastLoggedSize
```
public int getLastLoggedSize(int idx)
```
    Description copied from class: IN
    
    The last logged size is not stored for UINs.
    
    Overrides:
    
    getLastLoggedSize in class IN
    
    Returns:
    
    a positive value if the size is known, or zero if unknown.
  - setExpiration
```
public void setExpiration(int idx,
                          int value,
                          boolean hours)
```
    Sets the expiration time for a slot in days or hours.
  - hasExpirationValues
```
public boolean hasExpirationValues()
```
  - getExpiration
```
public int getExpiration(int idx)
```
    Returns the expiration time for a slot. The return value is in days or hours, depending on isExpirationTimeInHours.
  - isDefunct
```
public boolean isDefunct(int idx)
```
    Returns whether the slot is known-deleted, pending-deleted, or expired.
  - isDeleted
```
public boolean isDeleted(int idx)
```
    Returns whether the slot is known-deleted or pending-deleted.
  - isExpired
```
public boolean isExpired(int idx)
```
    Returns whether the slot is expired.
  - isProbablyExpired
```
public boolean isProbablyExpired(int idx)
```
  - getLastLoggedSizeUnconditional
```
public int getLastLoggedSizeUnconditional(int idx)
```
  - setOffHeapLNId
```
public void setOffHeapLNId(int idx,
                           long memId)
```
  - clearOffHeapLNIds
```
public void clearOffHeapLNIds()
```
  - getOffHeapLNIdsMemorySize
```
public long getOffHeapLNIdsMemorySize()
```
  - getOffHeapLNId
```
public long getOffHeapLNId(int idx)
```
  - hasOffHeapLNs
```
public boolean hasOffHeapLNs()
```
  - setOffHeapLruId
```
public void setOffHeapLruId(int id)
```
  - getOffHeapLruId
```
public int getOffHeapLruId()
```
  - getCursorSet
```
public Set<CursorImpl> getCursorSet()
```
  - addCursor
```
public void addCursor(CursorImpl cursor)
```
    Register a cursor with this BIN. Caller has this BIN already latched.
    
    Parameters:
    
    cursor - Cursor to register.
  - removeCursor
```
public void removeCursor(CursorImpl cursor)
```
    Unregister a cursor with this bin. Caller has this BIN already latched.
    
    Parameters:
    
    cursor - Cursor to unregister.
  - nCursors
```
public int nCursors()
```
    Returns:
    
    the number of cursors currently referring to this BIN.
  - verifyCursors
```
public void verifyCursors()
```
    For each cursor in this BIN's cursor set, ensure that the cursor is actually referring to this BIN.
  - compress
```
public boolean compress(boolean compressDirtySlots,
                        LocalUtilizationTracker localTracker)
```
    Compress a full BIN by removing any slots that are deleted or expired. This must not be a BIN-delta. No cursors can be present on the BIN, unless the env is closing. Caller is responsible for latching and unlatching this node. If the slot containing the identifier is removed, the identifier key will be changed to the key in the first remaining slot. Normally when a slot is removed, the IN is dirtied. However, during compression the BIN is not dirtied when a slot is removed. This is safe for the reasons described below. Note that the BIN being compressed is always a full BIN, not a delta. + If the BIN is not dirty and it does not become dirty before shutdown, i.e., it is not logged, then it is possible that this compression will be "lost". However, the state of the slot on disk is expired/deleted, and when the BIN is later fetched from disk, this state will be restored and the compression will be performed again. + If the slot is dirty, the BIN may also be dirty or may become dirty later, and be logged. Logging a delta would cause the information in the dirty slot to be lost. Therefore, when a dirty slot is removed, we set a flag that prohibits the next BIN logged from being a delta. This optimization (that we don't dirty the BIN and we allow logging a delta after removing a non-dirty slot) has one minor and one major impact: 1. When a slot is removed for a deleted record, normally the slot and the BIN will be dirty. Although it is unusual, we may encounter a non-dirty slot for a deleted record. This happens if the slot could not be removed by this method when a full BIN is logged, due to a lock or a cursor, and we compress the full BIN later. 2. When a slot is removed for an expired record, it is common that the slot will not be be dirty. In this case, without the optimization, the removal of expired slots would cause more logging and less deltas would be logged.
    
    Parameters:
    
    localTracker - is used only for temporary DBs, and may be specified to consolidate multiple tracking operations. If null, the tracking is performed immediately in this method.
    
    Returns:
    
    true if all deleted and expired slots were compressed, or false if one or more slots could not be compressed because we were unable to obtain a lock. A false return value means "try again later".
  - queueSlotDeletion
```
public void queueSlotDeletion(int idx)
```
    This method is called opportunistically at certain places where a deleted slot is observed (when the slot's PendingDeleted or KnownDeleted flag is set), to ensure that the slot is compressed away. This is an attempt to process slots that were not compressed during the mainstream record deletion process because of cursors on the BIN during compress, or a crash prior to compression.
  - compactMemory
```
public long compactMemory()
```
    Description copied from class: IN
    
    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.
    
    Overrides:
    
    compactMemory in class IN
    
    Returns:
    
    number of bytes reclaimed.
  - computeMemorySize
```
public long computeMemorySize()
```
    Adds vlsnCache size to computed memory size.
    
    Overrides:
    
    computeMemorySize in class IN
  - printMemorySize
```
protected long printMemorySize()
```
    Overrides:
    
    printMemorySize in class IN
  - getFixedMemoryOverhead
```
protected long getFixedMemoryOverhead()
```
    Overrides:
    
    getFixedMemoryOverhead in class IN
  - partialEviction
```
public long partialEviction()
```
    Reduce memory consumption. Note that evicting deferred-write LNs may require logging them, which will mark this BIN dirty. Compression of deleted slots will also mark the BIN dirty. The BIN should be latched by the caller.
    
    Overrides:
    
    partialEviction in class IN
    
    Returns:
    
    a long number encoding (a) the number of evicted bytes, and (b) whether this BIN is evictable. (b) will be false if the BIN has any cursors on it, or has any non-evictable children.
  - discardVLSNCache
```
public long discardVLSNCache()
```
  - evictLNs
```
public long evictLNs()
              throws DatabaseException
```
    Reduce memory consumption by evicting all LN targets. Note that this may cause LNs to be logged, which will mark this BIN dirty. The BIN should be latched by the caller.
    
    Returns:
    
    a long number encoding (a) the number of evicted bytes, and (b) whether this BIN is evictable. (b) will be false if the BIN has any cursors on it, or has any non-evictable children.
    
    Throws:
    
    DatabaseException
  - evictLN
```
public void evictLN(int index)
```
  - evictLN
```
public void evictLN(int index,
                    boolean ifFetchedCold)
             throws DatabaseException
```
    Throws:
    
    DatabaseException
  - logDirtyChildren
```
public void logDirtyChildren()
                      throws DatabaseException
```
    Description copied from class: IN
    
    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?
    
    Overrides:
    
    logDirtyChildren in class IN
    
    Throws:
    
    DatabaseException
    
    See Also:
    
    IN.logDirtyChildren()
  - getLogType
```
public LogEntryType getLogType()
```
    Description copied from class: IN
    
    Get the log type of this node.
    
    Overrides:
    
    getLogType in class IN
    
    See Also:
    
    IN.getLogType()
  - getLastDeltaLsn
```
public long getLastDeltaLsn()
```
    Overrides the IN method to account for deltas. Public for unit testing.
    
    Overrides:
    
    getLastDeltaLsn in class IN
  - setLastDeltaLsn
```
public void setLastDeltaLsn(long lsn)
```
  - getFullBinNEntries
```
public int getFullBinNEntries()
```
  - setFullBinNEntries
```
public void setFullBinNEntries(int n)
```
  - getFullBinMaxEntries
```
public int getFullBinMaxEntries()
```
  - setFullBinMaxEntries
```
public void setFullBinMaxEntries(int n)
```
  - mayHaveKeyInFullBin
```
public boolean mayHaveKeyInFullBin(byte[] key)
```
  - shouldLogDelta
```
public boolean shouldLogDelta()
```
    Decide whether to log a full or partial BIN, depending on the ratio of the delta size to full BIN size. Other factors are taken into account: + a delta cannot be logged if the BIN has never been logged before + deltas are not currently supported for DeferredWrite databases + this particular delta may have been prohibited because the cleaner is migrating the BIN or a dirty slot has been removed + if there are no dirty slots, we might as well log a full BIN The restriction on using BIN-deltas for deferred-write DBs is for reasons that are probably no longer relevant. However, we have not tested deltas with DW, so we still prohibit them. Because BIN-deltas may be in cache at the time a DB is opened in DW mode, a workaround is currently necessary: see Database.mutateDeferredWriteBINDeltas.
    
    Returns:
    
    true if we should log the deltas of this BIN
  - canMutateToBINDelta
```
public boolean canMutateToBINDelta()
```
    Returns whether mutateToBINDelta can be called.
  - mutateToBINDelta
```
public long mutateToBINDelta()
```
    Mutate to a delta (discard non-dirty entries and resize arrays). This method must be called with this node latched exclusively, and canMutateToBINDelta must return true.
    
    Returns:
    
    the number of bytes freed.
  - cloneBINDelta
```
public BIN cloneBINDelta()
```
    This method assumes that "this" BIN is a delta and creates a clone of it. It is currently used by the DiskOrderedScanner only. The method does not clone the targets array.
  - mutateToFullBIN
```
public void mutateToFullBIN(boolean leaveFreeSlot)
```
    Fetch the full BIN and apply the deltas in this BIN to it, then use the merged result to replace the contents of this BIN. This method must be called with this node latched exclusively. If 'this' is not a delta, this method does nothing.
    
    Overrides:
    
    mutateToFullBIN in class IN
  - mutateToFullBIN
```
public void mutateToFullBIN(BIN fullBIN,
                            boolean leaveFreeSlot)
```
    Mutates this delta to a full BIN by applying this delta to the fullBIN param and then replacing this BIN's contents with it. This method must be called with this node latched exclusively. 'this' must be a delta. After mutation, the full BIN is compressed and compacted. The compression is particularly important, since BIN-deltas in cache cannot be compressed. The method is public because it is called directly from FileProcessor when it finds a BIN that must be migrated. In that case, fullBIN is a full BIN that has just been read from the log, and it is not part of the memory-resident tree.
  - reconstituteBIN
```
public BIN reconstituteBIN(DatabaseImpl dbImpl)
```
    Create a BIN by fetching its most recent full version from the log and applying to it the deltas in this BIN delta. The new BIN is not added to the INList or the BTree. Called from DiskOrderedScanner.fetchAndProcessBINs() and DiskOrderedScanner.accumulateLNs()
    
    Returns:
    
    the full BIN with deltas applied.
  - reconstituteBIN
```
public void reconstituteBIN(DatabaseImpl dbImpl,
                            BIN fullBIN,
                            boolean leaveFreeSlot)
```
    Given a full version BIN, apply to it the deltas in this BIN delta. The fullBIN will then be complete, but its memory will not be compacted. Called from mutateToFullBIN() above and from SortedLSNTreewalker.
    
    Parameters:
    
    leaveFreeSlot - should be true if a slot will be inserted into the resulting full BIN, without first checking whether the full BIN must be split, and performing the split if necessary. If this param is true, the returned BIN will contain at least one free slot. If this param is false, a BIN with no free slots may be returned. For example, it is important that false is passed when a split will be performed, since if true were passed, the BIN would grow beyond its bounds unnecessarily.

Class BIN

Field Summary

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

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

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Field Detail

TEST_NO_LAST_LOGGED_SIZES

Constructor Detail

BIN

BIN

BIN

Method Detail

createNewInstance

createReference

isBIN

shortClassName

beginTag

endTag

setCachedVLSN

getVLSN

getVLSNCache

setLastLoggedSize

clearLastLoggedSize

getLastLoggedSize

setExpiration

hasExpirationValues

getExpiration

isDefunct

isDeleted

isExpired

isProbablyExpired

getLastLoggedSizeUnconditional

setOffHeapLNId

clearOffHeapLNIds

getOffHeapLNIdsMemorySize

getOffHeapLNId

hasOffHeapLNs

setOffHeapLruId

getOffHeapLruId

getCursorSet

addCursor

removeCursor

nCursors

verifyCursors

compress

queueSlotDeletion

compactMemory

computeMemorySize

printMemorySize

getFixedMemoryOverhead

partialEviction

discardVLSNCache

evictLNs

evictLN

evictLN

logDirtyChildren

getLogType

getLastDeltaLsn

setLastDeltaLsn

getFullBinNEntries

setFullBinNEntries

getFullBinMaxEntries

setFullBinMaxEntries

mayHaveKeyInFullBin

shouldLogDelta

canMutateToBINDelta

mutateToBINDelta

cloneBINDelta

mutateToFullBIN

mutateToFullBIN

reconstituteBIN

reconstituteBIN