IndexData

java.lang.Object
- com.healthmarketscience.jackcess.impl.IndexData

```
public class IndexData
extends java.lang.Object
```
Access table index data. This is the actual data which backs a logical Index, where one or more logical indexes can be backed by the same index data.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private class`	`IndexData.AddRowPendingChange` PendingChange for a row addition.
`private static class`	`IndexData.BinaryColumnDescriptor` ColumnDescriptor for BINARY columns.
`private static class`	`IndexData.BooleanColumnDescriptor` ColumnDescriptor for boolean columns.
`private static class`	`IndexData.ByteColumnDescriptor` ColumnDescriptor for byte based columns.
`static class`	`IndexData.ColumnDescriptor` Information about the columns in an index.
`protected static class`	`IndexData.DataPage` Object used to maintain state about an Index page.
`static class`	`IndexData.Entry` A single leaf entry in an index (points to a single row)
`class`	`IndexData.EntryCursor` Utility class to traverse the entries in the Index.
`static class`	`IndexData.EntryType` type attributes for Entries which simplify comparisons
`private static class`	`IndexData.FixedPointColumnDescriptor` ColumnDescriptor for new-style fixed point based columns.
`private static class`	`IndexData.FloatingPointColumnDescriptor` ColumnDescriptor for floating point based columns.
`private static class`	`IndexData.GenLegTextColumnDescriptor` ColumnDescriptor for "general legacy" sort order text based columns.
`private static class`	`IndexData.GenTextColumnDescriptor` ColumnDescriptor for "general" sort order (2010+) text based columns.
`private static class`	`IndexData.GuidColumnDescriptor` ColumnDescriptor for guid columns.
`private static class`	`IndexData.IntegerColumnDescriptor` ColumnDescriptor for integer based columns.
`private static class`	`IndexData.LegacyFixedPointColumnDescriptor` ColumnDescriptor for fixed point based columns (legacy sort order).
`private static class`	`IndexData.NodeEntry` A single node entry in an index (points to a sub-page in the index)
`static class`	`IndexData.PendingChange` Utility class which maintains information about a pending index update.
`private static class`	`IndexData.Position` Simple value object for maintaining some cursor state.
`private class`	`IndexData.ReadOnlyColumnDescriptor` ColumnDescriptor for columns which we cannot currently write.
`private static class`	`IndexData.RootDataPage` Simple implementation of a DataPage
`private class`	`IndexData.UpdateRowPendingChange` PendingChange for a row update (which is essentially a deletion followed by an addition).

Field Summary

Fields
Modifier and Type	Field and Description
`private java.util.List<IndexData.ColumnDescriptor>`	`_columns` List of columns and flags
`private ByteUtil.ByteStream`	`_entryBuffer` temp buffer used to create index entries
`private TempBufferHolder`	`_indexBufferH` temp buffer used to read/write the index pages
`private java.util.List<Index>`	`_indexes` the logical indexes which this index data backs
`private byte`	`_indexFlags` flags for this index
`private boolean`	`_initialized` `true` if the index entries have been initialized, `false` otherwise
`private int`	`_maxPageEntrySize` max size for all the entries written to a given index data page
`private int`	`_modCount` modification count for the table, keeps cursors up-to-date
`private java.lang.String`	`_name` name, generated on demand
`private int`	`_number` 0-based index data number
`private UsageMap`	`_ownedPages` Usage map of pages that this index owns
`private IndexPageCache`	`_pageCache` Cache which manages the index pages
`private boolean`	`_primaryKey` whether or not this index data is backing a primary key logical index
`private int`	`_rootPageNumber` Page number of the root index data
`private TableImpl`	`_table` owning table
`private int`	`_uniqueEntryCount` The number of unique entries which have been added to this index.
`private int`	`_uniqueEntryCountOffset` offset within the tableDefinition buffer of the uniqueEntryCount for this index
`private java.lang.String`	`_unsupportedReason` if non-null, the reason why we cannot create entries for this index
`static byte`	`ASCENDING_COLUMN_FLAG`
`static java.util.Comparator<byte[]>`	`BYTE_CODE_COMPARATOR`
`(package private) static short`	`COLUMN_UNUSED`
`protected static byte[]`	`EMPTY_PREFIX`
`private static java.nio.ByteOrder`	`ENTRY_BYTE_ORDER`
`static IndexData.Entry`	`FIRST_ENTRY` special entry which is less than any other entry
`static byte`	`IGNORE_NULLS_INDEX_FLAG`
`protected static int`	`INVALID_INDEX_PAGE_NUMBER`
`static IndexData.Entry`	`LAST_ENTRY` special entry which is greater than any other entry
`protected static org.apache.commons.logging.Log`	`LOG`
`private static int`	`MAGIC_INDEX_NUMBER`
`static int`	`MAX_COLUMNS` Max number of columns in an index
`static java.lang.Object`	`MAX_VALUE` special object which will always be greater than any other value, when searching for an index entry range in a multi-value index
`static java.lang.Object`	`MIN_VALUE` special object which will always be greater than any other value, when searching for an index entry range in a multi-value index
`private static IndexData.DataPage`	`NEW_ROOT_DATA_PAGE`
`static byte`	`SPECIAL_INDEX_FLAG`
`static byte`	`UNIQUE_INDEX_FLAG`
`static byte`	`UNKNOWN_INDEX_FLAG`

Constructor Summary

Constructors
Modifier Constructor and Description

protected IndexData(TableImpl table, int number, int uniqueEntryCount, int uniqueEntryCountOffset)

Constructors
Modifier	Constructor and Description
`protected`	`IndexData(TableImpl table, int number, int uniqueEntryCount, int uniqueEntryCountOffset)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) void`	`addIndex(Index index)` Adds a logical index which this data is backing.
`(package private) void`	`addOwnedPage(int pageNumber)`
`private static int`	`calcMaxPageEntrySize(JetFormat format)` Returns the maximum amount of entry data which can be encoded on any index page.
`private void`	`commitAddRow(IndexData.Entry newEntry, IndexData.DataPage dataPage, int idx, boolean isDupeEntry, IndexData.Entry oldEntry)` Completes a prepared row addition.
`static void`	`commitAll(IndexData.PendingChange change)`
`java.lang.Object[]`	`constructIndexRow(java.util.Map<java.lang.String,?> row)` Constructs an array of values appropriate for this index from the given column values.
`java.lang.Object[]`	`constructIndexRow(java.lang.String colName, java.lang.Object value)` Constructs an array of values appropriate for this index from the given column value.
`java.lang.Object[]`	`constructIndexRowFromEntry(java.lang.Object... values)` Constructs an array of values appropriate for this index from the given column values, expected to match the columns for this index.
`private int`	`countNullValues(java.lang.Object[] values)` Determines the number of `null` values for this index from the given row.
`static IndexData`	`create(TableImpl table, java.nio.ByteBuffer tableBuffer, int number, JetFormat format)` Creates an IndexData appropriate for the given table, using information from the given table definition buffer.
`private byte[]`	`createEntryBytes(java.lang.Object[] values)` Creates the entry bytes for a row of values.
`private static IndexData.Entry`	`createSpecialEntry(RowIdImpl rowId)` Creates one of the special index entries.
`IndexData.EntryCursor`	`cursor()` Gets a new cursor for this index.
`IndexData.EntryCursor`	`cursor(java.lang.Object[] startRow, boolean startInclusive, java.lang.Object[] endRow, boolean endInclusive)` Gets a new cursor for this index, narrowed to the range defined by the given startRow and endRow.
`void`	`deleteRow(java.lang.Object[] row, RowIdImpl rowId)` Removes a row from this index
`private IndexData.Entry`	`deleteRowImpl(java.lang.Object[] row, RowIdImpl rowId)`
`private static IndexData.EntryType`	`determineEntryType(byte[] entryBytes, RowIdImpl rowId)` Returns the EntryType based on the given entry info.
`private static byte[]`	`encodeNumberColumnValue(java.lang.Object value, ColumnImpl column)` Writes the value of the given column type to a byte array and returns it.
`protected IndexData.DataPage`	`findDataPage(IndexData.Entry entry)` Finds the data page for the given entry.
`private IndexData.Position`	`findEntryPosition(IndexData.Entry entry)`
`private static byte[]`	`flipBytes(byte[] value)` Flips all the bits in the byte array.
`(package private) static byte[]`	`flipBytes(byte[] value, int offset, int length)` Flips the bits in the specified bytes in the byte array.
`private static byte[]`	`flipFirstBitInByte(byte[] value, int index)` Flips the first bit in the byte at the given index.
`java.util.List<IndexData.ColumnDescriptor>`	`getColumns()` Returns the Columns for this index (unmodifiable)
`protected IndexData.DataPage`	`getDataPage(int pageNumber)` Gets the data page for the pageNumber.
`int`	`getEntryCount()` Returns the number of index entries in the index.
`JetFormat`	`getFormat()`
`int`	`getIndexDataNumber()`
`java.util.List<Index>`	`getIndexes()`
`byte`	`getIndexFlags()`
`protected int`	`getMaxPageEntrySize()`
`java.lang.String`	`getName()`
`private IndexData.Position`	`getNextPosition(IndexData.Position curPos)`
`int`	`getOwnedPageCount()` Returns the number of database pages owned by this index data.
`PageChannel`	`getPageChannel()`
`private IndexData.Position`	`getPreviousPosition(IndexData.Position curPos)` Returns the Position before the given one, or `null` if none.
`Index`	`getPrimaryIndex()`
`protected int`	`getRootPageNumber()`
`TableImpl`	`getTable()`
`private java.nio.ByteBuffer`	`getTempEntryBuffer(java.nio.ByteBuffer indexPage, int entryLen, byte[] valuePrefix, TempBufferHolder tmpEntryBufferH)` Returns an entry buffer containing the relevant data for an entry given the valuePrefix.
`int`	`getUniqueEntryCount()`
`int`	`getUniqueEntryCountOffset()`
`(package private) java.lang.String`	`getUnsupportedReason()`
`void`	`initialize()` Forces initialization of this index (actual parsing of index pages).
`protected boolean`	`isBackingPrimaryKey()`
`boolean`	`isInitialized()` Whether or not the complete index state has been read.
`private boolean`	`isLeafPage(java.nio.ByteBuffer buffer)` Determines if the given index page is a leaf or node page.
`boolean`	`isUnique()` Whether or not index entries must be unique.
`protected static int`	`missingIndexToInsertionPoint(int idx)` Returns the valid insertion point for an index indicating a missing entry.
`private IndexData.ColumnDescriptor`	`newColumnDescriptor(ColumnImpl col, byte flags)` Constructs a ColumnDescriptor of the relevant type for the given Column.
`private static IndexData.Entry`	`newEntry(java.nio.ByteBuffer buffer, int entryLength, boolean isLeaf)` Returns a new Entry of the correct type for the given data and page type.
`private IndexData.PendingChange`	`prepareAddEntry(IndexData.Entry newEntry, boolean isNullEntry, java.lang.Object[] row, IndexData.AddRowPendingChange change)` Adds an entry to the correct index dataPage, maintaining the order.
`private IndexData.PendingChange`	`prepareAddRow(java.lang.Object[] row, RowIdImpl rowId, IndexData.AddRowPendingChange change)`
`IndexData.PendingChange`	`prepareAddRow(java.lang.Object[] row, RowIdImpl rowId, IndexData.PendingChange nextChange)` Prepares to add a row to this index.
`IndexData.PendingChange`	`prepareUpdateRow(java.lang.Object[] oldRow, RowIdImpl rowId, java.lang.Object[] newRow, IndexData.PendingChange nextChange)` Prepares to update a row in this index.
`void`	`read(java.nio.ByteBuffer tableBuffer, java.util.List<ColumnImpl> availableColumns)` Read the rest of the index info from a tableBuffer
`protected void`	`readDataPage(IndexData.DataPage dataPage)` Reads an index page, populating the correct collection based on the page type (node or leaf).
`private IndexData.Entry`	`removeEntry(IndexData.Entry oldEntry)` Removes an entry from the relevant index dataPage, maintaining the order.
`static void`	`rollbackAll(IndexData.PendingChange change)`
`private void`	`rollbackDeletedRow(IndexData.Entry removedEntry)` Undoes a previous row deletion.
`private void`	`setUnsupportedReason(java.lang.String reason, ColumnImpl col)`
`boolean`	`shouldIgnoreNulls()` Whether or not `null` values are actually recorded in the index.
`java.lang.String`	`toString()`
`void`	`update()` Writes the current index state to the database.
`void`	`validate()` Used by unit tests to validate the internal status of the index.
`(package private) java.lang.String`	`withErrorContext(java.lang.String msg)`
`private static java.lang.String`	`withErrorContext(java.lang.String msg, DatabaseImpl db, java.lang.String tableName, java.lang.String idxName)`
`protected static void`	`writeDataPage(java.nio.ByteBuffer buffer, IndexData.DataPage dataPage, int tdefPageNumber, JetFormat format)` Writes the data page info to the given buffer.
`protected void`	`writeDataPage(IndexData.DataPage dataPage)` Write the given index page out to a buffer
`protected static void`	`writeDefinitions(TableCreator creator, java.nio.ByteBuffer buffer)` Writes the index definitions into a table definition buffer.
`private static void`	`writeGeneralBinaryEntry(byte[] valueBytes, boolean isAsc, ByteUtil.ByteStream bout)` Writes a binary value using the general binary entry encoding rules.
`protected static void`	`writeRowCountDefinitions(TableCreator creator, java.nio.ByteBuffer buffer)` Writes the index row count definitions into a table definition buffer.

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

Field Detail
- LOG
```
protected static final org.apache.commons.logging.Log LOG
```
- FIRST_ENTRY
```
public static final IndexData.Entry FIRST_ENTRY
```
  special entry which is less than any other entry
- LAST_ENTRY
```
public static final IndexData.Entry LAST_ENTRY
```
  special entry which is greater than any other entry
- MAX_VALUE
```
public static final java.lang.Object MAX_VALUE
```
  special object which will always be greater than any other value, when searching for an index entry range in a multi-value index
- MIN_VALUE
```
public static final java.lang.Object MIN_VALUE
```
  special object which will always be greater than any other value, when searching for an index entry range in a multi-value index
- NEW_ROOT_DATA_PAGE
```
private static final IndexData.DataPage NEW_ROOT_DATA_PAGE
```
- INVALID_INDEX_PAGE_NUMBER
```
protected static final int INVALID_INDEX_PAGE_NUMBER
```
  See Also:
  
  Constant Field Values
- MAX_COLUMNS
```
public static final int MAX_COLUMNS
```
  Max number of columns in an index
  
  See Also:
  
  Constant Field Values
- EMPTY_PREFIX
```
protected static final byte[] EMPTY_PREFIX
```
- COLUMN_UNUSED
```
static final short COLUMN_UNUSED
```
  See Also:
  
  Constant Field Values
- ASCENDING_COLUMN_FLAG
```
public static final byte ASCENDING_COLUMN_FLAG
```
  See Also:
  
  Constant Field Values
- UNIQUE_INDEX_FLAG
```
public static final byte UNIQUE_INDEX_FLAG
```
  See Also:
  
  Constant Field Values
- IGNORE_NULLS_INDEX_FLAG
```
public static final byte IGNORE_NULLS_INDEX_FLAG
```
  See Also:
  
  Constant Field Values
- SPECIAL_INDEX_FLAG
```
public static final byte SPECIAL_INDEX_FLAG
```
  See Also:
  
  Constant Field Values
- UNKNOWN_INDEX_FLAG
```
public static final byte UNKNOWN_INDEX_FLAG
```
  See Also:
  
  Constant Field Values
- MAGIC_INDEX_NUMBER
```
private static final int MAGIC_INDEX_NUMBER
```
  See Also:
  
  Constant Field Values
- ENTRY_BYTE_ORDER
```
private static final java.nio.ByteOrder ENTRY_BYTE_ORDER
```
- BYTE_CODE_COMPARATOR
```
public static final java.util.Comparator<byte[]> BYTE_CODE_COMPARATOR
```
- _name
```
private java.lang.String _name
```
  name, generated on demand
- _table
```
private final TableImpl _table
```
  owning table
- _number
```
private final int _number
```
  0-based index data number
- _rootPageNumber
```
private int _rootPageNumber
```
  Page number of the root index data
- _uniqueEntryCountOffset
```
private final int _uniqueEntryCountOffset
```
  offset within the tableDefinition buffer of the uniqueEntryCount for this index
- _uniqueEntryCount
```
private int _uniqueEntryCount
```
  The number of unique entries which have been added to this index. note, however, that it is never decremented, only incremented (as observed in Access).
- _columns
```
private final java.util.List<IndexData.ColumnDescriptor> _columns
```
  List of columns and flags
- _indexes
```
private final java.util.List<Index> _indexes
```
  the logical indexes which this index data backs
- _indexFlags
```
private byte _indexFlags
```
  flags for this index
- _ownedPages
```
private UsageMap _ownedPages
```
  Usage map of pages that this index owns
- _initialized
```
private boolean _initialized
```
  true if the index entries have been initialized, false otherwise
- _modCount
```
private int _modCount
```
  modification count for the table, keeps cursors up-to-date
- _indexBufferH
```
private final TempBufferHolder _indexBufferH
```
  temp buffer used to read/write the index pages
- _entryBuffer
```
private ByteUtil.ByteStream _entryBuffer
```
  temp buffer used to create index entries
- _maxPageEntrySize
```
private final int _maxPageEntrySize
```
  max size for all the entries written to a given index data page
- _primaryKey
```
private boolean _primaryKey
```
  whether or not this index data is backing a primary key logical index
- _unsupportedReason
```
private java.lang.String _unsupportedReason
```
  if non-null, the reason why we cannot create entries for this index
- _pageCache
```
private final IndexPageCache _pageCache
```
  Cache which manages the index pages

Constructor Detail

IndexData

protected IndexData(TableImpl table,
                    int number,
                    int uniqueEntryCount,
                    int uniqueEntryCountOffset)

Method Detail

create

public static IndexData create(TableImpl table,
                               java.nio.ByteBuffer tableBuffer,
                               int number,
                               JetFormat format)
                        throws java.io.IOException

Creates an IndexData appropriate for the given table, using information from the given table definition buffer.

Throws:: java.io.IOException

getName
```
public java.lang.String getName()
```

getTable
```
public TableImpl getTable()
```

getFormat
```
public JetFormat getFormat()
```

getPageChannel
```
public PageChannel getPageChannel()
```

getPrimaryIndex
```
public Index getPrimaryIndex()
```
Returns:

the "main" logical index which is backed by this data.

getIndexes
```
public java.util.List<Index> getIndexes()
```
Returns:

All of the Indexes backed by this data (unmodifiable List)

addIndex
```
void addIndex(Index index)
```
Adds a logical index which this data is backing.

getIndexFlags
```
public byte getIndexFlags()
```

getIndexDataNumber
```
public int getIndexDataNumber()
```

getUniqueEntryCount
```
public int getUniqueEntryCount()
```

getUniqueEntryCountOffset

public int getUniqueEntryCountOffset()

isBackingPrimaryKey

protected boolean isBackingPrimaryKey()

shouldIgnoreNulls
```
public boolean shouldIgnoreNulls()
```
Whether or not null values are actually recorded in the index.

isUnique
```
public boolean isUnique()
```
Whether or not index entries must be unique.
Some notes about uniqueness:
- Access does not seem to consider multiple null entries invalid for a unique index
- text indexes collapse case, and Access seems to compare only the index entry bytes, therefore two strings which differ only in case will violate the unique constraint

getColumns

public java.util.List<IndexData.ColumnDescriptor> getColumns()

Returns the Columns for this index (unmodifiable)

isInitialized
```
public boolean isInitialized()
```
Whether or not the complete index state has been read.

getRootPageNumber
```
protected int getRootPageNumber()
```

setUnsupportedReason

private void setUnsupportedReason(java.lang.String reason,
                                  ColumnImpl col)

getUnsupportedReason

java.lang.String getUnsupportedReason()

getMaxPageEntrySize
```
protected int getMaxPageEntrySize()
```

getOwnedPageCount
```
public int getOwnedPageCount()
```
Returns the number of database pages owned by this index data.

addOwnedPage

void addOwnedPage(int pageNumber)
           throws java.io.IOException

Throws:: java.io.IOException

validate
```
public void validate()
              throws java.io.IOException
