import org.hsqldb.Row; //导入依赖的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.Row; //导入依赖的package包/类
private void addAdjusted(Object[] data, int[] columnMap) {

        try {
            if (columnMap == null) {
                data = (Object[]) ArrayUtil.resizeArrayIfDifferent(data,
                        table.getColumnCount());
            } else {
                Object[] newData = new Object[table.getColumnCount()];

                ArrayUtil.projectRow(data, columnMap, newData);

                data = newData;
            }

            Row row = (Row) store.getNewCachedObject(session, data);

            store.indexRow(null, row);

            size++;
        } catch (HsqlException e) {}
    }
 

import org.hsqldb.Row; //导入依赖的package包/类
public CachedObject getNewCachedObject(Session session, Object object,
                                       boolean tx) {

    int id;

    synchronized (this) {
        id = rowIdSequence++;
    }

    Row row = new RowAVL(table, (Object[]) object, id, this);

    if (tx) {
        RowAction action = new RowAction(session, table,
                                         RowAction.ACTION_INSERT, row,
                                         null);

        row.rowAction = action;
    }

    return row;
}
 

import org.hsqldb.Row; //导入依赖的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.Row; //导入依赖的package包/类
/**
 * Basic delete with no logging or referential checks.
 */
public void delete(Session session, Row row) {

    writeLock();

    try {
        for (int i = 0; i < indexList.length; i++) {
            indexList[i].delete(session, this, row);
        }

        for (int i = 0; i < subStores.length; i++) {
            subStores[i].delete(session, row);
        }

        row.delete(this);

        long count = elementCount.decrementAndGet();

        if (count > 16 * 1024 && count < baseElementCount / 2) {
            baseElementCount = count;
            searchCost       = null;
        }
    } finally {
        writeUnlock();
    }
}
 

import org.hsqldb.Row; //导入依赖的package包/类
public void writeData(Row row, Type[] types) {

        if (crypto == null) {
            super.writeData(row, types);
        } else {
            int start = count;

            ensureRoom(row.getStorageSize());
            writeInt(0);
            super.writeData(row, types);

            int origLength = count - start - INT_STORE_SIZE;
            int newLength = crypto.encode(buffer, start + INT_STORE_SIZE,
                                          origLength, buffer,
                                          start + INT_STORE_SIZE);

            writeIntData(newLength, start);

            count = start + INT_STORE_SIZE + newLength;
        }
    }
 

import org.hsqldb.Row; //导入依赖的package包/类
public Row getNextRow() {

            if (nextnode == null) {
                release();

                return null;
            }

            lastrow  = nextnode.getRow(store);
            nextnode = index.next(session, store, nextnode);

            if (nextnode == null) {
                release();
            }

            return lastrow;
        }
 

import org.hsqldb.Row; //导入依赖的package包/类
public final void indexRows() {

        RowIterator it = rowIterator();

        for (int i = 1; i < indexList.length; i++) {
            setAccessor(indexList[i], null);
        }

        while (it.hasNext()) {
            Row row = it.getNextRow();

            if (row instanceof RowAVL) {
                ((RowAVL) row).clearNonPrimaryNodes();
            }

            for (int i = 1; i < indexList.length; i++) {
                indexList[i].insert(null, this, row);
            }
        }
    }
 

import org.hsqldb.Row; //导入依赖的package包/类
public void update(Object[] oldData, Object[] newData) {

        if (isSimpleAggregate) {
            return;
        }

        RowIterator it = groupIndex.findFirstRow((Session) session, store,
            oldData);

        if (it.hasNext()) {
            Row row = it.getNextRow();

            it.removeCurrent();
            it.release();

            size--;

            add(newData);
        }
    }
 

import org.hsqldb.Row; //导入依赖的package包/类
public int getSize(Row row) {

        reset();

        try {
            writeSize(0);
            writeData(row, row.getTable().getColumnTypes());
            writeEnd();
        } catch (Exception e) {
            reset();

//            throw Error.error(ErrorCode.FILE_IO_ERROR, e.toString());
        }

        int rowsize = size();

        reset();

        return rowsize;
    }
 

