|
1 package com.daffodilwoods.daffodildb.server.sessionsystem;
2
3 import com.daffodilwoods.daffodildb.server.serversystem.*;
4 import com.daffodilwoods.database.resource.*;
5 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
6 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.*;
7 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
8 import java.util.*;
9 import com.daffodilwoods.database.general.*;
10 import com.daffodilwoods.daffodildb.server.datasystem.mergesystem.*;
11 import com.daffodilwoods.daffodildb.server.sessionsystem.sessioncondition.*;
12 import com.daffodilwoods.daffodildb.server.datasystem.utility._Record;
13 import com.daffodilwoods.database.utility.*;
14 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.Utility;
15 import com.daffodilwoods.daffodildb.server.sessionsystem.sessionversioninfo.SessionVersionHandler;
16
17 public class StatementHandler{
18
21 _Session session;
22
23
26 _Table mergeTable;
27
28
31 boolean transactionStarted;
32 KeyTracer keyTracer;
33 Object  sessionIdAtCommitInParent;
34 boolean insert, delete, insertDelete, chageInCommittedRecord ;
35
36
40 boolean performCommit = false;
41
44 QualifiedIdentifier tableName;
45 SessionVersionHandler sessionVersionHandler;
46
47 _Iterator insertedDeletedIterator,
48 validInsertedIterator,persistentIterator;
49 _Iterator validInsertedIteratorForFile,
50 invalidCommitedRecordIteratorForFile ;
51 _Iterator uncommitedRecordsIterator, transactionConditionIterator, invalidTransactionConditionIterator,invalidRecordIterator, makePersistentForInsertedIterator;
52
53 private static int[] S = {SystemFields.sessionId};
54
55 protected StatementHandler(_Session session0, _Table mergeTable0,QualifiedIdentifier tableName0,SessionVersionHandler sessionVersionHandler0){
56 session = session0;
57 mergeTable = mergeTable0;
58 tableName = tableName0;
59 keyTracer = new KeyTracer();
60 sessionVersionHandler = sessionVersionHandler0;
61 }
62
63
64
85
86 public void performCommitInParent(Object parentSessionId, _StatementExecutionContext statementExecutionContext ) throws DException {
87 try{
88 if( !isDataModified() )
89 return ;
90
91 if(transactionStarted == false){
92 transactionStarted = true;
93 TransactionIsolationLevelHandler tih = ((SessionDatabase)session.getSessionDatabase()).getTransactionIsolationLevelHandler();
94 tih.transactionStarted(((Session)session).getSuperMostSessionId(), session.getIsolationLevel());
95 }
96
97 try{
98 if(keyTracer.isValidToPerform){
99 performCommitForKeys(parentSessionId);
100 keyTracer.removeSavePoint();
101 sessionIdAtCommitInParent = parentSessionId;
102 return;
103 }
104 }catch(DException e){
105 if (!e.getDseCode().equalsIgnoreCase("DSE0"))
106 throw e;
107 }
108
109
110
111 if(insertDelete){
112 getInsertedDeletedIterator();
113 deleteAllFromIterator(insertedDeletedIterator);
114 }
115 if(delete){
116 getInvalidRecordIterator();
117 if (invalidRecordIterator.first())
118 do{
119 _Record record = invalidRecordIterator.getRecord();
120 if(record.getObject(SystemFields.sessionId).equals(parentSessionId ) && record.getObject(SystemFields.transactionId).equals(SystemFields.maxIntegerValue ) ){
121 ( (_TableOperations) invalidRecordIterator).delete();
122 }
123 else{
124 try {
125 ((_TableOperations)invalidRecordIterator).update(SystemFieldsCharacteristics.IS , new Object []{ parentSessionId});
126 }
127 catch (NegativeArraySizeException ex) {
128 P.pln(" record in prblem "+ invalidRecordIterator.getRecord().getObject(0));
129 throw ex;
130 }
131 }
132 }while ( invalidRecordIterator.next() );
133
134 }
135 if(insert){
136 getValidInsertedIterator();
137 if(validInsertedIterator.first()){
138 do{
139 ((_TableOperations)validInsertedIterator).update(S, new Object []{ parentSessionId });
140 }while ( validInsertedIterator.next() );
141 }
142 else
143 {} }
145 sessionIdAtCommitInParent = parentSessionId;
146 }
147 catch(DException de){
148 DException se = new DException("DSE1128",null);
149 throw se;
150 }
151 }
152
153
160
161 public void performRollBack(_StatementExecutionContext statementExecutionContext)throws DException{
162 transactionStarted = false;
163 if( isDataModified() ) {
164 keyTracer.resetLastSessionId();
165 getInvalidRecordIterator();
166 if(invalidRecordIterator.first())
167 do{
168 ((_TableOperations)invalidRecordIterator).delete();
169 }while(invalidRecordIterator.next());
170
171 if (insert){
172 getValidInsertedIterator();
173 deleteAllFromIterator(validInsertedIterator);
174 }
175
176 delete = false;
177 insert = false;
178 insertDelete = false;
179 performCommit = false;
180 chageInCommittedRecord = false;
181 }
182
183 }
184 public void performRollBackWithChildSession(_StatementExecutionContext statementExecutionContext)throws DException{
185 try{
186 if( performCommit ) {
187 try{
188 if(keyTracer.isValidToPerform) {
189 keyTracer.rollBackSavePoint();
190 sessionIdAtCommitInParent = session.getParentSessionId();
191 }
192 }catch(DException ex ){
193 if(!ex.getDseCode().equalsIgnoreCase("DSE0"))
194 throw ex;
195 }
196 _Iterator deleteRecordsIterator = getIteratorForDeletedRecordsByChildSession();
197
198 if(deleteRecordsIterator.first())
199 do{
200 ((_TableOperations)deleteRecordsIterator).delete();
201 }while(deleteRecordsIterator.next());
202
203
204 getInvalidRecordIterator();
205 if(invalidRecordIterator.first())
206 do{
207 ((_TableOperations)invalidRecordIterator).update(SystemFieldsCharacteristics.IS , new Object []{SystemFields.maxIntegerValue});
208 }while(invalidRecordIterator.next());
209
210
211 getValidInsertedIterator();
212 deleteAllFromIterator(validInsertedIterator);
213 sessionIdAtCommitInParent = session.getParentSessionId();
214 }
215
216 }catch( DatabaseException de ){
217 SessionException se = new SessionException("DSE1128",null);
218 se.setException( de );
219 throw se;
220 }
221 }
222
223
224 private void performCommitForKeys(Object parentSessionId) throws DException {
225 SavePointTracer spt = keyTracer.getSavePointTracer(session.getSessionId());
226 _Iterator iterator = ((MergeTable)mergeTable).getMemoryTable().getDefaultIterator();
227 for (int i = spt.deleteId , total = keyTracer.deleteList.size() ; i < total ; i++) {
228 if(i == spt.deleteId && (spt.insertId != (keyTracer.insertList.size()))) {
229 getInsertedDeletedIterator();
230 deleteAllFromIterator(insertedDeletedIterator);
231 }
232 boolean flag = sessionVersionHandler.recordFound(iterator,(Object [])keyTracer.deleteList.get(i));
233 if(flag){
234 ( (_TableOperations) iterator).update(SystemFieldsCharacteristics.IS
235 , new Object [] {parentSessionId});
236 }
237 }
238 int length = keyTracer.updateList.size();
239 _TableCharacteristics tableCharacteristics = mergeTable.getTableCharacteristics();
240 boolean isBlobClobTable = tableCharacteristics.isBlobClobTable() > 0 ? true : false;
241 for (int i = spt.updateId ; i < length ; i++) {
242 Object updateKey = keyTracer.updateList.get(i);
243 boolean flag = sessionVersionHandler.recordFound(iterator,(Object [])updateKey); if(flag){
245 Object [] updatedRecordKey = (Object [])updateKey;
246 if( parentSessionId.equals(updatedRecordKey[2]) && SystemFields.maxIntegerValue.equals(updatedRecordKey[1]) ) {
247 if (isBlobClobTable) {
248 if (iterator.next()) {
249 Object rowid = iterator.getColumnValues(SessionConditionReferences.rowIdReference_0);
250 iterator.previous();
251 if (updatedRecordKey[0].equals(rowid))
252 ( (_TableOperations) iterator).deleteBlobClobRecord(null);
253 else
254 ( (_TableOperations) iterator).delete();
255 }
256 else
257 ( (_TableOperations) iterator).delete();
258 } else
259 ( (_TableOperations) iterator).delete();
260 keyTracer.updateList.remove(i);
261 length--;
262 i--; }
264 else{
265 Object sessionId = ( (Object []) updateKey)[2];
266 Object inValidSessinId = iterator.getColumnValues(SessionConditionReferences.invalidSessionIdReference_4);
267 if (session.getSessionId().equals(sessionId) && sessionId.equals(inValidSessinId)) {
268 ( (_TableOperations) iterator).delete();
269 }
270 else {
271 ( (_TableOperations) iterator).update(SystemFieldsCharacteristics.IS, new Object [] {parentSessionId});
272 }
273 }
274 }
275
276 }
277
278 for (int i = spt.insertId , total = keyTracer.insertList.size() ; i < total ; i++) {
279 try {
280 Object key = keyTracer.insertList.get(i);
281 boolean flag = sessionVersionHandler.recordFound(iterator,(Object []) key); if(flag){
283 ( (_TableOperations) iterator).update(S,new Object [] {parentSessionId});
284 ( (Object []) key)[2] = parentSessionId;
285 }
286 }
287 catch (DException ex) {
288 if(!ex.getDseCode().equalsIgnoreCase("DSE2004"))
289 throw ex;
290 }
291 }
292
293 }
294
295
296 public boolean isDataModified() throws DException{
297 return performCommit && session.getSessionId().equals(sessionIdAtCommitInParent);
298 }
299
300 public void delete( Object sessionId , Object key ) throws DException {
301 keyTracer.ensureParentSession(((Session)session).getSessionIdList() );
302 keyTracer.delete(sessionId,key);
303 }
304 public void insert( Object sessionId , Object key ) throws DException {
305 keyTracer.ensureParentSession(((Session)session).getSessionIdList() );
306 keyTracer.insert(sessionId,key);
307 }
308
309 public void update( Object sessionId , Object key ) throws DException {
310 keyTracer.ensureParentSession(((Session)session).getSessionIdList() );
311 keyTracer.update(sessionId,key);
312 }
313
314 private _Iterator getInsertedDeletedIterator() throws DException{
315 if( insertedDeletedIterator != null )
316 return insertedDeletedIterator;
317 _SessionCondition inserDeletedCondition = ((Session)session).getInsertDeletedCondition( );
318 synchronized( inserDeletedCondition ){
319 _Iterator iterator = ((_MergeTable)mergeTable).getMemoryTable().getDefaultIterator();
320 insertedDeletedIterator = (_Iterator) new NonIndexedSessionFilterIterator ( iterator , inserDeletedCondition);
321 }
322 return insertedDeletedIterator;
323 }
324
325
326 public _Iterator getInvalidRecordIterator() throws DException{
327 if(invalidRecordIterator != null)
328 return invalidRecordIterator;
329 _SessionCondition invalidRecordCondition = ((Session)session).getInvlidRecordCondition( );
330 synchronized(invalidRecordCondition){
331 _Iterator iterator = ((_MergeTable)mergeTable).getMemoryTable().getDefaultIterator();
332 invalidRecordIterator = (_Iterator) new NonIndexedSessionFilterIterator( iterator, invalidRecordCondition);
333 }
334 return invalidRecordIterator;
335 }
336 private _Iterator getValidInsertedIterator() throws DException{
337 if( validInsertedIterator != null ){
338 return validInsertedIterator;
339 }
340 _SessionCondition insertedCondition = ((Session)session).getInsertedCondition( );
341 synchronized( insertedCondition ){
342 _Iterator iterator = ((_MergeTable)mergeTable).getMemoryTable().getDefaultIterator();
343 validInsertedIterator = (_Iterator) new NonIndexedSessionFilterIterator( iterator, insertedCondition);
344 }
345 return validInsertedIterator;
346 }
347
348
349
350
351 private void deleteAllFromIteratorForFile( _DatabaseUser databaseUser ,_Iterator insertedDeletedIterator)throws DException{
352 if(insertedDeletedIterator.first())
353 do{
354 ((_UserTableOperations)insertedDeletedIterator).delete(databaseUser);
355 }while(insertedDeletedIterator.next());
356 }
357
358
359
360
361 private _Iterator getInvalidCommitedRecordIteratorForFile()throws DException{
362 if(invalidCommitedRecordIteratorForFile != null)
363 return invalidCommitedRecordIteratorForFile;
364 _SessionCondition invalidCommittedCondition = ((Session)session).getInvalidCommittedCondition( );
365 synchronized(invalidCommittedCondition){
366 _Iterator iterator = ((_MergeTable)mergeTable).getFileTable().getDefaultIterator();
367 invalidCommitedRecordIteratorForFile = (_Iterator) new NonIndexedSessionFilterIterator(iterator, invalidCommittedCondition);
368 }
369 return invalidCommitedRecordIteratorForFile;
370 }
371
372 private _Iterator getValidInsertedIteratorForFile() throws DException{
373 if( validInsertedIteratorForFile != null ){
374 return validInsertedIteratorForFile;
375 }
376 _SessionCondition insertedCondition = ((Session)session).getInsertedCondition( );
377 synchronized( insertedCondition ){
378 _Iterator iterator = ((_MergeTable)mergeTable).getFileTable().getDefaultIterator() ;
379 validInsertedIteratorForFile = (_Iterator) new NonIndexedSessionFilterIterator( iterator , insertedCondition);
380 }
381 return validInsertedIteratorForFile;
382 }
383 public _Iterator getUncommitedRecordsIterator() throws DException{
384 if( uncommitedRecordsIterator != null )
385 return uncommitedRecordsIterator;
386 _SessionCondition criteriaForRollbacknCommit = ((Session)session).getCriteriaForRollBackNCommit();
387 synchronized( criteriaForRollbacknCommit){
388 _Iterator iterator = ((_MergeTable)mergeTable).getMemoryTable().getDefaultIterator() ;
389 uncommitedRecordsIterator = (_Iterator)new NonIndexedSessionFilterIterator( iterator, criteriaForRollbacknCommit);
390 }
391 return uncommitedRecordsIterator;
392 }
393
394 public _Iterator getTransactionConditionIterator(Object transactionID) throws DException{
395 if( transactionConditionIterator != null ){
396 ((Session)session).getTransactionCondition().setParameterValues(new Object []{transactionID});
397 return transactionConditionIterator;
398 }
399 _SessionCondition transactionCondition = ((Session)session).getTransactionCondition();
400 synchronized( transactionCondition ){
401 transactionCondition.setParameterValues(new Object []{transactionID});
402 _Iterator iterator = ((_MergeTable)mergeTable).getMemoryTable().getDefaultIterator();
403 transactionConditionIterator = (_Iterator) new NonIndexedSessionFilterIterator( iterator, transactionCondition);
404 }
405 return transactionConditionIterator;
406 }
407
408 public _Iterator getMakePersistentForInsertedIterator() throws DException{
409 if( makePersistentForInsertedIterator != null ){
410 return makePersistentForInsertedIterator;
411 }
412 _SessionCondition makePersistentForInsertedCondition = ((Session)session).getMakePersistentForInsertedCondition();
413 synchronized( makePersistentForInsertedCondition ){
414 _Iterator iterator = ((_MergeTable)mergeTable).getMemoryTable().getDefaultIterator();
415 makePersistentForInsertedIterator = (_Iterator) new NonIndexedSessionFilterIterator( iterator, makePersistentForInsertedCondition);
416 }
417 return makePersistentForInsertedIterator;
418 }
419
420 public _Iterator getInvalidTransactionConditionIterator(Object transactionID) throws DException{
421 if( invalidTransactionConditionIterator != null ){
422 ((Session)session).getInvalidTransactionCondition().setParameterValues(new Object []{transactionID});
423 return invalidTransactionConditionIterator;
424 }
425 _SessionCondition invalidTransactionCondition = ((Session)session).getInvalidTransactionCondition();
426 synchronized( invalidTransactionCondition){
427 invalidTransactionCondition.setParameterValues(new Object []{transactionID});
428 _Iterator iterator = ((_MergeTable)mergeTable).getMemoryTable().getDefaultIterator();
429 invalidTransactionConditionIterator = (_Iterator) new NonIndexedSessionFilterIterator(iterator, invalidTransactionCondition);
430 }
431 return invalidTransactionConditionIterator;
432 }
433
434 public _Iterator getPersistentIterator(Object transactionId) throws DException{
435 if( persistentIterator != null ){
436 ((Session)session).getPersistentCondition().setParameterValues(new Object []{transactionId});
437 return persistentIterator;
438 }
439 _SessionCondition persistentCondition = ((Session)session).getPersistentCondition();
440 synchronized( persistentCondition ){
441 persistentCondition.setParameterValues(new Object []{transactionId});
442 _Iterator iterator = ((_MergeTable)mergeTable).getMemoryTable().getDefaultIterator();
443 persistentIterator = (_Iterator) new NonIndexedSessionFilterIterator( iterator, persistentCondition);
444 }
445 return persistentIterator;
446 }
447
448 public void deleteAllFromIterator( _Iterator insertedDeletedIterator)throws DException{
449 if (insertedDeletedIterator.first()) {
450 do {
451 ( (_TableOperations) insertedDeletedIterator).delete();
452 } while (insertedDeletedIterator.next());
453 }
454 }
455
456 private _Iterator getIteratorForDeletedRecordsByChildSession() throws DException{
457
458 _SessionCondition condition1 = ((Session)session).getInvalidCommittedCondition();
459 _SessionCondition condition2 = ((Session)session).getInvalidTransactionConditionWithChild();
460 _SessionCondition sessionCondition = new MergedSessionCondition(new _SessionCondition[]{condition1,condition2});
461 _Iterator deleteChildRecordsIterator = new NonIndexedSessionFilterIterator(((_MergeTable)mergeTable).getMemoryTable().getDefaultIterator(),sessionCondition);
462
463 return deleteChildRecordsIterator;
464 }
465
466 public void resetAll(){
467 insert = false;
468 delete= false;
469 insertDelete = false;
470 chageInCommittedRecord = false;
471 }
472 }
473 |
Popular Tags |
Java API By Example, From Geeks To Geeks.