/**
   * 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 -1 performs SHUTDOWN IMMEDIATELY, equivalent to a poweroff or crash.
   *       <LI>closemode 0 performs a normal SHUTDOWN that checkpoints the database normally.
   *       <LI>closemode 1 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.
   *     </OL>
   *
   * @return true if closed with no problems or false if a problem was encountered.
   */
  boolean closeLog(int closemode) {

    if (lLog == null) {
      return true;
    }

    try {
      lLog.stop();

      switch (closemode) {
        case Database.CLOSEMODE_IMMEDIATELY:
          lLog.shutdown();
          break;

        case Database.CLOSEMODE_NORMAL:
          lLog.close(false, true);
          break;

        case Database.CLOSEMODE_COMPACT:
        case Database.CLOSEMODE_SCRIPT:
          lLog.close(true, true);
          break;
      }
    } catch (Throwable e) {
      lLog = null;

      return false;
    }

    lLog = null;

    return true;
  }
  /** Returns the Cache object or null if one doesn't exist. */
  DataFileCache getCache() throws HsqlException {

    if (lLog != null) {
      return lLog.getCache();
    } else {
      return null;
    }
  }
  /**
   * 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.
   *
   * @param db the Database
   * @throws HsqlException if there is a problem, such as the case when the specified files are in
   *     use by another process
   */
  void openLog(Database db) throws HsqlException {

    String path;

    // NOTE:
    // this method never gets called unless path is non-null
    // so no check here
    path = db.getPath();

    if (db.isFilesInJar()) {
      checkFilesInJar(path);
    }

    if (!db.isFilesReadOnly()) {
      acquireLock(path);
    }

    lLog = new Log(db, path);

    lLog.open();
  }
 /** Closes the TextCache object. */
 void closeTextCache(Table table) throws HsqlException {
   lLog.closeTextCache(table);
 }
 /** Opens the TextCache object. */
 DataFileCache openTextCache(Table table, String source, boolean readOnlyData, boolean reversed)
     throws HsqlException {
   return lLog.openTextCache(table, source, readOnlyData, reversed);
 }
  /**
   * Sets the log write delay mode on or off. When write delay mode is switched on, the strategy is
   * that executed commands are written to the log at most 1 second after they are executed. This
   * may improve 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. When switched off, the strategy is that all SQL commands
   * are written to the log immediately after they are executed, resulting in possibly slower
   * execution but with the maximum risk being the loss of at most one statement in the event of a
   * crash.
   *
   * @param delay if true, used a delayed write strategy, else use an immediate write strategy
   */
  void setWriteDelay(int delay) {

    if (lLog != null) {
      lLog.setWriteDelay(delay);
    }
  }
  /**
   * Sets the type of script file, currently 0 for text (default) 1 for binary and 3 for compressed
   *
   * @param i The type
   */
  void setScriptType(int i) throws HsqlException {

    if (lLog != null) {
      lLog.setScriptType(i);
    }
  }
  /**
   * Sets the maximum size to which the log file can grow before being automatically checkpointed.
   *
   * @param megas size in MB
   */
  void setLogSize(int megas) {

    if (lLog != null) {
      lLog.setLogSize(megas);
    }
  }
  /**
   * 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
   * properites of the database.
   *
   * @throws HsqlException if there is a problem checkpointing the database
   */
  void checkpoint(boolean mode) throws HsqlException {

    if (lLog != null) {
      lLog.checkpoint(mode);
    }
  }
  void writeSequenceStatement(Session c, NumberSequence s) throws HsqlException {

    if (lLog != null) {
      lLog.writeSequenceStatement(c, s);
    }
  }
  void writeDeleteStatement(Session c, Table t, Object[] row) throws HsqlException {

    if (lLog != null) {
      lLog.writeDeleteStatement(c, t, row);
    }
  }
  void writeInsertStatement(Session session, Table table, Object[] row) throws HsqlException {

    if (lLog != null) {
      lLog.writeInsertStatement(session, table, row);
    }
  }
  /**
   * Records a Log entry for the specified SQL statement, on behalf of the specified Session object.
   *
   * @param session the Session object for which to record the Log entry
   * @param statement the SQL statement to Log
   * @throws HsqlException if there is a problem recording the entry
   */
  void writeToLog(Session session, String statement) throws HsqlException {

    if (lLog != null) {
      lLog.writeStatement(session, statement);
    }
  }