MapLN (starrocks-bdb-je 18.3.17 API)

java.lang.Object
- com.sleepycat.je.tree.Node
- - com.sleepycat.je.tree.LN
  - - com.sleepycat.je.tree.MapLN

All Implemented Interfaces:

Loggable, VersionedWriteLoggable
```
public final class MapLN
extends LN
```
A MapLN represents a Leaf Node in the JE Db Mapping Tree. MapLNs contain a DatabaseImpl, which in turn contains three categories of information - database configuration information, the per-database File Summary utilization information, and each database's btree root. While LNs are written to the log as the result of API operations which create new data records, MapLNs are written to the log as a result of configuration changes, utilization information changes, or updates to the btree which cascade up the tree and result in a new root. Because they serve as a bridge between the application data btree and the db mapping tree, MapLNs must be written with special rules, and should only be written from DbTree.modifyDbRoot. The basic rule is that in order to ensure that the MapLN contains the proper btree root, the btree root latch is used to protect both any logging of the MapLN, and any updates to the root lsn. Updates to the internal btree nodes obey a strict bottom up approach, in accordance with the log semantics which require that later log entries are known to supercede earlier log entries. In other words, for a btree that looks like MapLN | IN | BIN | LN we know that update operations cause the btree nodes must be logged in this order: LN, BIN, IN, MapLN, so that the reference to each on disk node is correct. (Note that logging order is special and different when the btree is initially created.) However, MapLNs may need to be written to disk at arbitrary points in time in order to save database config or utilization data. Those writes don't have the time and context to be done in a cascading-upwards fashion. We ensure that MapLNs are not erroneously written with an out of sync root by requiring that DbTree.modifyDbRoot takes the root latch for the application data btree. RootINs are also written with the root latch, so it serves to ensure that the root doesn't change during the time when the MapLN is written. For example, suppose thread 1 is doing a cascading-up MapLN write, and thread 2 is doing an arbitrary-point MapLN write: Thread 1 Thread 2 -------- -------- latch root latch BIN parent of MapLN log root IN log MapLN (Tree root) wants to log MapLN too -- but has to take to refer to new root IN root latch, so we'll get the right rootIN Without latching the root this could produce the following, incorrect log 30 LNa 40 BIN 50 IN (first version of root) 60 MapLN, refers to IN(50) ... 90 LNb 100 BIN 110 IN (second version of root) 120 CkptStart (the tree is not dirty, no IN will be logged during the ckpt interval)) .. something arbirarily writes out the MapLN 130 MapLN refers to first root, IN(50) <------ impossible While a MapLN can't be written out with the wrong root, it's possible for a rootIN to be logged without the MapLN, and for that rootIN not to be processed at recovery. Suppose a checkpoint begins and ends in the window between when a rootIN is written, and DbTree.modifyDbRoot is called: 300 log new root IN, update root reference in tree unlatch root 310 Checkpoint starts 320 Checkpoint ends ...if we crash here, before the MapLN is logged, , we won't see the new root IN at lsn 300. However, the IN is non-txnal and will be recreated during reply of txnal information (LNs) by normal recovery processing.

Field Summary
- Fields inherited from class com.sleepycat.je.tree.Node
  NULL_NODE_ID

Constructor Summary

Constructors
Constructor and Description

MapLN()
Create an empty MapLN, to be filled in from the log.

MapLN(DatabaseImpl db)
Create a new MapLn to hold a new databaseImpl.

Constructors
Constructor and Description
`MapLN()` Create an empty MapLN, to be filled in from the log.
`MapLN(DatabaseImpl db)` Create a new MapLn to hold a new databaseImpl.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`String`	`beginTag()`
`protected void`	`dumpLogAdditional(StringBuilder sb, boolean verbose)` Dump additional fields.
`String`	`dumpString(int nSpaces, boolean dumpTags)`
`String`	`endTag()`
`DatabaseImpl`	`getDatabase()`
`int`	`getLogSize(int logVersion, boolean forReplication)` Returns the number of bytes needed to store this object in the format for the specified log version.
`protected LogEntryType`	`getLogType(boolean isInsert, boolean isTransactional, DatabaseImpl db)` Return the correct log entry type for a MapLN depends on whether it's transactional.
`long`	`getMemorySizeIncludedByParent()` Compute the approximate size of this node in memory for evictor invocation purposes.
`boolean`	`isDeleted()`
`boolean`	`isDirty()`
`boolean`	`logicalEquals(Loggable other)` Should never be replicated.
`void`	`postFetchInit(DatabaseImpl db, long sourceLsn)` Initialize a node that has been faulted in from the log.
`void`	`readFromLog(ByteBuffer itemBuffer, int entryVersion)` Initialize this object from the data in itemBuf.
`String`	`toString()` Default toString method at the root of the tree.
`void`	`writeToLog(ByteBuffer logBuffer, int logVersion, boolean forReplication)` Serializes this object into the specified buffer in the format for the specified log version.

