/* Copyright (c) 2001-2024, The HSQL Development Group
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * Neither the name of the HSQL Development Group nor the names of its
 * contributors may be used to endorse or promote products derived from this
 * software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


package org.hsqldb.persist;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.Locale;
import java.util.concurrent.atomic.AtomicInteger;

import org.hsqldb.Database;
import org.hsqldb.DatabaseType;
import org.hsqldb.HsqlNameManager.HsqlName;
import org.hsqldb.NumberSequence;
import org.hsqldb.Row;
import org.hsqldb.Session;
import org.hsqldb.SessionInterface;
import org.hsqldb.Statement;
import org.hsqldb.Table;
import org.hsqldb.TableBase;
import org.hsqldb.Tokens;
import org.hsqldb.TransactionManager;
import org.hsqldb.TransactionManagerMV2PL;
import org.hsqldb.TransactionManagerMVCC;
import org.hsqldb.error.Error;
import org.hsqldb.error.ErrorCode;
import org.hsqldb.index.Index;
import org.hsqldb.index.IndexAVL;
import org.hsqldb.index.IndexAVLMemory;
import org.hsqldb.lib.ArrayUtil;
import org.hsqldb.lib.EventLogInterface;
import org.hsqldb.lib.FileAccess;
import org.hsqldb.lib.FileUtil;
import org.hsqldb.lib.FrameworkLogger;
import org.hsqldb.lib.HashMap;
import org.hsqldb.lib.HsqlArrayList;
import org.hsqldb.lib.InputStreamInterface;
import org.hsqldb.lib.InputStreamWrapper;
import org.hsqldb.lib.List;
import org.hsqldb.lib.SimpleLog;
import org.hsqldb.lib.StringUtil;
import org.hsqldb.lib.tar.DbBackup;
import org.hsqldb.lib.tar.TarMalformatException;
import org.hsqldb.result.Result;
import org.hsqldb.scriptio.ScriptWriterBase;
import org.hsqldb.scriptio.ScriptWriterText;
import org.hsqldb.types.RowType;
import org.hsqldb.types.Type;

// campbell-burnet@users 20030510 - patch 1.7.2 - added cooperative file locking

/**
 *  The public interface of persistence and logging classes.<p>
 *
 *  Implements a storage manager wrapper that provides a consistent,
 *  always available interface to storage management for the Database
 *  class, despite the fact not all Database objects actually use file
 *  storage.<p>
 *
 * @author Fred Toussi (fredt@users dot sourceforge.net)
 * @version 2.7.3
 * @since 1.7.0
 */
public class Logger implements EventLogInterface {

    public SimpleLog appLog;
    public SimpleLog sqlLog;

    //
    FrameworkLogger fwLogger;
    FrameworkLogger sqlLogger;

    //
    private Database database;
    private boolean  logsStatements;    // false indicates Log is being opened
    private boolean  loggingEnabled;

    //
    private boolean propIsFileDatabase;
    boolean         propNioDataFile;
    long            propNioMaxSize    = 256 * 1024 * 1024L;
    int             propMaxFreeBlocks = 512;
    private int     propCacheMaxRows;
    private long    propCacheMaxSize;
    int             propDataFileDefragLimit;
    private int     propDataFileScale;
    int             propDataFileSpace;
    String          propTextSourceDefault = "";
    boolean         propTextAllowFullPath;
    private int     propWriteDelay;
    private int     propLogSize;
    private boolean propLogData = true;
    private int     propExternalEventLogLevel;
    private int     propEventLogLevel;
    int             propSqlLogLevel;
    int             propGC;
    int             propTxMode       = TransactionManager.LOCKS;
    boolean         propRefIntegrity = true;
    int             propLobBlockSize = 32 * 1024;
    boolean         propCompressLobs;
    int             propScriptFormat = 0;
    boolean         propLargeData;
    long            propFilesTimestamp;

    //
    Log               log;
    private LockFile  lockFile;
    private Crypto    crypto;
    boolean           cryptLobs;
    public FileAccess fileAccess;
    String            tempDirectoryPath;

    //
    public TextTableStorageManager textTableManager =
        new TextTableStorageManager();

    //
    public boolean isNewDatabase;

    //
    public boolean isSingleFile;

    //
    AtomicInteger backupState     = new AtomicInteger();
    AtomicInteger checkpointState = new AtomicInteger();

    //
    long maxLogSize;

    //
    static final int largeDataFactor = 128;

    // backupState cycle normal, backup, normal or normal, checkpoint, normal
    static final int stateNormal     = 0;
    static final int stateBackup     = 1;
    static final int stateCheckpoint = 2;

    // checkpointState cycle normal, required, due, normal
    static final int stateCheckpointNormal   = 0;
    static final int stateCheckpointRequired = 1;
    static final int stateCheckpointDue      = 2;

    //
    public static final String oldFileExtension        = ".old";
    public static final String newFileExtension        = ".new";
    public static final String appLogFileExtension     = ".app.log";
    public static final String sqlLogFileExtension     = ".sql.log";
    public static final String logFileExtension        = ".log";
    public static final String scriptFileExtension     = ".script";
    public static final String propertiesFileExtension = ".properties";
    public static final String dataFileExtension       = ".data";
    public static final String backupFileExtension     = ".backup";
    public static final String lobsFileExtension       = ".lobs";
    public static final String lockFileExtension       = ".lck";

    public Logger(Database database) {
        this.database = database;
    }

    /**
     *  Opens the specified Database object's database files and starts up
     *  the logging process. <p>
     *
     *  If the specified Database object is a new database, its database
     *  files are first created.
     *
     * @throws  org.hsqldb.HsqlException if there is a problem, such as the case when
     *      the specified files are in use by another process
     */
    public void open() {

        boolean hasFileProps = false;
        boolean hasScript    = false;

        fileAccess = FileUtil.getFileAccess(database.isFilesInJar());
        propIsFileDatabase          = database.getType().isFileBased();
        database.databaseProperties = new HsqlDatabaseProperties(database);
        propTextAllowFullPath = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.textdb_allow_full_path);

        if (propIsFileDatabase) {
            hasFileProps = database.databaseProperties.load();
            hasScript = fileAccess.isStreamElement(
                database.getPath() + scriptFileExtension);

            boolean version18 = database.databaseProperties.isVersion18();

            if (version18) {
                throw Error.error(
                    ErrorCode.WRONG_DATABASE_FILE_VERSION,
                    "unsupported old database version");
            }

            boolean exists = hasScript;

            if (!exists) {
                exists = fileAccess.isStreamElement(
                    database.getPath() + scriptFileExtension
                    + Logger.newFileExtension);

                if (exists) {
                    database.databaseProperties.setDBModified(
                        HsqlDatabaseProperties.FILES_MODIFIED_NEW);
                } else {
                    exists = fileAccess.isStreamElement(
                        database.getPath() + dataFileExtension);

                    if (exists) {
                        throw Error.error(
                            ErrorCode.DATA_FILE_ERROR,
                            "database files not complete");
                    }

                    exists = fileAccess.isStreamElement(
                        database.getPath() + backupFileExtension);

                    if (exists) {
                        throw Error.error(
                            ErrorCode.DATA_FILE_ERROR,
                            "database files not complete");
                    }
                }
            }

            isNewDatabase = !exists;
        } else {
            isNewDatabase = true;
        }

        if (isNewDatabase) {
            String name = newUniqueName();

            database.setDatabaseName(name);

            boolean checkExists = database.isFilesInJar();

            checkExists |= (database.urlProperties.isPropertyTrue(
                HsqlDatabaseProperties.url_ifexists)
                            || !database.urlProperties.isPropertyTrue(
                                HsqlDatabaseProperties.url_create,
                                true));

            if (checkExists) {
                throw Error.error(
                    ErrorCode.DATABASE_NOT_EXISTS,
                    database.getPath());
            }

            database.databaseProperties.setURLProperties(
                database.urlProperties);
        } else {
            if (!hasFileProps) {
                database.databaseProperties.setDBModified(
                    HsqlDatabaseProperties.FILES_MODIFIED);
            }

            // properties that also apply to existing database only if they exist
            if (database.urlProperties.isPropertyTrue(
                    HsqlDatabaseProperties.hsqldb_files_readonly)) {
                database.databaseProperties.setProperty(
                    HsqlDatabaseProperties.hsqldb_files_readonly,
                    true);
            }

            if (database.urlProperties.isPropertyTrue(
                    HsqlDatabaseProperties.hsqldb_readonly)) {
                database.databaseProperties.setProperty(
                    HsqlDatabaseProperties.hsqldb_readonly,
                    true);
            }

            // hsqldb.lock_file=false is applied
            if (!database.urlProperties.isPropertyTrue(
                    HsqlDatabaseProperties.hsqldb_lock_file,
                    true)) {
                database.databaseProperties.setProperty(
                    HsqlDatabaseProperties.hsqldb_lock_file,
                    false);
            }
        }

