import org.hsqldb.Session; //导入依赖的package包/类
public void writeDeleteStatement(Session session, Table table,
                                 Object[] data)
                                 throws HsqlException, IOException {

    schemaToLog = table.getName().schema;
    busyWriting = true;

    rowOut.reset();
    ((RowOutputTextLog) rowOut).setMode(RowOutputTextLog.MODE_DELETE);
    addSessionId(session);
    rowOut.write(BYTES_DELETE_FROM);
    rowOut.writeString(table.getName().statementName);
    rowOut.write(BYTES_WHERE);
    rowOut.writeData(table.getColumnCount(), table.getColumnTypes(),
                     data, table.columnList, table.getPrimaryKey());
    rowOut.write(BYTES_LINE_SEP);
    fileStreamOut.write(rowOut.getBuffer(), 0, rowOut.size());

    byteCount   += rowOut.size();
    needsSync   |= session.isAutoCommit();
    busyWriting = false;

    if (forceSync || writeDelay == 0) {
        sync();
    }
}
 

import org.hsqldb.Session; //导入依赖的package包/类
boolean hasNulls(Session session, Object[] rowData) {

        boolean uniqueNulls = session == null
                              || session.database.sqlUniqueNulls;
        boolean compareId = false;

        for (int j = 0; j < colIndex.length; j++) {
            if (rowData[colIndex[j]] == null) {
                compareId = true;

                if (uniqueNulls) {
                    break;
                }
            } else if (!uniqueNulls) {
                compareId = false;

                break;
            }
        }

        return compareId;
    }
 

import org.hsqldb.Session; //导入依赖的package包/类
public int compare(Session session, Object a, Object b) {

        if (a == b) {
            return 0;
        }

        if (a == null) {
            return -1;
        }

        if (b == null) {
            return 1;
        }

        if (b instanceof BinaryData) {
            return session.database.lobManager.compare((BlobData) a,
                    ((BlobData) b).getBytes());
        }

        return session.database.lobManager.compare((BlobData) a, (BlobData) b);
    }
 

import org.hsqldb.Session; //导入依赖的package包/类
boolean hasNulls(Session session, Object[] rowData) {

        boolean uniqueNulls = session == null
                              || session.database.sqlUniqueNulls;
        boolean compareId = false;

        for (int j = 0; j < colIndex.length; j++) {
            if (rowData[colIndex[j]] == null) {
                compareId = true;

                if (uniqueNulls) {
                    break;
                }
            } else {
                compareId = false;

                break;
            }
        }

        return compareId;
    }
 

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

        writeLock();

        try {
            setAccessor(index, null);

            RowIterator it = table.rowIterator(this);

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

                row.getNode(index.getPosition()).delete();
                index.insert(session, this, row);
            }
        } finally {
            writeUnlock();
        }
    }
 

import org.hsqldb.Session; //导入依赖的package包/类
/**
 * The predicate "a OVERLAPS b" applies when both a and b are either period
 * names or period constructors.
 * This predicate returns True if the two periods have at least one time
 * point in common, i.e, if a[0] < b[1] and
 * a[1] > b[0]. This predicates is commutative: "a OVERLAPS B" must return
 * the same result of "b OVERLAPS a"
 * <p>
 *
 * @param session
 * @param a First period to compare
 * @param ta Types of the first period
 * @param b Second period to compare
 * @param tb Type of the second period
 *
 * @return {@link Boolean#TRUE} if the two periods overlaps,
 *          else {@link Boolean#FALSE}
 */
public static Boolean overlaps(Session session, Object[] a, Type[] ta,
                               Object[] b, Type[] tb) {

    Type commonType = normalizeInput(session, a, ta, b, tb, false);

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

    if (commonType.compare(session, a[0], b[0]) > 0) {
        Object[] temp = a;

        a = b;
        b = temp;
    }

    if (commonType.compare(session, a[1], b[0]) > 0) {
        return Boolean.TRUE;
    }

    return Boolean.FALSE;
}
 

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

        sortFull(session);

        Object[] lastRowData = null;

        while (next()) {
            Object[] currentData = getCurrent();

            if (lastRowData != null
                    && fullIndex.compareRow(session, lastRowData, currentData)
                       == 0) {
                removeCurrent();
            } else {
                lastRowData = currentData;
            }
        }

        reset();
    }
 

import org.hsqldb.Session; //导入依赖的package包/类
public void writeLogStatement(Session session,
                              String s) throws IOException {

    if (session != null) {
        schemaToLog = session.currentSchema;

        writeSessionIdAndSchema(session);
    }

    rowOut.reset();
    rowOut.writeString(s);
    rowOut.write(BYTES_LINE_SEP);
    writeRowOutToFile();

    needsSync = true;
}
 

