Java > Open Source Codes > org > hsqldb > Session


1 /* Copyright (c) 1995-2000, The Hypersonic SQL Group.
2  * All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are met:
6  *
7  * Redistributions of source code must retain the above copyright notice, this
8  * list of conditions and the following disclaimer.
9  *
10  * Redistributions in binary form must reproduce the above copyright notice,
11  * this list of conditions and the following disclaimer in the documentation
12  * and/or other materials provided with the distribution.
13  *
14  * Neither the name of the Hypersonic SQL Group nor the names of its
15  * contributors may be used to endorse or promote products derived from this
16  * software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED. IN NO EVENT SHALL THE HYPERSONIC SQL GROUP,
22  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  *
30  * This software consists of voluntary contributions made by many individuals
31  * on behalf of the Hypersonic SQL Group.
32  *
33  *
34  * For work added by the HSQL Development Group:
35  *
36  * Copyright (c) 2001-2005, The HSQL Development Group
37  * All rights reserved.
38  *
39  * Redistribution and use in source and binary forms, with or without
40  * modification, are permitted provided that the following conditions are met:
41  *
42  * Redistributions of source code must retain the above copyright notice, this
43  * list of conditions and the following disclaimer.
44  *
45  * Redistributions in binary form must reproduce the above copyright notice,
46  * this list of conditions and the following disclaimer in the documentation
47  * and/or other materials provided with the distribution.
48  *
49  * Neither the name of the HSQL Development Group nor the names of its
50  * contributors may be used to endorse or promote products derived from this
51  * software without specific prior written permission.
52  *
53  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
54  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
55  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
56  * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
57  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
58  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
59  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
60  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
61  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
62  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
63  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
64  */
65
66
67 package org.hsqldb;
68
69 import java.sql.Date ;
70 import java.sql.Time ;
71 import java.sql.Timestamp ;
72
73 import org.hsqldb.HsqlNameManager.HsqlName;
74 import org.hsqldb.jdbc.jdbcConnection;
75 import org.hsqldb.lib.ArrayUtil;
76 import org.hsqldb.lib.HashMappedList;
77 import org.hsqldb.lib.HsqlArrayList;
78 import org.hsqldb.lib.IntKeyHashMap;
79 import org.hsqldb.lib.SimpleLog;
80 import org.hsqldb.lib.java.JavaSystem;
81 import org.hsqldb.store.ValuePool;
82
83 // fredt@users 20020320 - doc 1.7.0 - update
84 // fredt@users 20020315 - patch 1.7.0 - switch for scripting
85 // fredt@users 20020130 - patch 476694 by velichko - transaction savepoints
86 // additions in different parts to support savepoint transactions
87 // fredt@users 20020910 - patch 1.7.1 by fredt - database readonly enforcement
88 // fredt@users 20020912 - patch 1.7.1 by fredt - permanent internal connection
89 // boucherb@users 20030512 - patch 1.7.2 - compiled statements
90 // - session becomes execution hub
91 // boucherb@users 20050510 - patch 1.7.2 - generalized Result packet passing
92 // based command execution
93 // - batch execution handling
94 // fredt@users 20030628 - patch 1.7.2 - session proxy support
95 // fredt@users 20040509 - patch 1.7.2 - SQL conformance for CURRENT_TIMESTAMP and other datetime functions
96
97 /**
98  * Implementation of a user session with the database. In 1.7.2 Session
99  * becomes the public interface to an HSQLDB database, accessed locally or
100  * remotely via SessionInterface.
101  *
102  * When as Session is closed, all references to internal engine objects are
103  * set to null. But the session id and scripting mode may still be used for
104  * scripting
105  *
106  * New class based based on original Hypersonic code.
107  * Extensively rewritten and extended in successive versions of HSQLDB.
108  *
109  * @author Thomas Mueller (Hypersonic SQL Group)
110  * @version 1.8.0
111  * @since 1.7.0
112  */
113 public class Session implements SessionInterface {
114
115     //
116 private volatile boolean isAutoCommit;
117     private volatile boolean isReadOnly;
118     private volatile boolean isClosed;
119
120     //
121 Database database;
122     private User user;
123     HsqlArrayList rowActionList;
124     private boolean isNestedTransaction;
125     private int nestedOldTransIndex;
126     int isolationMode = SessionInterface.TX_READ_COMMITTED;
127     long actionTimestamp;
128     long transactionTimestamp;
129     private int currentMaxRows;
130     private int sessionMaxRows;
131     private Number lastIdentity = ValuePool.getInt(0);
132     private final int sessionId;
133     HashMappedList savepoints;
134     private boolean script;
135     private Tokenizer tokenizer;
136     private Parser parser;
137     static final Result emptyUpdateCount =
138         new Result(ResultConstants.UPDATECOUNT);
139
140     //
141 private jdbcConnection intConnection;
142
143     // schema
144 public HsqlName currentSchema;
145     public HsqlName loggedSchema;
146     private HsqlName oldSchema;
147
148     // query processing
149 boolean isProcessingScript;
150     boolean isProcessingLog;
151
152     // two types of temp tables
153 private IntKeyHashMap indexArrayMap;
154     private IntKeyHashMap indexArrayKeepMap;
155
156     /** @todo fredt - clarify in which circumstances Session has to disconnect */
157     Session getSession() {
158         return this;
159     }
160
161     /**
162      * Constructs a new Session object.
163      *
164      * @param db the database to which this represents a connection
165      * @param user the initial user
166      * @param autocommit the initial autocommit value
167      * @param readonly the initial readonly value
168      * @param id the session identifier, as known to the database
169      */
170     Session(Database db, User user, boolean autocommit, boolean readonly,
171             int id) {
172
173         sessionId = id;
174         database = db;
175         this.user = user;
176         rowActionList = new HsqlArrayList(true);
177         savepoints = new HashMappedList(4);
178         isAutoCommit = autocommit;
179         isReadOnly = readonly;
180         dbCommandInterpreter = new DatabaseCommandInterpreter(this);
181         compiledStatementExecutor = new CompiledStatementExecutor(this);
182         compiledStatementManager = db.compiledStatementManager;
183         tokenizer = new Tokenizer();
184         parser = new Parser(this, database, tokenizer);
185
186         resetSchema();
187     }
188
189     void resetSchema() {
190
191         HsqlName initialSchema = user.getInitialSchema();
192
193         currentSchema = ((initialSchema == null)
194                          ? database.schemaManager.getDefaultSchemaHsqlName()
195                          : initialSchema);
196     }
197
198     /**
199      * Retrieves the session identifier for this Session.
200      *
201      * @return the session identifier for this Session
202      */
203     public int getId() {
204         return sessionId;
205     }
206
207     /**
208      * Closes this Session.
209      */
210     public void close() {
211
212         if (isClosed) {
213             return;
214         }
215
216         synchronized (database) {
217
218             // test again inside block
219 if (isClosed) {
220                 return;
221             }
222
223             database.sessionManager.removeSession(this);
224             rollback();
225
226             try {
227                 database.logger.writeToLog(this, Token.T_DISCONNECT);
228             } catch (HsqlException e) {}
229
230             clearIndexRoots();
231             clearIndexRootsKeep();
232             compiledStatementManager.removeSession(sessionId);
233             database.closeIfLast();
234
235             database = null;
236             user = null;
237             rowActionList = null;
238             savepoints = null;
239             intConnection = null;
240             compiledStatementExecutor = null;
241             compiledStatementManager = null;
242             dbCommandInterpreter = null;
243             lastIdentity = null;
244             isClosed = true;
245         }
246     }
247
248     /**
249      * Retrieves whether this Session is closed.
250      *
251      * @return true if this Session is closed
252      */
253     public boolean isClosed() {
254         return isClosed;
255     }
256
257     public void setIsolation(int level) throws HsqlException {
258         isolationMode = level;
259     }
260
261     public int getIsolation() throws HsqlException {
262         return isolationMode;
263     }
264
265     /**
266      * Setter for iLastIdentity attribute.
267      *
268      * @param i the new value
269      */
270     void setLastIdentity(Number i) {
271         lastIdentity = i;
272     }
273
274     /**
275      * Getter for iLastIdentity attribute.
276      *
277      * @return the current value
278      */
279     Number getLastIdentity() {
280         return lastIdentity;
281     }
282
283     /**
284      * Retrieves the Database instance to which this
285      * Session represents a connection.
286      *
287      * @return the Database object to which this Session is connected
288      */
289     Database getDatabase() {
290         return database;
291     }
292
293     /**
294      * Retrieves the name, as known to the database, of the
295      * user currently controlling this Session.
296      *
297      * @return the name of the user currently connected within this Session
298      */
299     String getUsername() {
300         return user.getName();
301     }
302
303     /**
304      * Retrieves the User object representing the user currently controlling
305      * this Session.
306      *
307      * @return this Session's User object
308      */
309     public User getUser() {
310         return user;
311     }
312
313     /**
314      * Sets this Session's User object to the one specified by the
315      * user argument.
316      *
317      * @param user the new User object for this session
318      */
319     void setUser(User user) {
320         this.user = user;
321     }
322
323     int getMaxRows() {
324         return currentMaxRows;
325     }
326
327     int getSQLMaxRows() {
328         return sessionMaxRows;
329     }
330
331     /**
332      * The SQL command SET MAXROWS n will override the Statement.setMaxRows(n)
333      * until SET MAXROWS 0 is issued.
334      *
335      * NB this is dedicated to the SET MAXROWS sql statement and should not
336      * otherwise be called. (fredt@users)
337      */
338     void setSQLMaxRows(int rows) {
339         currentMaxRows = sessionMaxRows = rows;
340     }
341
342     /**
343      * Checks whether this Session's current User has the privileges of
344      * the ADMIN role.
345      *
346      * @throws HsqlException if this Session's User does not have the
347      * privileges of the ADMIN role.
348      */
349     void checkAdmin() throws HsqlException {
350         user.checkAdmin();
351     }
352
353     /**
354      * Checks whether this Session's current User has the set of rights
355      * specified by the right argument, in relation to the database
356      * object identifier specified by the object argument.
357      *
358      * @param object the database object to check
359      * @param right the rights to check for
360      * @throws HsqlException if the Session User does not have such rights
361      */
362     void check(HsqlName object, int right) throws HsqlException {
363         user.check(object, right);
364     }
365
366     /**
367      * Checks the rights on a function
368      *
369      * @param object the function
370      * @throws HsqlException if the Session User does not have such rights
371      */
372     void check(String object) throws HsqlException {
373         user.check(object);
374     }
375
376     /**
377      * This is used for reading - writing to existing tables.
378      * @throws HsqlException
379      */
380     void checkReadWrite() throws HsqlException {
381
382         if (isReadOnly) {
383             throw Trace.error(Trace.DATABASE_IS_READONLY);
384         }
385     }
386
387     /**
388      * This is used for creating new database objects such as tables.
389      * @throws HsqlException
390      */
391     void checkDDLWrite() throws HsqlException {
392
393         if (database.isFilesReadOnly() &&!user.isSys()) {
394             throw Trace.error(Trace.DATABASE_IS_READONLY);
395         }
396     }
397
398     /**
399      * Adds a single-row deletion step to the transaction UNDO buffer.
400      *
401      * @param table the table from which the row was deleted
402      * @param row the deleted row
403      * @throws HsqlException
404      */
405     boolean addDeleteAction(Table table, Row row) throws HsqlException {
406
407         if (!isAutoCommit || isNestedTransaction) {
408             Transaction t = new Transaction(true, table, row,
409                                             actionTimestamp);
410
411             rowActionList.add(t);
412             database.txManager.addTransaction(this, t);
413
414             return true;
415         } else {
416             table.removeRowFromStore(row);
417         }
418
419         return false;
420     }
421
422     /**
423      * Adds a single-row insertion step to the transaction UNDO buffer.
424      *
425      * @param table the table into which the row was inserted
426      * @param row the inserted row
427      * @throws HsqlException
428      */
429     boolean addInsertAction(Table table, Row row) throws HsqlException {
430
431         if (!isAutoCommit || isNestedTransaction) {
432             Transaction t = new Transaction(false, table, row,
433                                             actionTimestamp);
434
435             rowActionList.add(t);
436             database.txManager.addTransaction(this, t);
437
438             return true;
439         } else {
440             table.commitRowToStore(row);
441         }
442
443         return false;
444     }
445
446     /**
447      * Setter for the autocommit attribute.
448      *
449      * @param autocommit the new value
450      * @throws HsqlException
451      */
452     public void setAutoCommit(boolean autocommit) {
453
454         if (isClosed) {
455             return;
456         }
457
458         synchronized (database) {
459             if (autocommit != isAutoCommit) {
460                 commit();
461
462                 isAutoCommit = autocommit;
463
464                 try {
465                     database.logger.writeToLog(this,
466                                                getAutoCommitStatement());
467                 } catch (HsqlException e) {}
468             }
469         }
470     }
471
472     public void startPhasedTransaction() throws HsqlException {}
473
474     public void prepareCommit() throws HsqlException {}
475
476     /**
477      * Commits any uncommited transaction this Session may have open
478      *
479      * @throws HsqlException
480      */
481     public void commit() {
482
483         if (isClosed) {
484             return;
485         }
486
487         synchronized (database) {
488             if (!rowActionList.isEmpty()) {
489                 try {
490                     database.logger.writeCommitStatement(this);
491                 } catch (HsqlException e) {}
492             }
493
494             database.txManager.commit(this);
495             clearIndexRoots();
496         }
497     }
498
499     /**
500      * Rolls back any uncommited transaction this Session may have open.
501      *
502      * @throws HsqlException
503      */
504     public void rollback() {
505
506         if (isClosed) {
507             return;
508         }
509
510         synchronized (database) {
511             if (rowActionList.size() != 0) {
512                 try {
513                     database.logger.writeToLog(this, Token.T_ROLLBACK);
514                 } catch (HsqlException e) {}
515             }
516
517             database.txManager.rollback(this);
518             clearIndexRoots();
519         }
520     }
521
522     /**
523      * No-op in this implementation
524      */
525     public void resetSession() throws HsqlException {
526         throw new HsqlException("", "", 0);
527     }
528
529     /**
530      * Implements a transaction SAVEPOINT. A new SAVEPOINT with the
531      * name of an existing one replaces the old SAVEPOINT.
532      *
533      * @param name of the savepoint
534      * @throws HsqlException if there is no current transaction
535      */
536     void savepoint(String name) throws HsqlException {
537
538         savepoints.remove(name);
539         savepoints.add(name, ValuePool.getInt(rowActionList.size()));
540
541         try {
542             database.logger.writeToLog(this, Token.T_SAVEPOINT + " " + name);
543         } catch (HsqlException e) {}
544     }
545
546     /**
547      * Implements a partial transaction ROLLBACK.
548      *
549      * @param name Name of savepoint that was marked before by savepoint()
550      * call
551      * @throws HsqlException
552      */
553     void rollbackToSavepoint(String name) throws HsqlException {
554
555         if (isClosed) {
556             return;
557         }
558
559         try {
560             database.logger.writeToLog(this,
561                                        Token.T_ROLLBACK + " " + Token.T_TO
562                                        + " " + Token.T_SAVEPOINT + " "
563                                        + name);
564         } catch (HsqlException e) {}
565
566         database.txManager.rollbackSavepoint(this, name);
567     }
568
569     /**
570      * Implements release of named SAVEPOINT.
571      *
572      * @param name Name of savepoint that was marked before by savepoint()
573      * call
574      * @throws HsqlException if name does not correspond to a savepoint
575      */
576     void releaseSavepoint(String name) throws HsqlException {
577
578         // remove this and all later savepoints
579 int index = savepoints.getIndex(name);
580
581         Trace.check(index >= 0, Trace.SAVEPOINT_NOT_FOUND, name);
582
583         while (savepoints.size() > index) {
584             savepoints.remove(savepoints.size() - 1);
585         }
586     }
587
588     /**
589      * Starts a nested transaction.
590      *
591      * @throws HsqlException
592      */
593     void beginNestedTransaction() throws HsqlException {
594
595         if (isNestedTransaction) {
596             Trace.doAssert(false, "beginNestedTransaction");
597         }
598
599         nestedOldTransIndex = rowActionList.size();
600         isNestedTransaction = true;
601
602         if (isAutoCommit) {
603             try {
604                 database.logger.writeToLog(this, "SET AUTOCOMMIT FALSE");
605             } catch (HsqlException e) {}
606         }
607     }
608
609     /**
610      * @todo -- fredt 20050604 - if this method is called after an out of memory
611      * error during update, the next block might throw out of memory too and as
612      * a result inNestedTransaction remains true and no further update
613      * is possible. The session must be closed at that point by the user
614      * application.
615      */
616
617     /**
618      * Ends a nested transaction.
619      *
620      * @param rollback true to roll back or false to commit the nested transaction
621      * @throws HsqlException
622      */
623     void endNestedTransaction(boolean rollback) throws HsqlException {
624
625         if (!isNestedTransaction) {
626             Trace.doAssert(false, "endNestedTransaction");
627         }
628
629         if (rollback) {
630             database.txManager.rollbackTransactions(this,
631                     nestedOldTransIndex, true);
632         }
633
634         // reset after the rollback
635 isNestedTransaction = false;
636
637         if (isAutoCommit) {
638             database.txManager.commit(this);
639
640             try {
641                 database.logger.writeToLog(this, "SET AUTOCOMMIT TRUE");
642             } catch (HsqlException e) {}
643         }
644     }
645
646     /**
647      * Setter for readonly attribute.
648      *
649      * @param readonly the new value
650      */
651     public void setReadOnly(boolean readonly) throws HsqlException {
652
653         if (!readonly && database.databaseReadOnly) {
654             throw Trace.error(Trace.DATABASE_IS_READONLY);
655         }
656
657         isReadOnly = readonly;
658     }
659
660     /**
661      * Getter for readonly attribute.
662      *
663      * @return the current value
664      */
665     public boolean isReadOnly() {
666         return isReadOnly;
667     }
668
669     /**
670      * Getter for nestedTransaction attribute.
671      *
672      * @return the current value
673      */
674     boolean isNestedTransaction() {
675         return isNestedTransaction;
676     }
677
678     /**
679      * Getter for autoCommit attribute.
680      *
681      * @return the current value
682      */
683     public boolean isAutoCommit() {
684         return isAutoCommit;
685     }
686
687     /**
688      * A switch to set scripting on the basis of type of statement executed.
689      * A method in DatabaseCommandInterpreter.java sets this value to false
690      * before other methods are called to act on an SQL statement, which may
691      * set this to true. Afterwards the method reponsible for logging uses
692      * getScripting() to determine if logging is required for the executed
693      * statement. (fredt@users)
694      *
695      * @param script The new scripting value
696      */
697     void setScripting(boolean script) {
698         this.script = script;
699     }
700
701     /**
702      * Getter for scripting attribute.
703      *
704      * @return scripting for the last statement.
705      */
706     boolean getScripting() {
707         return script;
708     }
709
710     public String getAutoCommitStatement() {
711         return isAutoCommit ? "SET AUTOCOMMIT TRUE"
712                             : "SET AUTOCOMMIT FALSE";
713     }
714
715     /**
716      * Retrieves an internal Connection object equivalent to the one
717      * that created this Session.
718      *
719      * @return internal connection.
720      */
721     jdbcConnection getInternalConnection() throws HsqlException {
722
723         if (intConnection == null) {
724             intConnection = new jdbcConnection(this);
725         }
726
727         return intConnection;
728     }
729
730 // boucherb@users 20020810 metadata 1.7.2
731 //----------------------------------------------------------------
732 private final long connectTime = System.currentTimeMillis();
733
734 // more effecient for MetaData concerns than checkAdmin
735
736     /**
737      * Getter for admin attribute.
738      *
739      * @ return the current value
740      */
741     boolean isAdmin() {
742         return user.isAdmin();
743     }
744
745     /**
746      * Getter for connectTime attribute.
747      *
748      * @return the value
749      */
750     long getConnectTime() {
751         return connectTime;
752     }
753
754     /**
755      * Getter for transactionSise attribute.
756      *
757      * @return the current value
758      */
759     int getTransactionSize() {
760         return rowActionList.size();
761     }
762
763     /**
764      * Retrieves whether the database object identifier by the dbobject
765      * argument is accessible by the current Session User.
766      *
767      * @return true if so, else false
768      */
769     boolean isAccessible(String dbobject) throws HsqlException {
770         return user.isAccessible(dbobject);
771     }
772
773     boolean isAccessible(HsqlName dbobject) throws HsqlException {
774         return user.isAccessible(dbobject);
775     }
776
777 // boucherb@users 20030417 - patch 1.7.2 - compiled statement support
778 //-------------------------------------------------------------------
779 DatabaseCommandInterpreter dbCommandInterpreter;
780     CompiledStatementExecutor compiledStatementExecutor;
781     CompiledStatementManager compiledStatementManager;
782
783     CompiledStatement sqlCompileStatement(String sql) throws HsqlException {
784
785         parser.reset(sql);
786
787         CompiledStatement cs;
788         int brackets = 0;
789         String token = tokenizer.getString();
790         int cmd = Token.get(token);
791
792         switch (cmd) {
793
794             case Token.OPENBRACKET : {
795                 brackets = parser.parseOpenBracketsSelect() + 1;
796             }
797             case Token.SELECT : {
798                 cs = parser.compileSelectStatement(brackets);
799
800                 break;
801             }
802             case Token.INSERT : {
803                 cs = parser.compileInsertStatement();
804
805                 break;
806             }
807             case Token.UPDATE : {
808                 cs = parser.compileUpdateStatement();
809
810                 break;
811             }
812             case Token.DELETE : {
813                 cs = parser.compileDeleteStatement();
814
815                 break;
816             }
817             case Token.CALL : {
818                 cs = parser.compileCallStatement();
819
820                 break;
821             }
822             default : {
823
824                 // DDL statements
825 cs = new CompiledStatement(currentSchema);
826
827                 break;
828             }
829         }
830
831         // In addition to requiring that the compilation was successful,
832 // we also require that the submitted sql represents a _single_
833 // valid DML or DDL statement. We do not check the DDL yet.
834 // fredt - now accepts semicolon and whitespace at the end of statement
835 // fredt - investigate if it should or not for prepared statements
836 if (cs.type != CompiledStatement.DDL) {
837             while (tokenizer.getPosition() < tokenizer.getLength()) {
838                 token = tokenizer.getString();
839
840                 if (token.length() != 0 &&!token.equals(Token.T_SEMICOLON)) {
841                     throw Trace.error(Trace.UNEXPECTED_TOKEN, token);
842                 }
843             }
844         }
845
846         // - need to be able to key cs against its sql in statement pool
847 // - also need to be able to revalidate its sql occasionally
848 cs.sql = sql;
849
850         return cs;
851     }
852
853     /**
854      * Executes the command encapsulated by the cmd argument.
855      *
856      * @param cmd the command to execute
857      * @return the result of executing the command
858      */
859     public Result execute(Result cmd) {
860
861         try {
862             if (isClosed) {
863                 Trace.check(false, Trace.ACCESS_IS_DENIED,
864                             Trace.getMessage(Trace.Session_execute));
865             }
866         } catch (Throwable t) {
867             return new Result(t, null);
868         }
869
870         synchronized (database) {
871             int type = cmd.mode;
872
873             if (sessionMaxRows == 0) {
874                 currentMaxRows = cmd.updateCount;
875             }
876
877             // we simply get the next system change number - no matter what type of query
878 actionTimestamp = database.txManager.nextActionTimestamp();
879
880             JavaSystem.gc();
881
882             switch (type) {
883
884                 case ResultConstants.SQLEXECUTE : {
885                     Result resultout = sqlExecute(cmd);
886
887                     resultout = performPostExecute(resultout);
888
889                     return resultout;
890                 }
891                 case ResultConstants.BATCHEXECUTE : {
892                     Result resultout = sqlExecuteBatch(cmd);
893
894                     resultout = performPostExecute(resultout);
895
896                     return resultout;
897                 }
898                 case ResultConstants.SQLEXECDIRECT : {
899                     Result resultout =
900                         sqlExecuteDirectNoPreChecks(cmd.getMainString());
901
902                     resultout = performPostExecute(resultout);
903
904                     return resultout;
905                 }
906                 case ResultConstants.BATCHEXECDIRECT : {
907                     Result resultout = sqlExecuteBatchDirect(cmd);
908
909                     resultout = performPostExecute(resultout);
910
911                     return resultout;
912                 }
913                 case ResultConstants.SQLPREPARE : {
914                     CompiledStatement cs;
915
916                     try {
917                         cs = compiledStatementManager.compile(
918                             this, cmd.getMainString());
919                     } catch (Throwable t) {
920                         return new Result(t, cmd.getMainString());
921                     }
922
923                     Result rmd = cs.describeResult();
924                     Result pmd = cs.describeParameters();
925
926                     return Result.newPrepareResponse(cs.id, rmd, pmd);
927                 }
928                 case ResultConstants.SQLFREESTMT : {
929                     compiledStatementManager.freeStatement(
930                         cmd.getStatementID(), sessionId, false);
931
932                     return emptyUpdateCount;
933                 }
934                 case ResultConstants.GETSESSIONATTR : {
935                     return getAttributes();
936                 }
937                 case ResultConstants.SETSESSIONATTR : {
938                     return setAttributes(cmd);
939                 }
940                 case ResultConstants.SQLENDTRAN : {
941                     switch (cmd.getEndTranType()) {
942
943                         case ResultConstants.COMMIT :
944                             commit();
945                             break;
946
947                         case ResultConstants.ROLLBACK :
948                             rollback();
949                             break;
950
951                         case ResultConstants.SAVEPOINT_NAME_RELEASE :
952                             try {
953                                 String name = cmd.getMainString();
954
955                                 releaseSavepoint(name);
956                             } catch (Throwable t) {
957                                 return new Result(t, null);
958                             }
959                             break;
960
961                         case ResultConstants.SAVEPOINT_NAME_ROLLBACK :
962                             try {
963                                 rollbackToSavepoint(cmd.getMainString());
964                             } catch (Throwable t) {
965                                 return new Result(t, null);
966                             }
967                             break;
968
969                         // not yet
970 // case ResultConstants.COMMIT_AND_CHAIN :
971 // case ResultConstants.ROLLBACK_AND_CHAIN :
972 }
973
974                     return emptyUpdateCount;
975                 }
976                 case ResultConstants.SQLSETCONNECTATTR : {
977                     switch (cmd.getConnectionAttrType()) {
978
979                         case ResultConstants.SQL_ATTR_SAVEPOINT_NAME :
980                             try {
981            &