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