| /* Copyright (c) 2001-2010, 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; |
| |
| import org.hsqldb.HsqlNameManager.HsqlName; |
| import org.hsqldb.error.Error; |
| import org.hsqldb.error.ErrorCode; |
| import org.hsqldb.lib.HsqlArrayList; |
| import org.hsqldb.navigator.RowIterator; |
| import org.hsqldb.result.Result; |
| import org.hsqldb.rights.Grantee; |
| import org.hsqldb.rights.User; |
| import org.hsqldb.types.DTIType; |
| import org.hsqldb.types.IntervalSecondData; |
| import org.hsqldb.types.Type; |
| |
| /** |
| * Implementation of Statement for SQL session statements.<p> |
| * |
| * @author Fred Toussi (fredt@users dot sourceforge.net) |
| * @version 1.9.0 |
| * @since 1.9.0 |
| */ |
| public class StatementSession extends Statement { |
| |
| Expression[] expressions; |
| Object[] parameters; |
| |
| StatementSession(int type, Expression[] args) { |
| |
| super(type); |
| |
| this.expressions = args; |
| isTransactionStatement = false; |
| |
| switch (type) { |
| |
| case StatementTypes.SET_PATH : |
| case StatementTypes.SET_TIME_ZONE : |
| case StatementTypes.SET_NAMES : |
| case StatementTypes.SET_ROLE : |
| case StatementTypes.SET_SCHEMA : |
| case StatementTypes.SET_CATALOG : |
| case StatementTypes.SET_SESSION_AUTHORIZATION : |
| case StatementTypes.SET_COLLATION : |
| group = StatementTypes.X_SQL_SESSION; |
| break; |
| |
| default : |
| throw Error.runtimeError(ErrorCode.U_S0500, |
| "StateemntSession"); |
| } |
| } |
| |
| StatementSession(int type, Object[] args) { |
| |
| super(type); |
| |
| this.parameters = args; |
| isTransactionStatement = false; |
| isLogged = false; |
| |
| switch (type) { |
| |
| // logged by statement |
| case StatementTypes.SET_SCHEMA : |
| group = StatementTypes.X_SQL_SESSION; |
| isLogged = true; |
| break; |
| |
| case StatementTypes.DECLARE_VARIABLE : |
| group = StatementTypes.X_HSQLDB_SESSION; |
| isLogged = true; |
| break; |
| |
| // cursor |
| case StatementTypes.ALLOCATE_CURSOR : |
| group = StatementTypes.X_SQL_DATA; |
| break; |
| |
| case StatementTypes.ALLOCATE_DESCRIPTOR : |
| case StatementTypes.DEALLOCATE_DESCRIPTOR : |
| case StatementTypes.DEALLOCATE_PREPARE : |
| group = StatementTypes.X_DYNAMIC; |
| break; |
| |
| // |
| case StatementTypes.DYNAMIC_DELETE_CURSOR : |
| group = StatementTypes.X_SQL_DATA_CHANGE; |
| break; |
| |
| case StatementTypes.DYNAMIC_CLOSE : |
| case StatementTypes.DYNAMIC_FETCH : |
| case StatementTypes.DYNAMIC_OPEN : |
| group = StatementTypes.X_SQL_DATA; |
| break; |
| |
| // |
| case StatementTypes.OPEN : |
| case StatementTypes.FETCH : |
| case StatementTypes.FREE_LOCATOR : |
| case StatementTypes.GET_DESCRIPTOR : |
| case StatementTypes.HOLD_LOCATOR : |
| group = StatementTypes.X_SQL_DATA; |
| break; |
| |
| // |
| case StatementTypes.PREPARABLE_DYNAMIC_DELETE_CURSOR : |
| case StatementTypes.PREPARABLE_DYNAMIC_UPDATE_CURSOR : |
| case StatementTypes.PREPARE : |
| group = StatementTypes.X_DYNAMIC; |
| break; |
| |
| // logged by session |
| case StatementTypes.DISCONNECT : |
| group = StatementTypes.X_SQL_CONNECTION; |
| break; |
| |
| // |
| case StatementTypes.SET_CONNECTION : |
| case StatementTypes.SET_CONSTRAINT : |
| case StatementTypes.SET_DESCRIPTOR : |
| case StatementTypes.SET_SESSION_CHARACTERISTICS : |
| case StatementTypes.SET_TRANSFORM_GROUP : |
| case StatementTypes.SET_SESSION_RESULT_MAX_ROWS : |
| case StatementTypes.SET_SESSION_RESULT_MEMORY_ROWS : |
| case StatementTypes.SET_SESSION_AUTOCOMMIT : |
| case StatementTypes.SET_SESSION_SQL_IGNORECASE : |
| group = StatementTypes.X_HSQLDB_SESSION; |
| break; |
| |
| // logged by session if necessary |
| case StatementTypes.COMMIT_WORK : |
| case StatementTypes.RELEASE_SAVEPOINT : |
| case StatementTypes.ROLLBACK_SAVEPOINT : |
| case StatementTypes.ROLLBACK_WORK : |
| case StatementTypes.SAVEPOINT : |
| case StatementTypes.SET_TRANSACTION : |
| case StatementTypes.START_TRANSACTION : |
| group = StatementTypes.X_SQL_TRANSACTION; |
| break; |
| |
| case StatementTypes.DECLARE_SESSION_TABLE : |
| case StatementTypes.DROP_TABLE : |
| group = StatementTypes.X_SQL_SESSION; |
| break; |
| |
| default : |
| throw Error.runtimeError(ErrorCode.U_S0500, |
| "StatementSession"); |
| } |
| } |
| |
| StatementSession(int type, HsqlName[] readNames, HsqlName[] writeNames) { |
| |
| super(type); |
| |
| this.isTransactionStatement = true; |
| this.readTableNames = readNames; |
| writeTableNames = writeNames; |
| |
| switch (type) { |
| |
| case StatementTypes.TRANSACTION_LOCK_TABLE : |
| group = StatementTypes.X_HSQLDB_TRANSACTION; |
| break; |
| |
| default : |
| throw Error.runtimeError(ErrorCode.U_S0500, |
| "StatementSession"); |
| } |
| } |
| |
| public Result execute(Session session) { |
| |
| Result result; |
| |
| try { |
| result = getResult(session); |
| } catch (Throwable t) { |
| result = Result.newErrorResult(t, null); |
| } |
| |
| if (result.isError()) { |
| result.getException().setStatementType(group, type); |
| |
| return result; |
| } |
| |
| try { |
| if (isLogged) { |
| session.database.logger.writeToLog(session, sql); |
| } |
| } catch (Throwable e) { |
| return Result.newErrorResult(e, sql); |
| } |
| |
| return result; |
| } |
| |
| Result getResult(Session session) { |
| |
| boolean startTransaction = false; |
| |
| if (this.isExplain) { |
| return Result.newSingleColumnStringResult("OPERATION", |
| describe(session)); |
| } |
| |
| switch (type) { |
| |
| // cursor |
| case StatementTypes.ALLOCATE_CURSOR : |
| case StatementTypes.ALLOCATE_DESCRIPTOR : |
| return Result.updateZeroResult; |
| |
| // |
| case StatementTypes.COMMIT_WORK : { |
| try { |
| boolean chain = parameters != null; |
| |
| session.commit(chain); |
| |
| return Result.updateZeroResult; |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| case StatementTypes.DEALLOCATE_DESCRIPTOR : |
| case StatementTypes.DEALLOCATE_PREPARE : |
| return Result.updateZeroResult; |
| |
| case StatementTypes.DISCONNECT : |
| session.close(); |
| |
| return Result.updateZeroResult; |
| |
| // |
| case StatementTypes.DYNAMIC_CLOSE : |
| case StatementTypes.DYNAMIC_DELETE_CURSOR : |
| case StatementTypes.DYNAMIC_FETCH : |
| case StatementTypes.DYNAMIC_OPEN : |
| |
| // |
| case StatementTypes.FETCH : |
| case StatementTypes.FREE_LOCATOR : |
| case StatementTypes.GET_DESCRIPTOR : |
| case StatementTypes.HOLD_LOCATOR : |
| |
| // |
| case StatementTypes.OPEN : |
| case StatementTypes.PREPARABLE_DYNAMIC_DELETE_CURSOR : |
| case StatementTypes.PREPARABLE_DYNAMIC_UPDATE_CURSOR : |
| case StatementTypes.PREPARE : |
| return Result.updateZeroResult; |
| |
| case StatementTypes.TRANSACTION_LOCK_TABLE : { |
| return Result.updateZeroResult; |
| } |
| case StatementTypes.RELEASE_SAVEPOINT : { |
| String savepoint = (String) parameters[0]; |
| |
| try { |
| session.releaseSavepoint(savepoint); |
| |
| return Result.updateZeroResult; |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| case StatementTypes.ROLLBACK_WORK : { |
| boolean chain = ((Boolean) parameters[0]).booleanValue(); |
| |
| session.rollback(chain); |
| |
| return Result.updateZeroResult; |
| } |
| case StatementTypes.ROLLBACK_SAVEPOINT : { |
| String savepoint = (String) parameters[0]; |
| |
| try { |
| session.rollbackToSavepoint(savepoint); |
| |
| return Result.updateZeroResult; |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| case StatementTypes.SAVEPOINT : { |
| String savepoint = (String) parameters[0]; |
| |
| session.savepoint(savepoint); |
| |
| return Result.updateZeroResult; |
| } |
| case StatementTypes.SET_CATALOG : { |
| String name; |
| |
| try { |
| name = (String) expressions[0].getValue(session); |
| name = (String) Type.SQL_VARCHAR.trim(session, name, ' ', |
| true, true); |
| |
| if (session.database.getCatalogName().name.equals(name)) { |
| return Result.updateZeroResult; |
| } |
| |
| return Result.newErrorResult( |
| Error.error(ErrorCode.X_3D000), sql); |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| case StatementTypes.SET_CONNECTION : |
| case StatementTypes.SET_CONSTRAINT : |
| case StatementTypes.SET_DESCRIPTOR : |
| return Result.updateZeroResult; |
| |
| case StatementTypes.SET_TIME_ZONE : { |
| Object value = null; |
| |
| if (expressions[0].getType() == OpTypes.VALUE |
| && expressions[0].getConstantValueNoCheck(session) |
| == null) { |
| session.setZoneSeconds(session.sessionTimeZoneSeconds); |
| |
| return Result.updateZeroResult; |
| } |
| |
| try { |
| value = expressions[0].getValue(session); |
| } catch (HsqlException e) {} |
| |
| if (value instanceof Result) { |
| Result result = (Result) value; |
| |
| if (result.isData()) { |
| Object[] data = |
| (Object[]) result.getNavigator().getNext(); |
| boolean single = !result.getNavigator().next(); |
| |
| if (single && data != null && data[0] != null) { |
| value = data[0]; |
| |
| result.getNavigator().close(); |
| } else { |
| result.getNavigator().close(); |
| |
| return Result.newErrorResult( |
| Error.error(ErrorCode.X_22009), sql); |
| } |
| } else { |
| return Result.newErrorResult( |
| Error.error(ErrorCode.X_22009), sql); |
| } |
| } else { |
| if (value == null) { |
| return Result.newErrorResult( |
| Error.error(ErrorCode.X_22009), sql); |
| } |
| } |
| |
| long seconds = ((IntervalSecondData) value).getSeconds(); |
| |
| if (-DTIType.timezoneSecondsLimit <= seconds |
| && seconds <= DTIType.timezoneSecondsLimit) { |
| session.setZoneSeconds((int) seconds); |
| |
| return Result.updateZeroResult; |
| } |
| |
| return Result.newErrorResult(Error.error(ErrorCode.X_22009), |
| sql); |
| } |
| case StatementTypes.SET_NAMES : |
| return Result.updateZeroResult; |
| |
| case StatementTypes.SET_PATH : |
| return Result.updateZeroResult; |
| |
| case StatementTypes.SET_ROLE : { |
| String name; |
| Grantee role = null; |
| |
| try { |
| name = (String) expressions[0].getValue(session); |
| |
| if (name != null) { |
| name = (String) Type.SQL_VARCHAR.trim(session, name, |
| ' ', true, true); |
| role = session.database.granteeManager.getRole(name); |
| } |
| } catch (HsqlException e) { |
| return Result.newErrorResult( |
| Error.error(ErrorCode.X_0P000), sql); |
| } |
| |
| if (session.isInMidTransaction()) { |
| return Result.newErrorResult( |
| Error.error(ErrorCode.X_25001), sql); |
| } |
| |
| if (role == null) { |
| session.setRole(null); |
| } |
| |
| if (session.getGrantee().hasRole(role)) { |
| session.setRole(role); |
| |
| return Result.updateZeroResult; |
| } else { |
| return Result.newErrorResult( |
| Error.error(ErrorCode.X_0P000), sql); |
| } |
| } |
| case StatementTypes.SET_SCHEMA : { |
| String name; |
| HsqlName schema; |
| |
| try { |
| if (expressions == null) { |
| name = ((HsqlName) parameters[0]).name; |
| } else { |
| name = (String) expressions[0].getValue(session); |
| } |
| |
| name = (String) Type.SQL_VARCHAR.trim(session, name, ' ', |
| true, true); |
| schema = |
| session.database.schemaManager.getSchemaHsqlName(name); |
| |
| session.setSchema(schema.name); |
| |
| return Result.updateZeroResult; |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| case StatementTypes.SET_SESSION_AUTHORIZATION : { |
| if (session.isInMidTransaction()) { |
| return Result.newErrorResult( |
| Error.error(ErrorCode.X_25001), sql); |
| } |
| |
| try { |
| String user; |
| String password = null; |
| |
| user = (String) expressions[0].getValue(session); |
| user = (String) Type.SQL_VARCHAR.trim(session, user, ' ', |
| true, true); |
| |
| if (expressions[1] != null) { |
| password = (String) expressions[1].getValue(session); |
| } |
| |
| User userObject; |
| |
| if (password == null) { |
| userObject = session.database.userManager.get(user); |
| } else { |
| userObject = |
| session.database.getUserManager().getUser(user, |
| password); |
| } |
| |
| if (userObject == null) { |
| throw Error.error(ErrorCode.X_28501); |
| } |
| |
| sql = userObject.getConnectUserSQL(); |
| |
| if (userObject == session.getGrantee()) { |
| return Result.updateZeroResult; |
| } |
| |
| if (session.getGrantee().canChangeAuthorisation()) { |
| session.setUser((User) userObject); |
| session.setRole(null); |
| session.resetSchema(); |
| |
| return Result.updateZeroResult; |
| } |
| |
| /** @todo may need different error code */ |
| throw Error.error(ErrorCode.X_28000); |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| case StatementTypes.SET_SESSION_CHARACTERISTICS : { |
| try { |
| if (parameters[0] != null) { |
| boolean readonly = |
| ((Boolean) parameters[0]).booleanValue(); |
| |
| session.setReadOnlyDefault(readonly); |
| } |
| |
| if (parameters[1] != null) { |
| int level = ((Integer) parameters[1]).intValue(); |
| |
| session.setIsolationDefault(level); |
| } |
| |
| return Result.updateZeroResult; |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| case StatementTypes.SET_COLLATION : |
| return Result.updateZeroResult; |
| |
| case StatementTypes.SET_TRANSFORM_GROUP : |
| return Result.updateZeroResult; |
| |
| case StatementTypes.START_TRANSACTION : |
| startTransaction = true; |
| |
| // fall through |
| case StatementTypes.SET_TRANSACTION : { |
| try { |
| if (parameters[0] != null) { |
| boolean readonly = |
| ((Boolean) parameters[0]).booleanValue(); |
| |
| session.setReadOnly(readonly); |
| } |
| |
| if (parameters[1] != null) { |
| int level = ((Integer) parameters[1]).intValue(); |
| |
| session.setIsolation(level); |
| } |
| |
| if (startTransaction) { |
| session.startTransaction(); |
| } |
| |
| return Result.updateZeroResult; |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| |
| // |
| case StatementTypes.SET_SESSION_AUTOCOMMIT : { |
| boolean mode = ((Boolean) parameters[0]).booleanValue(); |
| |
| try { |
| session.setAutoCommit(mode); |
| |
| return Result.updateZeroResult; |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| case StatementTypes.DECLARE_VARIABLE : { |
| ColumnSchema[] variables = (ColumnSchema[]) parameters[0]; |
| |
| try { |
| for (int i = 0; i < variables.length; i++) { |
| session.sessionContext.addSessionVariable( |
| variables[i]); |
| } |
| |
| return Result.updateZeroResult; |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| case StatementTypes.SET_SESSION_RESULT_MAX_ROWS : { |
| int size = ((Integer) parameters[0]).intValue(); |
| |
| session.setSQLMaxRows(size); |
| |
| return Result.updateZeroResult; |
| } |
| case StatementTypes.SET_SESSION_RESULT_MEMORY_ROWS : { |
| int size = ((Integer) parameters[0]).intValue(); |
| |
| session.setResultMemoryRowCount(size); |
| |
| return Result.updateZeroResult; |
| } |
| case StatementTypes.SET_SESSION_SQL_IGNORECASE : { |
| try { |
| boolean mode = ((Boolean) parameters[0]).booleanValue(); |
| |
| session.setIgnoreCase(mode); |
| |
| return Result.updateZeroResult; |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| case StatementTypes.DECLARE_SESSION_TABLE : { |
| Table table = (Table) parameters[0]; |
| HsqlArrayList tempConstraints = (HsqlArrayList) parameters[1]; |
| StatementDMQL statement = (StatementDMQL) parameters[2]; |
| |
| try { |
| if (tempConstraints != null) { |
| table = |
| ParserDDL.addTableConstraintDefinitions(session, |
| table, tempConstraints, null, false); |
| } |
| |
| table.compile(session, null); |
| session.addSessionTable(table); |
| |
| if (statement != null) { |
| Result result = statement.execute(session); |
| |
| table.insertIntoTable(session, result); |
| } |
| |
| if (table.hasLobColumn) { |
| RowIterator it = table.rowIterator(session); |
| |
| while (it.hasNext()) { |
| Row row = it.getNextRow(); |
| Object[] data = row.getData(); |
| |
| session.sessionData.adjustLobUsageCount(table, |
| data, 1); |
| } |
| } |
| |
| return Result.updateZeroResult; |
| } catch (HsqlException e) { |
| return Result.newErrorResult(e, sql); |
| } |
| } |
| case StatementTypes.DROP_TABLE : { |
| HsqlName name = (HsqlName) parameters[0]; |
| Boolean ifExists = (Boolean) parameters[1]; |
| Table table = session.findSessionTable(name.name); |
| |
| if (table == null) { |
| if (ifExists.booleanValue()) { |
| return Result.updateZeroResult; |
| } else { |
| throw Error.error(ErrorCode.X_42501, name.name); |
| } |
| } |
| |
| session.dropSessionTable(name.name); |
| |
| return Result.updateZeroResult; |
| } |
| default : |
| throw Error.runtimeError(ErrorCode.U_S0500, |
| "StatementSession"); |
| } |
| } |
| |
| public boolean isAutoCommitStatement() { |
| return false; |
| } |
| |
| public String describe(Session session) { |
| return sql; |
| } |
| |
| public boolean isCatalogChange() { |
| return false; |
| } |
| } |
