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 ; 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 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 48 public synchronized void transactionRollbacked(Object 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 sessionId, Object 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 sessionId = transaction.sessionId; 137 for (Iterator i = memoryTables.iterator(); i.hasNext(); ) { 138 SessionTable sessionTable = (SessionTable)i.next(); 139 boolean deleted = ((Boolean )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 sessionId = transaction.sessionId; 152 for (Iterator i = memoryTables.iterator(); i.hasNext(); ) { 153 SessionTable sessionTable = (SessionTable)i.next(); 154 boolean inserted = ((Boolean )i.next()).booleanValue() ; 155 i.next(); 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 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 sessionId = transaction.sessionId; 193 for (Iterator i = memoryTables.iterator(); i.hasNext(); ) { 194 SessionTable sessionTable = (SessionTable)i.next(); 195 boolean deleted = ((Boolean )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 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 transactionId; 222 int isolationLevel; 223 Object sessionId; 224 ArrayList notifiers; 225 ArrayList waiters; 226 227 ArrayList memoryTables; 228 229 230 231 TransactionInfo(Object 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 toString(){ 271 return ""+ transactionId+ "-- IL -- "+ isolationLevel; 272 } 273 274 public void setSessionId(Object sessionId0){ 275 sessionId = sessionId0; 276 } 277 278 } 279 280 static class TransactionComparator implements Comparator { 281 public int compare(Object obj2, Object 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 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 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 |