KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > daffodilwoods > daffodildb > server > sessionsystem > TransactionIsolationLevelHandler


1 package com.daffodilwoods.daffodildb.server.sessionsystem;
2
3 import com.daffodilwoods.database.resource.DException;
4 import java.util.*;
5 import com.daffodilwoods.daffodildb.server.datasystem.interfaces._IndexTable;
6 import com.daffodilwoods.daffodildb.server.sql99.expression.booleanvalueexpression.booleanvalueexpression;
7 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator._Iterator;
8 import com.daffodilwoods.daffodildb.server.datasystem.interfaces._TableOperations;
9 import com.daffodilwoods.database.general.QualifiedIdentifier;
10 import com.daffodilwoods.daffodildb.server.sql99.common.TableDetails;
11 import java.sql.Connection JavaDoc;
12 import com.daffodilwoods.daffodildb.utils.GetByteComparator;
13 import com.daffodilwoods.daffodildb.server.datasystem.mergesystem.MergeTable;
14 import com.daffodilwoods.daffodildb.server.sql99.common.GeneralPurposeStaticClass;
15 import com.daffodilwoods.daffodildb.server.sessionsystem.sessioncondition.*;
16 import com.daffodilwoods.daffodildb.server.sessionsystem.sessioncondition.InvalidRecordCondition;
17
18 public class TransactionIsolationLevelHandler {
19     final static int Read_Uncommitted = Connection.TRANSACTION_READ_UNCOMMITTED;
20     final static int Read_Committed = Connection.TRANSACTION_READ_COMMITTED;
21     final static int Repeatable_Read = Connection.TRANSACTION_REPEATABLE_READ;
22     final static int Serializable = Connection.TRANSACTION_SERIALIZABLE;
23
24     Map activeTransactions;
25     private static Comparator cmp = new TransactionComparator();
26
27     public TransactionIsolationLevelHandler() {
28         activeTransactions = new TreeMap(cmp);
29     }
30
31     private static boolean isJDBCIsolationLevel(int isolationLevel){
32         return isolationLevel != 5 && isolationLevel != 6;
33     }
34
35     public synchronized void transactionStarted(Object JavaDoc sessionId,
36             int isolationLevel)throws DException
37     {
38         if( isJDBCIsolationLevel(isolationLevel) ){
39             TransactionInfo transactionInfo = new TransactionInfo(sessionId, isolationLevel);
40             activeTransactions.put(sessionId,transactionInfo);
41         }
42     }
43
44     /* When a transaction is rollbacked, simply delete the data from the memory
45        table for this transaction. This is done because no isolation level other
46        than read-uncommitted allows for the reading of dirty data.
47     */

48     public synchronized void transactionRollbacked(Object JavaDoc uniqueId) throws DException
49     {
50         TransactionInfo transactionDetails =(TransactionInfo)activeTransactions.remove(uniqueId);
51         if( transactionDetails != null ){
52             transactionDetails.closeTransaction();
53         }
54     }
55
56     public synchronized void transactionCommitted(Object JavaDoc sessionId, Object JavaDoc transactionId,
57             ArrayList memoryTables) throws DException
58     {
59
60         TransactionInfo transactionDetails =(TransactionInfo)activeTransactions.remove(sessionId);
61         if( transactionDetails == null ){
62             TransactionInfo tInfo = new TransactionInfo(null,-1);
63             tInfo.setSessionId(sessionId);
64             deleteData(tInfo,memoryTables);
65             return;
66         }
67
68         transactionDetails.setSessionId(sessionId);
69
70         switch ( transactionDetails.isolationLevel ){
71             case Read_Uncommitted :
72                 deleteModifiedData(transactionDetails,memoryTables);
73                 transactionDetails.closeTransaction();
74                 break;
75             case Read_Committed :
76                 ArrayList dependentTransactions = getDependentTransactions_ReadCommitted(transactionDetails);
77                 if( dependentTransactions == null ){
78                     deleteModifiedData(transactionDetails,memoryTables);
79                     transactionDetails.closeTransaction();
80                 }
81                 else{
82                     transactionDetails.addDependendentTransaction(dependentTransactions);
83                     transactionDetails.addMemoryTables(memoryTables);
84                 }
85                 break;
86             case Repeatable_Read :
87             case Serializable :
88                 ArrayList dependentTransactions0 = getDependentTransactions(transactionDetails);
89                 if( dependentTransactions0 == null ){
90                     deleteModifiedData(transactionDetails,memoryTables);
91                     transactionDetails.closeTransaction();
92                 }
93                 else{
94                     transactionDetails.addDependendentTransaction(dependentTransactions0);
95                     transactionDetails.addMemoryTables(memoryTables);
96                 }
97                 break;
98         }
99     }
100
101     private ArrayList getDependentTransactions_ReadCommitted(TransactionInfo currentTransaction){
102         ArrayList dependentTransactions=null;
103         for (Iterator i = activeTransactions.values().iterator(); i.hasNext(); ) {
104             TransactionInfo transaction = (TransactionInfo)i.next();
105             if( transaction != currentTransaction &&
106                 transaction.isolationLevel > currentTransaction.isolationLevel )
107             {
108                 if( dependentTransactions == null ){
109                     dependentTransactions = new ArrayList();
110                 }
111                 dependentTransactions.add(transaction);
112             }
113         }
114         return dependentTransactions;
115     }
116
117     private ArrayList getDependentTransactions(TransactionInfo currentTransaction){
118         ArrayList dependentTransactions=null;
119         for (Iterator i = activeTransactions.values().iterator(); i.hasNext(); ) {
120             TransactionInfo transaction = (TransactionInfo)i.next();
121             if( transaction != currentTransaction &&
122                 transaction.isolationLevel > Read_Committed )
123             {
124                 if(dependentTransactions == null ){
125                     dependentTransactions = new ArrayList();
126                 }
127                 dependentTransactions.add(transaction);
128             }
129         }
130         return dependentTransactions;
131     }
132
133     void deleteData(TransactionInfo transaction, ArrayList memoryTables)
134             throws DException
135     {
136        Object JavaDoc sessionId = transaction.sessionId;
137         for (Iterator i = memoryTables.iterator(); i.hasNext(); ) {
138             SessionTable sessionTable = (SessionTable)i.next();
139             boolean deleted = ((Boolean JavaDoc)i.next()).booleanValue() ;
140             QualifiedIdentifier tableName= sessionTable.getTableName();
141             _IndexTable memoryTable = ((MergeTable)(sessionTable).getMergeTable()).getMemoryTable();
142             if(deleted)
143             deleteModifiedRecords(memoryTable, sessionId,tableName);
144
145         }
146     }
147
148     void deleteNewlyInsertedData(TransactionInfo transaction, ArrayList memoryTables)
149            throws DException
150    {
151       Object JavaDoc sessionId = transaction.sessionId;
152        for (Iterator i = memoryTables.iterator(); i.hasNext(); ) {
153            SessionTable sessionTable = (SessionTable)i.next();
154            boolean inserted = ((Boolean JavaDoc)i.next()).booleanValue() ;
155            i.next(); // to skip the boolean variable of deleted
156
QualifiedIdentifier tableName= sessionTable.getTableName();
157            _IndexTable memoryTable = ((MergeTable)(sessionTable).getMergeTable()).getMemoryTable();
158            if(inserted)
159            deleteInsertedRecords(memoryTable, sessionId, tableName);
160
161
162        }
163    }
164
165
166     private void deleteInsertedRecords(_IndexTable memoryTable, Object JavaDoc sessionId, QualifiedIdentifier tableName)
167             throws DException
168     {
169
170
171         _SessionCondition sessionCondition = new PersistentForInsertedCondition(sessionId);
172         _Iterator deleteIterator = new NonIndexedSessionFilterIterator(memoryTable.getDefaultIterator(),sessionCondition) ;
173
174
175
176         if(deleteIterator.last()){
177             do{
178                try {
179
180                  ( (_TableOperations) deleteIterator).delete();
181                }
182                catch (DException ex) {
183                   throw ex;
184                }
185             }while(deleteIterator.previous());
186         }
187     }
188
189     void deleteModifiedData(TransactionInfo transaction, ArrayList memoryTables)
190             throws DException
191     {
192        Object JavaDoc sessionId = transaction.sessionId;
193         for (Iterator i = memoryTables.iterator(); i.hasNext(); ) {
194             SessionTable sessionTable = (SessionTable)i.next();
195             boolean deleted = ((Boolean JavaDoc)i.next()).booleanValue() ;
196             QualifiedIdentifier tableName= sessionTable.getTableName();
197             _IndexTable memoryTable = ((MergeTable)(sessionTable).getMergeTable()).getMemoryTable();
198            if(deleted)
199             deleteModifiedRecords(memoryTable, sessionId,tableName);
200         }
201     }
202
203     private void deleteModifiedRecords(_IndexTable memoryTable,Object JavaDoc sessionId, QualifiedIdentifier tableName)
204             throws DException
205     {
206
207
208
209         _SessionCondition sessionCondition = new InvalidRecordCondition(sessionId);
210         _Iterator deleteIterator = new NonIndexedSessionFilterIterator(memoryTable.getDefaultIterator(),sessionCondition) ;
211
212         if(deleteIterator.last()){
213             do{
214
215                 ((_TableOperations)deleteIterator).delete();
216             }while(deleteIterator.previous());
217         }
218     }
219
220     class TransactionInfo{
221         Object JavaDoc transactionId;
222         int isolationLevel;
223         Object JavaDoc sessionId;
224         ArrayList notifiers;
225         ArrayList waiters;
226
227         ArrayList memoryTables;
228
229
230
231         TransactionInfo(Object JavaDoc transactionId0, int isolationLevel0){
232             transactionId = transactionId0;
233             isolationLevel = isolationLevel0;
234         }
235
236         void addDependendentTransaction(ArrayList transactions){
237             notifiers = transactions;
238             for (Iterator i = notifiers.iterator(); i.hasNext(); ) {
239                 TransactionInfo t = (TransactionInfo) i.next();
240                 t.addWaitingTransaction(this);
241             }
242         }
243
244         void addWaitingTransaction(TransactionInfo transaction){
245             if( waiters == null )
246                 waiters = new ArrayList(5);
247             waiters.add(transaction);
248         }
249
250         void transactionClosed(TransactionInfo transaction) throws DException{
251             notifiers.remove(transaction);
252             if( notifiers.size() == 0 ){
253                 deleteModifiedData(this,memoryTables);
254             }
255         }
256
257         void closeTransaction() throws DException{
258             if( waiters != null ) {
259                 for (Iterator i = waiters.iterator(); i.hasNext(); ) {
260                     TransactionInfo waitingTransaction = (TransactionInfo)i.next();
261                     waitingTransaction.transactionClosed(this);
262                 }
263             }
264         }
265
266         void addMemoryTables(ArrayList memoryTables0){
267             this.memoryTables = memoryTables0;
268         }
269
270         public String JavaDoc toString(){
271             return ""+ transactionId+ "-- IL -- "+ isolationLevel;
272         }
273
274         public void setSessionId(Object JavaDoc sessionId0){
275            sessionId = sessionId0;
276         }
277
278     }
279
280     static class TransactionComparator implements Comparator {
281         public int compare(Object JavaDoc obj2, Object JavaDoc obj3){
282             try {
283                 return GetByteComparator.sameComparator.compare(obj2,obj3);
284             }
285             catch (DException ex) {
286                 return 0;
287             }
288         }
289     }
290
291     public synchronized void transactionEnded(Object JavaDoc uniqueId) throws DException
292     {
293         TransactionInfo transactionDetails =(TransactionInfo)activeTransactions.remove(uniqueId);
294         if( transactionDetails != null ){
295             transactionDetails.closeTransaction();
296         }
297     }
298
299     public synchronized boolean hasAnyDependentTransaction(Object JavaDoc uniqueId)throws DException{
300        TransactionInfo transactionDetails =(TransactionInfo)activeTransactions.get(uniqueId);
301        if( transactionDetails == null ){
302            return false;
303        }
304        transactionDetails.setSessionId(uniqueId);
305        switch ( transactionDetails.isolationLevel ){
306            case Read_Committed :
307                ArrayList dependentTransactions = getDependentTransactions_ReadCommitted(transactionDetails);
308                return dependentTransactions != null ;
309            case Repeatable_Read :
310            case Serializable :
311                ArrayList dependentTransactions0 = getDependentTransactions(transactionDetails);
312                return dependentTransactions0 != null ;
313        }
314        return false;
315     }
316
317 }
318
319
320
Popular Tags