/* Copyright (c) 2001-2024, 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 java.text.SimpleDateFormat;

import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Random;
import java.util.TimeZone;

import org.hsqldb.HsqlNameManager.HsqlName;
import org.hsqldb.error.Error;
import org.hsqldb.error.ErrorCode;
import org.hsqldb.jdbc.JDBCConnection;
import org.hsqldb.jdbc.JDBCDriver;
import org.hsqldb.lib.ArrayUtil;
import org.hsqldb.lib.CountUpDownLatch;
import org.hsqldb.lib.HashMap;
import org.hsqldb.lib.HsqlArrayList;
import org.hsqldb.lib.HsqlDeque;
import org.hsqldb.lib.Iterator;
import org.hsqldb.lib.OrderedHashSet;
import org.hsqldb.lib.SimpleLog;
import org.hsqldb.map.ValuePool;
import org.hsqldb.navigator.RowSetNavigator;
import org.hsqldb.navigator.RowSetNavigatorClient;
import org.hsqldb.persist.HsqlDatabaseProperties;
import org.hsqldb.persist.HsqlProperties;
import org.hsqldb.persist.PersistentStore;
import org.hsqldb.result.Result;
import org.hsqldb.result.ResultConstants;
import org.hsqldb.result.ResultLob;
import org.hsqldb.result.ResultProperties;
import org.hsqldb.rights.Grantee;
import org.hsqldb.rights.User;
import org.hsqldb.types.BlobDataID;
import org.hsqldb.types.ClobDataID;
import org.hsqldb.types.DateTimeType;
import org.hsqldb.types.HsqlDateTime;
import org.hsqldb.types.TimeData;
import org.hsqldb.types.TimestampData;
import org.hsqldb.types.Type;
import org.hsqldb.types.TypedComparator;

/**
 * Implementation of SQL sessions.
 *
 * @author Fred Toussi (fredt@users dot sourceforge.net)
 * @version 2.7.3
 * @since 1.7.0
 */
public class Session implements SessionInterface {

    //
    private volatile boolean isClosed;

    //
    public Database    database;
    private final User sessionUser;
    private User       user;
    private Grantee    role;

    // transaction support
    public boolean                 isReadOnlyDefault;
    int isolationLevelDefault = SessionInterface.TX_READ_COMMITTED;
    int isolationLevel        = SessionInterface.TX_READ_COMMITTED;
    boolean                        isReadOnlyIsolation;
    int                            actionIndex;
    long                           actionStartSCN;
    long                           actionSCN;
    long                           statementStartSCN;
    long                           transactionSCN;
    long                           transactionEndSCN;
    final boolean                  txConflictRollback;
    final boolean                  txInterruptRollback;
    volatile boolean               isPreTransaction;
    volatile boolean               isTransaction;
    boolean                        isBatch;
    volatile boolean               abortAction;
    volatile boolean               abortTransaction;
    volatile boolean               redoAction;
    HsqlArrayList<RowAction>       rowActionList;
    volatile boolean               tempUnlocked;
    public OrderedHashSet<Session> waitedSessions;
    public OrderedHashSet<Session> waitingSessions;
    OrderedHashSet<Session>        tempSet;
    OrderedHashSet<RowActionBase>  actionSet;
    public CountUpDownLatch        latch = new CountUpDownLatch();
    TimeoutManager                 timeoutManager;

    // current settings
    final TimeZone              timeZone;
    TimeZone                    currentTimeZone;
    final String                zoneString;
    boolean                     isNetwork;
    private int                 sessionMaxRows;
    int                         sessionOptimization = 8;
    private final long          sessionId;
    private boolean             ignoreCase;
    private final TimestampData connectTimestamp;

    // internal connection
    private JDBCConnection intConnection;

    // external connection
    private JDBCConnection extConnection;

    // schema
    public HsqlName currentSchema;
    public HsqlName loggedSchema;

    // query processing
    ParserCommand         parser;
    boolean               isProcessingScript;
    boolean               isProcessingLog;
    public SessionContext sessionContext;
    int                   resultMaxMemoryRows;

    //
    public SessionData sessionData;

    //
    public StatementManager statementManager;

    //
    public Object special;
    public int    sessionTxId;

    /**
     * Constructs a new Session object.
     * @param  db the database to which this represents a connection
     * @param  user the initial user
     * @param  autocommit the initial autocommit value
     * @param  readonly the initial readonly value
     * @param  id the session identifier, as known to the database
     * @param  zone the TimeZone
     */
    Session(
            Database db,
            User user,
            boolean autocommit,
            boolean readonly,
            long id,
            TimeZone zone) {

        this.database               = db;
        this.sessionUser            = user;
        this.user                   = user;
        this.sessionId              = id;
        this.timeZone               = zone;
        this.currentTimeZone        = zone;
        this.zoneString             = zone.getID();
        rowActionList = new HsqlArrayList<>(new RowAction[128], 0, true);
        waitedSessions              = new OrderedHashSet<>();
        waitingSessions             = new OrderedHashSet<>();
        tempSet                     = new OrderedHashSet<>();
        actionSet                   = new OrderedHashSet<>();
        isolationLevelDefault       = database.defaultIsolationLevel;
        ignoreCase                  = database.sqlIgnoreCase;
        isolationLevel              = isolationLevelDefault;
        txConflictRollback          = database.txConflictRollback;
        txInterruptRollback         = database.txInterruptRollback;
        isReadOnlyDefault           = readonly;
        isReadOnlyIsolation = isolationLevel
                              == SessionInterface.TX_READ_UNCOMMITTED;
        sessionContext              = new SessionContext(this);
        sessionContext.isAutoCommit = autocommit;
        sessionContext.isReadOnly   = isReadOnlyDefault;
        parser                      = new ParserCommand(this, new Scanner());
        sessionData                 = new SessionData(database, this);
        statementManager            = new StatementManager(this);
        timeoutManager              = new TimeoutManager();

        setResultMemoryRowCount(database.getResultMaxMemoryRows());
        resetSchema();

        connectTimestamp = getCurrentTimestamp();
    }

    void resetSchema() {
        loggedSchema  = null;
        currentSchema = user.getInitialOrDefaultSchema();
    }

    /**
     *  Retrieves the session identifier for this Session.
     *
     * @return the session identifier for this Session
     */
    public long getId() {
        return sessionId;
    }

    public int getRandomId() {
        return randomId;
    }

    /**
     * Closes this Session.
     */
    public synchronized void close() {

        if (isClosed) {
            return;
        }

        rollback(false);

        try {
            database.logger.writeOtherStatement(this, Tokens.T_DISCONNECT);
        } catch (HsqlException e) {}

        sessionData.closeAllNavigators();
        sessionData.persistentStoreCollection.release();
        statementManager.reset();

        // keep sessionContext and sessionData
        rowActionList.clear();

        isClosed                    = true;
        user                        = null;
        sessionContext.savepoints   = null;
        sessionContext.lastIdentity = null;
        intConnection               = null;

        database.sessionManager.removeSession(this);
        database.closeIfLast();

        database = null;
    }

    /**
     * Retrieves whether this Session is closed.
     *
     * @return true if this Session is closed
     */
    public boolean isClosed() {
        return isClosed;
    }

    public synchronized void setIsolationDefault(int level) {

        if (level == SessionInterface.TX_READ_UNCOMMITTED) {
            level = SessionInterface.TX_READ_COMMITTED;
        }

        if (level == isolationLevelDefault) {
            return;
        }

        isolationLevelDefault = level;

        if (!isInMidTransaction()) {
            isolationLevel      = isolationLevelDefault;
            isReadOnlyIsolation = level == SessionInterface.TX_READ_UNCOMMITTED;
        }
    }

