Page Format
The page is broken into five sections
+----------+-------------+-------------------+-------------------+----------+ | formatId | page header | records | slot offset table | checksum | +----------+-------------+-------------------+-------------------+----------+
1 byte boolean is page an overflow page
1 byte byte page status (a field maintained in base page)
8 bytes long pageVersion (a field maintained in base page)
2 bytes unsigned short number of slots in slot offset table
4 bytes integer next record identifier
4 bytes integer generation number of this page (Future Use)
4 bytes integer previous generation of this page (Future Use)
8 bytes bipLocation the location of the beforeimage page (Future Use)
2 bytes unsigned short number of deleted rows on page. (new release 2.0)
2 bytes unsigned short % of the page to keep free for updates
2 bytes short spare for future use
4 bytes long spare for future use (encryption uses to write
random bytes here).
8 bytes long spare for future use
8 bytes long spare for future use
Note that spare space has been guaranteed to be writen with "0", so
that future use of field should not either not use "0" as a valid data
item or pick 0 as a valid default value so that on the fly upgrade can
assume that 0 means field was never assigned.
Fields 1 byte Boolean - is null, if true no more data follows. 4 bytes Integer - length of field that follows (excludes these four bytes). StoredPage will use the static method provided by StoredFieldHeader to read/write field status and field data length. Field Header format is defined in the StoredFieldHeader class.
Page Access The page data is accessed in this class by one of three methods.
java.util.zip.CRC32 , ArrayInputStream, ArrayOutputStream
| Modifier and Type | Field and Description |
|---|---|
| pack-priv ByteHolder | bh
In memory buffer used as scratch space for streaming columns. |
| private long | |
| private CRC32 | checksum
holder for the checksum. |
| protected static final int | CHECKSUM_SIZE
Size of the checksum stored on the page. |
| protected static final int | |
| protected static final int | |
| protected static final int | |
| protected static final int | COLUMN_NONE
Constants used in call to logColumn. |
| private int | |
| private int | |
| public static final int | FORMAT_NUMBER
static final Fields of the class |
| protected int | |
| private int | |
| private boolean | headerOutOfDate
Is the header in the byte array out of date wrt the fields. |
| private boolean | isOverflowPage
The page header is a fixed size, 56 bytes, following are variables used to access the fields in the header: 1 byte boolean isOverflowPage is page an overflow page 1 byte byte pageStatus page status (field in base page) 8 bytes long pageVersion page version (field in base page) 2 bytes ushort slotsInUse number of slots in slot offset table 4 bytes integer nextId next record identifier 4 bytes integer generation generation number of this page(FUTURE USE) 4 bytes integer prevGeneration previous generation of page (FUTURE USE) 8 bytes long bipLocation the location of the BI page (FUTURE USE) 2 bytes ushort deletedRowCount number of deleted rows on page.(rel 2.0) 2 bytes long spare for future use 4 bytes long spare (encryption writes random bytes) 8 bytes long spare for future use 8 bytes long spare for future use Note that spare space has been guaranteed to be writen with "0", so that future use of field should not either not use "0" as a valid data item or pick 0 as a valid default value so that on the fly upgrade can assume that 0 means field was never assigned. |
| protected static final int | |
| protected FormatIdOutputStream | |
| private int | maxFieldSize
maxFieldSize is a worst case calculation for the size of a record on an empty page, with a single field, but still allow room for an overflow pointer if another field is to be added. |
| protected int | minimumRecordSize
Minimum space to reserve for record portion length of row. |
| private int | |
| protected static final int | OVERFLOW_POINTER_SIZE
OVERFLOW_POINTER_SIZE - Number of bytes to reserve for overflow pointer The overflow pointer is the pointer that the takes the place of the last column of a row if the row can't fit on the page. |
| protected static final int | OVERFLOW_PTR_FIELD_SIZE
OVERFLOW_PTR_FIELD_SIZE - Number of bytes of an overflow field This is the length to reserve for either a column or row overflow pointer field. |
| private StoredRecordHeader | overflowRecordHeader
Scratch variable used when you need a overflowRecordHeader. |
| protected static final int | PAGE_HEADER_OFFSET
Start of page, formatId must fit in 4 bytes. |
| protected static final int | PAGE_HEADER_SIZE
Fixed size of the page header |
| protected static final int | PAGE_VERSION_OFFSET
offset of the page version number |
| private int | |
| protected ArrayInputStream | rawDataIn
Input streams used to read/write bytes to/from the page byte array. |
| protected ArrayOutputStream | |
| protected static final int | RECORD_SPACE_OFFSET
Start of the record storage area. |
| private int | |
| private int | slotFieldSize
slot field and slot entry size. |
| private int | |
| private int | slotTableOffsetToFirstEntry
Offset of the first entry in the slot table. |
| private int | slotTableOffsetToFirstRecordLengthField
Offset of the record length entry in the 1st slot table entry. |
| private int | slotTableOffsetToFirstReservedSpaceField
Offset of the reserved space length entry in the 1st slot table entry. |
| protected static final int | SMALL_SLOT_SIZE
SMALL_SLOT_SIZE are for pages smaller than 64K, LARGE_SLOT_SIZE is for pages bigger than 64K. |
| protected int | spareSpace
% of page to keep free for updates. |
| protected int | totalSpace
total usable space on a page. |
| private int | userRowSize
scratch variable used to keep track of the total user size for the row. |
| Access | Constructor and Description |
|---|---|
| public |
| Modifier and Type | Method and Description |
|---|---|
| private void | addSlotEntry(int
Position the new slot will take slot, int Offset of the record for the new slot recordOffset, int Length of the record stored in the new slot recordPortionLength, int Length of reserved space of record in slot reservedSpace)Insert a new slot entry into the current slot array. |
| public boolean | Returns: boolean indicating if a minimum sized row can be inserted.Implements abstract org. Is there enough space on the page to insert a minimum size row? |
| public int | appendOverflowFieldHeader(DynamicByteArrayOutputStream
The buffer that contains the partially logged row. logBuffer, RecordHandle the overflow (continuation) pointer
to the beginning of the long column overflowHandle)Implements abstract org. Append an overflow pointer to a partly logged row, to point to a long column that just been logged. |
| private int | Returns: slot field size in bytespage size in bytes pageSize)Calculate the slot field size from the page size. |
| private boolean | Returns: true if space should be reclaimed from this row post commit.See if reserved space should be reclaimed for the input row. |
| private void | |
| private void | |
| protected final void | clearSection(int
position of first byte to clear offset, int how many bytes to clear length)Zero out a portion of the page. |
| protected void | compactRecord(RawTransaction t, int slot, int id)
Implements abstract org. Subclass implementation of compactRecord. |
| private void | compressPage(int
compress out space starting at startByte offset startByte, int compress out space ending at endByte offset endByte)Compress out the space specified by startByte and endByte. |
| private void | |
| protected void | createPage(PageKey
The key describing page (segment,container,page). newIdentity, PageCreationArgs information stored about the page, once in the
container header and passed in through the object. args)Implements abstract org. Create a new StoredPage. |
| private void | createSpaceForUpdate(int slot, int offset, int oldLength, int newLength)
Create the space to update a portion of a record. |
| public PageTimeStamp | Returns: page time stampImplements org. Get a time stamp for this page |
| public void | doUpdateAtSlot(RawTransaction t, int slot, int id, Object[] row, FormatableBitSet validColumns)
Implements abstract org. Perform an update. |
| public boolean | Returns: true if the entire record at slot is on this page, i.e, no overflow row or long columns.Check record at this slot. slot)Implements abstract org. Is entire record on the page? |
| public boolean | Returns: true if the samethe page version gotton from this page via a currentTimeStamp
or setTimeStamp call earlier ts)Implements org. compare given PageVersion with pageVersion on page |
| protected void | expandPage(int
offset on page to begin the shift startOffset, int the number of bytes that must be freed. requiredBytes)Free up required bytes by shifting rows "down" the page. |
| public int | fetchNumFieldsAtSlot(int
is the slot number slot)Overrides org. Implements org. Get the number of fields on the row at slot |
| protected int | |
| private int | getFieldOffset(int slot, int fieldNumber)
Get the offset of the field header of the given field for the record in the given slot. |
| protected boolean | |
| private int | getMaxDataLength(int spaceAvailable, int overflowThreshold)
return the max datalength allowed with the space available |
| protected int | Returns: the maximum free space on this page possible.The maximum free space on this page possible. |
| protected BasePage | getNewOverflowPage()
Implements abstract org. Get an empty overflow page. |
| private RecordHandle | Returns: The next record handle in a long column chain.The slot of the current long column piece. slot)Return the next recordHandle in a long column chain. |
| protected StoredPage | |
| public BasePage | getOverflowPageForInsert(int currentSlot, Object[] row, FormatableBitSet validColumns)
Get a overflow page that potentially can handle a new overflowed record. |
| public BasePage | getOverflowPageForInsert(int currentSlot, Object[] row, FormatableBitSet validColumns, int startColumn)
Implements abstract org.
|
| private StoredRecordHeader | |
| protected static int | getOverflowSlot(BasePage overflowPage, StoredRecordHeader recordHeader)
Get the overflow slot for a record that has already overflowed. |
| pack-priv String | |
| public final int | |
| public int | getRecordLength(int slot)
Implements abstract org. Get the stored length of a record. |
| private int | Returns: The page offset of the record associated with the input slot.The array entry of the slot to find. slot)Get the page offset of the record associated with the input slot. |
| protected int | Returns: The length of the row on this page.the slot of the row to look up the length of. slot)Return length of row on this page. |
| public int | Returns: The reserved length of the row on this page.the slot of the row to look up the length of. slot)Implements abstract org. Return reserved length of row on this page. |
| private int | Returns: The page offset of a given slot entry.The array entry of the slot to find. slot)Get the page offset of a given slot entry. |
| protected int | |
| public int | Returns: The number of bytes used by the row at slot "slot".look at row at this slot. slot)Implements abstract org. Return the total number of bytes used, reserved, or wasted by the record at this slot. |
| public int | getTypeFormatId()
Implements org. Return my format identifier. |
| private void | handleIncompleteLogRow(int
slot of the current update. slot, int column to start at, handles start in middle of row startColumn, FormatableBitSet bit map indicating which columns are being updated. columnList, DynamicByteArrayOutputStream place to lot to. out)Handle an update of a record portion that is incomplete. |
| protected void | initFromData(FileContainer
The container to read the page in from. myContainer, PageKey The key representing page being read in (segment,
container, page number) newIdentity)Implements abstract org. Initialize the page from values in the page buffer. |
| protected void | initialize()
Overrides org. Initialize the StoredPage. |
| public void | initPage(LogInstant instant, byte status, int recordId, boolean overflow, boolean reuse)
Implements abstract org. Initialize the page. |
| private void | initSlotTable(PageKey
The identity of the page we are trying to
initialize, since we are in the middle of trying
to build the page existing info in the class is
not set up yet (like getIdentity()). newIdentity)Initialize the in-memory slot table. |
| private void | |
| public RecordHandle | insertAtSlot(int
The specified slot slot, Object[] The row version of the data row, FormatableBitSet a bit map of which columns in the row is valid.
ValidColumns will not be changed by RawStore. validColumns, LogicalUndo if logical undo may be necessary, a function pointer
to the access code where the logical undo logic
resides. Null if logical undo is not necessary. undo, byte if INSERT_UNDO_WITH_PURGE set, then the undo of this
insert will purge the row rather than mark it as
deleted, which is the default bahavior for
insertAtSlot and insert. insertFlag, int overflowThreshold)Overrides org. Implements org. Override insertAtSlot to provide long row support. |
| protected int | internalDeletedRecordCount()
Implements abstract org. get record count without checking for latch |
| private boolean | Returns: true if page no longer points to the long column chain.record header which used to point at the long column recordHeader, int column id of the long column in head. columnId, long the page id where the long column used to be. oldPageId, long the record id where the long column used to be. oldRecordId)See if there is a orphaned long colum chain or not. |
| private boolean | isLong(int fieldSize, int overflowThreshold)
return whether the field has exceeded the max threshold for this page it compares the fieldSize with the largest possible field for this page |
| public boolean | isOverflowPage()
Implements abstract org. Return true if the page is an overflow page, false if not. |
| public void | |
| public void | logColumn(int
slot of the current record slot, int field number of the column being updated fieldId, Object column version of the field. column, DynamicByteArrayOutputStream Where to write the logged form. out, int overflowThreshold)Implements abstract org. Log a Storable to a stream. |
| private int | Returns: The spaceAvailable after accounting for space for this column.array of column from which to read the column from. row, int The array position of column to be reading from row. arrayPosition, DynamicByteArrayOutputStream The stream to write the raw store page format of the
the column to. out, int The number of bytes available on the page for
this column, this may differ from current page
as it may include bytes used by previous
columns. spaceAvailable, int one of: COLUMN_NONE, COLUMN_FIRST, or COLUMN_LONG. columnFlag, int overflowThreshold)Log column from input row to the given output stream. |
| public void | logField(int
Slot number the record is stored in. slot, int Number of the field (starts at 0). fieldNumber, OutputStream Where to write the logged form. out)Implements abstract org. Log a field to the ObjectOutput stream. |
| public int | logLongColumn(int
slot of the row with the column slot, int record id of the recordId, Object the object form of the column to log column, DynamicByteArrayOutputStream where to log to the column to. out)Implements abstract org. Log a long column into a DataOuput. |
| private int | logOverflowField(DynamicByteArrayOutputStream out, int spaceAvailable, long overflowPage, int overflowId)
|
| private int | Returns: -1slot of record to log. slot, int spaceAvaliable on page. spaceAvailable, DynamicByteArrayOutputStream stream to log the record to. out)Create and write a long row header to the log stream. |
| public void | logRecord(int
Slot number the record is stored in. slot, int LOG_RECORD_*, the reason for logging the record. flag, int Record identifier of the record. recordId, FormatableBitSet which columns needs to be logged validColumns, OutputStream Where to write the logged form. out, RecordHandle the recordHandle of the head row piece, used
for post commit cleanup for update. headRowHandle)Implements abstract org. Log a record to the ObjectOutput stream. |
| private void | logRecordDataPortion(int slot, int flag, StoredRecordHeader recordHeader, FormatableBitSet validColumns, OutputStream out, RecordHandle headRowHandle)
|
| public int | Returns: the "realStartColumn" value, -1 if not a long row.the slot of the row being logged. slot, boolean this is logging an insert (not update/delete). forInsert, int record id of the row being logged. recordId, Object[] actual data of row in object form. If row is
null then we are logging an overflow pointer. row, FormatableBitSet bit map describing valid columns in row. validColumns, DynamicByteArrayOutputStream stream to log to. out, int what column to start with (see above for detail) startColumn, byte flag indicating mode we are in,
INSERT_DEFAULT - default insert
INSERT_SPLIT - splitting a row/column
across pages. insertFlag, int If -1 ignore variable, else part of row has
already been logged, and should continue with
this column. realStartColumn, int Use this as space on page if realStartColumn
is not -1. realSpaceOnPage, int How much of the page to use before deciding
to overflow a row. overflowThreshold)Implements abstract org. Log a row into the StoreOuput stream. |
| public int | Returns: the number of rows processed.slot of original row to move. slot, Object[] a row template to hold all columns of row. row, RecordHandle[] An array to be filled in by the call with the
old handles of all rows moved. old_handle, RecordHandle[] An array to be filled in by the call with the
new handles of all rows moved. new_handle)Implements org. Move record to a page toward the beginning of the file. |
| private int | |
| public int | Returns: The next id to assing to a row.Implements abstract org. Create a new record handle. |
| protected int | Returns: the next id based on the input id.The id caller just used, return the next one. recordId)Implements abstract org. Create a new record id based on current one passed in. This interface is used for the "copy" insert interface of raw store where multiple rows are inserted into a page in a single logged operation. |
| public int | Returns: The next id to assing to a row.Implements abstract org. Create a new record handle, and bump the id. Create a new record handle, and bump the id while holding the latch so that no other user can ever see this record id. This will lead to unused record id's in the case where an insert fails because there is not enough space on the page. |
| private static String | Returns: The string with the hex dump in it.array of bytes to dump. data)Provide a hex dump of the data in the in memory version of the page. |
| private String | |
| private void | purgeColumnChains(RawTransaction
The raw transaction doing the purging. t, int The slot of the row to purge. slot, RecordHandle The RecordHandle of the head row. headRowHandle)purge long columns chains which eminate from this page. |
| private void | purgeOneColumnChain(long
The page where the long column chain starts. overflowPageId, int The record id where long column chain starts. overflowRecordId)Purge the column chain that starts at overflowPageId, overflowRecordId Purge just the column chain that starts at the input address. |
| protected void | purgeOverflowAtSlot(int
slot number of row to purge. slot, RecordHandle recordHandle of the head row piece. headRowHandle, boolean when true data is logged for purges otherwise just headers. needDataLogged)Purge one row on an overflow page. |
| public void | purgeRecord(LogInstant instant, int
the slot to purge slot, int the id of the record that is to be purged recordId)Implements abstract org. purgeRecord from page. |
| protected void | purgeRowPieces(RawTransaction
The raw transaction doing the purging. t, int The slot of the row to purge. slot, RecordHandle The RecordHandle of the head row. headRowHandle, boolean when true data is logged for purges otherwise just headers. needDataLogged)Implements abstract org. Purge all the overflow columns and overflow rows of the record at slot. |
| private boolean | Returns: true if the row qualifies.The row being qualified. row, Qualifier[][] 2 dimensional array representing conjunctive
normal form of simple qualifiers. qual_list)Process the qualifier list on the row, return true if it qualifies. |
| private final boolean | Returns: Whether or not the row input qualifies.restore row into this object array. row, int offset in bytes from top of page to row offset_to_row_data, FetchDescriptor Description of fetch including which cols
and qualifiers. fetchDesc, StoredRecordHeader The record header of the row, it was read
in from stream and dataIn is positioned
after it. recordHeader, RecordHandle The head row to use for locking, used to
lock head row of overflow columns/rows. recordToLock)Process the list of qualifiers on the row in the stream. |
| private final void | readOneColumnFromPage(Object[]
col is read into object in row[qual_colid]. row, int the column id to read, colid N is row[N] colid, int offset in bytes from top of page to field offset_to_field_data, StoredRecordHeader record header of row to read column from. recordHeader, RecordHandle record handle to lock,
used by overflow column code. recordToLock)Read just one column from stream into row. |
| private void | |
| private final boolean | readRecordFromArray(Object[] row, int max_colid, int[] vCols, int[] mCols, ArrayInputStream dataIn, StoredRecordHeader recordHeader, RecordHandle recordToLock)
|
| private final boolean | Returns: The identifier to be used to open the conglomerate later.restore row into this object array. row, int The maximum numbered column id that will be
requested by caller. It should be:
min(row.length - 1, maximum bit set in vCols)
It is used to stop the inner most loop from
looking at more columns in the row. max_colid, int[] If not null, bit map indicates valid cols. vCols, int[] If not null, int array indicates columns already
read in from the stream. A non-zero entry
means the column has already been read in. mCols, LimitObjectInput restore row from this stream. dataIn, StoredRecordHeader The record header of the row, it was read in
from stream and dataIn is positioned after it. recordHeader, RecordHandle The head row to use for locking, used to lock
head row of overflow columns/rows. recordToLock)restore a record from a stream. |
| public StoredRecordHeader | Returns: The record header for the specific slot.return record header of this slot. slot)Implements abstract org. create the record header for the specific slot. |
| private String | |
| protected void | releaseExclusive()
Overrides org. Ensure that the page is released from the cache when it is unlatched. |
| pack-priv void | removeOrphanedColumnChain(ReclaimSpace
object describing the chain to remove. work, ContainerHandle open container handle to use to remove chain. containerHdl)Remove a column chain that may have been orphaned by an update. |
| private void | |
| public void | reserveSpaceForSlot(LogInstant instant, int slot, int spaceToReserve)
Implements abstract org. reserveSpaceForSlot This method will reserve at least specified "spaceToReserve" bytes for the record in the slot. |
| private void | |
| private StoredRecordHeader | restoreLongRecordFromSlot(Object[] row, FetchDescriptor fetchDesc, RecordHandle recordToLock, StoredRecordHeader parent_recordHeader)
|
| public void | restorePortionLongColumn(OverflowInputStream
the stream to read the next portion of long col from fetchStream)Implements abstract org. Restore a portion of a long column. |
| protected boolean | Returns: false if a qualifier_list is provided and the row does not qualifier (no row read in that case), else true.the slot number slot, Object[] (out) filled in sparse row row, FetchDescriptor Information describing fetch, including what
columns to fetch and qualifiers. fetchDesc, RecordHandle the record handle for the row at top level,
and is used in OverflowInputStream to lock the
row for Blobs/Clobs. recordToLock, StoredRecordHeader recordHeader, boolean The row on this page includes the head record
handle. Will be false for the overflow portions
of a "long" row, where columns of a row span
multiple pages. isHeadRow)Implements abstract org. Read the record at the given slot into the given row. |
| public void | restoreRecordFromStream(LimitObjectInput
the limit input stream in, Object[] (IN/OUT) row that is to be restored
(sparse representation) row)Implements abstract org. Restore a storable row from a LimitInputStream. |
| public void | setDeleteStatus(LogInstant instant, int
the slot to delete or undelete slot, boolean set delete status to this value delete)Implements abstract org. Set the deleted status |
| private void | |
| public void | setPageStatus(LogInstant
the log instant of the log record instant, byte the page status status)Implements abstract org. Set page status |
| private void | setRecordOffset(int
The array entry of the slot to set. slot, int the new offset to set. recordOffset)Set the page offset of the record associated with the input slot. |
| public void | setReservedSpace(LogInstant instant, int slot, int value)
Implements abstract org. Set the row reserved space. |
| private void | setSlotEntry(int
the slot to initialize. slot, int the offset on the page to find the record. recordOffset, int the actual length of record+hdr on page. recordPortionLength, int the reserved length associated with record. reservedSpace)Set up a new slot entry. |
| public void | setTimeStamp(PageTimeStamp ts)
Implements org. Set given pageVersion to be the as what is on this page |
| private int | Returns: the length of the data in the record after the replaced data.Offset where the update starts, need not be on a field boundry. offset, int length of the data being replaced oldLength, int length of the data replacing the old data newLength)Shift data within a record to account for an update. |
| private void | shrinkPage(int
offset on page to begin the shift startOffset, int the number of bytes that must be moved. shrinkBytes)Shrink page. |
| public void | skipField(ObjectInput in)
Implements abstract org. Skip a field header and its data on the given stream. |
| public void | skipRecord(ObjectInput in)
Implements abstract org.
|
| public boolean | Returns: true if the sum of the lengths will fit on the page.number of rows to check for. num_rows, int[] array of lengths of the rows to insert. spaceNeeded)Implements abstract org. Does this page have enough space to insert the input rows? |
| protected boolean | Returns: true if the record will fit on this page, after being given a new record id as the next id on this page.length of the row encoded with source_id record id. spaceNeeded, int record id of the row being moved. source_id)Does this page have enough space to move the row to it. |
| public boolean | Returns: true if we think the page will allow an insert, false otherwise.Implements org. Is there minimal space for insert? |
| public boolean | Returns: bolean indicating if row can be inserted on this page.The row to check for insert. row, FormatableBitSet bit map to interpret valid columns in row. validColumns, int The percentage of the page to use for the
insert. 100 means use 100% of the page,
50 means use 50% of page (ie. make sure
2 rows fit per page). overflowThreshold)Implements org. Is row guaranteed to be inserted successfully on this page? |
| private boolean | Returns: bolean indicating if row can be inserted on this page.The row to check for insert. row, FormatableBitSet bit map to interpret valid columns in row. validColumns, int spaceNeeded, int startColumn, int The percentage of the page to use for the
insert. 100 means use 100% of the page,
50 means use 50% of page (ie. make sure
2 rows fit per page). overflowThreshold)Is row guaranteed to be inserted successfully on this page? |
| public void | storeField(LogInstant instant, int slot, int fieldNumber, ObjectInput in)
Implements abstract org. storeField |
| public void | storeRecord(LogInstant instant, int slot, boolean insert, ObjectInput in)
Implements abstract org. Store a record at the given slot. |
| private void | |
| private void | |
| public String | |
| public String | |
| public boolean | Returns: true if page is relatively unfilled.Implements abstract org. Is this page unfilled? |
| protected void | |
| public RecordHandle | updateFieldAtSlot(int
is the slot number slot, int is the column id fieldId, Object has the new colum value to be stored in the record newValue, LogicalUndo if logical undo may be necessary, a function pointer to the
access code where the logical undo logic resides. Null if logical undo
is not necessary. undo)Overrides org. Implements org. Update field at specified slot |
| public void | updateFieldOverflowDetails(RecordHandle
handle of the record for long row handle, RecordHandle the overflow (continuation) pointer for the long row overflowHandle)Implements abstract org. Update the overflow pointer for a long column MT - latched - page latch must be held |
| public void | updateOverflowDetails(RecordHandle
handle of the record for long row handle, RecordHandle the overflow (continuation) pointer for the long row overflowHandle)Implements abstract org. Update a record handle to point to an overflowed record portion. |
| private void | |
| protected void | updateOverflowed(RawTransaction t, int
Slot of the original record on its original page slot, Object[] new version of the data row, FormatableBitSet validColumns, StoredRecordHeader recordHeader)Update an already overflowed record. |
| private void | |
| private void | |
| private void | updateRecordPortionLength(int
the slot of the record to set. slot, int The amount the record length changed. delta, int The amount the reserved length changed. reservedDelta)Update the length of data stored on this page for this record Update both the record length "field" and the reserved space "field" of the slot table entry associated with "slot". |
| protected void | usePageBuffer(byte[]
The array of bytes to use as the page buffer. pageBuffer)Implements abstract org. use this passed in page buffer as this object's page data. |
| protected void | |
| protected void | writeFormatId(PageKey
The key of this page. identity)Implements abstract org. Write out the format id of this page |
| protected void | writePage(PageKey
The key of this page. identity)Implements abstract org. Write information about page from variables into page byte array. |