Methods inherited from class com.sleepycat.je.tree.LN
addExtraMarshaledMemorySize, clearDirty, copyEntryData, delete, dumpKey, dumpLog, getData, getEmbeddedLoggables, getFetchedCold, getGenericLogType, getLastFormatChange, getLogSize, getVLSNSequence, hasReplicationFormat, isLN, isReplicationFormatWorthwhile, log, makeLN, makeLN, modify, optionalLog, resolvePartialEntry, setDirty, setEmpty, setEntry, setEntry, setEntry, setFetchedCold, setVLSNSequence, writeToLog

Methods inherited from class com.sleepycat.je.tree.Node
containsDuplicates, dump, getLevel, getTransactionId, getType, isBIN, isBINDelta, isBINDelta, isDBIN, isDIN, isIN, isUpperIN, latch, latchShared, latchShared, releaseLatch

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

Methods inherited from interface com.sleepycat.je.log.Loggable
getTransactionId

- Constructor Detail
  - MapLN
```
public MapLN(DatabaseImpl db)
```
    Create a new MapLn to hold a new databaseImpl. In the ideal world, we'd have a base LN class so that this MapLN doesn't have a superfluous data field, but we want to optimize the LN class for size and speed right now.
  - MapLN
```
public MapLN()
```
    Create an empty MapLN, to be filled in from the log.
- Method Detail
  - isDeleted
```
public boolean isDeleted()
```
    Overrides:
    
    isDeleted in class LN
  - getDatabase
```
public DatabaseImpl getDatabase()
```
  - isDirty
```
public boolean isDirty()
```
    Overrides:
    
    isDirty in class LN
  - postFetchInit
```
public void postFetchInit(DatabaseImpl db,
                          long sourceLsn)
```
    Initialize a node that has been faulted in from the log.
    
    Overrides:
    
    postFetchInit in class LN
  - getMemorySizeIncludedByParent
```
public long getMemorySizeIncludedByParent()
```
    Compute the approximate size of this node in memory for evictor invocation purposes. Don't count the treeAdmin memory, because that goes into a different bucket.
    
    Overrides:
    
    getMemorySizeIncludedByParent in class LN
  - toString
```
public String toString()
```
    Description copied from class: Node
    
    Default toString method at the root of the tree.
    
    Overrides:
    
    toString in class Node
  - beginTag
```
public String beginTag()
```
    Overrides:
    
    beginTag in class LN
  - endTag
```
public String endTag()
```
    Overrides:
    
    endTag in class LN
  - dumpString
```
public String dumpString(int nSpaces,
                         boolean dumpTags)
```
    Overrides:
    
    dumpString in class LN
  - getLogType
```
protected LogEntryType getLogType(boolean isInsert,
                                  boolean isTransactional,
                                  DatabaseImpl db)
```
    Return the correct log entry type for a MapLN depends on whether it's transactional.
    
    Overrides:
    
    getLogType in class LN
  - getLogSize
```
public int getLogSize(int logVersion,
                      boolean forReplication)
```
    Description copied from interface: VersionedWriteLoggable
    
    Returns the number of bytes needed to store this object in the format for the specified log version. Earlier log versions only need to be supported for log entries with format changes made in LogEntryType.LOG_VERSION_REPLICATE_OLDER or greater.
    
    Specified by:
    
    getLogSize in interface VersionedWriteLoggable
    
    Overrides:
    
    getLogSize in class LN
    
    Parameters:
    
    logVersion - the log version
    
    forReplication - whether the entry will be sent over the wire, and not written to the log.
    
    Returns:
    
    the number of bytes to store this object for the log version
  - writeToLog
```
public void writeToLog(ByteBuffer logBuffer,
                       int logVersion,
                       boolean forReplication)
```
    Description copied from interface: VersionedWriteLoggable
    
    Serializes this object into the specified buffer in the format for the specified log version. Earlier log versions only need to be supported for log entries with format changes made in LogEntryType.LOG_VERSION_REPLICATE_OLDER or greater.
    
    Specified by:
    
    writeToLog in interface VersionedWriteLoggable
    
    Overrides:
    
    writeToLog in class LN
    
    Parameters:
    
    logBuffer - the destination buffer
    
    logVersion - the log version
    
    forReplication - whether the entry will be sent over the wire, and not written to the log.
  - 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
    
    Overrides:
    
    readFromLog in class LN
    
    Parameters:
    
    itemBuffer - the source buffer
    
    entryVersion - the log version of the data
  - logicalEquals
```
public boolean logicalEquals(Loggable other)
```
    Should never be replicated.
    
    Specified by:
    
    logicalEquals in interface Loggable
    
    Overrides:
    
    logicalEquals in class LN
    
    Returns:
    
    true if these two loggable items are logically the same. Used for replication testing.
  - dumpLogAdditional
```
protected void dumpLogAdditional(StringBuilder sb,
                                 boolean verbose)
```
    Dump additional fields. Done this way so the additional info can be within the XML tags defining the dumped log entry.
    
    Overrides:
    
    dumpLogAdditional in class LN

Class MapLN

Field Summary

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

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Methods inherited from interface com.sleepycat.je.log.Loggable

Constructor Detail

MapLN

MapLN

Method Detail

isDeleted

getDatabase

isDirty

postFetchInit

getMemorySizeIncludedByParent

toString

beginTag

endTag

dumpString

getLogType

getLogSize

writeToLog

readFromLog

logicalEquals

dumpLogAdditional