    /**
     * sets ISOLATION for the next transaction only
     */
    public void setIsolation(int level) {

        if (isInMidTransaction()) {
            throw Error.error(ErrorCode.X_25001);
        }

        if (level == SessionInterface.TX_READ_UNCOMMITTED) {
            level               = SessionInterface.TX_READ_COMMITTED;
            isReadOnlyIsolation = true;
        }

        isolationLevel = level;
    }

    public synchronized int getIsolation() {
        return isolationLevel;
    }

    /**
     * Setter for iLastIdentity attribute.
     *
     * @param  i the new value
     */
    void setLastIdentity(Number i) {
        sessionContext.lastIdentity = i;
    }

    /**
     * Getter for iLastIdentity attribute.
     *
     * @return the current value
     */
    public Number getLastIdentity() {
        return sessionContext.lastIdentity;
    }

    /**
     * Retrieves the Database instance to which this
     * Session represents a connection.
     *
     * @return the Database object to which this Session is connected
     */
    public Database getDatabase() {
        return database;
    }

    /**
     * Retrieves the name, as known to the database, of the
     * user currently controlling this Session.
     *
     * @return the name of the user currently connected within this Session
     */
    public String getUsername() {
        return user.getName().getNameString();
    }

    /**
     * Retrieves the User object representing the user currently controlling
     * this Session.
     *
     * @return this Session's User object
     */
    public User getUser() {
        return user;
    }

    public Grantee getGrantee() {
        return user;
    }

    public Grantee getRole() {
        return role;
    }

    /**
     * Sets this Session's User object to the one specified by the
     * user argument.
     *
     * @param  user the new User object for this session
     */
    public void setUser(User user) {
        this.user = user;
    }

    public void setRole(Grantee role) {
        this.role = role;
    }

    int getMaxRows() {
        return sessionContext.currentMaxRows;
    }

    /**
     * The SQL command SET MAXROWS n will override the Statement.setMaxRows(n)
     * for the next direct statement only
     *
     * NB this is dedicated to the SET MAXROWS sql statement and should not
     * otherwise be called. (fredt@users)
     */
    void setSQLMaxRows(int rows) {
        sessionMaxRows = rows;
    }

    void setFeature(String feature, boolean value) {

        int number = 8;

        if (value) {
            sessionOptimization |= number;
        } else {
            sessionOptimization &= ~number;
        }
    }

    /**
     * Checks whether this Session's current User has the privileges of
     * the ADMIN role.
     */
    void checkAdmin() {
        user.checkAdmin();
    }

    /**
     * This is used for reading - writing to existing tables.
     */
    void checkReadWrite() {
        if (sessionContext.isReadOnly || isReadOnlyIsolation) {
            throw Error.error(ErrorCode.X_25006);
        }
    }

    /**
     * This is used for creating new database objects such as tables.
     */
    void checkDDLWrite() {

        if (isProcessingScript || isProcessingLog) {
            return;
        }

        checkReadWrite();
    }

    public long getActionSCN() {
        return actionSCN;
    }

    /**
     *  Adds a delete action to the row and the transaction manager.
     *
     * @param  table the table of the row
     * @param  row the deleted row
     */
    public void addDeleteAction(
            Table table,
            PersistentStore store,
            Row row,
            int[] changedColumns) {

//        tempActionHistory.add("add delete action " + actionTimestamp);
        if (abortTransaction) {
            throw Error.error(ErrorCode.X_40001);
        }

        if (abortAction) {
            throw Error.error(ErrorCode.X_40502);
        }

        database.txManager.addDeleteAction(
            this,
            table,
            store,
            row,
            changedColumns);
    }

    void addInsertAction(
            Table table,
            PersistentStore store,
            Row row,
            int[] changedColumns) {

//        tempActionHistory.add("add insert to transaction " + actionTimestamp);
        database.txManager.addInsertAction(
            this,
            table,
            store,
            row,
            changedColumns);

        // abort only after adding so that the new row gets removed from indexes
        if (abortTransaction) {
            throw Error.error(ErrorCode.X_40001);
        }

        if (abortAction) {
            throw Error.error(ErrorCode.X_40502);
        }
    }

    public HsqlArrayList<RowAction> getRowActionList() {
        return rowActionList;
    }

    /**
     *  Setter for the autocommit attribute.
     *
     * @param  autocommit the new value
     */
    public synchronized void setAutoCommit(boolean autocommit) {

        if (isClosed) {
            return;
        }

        if (sessionContext.depth > 0) {
            return;
        }

        if (sessionContext.isAutoCommit != autocommit) {
            commit(false);

            sessionContext.isAutoCommit = autocommit;
        }
    }

    public void setAutoCommitRows(int rows) {

        if (isClosed) {
            return;
        }

        if (sessionContext.depth > 0) {
            return;
        }

        sessionContext.autoCommitRows = rows;
    }

    public void beginAction(Statement cs) {

        actionIndex = rowActionList.size();

        database.txManager.beginAction(this, cs);
        database.txManager.beginActionResume(this);
    }

    public void endAction(Result result) {

//        tempActionHistory.add("endAction " + actionTimestamp);
        abortAction = false;

        timeoutManager.endTimeout();
        sessionData.persistentStoreCollection.clearStatementTables();

        if (result.mode == ResultConstants.ERROR) {
            sessionData.persistentStoreCollection.clearResultTables(actionSCN);
            database.txManager.rollbackAction(this);
        } else {
            sessionContext.diagnosticsVariables[ExpressionColumn.idx_row_count] =
                result.mode == ResultConstants.UPDATECOUNT
                ? Integer.valueOf(result.getUpdateCount())
                : ValuePool.INTEGER_0;

            database.txManager.completeActions(this);
        }

//        tempActionHistory.add("endAction ends " + actionTimestamp);
    }

    /**
     * Explicit start of transaction by user
     */
    public void startTransaction() {

        if (isInMidTransaction()) {
            throw Error.error(ErrorCode.X_25001);
        }

        database.txManager.beginTransaction(this);
    }

    public synchronized void startPhasedTransaction() {}

    /*
     * @todo - fredt - for two phased pre-commit - after this call, further
     * state changing calls should fail
     */
    public synchronized void prepareCommit() {

        if (isClosed) {
            throw Error.error(ErrorCode.X_08003);
        }

        if (!database.txManager.prepareCommitActions(this)) {

//            tempActionHistory.add("commit aborts " + actionTimestamp);
            rollbackNoCheck(false);

            throw Error.error(ErrorCode.X_40001);
        }
    }

    /**
     * Commits any uncommitted transaction this Session may have open
     */
    public synchronized void commit(boolean chain) {

//        tempActionHistory.add("commit " + actionTimestamp);
        if (isClosed) {
            return;
        }

        if (sessionContext.depth > 0) {
            return;
        }

        if (isTransaction) {
            if (!database.txManager.commitTransaction(this)) {

                // tempActionHistory.add("commit aborts " + actionTimestamp);
                rollbackNoCheck(chain);

                throw Error.error(ErrorCode.X_40001);
            }
        } else {
            logSequences();
        }

        endTransaction(true, chain);

        if (database != null
                && !sessionUser.isSystem()
                && database.logger.needsCheckpointReset()) {
            database.checkpointRunner.start();
        }
    }

    /**
     * Rolls back any uncommitted transaction this Session may have open.
     */
    public synchronized void rollback(boolean chain) {

        //        tempActionHistory.add("rollback " + actionTimestamp);
        if (sessionContext.depth > 0) {
            return;
        }

        rollbackNoCheck(chain);
    }

