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