/**
* Releases the link betwen the session and all compiled statement objects it is linked to.
*
* <p>If any such statement is not linked with any other session, it is removed from management.
*
* @param sid the session identifier
*/
synchronized void removeSession(int sid) {
IntKeyIntValueHashMap scsMap;
int csid;
Iterator i;
scsMap = (IntKeyIntValueHashMap) sessionMap.remove(sid);
if (scsMap == null) {
return;
}
i = scsMap.keySet().iterator();
while (i.hasNext()) {
csid = i.nextInt();
int usecount = useMap.get(csid, 1) - 1;
if (usecount == 0) {
String sql = (String) sqlLookup.remove(csid);
sqlMap.remove(sql);
csidMap.remove(csid);
useMap.remove(csid);
} else {
useMap.put(csid, usecount);
}
}
}
/**
* Used after a DDL change that could impact the compiled statements. Clears references to
* CompiledStatement objects while keeping the counts and references to the sql strings.
*/
synchronized void resetStatements() {
Iterator it = csidMap.keySet().iterator();
while (it.hasNext()) {
int key = it.nextInt();
csidMap.put(key, null);
}
}
/** Clears all internal data structures, removing any references to compiled statements. */
synchronized void reset() {
sqlMap.clear();
sqlLookup.clear();
csidMap.clear();
sessionMap.clear();
useMap.clear();
next_cs_id = 0;
}
/**
* Registers a compiled statement to be managed.
*
* <p>The only caller should be a Session that is attempting to prepare a statement for the first
* time, or a statement that has been invalidated due to DDL changes.
*
* @param csid existing id or negative if the statement is not yet managed
* @param cs The CompiledStatement to add
* @return The compiled statement id assigned to the CompiledStatement object
*/
synchronized int registerStatement(int csid, CompiledStatement cs) {
if (csid < 0) {
csid = nextID();
sqlMap.put(cs.sql, csid);
sqlLookup.put(csid, cs.sql);
}
csidMap.put(csid, cs);
return csid;
}
/**
* Links a session with a registered compiled statement.
*
* <p>If this session has not already been linked with the given statement, then the statement use
* count is incremented.
*
* @param csid the compiled statement identifier
* @param sid the session identifier
*/
synchronized void linkSession(int csid, int sid) {
IntKeyIntValueHashMap scsMap;
scsMap = (IntKeyIntValueHashMap) sessionMap.get(sid);
if (scsMap == null) {
scsMap = new IntKeyIntValueHashMap();
sessionMap.put(sid, scsMap);
}
int count = scsMap.get(csid, 0);
scsMap.put(csid, count + 1);
if (count == 0) {
useMap.put(csid, useMap.get(csid, 0) + 1);
}
}
/**
* Removes the link between a session and a compiled statement.
*
* <p>If the statement is not linked with any other session, it is removed from management.
*
* @param csid the compiled statment identifier
* @param sid the session identifier
*/
synchronized void freeStatement(int csid, int sid) {
IntKeyIntValueHashMap scsMap = (IntKeyIntValueHashMap) sessionMap.get(sid);
int count = scsMap.get(csid) - 1;
if (count != 0) {
scsMap.put(csid, count);
} else {
scsMap.remove(csid);
int usecount = useMap.get(csid, 1) - 1;
if (usecount == 0) {
String sql = (String) sqlLookup.remove(csid);
sqlMap.remove(sql);
csidMap.remove(csid);
useMap.remove(csid);
} else {
useMap.put(csid, usecount);
}
}
}
/**
* This is used to read the *.log file and manage any necessary transaction rollback.
*
* @throws HsqlException
*/
public static void runScript(Database database, String logFilename, int logType)
throws HsqlException {
IntKeyHashMap sessionMap = new IntKeyHashMap();
Session sysSession = database.getSessionManager().getSysSession(null, false);
Session current = sysSession;
int currentId = 0;
database.setReferentialIntegrity(false);
ScriptReaderBase scr = null;
try {
StopWatch sw = new StopWatch();
scr =
ScriptReaderBase.newScriptReader(database, logFilename, ScriptWriterBase.SCRIPT_TEXT_170);
while (scr.readLoggedStatement(current)) {
int sessionId = scr.getSessionNumber();
if (currentId != sessionId) {
currentId = sessionId;
current = (Session) sessionMap.get(currentId);
if (current == null) {
current =
database
.getSessionManager()
.newSession(database, sysSession.getUser(), false, true);
sessionMap.put(currentId, current);
}
}
if (current.isClosed()) {
sessionMap.remove(currentId);
continue;
}
String schema = current.currentSchema.name;
Result result = null;
switch (scr.getStatementType()) {
case ScriptReaderBase.ANY_STATEMENT:
result = current.sqlExecuteDirectNoPreChecks(scr.getLoggedStatement());
if (result != null && result.mode == ResultConstants.ERROR) {
if (result.getException() != null) {
throw result.getException();
}
throw Trace.error(result);
}
break;
case ScriptReaderBase.SEQUENCE_STATEMENT:
scr.getCurrentSequence().reset(scr.getSequenceValue());
break;
case ScriptReaderBase.COMMIT_STATEMENT:
current.commit();
break;
case ScriptReaderBase.INSERT_STATEMENT:
{
Object[] data = scr.getData();
scr.getCurrentTable().insertNoCheckFromLog(current, data);
break;
}
case ScriptReaderBase.DELETE_STATEMENT:
{
Object[] data = scr.getData();
scr.getCurrentTable().deleteNoCheckFromLog(current, data);
break;
}
case ScriptReaderBase.SCHEMA_STATEMENT:
{
current.setSchema(scr.getCurrentSchema());
}
}
if (current.isClosed()) {
sessionMap.remove(currentId);
}
}
} catch (Throwable e) {
String message;
// catch out-of-memory errors and terminate
if (e instanceof OutOfMemoryError) {
message = "out of memory processing " + logFilename + " line: " + scr.getLineNumber();
database.logger.appLog.logContext(message);
throw Trace.error(Trace.OUT_OF_MEMORY);
}
// stop processing on bad log line
message = logFilename + " line: " + scr.getLineNumber() + " " + e.getMessage();
database.logger.appLog.logContext(message);
Trace.printSystemOut(message);
} finally {
if (scr != null) {
scr.close();
}
database.getSessionManager().closeAllSessions();
database.setReferentialIntegrity(true);
}
}
/** Returns SQL type string for a java.sql.Types int value */
static String getTypeString(int type) {
return (String) typeNames.get(type);
}
static {
typeAliases = new IntValueHashMap(67, 1);
typeAliases.put("INTEGER", Types.INTEGER);
typeAliases.put("INT", Types.INTEGER);
typeAliases.put("int", Types.INTEGER);
typeAliases.put("java.lang.Integer", Types.INTEGER);
typeAliases.put("IDENTITY", Types.INTEGER);
typeAliases.put("DOUBLE", Types.DOUBLE);
typeAliases.put("double", Types.DOUBLE);
typeAliases.put("java.lang.Double", Types.DOUBLE);
typeAliases.put("FLOAT", Types.FLOAT);
typeAliases.put("REAL", Types.REAL);
typeAliases.put("VARCHAR", Types.VARCHAR);
typeAliases.put("java.lang.String", Types.VARCHAR);
typeAliases.put("CHAR", Types.CHAR);
typeAliases.put("CHARACTER", Types.CHAR);
typeAliases.put("LONGVARCHAR", Types.LONGVARCHAR);
typeAliases.put("VARCHAR_IGNORECASE", VARCHAR_IGNORECASE);
typeAliases.put("DATE", Types.DATE);
typeAliases.put("java.sql.Date", Types.DATE);
typeAliases.put("TIME", Types.TIME);
typeAliases.put("java.sql.Time", Types.TIME);
typeAliases.put("TIMESTAMP", Types.TIMESTAMP);
typeAliases.put("java.sql.Timestamp", Types.TIMESTAMP);
typeAliases.put("DATETIME", Types.TIMESTAMP);
typeAliases.put("DECIMAL", Types.DECIMAL);
typeAliases.put("java.math.BigDecimal", Types.DECIMAL);
typeAliases.put("NUMERIC", Types.NUMERIC);
typeAliases.put("BIT", Types.BIT);
typeAliases.put("boolean", Types.BIT);
typeAliases.put("java.lang.Boolean", Types.BIT);
typeAliases.put("TINYINT", Types.TINYINT);
typeAliases.put("byte", Types.TINYINT);
typeAliases.put("java.lang.Byte", Types.TINYINT);
typeAliases.put("SMALLINT", Types.SMALLINT);
typeAliases.put("short", Types.SMALLINT);
typeAliases.put("java.lang.Short", Types.SMALLINT);
typeAliases.put("BIGINT", Types.BIGINT);
typeAliases.put("long", Types.BIGINT);
typeAliases.put("java.lang.Long", Types.BIGINT);
typeAliases.put("BINARY", Types.BINARY);
typeAliases.put("[B", Types.BINARY);
typeAliases.put("VARBINARY", Types.VARBINARY);
typeAliases.put("LONGVARBINARY", Types.LONGVARBINARY);
typeAliases.put("OTHER", Types.OTHER);
typeAliases.put("OBJECT", Types.OTHER);
typeAliases.put("java.lang.Object", Types.OTHER);
typeAliases.put("NULL", Types.NULL);
typeAliases.put("void", Types.NULL);
typeAliases.put("java.lang.Void", Types.NULL);
//
typeNames = new IntKeyHashMap(37);
typeNames.put(Types.NULL, "NULL");
typeNames.put(Types.INTEGER, "INTEGER");
typeNames.put(Types.DOUBLE, "DOUBLE");
typeNames.put(VARCHAR_IGNORECASE, "VARCHAR_IGNORECASE");
typeNames.put(Types.VARCHAR, "VARCHAR");
typeNames.put(Types.CHAR, "CHAR");
typeNames.put(Types.LONGVARCHAR, "LONGVARCHAR");
typeNames.put(Types.DATE, "DATE");
typeNames.put(Types.TIME, "TIME");
typeNames.put(Types.DECIMAL, "DECIMAL");
typeNames.put(Types.BIT, "BIT");
typeNames.put(Types.TINYINT, "TINYINT");
typeNames.put(Types.SMALLINT, "SMALLINT");
typeNames.put(Types.BIGINT, "BIGINT");
typeNames.put(Types.REAL, "REAL");
typeNames.put(Types.FLOAT, "FLOAT");
typeNames.put(Types.NUMERIC, "NUMERIC");
typeNames.put(Types.TIMESTAMP, "TIMESTAMP");
typeNames.put(Types.BINARY, "BINARY");
typeNames.put(Types.VARBINARY, "VARBINARY");
typeNames.put(Types.LONGVARBINARY, "LONGVARBINARY");
typeNames.put(Types.OTHER, "OBJECT");
//
illegalParameterClasses = new org.hsqldb.lib.HashSet(13);
illegalParameterClasses.add(Byte.TYPE);
illegalParameterClasses.add(Short.TYPE);
illegalParameterClasses.add(Float.TYPE);
illegalParameterClasses.add(Byte.class);
illegalParameterClasses.add(Short.class);
illegalParameterClasses.add(Float.class);
}
/**
* Retreives the sql statement for a registered compiled statement.
*
* @param csid the compiled statement identifier
* @return sql string
*/
synchronized String getSql(int csid) {
return (String) sqlLookup.get(csid);
}
/**
* Retrieves the CompiledStatement object having the specified compiled statement identifier, or
* null if the CompiledStatement object has been invalidated.
*
* @param csid the identifier of the requested CompiledStatement object
* @return the requested CompiledStatement object
*/
synchronized CompiledStatement getStatement(int csid) {
return (CompiledStatement) csidMap.get(csid);
}