```
Used by unit tests to validate the internal status of the index.

Throws:

java.io.IOException

getEntryCount
```
public int getEntryCount()
                  throws java.io.IOException
```
Returns the number of index entries in the index. Only called by unit tests.
Forces index initialization.

Throws:

java.io.IOException

initialize
```
public void initialize()
                throws java.io.IOException
```
Forces initialization of this index (actual parsing of index pages). normally, the index will not be initialized until the entries are actually needed.

Throws:

java.io.IOException

update
```
public void update()
            throws java.io.IOException
```
Writes the current index state to the database.
Forces index initialization.

Throws:

java.io.IOException

read
```
public void read(java.nio.ByteBuffer tableBuffer,
                 java.util.List<ColumnImpl> availableColumns)
          throws java.io.IOException
```
Read the rest of the index info from a tableBuffer

Parameters:

tableBuffer - table definition buffer to read from initial info

availableColumns - Columns that this index may use

Throws:

java.io.IOException

writeRowCountDefinitions
```
protected static void writeRowCountDefinitions(TableCreator creator,
                                               java.nio.ByteBuffer buffer)
```
Writes the index row count definitions into a table definition buffer.

Parameters:

creator - description of the indexes to write

buffer - Buffer to write to

writeDefinitions

protected static void writeDefinitions(TableCreator creator,
                                       java.nio.ByteBuffer buffer)
                                throws java.io.IOException

Writes the index definitions into a table definition buffer.

Parameters:: creator - description of the indexes to write; buffer - Buffer to write to
Throws:: java.io.IOException

prepareAddRow

public IndexData.PendingChange prepareAddRow(java.lang.Object[] row,
                                             RowIdImpl rowId,
                                             IndexData.PendingChange nextChange)
                                      throws java.io.IOException

Prepares to add a row to this index. All constraints are checked before this method returns.

Forces index initialization.

Parameters:: row - Row to add; rowId - rowId of the row to be added
Returns:: a PendingChange which can complete the addition or roll it back
Throws:: java.io.IOException

prepareAddRow

private IndexData.PendingChange prepareAddRow(java.lang.Object[] row,
                                              RowIdImpl rowId,
                                              IndexData.AddRowPendingChange change)
                                       throws java.io.IOException

Throws:: java.io.IOException

prepareAddEntry

private IndexData.PendingChange prepareAddEntry(IndexData.Entry newEntry,
                                                boolean isNullEntry,
                                                java.lang.Object[] row,
                                                IndexData.AddRowPendingChange change)
                                         throws java.io.IOException

Adds an entry to the correct index dataPage, maintaining the order.

Throws:: java.io.IOException

commitAddRow

private void commitAddRow(IndexData.Entry newEntry,
                          IndexData.DataPage dataPage,
                          int idx,
                          boolean isDupeEntry,
                          IndexData.Entry oldEntry)
                   throws java.io.IOException

Completes a prepared row addition.

Throws:: java.io.IOException

prepareUpdateRow

public IndexData.PendingChange prepareUpdateRow(java.lang.Object[] oldRow,
                                                RowIdImpl rowId,
                                                java.lang.Object[] newRow,
                                                IndexData.PendingChange nextChange)
                                         throws java.io.IOException

Prepares to update a row in this index. All constraints are checked before this method returns.

Forces index initialization.

Parameters:: oldRow - Row to be removed; newRow - Row to be added; rowId - rowId of the row to be updated
Returns:: a PendingChange which can complete the update or roll it back
Throws:: java.io.IOException

deleteRow
```
public void deleteRow(java.lang.Object[] row,
                      RowIdImpl rowId)
               throws java.io.IOException