    synchronized void rollbackNoCheck(boolean chain) {

        if (isClosed) {
            return;
        }

        if (isTransaction || isPreTransaction) {
            database.txManager.rollback(this);
        }

        endTransaction(false, chain);
    }

    private void endTransaction(boolean commit, boolean chain) {

        abortAction       = false;
        abortTransaction  = false;
        transactionUTCSet = false;

        sessionContext.resetStack();
        sessionContext.savepoints.clear();
        sessionContext.savepointTimestamps.clear();
        rowActionList.clear();
        sessionData.persistentStoreCollection.clearTransactionTables();
        sessionData.closeAllTransactionNavigators();

        if (!chain) {
            sessionContext.isReadOnly = isReadOnlyDefault;

            setIsolation(isolationLevelDefault);
        }

        if (database.logger.getSqlEventLogLevel() > SimpleLog.LOG_NONE) {
            Statement endTX = commit
                              ? StatementSession.commitNoChainStatement
                              : StatementSession.rollbackNoChainStatement;

            database.logger.logStatementEvent(
                this,
                endTX,
                null,
                Result.updateZeroResult,
                SimpleLog.LOG_SQL_BASIC);
        }

/* debug 190
        tempActionHistory.add("transaction ends " + actionTimestamp);
        tempActionHistory.clear();
*/
    }

    /**
     * Clear structures and reset variables to original. For JDBC use only.
     * Note: sets autocommit true
     */
    public synchronized void resetSession() {

        if (isClosed) {
            return;
        }

        rollbackNoCheck(false);
        sessionData.closeAllNavigators();
        sessionData.persistentStoreCollection.clearAllTables();
        statementManager.reset();

        sessionContext.lastIdentity = ValuePool.INTEGER_0;
        sessionContext.isAutoCommit = true;

        setResultMemoryRowCount(database.getResultMaxMemoryRows());

        user = sessionUser;

        resetSchema();
        resetTimeZone();

        sessionMaxRows = 0;
        ignoreCase     = database.sqlIgnoreCase;

        setIsolation(isolationLevelDefault);
    }

    /**
     *  Registers a transaction SAVEPOINT. A new SAVEPOINT with the
     *  name of an existing one replaces the old SAVEPOINT.
     *
     * @param  name name of the savepoint
     */
    public synchronized void savepoint(String name) {

        int index = sessionContext.savepoints.getIndex(name);

        if (index != -1) {
            sessionContext.savepoints.remove(name);
            sessionContext.savepointTimestamps.remove(index);
        }

        actionSCN = database.txManager.getNextSystemChangeNumber();

        sessionContext.savepoints.add(
            name,
            ValuePool.getInt(rowActionList.size()));
        sessionContext.savepointTimestamps.addLast(actionSCN);
    }

    /**
     *  Performs a partial transaction ROLLBACK to savepoint.
     *
     * @param  name name of savepoint
     */
    public synchronized void rollbackToSavepoint(String name) {

        if (isClosed) {
            return;
        }

        int index = sessionContext.savepoints.getIndex(name);

        if (index < 0) {
            throw Error.error(ErrorCode.X_3B001, name);
        }

        database.txManager.rollbackSavepoint(this, index);
    }

    /**
     * Performs a partial transaction ROLLBACK of current savepoint level.
     */
    public synchronized void rollbackToSavepoint() {

        if (isClosed) {
            return;
        }

        database.txManager.rollbackSavepoint(this, 0);
    }

    public synchronized void rollbackAction(int start, long timestamp) {

        if (isClosed) {
            return;
        }

        database.txManager.rollbackPartial(this, start, timestamp);
    }

    /**
     * Releases a savepoint
     *
     * @param  name name of savepoint
     */
    public synchronized void releaseSavepoint(String name) {

        // remove this and all later savepoints
        int index = sessionContext.savepoints.getIndex(name);

        if (index < 0) {
            throw Error.error(ErrorCode.X_3B001, name);
        }

        while (sessionContext.savepoints.size() > index) {
            sessionContext.savepoints.removeEntry(
                sessionContext.savepoints.size() - 1);
            sessionContext.savepointTimestamps.removeLast();
        }
    }

    public boolean isInMidTransaction() {
        return isTransaction;
    }

    public void setNoSQL() {
        sessionContext.noSQL = true;
    }

    public void setIgnoreCase(boolean mode) {
        ignoreCase = mode;
    }

    public boolean isIgnorecase() {
        return ignoreCase;
    }

    /**
     * sets READ ONLY for next transaction / subtransaction only
     *
     * @param  readonly the new value
     */
    public void setReadOnly(boolean readonly) {

        if (!readonly && database.databaseReadOnly) {
            throw Error.error(ErrorCode.DATABASE_IS_READONLY);
        }

        if (isInMidTransaction()) {
            throw Error.error(ErrorCode.X_25001);
        }

        sessionContext.isReadOnly = readonly;
    }

    public synchronized void setReadOnlyDefault(boolean readonly) {

        if (!readonly && database.databaseReadOnly) {
            throw Error.error(ErrorCode.DATABASE_IS_READONLY);
        }

        isReadOnlyDefault = readonly;

        if (!isInMidTransaction()) {
            sessionContext.isReadOnly = isReadOnlyDefault;
        }
    }

    /**
     *  Getter for readonly attribute.
     *
     * @return the current value
     */
    public boolean isReadOnly() {
        return sessionContext.isReadOnly || isReadOnlyIsolation;
    }

    public synchronized boolean isReadOnlyDefault() {
        return isReadOnlyDefault;
    }

    /**
     *  Getter for autoCommit attribute.
     *
     * @return the current value
     */
    public synchronized boolean isAutoCommit() {
        return sessionContext.isAutoCommit;
    }

    public synchronized int getStreamBlockSize() {
        return lobStreamBlockSize;
    }

    /**
     * Retrieves an internal Connection object equivalent to the one
     * that created this Session.
     *
     * @return  internal connection.
     */
    JDBCConnection getInternalConnection() {

        if (intConnection == null) {
            intConnection = new JDBCConnection(this);
        }

        JDBCDriver.driverInstance.threadConnection.set(intConnection);

        return intConnection;
    }

    void releaseInternalConnection() {
        if (sessionContext.depth == 0) {
            JDBCDriver.driverInstance.threadConnection.set(null);
        }
    }

    /**
     * Retrieves the external JDBC connection
     */
    public JDBCConnection getJDBCConnection() {
        return extConnection;
    }

    public void setJDBCConnection(JDBCConnection connection) {
        extConnection = connection;
    }

    public String getDatabaseUniqueName() {
        return database.getNameString();
    }

// campbell-burnet@users 20020810 metadata 1.7.2
//----------------------------------------------------------------
// more efficient for MetaData concerns than checkAdmin

    /**
     * Getter for admin attribute.
     *
     * @return the current value
     */
    public boolean isAdmin() {
        return user.isAdmin();
    }

    /**
     * Getter for connectTime attribute.
     *
     * @return the value
     */
    public TimestampData getConnectTimestamp() {
        return connectTimestamp;
    }

    /**
     * Count of actions in current transaction.
     *
     * @return the current value
     */
    public int getTransactionSize() {
        return rowActionList.size();
    }

    public long getTransactionSCN() {
        return transactionSCN;
    }

    public Statement compileStatement(String sql, int props) {

        parser.reset(this, sql);

        Statement cs = parser.compileStatement(props);

        return cs;
    }

    public Statement compileStatement(String sql) {

        parser.reset(this, sql);

        Statement cs = parser.compileStatement(
            ResultProperties.defaultPropsValue);

        cs.setCompileTimestamp(Long.MAX_VALUE);

        return cs;
    }