import org.hsqldb.Row; //导入依赖的package包/类
public boolean addRow(Row row) {

        int lookup = list.getLookup(row.getId());

        if (lookup == -1) {
            list.put(row.getId(), row, null);

            size++;

            return true;
        } else {
            if (list.getSecondValueByIndex(lookup) != null) {
                if (session.database.sqlEnforceTDCD) {
                    throw Error.error(ErrorCode.X_27000);
                }

                list.setSecondValueByIndex(lookup, null);
                list.setThirdValueByIndex(lookup, null);

                return true;
            }

            return false;
        }
    }
 

import org.hsqldb.Row; //导入依赖的package包/类
public int getSize(Row r) {

        reset();

        try {
            writeSize(0);
            writeData(r.getData(), r.getTable().getColumnTypes());
            writeEnd();
        } catch (Exception e) {
            reset();

//            throw Error.error(ErrorCode.FILE_IO_ERROR, e.toString());
        }

        int rowsize = size();

        reset();

        return rowsize;
    }
 

import org.hsqldb.Row; //导入依赖的package包/类
public CachedObject getNewCachedObject(Session session,
                                       Object object)
                                       {

    Row row = new RowAVL(table, (Object[]) object);

    if (session != null) {
        RowAction.addAction(session, RowAction.ACTION_INSERT, table, row);
    }

    int id = rowIdSequence++;

    row.setPos(id);
    rowIdMap.put(id, row);

    return row;
}
 

import org.hsqldb.Row; //导入依赖的package包/类
/**
 *  Calculate the size of byte array required to store a row.
 *
 * @param  row - a database row
 * @return  size of byte array
 * @exception  HsqlException When data is inconsistent
 */
public int getSize(Row row) {

    int size = super.getSize(row);

    if (crypto != null) {
        size = crypto.getEncodedSize(size - INT_STORE_SIZE)
               + INT_STORE_SIZE * 2;
    }

    return size;
}
 

import org.hsqldb.Row; //导入依赖的package包/类
/**
 * Returns the node after the given one
 *
 * @param x node
 *
 * @return next node
 */
private NodeAVL next(Session session, PersistentStore store, NodeAVL x) {

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

    readLock.lock();

    try {
        while (true) {
            x = next(store, x);

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

            if (session == null) {
                return x;
            }

            Row row = x.getRow(store);

            if (session.database.txManager.canRead(session, row)) {
                return x;
            }
        }
    } finally {
        readLock.unlock();
    }
}
 

import org.hsqldb.Row; //导入依赖的package包/类
/**
 * for result tables
 */
void reindex(Session session, Index index) {

    setAccessor(index, null);

    RowIterator it = table.rowIterator(session);

    while (it.hasNext()) {
        Row row = it.getNextRow();

        // may need to clear the node before insert
        index.insert(session, this, row);
    }
}
 

import org.hsqldb.Row; //导入依赖的package包/类
public CachedObject getNewCachedObject(Session session, Object object,
                                       boolean tx) {

    int id  = rowIdSequence.getAndIncrement();
    Row row = new RowAVL(table, (Object[]) object, id, this);

    if (tx) {
        RowAction.addInsertAction(session, table, row);
    }

    return row;
}
 

import org.hsqldb.Row; //导入依赖的package包/类
public void exceptAll(Session session, RowSetNavigatorData other) {

        Object[]    compareData = null;
        RowIterator it;
        Row         otherRow  = null;
        Object[]    otherData = null;

        sortFull(session);
        other.sortFull(session);

        it = fullIndex.emptyIterator();

        while (hasNext()) {
            Object[] currentData = getNext();
            boolean newGroup =
                compareData == null
                || fullIndex.compareRowNonUnique(
                    session, currentData, compareData,
                    fullIndex.getColumnCount()) != 0;

            if (newGroup) {
                compareData = currentData;
                it          = other.findFirstRow(currentData);
            }

            otherRow  = it.getNextRow();
            otherData = otherRow == null ? null
                                         : otherRow.getData();

            if (otherData != null
                    && fullIndex.compareRowNonUnique(
                        session, currentData, otherData,
                        fullIndex.getColumnCount()) == 0) {
                removeCurrent();
            }
        }

        other.release();
    }
 

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

        writeLock();

        try {
            super.delete(session, row);
        } finally {
            writeUnlock();
        }
    }
 

import org.hsqldb.Row; //导入依赖的package包/类
Row getRow(PersistentStore store) {

        if (!row.isInMemory()) {
            return (RowAVLDisk) store.get(this.row, false);
        } else {
            row.updateAccessCount(store.getAccessCount());
        }

        return row;
    }