1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/dbms/pcdbms/utable/UT_TRANS.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,742 @@
1.4 +// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "UT_STD.H"
1.20 +
1.21 +// Class RDbTransaction::CNotifier
1.22 +
1.23 +NONSHARABLE_CLASS(RDbTransaction::CNotifier) : public CDbNotifier
1.24 + {
1.25 +public:
1.26 + inline CNotifier( RDbTransaction& aTransaction );
1.27 + ~CNotifier();
1.28 +//
1.29 +// void Event( RDbNotifier::TEvent aEvent );
1.30 +private:
1.31 +// void Complete( TInt aStatus );
1.32 +// from CDbNotifier
1.33 +// void Notify( TType aEvent, TRequestStatus& aStatus );
1.34 + void Cancel();
1.35 +private:
1.36 + RDbTransaction* iTransaction;
1.37 +// TRequestStatus* iStatus;
1.38 + TInt iPending;
1.39 + };
1.40 +
1.41 +inline RDbTransaction::CNotifier::CNotifier( RDbTransaction& aTransaction )
1.42 + : iTransaction( &aTransaction )
1.43 + {}
1.44 +
1.45 +RDbTransaction::CNotifier::~CNotifier()
1.46 +//
1.47 +// Cancel any outstanding request and extract from the transaction
1.48 +//
1.49 + {
1.50 + Cancel();
1.51 + if ( iTransaction )
1.52 + {
1.53 + __ASSERT( iTransaction->iNotifier == this );
1.54 + iTransaction->iNotifier = 0;
1.55 + }
1.56 + }
1.57 +
1.58 +//void RDbTransaction::CNotifier::Complete( TInt aStatus )
1.59 +// {
1.60 +// if ( iStatus )
1.61 +// {
1.62 +// iPending = 0;
1.63 +// User::RequestComplete( iStatus, aStatus );
1.64 +// }
1.65 +// }
1.66 +
1.67 +//void RDbTransaction::CNotifier::Notify( CDbNotifier::TType aType, TRequestStatus& aStatus )
1.68 +////
1.69 +//// Request for future notification. If the database is closed complete immediately
1.70 +////
1.71 +// {
1.72 +// __ASSERT( !iStatus );
1.73 +// __ASSERT( iPending >= 0 );
1.74 +// iStatus = &aStatus;
1.75 +// if ( iPending > RDbNotifier::EUnlock )
1.76 +// Complete( iPending );
1.77 +// else if ( !iTransaction )
1.78 +// Complete( RDbNotifier::EClose );
1.79 +// else
1.80 +// {
1.81 +// iPending = aType;
1.82 +// aStatus = KRequestPending;
1.83 +// }
1.84 +// }
1.85 +
1.86 +void RDbTransaction::CNotifier::Cancel()
1.87 + {
1.88 +// Complete( KErrCancel );
1.89 + }
1.90 +
1.91 +//void RDbTransaction::CNotifier::Event( RDbNotifier::TEvent aEvent )
1.92 +// {
1.93 +// if ( aEvent == RDbNotifier::EClose )
1.94 +// iTransaction = 0;
1.95 +// if ( iStatus )
1.96 +// {
1.97 +// __ASSERT( iPending < 0 );
1.98 +// if (aEvent == RDbNotifier::EUnlock && iPending == CDbNotifier::EChange )
1.99 +// ; // not interested in unlock events
1.100 +// else
1.101 +// Complete( aEvent );
1.102 +// }
1.103 +// else
1.104 +// {
1.105 +// __ASSERT( iPending >= 0 );
1.106 +// if ( aEvent > iPending )
1.107 +// iPending = aEvent; // save the event
1.108 +// }
1.109 +// }
1.110 +
1.111 +
1.112 +// Class RDbTransaction
1.113 +
1.114 +#ifdef _ASSERTIONS
1.115 +
1.116 +//void RDbTransaction::_Invariant() const
1.117 +////
1.118 +//// Invariance test
1.119 +////
1.120 +// {
1.121 +// if ( iLockCount == 0 )
1.122 +// { // nothing must be happening in this state
1.123 +// __ASSERT( iLockState == EDbReadLock );
1.124 +// __ASSERT( iAction == EDbReadLock );
1.125 +// __ASSERT( iUpdaters == 0 );
1.126 +// return;
1.127 +// }
1.128 +// switch ( iLockState & EState )
1.129 +// {
1.130 +// default:
1.131 +// __ASSERT( 0 );
1.132 +// case EDbReadLock:
1.133 +// {
1.134 +// __ASSERT( iAction == EDbReadLock );
1.135 +// __ASSERT( iLockCount > 0 ); // someone must have a lock
1.136 +// __ASSERT( iLockCount <= iMaxLock );
1.137 +// __ASSERT( iUpdaters == 0 );
1.138 +// __ASSERT( iPrimary.iState != 0 );
1.139 +// for (TInt ii = iLockCount - 1; --ii >= 0; )
1.140 +// __ASSERT( iSharers[ii].iState != 0 );
1.141 +// }
1.142 +// break;
1.143 +// case EDbCompactLock: // not allowed in user-transactions
1.144 +// case EDbRecoveryLock:
1.145 +// __ASSERT( iAction == iLockState );
1.146 +// __ASSERT( iLockCount == 1 ); // exactly one lock allowed
1.147 +// __ASSERT( iUpdaters == 0 );
1.148 +// __ASSERT( iPrimary.iState == 0 );
1.149 +// break;
1.150 +// case EDbXReadLock: // intention to write. No updates but exclusive
1.151 +// __ASSERT( iLockCount == 1 ); // exactly one lock allowed
1.152 +// switch ( iAction )
1.153 +// {
1.154 +// default:
1.155 +// __ASSERT( 0 );
1.156 +// case EDbReadLock: // must be in a transaction: cannot commit a write/schema mod when releasing a read lock
1.157 +// __ASSERT( iUpdaters == 0 );
1.158 +// __ASSERT( iPrimary.iState & static_cast<TUint>( ETransactionLock ) );
1.159 +// break;
1.160 +// case EDbWriteLock:
1.161 +// __ASSERT( iUpdaters > 0 );
1.162 +// break;
1.163 +// }
1.164 +// break;
1.165 +// case EDbWriteLock:
1.166 +// case EDbSchemaLock:
1.167 +// __ASSERT( iLockCount == 1 ); // exactly one lock allowed
1.168 +// switch ( iAction )
1.169 +// {
1.170 +// default:
1.171 +// __ASSERT( 0 );
1.172 +// case EDbReadLock: // must be in a transaction: cannot commit a write/schema mod when releasing a read lock
1.173 +// __ASSERT( iUpdaters == 0 );
1.174 +// __ASSERT( iPrimary.iState & static_cast<TUint>( ETransactionLock ) );
1.175 +// break;
1.176 +// case EDbWriteLock:
1.177 +// __ASSERT( iUpdaters > 0 );
1.178 +// __ASSERT( ( iLockState & EState ) == EDbWriteLock || ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) );
1.179 +// break;
1.180 +// case EDbSchemaLock:
1.181 +// __ASSERT( ( iLockState & EState ) == EDbSchemaLock );
1.182 +// __ASSERT( iUpdaters == 0 );
1.183 +// break;
1.184 +// }
1.185 +// break;
1.186 +// }
1.187 +// }
1.188 +
1.189 +//template <class T> struct _InvariantFunc
1.190 +// {
1.191 +// static void Invariant( TAny* aPtr ) { ( (const T*)aPtr )->_Invariant(); }
1.192 +// };
1.193 +//
1.194 +//template <class T> inline TCleanupOperation _InvariantFunction( T* )
1.195 +// { return _InvariantFunc<T>::Invariant; }
1.196 +//
1.197 +//struct _Invariant
1.198 +// {
1.199 +// inline _Invariant( TCleanupOperation aOp, TAny* aPtr )
1.200 +// : iOp( aOp ), iPtr( aPtr )
1.201 +// { aOp( aPtr ); }
1.202 +// inline ~_Invariant()
1.203 +// { iOp( iPtr ); }
1.204 +//private:
1.205 +// TCleanupOperation iOp;
1.206 +// TAny* iPtr;
1.207 +// };
1.208 +
1.209 +#ifndef __LEAVE_EQUALS_THROW
1.210 +//struct _InvariantL
1.211 +// {
1.212 +// inline _InvariantL( TCleanupOperation aOp, TAny* aPtr )
1.213 +// { aOp( aPtr ); CleanupStack::PushL( TCleanupItem( aOp, aPtr ) ); }
1.214 +// inline ~_InvariantL()
1.215 +// { CleanupStack::PopAndDestroy(); }
1.216 +// };
1.217 +#endif //__LEAVE_EQUALS_THROW__
1.218 +
1.219 +//#define __INVARIANT struct _Invariant _invariant( _InvariantFunction( this ), this );
1.220 +
1.221 +//#ifdef __LEAVE_EQUALS_THROW__
1.222 +// #define __INVARIANT_L __INVARIANT
1.223 +//#else
1.224 +// #define __INVARIANT_L struct _InvariantL _invariant( _InvariantFunction( this ), this );
1.225 +//#endif //__LEAVE_EQUALS_THROW__
1.226 +
1.227 +#define __INVARIANT ( (void)0 )
1.228 +#define __INVARIANT_L ( (void)0 )
1.229 +#else // _ASSERTIONS
1.230 +
1.231 +#define __INVARIANT ( (void)0 )
1.232 +#define __INVARIANT_L ( (void)0 )
1.233 +
1.234 +#endif // _ASSERTIONS
1.235 +
1.236 +inline TDbLockType RDbTransaction::LockState() const
1.237 + { return TDbLockType( iLockState & EState ); }
1.238 +
1.239 +void RDbTransaction::Close()
1.240 + {
1.241 + __ASSERT( !IsLocked() );
1.242 + User::Free( iSharers );
1.243 +// Event( RDbNotifier::EClose );
1.244 + }
1.245 +
1.246 +void RDbTransaction::DoCommitL()
1.247 +//
1.248 +// Commit any changes
1.249 +//
1.250 + {
1.251 + __ASSERT_ALWAYS( ( iPrimary.iState & ~ETransactionLock ) == 0, Panic( EDbStreamsPendingOnCommit ) );
1.252 + iLockState |= EFailed;
1.253 + Database().FlushL( LockState() );
1.254 + Database().SynchL( LockState() );
1.255 + Unlock( RDbNotifier::ECommit );
1.256 + }
1.257 +
1.258 +void RDbTransaction::DoRollback()
1.259 +//
1.260 +// Rollback any changes
1.261 +//
1.262 + {
1.263 + __ASSERT_ALWAYS( ( iPrimary.iState & ~ETransactionLock ) == 0, Panic( EDbStreamsPendingOnRollback ) );
1.264 + Database().Revert( LockState() );
1.265 + Database().Abandon( LockState() );
1.266 + if ( LockState() >= EDbWriteLock )
1.267 + ++iRollback;
1.268 + Unlock( RDbNotifier::ERollback );
1.269 + }
1.270 +
1.271 +// explicit transactions
1.272 +
1.273 +void RDbTransaction::BeginL( const CDbObject& aObject )
1.274 +//
1.275 +// begin a user transaction. This first gains a shared read-lock
1.276 +//
1.277 + {
1.278 + __INVARIANT_L;
1.279 + __ASSERT_ALWAYS( GetLock( aObject ) == 0, Panic( EDbBeginNestedTransaction ) );
1.280 + ReadyL();
1.281 + PrepareSLockL( aObject, TUint( ETransactionLock ) );
1.282 + __ASSERT( iAction == EDbReadLock );
1.283 + __ASSERT( iLockState == EDbReadLock );
1.284 + ++iLockCount;
1.285 + }
1.286 +
1.287 +void RDbTransaction::CommitL( const CDbObject& aObject )
1.288 +//
1.289 +// Commit a user transaction and release the lock
1.290 +// All updates must be complete for a write-lock
1.291 +//
1.292 + {
1.293 + __INVARIANT_L;
1.294 + __ASSERT_ALWAYS( InTransaction( aObject ), Panic( EDbNoCurrentTransaction ) );
1.295 + ReadyL();
1.296 + if ( iLockCount > 1 )
1.297 + {
1.298 + TLock* lock = GetLock( aObject );
1.299 + __ASSERT( lock );
1.300 + __ASSERT_ALWAYS( lock->iState == static_cast<TUint>( ETransactionLock ), Panic( EDbStreamsPendingOnCommit ) );
1.301 + Unlock( *lock );
1.302 + }
1.303 + else
1.304 + {
1.305 + __ASSERT_ALWAYS( iAction == EDbReadLock, Panic( EDbUpdatesPendingOnCommit ) );
1.306 + DoCommitL();
1.307 + }
1.308 + }
1.309 +
1.310 +void RDbTransaction::Rollback( const CDbObject& aObject )
1.311 +//
1.312 +// Rollback a user transaction and release the lock
1.313 +// All updates must be complete/aborted for a write-lock
1.314 +//
1.315 + {
1.316 + __INVARIANT;
1.317 + __ASSERT_ALWAYS( InTransaction( aObject ), Panic( EDbNoCurrentTransaction ) );
1.318 + if ( iLockCount > 1 )
1.319 + {
1.320 + TLock* lock = GetLock( aObject );
1.321 + __ASSERT( lock );
1.322 + __ASSERT_ALWAYS( lock->iState == static_cast<TUint>( ETransactionLock ), Panic( EDbStreamsPendingOnRollback ) );
1.323 + Unlock( *lock );
1.324 + }
1.325 + else
1.326 + {
1.327 + __ASSERT_ALWAYS( iAction == EDbReadLock, Panic( EDbUpdatesPendingOnRollback ) );
1.328 + DoRollback();
1.329 + }
1.330 + }
1.331 +
1.332 +void RDbTransaction::PrepareSLockL( const CDbObject& aObject, TUint aInitState )
1.333 +//
1.334 +// prepare to acquire a shared read lock
1.335 +// if any holder has an exclusive lock this fails
1.336 +//
1.337 + {
1.338 + __ASSERT( GetLock( aObject ) == 0 ); // cannot get a 2nd shared lock
1.339 +//
1.340 + THolder h = aObject.Context();
1.341 + if ( iLockCount == 0 )
1.342 + {
1.343 + iPrimary.iHolder = h; // first lock, no other checks required
1.344 + iPrimary.iState = aInitState;
1.345 + }
1.346 + else if ( iLockState != EDbReadLock )
1.347 + __LEAVE( KErrLocked );
1.348 + else
1.349 + { // allocate a Sharers-slot
1.350 + TLock* share = iSharers;
1.351 + if ( iLockCount == iMaxLock )
1.352 + {
1.353 + TInt newsize = iMaxLock + ELockListGranularity;
1.354 + if ( newsize > EMaxLock )
1.355 + {
1.356 + __LEAVE( KErrLocked );
1.357 + return;
1.358 + }
1.359 + iSharers = share = ( TLock* )User::ReAllocL( share, ( newsize - 1 ) * sizeof( TLock ) );
1.360 + iMaxLock = TUint8( newsize );
1.361 + }
1.362 + share += iLockCount - 1;
1.363 + share->iHolder = h;
1.364 + share->iState = aInitState;
1.365 + }
1.366 + }
1.367 +
1.368 +void RDbTransaction::PrepareXLockL( const CDbObject& aObject )
1.369 +//
1.370 +// prepare to acquire an exclusive lock
1.371 +// if any other holder has a lock this fails
1.372 +//
1.373 + {
1.374 + THolder h = aObject.Context();
1.375 + switch ( iLockCount )
1.376 + {
1.377 + case 0: // no other holders, acquire the lock
1.378 + iPrimary.iHolder = h;
1.379 + iPrimary.iState = 0; // this is not a transaction lock
1.380 + break;
1.381 + case 1: // check we are the single Lock holder
1.382 + if (iPrimary.iHolder != h)
1.383 + __LEAVE( KErrLocked );
1.384 + break;
1.385 + default: // cannot get XLock
1.386 + __LEAVE( KErrLocked );
1.387 + break;
1.388 + }
1.389 + }
1.390 +
1.391 +void RDbTransaction::Unlock( RDbNotifier::TEvent aEvent )
1.392 +//
1.393 +// Remove the last lock and signal an event to the Notifier
1.394 +//
1.395 + {
1.396 + __ASSERT( iLockCount == 1 );
1.397 + __ASSERT( ( iPrimary.iState & ~ETransactionLock ) == 0 );
1.398 + TDbLockType ls = LockState();
1.399 + Event( ls == EDbReadLock || ls == EDbXReadLock ? RDbNotifier::EUnlock : aEvent );
1.400 + iLockCount = 0;
1.401 + iAction = iLockState = EDbReadLock;
1.402 + iUpdaters = 0;
1.403 + Database().CheckIdle();
1.404 + }
1.405 +
1.406 +void RDbTransaction::Unlock( RDbTransaction::TLock& aLock )
1.407 +//
1.408 +// Remove a shared lock holder from the list
1.409 +//
1.410 + {
1.411 + __ASSERT( iLockCount > 1 );
1.412 + __ASSERT( LockState() == EDbReadLock );
1.413 + __ASSERT( ( aLock.iState & ~ETransactionLock ) == 0 );
1.414 + aLock = iSharers[--iLockCount - 1];
1.415 + }
1.416 +
1.417 +RDbTransaction::TLock* RDbTransaction::GetLock( const CDbObject& aObject )
1.418 +//
1.419 +// Test if aObject holds any lock, and return it
1.420 +//
1.421 + {
1.422 + const THolder h = aObject.Context();
1.423 + TInt lc = iLockCount;
1.424 + if ( --lc >= 0 )
1.425 + {
1.426 + if ( iPrimary.iHolder == h )
1.427 + return &iPrimary;
1.428 + if ( lc > 0 )
1.429 + {
1.430 + TLock* const base = iSharers;
1.431 + TLock* l = base + lc;
1.432 + do {
1.433 + if ( ( --l )->iHolder == h )
1.434 + return l;
1.435 + } while ( l > base );
1.436 + }
1.437 + }
1.438 + return 0;
1.439 + }
1.440 +
1.441 +TBool RDbTransaction::InTransaction( const CDbObject& aObject )
1.442 +//
1.443 +// Test if aObject holds a non-auto transaction
1.444 +//
1.445 + {
1.446 + __INVARIANT;
1.447 + TLock* lock = GetLock( aObject );
1.448 + return lock ? lock->iState & static_cast<TUint>( ETransactionLock ) : 0;
1.449 + }
1.450 +
1.451 +void RDbTransaction::ReadPrepareL( const CDbObject& aObject )
1.452 +//
1.453 +// Check that aObject can gain a shared read lock and allocate required resources
1.454 +//
1.455 + {
1.456 + __INVARIANT_L;
1.457 + if ( GetLock( aObject ) == 0 )
1.458 + PrepareSLockL( aObject, 0 ); // prepare a S-Lock for the read
1.459 + else if ( iAction == EDbCompactLock ) // Cannot already hold a compaction lock
1.460 + __LEAVE( KErrAccessDenied );
1.461 + }
1.462 +
1.463 +void RDbTransaction::ReadBegin( const CDbObject& aObject )
1.464 +//
1.465 +// Take a read-lock: ReadPrepareL(aObject) _must_ already have been called
1.466 +//
1.467 + {
1.468 + __INVARIANT;
1.469 + TLock* lock = GetLock( aObject );
1.470 + if ( !lock )
1.471 + {
1.472 + ++iLockCount;
1.473 + lock = GetLock( aObject );
1.474 + __ASSERT( lock );
1.475 + }
1.476 + ++lock->iState;
1.477 + }
1.478 +
1.479 +void RDbTransaction::ReadRelease( const CDbObject& aObject )
1.480 + {
1.481 + __INVARIANT;
1.482 + TLock* lock = GetLock( aObject );
1.483 + __ASSERT( lock );
1.484 + __ASSERT( ( lock->iState & ~ETransactionLock ) > 0 );
1.485 + if ( --lock->iState == 0 )
1.486 + { // not transaction-lock
1.487 + if ( iLockCount > 1 )
1.488 + Unlock( *lock );
1.489 + else if ( iAction == EDbReadLock ) // no other locks to this client
1.490 + Unlock( RDbNotifier::EUnlock );
1.491 + }
1.492 + }
1.493 +
1.494 +void RDbTransaction::DMLCheckL()
1.495 +//
1.496 +// Check that we can open a new rowset
1.497 +//
1.498 + {
1.499 + __INVARIANT_L;
1.500 + ReadyL();
1.501 + if ( iAction > EDbCompactLock )
1.502 + __LEAVE( KErrAccessDenied );
1.503 + }
1.504 +
1.505 +void RDbTransaction::DMLPrepareL( const CDbObject& aObject )
1.506 +//
1.507 +// Check that we can do DML, this should be called immediately prior to DMLBegin
1.508 +//
1.509 + {
1.510 + __INVARIANT_L;
1.511 + PrepareXLockL( aObject );
1.512 + if ( iAction>EDbWriteLock )
1.513 + __LEAVE( KErrAccessDenied );
1.514 + }
1.515 +
1.516 +void RDbTransaction::DMLBegin()
1.517 +//
1.518 +// A Rowset begins an update
1.519 +//
1.520 + {
1.521 + __INVARIANT;
1.522 + __ASSERT( iAction == EDbReadLock || iAction == EDbWriteLock );
1.523 + __ASSERT( ( iLockState & EFailed ) == 0 );
1.524 + __ASSERT( iLockCount <= 1 );
1.525 + if ( iAction == EDbReadLock )
1.526 + iAction = EDbWriteLock;
1.527 + if (iLockState == EDbReadLock )
1.528 + iLockState = EDbXReadLock; // escalate lock to exclusive as we are now writing
1.529 + ++iUpdaters;
1.530 + iLockCount = 1;
1.531 + }
1.532 +
1.533 +void RDbTransaction::DMLTouch()
1.534 +//
1.535 +// This must be called prior to putting DML updates
1.536 +//
1.537 + {
1.538 + __ASSERT( iAction == EDbWriteLock );
1.539 + __ASSERT( iUpdaters > 0 );
1.540 + TInt ls = iLockState;
1.541 + if ( ls == EDbXReadLock )
1.542 + ls = EDbWriteLock | EFailed;
1.543 + else
1.544 + ls |= EFailed;
1.545 + iLockState = TUint8( ls );
1.546 + }
1.547 +
1.548 +void RDbTransaction::DMLBeginLC()
1.549 + {
1.550 + DMLBegin();
1.551 + CleanupStack::PushL( TCleanupItem( DMLAbandon, this ) );
1.552 + DMLTouch();
1.553 + }
1.554 +
1.555 +void RDbTransaction::DMLCommitL()
1.556 +//
1.557 +// A rowset has completed an update
1.558 +//
1.559 + {
1.560 + __INVARIANT_L;
1.561 + __ASSERT( iAction == EDbWriteLock && ( iLockState & EFailed ) );
1.562 + TInt updaters = iUpdaters - 1;
1.563 + if ( updaters == 0 )
1.564 + {
1.565 + if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
1.566 + {
1.567 + __ASSERT( iLockState == ( EDbWriteLock | EFailed ) );
1.568 + DoCommitL(); // automatic write-commit, release auto-lock
1.569 + return;
1.570 + }
1.571 + iAction = EDbReadLock;
1.572 + }
1.573 + iUpdaters = updaters;
1.574 + iLockState &= ~EFailed;
1.575 + }
1.576 +
1.577 +void RDbTransaction::DMLRollback()
1.578 +//
1.579 +// Rollback a DML operation
1.580 +//
1.581 + {
1.582 + __INVARIANT;
1.583 + __ASSERT( iAction == EDbWriteLock );
1.584 + TInt updates = iUpdaters - 1;
1.585 + if ( updates == 0 )
1.586 + {
1.587 + if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
1.588 + {
1.589 + __ASSERT( LockState() == EDbWriteLock || LockState() == EDbXReadLock );
1.590 + DoRollback(); // automatic rollback now (may panic)
1.591 + return;
1.592 + }
1.593 + iAction = EDbReadLock;
1.594 + }
1.595 + iUpdaters = updates;
1.596 + }
1.597 +
1.598 +void RDbTransaction::DMLAbandon( TAny* aPtr )
1.599 + {
1.600 + STATIC_CAST( RDbTransaction*, aPtr )->DMLRollback();
1.601 + }
1.602 +
1.603 +void RDbTransaction::DDLPrepareL( const CDbObject& aObject )
1.604 +//
1.605 +// Check that we can use the database for ddl and flush out any tables
1.606 +// should be called before DDLBegin
1.607 +//
1.608 + {
1.609 + __INVARIANT_L;
1.610 + ReadyL();
1.611 + PrepareXLockL( aObject );
1.612 + if ( iAction != EDbReadLock || ( IsLocked() && iPrimary.iState != static_cast<TUint>( ETransactionLock ) ) )
1.613 + __LEAVE( KErrAccessDenied ); // Cannot take sole ownership of the database
1.614 + TInt ls = iLockState;
1.615 + if ( ls >= EDbWriteLock )
1.616 + { // ensure all table data is flushed as they may be "released"
1.617 + iLockState = TUint8( ls | EFailed );
1.618 + Database().FlushL( EDbWriteLock );
1.619 + iLockState = TUint8( ls );
1.620 + }
1.621 + }
1.622 +
1.623 +void RDbTransaction::DDLBegin()
1.624 +//
1.625 +// A DDL object is about to start ops
1.626 +//
1.627 + {
1.628 + __INVARIANT;
1.629 + __ASSERT( iAction == EDbReadLock );
1.630 + __ASSERT( ( iLockState & EFailed ) == 0 );
1.631 + __ASSERT( iLockCount <= 1 );
1.632 + iLockState = iAction = EDbSchemaLock;
1.633 + iLockCount = 1;
1.634 + }
1.635 +
1.636 +void RDbTransaction::DDLBeginLC()
1.637 + {
1.638 + DDLBegin();
1.639 + CleanupStack::PushL( TCleanupItem( DDLAbandon, this ) );
1.640 + }
1.641 +
1.642 +void RDbTransaction::DDLCommitL()
1.643 +//
1.644 +// A DDL incremental object has completed
1.645 +//
1.646 + {
1.647 + __INVARIANT_L;
1.648 + __ASSERT( iAction == EDbSchemaLock );
1.649 + if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
1.650 + {
1.651 + __ASSERT( iLockState == EDbSchemaLock );
1.652 + DoCommitL(); // release auto-lock
1.653 + }
1.654 + else
1.655 + iAction = EDbReadLock;
1.656 + }
1.657 +
1.658 +void RDbTransaction::DDLRollback()
1.659 +//
1.660 +// Rollback a DDL operation
1.661 +//
1.662 + {
1.663 + __INVARIANT;
1.664 + __ASSERT( iAction == EDbSchemaLock );
1.665 + iLockState |= EFailed;
1.666 + if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
1.667 + {
1.668 + __ASSERT( iLockState == ( EDbSchemaLock | EFailed ) );
1.669 + DoRollback(); // release auto-lock
1.670 + }
1.671 + else
1.672 + iAction = EDbReadLock;
1.673 + }
1.674 +
1.675 +void RDbTransaction::DDLAbandon( TAny* aPtr )
1.676 + {
1.677 + STATIC_CAST( RDbTransaction*, aPtr )->DDLRollback();
1.678 + }
1.679 +
1.680 +// recovery. Nothing else can be done at the same time as this
1.681 +
1.682 +void RDbTransaction::UtilityPrepareL( const CDbObject& aObject )
1.683 +//
1.684 +// Check that we are in a state to run a utility
1.685 +//
1.686 + {
1.687 + __INVARIANT_L;
1.688 + ReadyL();
1.689 + PrepareXLockL( aObject );
1.690 + if ( IsLocked() ) // utilities not allowed in user transaction
1.691 + __LEAVE( KErrAccessDenied );
1.692 + }
1.693 +
1.694 +void RDbTransaction::UtilityBegin( CDbDatabase::TUtility aType )
1.695 +//
1.696 +// Database Recovery object is about to start
1.697 +//
1.698 + {
1.699 + __INVARIANT;
1.700 + __ASSERT( !IsLocked() );
1.701 + if ( aType == CDbDatabase::ERecover )
1.702 + iLockState = iAction = EDbRecoveryLock;
1.703 + else
1.704 + iLockState = iAction = EDbCompactLock;
1.705 + iLockCount = 1;
1.706 + }
1.707 +
1.708 +void RDbTransaction::UtilityCommitL()
1.709 +//
1.710 +// Database Recovery has completed
1.711 +//
1.712 + {
1.713 + __INVARIANT_L;
1.714 + Database().SynchL( LockState() );
1.715 + Unlock( iAction == EDbRecoveryLock ? RDbNotifier::ERecover : RDbNotifier::EUnlock ); // release auto-lock
1.716 + }
1.717 +
1.718 +void RDbTransaction::UtilityRollback()
1.719 + {
1.720 + __INVARIANT;
1.721 + Database().Revert( LockState() );
1.722 + Unlock( RDbNotifier::EUnlock ); // release auto-lock
1.723 + }
1.724 +
1.725 +CDbNotifier* RDbTransaction::NotifierL()
1.726 +//
1.727 +// Only support a single notifier for the database (server multiplexes)
1.728 +//
1.729 + {
1.730 + if ( iNotifier )
1.731 + __LEAVE( KErrNotSupported );
1.732 + return iNotifier = new( ELeave ) CNotifier( *this );
1.733 + }
1.734 +
1.735 +void RDbTransaction::Event( RDbNotifier::TEvent aEvent )
1.736 +//
1.737 +// Report an event to the Notifier
1.738 +// If the lock was less than a write lock, report unlock only: no commit or rollback
1.739 +//
1.740 + {
1.741 +// if ( iNotifier )
1.742 +// iNotifier->Event( aEvent );
1.743 + }
1.744 +
1.745 +