    /**
     * Executes the command encapsulated by the cmd argument.
     *
     * @param cmd the command to execute
     * @return the result of executing the command
     */
    public synchronized Result execute(Result cmd) {

        if (isClosed) {
            return Result.newErrorResult(Error.error(ErrorCode.X_08503));
        }

        sessionContext.currentMaxRows = 0;
        isBatch                       = false;

        switch (cmd.mode) {

            case ResultConstants.LARGE_OBJECT_OP : {
                return performLOBOperation((ResultLob) cmd);
            }

            case ResultConstants.EXECUTE : {
                int maxRows = cmd.getUpdateCount();

                if (maxRows == -1) {
                    sessionContext.currentMaxRows = 0;
                } else {
                    sessionContext.currentMaxRows = maxRows;
                }

                Statement cs = cmd.statement;

                if (cs == null
                        || cs.compileTimestamp
                           < database.schemaManager.schemaChangeTimestamp) {
                    long csid = cmd.getStatementID();

                    cs = statementManager.getStatement(csid);

                    cmd.setStatement(cs);

                    if (cs == null) {

                        // invalid sql has been removed already
                        return Result.newErrorResult(
                            Error.error(ErrorCode.X_07502));
                    }
                }

                Object[] pvals = (Object[]) cmd.valueData;
                Result result = executeCompiledStatement(
                    cs,
                    pvals,
                    cmd.queryTimeout);

                result = performPostExecute(cmd, result);

                return result;
            }

            case ResultConstants.BATCHEXECUTE : {
                isBatch = true;

                Result result = executeCompiledBatchStatement(cmd);

                result = performPostExecute(cmd, result);

                return result;
            }

            case ResultConstants.EXECDIRECT : {
                Result result = executeDirectStatement(cmd);

                result = performPostExecute(cmd, result);

                return result;
            }

            case ResultConstants.BATCHEXECDIRECT : {
                isBatch = true;

                Result result = executeDirectBatchStatement(cmd);

                result = performPostExecute(cmd, result);

                return result;
            }

            case ResultConstants.PREPARE : {
                Statement cs;

                try {
                    cs = statementManager.compile(cmd);
                } catch (Throwable t) {
                    String errorString = cmd.getMainString();

                    return Result.newErrorResult(t, errorString);
                }

                Result result = Result.newPrepareResponse(cs);

                if (cs.getType() == StatementTypes.SELECT_CURSOR
                        || cs.getType() == StatementTypes.CALL) {
                    sessionData.setResultSetProperties(cmd, result);
                }

                result = performPostExecute(cmd, result);

                return result;
            }

            case ResultConstants.CLOSE_RESULT : {
                closeNavigator(cmd.getResultId());

                return Result.updateZeroResult;
            }

            case ResultConstants.UPDATE_RESULT : {
                Result result = this.executeResultUpdate(cmd);

                result = performPostExecute(cmd, result);

                return result;
            }

            case ResultConstants.FREESTMT : {
                statementManager.freeStatement(cmd.getStatementID());

                return Result.updateZeroResult;
            }

            case ResultConstants.GETSESSIONATTR : {
                int id = cmd.getStatementType();

                return getAttributesResult(id);
            }

            case ResultConstants.SETSESSIONATTR : {
                return setAttributes(cmd);
            }

            case ResultConstants.ENDTRAN : {
                switch (cmd.getActionType()) {

                    case ResultConstants.TX_COMMIT :
                        try {
                            commit(false);
                        } catch (Throwable t) {
                            return Result.newErrorResult(t);
                        }

                        break;

                    case ResultConstants.TX_COMMIT_AND_CHAIN :
                        try {
                            commit(true);
                        } catch (Throwable t) {
                            return Result.newErrorResult(t);
                        }

                        break;

                    case ResultConstants.TX_ROLLBACK :
                        rollback(false);
                        break;

                    case ResultConstants.TX_ROLLBACK_AND_CHAIN :
                        rollback(true);
                        break;

                    case ResultConstants.TX_SAVEPOINT_NAME_RELEASE :
                        try {
                            String name = cmd.getMainString();

                            releaseSavepoint(name);
                        } catch (Throwable t) {
                            return Result.newErrorResult(t);
                        }

                        break;

                    case ResultConstants.TX_SAVEPOINT_NAME_ROLLBACK :
                        try {
                            rollbackToSavepoint(cmd.getMainString());
                        } catch (Throwable t) {
                            return Result.newErrorResult(t);
                        }

                        break;

                    case ResultConstants.PREPARECOMMIT :
                        try {
                            prepareCommit();
                        } catch (Throwable t) {
                            return Result.newErrorResult(t);
                        }

                        break;
                }

                return Result.updateZeroResult;
            }

            case ResultConstants.SETCONNECTATTR : {
                switch (cmd.getConnectionAttrType()) {

                    case ResultConstants.SQL_ATTR_SAVEPOINT_NAME :
                        try {
                            savepoint(cmd.getMainString());
                        } catch (Throwable t) {
                            return Result.newErrorResult(t);
                        }

                    // case ResultConstants.SQL_ATTR_AUTO_IPD
                    //   - always true
                    // default: throw - case never happens
                }

                return Result.updateZeroResult;
            }

            case ResultConstants.REQUESTDATA : {
                return sessionData.getDataResultSlice(
                    cmd.getResultId(),
                    cmd.getUpdateCount(),
                    cmd.getFetchSize());
            }

            case ResultConstants.DISCONNECT : {
                close();

                return Result.updateZeroResult;
            }

            default : {
                return Result.newErrorResult(
                    Error.runtimeError(ErrorCode.U_S0500, "Session"));
            }
        }
    }

    private Result performPostExecute(Result command, Result result) {

        if (result.mode == ResultConstants.DATA) {
            result = sessionData.getDataResultHead(command, result, isNetwork);
        }

/*
        else if (result.mode == ResultConstants.ERROR) {
            while (sessionContext.depth > 0) {
                sessionContext.pop();
            }
        }
*/
        if (sqlWarnings != null && sqlWarnings.size() > 0) {
            if (result.mode == ResultConstants.UPDATECOUNT) {
                result = new Result(
                    ResultConstants.UPDATECOUNT,
                    result.getUpdateCount());
            }

            HsqlException[] warnings = getAndClearWarnings();

            result.addWarnings(warnings);
        }

        return result;
    }

    public RowSetNavigatorClient getRows(
            long navigatorId,
            int offset,
            int blockSize) {
        return sessionData.getRowSetSlice(navigatorId, offset, blockSize);
    }

    public synchronized void closeNavigator(long id) {
        sessionData.closeNavigator(id);
    }

    public Result executeDirectStatement(Result cmd) {

        String                   sql = cmd.getMainString();
        HsqlArrayList<Statement> list;
        int                      maxRows = cmd.getUpdateCount();

        if (maxRows == -1) {
            sessionContext.currentMaxRows = 0;
        } else if (sessionMaxRows == 0) {
            sessionContext.currentMaxRows = maxRows;
        } else {
            sessionContext.currentMaxRows = sessionMaxRows;
            sessionMaxRows                = 0;
        }

        try {
            list = parser.compileStatements(sql, cmd);
        } catch (Throwable e) {
            return Result.newErrorResult(e);
        }

        Result   result         = null;
        boolean  recompile      = false;
        HsqlName originalSchema = getCurrentSchemaHsqlName();

        for (int i = 0; i < list.size(); i++) {
            Statement cs = list.get(i);

            if (isClosed) {
                result = Result.newErrorResult(Error.error(ErrorCode.X_08503));
                break;
            }

            if (i > 0) {
                if (cs.getCompileTimestamp()
                        > database.txManager.getSystemChangeNumber()) {
                    recompile = true;
                }

                if (cs.getSchemaName() != null
                        && cs.getSchemaName() != originalSchema) {
                    recompile = true;
                }
            }

            if (recompile) {
                cs = compileStatement(cs.getSQL(), cmd.getExecuteProperties());
            }

            cs.setGeneratedColumnInfo(
                cmd.getGeneratedResultType(),
                cmd.getGeneratedResultMetaData());

            result = executeCompiledStatement(
                cs,
                ValuePool.emptyObjectArray,
                cmd.queryTimeout);

            if (result.mode == ResultConstants.ERROR) {
                break;
            }
        }

        return result;
    }

