import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 * Row might have changed from memory to disk or indexes added
 */
public void delete(Session session, Row row) {

    NodeAVL node  = ((RowAVL) row).getNode(0);
    int     count = 0;

    while (node != null) {
        count++;

        node = node.nNext;
    }

    if ((isCached ^ !row.isMemory()) || count != indexList.length) {
        row = ((Table) table).getDeleteRowFromLog(session, row.getData());
    }

    if (row != null) {
        super.delete(session, row);
    }
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
void dropIndexFromRows(Index primaryIndex, Index oldIndex) {

        RowIterator it       = primaryIndex.firstRow(this);
        int         position = oldIndex.getPosition() - 1;

        while (it.hasNext()) {
            Row     row      = it.getNextRow();
            int     i        = position - 1;
            NodeAVL backnode = ((RowAVL) row).getNode(0);

            while (i-- > 0) {
                backnode = backnode.nNext;
            }

            backnode.nNext = backnode.nNext.nNext;
        }

        it.release();
    }
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
void dropIndexFromRows(Index primaryIndex,
                       Index oldIndex) {

    RowIterator it       = primaryIndex.firstRow(this);
    int         position = oldIndex.getPosition() - 1;

    while (it.hasNext()) {
        Row     row      = it.getNextRow();
        int     i        = position - 1;
        NodeAVL backnode = ((RowAVL) row).getNode(0);

        while (i-- > 0) {
            backnode = backnode.nNext;
        }

        backnode.nNext = backnode.nNext.nNext;
    }
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
public CachedObject getAccessor(Index key) {

        NodeAVL node = (NodeAVL) accessorList[key.getPosition()];

        if (node == null) {
            return null;
        }

        if (!node.isInMemory()) {
            RowAVL row = (RowAVL) get(node.getPos(), false);

            node                            = row.getNode(key.getPosition());
            accessorList[key.getPosition()] = node;
        }

        return node;
    }
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 *  Constructor for MEMORY table Row. The result is a Row with Nodes that
 *  are not yet linked with other Nodes in the AVL indexes.
 */
public RowAVL(TableBase t, Object[] o) {

    int index = t.getIndexCount();

    nPrimaryNode = new NodeAVLMemory(this);

    NodeAVL n = nPrimaryNode;

    for (int i = 1; i < index; i++) {
        n.nNext = new NodeAVLMemory(this);
        n       = n.nNext;
    }

    tableId = t.getId();
    rowData = o;
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 *  Constructor when read from the disk into the Cache.
 *
 * @param t table
 * @param in data source
 * @throws IOException
 */
public RowAVLDisk(TableBase t,
                  RowInputInterface in) throws IOException {

    tTable      = t;
    position    = in.getPos();
    storageSize = in.getSize();

    int indexcount = t.getIndexCount();

    nPrimaryNode = new NodeAVLDisk(this, in, 0);

    NodeAVL n = nPrimaryNode;

    for (int i = 1; i < indexcount; i++) {
        n.nNext = new NodeAVLDisk(this, in, i);
        n       = n.nNext;
    }

    rowData = in.readData(tTable.getColumnTypes());
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 * Row might have changed from memory to disk or indexes added
 */
public void delete(Session session, Row row) {

    NodeAVL node  = ((RowAVL) row).getNode(0);
    int     count = 0;

    while (node != null) {
        count++;

        node = node.nNext;
    }

    if ((isCached && row.isMemory()) || count != indexList.length) {
        row = ((Table) table).getDeleteRowFromLog(session, row.getData());
    }

    if (row != null) {
        super.delete(session, row);
    }
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
public void indexRow(Session session, Row row) {

        NodeAVL node  = ((RowAVL) row).getNode(0);
        int     count = 0;

        while (node != null) {
            count++;

            node = node.nNext;
        }

        if (count != indexList.length) {
            resetAccessorKeys(table.getIndexList());
            ((RowAVL) row).setNewNodes(this);
        }

        super.indexRow(session, row);
    }
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
void dropIndexFromRows(Index primaryIndex, Index oldIndex) {

        RowIterator it       = primaryIndex.firstRow(this);
        int         position = oldIndex.getPosition() - 1;

        while (it.hasNext()) {
            Row     row      = it.getNextRow();
            int     i        = position - 1;
            NodeAVL backnode = ((RowAVL) row).getNode(0);

            while (i-- > 0) {
                backnode = backnode.nNext;
            }

            backnode.nNext = backnode.nNext.nNext;
        }
    }
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
public final void changeToDiskTable(Session session) {

        cache =
            session.sessionData.persistentStoreCollection
                .getSessionDataCache();
        maxMemoryRowCount = Integer.MAX_VALUE;

        if (cache == null) {
            return;
        }

        tableSpace =
            cache.spaceManager.getTableSpace(DataSpaceManager.tableIdDefault);
        isCached = true;

        cache.adjustStoreCount(1);

        if (elementCount.get() == 0) {
            return;
        }

        IndexAVL    idx      = (IndexAVL) indexList[0];
        NodeAVL     root     = (NodeAVL) accessorList[0];
        RowIterator iterator = table.rowIterator(this);

        ArrayUtil.fillArray(accessorList, null);
        ArrayUtil.fillArray(nullsList, false);
        elementCount.set(0);

        while (iterator.hasNext()) {
            Row row = iterator.getNextRow();
            Row newRow = (Row) getNewCachedObject(session, row.getData(),
                                                  false);

            indexRow(session, newRow);
        }

        idx.unlinkNodes(root);
    }
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 * Used with memory indexes
 */
void destroy() {

    if (indexList.length == 0) {
        return;
    }

    IndexAVL idx  = (IndexAVL) indexList[0];
    NodeAVL  root = (NodeAVL) accessorList[0];

    idx.unlinkNodes(root);
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 *  Used when data is read from the disk into the Cache the first time.
 *  New Nodes are created which are then indexed.
 */
public void setNewNodes(PersistentStore store) {

    int index = store.getAccessorKeys().length;

    nPrimaryNode = new NodeAVL(this);

    NodeAVL n = nPrimaryNode;

    for (int i = 1; i < index; i++) {
        n.nNext = new NodeAVL(this);
        n       = n.nNext;
    }
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 * Returns the Node for a given Index, using the ordinal position of the
 * Index within the Table Object.
 */
public NodeAVL getNode(int index) {

    NodeAVL n = nPrimaryNode;

    while (index-- > 0) {
        n = n.nNext;
    }

    return n;
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 *  Returns the Node for the next Index on this database row, given the
 *  Node for any Index.
 */
NodeAVL getNextNode(NodeAVL n) {

    if (n == null) {
        n = nPrimaryNode;
    } else {
        n = n.nNext;
    }

    return n;
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 *  Used when data is read from the disk into the Cache the first time.
 *  New Nodes are created which are then indexed.
 */
void setNewNodes() {

    int index = tTable.getIndexCount();

    nPrimaryNode = new NodeAVLMemoryPointer(this);

    NodeAVL n = nPrimaryNode;

    for (int i = 1; i < index; i++) {
        n.nNext = new NodeAVLMemoryPointer(this);
        n       = n.nNext;
    }
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 * Sets the file position for the row and registers the row with
 * the table.
 *
 * @param pos position in data file
 */
public void setPos(int pos) {

    position = pos;

    NodeAVL n = nPrimaryNode;

    while (n != null) {
        ((NodeAVLMemoryPointer) n).iData = position;
        n                                = n.nNext;
    }
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
public void clearNonPrimaryNodes() {

        NodeAVL n = nPrimaryNode.nNext;

        while (n != null) {
            n.delete();

            n.iBalance = 0;
            n          = n.nNext;
        }
    }
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
public void restore() {

        NodeAVL n = nPrimaryNode;

        while (n != null) {
            n.iBalance = 0;
            n          = n.nNext;
        }
    }
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 * Sets the file position for the row
 *
 * @param pos position in data file
 */
public void setPos(int pos) {

    position = pos;

    NodeAVL n = nPrimaryNode;

    while (n != null) {
        ((NodeAVLDisk) n).iData = position;
        n                       = n.nNext;
    }
}
 

import org.hsqldb.index.NodeAVL; //导入依赖的package包/类
/**
 * used in CachedDataRow
 */
void setNewNodes() {

    int indexcount = tTable.getIndexCount();

    nPrimaryNode = new NodeAVLDisk(this, 0);

    NodeAVL n = nPrimaryNode;

    for (int i = 1; i < indexcount; i++) {
        n.nNext = new NodeAVLDisk(this, i);
        n       = n.nNext;
    }
}