import org.hsqldb.Session; //导入依赖的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.Session; //导入依赖的package包/类
public static Result newResult(Session session, int mode,
                               DataInput dataInput,
                               RowInputBinary in)
                               throws IOException, HsqlException {

    try {
        if (mode == ResultConstants.LARGE_OBJECT_OP) {
            return ResultLob.newLob(dataInput, false);
        }

        Result result = newResult(session, dataInput, in, mode);

        return result;
    } catch (IOException e) {
        throw Error.error(ErrorCode.X_08000);
    }
}
 

import org.hsqldb.Session; //导入依赖的package包/类
public boolean checkComplexity(Session session, String password) {

        if (session == null || pwCheckFunction == null) {
            return true;
        }

        Result result = pwCheckFunction.invoke(session,
                                               new Object[]{ password }, null,
                                               true);
        Boolean check = (Boolean) result.getValueObject();

        if (check == null || !check.booleanValue()) {
            return false;
        }

        return true;
    }
 

import org.hsqldb.Session; //导入依赖的package包/类
public final void setStore(Session session, Table table,
                           PersistentStore store) {

    long dbscts = database.schemaManager.getSchemaChangeTimestamp();

    if (store.getTimestamp() == dbscts
            && !isNonCachedTable(table.getName().name)) {
        return;
    }

    // fredt - clear the contents of table and generate
    store.removeAll();
    store.setTimestamp(dbscts);

    int tableIndex = getSysTableID(table.getName().name);

    generateTable(session, store, tableIndex);
}
 

import org.hsqldb.Session; //导入依赖的package包/类
public int compare(Session session, Object a, Object b) {

        if (a == b) {
            return 0;
        }

        if (a == null) {
            return -1;
        }

        if (b == null) {
            return 1;
        }

        boolean boola = ((Boolean) a).booleanValue();
        boolean boolb = ((Boolean) b).booleanValue();

        return (boola == boolb) ? 0
                                : (boolb ? -1
                                         : 1);
    }
 

import org.hsqldb.Session; //导入依赖的package包/类
protected void writeRow(Session session, Table table,
                        Object[] data) throws HsqlException, IOException {

    busyWriting = true;

    rowOut.reset();
    ((RowOutputTextLog) rowOut).setMode(RowOutputTextLog.MODE_INSERT);
    addSessionId(session);
    rowOut.write(BYTES_INSERT_INTO);
    rowOut.writeString(table.getName().statementName);
    rowOut.write(BYTES_VALUES);
    rowOut.writeData(data, table);
    rowOut.write(BYTES_TERM);
    rowOut.write(BYTES_LINE_SEP);
    fileStreamOut.write(rowOut.getBuffer(), 0, rowOut.size());

    byteCount   += rowOut.size();
    needsSync   |= session.isAutoCommit();
    busyWriting = false;

    if (forceSync || writeDelay == 0) {
        sync();
    }
}
 

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

        int i = 0;

        try {
            for (; i < indexList.length; i++) {
                indexList[i].insert(session, this, row);
            }
        } catch (HsqlException e) {

            // unique index violation - rollback insert
            for (--i; i >= 0; i--) {
                indexList[i].delete(this, row);
            }

            remove(row.getPos());

            throw e;
        }
    }
 

import org.hsqldb.Session; //导入依赖的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.Session; //导入依赖的package包/类
/**
 * Return the first node equal to the indexdata object. The rowdata has the
 * same column mapping as this index.
 *
 * @param session session object
 * @param store store object
 * @param rowdata array containing index column data
 * @param matchCount count of columns to match
 * @param compareType int
 * @param reversed boolean
 * @param map boolean[]
 * @return iterator
 */
public RowIterator findFirstRow(Session session, PersistentStore store,
                                Object[] rowdata, int matchCount,
                                int distinctCount, int compareType,
                                boolean reversed, boolean[] map) {

    NodeAVL node = findNode(session, store, rowdata, defaultColMap,
                            matchCount, compareType,
                            TransactionManager.ACTION_READ, reversed);

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

    return new IndexRowIterator(session, store, this, node, distinctCount,
                                false, reversed);
}
 

import org.hsqldb.Session; //导入依赖的package包/类
/**
 * Records a Log entry for the specified SQL statement, on behalf of
 * the specified Session object.
 */
public synchronized void writeOtherStatement(Session session,
        String statement) {

    if (loggingEnabled) {
        log.writeOtherStatement(session, statement);
    }
}
 

import org.hsqldb.Session; //导入依赖的package包/类
/**
 * Clears the contents of cached system tables and resets user slots
 * to null. <p>
 *
 */
protected final void cacheClear(Session session) {

    int i = sysTables.length;

    while (i-- > 0) {
        Table t = sysTables[i];

        if (t != null) {
            t.clearAllData(session);
        }
    }
}
 

import org.hsqldb.Session; //导入依赖的package包/类
public void writeInsertStatement(Session session, Table table,
                                 Object[] data)
                                 throws HsqlException, IOException {

    schemaToLog = table.getName().schema;

    writeRow(session, table, data);
}