    public Result executeDirectStatement(String sql) {

        try {
            Statement cs = compileStatement(sql);
            Result result = executeCompiledStatement(
                cs,
                ValuePool.emptyObjectArray,
                0);

            return result;
        } catch (HsqlException e) {
            return Result.newErrorResult(e);
        }
    }

    public Result executeCompiledStatement(
            Statement cs,
            Object[] pvals,
            int timeout) {

        Result r;

        if (abortTransaction) {
            return handleAbortTransaction();
        }

        if (sessionContext.depth > 0) {
            if (sessionContext.noSQL || cs.isAutoCommitStatement()) {
                return Result.newErrorResult(Error.error(ErrorCode.X_46000));
            }
        }

        if (cs.isAutoCommitStatement()) {
            if (isReadOnly()) {
                return Result.newErrorResult(Error.error(ErrorCode.X_25006));
            }

            try {

                /* special autocommit for backward compatibility */
                commit(false);
            } catch (HsqlException e) {
                database.logger.logInfoEvent("Exception at commit");
            }
        }

        sessionContext.currentStatement = cs;
        sessionContext.invalidStatement = false;
        statementStartSCN = database.txManager.getSystemChangeNumber();

        boolean isTX = cs.isTransactionStatement();

        if (!isTX) {
            actionSCN = database.txManager.getNextSystemChangeNumber();

            sessionContext.setDynamicArguments(pvals);

            // statements such as DISCONNECT may close the session
            if (database.logger.getSqlEventLogLevel()
                    >= SimpleLog.LOG_SQL_NORMAL) {
                database.logger.logStatementEvent(
                    this,
                    cs,
                    pvals,
                    Result.updateZeroResult,
                    SimpleLog.LOG_SQL_NORMAL);
            }

            r                               = cs.execute(this);
            sessionContext.currentStatement = null;
            sessionContext.invalidStatement = false;
            abortAction                     = false;

            sessionData.persistentStoreCollection.clearStatementTables();

            return r;
        }

        timeoutManager.startTimeout(timeout);
        repeatLoop:
        while (true) {
            actionIndex = rowActionList.size();

            database.txManager.beginAction(this, cs);

            if (redoAction) {
                redoAction = false;
                continue;
            }

            if (abortTransaction) {
                return handleAbortTransaction();
            }

            while (true) {
                try {
                    latch.await();
                } catch (InterruptedException e) {
                    if (txInterruptRollback) {
                        database.txManager.resetSession(
                            this,
                            this,
                            Long.MAX_VALUE,
                            TransactionManager.resetSessionStatement);

                        abortTransaction = true;
                        break;
                    }

                    Thread.interrupted();
                    continue;
                }

                break;
            }

            if (abortAction) {
                r = Result.newErrorResult(Error.error(ErrorCode.X_40502));

                endAction(r);
                break repeatLoop;
            }

            if (abortTransaction) {
                return handleAbortTransaction();
            }

            database.txManager.beginActionResume(this);

            // expiration check
            cs = sessionContext.currentStatement;

            if (sessionContext.invalidStatement) {
                r = Result.newErrorResult(Error.error(ErrorCode.X_07502));
                abortTransaction = true;
            } else {

                // tempActionHistory.add("sql execute " + cs.sql + " " + actionTimestamp + " " + rowActionList.size());
                sessionContext.setDynamicArguments(pvals);

                r = cs.execute(this);

                // tempActionHistory.add("sql execute end " + actionTimestamp + " " + rowActionList.size());
                if (database.logger.getSqlEventLogLevel()
                        >= SimpleLog.LOG_SQL_NORMAL) {
                    database.logger.logStatementEvent(
                        this,
                        cs,
                        pvals,
                        r,
                        SimpleLog.LOG_SQL_NORMAL);
                }
            }

            endAction(r);

            if (abortTransaction) {
                break repeatLoop;
            }

            if (redoAction) {
                redoAction = false;

                while (true) {
                    try {
                        latch.await();
                    } catch (InterruptedException e) {
                        if (txInterruptRollback) {
                            database.txManager.resetSession(
                                this,
                                this,
                                Long.MAX_VALUE,
                                TransactionManager.resetSessionStatement);

                            abortTransaction = true;
                            break repeatLoop;
                        }

                        Thread.interrupted();
                        continue;
                    }

                    break;
                }
            } else {
                break repeatLoop;
            }
        }

        if (abortTransaction) {
            return handleAbortTransaction();
        }

        if (sessionContext.depth == 0) {
            if (sessionContext.isAutoCommit || cs.isAutoCommitStatement()) {
                try {
                    if (r.mode == ResultConstants.ERROR) {
                        rollbackNoCheck(false);
                    } else {
                        commit(false);
                    }
                } catch (Exception e) {
                    sessionContext.currentStatement = null;
                    sessionContext.invalidStatement = false;

                    return Result.newErrorResult(
                        Error.error(ErrorCode.X_40001, e));
                }
            } else if (sessionContext.autoCommitRows > 0) {
                if (rowActionList.size() > sessionContext.autoCommitRows) {
                    try {
                        commit(false);
                    } catch (Exception e) {
                        sessionContext.currentStatement = null;
                        sessionContext.invalidStatement = false;

                        return Result.newErrorResult(
                            Error.error(ErrorCode.X_40001, e));
                    }
                }
            }
        }

        sessionContext.currentStatement = null;
        sessionContext.invalidStatement = false;

        return r;
    }

    private Result handleAbortTransaction() {

        rollbackNoCheck(false);

        sessionContext.currentStatement = null;
        sessionContext.invalidStatement = false;

        return Result.newErrorResult(Error.error(ErrorCode.X_40001));
    }

    private Result executeCompiledBatchStatement(Result cmd) {

        long      csid;
        Statement cs;
        int[]     updateCounts;
        int       count;

        cs = cmd.statement;

        if (cs == null
                || cs.compileTimestamp
                   < database.schemaManager.schemaChangeTimestamp) {
            csid = cmd.getStatementID();
            cs   = statementManager.getStatement(csid);

            if (cs == null) {

                // invalid sql has been removed already
                return Result.newErrorResult(Error.error(ErrorCode.X_07502));
            }
        }

        count = 0;

        RowSetNavigator nav = cmd.initialiseNavigator();

        updateCounts = new int[nav.getSize()];

        Result generatedResult = null;

        if (cs.hasGeneratedColumns()) {
            generatedResult = Result.newGeneratedDataResult(
                cs.generatedResultMetaData());
        }

        Result error = null;

        while (nav.next()) {
            Object[] pvals = nav.getCurrent();
            Result   in = executeCompiledStatement(cs, pvals, cmd.queryTimeout);

            // On the client side, iterate over the vals and throw
            // a BatchUpdateException if a batch status value of
            // esultConstants.EXECUTE_FAILED is encountered in the result
            if (in.isUpdateCount()) {
                if (cs.hasGeneratedColumns()) {
                    RowSetNavigator navgen = in.getChainedResult()
                                               .getNavigator();

                    while (navgen.next()) {
                        Object[] generatedRow = navgen.getCurrent();

                        generatedResult.getNavigator().add(generatedRow);
                    }
                }

                updateCounts[count++] = in.getUpdateCount();
            } else if (in.isData()) {

                // FIXME:  we don't have what it takes yet
                // to differentiate between things like
                // stored procedure calls to methods with
                // void return type and select statements with
                // a single row/column containing null
                updateCounts[count++] = ResultConstants.SUCCESS_NO_INFO;
            } else if (in.mode == ResultConstants.CALL_RESPONSE) {
                updateCounts[count++] = ResultConstants.SUCCESS_NO_INFO;
            } else if (in.mode == ResultConstants.ERROR) {
                updateCounts = ArrayUtil.arraySlice(updateCounts, 0, count);
                error        = in;
                break;
            } else {
                throw Error.runtimeError(ErrorCode.U_S0500, "Session");
            }
        }

        return Result.newBatchedExecuteResponse(
            updateCounts,
            generatedResult,
            error);
    }

