|
1 package com.daffodilwoods.daffodildb.server.serversystem;
2
3 import java.sql.*;
4 import java.util.*;
5 import com.daffodilwoods.daffodildb.server.datadictionarysystem.*;
6 import com.daffodilwoods.daffodildb.server.datasystem.indexsystem.*;
7 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
8 import com.daffodilwoods.daffodildb.server.datasystem.mergesystem.*;
9 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.*;
10 import com.daffodilwoods.daffodildb.server.serversystem.chainedcolumn.*;
11 import com.daffodilwoods.daffodildb.server.serversystem.datatriggersystem.*;
12 import com.daffodilwoods.daffodildb.server.serversystem.deeprecordcopy.*;
13 import com.daffodilwoods.daffodildb.server.serversystem.dmlvalidation.statementtriggersystem.*;
14 import com.daffodilwoods.daffodildb.server.serversystem.triggerInfo.*;
15 import com.daffodilwoods.daffodildb.server.sessionsystem.*;
16 import com.daffodilwoods.daffodildb.server.sessionsystem.sessionversioninfo.*;
17 import com.daffodilwoods.daffodildb.server.sql99.*;
18 import com.daffodilwoods.daffodildb.server.sql99.common.*;
19 import com.daffodilwoods.daffodildb.server.sql99.dcl.sqlcontrolstatement.*;
20 import com.daffodilwoods.daffodildb.server.sql99.dcl.sqlsessionstatement.*;
21 import com.daffodilwoods.daffodildb.server.sql99.dcl.sqltransactionstatement.*;
22 import com.daffodilwoods.daffodildb.server.sql99.ddl.schemadefinition.*;
23 import com.daffodilwoods.daffodildb.server.sql99.ddl.schemamanipulation.*;
24 import com.daffodilwoods.daffodildb.server.sql99.dml.*;
25 import com.daffodilwoods.daffodildb.server.sql99.dml.declarecursor.*;
26 import com.daffodilwoods.daffodildb.server.sql99.dql.execution.*;
27 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.*;
28 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.condition.*;
29 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.order.*;
30 import com.daffodilwoods.daffodildb.server.sql99.dql.listenerevents.*;
31 import com.daffodilwoods.daffodildb.server.sql99.dql.plan.table.*;
32 import com.daffodilwoods.daffodildb.server.sql99.dql.queryexpression.*;
33 import com.daffodilwoods.daffodildb.server.sql99.dql.queryexpression.orderbyclause.*;
34 import com.daffodilwoods.daffodildb.server.sql99.expression.booleanvalueexpression.*;
35 import com.daffodilwoods.daffodildb.server.sql99.utils.*;
36 import com.daffodilwoods.daffodildb.utils.*;
37 import com.daffodilwoods.daffodildb.utils.byteconverter.*;
38 import com.daffodilwoods.daffodildb.utils.comparator.*;
39 import com.daffodilwoods.daffodildb.utils.parser.*;
40 import com.daffodilwoods.database.general.*;
41 import com.daffodilwoods.database.resource.*;
42
43 public class ServerSession implements _ServerSession {
44 protected _UserSession userSession;
45 public ServerSystem serverSystem;
46 protected String  databaseURL;
47 private WeakOrderedKeyList serverTableList = new WeakOrderedKeyList(new CTusjohDbtfJoTfotjujwfDpnqbsbups());
48 private String moduleSchema = SystemTables.DEFAULT_SCHEMA;
49 private String moduleCatalog = SystemTables.DEFAULT_CATALOG;
50 private String currentSchema = SystemTables.DEFAULT_SCHEMA;
51 private String currentCatalog = SystemTables.DEFAULT_CATALOG;
52 private HashMap viewMap = new HashMap();
53
54 private TreeMap cursorPool = new TreeMap(String.CASE_INSENSITIVE_ORDER);
55 private HashMap materializedViewTableMap = new HashMap();
56
57 _Iterator foreignKeyIterator;
58
59 boolean commit = true;
60 private boolean checkConstraint = false;
61 public boolean verbose = true;
62 public int queryTimeOut;
63 private int type = IteratorConstants.NONSCROLLABLE;
64 protected boolean connectionStatus = false;
65
66 private HashMap iteratorsList = new HashMap();
67 protected String verboseUser;
68 private _DataTriggerDatabase datatriggerDatabase;
69
70 protected ArrayList createIndexesList = new ArrayList(4);
71
72 private TriggerInformationStore triggerInfoStore;
73
74 private TriggerInformationStore statementLevelTriggerInfoStore;
75
76 public ServerSession() throws DException {
77 }
78
79 public ServerSession(String databaseURL, _UserSession userSession,
80 ServerSystem serverSystem) throws DException {
81 this.databaseURL = databaseURL;
82 this.userSession = userSession;
83 this.serverSystem = serverSystem;
84 triggerInfoStore = new TriggerInformationStore();
85 statementLevelTriggerInfoStore = new TriggerInformationStore();
86 }
87
88 protected void finalize() {
89 try {
90 if (connectionStatus == false) {
91 serverSystem.close(databaseURL, this);
92 }
93 } catch (DException ex) {
94
95 }
96 }
97
98 public void commit() throws DException {
99 if (connectionStatus)
100 throw new DatabaseException("DSE279", null);
101 if ( ( (String ) getUserSession().getTransactionAccessMode()).
102 equalsIgnoreCase("Read Only"))
103 throw new DException("DSE1184", (Object [])null);
104 if (commit) {
105 _StatementExecutionContext statementExecutionContext =
106 getStatementExecutionContext();
107 _TriggerExecutionContext triggerExecutionContext = new
108 TriggerExecutionContext();
109 statementExecutionContext.setTriggerExecutionContext(
110 triggerExecutionContext);
111
112 int length = createIndexesList.size();
113 if (length > 0) {
114 HashMap tablesRefreshed = new HashMap(5);
115 QualifiedIdentifier tableName;
116 for (int i = 0; i < length; i++) {
117 IndexInfo indexInfo = (IndexInfo) createIndexesList.get(i);
118 tableName = indexInfo.getTableName();
119 if (indexInfo.type == IndexInfo.CREATEINDEX) {
120 _IndexCharacteristics ic = serverSystem.getDataDictionary(databaseURL).
121 getIndexCharacteristics(tableName);
122 if (tablesRefreshed.get(tableName) == null) {
123 ic.refresh();
124 tablesRefreshed.put(tableName, "");
125 }
126 boolean isNonUnique = indexInfo.getIsNonUnique();
127 _IndexInformation iif = ic.getIndexInformations(indexInfo.
128 getIndexName(), isNonUnique);
129 if (isNonUnique)
130 ( (MergeDatabase) serverSystem.getMergeDatabase(databaseURL)).
131 getSessionVersionHandler().update(iif);
132 indexInfo.setIndexInformation(iif);
133 }
134 }
135 }
136
137 statementExecutionContext.setCreateIndexList(createIndexesList);
138 try {
139 userSession.commit(statementExecutionContext);
140 } finally {
141 createIndexesList.clear();
142 }
143 userSession.getSavePointVector().clear();
144 }
145 }
146
147 public void rollback() throws DException {
148 if (connectionStatus)
149 throw new DatabaseException("DSE279", null);
150 if (getUserSession().getTransactionAccessMode().equals("Read Only"))
151 throw new DException("DSE1184", (Object [])null);
152
153 if (commit) {
154 _StatementExecutionContext statementExecutionContext =
155 getStatementExecutionContext();
156 TriggerExecutionContext triggerExecutionContext = new
157 TriggerExecutionContext();
158 statementExecutionContext.setTriggerExecutionContext(
159 triggerExecutionContext);
160 try {
161 userSession.rollback(statementExecutionContext);
162 } finally {
163 createIndexesList.clear();
164 }
165 userSession.getSavePointVector().clear();
166 }
167 }
168
169 public synchronized _ServerTable getServerTable(QualifiedIdentifier tableName) throws
170 DException {
171
172 if (connectionStatus)
173 throw new DatabaseException("DSE279", null);
174 _ServerTable serverTable = (_ServerTable) serverTableList.get(tableName.
175 getIdentifier());
176 if (serverTable != null)
177 return serverTable;
178
179 _DataTriggerTable dataTriggerTable = getDataTriggerTable(
180 tableName);
181 _StatementTriggerTable statementTriggerTable = serverSystem.
182 getStatementTriggerTable(databaseURL, tableName);
183 serverTable = new ServerTable(tableName, this, dataTriggerTable,
184 statementTriggerTable);
185 serverTableList.put(tableName.getIdentifier(), serverTable);
186 return serverTable;
187
188 }
189
190 public _StatementExecutionContext getStatementExecutionContext() throws
191 DException {
192 StatementExecutionContext statementExecutionContext = new StatementExecutionContext();
193 statementExecutionContext.setServerSession(this);
194 statementExecutionContext.setServerSystem(serverSystem);
195 return statementExecutionContext;
196 }
197
198 public String getDatabaseURL() throws DException {
199 return this.databaseURL;
200 }
201
202 public _UserSession getUserSession() throws DException {
203 return userSession;
204 }
205
206 public _ColumnCharacteristics getColumnCharacteristics(QualifiedIdentifier
207 tableName) throws DException {
208 if (connectionStatus)
209 throw new DatabaseException("DSE279", null);
210 _DataDictionarySystem dataDictionarySystem = serverSystem.
211 getDataDictionarySystem();
212 return dataDictionarySystem.getDataDictionary(databaseURL).
213 getColumnCharacteristics(tableName, true);
214 }
215
216 public void setTimeOut(int timeOut) throws DException {
217 queryTimeOut = timeOut;
218 }
219
220 public void setModuleSchema(String moduleSchema) throws DException {
221 this.moduleSchema = moduleSchema;
222 }
223
224 public String getModuleSchema() throws DException {
225 return moduleSchema;
226 }
227
228 public void setModuleCatalog(String moduleCatalog) throws DException {
229 this.moduleCatalog = moduleCatalog;
230 }
231
232 public String getModuleCatalog() throws DException {
233 return moduleCatalog;
234 }
235
236 public String getCurrentRole() throws DException {
237 return userSession.getCurrentRole();
238 }
239
240 public String getCurrentUser() throws DException {
241 return userSession.getCurrentUser();
242 }
243
244 public java.sql.Date getDate() throws DException {
245 return userSession.getDate();
246 }
247
248 public Time getTime() throws DException {
249 return userSession.getTime();
250 }
251
252 public void deleteTable(QualifiedIdentifier tableName, boolean dropTable) throws
253 DException {
254
255 try {
256 serverSystem.deleteTable(databaseURL, tableName, dropTable);
257 } catch (DatabaseException e) {
258 throw e;
259 }
260 }
261
262 public void setCurrentSchema(String currentSchema) throws DException {
263 this.currentSchema = currentSchema;
264 }
265
266 public String getCurrentSchema() throws DException {
267 return currentSchema;
268 }
269
270 public void setCurrentCatalog(String currentCatalog) throws DException {
271 this.currentCatalog = currentCatalog;
272 }
273
274 public String getCurrentCatalog() throws DException {
275 return currentCatalog;
276 }
277
278 public boolean isEnabledAuthorizationIdentifier(String
279 authorizationIdentifier, boolean checkBrowserUser) throws
280 DException {
281 if (checkBrowserUser && getCurrentUser().equalsIgnoreCase(ServerSystem.browserUser))
282 return!authorizationIdentifier.equalsIgnoreCase(SystemTables.SYSTEM);
283 return userSession.isEnabledAuthorizationIdentifier(authorizationIdentifier);
284 }
285
286 public String getAuthorizationIdentifier() throws DException {
287 return userSession.getAuthorizationIdentifier();
288 }
289
290 public void setTransactionMode(SessionTransactionMode sessionTransactionMode) throws
291 DException {
292 userSession.setTransactionMode(sessionTransactionMode);
293 }
294
295 public SessionTransactionMode getTransactionMode() throws DException {
296 return userSession.getTransactionMode();
297 }
298
299 public void setUserSession(_UserSession userSession) throws DException {
300 this.userSession = userSession;
301 }
302
303 public void close() throws DException {
304 try {
305 userSession.rollback(getStatementExecutionContext());
306 } catch (DException e) {}
307 connectionStatus = true;
308 serverSystem.close(databaseURL, this);
309 }
310
311 public java.sql.Timestamp getTimeStamp() throws DException {
312 return userSession.getTimeStamp();
313 }
314
315 public String getDatabase() throws DException {
316 int index = databaseURL.lastIndexOf(".");
317 String databaseName = databaseURL.substring(index + 1);
318 return databaseName;
319 }
320
321 public Object getSessionConstant() throws DException {
322 return userSession.getSessionConstant();
323 }
324
325 public int getIsolationLevel() throws DException {
326 return userSession.getSession().getIsolationLevel();
327 }
328
329 public SessionConditionInfo getSessionCondition() throws DException {
330 throw new UnsupportedOperationException (" getSessionCondition not supported ");
331 }
332
333 public Object getSessionId() throws DException {
334 return userSession.getSession().getSessionId();
335 }
336
337 public _ServerSession getGlobalSession() throws DException {
338 return userSession.getGlobalSession();
339 }
340
341 public String [] getSuitableIndex(String tableName, String [] columns) throws
342 DException {
343 throw new UnsupportedOperationException ();
344 }
345
346 public boolean prepare() throws DException {
347 if (connectionStatus)
348 throw new DException("DSE279", null);
349 _StatementExecutionContext statementExecutionContext =
350 getStatementExecutionContext();
351 TriggerExecutionContext triggerExecutionContext = new
352 TriggerExecutionContext();
353 statementExecutionContext.setTriggerExecutionContext(
354 triggerExecutionContext);
355 return userSession.prepare(statementExecutionContext);
356 }
357
358 public boolean makePersistent() throws DException {
359 if (connectionStatus)
360 throw new DException("DSE279", null);
361 _StatementExecutionContext statementExecutionContext =
362 getStatementExecutionContext();
363 TriggerExecutionContext triggerExecutionContext = new
364 TriggerExecutionContext();
365 statementExecutionContext.setTriggerExecutionContext(
366 triggerExecutionContext);
367 statementExecutionContext.setCreateIndexList(createIndexesList);
368 return userSession.makePersistent(statementExecutionContext);
369 }
370
371 public TimeZone getTimeZone() throws DException {
372 return userSession.getTimeZone();
373 }
374
375 public _ServerSession getSystemServerSession() throws DException {
376 java.util.Properties systemProperties = new java.util.Properties ();
377 return serverSystem.getServerSession(SystemTables.SYSTEM,
378 SystemTables.SYSTEM, systemProperties,
379 databaseURL);
380 }
381
382 public _Connection getSystemConnection() throws DException {
383 java.util.Properties systemProperties = new java.util.Properties ();
384 systemProperties.setProperty(_Server.USER, SystemTables.SYSTEM);
385 systemProperties.setProperty(_Server.XID, SystemTables.SYSTEM);
386 return serverSystem.get_Connection(databaseURL, systemProperties);
387 }
388
389 public _DataDictionary getDataDictionary() throws DException {
390 return serverSystem.getDataDictionarySystem().getDataDictionary(databaseURL);
391 }
392
393 public void setAutoCommit(boolean autoCommit0) throws DException {
394
395 if (userSession.getAutoCommit() != autoCommit0) {
396 if (userSession.getAutoCommit() == false)
397 commit();
398 userSession.setAutoCommit(autoCommit0);
399 }
400
401 }
402
403 public void createDatabase(String databaseName, Properties prop) throws
404 DException {
405 serverSystem.createDatabase(databaseName, prop);
406 }
407
408 public void createTable(QualifiedIdentifier tableName) throws DException {
409 _ColumnCharacteristics cc = getColumnCharacteristics(tableName);
410 String country = ( (ColumnCharacteristics) cc).getCountry();
411 String [] columns = cc.getColumnNames();
412 Object [][] columnsDetail = new Object [columns.length][4];
413 for (int i = 0; i < columns.length; i++) {
414 columnsDetail[i][0] = columns[i];
415 int index = cc.getColumnIndex(columns[i]);
416 int type = cc.getColumnType(index);
417 int size = cc.getSize(index);
418 size = country != null &&
419 ColumnCharacteristicsUtilities.isStringType(type) ? (size + 1) * 2 :
420 size;
421 columnsDetail[i][1] = new Long (type);
422 columnsDetail[i][2] = new Integer (size);
423 columnsDetail[i][3] = new Long (index);
424 }
425 ColumnInformation columnInfo = new ColumnInformation();
426 if (country != null) {
427 columnInfo.setCountry(country);
428 columnInfo.setLanguage( ( (ColumnCharacteristics) cc).getLanguage());
429 }
430 columnInfo.setObjects(columnsDetail);
431 _Database mergeDatabase = serverSystem.getMergeDatabase(databaseURL);
432 mergeDatabase.createTable(tableName, columnInfo);
433 }
434
435 public _Iterator getIterator(QualifiedIdentifier tableName,
436 _SingleTableExecuter singleTableExecuter) throws
437 DException {
438 if (connectionStatus)
439 throw new DatabaseException("DSE279", null);
440 if (singleTableExecuter.getInternalIteratorRequired())
441 return userSession.getUserSessionTable(tableName).getInternalIterator(singleTableExecuter, this);
442 else
443 return userSession.getUserSessionTable(tableName).getIterator(singleTableExecuter, this);
444
445 }
446
447 public Object execute(String query, int queryTimeOut) throws DException {
448 return execute(query, queryTimeOut, getType());
449 }
450
451 public Object execute(String query, int queryTimeOut, int type) throws
452 DException {
453 if (verbose)
454 PrintHandler.print(query, null, verboseUser);
455 if (connectionStatus)
456 throw new DException("DSE279", null);
457 try {
458 Object parsedQuery = Parser.parseQuery(query);
459 return execute(parsedQuery, queryTimeOut, type);
460
461 } catch (DException de) {
462 throw de;
463 } catch (RuntimeException de) {
464 throw de;
465 }
466 }
467
468 public Object execute(Object parsedQuery, int queryTimeOut, int type) throws
469 DException {
470 if (parsedQuery instanceof queryexpression) {
471 {
472 userSession.startTransaction();
473 }
474
475 int tp = getType();
476 queryexpression qurexp = (queryexpression) parsedQuery;
477 ServerSessionWrapper sersewr = new ServerSessionWrapper(this);
478 if (qurexp.isSimpleQuery(sersewr)) {
479 if (type == IteratorConstants.UPDATABLE) {
480 tp = IteratorConstants.UPDATABLE;
481 }
482 } else {
483 tp = IteratorConstants.NONSCROLLABLE;
484 }
485 sersewr.setType(tp);
486 _Executer executer = (_Executer) (qurexp).run(sersewr);
487 Object obj = executer.execute( (Object [])null);
488 return obj;
489 }
490
491 if (parsedQuery instanceof SQLschemastatement) {
492 commit();
493 _ServerSession ss = getSystemServerSession();
494 if ( ( (String ) getUserSession().getTransactionAccessMode()).
495 equalsIgnoreCase("Read Only"))
496 throw new DException("DSE1184", (Object [])null);
497 Object returnedObject = null;
498 _DataDictionary dd = getDataDictionary();
499 dd.lockDDL();
500 try {
501 try {
502 returnedObject = ( (SQLschemastatement) parsedQuery).run(this);
503 } catch (DException ex) {
504 dd.restoreGeneratedKeys();
505 createIndexesList.clear();
506 ss.rollback();
507 throw ex;
508 }
509 if (! (parsedQuery instanceof dropdatabasestatement)) {
510 ( (ServerSession) ss).createIndexesList = createIndexesList;
511 ss.commit();
512 createIndexesList.clear();
513 }
514 } finally {
515 dd.releaseDDL();
516 ss.close();
517 }
518 if (returnedObject == null)
519 return new Integer (Integer.MIN_VALUE);
520 return returnedObject;
521 }
522 if (parsedQuery instanceof SQLtransactionstatement) {
523 Object returnedObject = ( (SQLtransactionstatement) parsedQuery).run(this);
524 return new Integer (Integer.MIN_VALUE);
525
526 }
527 if (parsedQuery instanceof SQLsessionstatement) {
528 _StatementExecutionContext sec = getStatementExecutionContext();
529 Object returnedObject = ( (SQLsessionstatement) parsedQuery).run(sec);
530 return new Integer (Integer.MIN_VALUE);
531 }
532
533 if (parsedQuery instanceof SQLdatastatement) {
534 if ( ( (String ) getUserSession().getTransactionAccessMode()).
535 equalsIgnoreCase("Read Only"))
536 throw new DException("DSE1184", (Object [])null);
537 _StatementExecutionContext sec = getStatementExecutionContext();
538 _Executer executer = (_Executer) ( (SQLdatastatement) parsedQuery).run(
539 sec);
540 Object returnedObject = executer.execute( (_VariableValues)null);
541 if (returnedObject == null)
542 return new Integer (Integer.MIN_VALUE);
543 return returnedObject;
544 }
545 if (parsedQuery instanceof SQLcontrolstatement) {
546 _StatementExecutionContext sec = getStatementExecutionContext();
547 _Executer executer = (_Executer) ( (SQLcontrolstatement) parsedQuery).run(
548 sec);
549 Object returnedObject = executer.execute( (_VariableValues)null);
550 ( (CallResult) returnedObject).print();
551 if (returnedObject == null)
552 return new Integer (Integer.MIN_VALUE);
553 return returnedObject;
554 }
555
556 throw new DException("DSE531", null);
557 }
558
559 public Object execute(String query, int queryTimeOut, int type, int queryType,
560 int autoGeneratedType, Object autoGenetatedValues) throws
561 DException {
562 try {
563 Object parsedQuery = Parser.parseQuery(query);
564 if (parsedQuery instanceof SQLdatastatement) {
565 if ( ( (String ) getUserSession().getTransactionAccessMode()).
566 equalsIgnoreCase("Read Only"))
567 throw new DException("DSE1184", (Object [])null);
568 _StatementExecutionContext sec = getStatementExecutionContext();
569 sec.setAutoGeneratedInfo(autoGeneratedType, autoGenetatedValues);
570 _Executer executer = (_Executer) ( (SQLdatastatement) parsedQuery).run(
571 sec);
572 return executer.execute( (_VariableValues)null);
573 } else {
574 if (queryType == _Connection.EXECUTE)
575 return execute(parsedQuery, queryTimeOut, type);
576 else
577 return executeUpdate(parsedQuery, queryTimeOut);
578 }
579 } catch (DException de) {
580 throw de;
581 } catch (RuntimeException de) {
582 throw de;
583 }
584 }
585
586 public Object executeParameterised(String query, int queryTimeOut) throws
587 DException {
588 try {
589 Object parsedQuery = Parser.parseQuery(query);
590 if (parsedQuery instanceof queryexpression)
591 {
592 {
593 userSession.startTransaction();
594 }
595
596 queryexpression qurexp = (queryexpression) parsedQuery;
597 ServerSessionWrapper serwr = new ServerSessionWrapper(this);
598 serwr.setType(IteratorConstants.NONSCROLLABLE);
599 if (qurexp.isSimpleQuery(serwr))
600 return qurexp.run(serwr);
601 return qurexp.run(serwr);
602 }
603
604 if (parsedQuery instanceof SQLschemastatement) {
605 commit();
606 _ServerSession ss = getSystemServerSession();
607 _DataDictionary dd = getDataDictionary();
608 if ( ( (String ) getUserSession().getTransactionAccessMode()).
609 equalsIgnoreCase("Read Only"))
610 throw new DException("DSE1184", (Object [])null);
611 Object retunObject = null;
612 dd.lockDDL();
613 try {
614 try {
615 retunObject = ( (SQLschemastatement) parsedQuery).run(this);
616 } catch (DException ex) {
617 dd.restoreGeneratedKeys();
618 createIndexesList.clear();
619 ss.rollback();
620 throw ex;
621 }
622 if (! (parsedQuery instanceof dropdatabasestatement)) {
623 ( (ServerSession) ss).createIndexesList = createIndexesList;
624 ss.commit();
625 createIndexesList.clear();
626 }
627 } finally {
628 dd.releaseDDL();
629 }
630 return retunObject;
631 }
632 if (parsedQuery instanceof SQLtransactionstatement) {
633 ( (SQLtransactionstatement) parsedQuery).run(this);
634 return new Integer (Integer.MIN_VALUE);
635
636 }
637 if (parsedQuery instanceof SQLsessionstatement) {
638 _StatementExecutionContext sec = getStatementExecutionContext();
639 ( (SQLsessionstatement) parsedQuery).run(sec);
640 return new Integer (Integer.MIN_VALUE);
641
642 }
643
644 if (parsedQuery instanceof SQLdatastatement) {
645 if ( ( (String ) getUserSession().getTransactionAccessMode()).
646 equalsIgnoreCase("Read Only"))
647 throw new DException("DSE1184", (Object [])null);
648
649 _StatementExecutionContext sec = getStatementExecutionContext();
650 return ( (SQLdatastatement) parsedQuery).run(sec);
651 }
652 if (parsedQuery instanceof SQLcontrolstatement) {
653
654 _StatementExecutionContext sec = getStatementExecutionContext();
655 return ( (SQLcontrolstatement) parsedQuery).run(sec);
656 }
657
658
659 if (parsedQuery instanceof SQLprocedurestatement) {
660 if ( ( (String ) getUserSession().getTransactionAccessMode()).
661 equalsIgnoreCase("Read Only"))
662 throw new DException("DSE1184", (Object [])null);
663 return (_Executer) ( (SQLprocedurestatement) parsedQuery).run(this);
664 }
665 } catch (DException de) {
666 throw de;
667 } catch (RuntimeException de) {
668 throw de;
669 }
670 throw new DException("DSE86", null);
671 }
672
673 public Object executeUpdate(String query, int queryTimeOut) throws DException {
674 if (verbose)
675 PrintHandler.print(query, null, verboseUser);
676 try {
677 if (connectionStatus)
678 throw new DException("DSE279", null);
679 Object parsedObject = Parser.parseQuery(query);
680 return executeUpdate(parsedObject, queryTimeOut);
681
682 } catch (DException de) {
683 throw de;
684 } catch (RuntimeException de) {
685 throw de;
686 }
687 }
688
689 public Object executeUpdate(Object parsedObject, int queryTimeOut) throws
690 DException {
691 if (parsedObject instanceof SQLdatastatement) {
692 if ( ( (String ) getUserSession().getTransactionAccessMode()).
693 equalsIgnoreCase("Read Only"))
694 throw new DException("DSE1184", (Object [])null);
695 _StatementExecutionContext sec = getStatementExecutionContext();
696 _Executer executer = (_Executer) ( (SQLdatastatement) parsedObject).run(
697 sec);
698 Object returnedObject = executer.execute( (_VariableValues)null);
699 if (returnedObject == null)
700 return new Integer (Integer.MIN_VALUE);
701 return returnedObject;
702 } else if (parsedObject instanceof SQLschemastatement) {
703 commit();
704 _ServerSession ss = getSystemServerSession();
705 if ( ( (String ) getUserSession().getTransactionAccessMode()).
706 equalsIgnoreCase("Read Only"))
707 throw new DException("DSE1184", (Object [])null);
708 Object returnedObject = null;
709 _DataDictionary dd = getDataDictionary();
710 dd.lockDDL();
711 try {
712 try {
713 returnedObject = ( (SQLschemastatement) parsedObject).run(this);
714 } catch (DException ex) {
715 dd.restoreGeneratedKeys();
716 createIndexesList.clear();
717 ss.rollback();
718 throw ex;
719 }
720 if (! (parsedObject instanceof dropdatabasestatement)) {
721 ( (ServerSession) ss).createIndexesList = createIndexesList;
722
723 ss.commit();
724 createIndexesList.clear();
725 }
726 } finally {
727 dd.releaseDDL();
728 }
729 if (returnedObject == null)
730 return new Integer (Integer.MIN_VALUE);
731 return returnedObject;
732 }
733 throw new DException("DSE533", null);
734 }
735
736 public Object executeUpdateParameterised(String query, int queryTimeOut) throws
737 DException {
738 try {
739 if (connectionStatus)
740 throw new DException("DSE279", null);
741 Object parsedObject = Parser.parseQuery(query);
742 if (parsedObject instanceof SQLdatastatement) {
743 if ( ( (String ) getUserSession().getTransactionAccessMode()).
744 equalsIgnoreCase("Read Only"))
745 throw new DException("DSE1184", (Object [])null);
746 _StatementExecutionContext sec = getStatementExecutionContext();
747 return ( (StatementExecuter) parsedObject).run(sec);
748 } else if (parsedObject instanceof SQLschemastatement) {
749 commit();
750 _ServerSession ss = getSystemServerSession();
751 if ( ( (String ) getUserSession().getTransactionAccessMode()).
752 equalsIgnoreCase("Read Only"))
753 throw new DException("DSE1184", (Object [])null);
754 _DataDictionary dd = getDataDictionary();
755 dd.lockDDL();
756 try {
757 try {
758 ( (SQLschemastatement) parsedObject).run(this);
759 } catch (DException ex) {
760 dd.restoreGeneratedKeys();
761 createIndexesList.clear();
762 ss.rollback();
763 throw ex;
764 }
765 if (! (parsedObject instanceof dropdatabasestatement)) {
766 ( (ServerSession) ss).createIndexesList = createIndexesList;
767 ss.commit();
768 createIndexesList.clear();
769 }
770 } finally {
771 dd.releaseDDL();
772 }
773 return new Integer (Integer.MIN_VALUE);
774 }
775 } catch (DException de) {
776 throw de;
777 } catch (RuntimeException de) {
778 throw de;
779 }
780 throw new DException("DSE533", null);
781 }
782
783 public Object executeQuery(String query, int queryTimeOut) throws DException {
784 return executeQuery(query, queryTimeOut, getType());
785 }
786
787 public Object executeQuery(String query, int queryTimeOut, int type) throws
788 DException {
789 if (verbose)
790 PrintHandler.print(query, null, verboseUser);
791 try {
792 if (connectionStatus)
793 throw new DException("DSE279", null);
794 Object parsedQuery = Parser.parseQuery(query);
795 if (parsedQuery instanceof queryexpression ) {
796 {
797 userSession.startTransaction();
798 }
799
800 queryexpression qurexp = (queryexpression) parsedQuery;
801 int tp = IteratorConstants.NONSCROLLABLE;
802 ServerSessionWrapper sersewr = new ServerSessionWrapper(this);
803 if (type == IteratorConstants.UPDATABLE)
804 tp = qurexp.isSimpleQuery(sersewr) ? IteratorConstants.UPDATABLE : IteratorConstants.NONSCROLLABLE;
805 sersewr.setType(tp);
806 _Executer executer = (_Executer) qurexp.run(sersewr);
807 return executer.execute( (Object [])null);
808 }
809 } catch (DException de) {
810 throw de;
811 } catch (RuntimeException de) {
812 throw de;
813 }
814 throw new DException("DSE86", null);
815 }
816
817 public Object executeQueryParameterised(String query, int queryTimeOut) throws
818 DException {
819 try {
820 if (connectionStatus)
821 throw new DException("DSE279", null);
822 if ( ( (String ) getUserSession().getTransactionAccessMode()).
823 equalsIgnoreCase("Read Only"))
824 throw new DException("DSE1184", (Object [])null);
825 Object parsedQuery = Parser.parseQuery(query);
826 if (parsedQuery instanceof queryexpression ) {
827 {
828 userSession.startTransaction();
829 }
830
831 queryexpression qurexp = (queryexpression) parsedQuery;
832 ServerSessionWrapper serwr = new ServerSessionWrapper(this);
833 serwr.setType(IteratorConstants.NONSCROLLABLE);
834 if (qurexp.isSimpleQuery(serwr))
835 return qurexp.run(serwr);
836 return qurexp.run(serwr);
837 }
838 } catch (DException de) {
839 throw de;
840 } catch (RuntimeException de) {
841 throw de;
842 }
843 throw new DException("DSE86", null);
844
845 }
846
847 public _Iterator getIndexedIterator(_Iterator selectIterator,
848 _ExpressionOrderValues order, CbCUsffWbmvfIboemfs btreeValueHandler) throws
849 DException {
850 if (serverSystem.getReadOnlyMode()) {
851 return new ReadOnlyTempIndexIterator(selectIterator, order, ( (MergeDatabase) serverSystem.getMergeDatabase(databaseURL)).getVersionHandler());
852
853 }
854 TempIndexDatabase tempIndexDatabase = (TempIndexDatabase) ( (MergeDatabase) serverSystem.getMergeDatabase(databaseURL)).getMemoryDatabase();
855 return new TemporaryIndexIterator(selectIterator, order, btreeValueHandler, tempIndexDatabase);
856 }
857
858 public _IndexTable getIndexTable(QualifiedIdentifier tableName) throws
859 DException {
860 return (_IndexTable) serverSystem.getMergeDatabase(databaseURL).getTable(
861 tableName);
862 }
863
864 public int getType() {
865 return type;
866 }
867
868 public void setType(int type0) {
869 type = type0;
870 }
871
872 public void createIndex(QualifiedIdentifier tableName, String indexName,
873 boolean isNonUnique) throws DException {
874 IndexInfo indexInfo = new IndexInfo(IndexInfo.CREATEINDEX, tableName, indexName, null);
875 indexInfo.setIsNonUnique(isNonUnique);
876 createIndexesList.add(indexInfo);
877
878 }
879
880 public void createFullTextIndex(QualifiedIdentifier tableName,
881 String indexName, String [] columnName) throws
882 DException {
883 MergeDatabase md = ( (MergeDatabase) userSession.getSession().
884 getSessionDatabase().getMergeDatabase());
885 if (!md.getVersionHandler().isFullTextSupported())
886 throw new DException("DSE5590", new Object [] {"createFullTextIndex"});
887 md.createFullTextIndex(tableName, indexName, columnName);
888 }
889
890 public void dropFullTextIndex(QualifiedIdentifier tableName, String indexName) throws DException {
891 ( (_IndexDatabase) userSession.getSession().getSessionDatabase().
892 getMergeDatabase()).dropFullTextIndex(tableName, indexName);
893 }
894
895 public void createIndexForSystemTable(QualifiedIdentifier tableName,
896 String indexName) throws DException {
897 createIndex(tableName, indexName, true);
898 }
899
900 public void dropTable(QualifiedIdentifier tableName) throws DException {
901 serverSystem.getMergeDatabase(databaseURL).dropTable(tableName);
902 }
903
904
905 public void dropIndex(QualifiedIdentifier tableName, String indexName) throws
906 DException {
907 IndexInfo indexInfo = new IndexInfo(IndexInfo.DROPINDEX, tableName, indexName, null);
908 createIndexesList.add(indexInfo);
909
910 ( (_IndexDatabase) userSession.getSession().getSessionDatabase().
911 getMergeDatabase()).dropTemporaryIndex(tableName, indexName);
912 }
913
914 public boolean getAutoCommit() {
915 return userSession.getAutoCommit();
916 }
917
918 public String [] getUniqueInformation(QualifiedIdentifier tableName) throws
919 DException {
920 _PrimaryAndUniqueConstraintCharacteristics pucc = getDataDictionary().
921 getDDSConstraintsOperation().
922 getPrimaryAndUniqueConstraintCharacteristics(tableName, false);
923 _UniqueConstraint uc = pucc.getPrimaryConstraints();
924 return uc == null ? null : uc.getColumnNames();
925 }
926
927 public HashMap getViewMap() throws DException {
928 return viewMap;
929 }
930
931 public _Iterator getForeignKeyIterator(QualifiedIdentifier tableName,
932 _SingleTableExecuter conditionExecuter,
933 _TableAlias[] tableAlias) throws
934 DException {
935 if (connectionStatus)
936 throw new DatabaseException("DSE279", null);
937 HashMap tablesMapping = new HashMap();
938 HashMap columnsMapping = new HashMap();
939 ArrayList tableDetailsList = new ArrayList();
940 _DataDictionary dic = getDataDictionary();
941 ChainedColumnInfo cci = new ChainedColumnInfo(tableName, "");
942 ChainedTableInfo cti = new ChainedTableInfo(cci, tableName);
943 tablesMapping.put(cci, cti);
944 TableDetails tableD0 = new TableDetails();
945 tableD0.setTableName(new String [] {tableName.catalog, tableName.schema,
946 tableName.name});
947 tableD0.cc = dic.getColumnCharacteristics(tableD0.getQualifiedIdentifier(), true);
948 tableDetailsList.add(tableD0);
949 for (int i = 0; i < tableAlias.length; i++) {
950 String [] columns = tableAlias[i].getColumnName();
951 ChainedTableInfo parent = cti;
952 for (int j = 0; j < columns.length; j++) {
953 QualifiedIdentifier tempName = parent.getTableName();
954 ChainedColumnInfo childColumnInfo = new ChainedColumnInfo(tempName,
955 columns[j]);
956 ChainedTableInfo childTableInfo = (ChainedTableInfo) tablesMapping.get(
957 childColumnInfo);
958 if (childTableInfo != null) {
959 parent = childTableInfo;
960 continue;
961 }
962
963 _ColumnCharacteristics cc = dic.getColumnCharacteristics(tempName, true);
964 _ReferencingConstraintCharacteristics rcc = dic.
965 getDDSConstraintsOperation().
966 getReferencingConstraintCharacteristics(tempName, false);
967 _ReferentialConstraint rc = rcc.getReferencingConstraints(
968 new int[] {cc.getColumnIndex(columns[j])})[0];
969
970 QualifiedIdentifier childtemp = rc.getReferencedTable();
971
972 TableDetails tableD = new TableDetails();
973 tableD.setTableName(new String [] {childtemp.catalog, childtemp.schema,
974 childtemp.name});
975
976 childTableInfo = new ChainedTableInfo(childColumnInfo, childtemp);
977
978 int[] referencedIndexes = rc.getReferencedColumns();
979 int columnIndex = cc.getColumnIndex(columns[j]);
980 booleanvalueexpression referencingCondition =
981 rc.getReferencingCondition(rc.getReferencingColumns());
982
983 booleanvalueexpression referencedCondition =
984 rc.getReferencedCondition(referencedIndexes);
985 _Reference[] referecingCoditionRefs = GeneralPurposeStaticClass.
986 changeReferences(referencingCondition.getParameters(null));
987 _Reference[] referencedConditionRefs = GeneralPurposeStaticClass.
988 changeReferences(referencedCondition.getParameters(null));
989
990 TableDetails parentDetails = new TableDetails();
991 parentDetails.setTableName(new String [] {tempName.catalog,
992 tempName.schema, tempName.name});
993
994 IteratorInfo ii1 = new IteratorInfo(childtemp,
995 referencedCondition, tableD,
996 tempName,
997 columnIndex,
998 referencedConditionRefs);
999
1000 IteratorInfo ii2 = new IteratorInfo(tempName,
1001 referencingCondition, parentDetails,
1002 childtemp,
1003 referencedIndexes[0],
1004 referecingCoditionRefs);
1005
1006 childTableInfo.setReferencingToReferencedTableIteratorInfo(ii1); childTableInfo.setReferencedToReferencingTableIteratorInfo(ii2); childTableInfo.setParentTableInfo(parent);
1009 parent.addChildTableInfo(childTableInfo);
1010 tablesMapping.put(childColumnInfo, childTableInfo);
1011 tableD.cc = dic.getColumnCharacteristics(tableD.getQualifiedIdentifier(), true);
1012 tableDetailsList.add(tableD);
1013 parent = childTableInfo;
1014 if (j == columns.length - 1) {
1015 columnsMapping.put(columns, childColumnInfo);
1016 }
1017 }
1018 }
1019 ForeignConstraintTable fct = new ForeignConstraintTable(this, tablesMapping,
1020 cti, columnsMapping, tableDetailsList);
1021 _Iterator sessionIterator = userSession.getUserSessionTable(tableName).
1022 getForeignConstraintIterator(conditionExecuter, fct);
1023 foreignKeyIterator = ( (SessionIterator) sessionIterator).
1024 getForeignKeyIterator();
1025 return sessionIterator;
1026 }
1027
1028 public ForeignKeyIterator getForeignKeyIterator() throws DException {
1029 if (foreignKeyIterator instanceof ForeignKeyIterator)
1030 return (ForeignKeyIterator) foreignKeyIterator;
1031 if (foreignKeyIterator instanceof NonIndexedFilterIterator)
1032 return (ForeignKeyIterator) ( (NonIndexedFilterIterator)
1033 foreignKeyIterator).getForeignKeyIterator();
1034 if (foreignKeyIterator instanceof IndexedFilterIterator)
1035 return (ForeignKeyIterator) ( (IndexedFilterIterator) foreignKeyIterator).
1036 getForeignKeyIterator();
1037 throw new DException("DSE5537", new Object [] {foreignKeyIterator.getClass().getName()});
1038 }
1039
1040 public Object [] getForeignConstraintCharacteritics(QualifiedIdentifier
1041 tableName, String columnName) throws DException {
1042 try {
1043 _ColumnCharacteristics cc = getColumnCharacteristics(tableName);
1044 if (cc.getTableType() == TypeConstants.VIEW) {
1045 return getViewObject(tableName, true).getForeignConstraintCharacteritics(
1046 columnName, this, cc);
1047 }
1048 _ReferencingConstraintCharacteristics rcc = getDataDictionary().
1049 getDDSConstraintsOperation().getReferencingConstraintCharacteristics(
1050 tableName, false);
1051 _ReferentialConstraint rc = rcc.getReferencingConstraints(new int[] {cc.
1052 getColumnIndex(columnName)})[0];
1053 QualifiedIdentifier referencedTable = rc.getReferencedTable();
1054 String [] referencedColumns = rc.getReferencedColumnNames();
1055 return new Object [] {
1056 referencedTable, getColumnCharacteristics(referencedTable),
1057 referencedColumns};
1058 } catch (NullPointerException nex) {
1059 throw new DException("DSE5538", new Object [] {columnName});
1060 }
1061 }
1062
1063 public synchronized _ViewObject getViewObject(QualifiedIdentifier viewName, boolean checkUserRight) throws DException {
1064 _DataDictionary dataDictionary = getDataDictionary();
1065 if (checkUserRight) {
1066 _PrivilegeTable pt = userSession.getPrivilegeCharacteristics().getPrivilegeTable(viewName);
1067 boolean hasRight = pt.hasTablePrivileges(_PrivilegeTable.SELECT);
1068 if (!hasRight)
1069 throw new DException("DSE8132", null);
1070 }
1071 return dataDictionary.getViewObject(viewName, this);
1072 }
1073
1074 public boolean cursorAlreadyCreated(String name) {
1075 return cursorPool.containsKey(name);
1076 }
1077
1078 public void removeCursor(String name) {
1079 cursorPool.remove(name);
1080 }
1081
1082 public void addCursor(String cname, _Cursor cur) {
1083 cursorPool.put(cname, cur);
1084 }
1085
1086 public _Cursor getCursor(String name) {
1087 return (_Cursor) cursorPool.get(name);
1088 }
1089
1090 public int getEstimatedRowCount(QualifiedIdentifier parm1) throws com.
1091 daffodilwoods.database.resource.DException {
1092 return ( (_IndexTable) serverSystem.getMergeDatabase(databaseURL).getTable(
1093 parm1)).getEstimatedRowCount();
1094 }
1095
1096 public void alterTable(QualifiedIdentifier tableName,
1097 _ColumnCharacteristics cc, Object defaultValue) throws
1098 DException {
1099 ColumnInformation columnInfo = getColumnInfo(cc);
1100 _AlterRecord alterRecord = new AlterRecord(columnInfo);
1101 IndexInfo indexInfo = new IndexInfo(IndexInfo.ALTERTABLE, tableName, columnInfo, alterRecord, defaultValue);
1102 createIndexesList.add(indexInfo);
1103 }
1104
1105 public ColumnInformation getColumnInfo(_ColumnCharacteristics cc) throws
1106 DException {
1107 String [] columns = cc.getColumnNames();
1108 Object [][] columnsDetail = new Object [columns.length][4];
1109 for (int i = 0; i < columns.length; i++) {
1110 columnsDetail[i][0] = columns[i];
1111 int index = cc.getColumnIndex(columns[i]);
1112 int type = cc.getColumnType(index);
1113 int size = cc.getSize(index);
1114 columnsDetail[i][1] = new Long (type);
1115 columnsDetail[i][2] = new Integer (size);
1116 columnsDetail[i][3] = new Long (index);
1117 }
1118 ColumnInformation columnInfo = new ColumnInformation();
1119 columnInfo.setObjects(columnsDetail);
1120 return columnInfo;
1121 }
1122
1123 public Object [] createDeepRecordCopy(QualifiedIdentifier tableName,
1124 Object [] keys, String [] tableNames) throws
1125 DException {
1126 HierarchyCreator hr = new HierarchyCreator(tableName,
1127 serverSystem.
1128 getDataDictionary(databaseURL),
1129 tableNames, true);
1130 hr.createHierarchy();
1131 TableCopy tableCopy = hr.getRootNode();
1132 CopyHierarchy ch = new CopyHierarchy(this);
1133 Object [] val = ch.copy(keys, tableCopy);
1134 return val;
1135 }
1136
1137 public Object [] createDeepRecordCopy(QualifiedIdentifier tableName,
1138 Object [] keys) throws DException {
1139 HierarchyCreator hr = new HierarchyCreator(tableName,
1140 serverSystem.
1141 getDataDictionary(databaseURL), null, false);
1142 hr.createHierarchy();
1143 TableCopy tableCopy = hr.getRootNode();
1144 CopyHierarchy ch = new CopyHierarchy(this);
1145 Object [] val = ch.copy(keys, tableCopy);
1146 return val;
1147 }
1148
1149 public boolean hasRecordInMemory(QualifiedIdentifier tableName) throws
1150 DException {
1151 _Database mergeDatabase = serverSystem.getMergeDatabase(databaseURL);
1152 _Iterator memoryIterator = ( (MergeTable) mergeDatabase.getTable(tableName)).
1153 getMemoryTable().getIterator(0);
1154 return memoryIterator.first();
1155 }
1156
1157 public void startSavePoint() throws DException {
1158 userSession.startSavePoint();
1159 }
1160
1161 public void commitSavePoint() throws DException {
1162 userSession.commitSavePoint(getStatementExecutionContext());
1163 }
1164
1165 public void rollbackSavePoint() throws DException {
1166 userSession.rollbackSavePoint(getStatementExecutionContext());
1167 }
1168
1169 public void releaseSavePoint() throws DException {
1170 userSession.releaseSavePoint(getStatementExecutionContext());
1171 }
1172
1173 public void setTransactionIsolation(int level) throws DException {
1174 if (iteratorsList.size() > 0)
1175 throw new DException("DSE5503", null);
1176 userSession.getSession().setIsolationLevel(level);
1177 }
1178
1179 public _SequenceManager getSequenceManager() throws DException {
1180 return serverSystem.getSequenceManager(databaseURL);
1181 }
1182
1183 public void dropDatabase(String databaseName, String userName,
1184 String password) throws DException {
1185 serverSystem.dropDatabase(databaseName, userName, password, getDatabase());
1186 }
1187
1188 public boolean isConstraintCheckingDeffered() {
1189 return checkConstraint;
1190 }
1191
1192 public void removeTable(QualifiedIdentifier tableName) throws DException {
1193 serverTableList.remove(tableName.getIdentifier());
1194 materializedViewTableMap.remove(tableName);
1195 viewMap.remove(tableName);
1196 ( (UserSession) userSession).removeTable(tableName);
1197 }
1198
1199 public boolean isDataModified() throws DException {
1200 return userSession.getSession().isDataModified();
1201 }
1202
1203 public void hideSavePoint() throws DException {
1204 userSession.hideSavePoint();
1205 }
1206
1207 public void unhideSavePoint() throws DException {
1208 userSession.unhideSavePoint();
1209 }
1210
1211 public void ignoreParallelSavePoint() throws DException {
1212 userSession.ignoreParallelSavePoint();
1213 }
1214
1215 public void allowParallelSavePoint() throws DException {
1216 userSession.allowParallelSavePoint();
1217 }
1218
1219 public void checkImmediateConstraintsOnCommit() throws DException {
1220 userSession.checkImmediateConstraintsOnCommit();
1221 }
1222
1223
1224
1225 public void setSavePoint(String savepoint) throws DException {
1226 ArrayList savePointVector = userSession.getSavePointVector();
1227 if (!savePointVector.contains(savepoint)) {
1228 userSession.addSavePoint(savepoint);
1229 userSession.startSavePoint();
1230 } else
1231 throw new DException("DSE889", new Object [] {savepoint});
1232 }
1233
1234 public String setSavePoint() throws DException {
1235 String savepoint = "sp" + userSession.getSavePointVector().size();
1236 setSavePoint(savepoint);
1237 return savepoint;
1238 }
1239
1240 public void releaseSavePoint(String savepoint) throws DException {
1241 ArrayList savePointVector = userSession.getSavePointVector();
1242 int index = savePointVector.indexOf(savepoint);
1243 if (index == -1)
1244 throw new DException("DSE890", null);
1245 userSession = commitUptoLevel(userSession, getStatementExecutionContext(),
1246 savePointVector.size() - index);
1247 }
1248
1249 protected _UserSession commitUptoLevel(_UserSession userSession,
1250 _StatementExecutionContext sec,
1251 int level) throws com.daffodilwoods.
1252 database.resource.DException {
1253 for (int i = 0; i < level; i++) {
1254 userSession.commitSavePoint(sec);
1255 userSession.releaseLastSavePoint();
1256 }
1257 return userSession;
1258 }
1259
1260 public void rollbackSavePoint(String savepoint) throws DException {
1261 ArrayList userSavepointVector = userSession.getSavePointVector();
1262 _StatementExecutionContext sec = getStatementExecutionContext();
1263 if (savepoint != null) {
1264 int index = userSavepointVector.indexOf(savepoint);
1265 if (index < 0)
1266 throw new DException("DSE877", null);
1267 CommitToParentAndRollback(userSession, sec,
1268 userSavepointVector.size() - index);
1269 userSession.rollbackSavePoint(sec);
1270 userSession.releaseLastSavePoint();
1271 } else {
1272 CommitToParentAndRollback(userSession, sec,
1273 userSavepointVector.size() + 1);
1274 userSession.rollback(sec);
1275 }
1276 }
1277
1278 protected void CommitToParentAndRollback(_UserSession userSession,
1279 _StatementExecutionContext sec,
1280 int level) throws com.daffodilwoods.
1281 database.resource.DException {
1282 for (int i = 0; i < level - 1; i++) {
1283 userSession.commitSavePoint(sec);
1284 userSession.releaseLastSavePoint();
1285 }
1286 }
1287
1288 public void setVerboseForCreatingDatabase() {
1289 verbose = false;
1290 }
1291
1292 public void setVerboseUser(String verboseUser0) {
1293 verboseUser = verboseUser0;
1294 }
1295
1296 public void setRole(String roleName) throws DException {
1297 userSession.setRole(roleName);
1298 }
1299
1300 public boolean isActiveAuthorization(String authorization) throws DException {
1301 return serverSystem.isActiveAuthorization(authorization, databaseURL);
1302 }
1303
1304 public _Iterator getInternalIterator(QualifiedIdentifier tableName, _SingleTableExecuter singleTableExecuter) throws DException {
1305 return userSession.getUserSessionTable(tableName).getInternalIterator(singleTableExecuter, this);
1306 }
1307
1308 public ArrayList getCreateIndexesList() {
1309 return createIndexesList;
1310 }
1311
1312 public _DataTriggerTable getDataTriggerTable(QualifiedIdentifier tableName) throws DException {
1313 if (datatriggerDatabase == null)
1314 datatriggerDatabase = serverSystem.getDataTriggerDatabase(databaseURL);
1315 return datatriggerDatabase.getDataTriggerTable(tableName);
1316 }
1317
1318 public double getDbVersion() throws DException {
1319 return ( (MergeDatabase) serverSystem.getMergeDatabase(databaseURL)).getVersionHandler().getDbVersion();
1320 }
1321
1322 public void refereshTable(QualifiedIdentifier tableName,
1323 boolean dropTable) throws DException {
1324 serverSystem.refereshTable(databaseURL, tableName, dropTable);
1325 }
1326
1327 public _Triggers[] getAfterInsertTrigger(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext) throws DException {
1328 return triggerInfoStore.getAfterInsertTrigger(triggerCharacteristics, tableName, statementExecutionContext);
1329 }
1330
1331 public _Triggers[] getBeforeInsertTrigger(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext) throws DException {
1332 return triggerInfoStore.getBeforeInsertTrigger(triggerCharacteristics, tableName, statementExecutionContext);
1333 }
1334
1335 public _Triggers[] getAfterUpdateTrigger(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext, int[] cols) throws DException {
1336 return triggerInfoStore.getAfterUpdateTrigger(triggerCharacteristics, tableName, statementExecutionContext, cols);
1337 }
1338
1339 public _Triggers[] getBeforeUpdateTrigger(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext, int[] cols) throws DException {
1340 return triggerInfoStore.getBeforeUpdateTrigger(triggerCharacteristics, tableName, statementExecutionContext, cols);
1341 }
1342
1343 public _Triggers[] getAfterDeleteTrigger(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext) throws DException {
1344 return triggerInfoStore.getAfterDeleteTrigger(triggerCharacteristics, tableName, statementExecutionContext);
1345 }
1346
1347 public _Triggers[] getBeforeDeleteTrigger(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext) throws DException {
1348 return triggerInfoStore.getBeforeDeleteTrigger(triggerCharacteristics, tableName, statementExecutionContext);
1349 }
1350
1351 public void refreshTriggers(QualifiedIdentifier tableName) throws DException {
1352 serverSystem.refreshTriggers(databaseURL, tableName);
1353
1354 }
1355
1356 public void refreshTriggerInfo(QualifiedIdentifier tableName) throws DException {
1357 triggerInfoStore.removeTriggerInfo(tableName);
1358 statementLevelTriggerInfoStore.removeTriggerInfo(tableName);
1359 }
1360
1361 public SessionVersionHandler getSessionVersionHandler() throws DException {
1362 return ( (MergeDatabase) serverSystem.getMergeDatabase(databaseURL)).getSessionVersionHandler();
1363 }
1364
1365 public _Triggers[] getAfterInsertTriggerOfStatementLevel(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext) throws DException {
1366 return statementLevelTriggerInfoStore.getAfterInsertTrigger(triggerCharacteristics, tableName, statementExecutionContext);
1367 }
1368
1369 public _Triggers[] getBeforeInsertTriggerOfStatementLevel(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext) throws DException {
1370 return statementLevelTriggerInfoStore.getBeforeInsertTrigger(triggerCharacteristics, tableName, statementExecutionContext);
1371 }
1372
1373 public _Triggers[] getAfterUpdateTriggerOfStatementLevel(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext, int[] cols) throws DException {
1374 return statementLevelTriggerInfoStore.getAfterUpdateTrigger(triggerCharacteristics, tableName, statementExecutionContext, cols);
1375 }
1376
1377 public _Triggers[] getBeforeUpdateTriggerOfStatementLevel(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext, int[] cols) throws DException {
1378 return statementLevelTriggerInfoStore.getBeforeUpdateTrigger(triggerCharacteristics, tableName, statementExecutionContext, cols);
1379 }
1380
1381 public _Triggers[] getAfterDeleteTriggerOfStatementLevel(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext) throws DException {
1382 return statementLevelTriggerInfoStore.getAfterDeleteTrigger(triggerCharacteristics, tableName, statementExecutionContext);
1383 }
1384
1385 public _Triggers[] getBeforeDeleteTriggerOfStatementLevel(QualifiedIdentifier tableName, _TriggerCharacteristics triggerCharacteristics, _StatementExecutionContext statementExecutionContext) throws DException {
1386 return statementLevelTriggerInfoStore.getBeforeDeleteTrigger(triggerCharacteristics, tableName, statementExecutionContext);
1387 }
1388
1389 public ArrayList getCreateIndexList() throws DException {
1390 return createIndexesList;
1391 }
1392
1393 public void resetTime() throws DException {
1394 userSession.getSession().resetTime();
1395 }
1396
1397 public void refreshConstraint(QualifiedIdentifier tableName) throws DException {
1398 serverSystem.refreshConstraintTable(databaseURL, tableName);
1399 getDataDictionary().refereshCheckConstraints(tableName);
1400 }
1401
1402
1404 public int getTypeForPrivilige() throws DException {
1405 return serverSession;
1406 }
1407
1408 public boolean isUserActiveMoreThanOnceOnSameDatabase(String databaseName, String userName) throws DException {
1409 return serverSystem.isUserActiveMoreThanOnceOnSameDatabase(databaseName, userName);
1410 }
1411}
1412 |
Popular Tags |
Java API By Example, From Geeks To Geeks.