```
Removes a row from this index
Forces index initialization.

Parameters:

row - Row to remove

rowId - rowId of the row to be removed

Throws:

java.io.IOException

deleteRowImpl

private IndexData.Entry deleteRowImpl(java.lang.Object[] row,
                                      RowIdImpl rowId)
                               throws java.io.IOException

Throws:: java.io.IOException

rollbackDeletedRow

private void rollbackDeletedRow(IndexData.Entry removedEntry)
                         throws java.io.IOException

Undoes a previous row deletion.

Throws:: java.io.IOException

removeEntry
```
private IndexData.Entry removeEntry(IndexData.Entry oldEntry)
                             throws java.io.IOException
```
Removes an entry from the relevant index dataPage, maintaining the order. Will search by RowId if entry is not found (in case a partial entry was provided).

Throws:

java.io.IOException

commitAll

public static void commitAll(IndexData.PendingChange change)
                      throws java.io.IOException

Throws:: java.io.IOException

rollbackAll

public static void rollbackAll(IndexData.PendingChange change)
                        throws java.io.IOException

Throws:: java.io.IOException

cursor

public IndexData.EntryCursor cursor()
                             throws java.io.IOException

Gets a new cursor for this index.

Forces index initialization.

Throws:: java.io.IOException

cursor
```
public IndexData.EntryCursor cursor(java.lang.Object[] startRow,
                                    boolean startInclusive,
                                    java.lang.Object[] endRow,
                                    boolean endInclusive)
                             throws java.io.IOException