    private Result executeDirectBatchStatement(Result cmd) {

        int[] updateCounts;
        int   count;

        count = 0;

        RowSetNavigator nav = cmd.initialiseNavigator();

        updateCounts = new int[nav.getSize()];

        Result error = null;

        while (nav.next()) {
            Result   in;
            Object[] data = nav.getCurrent();
            String   sql  = (String) data[0];

            try {
                Statement cs = compileStatement(sql);

                in = executeCompiledStatement(
                    cs,
                    ValuePool.emptyObjectArray,
                    cmd.queryTimeout);
            } catch (Throwable t) {
                in = Result.newErrorResult(t);

                // if (t instanceof OutOfMemoryError) {
                // System.gc();
                // }
                // "in" already equals "err"
                // maybe test for OOME and do a gc() ?
                // t.printStackTrace();
            }

            if (in.isUpdateCount()) {
                updateCounts[count++] = in.getUpdateCount();
            } else if (in.isData()) {

                // FIXME:  we don't have what it takes yet
                // to differentiate between things like
                // stored procedure calls to methods with
                // void return type and select statements with
                // a single row/column containing null
                updateCounts[count++] = ResultConstants.SUCCESS_NO_INFO;
            } else if (in.mode == ResultConstants.CALL_RESPONSE) {
                updateCounts[count++] = ResultConstants.SUCCESS_NO_INFO;
            } else if (in.mode == ResultConstants.ERROR) {
                updateCounts = ArrayUtil.arraySlice(updateCounts, 0, count);
                error        = in;
                break;
            } else {
                throw Error.runtimeError(ErrorCode.U_S0500, "Session");
            }
        }

        return Result.newBatchedExecuteResponse(updateCounts, null, error);
    }

    /**
     * Retrieves the result of inserting, updating or deleting a row
     * from an updatable result.
     *
     * @return the result of executing the statement
     */
    private Result executeResultUpdate(Result cmd) {

        long   id         = cmd.getResultId();
        int    actionType = cmd.getActionType();
        Result result     = sessionData.getDataResult(id);

        if (result == null) {
            return Result.newErrorResult(Error.error(ErrorCode.X_24501));
        }

        Object[]       pvals     = (Object[]) cmd.valueData;
        Type[]         types     = cmd.metaData.columnTypes;
        StatementQuery statement = (StatementQuery) result.getStatement();

        sessionContext.rowUpdateStatement.setRowActionProperties(
            result,
            actionType,
            statement,
            types);

        Result resultOut = executeCompiledStatement(
            sessionContext.rowUpdateStatement,
            pvals,
            cmd.queryTimeout);

        return resultOut;
    }

// session DATETIME functions
    long                  currentTimestampSCN = -1;    // initialise to invalid val
    private TimestampData transactionUTC;
    boolean               transactionUTCSet;
    private TimestampData currentDate;
    private TimestampData currentTimestamp;
    private TimestampData localTimestamp;
    private TimeData      currentTime;
    private TimeData      localTime;

    /**
     * Returns the current date/time, unchanged for the duration of the current
     * execution unit (statement).<p>
     *
     * SQL standards require that CURRENT_DATE, CURRENT_TIME,
     * CURRENT_TIMESTAMP, LOCALTIME, and LOCALTIMESTAMP are all evaluated at
     * the same point of time in the duration of each SQL statement, no matter
     * how long the SQL statement takes to complete.<p>
     *
     * When this method or a corresponding method for CURRENT_TIME or
     * CURRENT_TIMESTAMP is first called in the scope of a system change
     * number, currentTimestamp is set to the current system time. All further
     * CURRENT_XXXX and LOCALXXXX calls in this scope will use this base point
     * of time.
     *
     * (fredt@users)
     */
    synchronized TimestampData getCurrentTimestamp() {
        resetCurrentTimestamp();

        return currentTimestamp;
    }

    synchronized TimestampData getLocalTimestamp() {

        resetCurrentTimestamp();

        if (localTimestamp == null) {
            localTimestamp = DateTimeType.toLocalTimestampValue(
                currentTimestamp);
        }

        return localTimestamp;
    }

    public synchronized TimestampData getCurrentDate() {

        resetCurrentTimestamp();

        if (currentDate == null) {
            currentDate = DateTimeType.toCurrentDateValue(currentTimestamp);
        }

        return currentDate;
    }

    /**
     * Returns the current time, unchanged for the duration of the current
     * execution unit (statement)
     */
    synchronized TimeData getCurrentTime() {

        resetCurrentTimestamp();

        if (currentTime == null) {
            currentTime = DateTimeType.toCurrentTimeWithZoneValue(
                currentTimestamp);
        }

        return currentTime;
    }

    synchronized TimeData getLocalTime() {

        resetCurrentTimestamp();

        if (localTime == null) {
            localTime = DateTimeType.toCurrentTimeValue(currentTimestamp);
        }

        return localTime;
    }

    private void resetCurrentTimestamp() {

        if (currentTimestampSCN != actionSCN) {
            currentTimestampSCN = actionSCN;
            currentTimestamp = DateTimeType.newCurrentTimestamp(
                currentTimeZone);
            currentDate         = null;
            localTimestamp      = null;
            currentTime         = null;
            localTime           = null;
        }
    }

    TimestampData getTransactionUTC() {

        if (!transactionUTCSet) {
            transactionUTC    = DateTimeType.newSystemTimestampUTC();
            transactionUTCSet = true;
        }

        return transactionUTC;
    }

    // session calendars
    private Calendar calendar;
    private Calendar calendarGMT;

    public TimeZone getTimeZone() {
        return currentTimeZone;
    }

    public int getZoneSeconds() {
        return currentTimestamp.getZone();
    }

    public void resetTimeZone() {

        currentTimeZone = timeZone;

        if (calendar != null) {
            calendar.setTimeZone(currentTimeZone);
        }
    }

    public void setTimeZone(TimeZone zone) {

        currentTimeZone = zone;

        if (calendar != null) {
            calendar.setTimeZone(currentTimeZone);
        }

        resetCurrentTimestamp();
    }

    public Calendar getCalendar() {

        if (calendar == null) {
            calendar = new GregorianCalendar(currentTimeZone);
        }

        return calendar;
    }

    public Calendar getCalendarGMT() {

        if (calendarGMT == null) {
            calendarGMT = new GregorianCalendar(TimeZone.getTimeZone("GMT"));

            calendarGMT.setFirstDayOfWeek(Calendar.MONDAY);
            calendarGMT.setMinimalDaysInFirstWeek(4);
        }

        return calendarGMT;
    }