        setVariables();

        String appLogPath = null;
        String sqlLogPath = null;

        if (propIsFileDatabase && !database.isFilesReadOnly()) {
            appLogPath = database.getPath() + appLogFileExtension;
            sqlLogPath = database.getPath() + sqlLogFileExtension;
        }

        appLog = new SimpleLog(appLogPath, propEventLogLevel, false);
        sqlLog = new SimpleLog(sqlLogPath, propSqlLogLevel, true);

        database.setReferentialIntegrity(propRefIntegrity);

        if (!isFileDatabase()) {
            return;
        }

        checkpointState.set(stateCheckpointNormal);

        logsStatements = false;

        boolean useLock = database.getProperties()
                                  .isPropertyTrue(
                                      HsqlDatabaseProperties.hsqldb_lock_file);

        if (useLock && !database.isFilesReadOnly()) {
            acquireLock(database.getPath());
        }

        log = new Log(database);

        log.open();

        logsStatements = true;
        loggingEnabled = propLogData && !database.isFilesReadOnly();

        if (database.getNameString().isEmpty()) {
            database.setDatabaseName(newUniqueName());
        }

        // URL database properties that can override .script file settings
        int level = database.urlProperties.getIntegerProperty(
            HsqlDatabaseProperties.hsqldb_applog,
            -1);

        if (level >= 0) {
            setEventLogLevel(level);
        }

        level = database.urlProperties.getIntegerProperty(
            HsqlDatabaseProperties.hsqldb_extlog,
            -1);

        if (level >= 0) {
            setExternalEventLogLevel(level);
        }

        level = database.urlProperties.getIntegerProperty(
            HsqlDatabaseProperties.hsqldb_sqllog,
            -1);

        if (level >= 0) {
            setSqlLogLevel(level);
        }
    }

    private void setVariables() {

        String cryptKey = database.urlProperties.getProperty(
            HsqlDatabaseProperties.url_crypt_key);

        if (cryptKey != null) {
            String cryptType = database.urlProperties.getProperty(
                HsqlDatabaseProperties.url_crypt_type);
            String cryptProvider = database.urlProperties.getProperty(
                HsqlDatabaseProperties.url_crypt_provider);
            String cryptIv = database.urlProperties.getProperty(
                HsqlDatabaseProperties.url_crypt_iv);

            crypto = new Crypto(cryptKey, cryptIv, cryptType, cryptProvider);
            cryptLobs = database.urlProperties.isPropertyTrue(
                HsqlDatabaseProperties.url_crypt_lobs,
                true);
        }

        if (database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.hsqldb_readonly)) {
            database.setReadOnly();
        }

        if (database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.hsqldb_files_readonly)) {
            database.setFilesReadOnly();
        }

        // handle invalid paths as well as access issues
        if (!database.isFilesReadOnly()) {
            if (database.getType() == DatabaseType.DB_MEM) {
                tempDirectoryPath = database.getProperties()
                                            .getStringProperty(
                                                HsqlDatabaseProperties.hsqldb_temp_directory);
            } else {
                tempDirectoryPath = database.getPath() + ".tmp";
            }

            if (tempDirectoryPath != null) {
                tempDirectoryPath = FileUtil.makeDirectories(tempDirectoryPath);
            }
        }

        propScriptFormat = database.databaseProperties.getIntegerProperty(
            HsqlDatabaseProperties.hsqldb_script_format);
        propMaxFreeBlocks = database.databaseProperties.getIntegerProperty(
            HsqlDatabaseProperties.hsqldb_cache_free_count);
        propMaxFreeBlocks = ArrayUtil.getTwoPowerFloor(propMaxFreeBlocks);

        if (database.urlProperties.isPropertyTrue(
                HsqlDatabaseProperties.hsqldb_large_data,
                false)) {
            propLargeData = true;
        }

        if (!database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.sql_pad_space,
                true)) {
            database.collation.setPadding(false);
        }

        String temp = database.getProperties()
                              .getStringProperty(
                                  HsqlDatabaseProperties.hsqldb_digest);

        database.granteeManager.setDigestAlgo(temp);

        if (!isNewDatabase) {
            return;
        }

        if (tempDirectoryPath != null) {
            int rows = database.databaseProperties.getIntegerProperty(
                HsqlDatabaseProperties.hsqldb_result_max_memory_rows);

            database.setResultMaxMemoryRows(rows);
        }

        String tableType = database.databaseProperties.getStringProperty(
            HsqlDatabaseProperties.hsqldb_default_table_type);

        if (Tokens.T_CACHED.equalsIgnoreCase(tableType)) {
            database.schemaManager.setDefaultTableType(TableBase.CACHED_TABLE);
        }

        String txMode = database.databaseProperties.getStringProperty(
            HsqlDatabaseProperties.hsqldb_tx);

        if (Tokens.T_MVCC.equalsIgnoreCase(txMode)) {
            propTxMode = TransactionManager.MVCC;
        } else if (Tokens.T_MVLOCKS.equalsIgnoreCase(txMode)) {
            propTxMode = TransactionManager.MVLOCKS;
        } else if (Tokens.T_LOCKS.equalsIgnoreCase(txMode)) {
            propTxMode = TransactionManager.LOCKS;
        }

        switch (propTxMode) {

            case TransactionManager.LOCKS :
                break;

            case TransactionManager.MVLOCKS :
                database.txManager = new TransactionManagerMV2PL(database);
                break;

            case TransactionManager.MVCC :
                database.txManager = new TransactionManagerMVCC(database);
                break;
        }

        String txLevel = database.databaseProperties.getStringProperty(
            HsqlDatabaseProperties.hsqldb_tx_level);

        if (Tokens.T_SERIALIZABLE.equalsIgnoreCase(txLevel)) {
            database.defaultIsolationLevel = SessionInterface.TX_SERIALIZABLE;
        } else {
            database.defaultIsolationLevel = SessionInterface.TX_READ_COMMITTED;
        }

        database.txConflictRollback =
            database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.hsqldb_tx_conflict_rollback);
        database.txInterruptRollback =
            database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.hsqldb_tx_interrupt_rollback);
        database.sqlRestrictExec = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_restrict_exec);
        database.sqlEnforceNames = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_enforce_names);
        database.sqlRegularNames = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_regular_names);
        database.sqlEnforceRefs = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_enforce_refs);
        database.sqlEnforceSize = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_enforce_size);
        database.sqlEnforceTypes = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_enforce_types);
        database.sqlEnforceTDCD = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_enforce_tdcd);
        database.sqlEnforceTDCU = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_enforce_tdcu);
        database.sqlTranslateTTI = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.jdbc_translate_tti_types);
        database.sqlLiveObject = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_live_object);
        database.sqlCharLiteral = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_char_literal);
        database.sqlConcatNulls = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_concat_nulls);
        database.sqlNullsFirst = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_nulls_first);
        database.sqlNullsOrder = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_nulls_order);
        database.sqlUniqueNulls = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_unique_nulls);
        database.sqlConvertTruncate =
            database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.sql_convert_trunc);
        database.sqlTruncateTrailing =
            database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.sql_trunc_trailing);
        database.sqlAvgScale = database.databaseProperties.getIntegerProperty(
            HsqlDatabaseProperties.sql_avg_scale);
        database.sqlMaxRecursive =
            database.databaseProperties.getIntegerProperty(
                HsqlDatabaseProperties.sql_max_recursive);
        database.sqlDoubleNaN = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_double_nan);
        database.sqlLongvarIsLob = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_longvar_is_lob);
        database.sqlIgnoreCase = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_ignore_case);
        database.sqlSyntaxDb2 = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_syntax_db2);
        database.sqlSyntaxMss = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_syntax_mss);
        database.sqlSyntaxMys = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_syntax_mys);
        database.sqlSyntaxOra = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_syntax_ora);
        database.sqlSyntaxPgs = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_syntax_pgs);
        database.sqlSysIndexNames = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_sys_index_names);
        database.sqlLowerCaseIdentifier =
            database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.sql_lowercase_ident);

        if (database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.sql_compare_in_locale)) {
            database.collation.setCollationAsLocale();
        }

        propEventLogLevel = database.databaseProperties.getIntegerProperty(
            HsqlDatabaseProperties.hsqldb_applog);
        propExternalEventLogLevel =
            database.databaseProperties.getIntegerProperty(
                HsqlDatabaseProperties.hsqldb_extlog);
        propSqlLogLevel = database.databaseProperties.getIntegerProperty(
            HsqlDatabaseProperties.hsqldb_sqllog);

        if (database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.hsqldb_files_readonly)) {
            database.setFilesReadOnly();
        }

        if (database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.hsqldb_readonly)) {
            database.setReadOnly();
        }

        propNioDataFile = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.hsqldb_nio_data_file);
        propNioMaxSize = database.databaseProperties.getIntegerProperty(
            HsqlDatabaseProperties.hsqldb_nio_max_size) * 1024L * 1024L;
        propCacheMaxRows = database.databaseProperties.getIntegerProperty(
            HsqlDatabaseProperties.hsqldb_cache_rows);
        propCacheMaxSize = database.databaseProperties.getIntegerProperty(
            HsqlDatabaseProperties.hsqldb_cache_size) * 1024L;

        setLobFileScaleNoCheck(
            database.databaseProperties.getIntegerProperty(
                HsqlDatabaseProperties.hsqldb_lob_file_scale));
        setLobFileCompressedNoCheck(
            database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.hsqldb_lob_file_compressed));
        setDataFileScaleNoCheck(
            database.databaseProperties.getIntegerProperty(
                HsqlDatabaseProperties.hsqldb_cache_file_scale));

        // linked with above FILES SCALE
        boolean fileSpace = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.hsqldb_files_space);

        setDataFileSpace(fileSpace);

        propDataFileDefragLimit =
            database.databaseProperties.getIntegerProperty(
                HsqlDatabaseProperties.hsqldb_defrag_limit);
        propWriteDelay = database.databaseProperties.getIntegerProperty(
            HsqlDatabaseProperties.hsqldb_write_delay_millis);

        if (!database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.hsqldb_write_delay)) {
            propWriteDelay = 0;
        }

        setLogSize(
            database.databaseProperties.getIntegerProperty(
                HsqlDatabaseProperties.hsqldb_log_size));

        propLogData = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.hsqldb_log_data);
        propGC = database.databaseProperties.getIntegerProperty(
            HsqlDatabaseProperties.runtime_gc_interval);
        propRefIntegrity = database.databaseProperties.isPropertyTrue(
            HsqlDatabaseProperties.sql_ref_integrity);
    }