```
Gets a new cursor for this index, narrowed to the range defined by the given startRow and endRow.
Forces index initialization.

Parameters:

startRow - the first row of data for the cursor, or null for the first entry

startInclusive - whether or not startRow is inclusive or exclusive

endRow - the last row of data for the cursor, or null for the last entry

endInclusive - whether or not endRow is inclusive or exclusive

Throws:

java.io.IOException

findEntryPosition

private IndexData.Position findEntryPosition(IndexData.Entry entry)
                                      throws java.io.IOException

Throws:: java.io.IOException

getNextPosition

private IndexData.Position getNextPosition(IndexData.Position curPos)
                                    throws java.io.IOException

Throws:: java.io.IOException

getPreviousPosition

private IndexData.Position getPreviousPosition(IndexData.Position curPos)
                                        throws java.io.IOException

Returns the Position before the given one, or null if none.

Throws:: java.io.IOException

missingIndexToInsertionPoint
```
protected static int missingIndexToInsertionPoint(int idx)
```
Returns the valid insertion point for an index indicating a missing entry.

constructIndexRowFromEntry
```
public java.lang.Object[] constructIndexRowFromEntry(java.lang.Object... values)
```
Constructs an array of values appropriate for this index from the given column values, expected to match the columns for this index.

Returns:

the appropriate sparse array of data

Throws:

java.lang.IllegalArgumentException - if the wrong number of values are provided

constructIndexRow
```
public java.lang.Object[] constructIndexRow(java.lang.String colName,
                                            java.lang.Object value)