    public SimpleDateFormat getSimpleDateFormatGMT() {

        if (simpleDateFormatGMT == null) {
            simpleDateFormatGMT = new SimpleDateFormat(
                "MMMM",
                HsqlDateTime.defaultLocale);

            simpleDateFormatGMT.setCalendar(getCalendarGMT());
        }

        return simpleDateFormatGMT;
    }

    public Result getSetAttributeResult(int id) {

        Result result = getAttributesResult(id);

        result.setResultType(ResultConstants.SETSESSIONATTR);

        return result;
    }

    public Result getAttributesResult(int id) {

        Result   r    = Result.newSessionAttributesResult();
        Object[] data = r.getSingleRowData();

        data[AttributePos.INFO_ID] = ValuePool.getInt(id);

        switch (id) {

            case Attributes.INFO_ISOLATION :
                data[AttributePos.INFO_INTEGER] = ValuePool.getInt(
                    isolationLevel);
                break;

            case Attributes.INFO_AUTOCOMMIT :
                data[AttributePos.INFO_BOOLEAN] = sessionContext.isAutoCommit;
                break;

            case Attributes.INFO_CONNECTION_READONLY :
                data[AttributePos.INFO_BOOLEAN] = sessionContext.isReadOnly;
                break;

            case Attributes.INFO_CATALOG :
                data[AttributePos.INFO_VARCHAR] =
                    database.getCatalogName().name;
                break;

            case Attributes.INFO_TIMEZONE :
                data[AttributePos.INFO_VARCHAR] = currentTimeZone.getID();
                break;
        }

        return r;
    }

    private Result setAttributes(Result r) {

        Object[] row = r.getSessionAttributes();
        int      id  = ((Integer) row[AttributePos.INFO_ID]).intValue();

        try {
            switch (id) {

                case Attributes.INFO_AUTOCOMMIT : {
                    boolean value =
                        ((Boolean) row[AttributePos.INFO_BOOLEAN]).booleanValue();

                    this.setAutoCommit(value);
                    break;
                }

                case Attributes.INFO_CONNECTION_READONLY : {
                    boolean value =
                        ((Boolean) row[AttributePos.INFO_BOOLEAN]).booleanValue();

                    this.setReadOnlyDefault(value);
                    break;
                }

                case Attributes.INFO_ISOLATION : {
                    int value =
                        ((Integer) row[AttributePos.INFO_INTEGER]).intValue();

                    this.setIsolationDefault(value);
                    break;
                }

                case Attributes.INFO_CATALOG : {
                    String value = ((String) row[AttributePos.INFO_VARCHAR]);

                    this.setCatalog(value);
                }
            }
        } catch (HsqlException e) {
            return Result.newErrorResult(e);
        }

        return Result.updateZeroResult;
    }

    public synchronized Object getAttribute(int id) {

        switch (id) {

            case Attributes.INFO_ISOLATION :
                return ValuePool.getInt(isolationLevel);

            case Attributes.INFO_AUTOCOMMIT :
                return sessionContext.isAutoCommit;

            case Attributes.INFO_CONNECTION_READONLY :
                return isReadOnlyDefault;

            case Attributes.INFO_CATALOG :
                return database.getCatalogName().name;
        }

        return null;
    }

    /**
     * no-op, only for ClientConnection
     */
    public void setAttributeFromResult(Result result) {}

    public synchronized void setAttribute(int id, Object object) {

        switch (id) {

            case Attributes.INFO_AUTOCOMMIT : {
                boolean value = ((Boolean) object).booleanValue();

                this.setAutoCommit(value);
                break;
            }

            case Attributes.INFO_CONNECTION_READONLY : {
                boolean value = ((Boolean) object).booleanValue();

                this.setReadOnlyDefault(value);
                break;
            }

            case Attributes.INFO_ISOLATION : {
                int value = ((Integer) object).intValue();

                this.setIsolationDefault(value);
                break;
            }

            case Attributes.INFO_CATALOG : {
                String value = ((String) object);

                this.setCatalog(value);
            }
        }
    }

    // lobs
    public BlobDataID createBlob(long length) {

        long lobID = database.lobManager.createBlob(this, length);

        if (lobID == 0) {
            throw Error.error(ErrorCode.X_0F502);
        }

        if (sessionData.newLobFloor == SessionData.noLobFloor) {
            sessionData.newLobFloor = lobID;
        }

        return new BlobDataID(lobID);
    }

    public ClobDataID createClob(long length) {

        long lobID = database.lobManager.createClob(this, length);

        if (lobID == 0) {
            throw Error.error(ErrorCode.X_0F502);
        }

        if (sessionData.newLobFloor == SessionData.noLobFloor) {
            sessionData.newLobFloor = lobID;
        }

        return new ClobDataID(lobID);
    }

    public void registerResultLobs(Result result) {
        sessionData.registerLobForResult(result);
    }

    public Result allocateResultLob(ResultLob result) {
        return sessionData.allocateLobForResult(result);
    }

    Result performLOBOperation(ResultLob cmd) {

        long id        = cmd.getLobID();
        int  operation = cmd.getSubType();

        switch (operation) {

            case ResultLob.LobResultTypes.REQUEST_GET_LOB : {
                return database.lobManager.getLob(
                    id,
                    cmd.getOffset(),
                    cmd.getBlockLength());
            }

            case ResultLob.LobResultTypes.REQUEST_GET_LENGTH : {
                return database.lobManager.getLength(id);
            }

            case ResultLob.LobResultTypes.REQUEST_GET_BYTES : {
                return database.lobManager.getBytes(
                    id,
                    cmd.getOffset(),
                    (int) cmd.getBlockLength());
            }

            case ResultLob.LobResultTypes.REQUEST_SET_BYTES : {
                return database.lobManager.setBytes(
                    id,
                    cmd.getOffset(),
                    cmd.getByteArray(),
                    (int) cmd.getBlockLength());
            }

            case ResultLob.LobResultTypes.REQUEST_GET_CHARS : {
                return database.lobManager.getChars(
                    id,
                    cmd.getOffset(),
                    (int) cmd.getBlockLength());
            }

            case ResultLob.LobResultTypes.REQUEST_SET_CHARS : {
                return database.lobManager.setChars(
                    id,
                    cmd.getOffset(),
                    cmd.getCharArray(),
                    (int) cmd.getBlockLength());
            }

            case ResultLob.LobResultTypes.REQUEST_TRUNCATE : {
                return database.lobManager.truncate(id, cmd.getOffset());
            }

            case ResultLob.LobResultTypes.REQUEST_DUPLICATE_LOB : {
                return database.lobManager.createDuplicateLob(id);
            }

            case ResultLob.LobResultTypes.REQUEST_CREATE_BYTES :
            case ResultLob.LobResultTypes.REQUEST_CREATE_CHARS :
            case ResultLob.LobResultTypes.REQUEST_GET_BYTE_PATTERN_POSITION :
            case ResultLob.LobResultTypes.REQUEST_GET_CHAR_PATTERN_POSITION : {
                throw Error.error(ErrorCode.X_0A501);
            }

            default : {
                throw Error.runtimeError(ErrorCode.U_S0500, "Session");
            }
        }
    }

    // DatabaseMetaData.getURL should work as specified for
    // internal connections too.
    public String getInternalConnectionURL() {
        return DatabaseURL.S_URL_PREFIX + database.getURI();
    }

    public Result cancel(Result result) {

        if (result.getType() == ResultConstants.SQLCANCEL) {
            if (result.getSessionRandomID() == randomId) {
                database.txManager.resetSession(
                    this,
                    this,
                    statementStartSCN,
                    TransactionManager.resetSessionStatement);
            }
        }

        return Result.updateZeroResult;
    }