// fredt@users 20020130 - patch 495484 by campbell-burnet@users

    /**
     *  Shuts down the logging process using the specified mode. <p>
     *
     * @param  closemode The mode in which to shut down the logging
     *      process
     *      <OL>
     *        <LI> CLOSEMODE_IMMEDIATELY performs SHUTDOWN IMMEDIATELY, equivalent
     *        to  a poweroff or crash.
     *        <LI> CLOSEMODE_NORMAL performs a normal SHUTDOWN that
     *        checkpoints the database normally.
     *        <LI> CLOSEMODE_COMPACT performs a shutdown compact that scripts
     *        out the contents of any CACHED tables to the log then
     *        deletes the existing *.data file that contains the data
     *        for all CACHED table before the normal checkpoint process
     *        which in turn creates a new, compact *.data file.
     *        <LI> CLOSEMODE_SCRIPT performs a SHUTDOWN SCRIPT.
     *      </OL>
     *
     * @return  true if closed with no problems or false if a problem was
     *        encountered.
     */
    public boolean close(int closemode) {

        boolean result = true;

        if (log == null) {
            textTableManager.closeAllTextCaches(false);

            return true;
        }

        log.synchLog();
        database.lobManager.synch();

        try {
            switch (closemode) {

                case Database.CLOSEMODE_IMMEDIATELY :
                    log.closeImmediately();
                    break;

                case Database.CLOSEMODE_NORMAL :
                    log.close(false);
                    break;

                case Database.CLOSEMODE_COMPACT :
                case Database.CLOSEMODE_SCRIPT :
                    log.close(true);
                    break;
            }

            database.persistentStoreCollection.release();
        } catch (Throwable e) {
            database.logger.logSevereEvent("error closing log", e);

            result = false;
        }

        logInfoEvent("Database closed");

        log = null;

        appLog.close();
        sqlLog.close();

        logsStatements = false;
        loggingEnabled = false;

        return result;
    }

    String newUniqueName() {

        String name = StringUtil.toPaddedString(
            Long.toHexString(System.currentTimeMillis()),
            16,
            '0',
            false);

        name = "HSQLDB" + name.substring(6).toUpperCase(Locale.ENGLISH);

        return name;
    }

    /*
     * Must return correct mode prior to initialisation
     * @return  true if this object encapsulates a non-null Log instance,
     *      else false
     */
    public boolean isLogged() {
        return propIsFileDatabase && !database.isFilesReadOnly();
    }

    public boolean isCurrentlyLogged() {
        return loggingEnabled;
    }

    public boolean isAllowedFullPath() {
        return propTextAllowFullPath;
    }

    /**
     * All usage of FrameworkLogger should call this method before using an
     * instance.
     *
     * It ensures and requires that no logging should take place before a new
     * database unique name has been created for a new database or read from the
     * .script file for an old database.<p>
     *
     * An instance is returned when:
     * - database unique name has been created
     * - FrameworkLogger would use log4j
     *
     * Otherwise null is returned.
     *
     * This tactic avoids usage of file-based jdk logging for the time being.
     *
     */
    private void getEventLogger() {

        if (fwLogger != null) {
            return;
        }

        String name = database.getNameString();

        if (name.isEmpty()) {

            // The database unique name is set up at different times
            // depending on upgraded / exiting / new databases.
            // Therefore FrameworkLogger is not used until the unique
            // name is known.
            return;
        }

        fwLogger = FrameworkLogger.getLog(
            SimpleLog.logTypeName,
            "hsqldb.db." + database.getNameString());

        /*
        sqlLogger = FrameworkLogger.getLog(SimpleLog.logTypeNameEngine,
                                           "hsqldb.sql."
                                           + database.getUniqueName());
        */
    }

    public void setEventLogLevel(int level) {

        if (level < SimpleLog.LOG_NONE || level > SimpleLog.LOG_DETAIL) {
            throw Error.error(ErrorCode.X_42556);
        }

        propEventLogLevel = level;

        appLog.setLevel(level);
    }

    public void setSqlLogLevel(int level) {

        if (level < SimpleLog.LOG_NONE || level > SimpleLog.LOG_SQL_RESULT) {
            throw Error.error(ErrorCode.X_42556);
        }

        propSqlLogLevel = level;

        sqlLog.setLevel(level);
    }

    public void setExternalEventLogLevel(int level) {

        if (level < SimpleLog.LOG_NONE || level > SimpleLog.LOG_DETAIL) {
            throw Error.error(ErrorCode.X_42556);
        }

        propExternalEventLogLevel = level;
    }

    public void logSevereEvent(String message, Throwable t) {

        getEventLogger();

        if (fwLogger != null) {
            if (propExternalEventLogLevel >= SimpleLog.LOG_ERROR) {
                fwLogger.severe(message, t);
            }
        }

        if (appLog != null) {
            if (t == null) {
                appLog.logContext(SimpleLog.LOG_ERROR, message);
            } else {
                appLog.logContext(t, message, SimpleLog.LOG_ERROR);
            }
        }
    }

    public void logWarningEvent(String message, Throwable t) {

        getEventLogger();

        if (fwLogger != null) {
            if (propExternalEventLogLevel >= SimpleLog.LOG_WARNING) {
                fwLogger.warning(message, t);
            }
        }

        appLog.logContext(t, message, SimpleLog.LOG_WARNING);
    }

    public void logInfoEvent(String message) {

        getEventLogger();

        if (fwLogger != null) {
            if (propExternalEventLogLevel >= SimpleLog.LOG_NORMAL) {
                fwLogger.info(message);
            }
        }

        appLog.logContext(SimpleLog.LOG_NORMAL, message);
    }

    public void logDetailEvent(String message) {

        getEventLogger();

        if (fwLogger != null) {
            if (propExternalEventLogLevel >= SimpleLog.LOG_DETAIL) {
                fwLogger.finest(message);
            }
        }

        if (appLog != null) {
            appLog.logContext(SimpleLog.LOG_DETAIL, message);
        }
    }

    public void logStatementEvent(
            Session session,
            Statement statement,
            Object[] paramValues,
            Result result,
            int level) {

        if (sqlLog != null && level <= propSqlLogLevel) {
            String sessionId   = Long.toString(session.getId());
            String sql         = statement.getSQL();
            String values      = "";
            int    paramLength = 0;

            if (propSqlLogLevel < SimpleLog.LOG_SQL_DETAIL) {
                if (sql.length() > 256) {
                    sql = sql.substring(0, 256);
                }

                paramLength = 32;
            }

            if (paramValues != null && paramValues.length > 0) {
                values = RowType.convertToSQLString(
                    paramValues,
                    statement.getParametersMetaData().getParameterTypes(),
                    paramLength);
            }

            if (propSqlLogLevel == SimpleLog.LOG_SQL_RESULT) {
                StringBuilder sb = new StringBuilder(values);

                sb.append(' ').append('[');

                if (result.isError()) {
                    sb.append(result.getErrorCode());
                } else if (result.isData()) {
                    sb.append(result.getNavigator().getSize());
                } else if (result.isUpdateCount()) {
                    sb.append(result.getUpdateCount());
                }

                sb.append(']');

                values = sb.toString();
            }

            sqlLog.logContext(level, sessionId, sql, values);
        }
    }

    public int getSqlEventLogLevel() {
        return propSqlLogLevel;
    }

    /**
     * Returns the Cache object or null if one doesn't exist.
     */
    public DataFileCache getCache() {

        if (log == null) {
            return null;
        } else {
            return log.getCache();
        }
    }

    /**
     * Returns true if Cache object exists.
     */
    public boolean hasCache() {

        if (log == null) {
            return false;
        } else {
            return log.hasCache();
        }
    }

    /**
     * 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);
        }
    }

    /**
     * Used exclusively by PersistentStore objects
     */
    public synchronized void writeInsertStatement(
            Session session,
            Row row,
            Table table) {
        if (loggingEnabled) {
            log.writeInsertStatement(session, row, table);
        }
    }

    /**
     * Used exclusively by PersistentStore objects
     */
    public synchronized void writeDeleteStatement(
            Session session,
            Table t,
            Object[] row) {
        if (loggingEnabled) {
            log.writeDeleteStatement(session, t, row);
        }
    }

    /**
     * Used at transaction commit
     */
    public synchronized void writeSequenceStatement(
            Session session,
            NumberSequence s) {
        if (loggingEnabled) {
            log.writeSequenceStatement(session, s);
        }
    }

    /**
     * Used at transaction commit
     */
    public synchronized void writeCommitStatement(Session session) {

        if (loggingEnabled) {
            log.writeCommitStatement(session);
        } else {
            if (maxLogSize > 0
                    && database.lobManager.getUsageChanged() > maxLogSize) {
                setCheckpointRequired();
            }
        }
    }

    public synchronized void synchLog() {
        if (loggingEnabled) {
            log.synchLog();
        }
    }

    /**
     *  Checkpoints the database. <p>
     *
     *  The most important effect of calling this method is to cause the
     *  log file to be rewritten in the most efficient form to
     *  reflect the current state of the database, i.e. only the DDL and
     *  insert DML required to recreate the database in its present state.
     *  Other house-keeping duties are performed w.r.t. other database
     *  files, in order to ensure as much as possible the ACID properties
     *  of the database.
     *
     * @throws  org.hsqldb.HsqlException if there is a problem checkpointing the
     *      database
     */
    public void checkpoint(Session session, boolean defrag, boolean lobs) {

        if (!backupState.compareAndSet(stateNormal, stateCheckpoint)) {
            throw Error.error(ErrorCode.ACCESS_IS_DENIED);
        }

        database.lobManager.lock();

        try {
            synchronized (this) {
                checkpointInternal(session, defrag);

                if (lobs) {
                    Result result = database.lobManager.deleteUnusedLobs();

                    if (log != null && result.getUpdateCount() > 0) {
                        log.synchLog();
                        logDetailEvent(
                            "Deleted unused LOBs, count: "
                            + result.getUpdateCount());
                    }
                }
            }
        } finally {
            backupState.set(stateNormal);
            checkpointState.set(stateCheckpointNormal);
            database.lobManager.unlock();
        }
    }

    private void checkpointInternal(Session session, boolean defrag) {

        if (logsStatements) {
            logInfoEvent("Checkpoint start");
            log.checkpoint(session, defrag);
            logInfoEvent(
                "Checkpoint end - txts: "
                + database.txManager.getSystemChangeNumber());
        }
    }

    /**
     *  Sets the maximum size to which the log file can grow
     *  before being automatically checkpointed.
     *
     * @param  megas size in MB
     */
    public synchronized void setLogSize(int megas) {

        propLogSize = megas;
        maxLogSize  = propLogSize * 1024L * 1024;

        if (log != null) {
            log.setLogSize(propLogSize);
        }
    }

    /**
     *  Sets logging on or off.
     */
    public synchronized void setLogData(boolean mode) {
        propLogData    = mode;
        loggingEnabled = propLogData && !database.isFilesReadOnly();
        loggingEnabled &= logsStatements;
    }

    /**
     *  Sets the type of script file, currently 0 for text (default)
     *  3 for compressed
     *
     * @param  format The type
     */
    public synchronized void setScriptType(int format) {

        if (format == propScriptFormat) {
            return;
        }

        propScriptFormat = format;

        checkpointState.compareAndSet(
            stateCheckpointNormal,
            stateCheckpointRequired);
    }

    /**
     *  Sets the log write delay mode to number of seconds. By default
     *  executed commands written to the log are committed fully at most
     *  0.5 second after they are executed. This improves performance for
     *  applications that execute a large number
     *  of short running statements in a short period of time, but risks
     *  failing to log some possibly large number of statements in the
     *  event of a crash. A small value improves recovery.
     *  A value of 0 will severly slow down logging when autocommit is on,
     *  or many short transactions are committed.
     *
     * @param delay in milliseconds
     */
    public synchronized void setWriteDelay(int delay) {

        propWriteDelay = delay;

        if (log != null) {
            log.setWriteDelay(delay);
        }
    }

    public Crypto getCrypto() {
        return crypto;
    }

    public int getWriteDelay() {
        return propWriteDelay;
    }

    public int getLogSize() {
        return propLogSize;
    }

    public int getLobBlockSize() {
        return propLobBlockSize;
    }

    public void setCacheMaxRows(int value) {
        propCacheMaxRows = value;
    }

    public int getCacheMaxRows() {
        return propCacheMaxRows;
    }

    public void setCacheSize(int value) {
        propCacheMaxSize = value * 1024L;
    }

    public long getCacheSize() {
        return propCacheMaxSize;
    }

    public void setDataFileScale(int value) {

        if (value < 16) {
            throw Error.error(ErrorCode.X_42556);
        }

        setDataFileScaleNoCheck(value);
    }

    public void setDataFileScaleNoCheck(int value) {

        checkPower(value, 10);

        if (value < 8 && value != 1) {
            throw Error.error(ErrorCode.X_42556);
        }

        propDataFileScale = value;

        if (propDataFileSpace > 0) {
            propDataFileSpace = propDataFileScale / 16;    // change to default
        }
    }

    public int getDataFileScale() {
        return propDataFileScale;
    }

    public int getDataFileFactor() {
        return propLargeData
               ? largeDataFactor
               : 1;
    }

    public void setDataFileSpace(boolean value) {

        if (value) {
            setDataFileSpace(propDataFileScale / 16);
        } else {
            setDataFileSpace(0);
        }
    }

    public void setDataFileSpace(int value) {

        if (value != 0) {
            checkPower(value, 6);
        }

        if (value > propDataFileScale / 16) {
            value = propDataFileScale / 16;
        }

        propDataFileSpace = value;
    }

    public int getDataFileSpace() {
        return propDataFileSpace;
    }

    public long getFilesTimestamp() {
        return propFilesTimestamp;
    }

    public void setFilesTimestamp(long value) {
        propFilesTimestamp = value;
    }

    public void setLobFileScale(int value) {

        if (propLobBlockSize == value * 1024) {
            return;
        }

        checkPower(value, 5);

        if (database.lobManager.getLobCount() > 0) {
            throw Error.error(ErrorCode.DATA_FILE_IN_USE);
        }

        propLobBlockSize = value * 1024;

        database.lobManager.close();
        database.lobManager.open();
    }

    public void setLobFileScaleNoCheck(int value) {
        checkPower(value, 5);

        propLobBlockSize = value * 1024;
    }

    public int getLobFileScale() {
        return propLobBlockSize / 1024;
    }

    public void setLobFileCompressed(boolean value) {

        if (propCompressLobs == value) {
            return;
        }

        if (database.lobManager.getLobCount() > 0) {
            throw Error.error(ErrorCode.DATA_FILE_IN_USE);
        }

        propCompressLobs = value;

        database.lobManager.close();
        database.lobManager.open();
    }

    public void setLobFileCompressedNoCheck(boolean value) {
        propCompressLobs = value;
    }

    public void setDefagLimit(int value) {

        if (value > 0 && value < 25) {
            value = 25;
        }

        propDataFileDefragLimit = value;
    }

    public int getDefragLimit() {
        return propDataFileDefragLimit;
    }

    public void setDefaultTextTableProperties(
            String source,
            HsqlProperties props) {

        props.setProperty(HsqlDatabaseProperties.url_check_props, true);
        database.getProperties().setURLProperties(props);

        propTextSourceDefault = source;
    }

    public void setNioDataFile(boolean value) {
        propNioDataFile = value;
    }

    public void setNioMaxSize(int value) {

        value = ArrayUtil.getTwoPowerFloor(value);

        if (value < 64) {
            value = 64;
        }

        propNioMaxSize = value * 1024L * 1024L;
    }

    public FileAccess getFileAccess() {
        return fileAccess;
    }

    public boolean isFileDatabase() {
        return propIsFileDatabase;
    }

    public String getTempDirectoryPath() {
        return tempDirectoryPath;
    }

    static void checkPower(int n, int max) {
        if (!ArrayUtil.isTwoPower(n, max)) {
            throw Error.error(ErrorCode.X_42556);
        }
    }

    public void setCheckpointRequired() {
        checkpointState.compareAndSet(
            stateCheckpointNormal,
            stateCheckpointRequired);
    }

    public boolean needsCheckpointReset() {
        return checkpointState.compareAndSet(
            stateCheckpointRequired,
            stateCheckpointDue);
    }

    public boolean hasLockFile() {
        return lockFile != null;
    }

    public void acquireLock(String path) {

        if (lockFile != null) {
            return;
        }

        lockFile = LockFile.newLockFileLock(path);
    }

    public void releaseLock() {

        try {
            if (lockFile != null) {
                lockFile.tryRelease();
            }
        } catch (Exception e) {}

        lockFile = null;
    }

    public PersistentStore newStore(
            Session session,
            PersistentStoreCollection collection,
            TableBase table) {

        switch (table.getTableType()) {

            case TableBase.CACHED_TABLE :
                DataFileCache cache = getCache();

                if (cache == null) {
                    break;
                }

                return new RowStoreAVLDisk(cache, (Table) table);

            case TableBase.MEMORY_TABLE :
            case TableBase.SYSTEM_TABLE :
                return new RowStoreAVLMemory((Table) table);

            case TableBase.TEXT_TABLE :
                return new RowStoreAVLDiskData((Table) table);

            case TableBase.INFO_SCHEMA_TABLE :
                return new RowStoreAVLHybridExtended(session, table, false);

            case TableBase.TEMP_TABLE :
                return new RowStoreAVLHybridExtended(session, table, true);

            case TableBase.CHANGE_SET_TABLE :
                return new RowStoreDataChange(session, table);

            case TableBase.FUNCTION_TABLE :
            case TableBase.RESULT_TABLE :
            case TableBase.SYSTEM_SUBQUERY :
            case TableBase.VIEW_TABLE :
            case TableBase.TRANSITION_TABLE :
                if (session == null) {
                    return null;
                }

                return new RowStoreAVLHybrid(session, table, true);
        }

        throw Error.runtimeError(ErrorCode.U_S0500, "Logger");
    }

    public Index newIndex(
            HsqlName name,
            long id,
            TableBase table,
            int[] columns,
            boolean[] descending,
            boolean[] nullsLast,
            Type[] colTypes,
            boolean pk,
            boolean unique,
            boolean constraint,
            boolean forward) {

        switch (table.getTableType()) {

            case TableBase.INFO_SCHEMA_TABLE :
            case TableBase.SYSTEM_TABLE :
            case TableBase.MEMORY_TABLE :
                return new IndexAVLMemory(
                    name,
                    id,
                    table,
                    columns,
                    descending,
                    nullsLast,
                    colTypes,
                    pk,
                    unique,
                    constraint,
                    forward);

            case TableBase.CACHED_TABLE :
            case TableBase.CHANGE_SET_TABLE :
            case TableBase.FUNCTION_TABLE :
            case TableBase.TEXT_TABLE :
            case TableBase.TEMP_TABLE :
            case TableBase.RESULT_TABLE :
            case TableBase.SYSTEM_SUBQUERY :
            case TableBase.VIEW_TABLE :
            case TableBase.TRANSITION_TABLE :
                return new IndexAVL(
                    name,
                    id,
                    table,
                    columns,
                    descending,
                    nullsLast,
                    colTypes,
                    pk,
                    unique,
                    constraint,
                    forward);
        }

        throw Error.runtimeError(ErrorCode.U_S0500, "Logger");
    }

    public HashMap<String, String> getPropertyValueMap() {

        HashMap<String, String> map   = new HashMap<>();
        String                  value = null;

        map.put(
            HsqlDatabaseProperties.sql_avg_scale,
            String.valueOf(database.sqlAvgScale));
        map.put(
            HsqlDatabaseProperties.sql_char_literal,
            String.valueOf(database.sqlCharLiteral));
        map.put(
            HsqlDatabaseProperties.sql_concat_nulls,
            String.valueOf(database.sqlConcatNulls));
        map.put(
            HsqlDatabaseProperties.sql_convert_trunc,
            String.valueOf(database.sqlConvertTruncate));
        map.put(
            HsqlDatabaseProperties.sql_default_collation,
            String.valueOf(database.collation.getName().name));
        map.put(
            HsqlDatabaseProperties.sql_trunc_trailing,
            String.valueOf(database.sqlTruncateTrailing));
        map.put(
            HsqlDatabaseProperties.sql_double_nan,
            String.valueOf(database.sqlDoubleNaN));
        map.put(
            HsqlDatabaseProperties.sql_enforce_names,
            String.valueOf(database.sqlEnforceNames));
        map.put(
            HsqlDatabaseProperties.sql_enforce_refs,
            String.valueOf(database.sqlEnforceRefs));
        map.put(
            HsqlDatabaseProperties.sql_enforce_size,
            String.valueOf(database.sqlEnforceSize));
        map.put(
            HsqlDatabaseProperties.sql_enforce_tdcd,
            String.valueOf(database.sqlEnforceTDCD));
        map.put(
            HsqlDatabaseProperties.sql_enforce_tdcu,
            String.valueOf(database.sqlEnforceTDCU));
        map.put(
            HsqlDatabaseProperties.sql_enforce_types,
            String.valueOf(database.sqlEnforceTypes));
        map.put(
            HsqlDatabaseProperties.sql_ignore_case,
            String.valueOf(database.sqlIgnoreCase));
        map.put(
            HsqlDatabaseProperties.sql_live_object,
            String.valueOf(database.sqlLiveObject));
        map.put(
            HsqlDatabaseProperties.sql_longvar_is_lob,
            String.valueOf(database.sqlLongvarIsLob));
        map.put(
            HsqlDatabaseProperties.sql_lowercase_ident,
            String.valueOf(database.sqlLowerCaseIdentifier));
        map.put(
            HsqlDatabaseProperties.sql_max_recursive,
            String.valueOf(database.sqlMaxRecursive));
        map.put(
            HsqlDatabaseProperties.sql_nulls_first,
            String.valueOf(database.sqlNullsFirst));
        map.put(
            HsqlDatabaseProperties.sql_nulls_order,
            String.valueOf(database.sqlNullsOrder));
        map.put(
            HsqlDatabaseProperties.sql_pad_space,
            String.valueOf(database.collation.isPadSpace()));
        map.put(
            HsqlDatabaseProperties.sql_ref_integrity,
            String.valueOf(database.isReferentialIntegrity()));
        map.put(
            HsqlDatabaseProperties.sql_regular_names,
            String.valueOf(database.sqlRegularNames));
        map.put(
            HsqlDatabaseProperties.sql_restrict_exec,
            String.valueOf(database.sqlRestrictExec));
        map.put(
            HsqlDatabaseProperties.sql_syntax_db2,
            String.valueOf(database.sqlSyntaxDb2));
        map.put(
            HsqlDatabaseProperties.sql_syntax_mss,
            String.valueOf(database.sqlSyntaxMss));
        map.put(
            HsqlDatabaseProperties.sql_syntax_mys,
            String.valueOf(database.sqlSyntaxMys));
        map.put(
            HsqlDatabaseProperties.sql_syntax_ora,
            String.valueOf(database.sqlSyntaxOra));
        map.put(
            HsqlDatabaseProperties.sql_syntax_pgs,
            String.valueOf(database.sqlSyntaxPgs));
        map.put(
            HsqlDatabaseProperties.sql_sys_index_names,
            String.valueOf(database.sqlSysIndexNames));
        map.put(
            HsqlDatabaseProperties.sql_unique_nulls,
            String.valueOf(database.sqlUniqueNulls));

        //
        map.put(
            HsqlDatabaseProperties.jdbc_translate_tti_types,
            String.valueOf(database.sqlTranslateTTI));

        switch (database.txManager.getTransactionControl()) {

            case TransactionManager.MVCC :
                value = Tokens.T_MVCC;
                break;

            case TransactionManager.MVLOCKS :
                value = Tokens.T_MVLOCKS;
                break;

            case TransactionManager.LOCKS :
                value = Tokens.T_LOCKS;
                break;
        }

        map.put(HsqlDatabaseProperties.hsqldb_tx, value);

        switch (database.defaultIsolationLevel) {

            case SessionInterface.TX_READ_COMMITTED :
                value = Tokens.T_READ + '_' + Tokens.T_COMMITTED;
                break;

            case SessionInterface.TX_SERIALIZABLE :
                value = Tokens.T_SERIALIZABLE;
                break;
        }

        map.put(HsqlDatabaseProperties.hsqldb_tx_level, value);
        map.put(
            HsqlDatabaseProperties.hsqldb_reconfig_logging,
            System.getProperty(HsqlDatabaseProperties.hsqldb_reconfig_logging));

        if (HsqlDatabaseProperties.methodClassNames != null) {
            map.put(
                HsqlDatabaseProperties.hsqldb_method_class_names,
                HsqlDatabaseProperties.methodClassNames);
        }

        map.put(
            HsqlDatabaseProperties.hsqldb_applog,
            String.valueOf(appLog.getLevel()));
        map.put(
            HsqlDatabaseProperties.hsqldb_extlog,
            String.valueOf(propExternalEventLogLevel));
        map.put(
            HsqlDatabaseProperties.hsqldb_sqllog,
            String.valueOf(sqlLog.getLevel()));
        map.put(
            HsqlDatabaseProperties.hsqldb_lob_file_scale,
            String.valueOf(propLobBlockSize / 1024));
        map.put(
            HsqlDatabaseProperties.hsqldb_lob_file_compressed,
            String.valueOf(propCompressLobs));
        map.put(
            HsqlDatabaseProperties.hsqldb_cache_file_scale,
            String.valueOf(propDataFileScale));
        map.put(
            HsqlDatabaseProperties.hsqldb_cache_free_count,
            String.valueOf(propMaxFreeBlocks));
        map.put(
            HsqlDatabaseProperties.hsqldb_cache_rows,
            String.valueOf(propCacheMaxRows));
        map.put(
            HsqlDatabaseProperties.hsqldb_cache_size,
            String.valueOf(propCacheMaxSize / 1024));

        {
            String prop;

            switch (database.schemaManager.getDefaultTableType()) {

                case TableBase.CACHED_TABLE :
                    prop = Tokens.T_CACHED;
                    break;

                case TableBase.MEMORY_TABLE :
                default :
                    prop = Tokens.T_MEMORY;
            }

            map.put(HsqlDatabaseProperties.hsqldb_default_table_type, prop);
        }

        map.put(
            HsqlDatabaseProperties.hsqldb_defrag_limit,
            String.valueOf(propDataFileDefragLimit));
        map.put(
            HsqlDatabaseProperties.hsqldb_files_space,
            String.valueOf(propDataFileSpace));
        map.put(
            HsqlDatabaseProperties.hsqldb_files_readonly,
            database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.hsqldb_files_readonly)
            ? "true"
            : "false");
        map.put(
            HsqlDatabaseProperties.hsqldb_large_data,
            String.valueOf(propLargeData));
        map.put(
            HsqlDatabaseProperties.hsqldb_lock_file,
            database.databaseProperties.isPropertyTrue(
                HsqlDatabaseProperties.hsqldb_lock_file)
            ? "true"
            : "false");
        map.put(
            HsqlDatabaseProperties.hsqldb_log_data,
            String.valueOf(propLogData));
        map.put(
            HsqlDatabaseProperties.hsqldb_log_size,
            String.valueOf(propLogSize));
        map.put(
            HsqlDatabaseProperties.hsqldb_nio_data_file,
            String.valueOf(propNioDataFile));
        map.put(
            HsqlDatabaseProperties.hsqldb_nio_max_size,
            String.valueOf(propNioMaxSize / (1024 * 1024)));
        map.put(
            HsqlDatabaseProperties.hsqldb_script_format,
            ScriptWriterBase.LIST_SCRIPT_FORMATS[propScriptFormat].toLowerCase());
        map.put(
            HsqlDatabaseProperties.hsqldb_temp_directory,
            tempDirectoryPath);
        map.put(
            HsqlDatabaseProperties.hsqldb_tx_conflict_rollback,
            String.valueOf(database.txConflictRollback));
        map.put(
            HsqlDatabaseProperties.hsqldb_tx_interrupt_rollback,
            String.valueOf(database.txInterruptRollback));
        map.put(
            HsqlDatabaseProperties.hsqldb_result_max_memory_rows,
            String.valueOf(database.getResultMaxMemoryRows()));
        map.put(
            HsqlDatabaseProperties.hsqldb_readonly,
            database.isReadOnly()
            ? "true"
            : "false");
        map.put(
            HsqlDatabaseProperties.hsqldb_files_readonly,
            database.isFilesReadOnly()
            ? "true"
            : "false");
        map.put(
            HsqlDatabaseProperties.hsqldb_write_delay,
            String.valueOf(propWriteDelay != 0));
        map.put(
            HsqlDatabaseProperties.hsqldb_write_delay_millis,
            String.valueOf(propWriteDelay));
        map.put(
            HsqlDatabaseProperties.hsqldb_digest,
            database.granteeManager.getDigestAlgo());

        return map;
    }

    public List<String> getPropertiesSQLArray(boolean indexRoots) {

        HsqlArrayList<String> list = new HsqlArrayList<>();
        StringBuilder         sb   = new StringBuilder();

        sb.append("SET DATABASE ").append(Tokens.T_UNIQUE).append(' ');
        sb.append(Tokens.T_NAME).append(' ').append(database.getNameString());
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_DEFAULT).append(' ');
        sb.append(Tokens.T_RESULT).append(' ').append(Tokens.T_MEMORY);
        sb.append(' ').append(Tokens.T_ROWS).append(' ');
        sb.append(database.getResultMaxMemoryRows());
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_EVENT).append(' ');
        sb.append(Tokens.T_LOG).append(' ').append(Tokens.T_LEVEL);
        sb.append(' ').append(propEventLogLevel);
        list.add(sb.toString());
        sb.setLength(0);

        if (propExternalEventLogLevel != SimpleLog.LOG_NONE) {
            sb.append("SET DATABASE ").append(Tokens.T_EXTERNAL).append(' ');
            sb.append(Tokens.T_EVENT).append(' ');
            sb.append(Tokens.T_LOG).append(' ').append(Tokens.T_LEVEL);
            sb.append(' ').append(propExternalEventLogLevel);
            list.add(sb.toString());
            sb.setLength(0);
        }

        if (propSqlLogLevel != SimpleLog.LOG_NONE) {
            sb.append("SET DATABASE ").append(Tokens.T_EVENT).append(' ');
            sb.append(Tokens.T_LOG).append(' ').append(Tokens.T_SQL);
            sb.append(' ').append(Tokens.T_LEVEL);
            sb.append(' ').append(propEventLogLevel);
            list.add(sb.toString());
            sb.setLength(0);
        }

        sb.append("SET DATABASE ").append(Tokens.T_TRANSACTION);
        sb.append(' ').append(Tokens.T_CONTROL).append(' ');

        switch (database.txManager.getTransactionControl()) {

            case TransactionManager.MVCC :
                sb.append(Tokens.T_MVCC);
                break;

            case TransactionManager.MVLOCKS :
                sb.append(Tokens.T_MVLOCKS);
                break;

            case TransactionManager.LOCKS :
                sb.append(Tokens.T_LOCKS);
                break;
        }

        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_DEFAULT).append(' ');
        sb.append(Tokens.T_ISOLATION).append(' ').append(Tokens.T_LEVEL);
        sb.append(' ');

        switch (database.defaultIsolationLevel) {

            case SessionInterface.TX_READ_COMMITTED :
                sb.append(Tokens.T_READ).append(' ').append(Tokens.T_COMMITTED);
                break;

            case SessionInterface.TX_SERIALIZABLE :
                sb.append(Tokens.T_SERIALIZABLE);
                break;
        }

        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_TRANSACTION).append(' ');
        sb.append(Tokens.T_ROLLBACK).append(' ');
        sb.append(Tokens.T_ON).append(' ');
        sb.append(Tokens.T_CONFLICT).append(' ');
        sb.append(database.txConflictRollback
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);

        if (database.txInterruptRollback) {
            sb.append("SET DATABASE ").append(Tokens.T_TRANSACTION);
            sb.append(' ').append(Tokens.T_ROLLBACK).append(' ');
            sb.append(Tokens.T_ON).append(' ');
            sb.append(Tokens.T_INTERRUPT).append(' ');
            sb.append(Tokens.T_TRUE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        sb.append("SET DATABASE ").append(Tokens.T_TEXT).append(' ');
        sb.append(Tokens.T_TABLE).append(' ').append(Tokens.T_DEFAULTS);
        sb.append(' ').append('\'');
        sb.append(propTextSourceDefault).append('\'');
        list.add(sb.toString());
        sb.setLength(0);

        String temp = HsqlDatabaseProperties.getStringPropertyDefault(
            HsqlDatabaseProperties.hsqldb_digest);

        if (!temp.equals(database.granteeManager.getDigestAlgo())) {
            sb.append("SET DATABASE ").append(Tokens.T_PASSWORD).append(' ');
            sb.append(Tokens.T_DIGEST).append(' ').append('\'');
            sb.append(database.granteeManager.getDigestAlgo()).append('\'');
            list.add(sb.toString());
            sb.setLength(0);
        }

        if (database.schemaManager.getDefaultTableType()
                == TableBase.CACHED_TABLE) {
            sb.append("SET DATABASE ").append(Tokens.T_DEFAULT).append(' ');
            sb.append(Tokens.T_TABLE).append(' ');
            sb.append(Tokens.T_TYPE).append(' ');
            sb.append(Tokens.T_CACHED);
            list.add(sb.toString());
            sb.setLength(0);
        }

        //
        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_NAMES).append(' ');
        sb.append(database.sqlEnforceNames
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_RESTRICT).append(' ');
        sb.append(Tokens.T_EXEC).append(' ');
        sb.append(database.sqlRestrictExec
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);

        if (!database.sqlRegularNames) {
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_REGULAR).append(' ');
            sb.append(Tokens.T_NAMES).append(' ');
            sb.append(database.sqlRegularNames
                      ? Tokens.T_TRUE
                      : Tokens.T_FALSE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_REFERENCES).append(' ');
        sb.append(database.sqlEnforceRefs
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_SIZE).append(' ');
        sb.append(database.sqlEnforceSize
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_TYPES).append(' ');
        sb.append(database.sqlEnforceTypes
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_TDC).append(' ');
        sb.append(Tokens.T_DELETE).append(' ');
        sb.append(database.sqlEnforceTDCD
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_TDC).append(' ');
        sb.append(Tokens.T_UPDATE).append(' ');
        sb.append(database.sqlEnforceTDCU
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());

        if (!database.sqlTranslateTTI) {
            sb.setLength(0);
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_TRANSLATE).append(' ').append(Tokens.T_TTI);
            sb.append(' ').append(Tokens.T_TYPES).append(' ');
            sb.append(database.sqlTranslateTTI
                      ? Tokens.T_TRUE
                      : Tokens.T_FALSE);
            list.add(sb.toString());
        }

        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_SYS).append(' ').append(Tokens.T_INDEX);
        sb.append(' ').append(Tokens.T_NAMES).append(' ');
        sb.append(database.sqlSysIndexNames
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());

        if (!database.sqlCharLiteral) {
            sb.setLength(0);
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_CHARACTER).append(' ');
            sb.append(Tokens.T_LITERAL).append(' ');
            sb.append(database.sqlCharLiteral
                      ? Tokens.T_TRUE
                      : Tokens.T_FALSE);
            list.add(sb.toString());
        }

        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_CONCAT_WORD).append(' ');
        sb.append(Tokens.T_NULLS).append(' ');
        sb.append(database.sqlConcatNulls
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());

        if (!database.sqlNullsFirst) {
            sb.setLength(0);
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_NULLS).append(' ');
            sb.append(Tokens.T_FIRST).append(' ');
            sb.append(database.sqlNullsFirst
                      ? Tokens.T_TRUE
                      : Tokens.T_FALSE);
            list.add(sb.toString());
        }

        if (!database.sqlNullsOrder) {
            sb.setLength(0);
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_NULLS).append(' ');
            sb.append(Tokens.T_ORDER).append(' ');
            sb.append(database.sqlNullsOrder
                      ? Tokens.T_TRUE
                      : Tokens.T_FALSE);
            list.add(sb.toString());
        }

        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_UNIQUE).append(' ');
        sb.append(Tokens.T_NULLS).append(' ');
        sb.append(database.sqlUniqueNulls
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_CONVERT).append(' ');
        sb.append(Tokens.T_TRUNCATE).append(' ');
        sb.append(database.sqlConvertTruncate
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_AVG).append(' ');
        sb.append(Tokens.T_SCALE).append(' ');
        sb.append(database.sqlAvgScale);
        list.add(sb.toString());
        sb.setLength(0);

        if (database.sqlMaxRecursive
                != HsqlDatabaseProperties.getIntegerPropertyDefault(
                    HsqlDatabaseProperties.sql_max_recursive)) {
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_MAX).append(' ');
            sb.append(Tokens.T_RECURSIVE).append(' ');
            sb.append(database.sqlMaxRecursive);
            list.add(sb.toString());
            sb.setLength(0);
        }

        sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
        sb.append(Tokens.T_DOUBLE).append(' ');
        sb.append(Tokens.T_NAN).append(' ');
        sb.append(database.sqlDoubleNaN
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);

        if (database.sqlIgnoreCase) {
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_IGNORECASE).append(' ');
            sb.append(database.sqlIgnoreCase
                      ? Tokens.T_TRUE
                      : Tokens.T_FALSE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        if (database.sqlLongvarIsLob) {
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_LONGVAR).append(' ');
            sb.append(Tokens.T_IS).append(' ');
            sb.append(Tokens.T_LOB).append(' ');
            sb.append(database.sqlLongvarIsLob
                      ? Tokens.T_TRUE
                      : Tokens.T_FALSE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        if (database.sqlLowerCaseIdentifier) {
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_LOWER).append(' ');
            sb.append(Tokens.T_CASE).append(' ');
            sb.append(Tokens.T_IDENTIFIER).append(' ');
            sb.append(database.sqlLowerCaseIdentifier
                      ? Tokens.T_TRUE
                      : Tokens.T_FALSE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        if (!database.sqlTruncateTrailing) {
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_TRUNCATE).append(' ');
            sb.append(Tokens.T_TRAILING).append(' ');
            sb.append(database.sqlTruncateTrailing
                      ? Tokens.T_TRUE
                      : Tokens.T_FALSE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        if (database.sqlSyntaxDb2) {
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_SYNTAX).append(' ');
            sb.append(Tokens.T_DB2).append(' ');
            sb.append(Tokens.T_TRUE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        if (database.sqlSyntaxMss) {
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_SYNTAX).append(' ');
            sb.append(Tokens.T_MSS).append(' ');
            sb.append(Tokens.T_TRUE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        if (database.sqlSyntaxMys) {
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_SYNTAX).append(' ');
            sb.append(Tokens.T_MYS).append(' ');
            sb.append(Tokens.T_TRUE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        if (database.sqlSyntaxOra) {
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_SYNTAX).append(' ');
            sb.append(Tokens.T_ORA).append(' ');
            sb.append(Tokens.T_TRUE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        if (database.sqlSyntaxPgs) {
            sb.append("SET DATABASE ").append(Tokens.T_SQL).append(' ');
            sb.append(Tokens.T_SYNTAX).append(' ');
            sb.append(Tokens.T_PGS).append(' ');
            sb.append(Tokens.T_TRUE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        //
        int     delay  = propWriteDelay;
        boolean millis = delay > 0 && delay < 1000;

        if (millis) {
            if (delay < 20) {
                delay = 20;
            }
        } else {
            delay /= 1000;
        }

        sb.append("SET FILES ").append(Tokens.T_WRITE).append(' ');
        sb.append(Tokens.T_DELAY).append(' ').append(delay);

        if (millis) {
            sb.append(' ').append(Tokens.T_MILLIS);
        }

        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET FILES ").append(Tokens.T_BACKUP);
        sb.append(' ').append(Tokens.T_INCREMENT).append(' ');
        sb.append(Tokens.T_TRUE);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET FILES ").append(Tokens.T_CACHE);
        sb.append(' ').append(Tokens.T_SIZE).append(' ');
        sb.append(propCacheMaxSize / 1024);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET FILES ").append(Tokens.T_CACHE);
        sb.append(' ').append(Tokens.T_ROWS).append(' ');
        sb.append(propCacheMaxRows);
        list.add(sb.toString());

        {
            int fileScale = propDataFileScale;

            if (!indexRoots && fileScale < 32) {
                fileScale = 32;
            }

            sb.setLength(0);
            sb.append("SET FILES ").append(Tokens.T_SCALE);
            sb.append(' ').append(fileScale);
            list.add(sb.toString());
            sb.setLength(0);
        }

        if (propDataFileSpace != 0) {
            sb.append("SET FILES ").append(Tokens.T_SPACE).append(' ');
            sb.append(propDataFileSpace);
            list.add(sb.toString());
            sb.setLength(0);
        }

        sb.append("SET FILES ").append(Tokens.T_LOB).append(' ');
        sb.append(Tokens.T_SCALE);
        sb.append(' ').append(getLobFileScale());
        list.add(sb.toString());
        sb.setLength(0);

        if (propCompressLobs) {
            sb.append("SET FILES ").append(Tokens.T_LOB).append(' ');
            sb.append(Tokens.T_COMPRESSED).append(' ');
            sb.append(Tokens.T_TRUE);
            list.add(sb.toString());
            sb.setLength(0);
        }

        sb.append("SET FILES ").append(Tokens.T_DEFRAG).append(' ');
        sb.append(propDataFileDefragLimit);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET FILES ").append(Tokens.T_NIO).append(' ');
        sb.append(propNioDataFile
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET FILES ").append(Tokens.T_NIO).append(' ');
        sb.append(Tokens.T_SIZE).append(' ');
        sb.append(propNioMaxSize / (1024 * 1024));
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET FILES ").append(Tokens.T_LOG).append(' ');
        sb.append(propLogData
                  ? Tokens.T_TRUE
                  : Tokens.T_FALSE);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET FILES ").append(Tokens.T_LOG).append(' ');
        sb.append(Tokens.T_SIZE).append(' ').append(propLogSize);
        list.add(sb.toString());
        sb.setLength(0);
        sb.append("SET FILES ").append(Tokens.T_CHECK).append(' ');
        sb.append(propFilesTimestamp);
        list.add(sb.toString());
        sb.setLength(0);

        return list;
    }

    public void backup(
            String destPath,
            boolean script,
            boolean blocking,
            boolean compressed,
            boolean files) {

        if (!backupState.compareAndSet(stateNormal, stateBackup)) {
            throw Error.error(ErrorCode.BACKUP_ERROR, "backup in progress");
        }

        if (blocking) {
            database.lobManager.lock();

            try {
                synchronized (this) {
                    backupInternal(
                        destPath,
                        script,
                        blocking,
                        compressed,
                        files);
                }
            } finally {
                backupState.set(stateNormal);
                database.lobManager.unlock();
            }
        } else {
            try {
                backupInternal(destPath, script, blocking, compressed, files);
            } finally {
                backupState.set(stateNormal);
            }
        }
    }

    public SimpleDateFormat fileDateFormat = new SimpleDateFormat(
        "yyyyMMdd'T'HHmmss");
    private static final char runtimeFileDelim = System.getProperty(
        "file.separator")
            .charAt(0);
    DbBackup backup;

    void backupInternal(
            String destPath,
            boolean script,
            boolean blocking,
            boolean compressed,
            boolean asFiles) {

        String scriptName = null;
        String dbPath     = database.getPath();

        /* If we want to add db Id also, will need to pass either Database
         * instead of dbPath, or pass dbPath + Id from StatementCommand.
         */
        String  instanceName = new File(dbPath).getName();
        char    lastChar     = destPath.charAt(destPath.length() - 1);
        boolean generateName = (lastChar == '/'
                                || lastChar == runtimeFileDelim);
        File    archiveFile;

        if (asFiles) {
            if (!generateName) {
                throw Error.error(
                    null,
                    ErrorCode.UNSUPPORTED_FILENAME_SUFFIX,
                    0,
                    new String[]{ "", "/" });
            }

            destPath = getSecurePath(destPath, true, false);

            if (destPath == null) {
                throw Error.error(
                    ErrorCode.BACKUP_ERROR,
                    "access to directory denied");
            }

            archiveFile = new File(destPath);

            archiveFile.mkdirs();

            File[] files = FileUtil.getDatabaseMainFileList(
                destPath + instanceName);

            if (files == null || files.length != 0) {
                throw Error.error(
                    ErrorCode.BACKUP_ERROR,
                    "files exist in directory");
            }
        } else {
            String defaultSuffix = compressed
                                   ? ".tar.gz"
                                   : ".tar";

            if (generateName) {
                archiveFile = (new File(
                    destPath.substring(0, destPath.length() - 1),
                    instanceName + '-'
                    + fileDateFormat.format(new java.util.Date())
                    + defaultSuffix));
            } else {
                archiveFile = new File(destPath);
            }

            boolean nameImpliesCompress = archiveFile.getName().endsWith(
                ".tar.gz")
                                          || archiveFile.getName().endsWith(
                                              ".tgz");

            if ((!nameImpliesCompress)
                    && !archiveFile.getName().endsWith(".tar")) {
                throw Error.error(
                    null,
                    ErrorCode.UNSUPPORTED_FILENAME_SUFFIX,
                    0,
                    new String[]{ archiveFile.getName(),
                                  ".tar, .tar.gz, .tgz" });
            }

            if (compressed != nameImpliesCompress) {
                throw Error.error(
                    null,
                    ErrorCode.COMPRESSION_SUFFIX_MISMATCH,
                    0,
                    new String[]{ String.valueOf(
                        compressed), archiveFile.getName() });
            }

            if (archiveFile.exists()) {
                throw Error.error(
                    ErrorCode.BACKUP_ERROR,
                    "file exists :" + archiveFile.getName());
            }
        }

        if (blocking) {
            log.checkpointClose();
        }

        try {
            logInfoEvent(
                "Initiating backup of instance '" + instanceName + "'");

            // By default, DbBackup will throw if archiveFile (or
            // corresponding work file) already exist.  That's just what we
            // want here.
            if (script) {
                String path = getTempDirectoryPath();

                if (path == null) {
                    return;
                }

                path       = path + "/" + new File(
                    database.getPath()).getName();
                scriptName = path + scriptFileExtension;

                ScriptWriterText dsw = new ScriptWriterText(
                    database,
                    scriptName,
                    true,
                    true,
                    true);

                dsw.writeAll();
                dsw.close();

                backup = new DbBackup(archiveFile, path, true);

                backup.write();
            } else {
                backup = new DbBackup(archiveFile, dbPath);

                backup.setAbortUponModify(false);

                if (!blocking) {
                    InputStreamWrapper isw;
                    File               file = null;

                    if (hasCache()) {
                        DataFileCache dataFileCache = getCache();
                        RAShadowFile  shadowFile =
                            dataFileCache.getShadowFile();

                        file = new File(dataFileCache.dataFileName);
                        isw  = new InputStreamWrapper(
                            new FileInputStream(file));

                        isw.setSizeLimit(dataFileCache.fileStartFreePosition);
                        backup.setStream(dataFileExtension, isw);

                        InputStreamInterface isi = shadowFile.getInputStream();

                        backup.setStream(backupFileExtension, isi);
                    }

                    // log
                    file = new File(log.getLogFileName());

                    long fileLength = file.length();

                    if (fileLength == 0) {
                        backup.setFileIgnore(logFileExtension);
                    } else {
                        isw = new InputStreamWrapper(new FileInputStream(file));

                        isw.setSizeLimit(fileLength);
                        backup.setStream(logFileExtension, isw);
                    }
                }

                if (asFiles) {
                    backup.writeAsFiles();
                } else {
                    backup.write();
                }
            }

            logInfoEvent(
                "Successfully backed up instance '" + instanceName + "' to '"
                + destPath + "'");
        } catch (IOException ioe) {
            throw Error.error(ioe, ErrorCode.FILE_IO_ERROR, ioe.toString());
        } catch (TarMalformatException tme) {
            throw Error.error(tme, ErrorCode.FILE_IO_ERROR, tme.toString());
        } finally {
            if (scriptName != null) {
                FileUtil.getFileUtil().delete(scriptName);
            }

            if (blocking) {
                log.checkpointReopen();
            }
        }
    }

    /**
     *  Returns a secure path or null for a user-defined path when
     *  hsqldb.allow_full_path is false. Returns the path otherwise.
     *
     */
    public String getSecurePath(
            String path,
            boolean allowFull,
            boolean includeRes) {

        if (database.getType() == DatabaseType.DB_RES) {
            if (includeRes) {
                return path;
            } else {
                return null;
            }
        }

        if (database.getType() == DatabaseType.DB_MEM) {
            if (propTextAllowFullPath) {
                return path;
            } else {
                return null;
            }
        }

        // absolute paths
        if (path.startsWith("/")
                || path.startsWith("\\")
                || path.contains(":")) {
            if (allowFull || propTextAllowFullPath) {
                return path;
            } else {
                return null;
            }
        }

        if (path.contains("..")) {
            if (allowFull || propTextAllowFullPath) {

                // allow
            } else {
                return null;
            }
        }

        String fullPath = new File(
            new File(database.getPath()
                     + ".properties").getAbsolutePath()).getParent();

        if (fullPath != null) {
            path = fullPath + File.separator + path;
        }

        return path;
    }

    public boolean isNewDatabase() {
        return isNewDatabase;
    }
}