```
Constructs an array of values appropriate for this index from the given column value.

Returns:

the appropriate sparse array of data or null if not all columns for this index were provided

constructIndexRow
```
public java.lang.Object[] constructIndexRow(java.util.Map<java.lang.String,?> row)
```
Constructs an array of values appropriate for this index from the given column values.

Returns:

the appropriate sparse array of data or null if not all columns for this index were provided

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

writeDataPage

protected void writeDataPage(IndexData.DataPage dataPage)
                      throws java.io.IOException

Write the given index page out to a buffer

Throws:: java.io.IOException

writeDataPage

protected static void writeDataPage(java.nio.ByteBuffer buffer,
                                    IndexData.DataPage dataPage,
                                    int tdefPageNumber,
                                    JetFormat format)
                             throws java.io.IOException

Writes the data page info to the given buffer.

Throws:: java.io.IOException

readDataPage
```
protected void readDataPage(IndexData.DataPage dataPage)
                     throws java.io.IOException
```
Reads an index page, populating the correct collection based on the page type (node or leaf).

Throws:

java.io.IOException

newEntry

private static IndexData.Entry newEntry(java.nio.ByteBuffer buffer,
                                        int entryLength,
                                        boolean isLeaf)
                                 throws java.io.IOException

Returns a new Entry of the correct type for the given data and page type.

Throws:: java.io.IOException

getTempEntryBuffer

private java.nio.ByteBuffer getTempEntryBuffer(java.nio.ByteBuffer indexPage,
                                               int entryLen,
                                               byte[] valuePrefix,
                                               TempBufferHolder tmpEntryBufferH)

Returns an entry buffer containing the relevant data for an entry given the valuePrefix.

isLeafPage

private boolean isLeafPage(java.nio.ByteBuffer buffer)
                    throws java.io.IOException

Determines if the given index page is a leaf or node page.

Throws:: java.io.IOException

countNullValues
```
private int countNullValues(java.lang.Object[] values)
```
Determines the number of null values for this index from the given row.

createEntryBytes

private byte[] createEntryBytes(java.lang.Object[] values)
                         throws java.io.IOException

Creates the entry bytes for a row of values.

Throws:: java.io.IOException

findDataPage

protected IndexData.DataPage findDataPage(IndexData.Entry entry)
                                   throws java.io.IOException

Finds the data page for the given entry.

Throws:: java.io.IOException

getDataPage

protected IndexData.DataPage getDataPage(int pageNumber)
                                  throws java.io.IOException

Gets the data page for the pageNumber.

Throws:: java.io.IOException

flipFirstBitInByte

private static byte[] flipFirstBitInByte(byte[] value,
                                         int index)

Flips the first bit in the byte at the given index.

flipBytes

private static byte[] flipBytes(byte[] value)

Flips all the bits in the byte array.

flipBytes

static byte[] flipBytes(byte[] value,
                        int offset,
                        int length)

Flips the bits in the specified bytes in the byte array.

encodeNumberColumnValue

private static byte[] encodeNumberColumnValue(java.lang.Object value,
                                              ColumnImpl column)
                                       throws java.io.IOException

Writes the value of the given column type to a byte array and returns it.

Throws:: java.io.IOException

writeGeneralBinaryEntry

private static void writeGeneralBinaryEntry(byte[] valueBytes,
                                            boolean isAsc,
                                            ByteUtil.ByteStream bout)

Writes a binary value using the general binary entry encoding rules.

createSpecialEntry

private static IndexData.Entry createSpecialEntry(RowIdImpl rowId)

Creates one of the special index entries.

newColumnDescriptor

private IndexData.ColumnDescriptor newColumnDescriptor(ColumnImpl col,
                                                       byte flags)
                                                throws java.io.IOException

Constructs a ColumnDescriptor of the relevant type for the given Column.

Throws:: java.io.IOException

determineEntryType

private static IndexData.EntryType determineEntryType(byte[] entryBytes,
                                                      RowIdImpl rowId)

Returns the EntryType based on the given entry info.

calcMaxPageEntrySize
```
private static int calcMaxPageEntrySize(JetFormat format)
```
Returns the maximum amount of entry data which can be encoded on any index page.

withErrorContext

java.lang.String withErrorContext(java.lang.String msg)

withErrorContext

private static java.lang.String withErrorContext(java.lang.String msg,
                                                 DatabaseImpl db,
                                                 java.lang.String tableName,
                                                 java.lang.String idxName)

Class IndexData

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

FIRST_ENTRY

LAST_ENTRY

MAX_VALUE

MIN_VALUE

NEW_ROOT_DATA_PAGE

INVALID_INDEX_PAGE_NUMBER

MAX_COLUMNS

EMPTY_PREFIX

COLUMN_UNUSED

ASCENDING_COLUMN_FLAG

UNIQUE_INDEX_FLAG

IGNORE_NULLS_INDEX_FLAG

SPECIAL_INDEX_FLAG

UNKNOWN_INDEX_FLAG

MAGIC_INDEX_NUMBER

ENTRY_BYTE_ORDER

BYTE_CODE_COMPARATOR

_name

_table

_number

_rootPageNumber

_uniqueEntryCountOffset

_uniqueEntryCount

_columns

_indexes

_indexFlags

_ownedPages

_initialized

_modCount

_indexBufferH

_entryBuffer

_maxPageEntrySize

_primaryKey

_unsupportedReason

_pageCache

Constructor Detail

IndexData

Method Detail

create

getName

getTable

getFormat

getPageChannel

getPrimaryIndex

getIndexes

addIndex

getIndexFlags

getIndexDataNumber

getUniqueEntryCount

getUniqueEntryCountOffset

isBackingPrimaryKey

shouldIgnoreNulls

isUnique

getColumns

isInitialized

getRootPageNumber

setUnsupportedReason

getUnsupportedReason

getMaxPageEntrySize

getOwnedPageCount

addOwnedPage

validate

getEntryCount

initialize

update

read

writeRowCountDefinitions

writeDefinitions

prepareAddRow

prepareAddRow

prepareAddEntry

commitAddRow