    public boolean isProcessingScript() {
        return isProcessingScript;
    }

    public boolean isProcessingLog() {
        return isProcessingLog;
    }

    // schema object methods
    public void setSchema(String schema) {
        currentSchema = database.schemaManager.getSchemaHsqlName(schema);
    }

    public void setCatalog(String catalog) {

        if (database.getCatalogName().name.equals(catalog)) {
            return;
        }

        throw Error.error(ErrorCode.X_3D000);
    }

    /**
     * If schemaName is null, return the current schema name, else return
     * the HsqlName object for the schema. If schemaName does not exist,
     * throw.
     */
    HsqlName getSchemaHsqlName(String name) {
        return name == null
               ? currentSchema
               : database.schemaManager.getSchemaHsqlName(name);
    }

    /**
     * Same as above, but return string
     */
    public String getSchemaName(String name) {
        return name == null
               ? currentSchema.name
               : database.schemaManager.getSchemaName(name);
    }

    public void setCurrentSchemaHsqlName(HsqlName name) {
        currentSchema = name;
    }

    public HsqlName getCurrentSchemaHsqlName() {
        return currentSchema;
    }

    public int getResultMemoryRowCount() {
        return resultMaxMemoryRows;
    }

    public void setResultMemoryRowCount(int count) {

        if (database.logger.getTempDirectoryPath() != null) {
            if (count < 0) {
                count = 0;
            }

            resultMaxMemoryRows = count;
        }
    }

    // warnings
    HsqlDeque<HsqlException> sqlWarnings;

    public void addWarning(HsqlException warning) {

        if (sqlWarnings == null) {
            sqlWarnings = new HsqlDeque<>();
        }

        if (sqlWarnings.size() > 9) {
            sqlWarnings.removeFirst();
        }

        int index = sqlWarnings.indexOf(warning);

        if (index >= 0) {
            sqlWarnings.remove(index);
        }

        sqlWarnings.add(warning);
    }

    public HsqlException[] getAndClearWarnings() {

        if (sqlWarnings == null) {
            return HsqlException.emptyArray;
        }

        HsqlException[] array = new HsqlException[sqlWarnings.size()];

        sqlWarnings.toArray(array);
        sqlWarnings.clear();

        return array;
    }

    public HsqlException getLastWarning() {

        if (sqlWarnings == null || sqlWarnings.isEmpty()) {
            return null;
        }

        return sqlWarnings.getLast();
    }

    public void clearWarnings() {
        if (sqlWarnings != null) {
            sqlWarnings.clear();
        }
    }

    // services
    TypedComparator  typedComparator = new TypedComparator(this);
    Scanner          secondaryScanner;
    SimpleDateFormat simpleDateFormat;
    SimpleDateFormat simpleDateFormatGMT;
    Random           randomGenerator = new Random();
    long             seed            = -1;
    public final int randomId = randomGenerator.nextInt(Integer.MAX_VALUE);

    //
    public TypedComparator getComparator() {
        return typedComparator;
    }

    public double random(long seed) {

        if (this.seed != seed) {
            randomGenerator.setSeed(seed);

            this.seed = seed;
        }

        return randomGenerator.nextDouble();
    }

    public double random() {
        return randomGenerator.nextDouble();
    }

    public Scanner getScanner() {

        if (secondaryScanner == null) {
            secondaryScanner = new Scanner();
        }

        return secondaryScanner;
    }

    // properties
    HsqlProperties clientProperties;

    public HsqlProperties getClientProperties() {

        if (clientProperties == null) {
            clientProperties = new HsqlProperties();

            clientProperties.setProperty(
                HsqlDatabaseProperties.jdbc_translate_tti_types,
                database.sqlTranslateTTI);
            clientProperties.setProperty(
                HsqlDatabaseProperties.sql_live_object,
                database.sqlLiveObject);
        }

        return clientProperties;
    }

    // logging and SEQUENCE current values
    void logSequences() {

        HashMap<NumberSequence, Number> map = sessionData.sequenceUpdateMap;

        if (map == null || map.isEmpty()) {
            return;
        }

        Iterator<NumberSequence> it = map.keySet().iterator();

        for (int i = 0, size = map.size(); i < size; i++) {
            NumberSequence sequence = it.next();

            database.logger.writeSequenceStatement(this, sequence);
        }

        sessionData.sequenceUpdateMap.clear();
    }

    String getStartTransactionSQL() {

        StringBuilder sb = new StringBuilder();

        sb.append(Tokens.T_START).append(' ').append(Tokens.T_TRANSACTION);

        if (isolationLevel != isolationLevelDefault) {
            sb.append(' ');
            appendIsolationSQL(sb, isolationLevel);
        }

        return sb.toString();
    }

    String getTransactionIsolationSQL() {

        StringBuilder sb = new StringBuilder();

        sb.append(Tokens.T_SET)
          .append(' ')
          .append(Tokens.T_TRANSACTION)
          .append(' ');
        appendIsolationSQL(sb, isolationLevel);

        return sb.toString();
    }

    String getSessionIsolationSQL() {

        StringBuilder sb = new StringBuilder();

        sb.append(Tokens.T_SET)
          .append(' ')
          .append(Tokens.T_SESSION)
          .append(' ')
          .append(Tokens.T_CHARACTERISTICS)
          .append(' ')
          .append(Tokens.T_AS)
          .append(' ')
          .append(Tokens.T_TRANSACTION)
          .append(' ');
        appendIsolationSQL(sb, isolationLevelDefault);

        return sb.toString();
    }

    static void appendIsolationSQL(StringBuilder sb, int isolationLevel) {

        sb.append(Tokens.T_ISOLATION)
          .append(' ')
          .append(Tokens.T_LEVEL)
          .append(' ')
          .append(getIsolationString(isolationLevel));
    }

    static String getIsolationString(int isolationLevel) {

        switch (isolationLevel) {

            case SessionInterface.TX_READ_UNCOMMITTED :
            case SessionInterface.TX_READ_COMMITTED :
                StringBuilder sb = new StringBuilder();

                sb.append(Tokens.T_READ).append(' ').append(Tokens.T_COMMITTED);

                return sb.toString();

            case SessionInterface.TX_REPEATABLE_READ :
            case SessionInterface.TX_SERIALIZABLE :
            default :
                return Tokens.T_SERIALIZABLE;
        }
    }

    String getSetSchemaStatement() {
        return "SET SCHEMA " + currentSchema.statementName;
    }

    // timeouts
    class TimeoutManager {

        volatile int  currentTimeout;
        volatile long checkTimestampSCN;
        volatile long checkTimestamp;

        synchronized void startTimeout(int timeout) {

            if (timeout == 0) {
                return;
            }

            boolean add = checkTimestampSCN == 0;

            currentTimeout    = timeout * 1000;
            checkTimestampSCN = statementStartSCN;
            checkTimestamp    = System.currentTimeMillis();

            if (add) {
                database.timeoutRunner.addSession(this);
            }
        }

        synchronized void endTimeout() {
            currentTimeout = 0;
        }

        synchronized public boolean checkTimeout(long systemMillis) {

            if (currentTimeout == 0) {
                return false;
            }

            if (checkTimestampSCN != statementStartSCN) {
                return false;
            }

            if (checkTimestamp + currentTimeout < systemMillis) {
                currentTimeout = 0;

                database.txManager.resetSession(
                    Session.this,
                    Session.this,
                    checkTimestampSCN,
                    TransactionManager.resetSessionStatement);

                return true;
            }

            return false;
        }

        synchronized public boolean isClosed() {
            return Session.this.isClosed;
        }
    }
}
